Subversion Repositories planix.SVN

#pragma src "/sys/src/lib9p"
#pragma lib "lib9p.a"

/*
 * Maps from ulongs to void*s.
 */
typedef struct Intmap   Intmap;

#pragma incomplete Intmap

Intmap* allocmap(void (*inc)(void*));
void            freemap(Intmap*, void (*destroy)(void*));
void*   lookupkey(Intmap*, ulong);
void*   insertkey(Intmap*, ulong, void*);
int             caninsertkey(Intmap*, ulong, void*);
void*   deletekey(Intmap*, ulong);

/*
 * Fid and Request structures.
 */
typedef struct Fid              Fid;
typedef struct Req              Req;
typedef struct Fidpool  Fidpool;
typedef struct Reqpool  Reqpool;
typedef struct File             File;
typedef struct Filelist Filelist;
typedef struct Tree             Tree;
typedef struct Readdir  Readdir;
typedef struct Srv Srv;

#pragma incomplete Filelist
#pragma incomplete Readdir

struct Fid
{
        ulong   fid;
        char            omode;  /* -1 = not open */
        File*           file;
        char*   uid;
        Qid             qid;
        void*   aux;

/* below is implementation-specific; don't use */
        Readdir*        rdir;
        Ref             ref;
        Fidpool*        pool;
        vlong   diroffset;
        long            dirindex;
};

struct Req
{
        ulong   tag;
        void*   aux;
        Fcall           ifcall;
        Fcall           ofcall;
        Dir             d;
        Req*            oldreq;
        Fid*            fid;
        Fid*            afid;
        Fid*            newfid;
        Srv*            srv;

/* below is implementation-specific; don't use */
        QLock   lk;
        Ref             ref;
        Reqpool*        pool;
        uchar*  buf;
        uchar   type;
        uchar   responded;
        char*   error;
        void*   rbuf;
        Req**   flush;
        int             nflush;
};

/*
 * Pools to maintain Fid <-> fid and Req <-> tag maps.
 */

struct Fidpool {
        Intmap  *map;
        void            (*destroy)(Fid*);
        Srv             *srv;
};

struct Reqpool {
        Intmap  *map;
        void            (*destroy)(Req*);
        Srv             *srv;
};

Fidpool*        allocfidpool(void (*destroy)(Fid*));
void            freefidpool(Fidpool*);
Fid*            allocfid(Fidpool*, ulong);
Fid*            lookupfid(Fidpool*, ulong);
void            closefid(Fid*);
Fid*            removefid(Fidpool*, ulong);

Reqpool*        allocreqpool(void (*destroy)(Req*));
void            freereqpool(Reqpool*);
Req*            allocreq(Reqpool*, ulong);
Req*            lookupreq(Reqpool*, ulong);
void            closereq(Req*);
Req*            removereq(Reqpool*, ulong);

typedef int     Dirgen(int, Dir*, void*);
void            dirread9p(Req*, Dirgen*, void*);

/*
 * File trees.
 */
struct File {
        Ref;
        Dir;
        File *parent;
        void *aux;

/* below is implementation-specific; don't use */
        RWLock;
        Filelist *filelist;
        Tree *tree;
        int nchild;
        int allocd;
        int nxchild;
        Ref readers;
};

struct Tree {
        File *root;
        void    (*destroy)(File *file);

/* below is implementation-specific; don't use */
        Lock genlock;
        ulong qidgen;
        ulong dirqidgen;
};

Tree*   alloctree(char*, char*, ulong, void(*destroy)(File*));
void            freetree(Tree*);
File*           createfile(File*, char*, char*, ulong, void*);
int             removefile(File*);
void            closefile(File*);
File*           walkfile(File*, char*);
Readdir*        opendirfile(File*);
long            readdirfile(Readdir*, uchar*, long);
void            closedirfile(Readdir*);

/*
 * Kernel-style command parser
 */
typedef struct Cmdbuf Cmdbuf;
typedef struct Cmdtab Cmdtab;
Cmdbuf*         parsecmd(char *a, int n);
void            respondcmderror(Req*, Cmdbuf*, char*, ...);
Cmdtab* lookupcmd(Cmdbuf*, Cmdtab*, int);
#pragma varargck argpos respondcmderr 3
struct Cmdbuf
{
        char    *buf;
        char    **f;
        int     nf;
};

struct Cmdtab
{
        int     index;  /* used by client to switch on result */
        char    *cmd;   /* command name */
        int     narg;   /* expected #args; 0 ==> variadic */
};

/*
 * File service loop.
 */
struct Srv {
        Tree*   tree;
        void            (*destroyfid)(Fid*);
        void            (*destroyreq)(Req*);
        void            (*end)(Srv*);
        void*   aux;

        void            (*attach)(Req*);
        void            (*auth)(Req*);
        void            (*open)(Req*);
        void            (*create)(Req*);
        void            (*read)(Req*);
        void            (*write)(Req*);
        void            (*remove)(Req*);
        void            (*flush)(Req*);
        void            (*stat)(Req*);
        void            (*wstat)(Req*);
        void            (*walk)(Req*);
        char*   (*clone)(Fid*, Fid*);
        char*   (*walk1)(Fid*, char*, Qid*);

        int             infd;
        int             outfd;
        int             nopipe;
        int             srvfd;
        int             leavefdsopen;   /* magic for acme win */
        char*   keyspec;

/* below is implementation-specific; don't use */
        Fidpool*        fpool;
        Reqpool*        rpool;
        uint            msize;

        uchar*  rbuf;
        QLock   rlock;
        uchar*  wbuf;
        QLock   wlock;
        
        char*   addr;
};

void            srv(Srv*);
void            postmountsrv(Srv*, char*, char*, int);
void            _postmountsrv(Srv*, char*, char*, int);
void            listensrv(Srv*, char*);
void            _listensrv(Srv*, char*);
int             postfd(char*, int);
int             chatty9p;
void            respond(Req*, char*);
void            responderror(Req*);
void            threadpostmountsrv(Srv*, char*, char*, int);
void            threadlistensrv(Srv *s, char *addr);

/*
 * Helper.  Assumes user is same as group.
 */
int             hasperm(File*, char*, int);

void*   emalloc9p(ulong);
void*   erealloc9p(void*, ulong);
char*   estrdup9p(char*);

enum {
        OMASK = 3
};

void            readstr(Req*, char*);
void            readbuf(Req*, void*, long);
void            walkandclone(Req*, char*(*walk1)(Fid*,char*,void*), 
                        char*(*clone)(Fid*,Fid*,void*), void*);

void            auth9p(Req*);
void            authread(Req*);
void            authwrite(Req*);
void            authdestroy(Fid*);
int             authattach(Req*);

extern void (*_forker)(void (*)(void*), void*, int);