9base

revived minimalist port of Plan 9 userland to Unix
git clone git://git.suckless.org/9base
Log | Files | Refs | README | LICENSE

convS2M.c (5756B)

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