ref: 63f9a4fda36f916e543c8f3ea117b31c194a4db7
dir: /sys/src/cmd/ratfs/misc.c/
#include "ratfs.h"
#include <ip.h>
enum {
Maxdoms = 10, /* max domains in a path */
Timeout = 2*60*60, /* seconds until temporarily trusted addr times out */
};
static int accountmatch(char*, char**, int, char*);
static Node* acctwalk(char*, Node*);
static int dommatch(char*, char*);
static Address* ipsearch(ulong, Address*, int);
static Node* ipwalk(char*, Node*);
static Node* trwalk(char*, Node*);
static int usermatch(char*, char*);
/*
* Do a walk
*/
char*
walk(char *name, Fid *fidp)
{
Node *np;
if((fidp->node->d.mode & DMDIR) == 0)
return "not a directory";
if(strcmp(name, ".") == 0)
return 0;
if(strcmp(name, "..") == 0){
fidp->node = fidp->node->parent;
fidp->name = 0;
return 0;
}
switch(fidp->node->d.type){
case Directory:
case Addrdir:
np = dirwalk(name, fidp->node);
break;
case Trusted:
np = trwalk(name, fidp->node);
break;
case IPaddr:
np = ipwalk(name, fidp->node);
break;
case Acctaddr:
np = acctwalk(name, fidp->node);
break;
default:
return "directory botch in walk";
}
if(np) {
fidp->node = np;
fidp->name = np->d.name;
return 0;
}
return "file does not exist";
}
/*
* Walk to a subdirectory
*/
Node*
dirwalk(char *name, Node *np)
{
Node *p;
for(p = np->children; p; p = p->sibs)
if(strcmp(name, p->d.name) == 0)
break;
return p;
}
/*
* Walk the directory of trusted files
*/
static Node*
trwalk(char *name, Node *np)
{
Node *p;
ulong peerip;
uchar addr[IPv4addrlen];
v4parseip(addr, name);
peerip = nhgetl(addr);
for(p = np->children; p; p = p->sibs)
if((peerip&p->ip.mask) == p->ip.ipaddr)
break;
return p;
}
/*
* Walk a directory of IP addresses
*/
static Node*
ipwalk(char *name, Node *np)
{
Address *ap;
ulong peerip;
uchar addr[IPv4addrlen];
v4parseip(addr, name);
peerip = nhgetl(addr);
if(debugfd >= 0)
fprint(debugfd, "%d.%d.%d.%d - ", addr[0]&0xff, addr[1]&0xff,
addr[2]&0xff, addr[3]&0xff);
ap = ipsearch(peerip, np->addrs, np->count);
if(ap == 0)
return 0;
dummy.d.name = ap->name;
return &dummy;
}
/*
* Walk a directory of account names
*/
static Node*
acctwalk(char *name, Node *np)
{
int i, n;
Address *ap;
char *p, *cp, *user;
char buf[512];
char *doms[Maxdoms];
strecpy(buf, buf+sizeof buf, name);
subslash(buf);
p = buf;
for(n = 0; n < Maxdoms; n++) {
cp = strchr(p, '!');
if(cp == 0)
break;
*cp = 0;
doms[n] = p;
p = cp+1;
}
user = p;
for(i = 0; i < np->count; i++){
ap = &np->addrs[i];
if (accountmatch(ap->name, doms, n, user)) {
dummy.d.name = ap->name;
return &dummy;
}
}
return 0;
}
/*
* binary search sorted IP address list
*/
static Address*
ipsearch(ulong addr, Address *base, int n)
{
ulong top, bot, mid;
Address *ap;
bot = 0;
top = n;
for (mid = (bot+top)/2; mid < top; mid = (bot+top)/2) {
ap = &base[mid];
if((addr&ap->ip.mask) == ap->ip.ipaddr)
return ap;
if(addr < ap->ip.ipaddr)
top = mid;
else if(mid != n-1 && addr >= base[mid+1].ip.ipaddr)
bot = mid;
else
break;
}
return 0;
}
/*
* Read a directory
*/
int
dread(Fid *fidp, int cnt)
{
uchar *q, *eq, *oq;
int n, skip;
Node *np;
if(debugfd >= 0)
fprint(debugfd, "dread %d\n", cnt);
np = fidp->node;
oq = q = rbuf+IOHDRSZ;
eq = q+cnt;
if(fidp->dirindex >= np->count)
return 0;
skip = fidp->dirindex;
for(np = np->children; skip > 0 && np; np = np->sibs)
skip--;
if(np == 0)
return 0;
for(; q < eq && np; np = np->sibs){
if(debugfd >= 0)
printnode(np);
if((n=convD2M(&np->d, q, eq-q)) <= BIT16SZ)
break;
q += n;
fidp->dirindex++;
}
return q - oq;
}
/*
* Read a directory of IP addresses or account names
*/
int
hread(Fid *fidp, int cnt)
{
uchar *q, *eq, *oq;
int i, n, path;
Address *p;
Node *np;
if(debugfd >= 0)
fprint(debugfd, "hread %d\n", cnt);
np = fidp->node;
oq = q = rbuf+IOHDRSZ;
eq = q+cnt;
if(fidp->dirindex >= np->count)
return 0;
path = np->baseqid;
for(i = fidp->dirindex; q < eq && i < np->count; i++){
p = &np->addrs[i];
dummy.d.name = p->name;
dummy.d.qid.path = path++;
if((n=convD2M(&dummy.d, q, eq-q)) <= BIT16SZ)
break;
q += n;
}
fidp->dirindex = i;
return q - oq;
}
/*
* Find a directory node by type
*/
Node*
finddir(int type)
{
Node *np;
for(np = root->children; np; np = np->sibs)
if (np->d.type == type)
return np;
return 0;
}
/*
* Remove temporary pseudo-files that have timed-out
* from the trusted directory
*/
void
cleantrusted(void)
{
Node *np, **l;
ulong t;
np = finddir(Trusted);
if (np == 0)
return;
t = time(0)-Timeout;
l = &np->children;
for (np = np->children; np; np = *l) {
if(np->d.type == Trustedtemp && t >= np->d.mtime) {
*l = np->sibs;
if(debugfd >= 0)
fprint(debugfd, "Deleting %s\n", np->d.name);
np->parent->count--;
free(np);
} else
l = &np->sibs;
}
}
/*
* match path components to prohibited domain & user specifications. patterns include:
* domain, domain! or domain!* - all users in domain
* *.domain, *.domain! or *.domain!* - all users in domain and its subdomains
* !user or *!user - user in all domains
* domain!user - user in domain
* *.domain!user - user in domain and its subdomains
*
* if "user" has a trailing '*', it matches all user names beginning with "user"
*
* there are special semantics for the "domain, domain! or domain!*" specifications:
* the first two forms match when the domain is anywhere in at list of source-routed
* domains while the latter matches only when the domain is the last hop. the same is
* true for the *.domain!* form of the pattern.
*/
static int
accountmatch(char *spec, char **doms, int ndoms, char *user)
{
char *cp, *userp;
int i, ret;
userp = 0;
ret = 0;
cp = strchr(spec, '!');
if(cp){
*cp++ = 0; /* restored below */
if(*cp)
if(strcmp(cp, "*")) /* "!*" is the same as no user field */
userp = cp; /* there is a user name */
}
if(userp == 0){ /* no user field - domain match only */
for(i = 0; i < ndoms && doms[i]; i++)
if(dommatch(doms[i], spec) == 0)
ret = 1;
} else {
/* check for "!user", "*!user" or "domain!user" */
if(usermatch(user, userp) == 0){
if(*spec == 0 || strcmp(spec, "*") == 0)
ret = 1;
else if(ndoms > 0 && dommatch(doms[ndoms-1], spec) == 0)
ret = 1;
}
}
if(cp)
cp[-1] = '!';
return ret;
}
/*
* match a user name. the only meta-char is '*' which matches all
* characters. we only allow it as "*", which matches anything or
* an * at the end of the name (e.g., "username*") which matches
* trailing characters.
*/
static int
usermatch(char *pathuser, char *specuser)
{
int n;
n = strlen(specuser)-1;
if(specuser[n] == '*'){
if(n == 0) /* match everything */
return 0;
return strncmp(pathuser, specuser, n);
}
return strcmp(pathuser, specuser);
}
/*
* Match a domain specification
*/
static int
dommatch(char *pathdom, char *specdom)
{
int n;
if (*specdom == '*'){
if (specdom[1] == '.' && specdom[2]){
specdom += 2;
n = strlen(pathdom)-strlen(specdom);
if(n == 0 || (n > 0 && pathdom[n-1] == '.'))
return strcmp(pathdom+n, specdom);
return n;
}
}
return strcmp(pathdom, specdom);
}
/*
* Custom allocators to avoid malloc overheads on small objects.
* We never free these. (See below.)
*/
typedef struct Stringtab Stringtab;
struct Stringtab {
Stringtab *link;
char *str;
};
static Stringtab*
taballoc(void)
{
static Stringtab *t;
static uint nt;
if(nt == 0){
t = malloc(64*sizeof(Stringtab));
if(t == 0)
fatal("out of memory");
nt = 64;
}
nt--;
return t++;
}
static char*
xstrdup(char *s)
{
char *r;
int len;
static char *t;
static int nt;
len = strlen(s)+1;
if(len >= 8192)
fatal("strdup big string");
if(nt < len){
t = malloc(8192);
if(t == 0)
fatal("out of memory");
nt = 8192;
}
r = t;
t += len;
nt -= len;
strcpy(r, s);
return r;
}
/*
* Return a uniquely allocated copy of a string.
* Don't free these -- they stay in the table for the
* next caller who wants that particular string.
* String comparison can be done with pointer comparison
* if you know both strings are atoms.
*/
static Stringtab *stab[1024];
static uint
hash(char *s)
{
uint h;
uchar *p;
h = 0;
for(p=(uchar*)s; *p; p++)
h = h*37 + *p;
return h;
}
char*
atom(char *str)
{
uint h;
Stringtab *tab;
h = hash(str) % nelem(stab);
for(tab=stab[h]; tab; tab=tab->link)
if(strcmp(str, tab->str) == 0)
return tab->str;
tab = taballoc();
tab->str = xstrdup(str);
tab->link = stab[h];
stab[h] = tab;
return tab->str;
}