Subversion Repositories planix.SVN

ushort smbnhgets(uchar *);

ulong smbnhgetl(uchar *);

vlong smbnhgetv(uchar *);

void smbhnputs(uchar *, ushort);

void smbhnputl(uchar *, ulong);

void smbhnputv(uchar *, vlong);

SMBPROCESSFN smbnegotiate;

SMBPROCESSFN smbcomsessionsetupandx;

SMBPROCESSFN smbcomtreeconnectandx;

SMBPROCESSFN smbcomtransaction;

SMBPROCESSFN smbcomcheckdirectory;

SMBPROCESSFN smbcomtransaction2;

SMBPROCESSFN smbcomecho;

SMBPROCESSFN smbcomopenandx;

SMBPROCESSFN smbcomcreate;

SMBPROCESSFN smbcomopen;

SMBPROCESSFN smbcomclose;

SMBPROCESSFN smbcomreadandx;

SMBPROCESSFN smbcomwriteandx;

SMBPROCESSFN smbcomqueryinformation;

SMBPROCESSFN smbcomfindclose2;

SMBPROCESSFN smbcomtreedisconnect;

SMBPROCESSFN smbcomqueryinformation2;

SMBPROCESSFN smbcomdelete;

SMBPROCESSFN smbcomflush;

SMBPROCESSFN smbcomwrite;

SMBPROCESSFN smbcomsetinformation2;

SMBPROCESSFN smbcomcreatedirectory;

SMBPROCESSFN smbcomdeletedirectory;

SMBPROCESSFN smbcomrename;

SMBPROCESSFN smbcomlockingandx;

SMBPROCESSFN smbcomsetinformation;

SMBPROCESSFN smbcomntcreateandx;

void *smbemalloc(ulong size);

void *smbemallocz(ulong size, int clear);

void smberealloc(void **pp, ulong size);

char *smbestrdup(char *s);

void smbfree(void **pp);

int smbcheckwordcount(char *name, SmbHeader *h, ushort wordcount);

int smbcheckwordandbytecount(char *name, SmbHeader *h, ushort wordcount, uchar **bdatap, uchar **edatap);

int smbsendunicode(SmbPeerInfo *i);

char *smbstringdup(SmbHeader *h, uchar *base, uchar **bdatap, uchar *edata);

char *smbstrdup(uchar **bdatap, uchar *edata);

char *smbstrinline(uchar **bdatap, uchar *edata);

int smbstrlen(char *string);

int smbstringlen(SmbPeerInfo *i, char *string);

void smbstringprint(char **p, char *fmt, ...);

int smbucs2len(char *string);

int smbstringput(SmbPeerInfo *p, ulong flags, uchar *buf, ushort n, ushort maxlen, char *string);

int smbstrput(ulong flags, uchar *buf, ushort n, ushort maxlen, char *string);

int smbstrnput(uchar *buf, ushort n, ushort maxlen, char *string, ushort size, int upcase);

int smbucs2put(ulong flags, uchar *buf, ushort n, ushort maxlen, char *string);

void smbresponseinit(SmbSession *s, ushort maxlen);

int smbresponsealignl2(SmbSession *s, int l2a);

ushort smbresponseoffset(SmbSession *s);

int smbresponseputheader(SmbSession *s, SmbHeader *h, uchar errclass, ushort error);

int smbresponseputandxheader(SmbSession *s, SmbHeader *h, ushort andxcommand, ulong *andxoffsetfixup);

int smbresponseputb(SmbSession *s, uchar b);

int smbresponseputs(SmbSession *s, ushort s);

int smbresponseputl(SmbSession *s, ulong l);

int smbresponseoffsetputs(SmbSession *s, ushort offset, ushort s);

int smbresponseputstring(SmbSession *s, int mustalign, char *string);

int smbresponseputstr(SmbSession *s, char *string);

SmbProcessResult smbresponsesend(SmbSession *s);

int smbresponseputerror(SmbSession *s, SmbHeader *h, uchar errclass, ushort error);

int smbresponseskip(SmbSession *s, ushort amount);

ushort smbresponsespace(SmbSession *s);

void smbresponsereset(SmbSession *s);

int smbresponsecpy(SmbSession *s, uchar *data, ushort datalen);

