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