funfs/funfs.cc

   1 #include "funfs.h"
   2 #include "funfscodecs.h"
   3
   4 // Only used for cachefs message type translation
   5 #include "cachefs.h"
   6
   7 #include <wvtcp.h>
   8 #include <wvistreamlist.h>
   9
  10
  11 #define BUFREAD(x) \
  12         memcpy(&x, xinbuf.get(sizeof(x)), sizeof(x));   \
  13         if (sizeof(x) == 2)                             \
  14             SWAP16(&x);                                 \
  15         if (sizeof(x) == 4)                             \
  16             SWAP32(&x);                                 \
  17         if (sizeof(x) == 8)                             \
  18             SWAP64(&x)
  19
  20
  21 #define CHECKERROR()                                    \
  22     {                                                   \
  23         uint16 errcode;                                 \
  24         BUFREAD(errcode);                               \
  25         if (errcode)                                    \
  26             { RETURN(-errcode); }                       \
  27     }
  28
  29
  30 #define MAYBECHECKERROR()                               \
  31     {                                                   \
  32         if (xinbuf.used() == sizeof(uint16))            \
  33             { CHECKERROR(); }                           \
  34     }
  35
  36
  37 #define RETURN(x)                           \
  38     if (!reply_ready)                       \
  39         alarm(0);                           \
  40     return x
  41
  42
  43 #define PUTPATH(x)                          \
  44     xoutbuf.putstr(x);                      \
  45     xoutbuf.putch('\n')
  46
  47
  48 #define CONTINUE_SELECT()                   \
  49     do {                                    \
  50         context->continue_select(-1);       \
  51     } while (!context->alarm_was_ticking)
  52
  53
  54 uint16 FunFS::jobid = 1;
  55
  56
  57 FunFS::FunFS(UniConf _cfg)
  58     : WvStreamClone(NULL), mycloned((WvTCPConn*)cloned),
  59     log("FunFS", WvLog::Info), jobmap(255), cfg(_cfg)
  60 {
  61     ok = true;
  62     reply_ready = false;
  63     uses_continue_select = true;
  64
  65     cloned = new WvTCPConn(cfg["Hostname"].get(), cfg["Port"].getint());
  66     WvIStreamList::globallist.append(this, false);
  67
  68     setcallback(WvStreamCallback(this, &FunFS::line_mode_execute), NULL);
  69
  70     log("FunFS Initialized!\n");
  71 }
  72
  73 FunFS::~FunFS()
  74 {
  75     terminate_continue_select();
  76
  77     log("FunFS Destructor!\n");
  78 }
  79
  80 bool FunFS::isok() const
  81 {
  82     if (ok && cloned && mycloned->isconnected() && !cloned->isok())
  83     {
  84         log(WvLog::Error, "Connection to %s lost!\n", *mycloned->src());
  85         ok = false;
  86     }
  87     else if (ok && cloned && !cloned->isok())
  88     {
  89         log(WvLog::Error, "Connecting to %s: %s\n", *mycloned->src(),
  90                 cloned->errstr());
  91         ok = false;
  92     }
  93     return ok;
  94 }
  95
  96 size_t FunFS::write(WvStream *job, WvBuf &inbuf)
  97 {
  98     if (jobmap.exists(jobid))
  99     {
 100         log(WvLog::Error, "Expiring job #%s\n", (int)jobid);
 101         jobmap.remove(jobid);
 102     }
 103
 104     log("Adding a new job #%s\n", (int)jobid);
 105
 106     jobmap.add(jobid, job);
 107
 108     uint16 temp = jobid;
 109     cloned->write(SWAP16(&temp), sizeof(temp));
 110
 111     if (!++jobid)
 112         jobid++;
 113
 114     //fprintf(stderr, "writing %d bytes\n", inbuf.used());
 115     size_t r = cloned->write(inbuf);
 116     cloned->flush(0);
 117
 118     inbuf.zap();
 119
 120     return r;
 121 }
 122
 123 void FunFS::line_mode_execute(WvStream &, void *)
 124 {
 125     WvString line = getline(2000);
 126
 127     if (!line)
 128     {
 129         log(WvLog::Error, "Connection to %s timed out.\n", *mycloned->src());
 130         ok = false;
 131     }
 132
 133     if (!strstr(line.cstr(), "FunFS"))
 134     {
 135         log(WvLog::Error, "%s is not a FunFS server.\n", *mycloned->src());
 136         ok = false;
 137     }
 138
 139     // Switch to data mode
 140     mycloned->delay_output(true);
 141
 142     setcallback(WvStreamCallback(this, &FunFS::data_mode_execute), NULL);
 143 }
 144
 145 void FunFS::data_mode_execute(WvStream &, void *)
 146 {
 147     if (xinbuf.used())
 148     {
 149         log(WvLog::Error, "Oh-oh! Somebody was slacking on reads!\n");
 150         xinbuf.zap();
 151     }
 152
 153     uint16 replyid = 0;
 154     READ(replyid);
 155
 156     uint32 clength = 0;
 157     READ(clength);
 158
 159     log("FunFS::execute: replyid = %s, clength = %s\n", replyid, clength);
 160
 161     size_t r = continue_read(-1, xinbuf, clength);
 162     assert(r == clength);
 163
 164     if (replyid)
 165         got_reply(replyid);
 166     else
 167         got_message();
 168 }
 169
 170 void FunFS::got_reply(uint16 replyid)
 171 {
 172     if (jobmap.exists(replyid))
 173     {
 174         // Wake up the guy who's reply this is
 175         jobmap[replyid]->alarm(0);
 176
 177         do {
 178             continue_select(-1);
 179         } while (!alarm_was_ticking);
 180
 181         jobmap.remove(replyid);
 182     }
 183     else
 184         log(WvLog::Error, "Unknown jobid %s!\n", (int)replyid);
 185 }
 186
 187 void FunFS::got_message()
 188 {
 189     reply_ready = true;
 190     int jobtype = xinbuf.getch();
 191     WvString path = xinbuf.getstr(xinbuf.strchr('\0'));
 192
 193     log(WvLog::Debug3, "<BOB> got a message of type [%s], path = '%s'!\n",
 194             jobtype, path);
 195
 196     switch (jobtype)
 197     {
 198         case JT_GETATTR:
 199             messagecb(MT_GETATTR, path);
 200             break;
 201
 202         case JT_READLINK:
 203             messagecb(MT_READLINK, path);
 204             break;
 205
 206         default:
 207             log(WvLog::Error, "<BOB> unknown message type\n");
 208     }
 209
 210     if (xinbuf.used())
 211     {
 212         log(WvLog::Warning, "<BOB> Discarding %s bytes.\n", xinbuf.used());
 213         xinbuf.zap();
 214     }
 215
 216     reply_ready = false;
 217 }
 218
 219 /******************************************************************/
 220
 221 int FunFS::fs_getattr(CONTEXT, PATH, struct fuse_attr *attr)
 222 {
 223     if (!reply_ready)
 224     {
 225         xoutbuf.putch(JT_GETATTR);
 226         PUTPATH(path);
 227
 228         write(context, xoutbuf);
 229
 230         CONTINUE_SELECT();
 231         MAYBECHECKERROR();
 232     }
 233
 234     decode_fuse_attr(xinbuf, attr);
 235
 236     RETURN(0);
 237 }
 238
 239 int FunFS::fs_getdir(CONTEXT, PATH, WvFuseDirCb &cb)
 240 {
 241     xoutbuf.putch(JT_GETDIR);
 242     PUTPATH(path);
 243
 244     write(context, xoutbuf);
 245
 246     CONTINUE_SELECT();
 247
 248     MAYBECHECKERROR();
 249
 250     fuse_dirent fde;
 251
 252     while (xinbuf.used())
 253     {
 254         decode_fuse_dirent(xinbuf, &fde);
 255         cb(&fde);
 256     }
 257
 258     RETURN(0);
 259 }
 260
 261 int FunFS::fs_open(CONTEXT, PATH, int flags)
 262 {
 263     xoutbuf.putch(JT_OPEN);
 264     PUTPATH(path);
 265     xoutbuf.put(SWAP32(&flags), 4);
 266
 267     write(context, xoutbuf);
 268
 269     CONTINUE_SELECT();
 270     MAYBECHECKERROR();
 271
 272     int fd;
 273     BUFREAD(fd);
 274
 275     RETURN(fd);
 276 }
 277
 278 int FunFS::fs_release(CONTEXT, FD)
 279 {
 280     // FIXME: this should not even wait for a responce
 281     xoutbuf.putch(JT_RELEASE);
 282
 283     xoutbuf.put(SWAP32(&fd), 4);
 284
 285     write(context, xoutbuf);
 286
 287     CONTINUE_SELECT();
 288
 289     RETURN(0);
 290 }
 291
 292 int FunFS::fs_read(CONTEXT, FD, char *chbuf, size_t size, off_t offset)
 293 {
 294     xoutbuf.putch(JT_READ);
 295
 296     xoutbuf.put(SWAP32(&fd), 4);
 297     xoutbuf.put(SWAP32(&size), 4);
 298     xoutbuf.put(SWAP32(&offset), 4);
 299
 300     write(context, xoutbuf);
 301
 302     CONTINUE_SELECT();
 303
 304     size_t r = xinbuf.used();
 305     memcpy(chbuf, xinbuf.get(r), r);
 306
 307     RETURN(r);
 308 }
 309
 310 int FunFS::fs_readlink(CONTEXT, PATH, char *chbuf, size_t size)
 311 {
 312     if (!reply_ready)
 313     {
 314         xoutbuf.putch(JT_READLINK);
 315         PUTPATH(path);
 316
 317         write(context, xoutbuf);
 318         CONTINUE_SELECT();
 319     }
 320
 321     CHECKERROR();
 322
 323     strncpy(chbuf, xinbuf.getstr(), size);
 324
 325     RETURN(0);
 326 }
 327
 328 int FunFS::fs_statfs(CONTEXT, struct fuse_kstatfs *fst)
 329 {
 330     log(WvLog::Debug4, "fs_statfs called\n");
 331
 332     xoutbuf.putch(JT_STATFS);
 333
 334     write(context, xoutbuf);
 335
 336     CONTINUE_SELECT();
 337     MAYBECHECKERROR();
 338
 339     decode_fuse_kstatfs(xinbuf, fst);
 340
 341     RETURN(0);
 342 }
 343
 344 int FunFS::fs_symlink(CONTEXT, PATH, WvStringParm to)
 345 {
 346     // TODO
 347     log(WvLog::Error, "fs_symlink not implemented!\n");
 348
 349     /*
 350     int res = symlink(path, to);
 351     if(res == -1)
 352         return -errno;
 353     */
 354
 355     return -ENOSYS;
 356 }
 357
 358 int FunFS::fs_truncate(CONTEXT, FD, off_t size)
 359 {
 360     // TODO
 361     log(WvLog::Error, "fs_truncate not implemented!\n");
 362
 363     /*
 364     int res = truncate(path, size);
 365     if(res == -1)
 366         return -errno;
 367     */
 368
 369     return -ENOSYS;
 370 }
 371
 372 int FunFS::fs_unlink(CONTEXT, PATH)
 373 {
 374     // TODO
 375     log(WvLog::Error, "fs_unlink not implemented!\n");
 376
 377     /*
 378     int res = unlink(path);
 379     if(res == -1)
 380         return -errno;
 381     */
 382
 383     return -ENOSYS;
 384 }
 385
 386 int FunFS::fs_utime(CONTEXT, PATH, struct utimbuf *utbuf)
 387 {
 388     /*
 389     WvDynBuf buf;
 390     buf.putch(JT_READLINK);
 391     buf.put(path, path.len() + 1);
 392
 393     write(context, buf);
 394
 395     CONTINUE_SELECT();
 396
 397     uint32 actime = 0, modtime = 0;
 398
 399     READ(actime);
 400     READ(modtime);
 401
 402     if (utbuf)
 403     {
 404         utbuf->actime = actime;
 405         utbuf->modtime = modtime;
 406     }
 407     else
 408     {
 409         // TODO
 410         fprintf(stderr, "Updating utime not implemented yet.\n");
 411     }
 412     */
 413
 414     return -ENOSYS;
 415 }
 416
 417 int FunFS::fs_write(CONTEXT, FD, const char *buf,
 418         size_t size, off_t offset)
 419 {
 420     // TODO
 421     log(WvLog::Error, "fs_write not implemented!\n");
 422
 423     /*
 424     int fd;
 425     int res;
 426
 427     fd = open(path, O_WRONLY);
 428     if(fd == -1)
 429         return -errno;
 430
 431     res = pwrite(fd, buf, size, offset);
 432     if(res == -1)
 433         res = -errno;
 434
 435     ::close(fd);
 436
 437     return res;
 438     */
 439
 440     return -ENOSYS;
 441 }
 442
 443 int FunFS::fs_chmod(CONTEXT, PATH, mode_t mode)
 444 {
 445     // TODO
 446     log(WvLog::Error, "fs_chmod not implemented!\n");
 447
 448     /*
 449     int res;
 450
 451     res = chmod(path, mode);
 452     if(res == -1)
 453         return -errno;
 454     */
 455
 456     return -ENOSYS;
 457 }
 458
 459 int FunFS::fs_chown(CONTEXT, PATH, uid_t uid, gid_t gid)
 460 {
 461     // TODO
 462     log(WvLog::Error, "fs_chown not implemented!\n");
 463
 464     /*
 465     int res;
 466
 467     res = lchown(path, uid, gid);
 468     if(res == -1)
 469         return -errno;
 470     */
 471
 472     return -ENOSYS;
 473 }
 474
 475 int FunFS::fs_rename(CONTEXT, PATH, WvStringParm to)
 476 {
 477     // TODO
 478     log(WvLog::Error, "fs_rename not implemented!\n");
 479
 480     /*
 481     int res = rename(path, to);
 482
 483     if(res == -1)
 484         return -errno;
 485     */
 486
 487     return -ENOSYS;
 488 }
 489
 490 int FunFS::fs_mkdir(CONTEXT, PATH, mode_t mode)
 491 {
 492     // TODO
 493     log(WvLog::Error, "fs_mkdir not implemented!\n");
 494
 495     /*
 496     int res;
 497
 498     res = mkdir(path, mode);
 499     if(res == -1)
 500         return -errno;
 501     */
 502
 503     return -ENOSYS;
 504 }
 505
 506 int FunFS::fs_mknod(CONTEXT, PATH, mode_t mode, dev_t rdev)
 507 {
 508     // TODO
 509     log(WvLog::Error, "fs_mknod not implemented!\n");
 510
 511     /*
 512     int res = mknod(path, mode, rdev);
 513     if(res == -1)
 514         return -errno;
 515     */
 516
 517     return -ENOSYS;
 518 }
 519
 520 int FunFS::fs_link(CONTEXT, PATH, WvStringParm to)
 521 {
 522     /*
 523     WvDynBuf buf;
 524     buf.putch(JT_LINK);
 525     buf.put(path, path.len() + 1);
 526     buf.put(to, to.len() + 1);
 527
 528     write(context, buf);
 529
 530     CONTINUE_SELECT();
 531     CHECKERROR();
 532
 533     //READCLENGTH("link");
 534
 535     // For now we should always get an error.
 536     assert(0);
 537     return 0;
 538     */
 539
 540     return -ENOSYS;
 541 }
 542
 543 int FunFS::fs_rmdir(CONTEXT, PATH)
 544 {
 545     // TODO
 546     log(WvLog::Error, "fs_rmdir not implemented!\n");
 547
 548     /*
 549     int res = rmdir(path);
 550     if(res == -1)
 551         return -errno;
 552     */
 553
 554     return -ENOSYS;
 555 }
 556