void smbtreedisconnect(SmbSession *s, SmbTree *t);

void smbtreedisconnectbyid(SmbSession *s, ushort id);

SmbTree *smbtreeconnect(SmbSession *s, SmbService *serv);

int smbchaincommand(SmbSession *s, SmbHeader *h, ulong andxfixupoffset, uchar cmd, ushort offset, SmbBuffer *b);

SmbService *smbservicefind(SmbSession *s, char *path, char *service, uchar *errclassp, ushort *errorp);

void smbserviceput(SmbService *serv);

void smbserviceget(SmbService *serv);

int smbrap2(SmbSession *s);

void smbglobalsguess(int client);

SmbBuffer *smbbuffernew(ulong maxlen);

void smbbufferfree(SmbBuffer **bp);

SmbBuffer *smbbufferinit(void *base, void *bdata, ulong blen);

ulong smbbufferwriteoffset(SmbBuffer *s);

ulong smbbufferwritemaxoffset(SmbBuffer *s);

ulong smbbufferreadoffset(SmbBuffer *s);

void *smbbufferwritepointer(SmbBuffer *s);

void *smbbufferreadpointer(SmbBuffer *s);

int smbbufferputheader(SmbBuffer *s, SmbHeader *h, SmbPeerInfo *p);

int smbbufferputandxheader(SmbBuffer *s, SmbHeader *h, SmbPeerInfo *p, uchar andxcommand, ulong *andxoffsetfixup);

int smbbufferputb(SmbBuffer *s, uchar b);

int smbbufferputs(SmbBuffer *s, ushort s);

int smbbufferputl(SmbBuffer *s, ulong l);

int smbbufferoffsetputs(SmbBuffer *s, ulong offset, ushort s);

int smbbufferputstring(SmbBuffer *b, SmbPeerInfo *p, ulong flags, char *string);

int smbbufferpututstring(SmbBuffer *b, SmbPeerInfo *p, int mustalign, char *string);

int smbbufferputucs2(SmbBuffer *b, int mustalign, char *string);

int smbbufferputstr(SmbBuffer *s, char *string);

int smbbufferputstrn(SmbBuffer *s, char *string, int len, int upcase);

int smbbufferputerror(SmbBuffer *s, SmbHeader *h, SmbPeerInfo *p, uchar errclass, ushort error);

int smbbufferskip(SmbBuffer *s, ulong amount);

ulong smbbufferspace(SmbBuffer *s);

void smbbufferreset(SmbBuffer *s);

int smbbufferputbytes(SmbBuffer *s, void *data, ulong datalen);

int smbbuffergetbytes(SmbBuffer *b, void *buf, ulong len);

void smbbuffersetreadlen(SmbBuffer *b, ulong len);

int smbbuffertrimreadlen(SmbBuffer *b, ulong len);

ulong smbbufferwritespace(SmbBuffer *b);

int smbbuffergets(SmbBuffer *b, ushort *sp);

int smbbuffergetstr(SmbBuffer *b, ulong flags, char **sp);

int smbbuffergetstrinline(SmbBuffer *b, char **sp);

int smbbuffergetstrn(SmbBuffer *b, ushort size, char **sp);

int smbbuffergetstring(SmbBuffer *b, SmbHeader *h, ulong flags, char **sp);

int smbbuffergetucs2(SmbBuffer *b, ulong flags, char **sp);

void *smbbufferpointer(SmbBuffer *b, ulong offset);

int smbbuffergetb(SmbBuffer *b, uchar *bp);

int smbbuffergetl(SmbBuffer *b, ulong *lp);

int smbbuffergetv(SmbBuffer *b, vlong *vp);

ulong smbbufferreadspace(SmbBuffer *b);

void smbbufferwritelimit(SmbBuffer *b, ulong limit);

int smbbufferreadskipto(SmbBuffer *b, ulong offset);

int smbbufferpushreadlimit(SmbBuffer *b, ulong offset);

int smbbufferpopreadlimit(SmbBuffer *b);

int smbbufferalignl2(SmbBuffer *b, int al2);

int smbbufferwritebackup(SmbBuffer *b, ulong offset);

int smbbufferreadbackup(SmbBuffer *b, ulong offset);

