sys/src/libc/9sys/convS2M.c

   1 #include        <u.h>
   2 #include        <libc.h>
   3 #include        <fcall.h>
   4
   5 static
   6 uchar*
   7 pstring(uchar *p, char *s)
   8 {
   9         uint n;
  10
  11         if(s == nil){
  12                 PBIT16(p, 0);
  13                 p += BIT16SZ;
  14                 return p;
  15         }
  16
  17         n = strlen(s);
  18         /*
  19          * We are moving the string before the length,
  20          * so you can S2M a struct into an existing message
  21          */
  22         memmove(p + BIT16SZ, s, n);
  23         PBIT16(p, n);
  24         p += n + BIT16SZ;
  25         return p;
  26 }
  27
  28 static
  29 uchar*
  30 pqid(uchar *p, Qid *q)
  31 {
  32         PBIT8(p, q->type);
  33         p += BIT8SZ;
  34         PBIT32(p, q->vers);
  35         p += BIT32SZ;
  36         PBIT64(p, q->path);
  37         p += BIT64SZ;
  38         return p;
  39 }
  40
  41 static
  42 uint
  43 stringsz(char *s)
  44 {
  45         if(s == nil)
  46                 return BIT16SZ;
  47
  48         return BIT16SZ+strlen(s);
  49 }
  50
  51 uint
  52 sizeS2M(Fcall *f)
  53 {
  54         uint n;
  55         int i;
  56
  57         n = 0;
  58         n += BIT32SZ;   /* size */
  59         n += BIT8SZ;    /* type */
  60         n += BIT16SZ;   /* tag */
  61
  62         switch(f->type)
  63         {
  64         default:
  65                 return 0;
  66
  67         case Tversion:
  68                 n += BIT32SZ;
  69                 n += stringsz(f->version);
  70                 break;
  71
  72         case Tflush:
  73                 n += BIT16SZ;
  74                 break;
  75
  76         case Tauth:
  77                 n += BIT32SZ;
  78                 n += stringsz(f->uname);
  79                 n += stringsz(f->aname);
  80                 break;
  81
  82         case Tattach:
  83                 n += BIT32SZ;
  84                 n += BIT32SZ;
  85                 n += stringsz(f->uname);
  86                 n += stringsz(f->aname);
  87                 break;
  88
  89         case Twalk:
  90                 n += BIT32SZ;
  91                 n += BIT32SZ;
  92                 n += BIT16SZ;
  93                 for(i=0; i<f->nwname; i++)
  94                         n += stringsz(f->wname[i]);
  95                 break;
  96
  97         case Topen:
  98                 n += BIT32SZ;
  99                 n += BIT8SZ;
 100                 break;
 101
 102         case Tcreate:
 103                 n += BIT32SZ;
 104                 n += stringsz(f->name);
 105                 n += BIT32SZ;
 106                 n += BIT8SZ;
 107                 break;
 108
 109         case Tread:
 110                 n += BIT32SZ;
 111                 n += BIT64SZ;
 112                 n += BIT32SZ;
 113                 break;
 114
 115         case Twrite:
 116                 n += BIT32SZ;
 117                 n += BIT64SZ;
 118                 n += BIT32SZ;
 119                 n += f->count;
 120                 break;
 121
 122         case Tclunk:
 123         case Tremove:
 124                 n += BIT32SZ;
 125                 break;
 126
 127         case Tstat:
 128                 n += BIT32SZ;
 129                 break;
 130
 131         case Twstat:
 132                 n += BIT32SZ;
 133                 n += BIT16SZ;
 134                 n += f->nstat;
 135                 break;
 136 /*
 137  */
 138
 139         case Rversion:
 140                 n += BIT32SZ;
 141                 n += stringsz(f->version);
 142                 break;
 143
 144         case Rerror:
 145                 n += stringsz(f->ename);
 146                 break;
 147
 148         case Rflush:
 149                 break;
 150
 151         case Rauth:
 152                 n += QIDSZ;
 153                 break;
 154
 155         case Rattach:
 156                 n += QIDSZ;
 157                 break;
 158
 159         case Rwalk:
 160                 n += BIT16SZ;
 161                 n += f->nwqid*QIDSZ;
 162                 break;
 163
 164         case Ropen:
 165         case Rcreate:
 166                 n += QIDSZ;
 167                 n += BIT32SZ;
 168                 break;
 169
 170         case Rread:
 171                 n += BIT32SZ;
 172                 n += f->count;
 173                 break;
 174
 175         case Rwrite:
 176                 n += BIT32SZ;
 177                 break;
 178
 179         case Rclunk:
 180                 break;
 181
 182         case Rremove:
 183                 break;
 184
 185         case Rstat:
 186                 n += BIT16SZ;
 187                 n += f->nstat;
 188                 break;
 189
 190         case Rwstat:
 191                 break;
 192         }
 193         return n;
 194 }
 195
 196 uint
 197 convS2M(Fcall *f, uchar *ap, uint nap)
 198 {
 199         uchar *p;
 200         uint i, size;
 201
 202         size = sizeS2M(f);
 203         if(size == 0)
 204                 return 0;
 205         if(size > nap)
 206                 return 0;
 207
 208         p = (uchar*)ap;
 209
 210         PBIT32(p, size);
 211         p += BIT32SZ;
 212         PBIT8(p, f->type);
 213         p += BIT8SZ;
 214         PBIT16(p, f->tag);
 215         p += BIT16SZ;
 216
 217         switch(f->type)
 218         {
 219         default:
 220                 return 0;
 221
 222         case Tversion:
 223                 PBIT32(p, f->msize);
 224                 p += BIT32SZ;
 225                 p = pstring(p, f->version);
 226                 break;
 227
 228         case Tflush:
 229                 PBIT16(p, f->oldtag);
 230                 p += BIT16SZ;
 231                 break;
 232
 233         case Tauth:
 234                 PBIT32(p, f->afid);
 235                 p += BIT32SZ;
 236                 p  = pstring(p, f->uname);
 237                 p  = pstring(p, f->aname);
 238                 break;
 239
 240         case Tattach:
 241                 PBIT32(p, f->fid);
 242                 p += BIT32SZ;
 243                 PBIT32(p, f->afid);
 244                 p += BIT32SZ;
 245                 p  = pstring(p, f->uname);
 246                 p  = pstring(p, f->aname);
 247                 break;
 248
 249         case Twalk:
 250                 PBIT32(p, f->fid);
 251                 p += BIT32SZ;
 252                 PBIT32(p, f->newfid);
 253                 p += BIT32SZ;
 254                 PBIT16(p, f->nwname);
 255                 p += BIT16SZ;
 256                 if(f->nwname > MAXWELEM)
 257                         return 0;
 258                 for(i=0; i<f->nwname; i++)
 259                         p = pstring(p, f->wname[i]);
 260                 break;
 261
 262         case Topen:
 263                 PBIT32(p, f->fid);
 264                 p += BIT32SZ;
 265                 PBIT8(p, f->mode);
 266                 p += BIT8SZ;
 267                 break;
 268
 269         case Tcreate:
 270                 PBIT32(p, f->fid);
 271                 p += BIT32SZ;
 272                 p = pstring(p, f->name);
 273                 PBIT32(p, f->perm);
 274                 p += BIT32SZ;
 275                 PBIT8(p, f->mode);
 276                 p += BIT8SZ;
 277                 break;
 278
 279         case Tread:
 280                 PBIT32(p, f->fid);
 281                 p += BIT32SZ;
 282                 PBIT64(p, f->offset);
 283                 p += BIT64SZ;
 284                 PBIT32(p, f->count);
 285                 p += BIT32SZ;
 286                 break;
 287
 288         case Twrite:
 289                 PBIT32(p, f->fid);
 290                 p += BIT32SZ;
 291                 PBIT64(p, f->offset);
 292                 p += BIT64SZ;
 293                 PBIT32(p, f->count);
 294                 p += BIT32SZ;
 295                 memmove(p, f->data, f->count);
 296                 p += f->count;
 297                 break;
 298
 299         case Tclunk:
 300         case Tremove:
 301                 PBIT32(p, f->fid);
 302                 p += BIT32SZ;
 303                 break;
 304
 305         case Tstat:
 306                 PBIT32(p, f->fid);
 307                 p += BIT32SZ;
 308                 break;
 309
 310         case Twstat:
 311                 PBIT32(p, f->fid);
 312                 p += BIT32SZ;
 313                 PBIT16(p, f->nstat);
 314                 p += BIT16SZ;
 315                 memmove(p, f->stat, f->nstat);
 316                 p += f->nstat;
 317                 break;
 318 /*
 319  */
 320
 321         case Rversion:
 322                 PBIT32(p, f->msize);
 323                 p += BIT32SZ;
 324                 p = pstring(p, f->version);
 325                 break;
 326
 327         case Rerror:
 328                 p = pstring(p, f->ename);
 329                 break;
 330
 331         case Rflush:
 332                 break;
 333
 334         case Rauth:
 335                 p = pqid(p, &f->aqid);
 336                 break;
 337
 338         case Rattach:
 339                 p = pqid(p, &f->qid);
 340                 break;
 341
 342         case Rwalk:
 343                 PBIT16(p, f->nwqid);
 344                 p += BIT16SZ;
 345                 if(f->nwqid > MAXWELEM)
 346                         return 0;
 347                 for(i=0; i<f->nwqid; i++)
 348                         p = pqid(p, &f->wqid[i]);
 349                 break;
 350
 351         case Ropen:
 352         case Rcreate:
 353                 p = pqid(p, &f->qid);
 354                 PBIT32(p, f->iounit);
 355                 p += BIT32SZ;
 356                 break;
 357
 358         case Rread:
 359                 PBIT32(p, f->count);
 360                 p += BIT32SZ;
 361                 memmove(p, f->data, f->count);
 362                 p += f->count;
 363                 break;
 364
 365         case Rwrite:
 366                 PBIT32(p, f->count);
 367                 p += BIT32SZ;
 368                 break;
 369
 370         case Rclunk:
 371                 break;
 372
 373         case Rremove:
 374                 break;
 375
 376         case Rstat:
 377                 PBIT16(p, f->nstat);
 378                 p += BIT16SZ;
 379                 memmove(p, f->stat, f->nstat);
 380                 p += f->nstat;
 381                 break;
 382
 383         case Rwstat:
 384                 break;
 385         }
 386         if(size != p-ap)
 387                 return 0;
 388         return size;
 389 }