sys/src/libndb/ndbipinfo.c

   1 #include <u.h>
   2 #include <libc.h>
   3 #include <bio.h>
   4 #include <ndb.h>
   5 #include <ip.h>
   6
   7 enum
   8 {
   9         Ffound= 1<<0,
  10         Fignore=1<<1,
  11         Faddr=  1<<2,
  12 };
  13
  14 static Ndbtuple*        filter(Ndb *db, Ndbtuple *t, Ndbtuple *f);
  15 static Ndbtuple*        mkfilter(int argc, char **argv);
  16 static int              filtercomplete(Ndbtuple *f);
  17 static int              prefixlen(uchar *ip);
  18 static Ndbtuple*        subnet(Ndb *db, uchar *net, Ndbtuple *f, int prefix);
  19
  20 /* make a filter to be used in filter */
  21 static Ndbtuple*
  22 mkfilter(int argc, char **argv)
  23 {
  24         Ndbtuple *t, *first, *last;
  25         char *p;
  26
  27         last = first = nil;
  28         while(argc-- > 0){
  29                 t = ndbnew(0, 0);
  30                 if(first)
  31                         last->entry = t;
  32                 else
  33                         first = t;
  34                 last = t;
  35                 p = *argv++;
  36                 if(*p == '@'){                  /* @attr=val ? */
  37                         t->ptr |= Faddr;        /* return resolved address(es) */
  38                         p++;
  39                 }
  40                 strncpy(t->attr, p, sizeof(t->attr)-1);
  41         }
  42         ndbsetmalloctag(first, getcallerpc(&argc));
  43         return first;
  44 }
  45
  46 /* return true if every pair of filter has been used */
  47 static int
  48 filtercomplete(Ndbtuple *f)
  49 {
  50         for(; f; f = f->entry)
  51                 if((f->ptr & Fignore) == 0)
  52                         return 0;
  53         return 1;
  54 }
  55
  56 /* set the attribute of all entries in a tuple */
  57 static Ndbtuple*
  58 setattr(Ndbtuple *t, char *attr)
  59 {
  60         Ndbtuple *nt;
  61
  62         for(nt = t; nt; nt = nt->entry)
  63                 strcpy(nt->attr, attr);
  64         return t;
  65 }
  66
  67 /*
  68  *  return only the attr/value pairs in t maching the filter, f.
  69  *  others are freed.  line structure is preserved.
  70  */
  71 static Ndbtuple*
  72 filter(Ndb *db, Ndbtuple *t, Ndbtuple *f)
  73 {
  74         Ndbtuple *nt, *nf, *next;
  75
  76         /* filter out what we don't want */
  77         for(nt = t; nt; nt = next){
  78                 next = nt->entry;
  79
  80                 /* look through filter */
  81                 for(nf = f; nf != nil; nf = nf->entry){
  82                         if(!(nf->ptr&Fignore) && strcmp(nt->attr, nf->attr) == 0)
  83                                 break;
  84                 }
  85                 if(nf == nil){
  86                         /* remove nt from t */
  87                         t = ndbdiscard(t, nt);
  88                 } else {
  89                         if(nf->ptr & Faddr)
  90                                 t = ndbsubstitute(t, nt, setattr(ndbgetipaddr(db, nt->val), nt->attr));
  91                         nf->ptr |= Ffound;
  92                 }
  93         }
  94
  95         /* remember filter etnries that matched */
  96         for(nf = f; nf != nil; nf = nf->entry)
  97                 if(nf->ptr & Ffound)
  98                         nf->ptr = (nf->ptr & ~Ffound) | Fignore;
  99
 100         ndbsetmalloctag(t, getcallerpc(&db));
 101         return t;
 102 }
 103
 104 static int
 105 prefixlen(uchar *ip)
 106 {
 107         int y, i;
 108
 109         for(y = IPaddrlen-1; y >= 0; y--)
 110                 for(i = 8; i > 0; i--)
 111                         if(ip[y] & (1<<(8-i)))
 112                                 return y*8 + i;
 113         return 0;
 114 }
 115
 116 /*
 117  *  look through containing subsets
 118  */
 119 static Ndbtuple*
 120 subnet(Ndb *db, uchar *net, Ndbtuple *f, int prefix)
 121 {
 122         Ndbs s;
 123         int nprefix;
 124         char netstr[64];
 125         uchar mask[IPaddrlen];
 126         Ndbtuple *at[128+1], *nt, *xt, *t;
 127
 128         memset(at, 0, sizeof(at));
 129         snprint(netstr, sizeof(netstr), "%I", net);
 130         nt = ndbsearch(db, &s, "ip", netstr);
 131         while(nt != nil){
 132                 xt = ndbfindattr(nt, nt, "ipnet");
 133                 if(xt != nil){
 134                         xt = ndbfindattr(nt, nt, "ipmask");
 135                         if(xt == nil || parseipmask(mask, xt->val, isv4(net)) == -1)
 136                                 ipmove(mask, defmask(net));
 137                         nprefix = prefixlen(mask);
 138                         if(nprefix <= prefix && at[nprefix] == nil){
 139                                 /* remember containing subnet, order by prefix length */
 140                                 at[nprefix] = nt;
 141                                 nt = nil;
 142                         }
 143                 }
 144                 ndbfree(nt);
 145                 nt = ndbsnext(&s, "ip", netstr);
 146         }
 147         /* filter subnets, longest prefix first */
 148         for(t = nil; prefix >= 0; prefix--){
 149                 if(at[prefix] != nil)
 150                         t = ndbconcatenate(t, filter(db, at[prefix], f));
 151         }
 152         ndbsetmalloctag(t, getcallerpc(&db));
 153         return t;
 154 }
 155
 156 static Ndbtuple*
 157 netinfo(Ndb *db, Ndbtuple *t, char **alist, int n)
 158 {
 159         uchar ip[IPaddrlen], net[IPaddrlen];
 160         int prefix, smallestprefix, force;
 161         Ndbtuple *f, *nt;
 162
 163         nt = ndbfindattr(t, t, "ip");
 164         if(nt == nil || parseip(ip, nt->val) == -1){
 165                 ndbfree(t);
 166                 return nil;
 167         }
 168
 169         /* get needed attributes */
 170         f = mkfilter(n, alist);
 171
 172         t = filter(db, t, f);
 173
 174         /*
 175          *  now go through subnets to fill in any missing attributes
 176          */
 177         ipmove(net, ip);
 178         if(isv4(ip)){
 179                 prefix = 127;
 180                 smallestprefix = 100;
 181                 force = 0;
 182         } else {
 183                 /* in v6, the last 8 bytes have no structure (we hope) */
 184                 prefix = 64;
 185                 smallestprefix = 2;
 186                 memset(net+8, 0, 8);
 187                 force = 1;
 188         }
 189
 190         /*
 191          *  to find a containing network, keep turning off
 192          *  the lower bit and look for a network with
 193          *  that address and a shorter mask.  tedius but
 194          *  complete, we may need to find a trick to speed this up.
 195          */
 196         for(; prefix >= smallestprefix; prefix--){
 197                 if(filtercomplete(f))
 198                         break;
 199                 if(!force && (net[prefix/8] & (1<<(7-(prefix%8)))) == 0)
 200                         continue;
 201                 force = 0;
 202                 net[prefix/8] &= ~(1<<(7-(prefix%8)));
 203                 t = ndbconcatenate(t, subnet(db, net, f, prefix));
 204         }
 205
 206         /*
 207          *  if there's an unfulfilled ipmask, make one up
 208          */
 209         nt = ndbfindattr(f, f, "ipmask");
 210         if(nt != nil && !(nt->ptr & Fignore)){
 211                 char x[64];
 212
 213                 snprint(x, sizeof(x), "%M", defmask(ip));
 214                 nt = ndbnew("ipmask", x);
 215                 nt->line = nt;
 216                 nt->entry = nil;
 217                 t = ndbconcatenate(t, nt);
 218         }
 219
 220         ndbfree(f);
 221         ndbsetmalloctag(t, getcallerpc(&db));
 222         return t;
 223 }
 224
 225 /*
 226  *  fill in all the requested attributes for a system.
 227  *  if the system's entry doesn't have all required,
 228  *  walk through successively more inclusive networks
 229  *  for inherited attributes.
 230  */
 231 Ndbtuple*
 232 ndbipinfo(Ndb *db, char *attr, char *val, char **alist, int n)
 233 {
 234         Ndbtuple *t, *nt;
 235         char *ipstr;
 236         Ndbs s;
 237
 238         /* just in case */
 239         fmtinstall('I', eipfmt);
 240         fmtinstall('M', eipfmt);
 241
 242         /*
 243          *  first look for a matching entry with an ip address
 244          */
 245         ipstr = ndbgetvalue(db, &s, attr, val, "ip", &nt);
 246         if(ipstr == nil){
 247                 /* none found, make one up */
 248                 if(strcmp(attr, "ip") != 0)
 249                         return nil;
 250                 nt = ndbnew("ip", val);
 251                 nt->line = nt;
 252                 nt->entry = nil;
 253                 t = netinfo(db, nt, alist, n);
 254         } else {
 255                 /* found one */
 256                 free(ipstr);
 257                 t = nil;
 258                 do {
 259                         nt = ndbreorder(nt, s.t);
 260                         t = ndbconcatenate(t, netinfo(db, nt, alist, n));
 261                 } while((nt = ndbsnext(&s, attr, val)) != nil);
 262         }
 263         return ndbdedup(t);
 264 }