int smbbufferfixuprelatives(SmbBuffer *b, ulong fixupoffset);

int smbbufferfixuprelativel(SmbBuffer *b, ulong fixupoffset);

int smbbufferfixuprelativeinclusivel(SmbBuffer *b, ulong fixupoffset);

int smbbufferfixupabsolutes(SmbBuffer *b, ulong fixupoffset);

int smbbufferfixupabsolutel(SmbBuffer *b, ulong fixupoffset);

int smbbufferfixupl(SmbBuffer *b, ulong fixupoffset, ulong val);

int smbbufferputv(SmbBuffer *b, vlong v);

int smbbufferputack(SmbBuffer *b, SmbHeader *h, SmbPeerInfo *p);

int smbbufferfill(SmbBuffer *b, uchar c, ulong len);

int smbbufferoffsetgetb(SmbBuffer *b, ulong offset, uchar *bp);

int smbbuffercopy(SmbBuffer *to, SmbBuffer *from, ulong amount);

int smbbufferoffsetcopystr(SmbBuffer *b, ulong offset, char *buf, int buflen, int *lenp);

SmbClient *smbconnect(char *to, char *share, char **errmsgp);

void smbclientfree(SmbClient *s);

int smbsuccess(SmbHeader *h, char **errmsgp);

int smbtransactiondecodeprimary(SmbTransaction *t, SmbHeader *h, uchar *pdata, SmbBuffer *b, char **errmsgp);

int smbtransactiondecodeprimary2(SmbTransaction *t, SmbHeader *h, uchar *pdata, SmbBuffer *b, char **errmsgp);

void smbtransactionfree(SmbTransaction *t);

int smbtransactionencoderesponse(SmbTransaction *t, SmbHeader *h, SmbPeerInfo *p, SmbBuffer *ob, char **errmsgp);

int smbtransactionencoderesponse2(SmbTransaction *t, SmbHeader *h, SmbPeerInfo *p, SmbBuffer *ob, char **errmsgp);

int smbtransactionencodeprimary(SmbTransaction *t, SmbHeader *h, SmbPeerInfo *p, SmbBuffer *ob,

	uchar *wordcountp, ushort *bytecountp, char **errmsgp);

int smbtransactionencodeprimary2(SmbTransaction *t, SmbHeader *h, SmbPeerInfo *p, SmbBuffer *ob,

	uchar *wordcountp, ushort *bytecountp, char **errmsgp);

int smbtransactiondecoderesponse(SmbTransaction *t, SmbHeader *h, uchar *pdata, SmbBuffer *b, char **errmsgp);

int smbtransactiondecoderesponse2(SmbTransaction *t, SmbHeader *h, uchar *pdata, SmbBuffer *b, char **errmsgp);

int smbtransactionclientsend(void *magic, SmbBuffer *ob, char **errmsgp);

int smbtransactionclientreceive(void *magic, SmbBuffer *ib, char **errmsgp);

int smbtransactionexecute(SmbTransaction *t, SmbHeader *h, SmbPeerInfo *p,

	SmbBuffer *ob, SmbTransactionMethod *method, void *magic, SmbHeader *rh, char **errmsgp);

int smbtransactionrespond(SmbTransaction *t, SmbHeader *h, SmbPeerInfo *p, SmbBuffer *ob,

	SmbTransactionMethod *method, void *magic, char **errmsgp);

SmbProcessResult smbtrans2findfirst2(SmbSession *s, SmbHeader *h);

SmbProcessResult smbtrans2findnext2(SmbSession *s, SmbHeader *h);

SmbProcessResult smbtrans2queryfileinformation(SmbSession *s, SmbHeader *h);

SmbProcessResult smbtrans2queryfsinformation(SmbSession *s, SmbHeader *h);

SmbProcessResult smbtrans2querypathinformation(SmbSession *s, SmbHeader *h);

SmbProcessResult smbtrans2setfileinformation(SmbSession *s, SmbHeader *h);

SmbProcessResult smbtrans2setpathinformation(SmbSession *s, SmbHeader *h);

SmbIdMap *smbidmapnew(void);

long smbidmapadd(SmbIdMap *m, void *p);

void smbidmapremovebyid(SmbIdMap *m, long id);

