Return to conv.c CVS log

Up to [Research Unix] / researchv10no / cmd / u9fs

Annotation of researchv10no/cmd/u9fs/conv.c, revision 1.1

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

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.