sys/src/cmd/unix/u9fs/oldfcall.c

   1 #include <plan9.h>
   2 #include <fcall.h>
   3 #include <oldfcall.h>
   4 #include <stdlib.h>
   5
   6 /*
   7  * routines to package the old protocol in the new structures.
   8  */
   9
  10 #define SHORT(x)        p[0]=f->x; p[1]=f->x>>8; p += 2
  11 #define LONG(x)         p[0]=f->x; p[1]=f->x>>8; p[2]=f->x>>16; p[3]=f->x>>24; p += 4
  12 #define VLONG(x)        p[0]=f->x;      p[1]=f->x>>8;\
  13                         p[2]=f->x>>16;  p[3]=f->x>>24;\
  14                         p[4]=f->x>>32;  p[5]=f->x>>40;\
  15                         p[6]=f->x>>48;  p[7]=f->x>>56;\
  16                         p += 8
  17 #define STRING(x,n)     strecpy((char*)p, (char*)p+n, f->x); p += n;
  18 #define FIXQID(q)               q.path ^= (q.path>>33); q.path &= 0x7FFFFFFF; q.path |= (q.type&0x80)<<24
  19
  20 uint
  21 oldhdrsize(uchar type)
  22 {
  23         switch(type){
  24         default:
  25                 return 0;
  26         case oldTnop:
  27                 return 3;
  28         case oldTflush:
  29                 return 3+2;
  30         case oldTclone:
  31                 return 3+2+2;
  32         case oldTwalk:
  33                 return 3+2+28;
  34         case oldTopen:
  35                 return 3+2+1;
  36         case oldTcreate:
  37                 return 3+2+28+4+1;
  38         case oldTread:
  39                 return 3+2+8+2;
  40         case oldTwrite:
  41                 return 3+2+8+2+1;
  42         case oldTclunk:
  43                 return 3+2;
  44         case oldTremove:
  45                 return 3+2;
  46         case oldTstat:
  47                 return 3+2;
  48         case oldTwstat:
  49                 return 3+2+116;
  50         case oldTsession:
  51                 return 3+8;
  52         case oldTattach:
  53                 return 3+2+28+28+72+13;
  54         }
  55 }
  56
  57 uint
  58 iosize(uchar *p)
  59 {
  60         if(p[0] != oldTwrite)
  61                 return 0;
  62         return p[3+2+8] | (p[3+2+8+1]<<8);
  63 }
  64
  65 uint
  66 sizeS2M(Fcall *f)
  67 {
  68         switch(f->type)
  69         {
  70         default:
  71                 abort();
  72                 return 0;
  73
  74         /* no T messages */
  75
  76 /*
  77  */
  78         case Rversion:
  79                 return 1+2;
  80
  81 /*
  82         case Rsession:
  83                 return 1+2+8+28+48;
  84 */
  85
  86         case Rattach:
  87                 return 1+2+2+4+4+13;
  88
  89         case Rerror:
  90                 return 1+2+64;
  91
  92         case Rflush:
  93                 if(f->tag&0x8000)
  94                         return 1+2+8+28+48;     /* session */
  95                 return 1+2;
  96
  97         /* assumes we don't ever see Tclwalk requests ... */
  98         case Rwalk:
  99                 if(f->nwqid == 0)
 100                         return 1+2+2;
 101                 else
 102                         return 1+2+2+4+4;
 103
 104         case Ropen:
 105                 return 1+2+2+4+4;
 106
 107         case Rcreate:
 108                 return 1+2+2+4+4;
 109
 110         case Rread:
 111                 return 1+2+2+2+1+f->count;
 112
 113         case Rwrite:
 114                 return 1+2+2+2;
 115
 116         case Rclunk:
 117                 return 1+2+2;
 118
 119         case Rremove:
 120                 return 1+2+2;
 121
 122         case Rstat:
 123                 return 1+2+2+116;
 124
 125         case Rwstat:
 126                 return 1+2+2;
 127         }
 128 }
 129
 130 uint
 131 convS2Mold(Fcall *f, uchar *ap, uint nap)
 132 {
 133         uchar *p;
 134
 135         if(nap < sizeS2M(f))
 136                 return 0;
 137
 138         p = ap;
 139         switch(f->type)
 140         {
 141         default:
 142                 abort();
 143                 return 0;
 144
 145         /* no T messages */
 146
 147 /*
 148  */
 149         case Rversion:
 150                 *p++ = oldRnop;
 151                 SHORT(tag);
 152                 break;
 153
 154 /*
 155         case Rsession:
 156                 *p++ = oldRsession;
 157                 SHORT(tag);
 158
 159                 if(f->nchal > 8)
 160                         f->nchal = 8;
 161                 memmove(p, f->chal, f->nchal);
 162                 p += f->nchal;
 163                 if(f->nchal < 8){
 164                         memset(p, 0, 8 - f->nchal);
 165                         p += 8 - f->nchal;
 166                 }
 167
 168                 STRING(authid, 28);
 169                 STRING(authdom, 48);
 170                 break;
 171 */
 172
 173         case Rattach:
 174                 *p++ = oldRattach;
 175                 SHORT(tag);
 176                 SHORT(fid);
 177                 FIXQID(f->qid);
 178                 LONG(qid.path);
 179                 LONG(qid.vers);
 180                 memset(p, 0, 13);
 181                 p += 13;
 182                 break;
 183
 184         case Rerror:
 185                 *p++ = oldRerror;
 186                 SHORT(tag);
 187                 STRING(ename, 64);
 188                 break;
 189
 190         case Rflush:
 191                 if(f->tag&0x8000){
 192                         *p++ = oldRsession;
 193                         f->tag &= ~0x8000;
 194                         SHORT(tag);
 195                         memset(p, 0, 8+28+48);
 196                         p += 8+28+48;
 197                 }else{
 198                         *p++ = oldRflush;
 199                         SHORT(tag);
 200                 }
 201                 break;
 202
 203         /* assumes we don't ever see Tclwalk requests ... */
 204         case Rwalk:
 205                 if(f->nwqid == 0){      /* successful clone */
 206                         *p++ = oldRclone;
 207                         SHORT(tag);
 208                         SHORT(fid);
 209                 }else{                  /* successful 1-element walk */
 210                         *p++ = oldRwalk;
 211                         SHORT(tag);
 212                         SHORT(fid);
 213                         FIXQID(f->wqid[0]);
 214                         LONG(wqid[0].path);
 215                         LONG(wqid[0].vers);
 216                 }
 217                 break;
 218
 219         case Ropen:
 220                 *p++ = oldRopen;
 221                 SHORT(tag);
 222                 SHORT(fid);
 223                 FIXQID(f->qid);
 224                 LONG(qid.path);
 225                 LONG(qid.vers);
 226                 break;
 227
 228         case Rcreate:
 229                 *p++ = oldRcreate;
 230                 SHORT(tag);
 231                 SHORT(fid);
 232                 FIXQID(f->qid);
 233                 LONG(qid.path);
 234                 LONG(qid.vers);
 235                 break;
 236
 237         case Rread:
 238                 *p++ = oldRread;
 239                 SHORT(tag);
 240                 SHORT(fid);
 241                 SHORT(count);
 242                 p++;    /* pad(1) */
 243                 memmove(p, f->data, f->count);
 244                 p += f->count;
 245                 break;
 246
 247         case Rwrite:
 248                 *p++ = oldRwrite;
 249                 SHORT(tag);
 250                 SHORT(fid);
 251                 SHORT(count);
 252                 break;
 253
 254         case Rclunk:
 255                 *p++ = oldRclunk;
 256                 SHORT(tag);
 257                 SHORT(fid);
 258                 break;
 259
 260         case Rremove:
 261                 *p++ = oldRremove;
 262                 SHORT(tag);
 263                 SHORT(fid);
 264                 break;
 265
 266         case Rstat:
 267                 *p++ = oldRstat;
 268                 SHORT(tag);
 269                 SHORT(fid);
 270                 memmove(p, f->stat, 116);
 271                 p += 116;
 272                 break;
 273
 274         case Rwstat:
 275                 *p++ = oldRwstat;
 276                 SHORT(tag);
 277                 SHORT(fid);
 278                 break;
 279         }
 280         return p - ap;
 281 }
 282
 283 uint
 284 sizeD2Mold(Dir *d)
 285 {
 286         return 116;
 287 }
 288
 289 uint
 290 convD2Mold(Dir *f, uchar *ap, uint nap)
 291 {
 292         uchar *p;
 293
 294         if(nap < 116)
 295                 return 0;
 296
 297         p = ap;
 298         STRING(name, 28);
 299         STRING(uid, 28);
 300         STRING(gid, 28);
 301         FIXQID(f->qid);
 302         LONG(qid.path);
 303         LONG(qid.vers);
 304         LONG(mode);
 305         LONG(atime);
 306         LONG(mtime);
 307         VLONG(length);
 308         SHORT(type);
 309         SHORT(dev);
 310
 311         return p - ap;
 312 }
 313
 314 #undef SHORT
 315 #undef LONG
 316 #undef VLONG
 317 #undef STRING
 318 #define CHAR(x) f->x = *p++
 319 #define SHORT(x)        f->x = (p[0] | (p[1]<<8)); p += 2
 320 #define LONG(x)         f->x = (p[0] | (p[1]<<8) |\
 321                                 (p[2]<<16) | (p[3]<<24)); p += 4
 322 #define VLONG(x)        f->x = (ulong)(p[0] | (p[1]<<8) |\
 323                                         (p[2]<<16) | (p[3]<<24)) |\
 324                                 ((vlong)(p[4] | (p[5]<<8) |\
 325                                         (p[6]<<16) | (p[7]<<24)) << 32); p += 8
 326 #define STRING(x,n)     f->x = (char*)p; p += n
 327
 328 uint
 329 convM2Sold(uchar *ap, uint nap, Fcall *f)
 330 {
 331         uchar *p, *q, *ep;
 332
 333         p = ap;
 334         ep = p + nap;
 335
 336         if(p+3 > ep)
 337                 return 0;
 338
 339         switch(*p++){
 340         case oldTnop:
 341                 f->type = Tversion;
 342                 SHORT(tag);
 343                 f->msize = 0;
 344                 f->version = "9P1";
 345                 break;
 346
 347         case oldTflush:
 348                 f->type = Tflush;
 349                 SHORT(tag);
 350                 if(p+2 > ep)
 351                         return 0;
 352                 SHORT(oldtag);
 353                 break;
 354
 355         case oldTclone:
 356                 f->type = Twalk;
 357                 SHORT(tag);
 358                 if(p+2+2 > ep)
 359                         return 0;
 360                 SHORT(fid);
 361                 SHORT(newfid);
 362                 f->nwname = 0;
 363                 break;
 364
 365         case oldTwalk:
 366                 f->type = Twalk;
 367                 SHORT(tag);
 368                 if(p+2+28 > ep)
 369                         return 0;
 370                 SHORT(fid);
 371                 f->newfid = f->fid;
 372                 f->nwname = 1;
 373                 f->wname[0] = (char*)p;
 374                 p += 28;
 375                 break;
 376
 377         case oldTopen:
 378                 f->type = Topen;
 379                 SHORT(tag);
 380                 if(p+2+1 > ep)
 381                         return 0;
 382                 SHORT(fid);
 383                 CHAR(mode);
 384                 break;
 385
 386         case oldTcreate:
 387                 f->type = Tcreate;
 388                 SHORT(tag);
 389                 if(p+2+28+4+1 > ep)
 390                         return 0;
 391                 SHORT(fid);
 392                 f->name = (char*)p;
 393                 p += 28;
 394                 LONG(perm);
 395                 CHAR(mode);
 396                 break;
 397
 398         case oldTread:
 399                 f->type = Tread;
 400                 SHORT(tag);
 401                 if(p+2+8+2 > ep)
 402                         return 0;
 403                 SHORT(fid);
 404                 VLONG(offset);
 405                 SHORT(count);
 406                 break;
 407
 408         case oldTwrite:
 409                 f->type = Twrite;
 410                 SHORT(tag);
 411                 if(p+2+8+2+1 > ep)
 412                         return 0;
 413                 SHORT(fid);
 414                 VLONG(offset);
 415                 SHORT(count);
 416                 p++;    /* pad(1) */
 417                 if(p+f->count > ep)
 418                         return 0;
 419                 f->data = (char*)p;
 420                 p += f->count;
 421                 break;
 422
 423         case oldTclunk:
 424                 f->type = Tclunk;
 425                 SHORT(tag);
 426                 if(p+2 > ep)
 427                         return 0;
 428                 SHORT(fid);
 429                 break;
 430
 431         case oldTremove:
 432                 f->type = Tremove;
 433                 SHORT(tag);
 434                 if(p+2 > ep)
 435                         return 0;
 436                 SHORT(fid);
 437                 break;
 438
 439         case oldTstat:
 440                 f->type = Tstat;
 441                 f->nstat = 116;
 442                 SHORT(tag);
 443                 if(p+2 > ep)
 444                         return 0;
 445                 SHORT(fid);
 446                 break;
 447
 448         case oldTwstat:
 449                 f->type = Twstat;
 450                 SHORT(tag);
 451                 if(p+2+116 > ep)
 452                         return 0;
 453                 SHORT(fid);
 454                 f->stat = p;
 455                 q = p+28*3+5*4;
 456                 memset(q, 0xFF, 8);     /* clear length to ``don't care'' */
 457                 p += 116;
 458                 break;
 459
 460 /*
 461         case oldTsession:
 462                 f->type = Tsession;
 463                 SHORT(tag);
 464                 if(p+8 > ep)
 465                         return 0;
 466                 f->chal = p;
 467                 p += 8;
 468                 f->nchal = 8;
 469                 break;
 470 */
 471         case oldTsession:
 472                 f->type = Tflush;
 473                 SHORT(tag);
 474                 f->tag |= 0x8000;
 475                 f->oldtag = f->tag;
 476                 p += 8;
 477                 break;
 478
 479         case oldTattach:
 480                 f->type = Tattach;
 481                 SHORT(tag);
 482                 if(p+2+28+28+72+13 > ep)
 483                         return 0;
 484                 SHORT(fid);
 485                 STRING(uname, 28);
 486                 STRING(aname, 28);
 487                 p += 72+13;
 488                 f->afid = NOFID;
 489                 break;
 490
 491         default:
 492                 return 0;
 493         }
 494
 495         return p-ap;
 496 }
 497
 498 uint
 499 convM2Dold(uchar *ap, uint nap, Dir *f, char *strs)
 500 {
 501         uchar *p;
 502
 503         USED(strs);
 504
 505         if(nap < 116)
 506                 return 0;
 507
 508         p = (uchar*)ap;
 509         STRING(name, 28);
 510         STRING(uid, 28);
 511         STRING(gid, 28);
 512         LONG(qid.path);
 513         LONG(qid.vers);
 514         LONG(mode);
 515         LONG(atime);
 516         LONG(mtime);
 517         VLONG(length);
 518         SHORT(type);
 519         SHORT(dev);
 520         f->qid.type = (f->mode>>24)&0xF0;
 521         return p - (uchar*)ap;
 522 }