void smbidmapremove(SmbIdMap *m, void *thing);

void smbidmapfree(SmbIdMap **mp, SMBIDMAPAPPLYFN *free, void *magic);

void smbidmapapply(SmbIdMap *mp, SMBIDMAPAPPLYFN *free, void *magic);

void *smbidmapfind(SmbIdMap *m, long id);

void smbidmapremoveif(SmbIdMap *m, int (*f)(void *p, void *arg), void *arg);

void smbsearchfree(SmbSearch **searchp);

void smbsearchclose(SmbSession *s, SmbSearch *search);

void smbsearchclosebyid(SmbSession *s, ushort sid);

void smbseterror(SmbSession *s, uchar errclass, ushort error);

void smbplan9time2datetime(ulong time, int tzoff, ushort *datep, ushort *timep);

ulong smbdatetime2plan9time(ushort date, ushort time, int tzoff);

vlong smbplan9time2time(ulong time);

ulong smbplan9time2utime(ulong time, int tzoff);

ulong smbutime2plan9time(ulong time, int tzoff);

ulong smbtime2plan9time(vlong);

void smbpathcanon(char *path);

void smbpathsplit(char *path, char **dirp, char **namep);

ushort smbplan9mode2dosattr(ulong mode);

ulong smbdosattr2plan9wstatmode(ulong oldmode, ushort attr);

ulong smbdosattr2plan9mode(ushort attr);

ulong smbplan9length2size32(vlong size);

void smbfileclose(SmbSession *s, SmbFile *f);

void smbloglock(void);

void smblogunlock(void);

int smblogvprint(int cmd, char *fmt, va_list ap);

int translogprint(int cmd, char *fmt, ...);

int smblogprint(int cmd, char *fmt, ...);

int smblogprintif(int v, char *fmt, ...);

void smblogdata(int cmd, int (*print)(int cmd, char *fmt, ...), void *p, long data, long limit);

SmbSharedFile *smbsharedfileget(Dir *d, int p9mode, int *sharep);

void smbsharedfileput(SmbFile *f, SmbSharedFile *sf, int share);

int smbsharedfilelock(SmbSharedFile *sf, SmbSession *s, ushort pid, vlong base, vlong limit);

int smbsharedfileunlock(SmbSharedFile *sf, SmbSession *s, ushort pid, vlong base, vlong limit);

vlong smbl2roundupvlong(vlong v, int l2);

int smblistencifs(SMBCIFSACCEPTFN *accept);

int smbnetserverenum2(SmbClient *c, ulong stype, char *domain, int *entriesp, SmbRapServerInfo1 **sip, char **errmsgp);

int smbbuffergetheader(SmbBuffer *b, SmbHeader *h, uchar **parametersp, ushort *bytecountp);

int smbbuffergetandcheckheader(SmbBuffer *b, SmbHeader *h, uchar command, int response,

	uchar **pdatap, ushort *bytecountp, char **errmsgp);

int smbcheckheader(SmbHeader *h, uchar command, int response, char **errmsgp);

int smbcheckheaderdirection(SmbHeader *h, int response, char **errmsgp);

SmbDirCache *smbmkdircache(SmbTree *t, char *path);

void smbdircachefree(SmbDirCache **cp);

int smbmatch(char *name, Reprog *rep);

Reprog *smbmkrep(char *pattern);

int smbclientopen(SmbClient *c, ushort mode, char *name, uchar *errclassp, ushort *errorp, ushort *fid, ushort *attrp,

ulong *mtimep, ulong *sizep, ushort *accessallowedp, char **errmsgp);

Rune smbruneconvert(Rune r, ulong flags);

int smbslut(SmbSlut *table, char *name);

char *smbrevslut(SmbSlut *table, int val);

SmbProcessResult smbtruncatefile(SmbSession *s, SmbFile *f, vlong offset);

#ifdef LEAK

#define smbemallocz(n, z) mallocz(n, z)

#define smbemalloc(n) malloc(n)

#define smbestrdup(p) strcpy(malloc(strlen(p) + 1), p)

#endif

int smbremovefile(SmbTree *t, char *dir, char *name);

int smbbrowsesendhostannouncement(char *name, ulong periodms, ulong type, char *comment, char **errmsgp);