src/lib/valuepair.c

   1 /*
   2  * valuepair.c  Functions to handle VALUE_PAIRs
   3  *
   4  * Version:     $Id$
   5  *
   6  *   This library is free software; you can redistribute it and/or
   7  *   modify it under the terms of the GNU Lesser General Public
   8  *   License as published by the Free Software Foundation; either
   9  *   version 2.1 of the License, or (at your option) any later version.
  10  *
  11  *   This library is distributed in the hope that it will be useful,
  12  *   but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  14  *   Lesser General Public License for more details.
  15  *
  16  *   You should have received a copy of the GNU Lesser General Public
  17  *   License along with this library; if not, write to the Free Software
  18  *   Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  19  *
  20  * Copyright 2000,2006  The FreeRADIUS server project
  21  */
  22
  23 #include <freeradius-devel/ident.h>
  24 RCSID("$Id$")
  25
  26 #include        <freeradius-devel/libradius.h>
  27
  28 #include        <ctype.h>
  29
  30 #ifdef HAVE_MALLOC_H
  31 #  include      <malloc.h>
  32 #endif
  33
  34 #ifdef HAVE_REGEX_H
  35 #  include      <regex.h>
  36 #endif
  37
  38 static const char *months[] = {
  39         "jan", "feb", "mar", "apr", "may", "jun",
  40         "jul", "aug", "sep", "oct", "nov", "dec" };
  41
  42 /*
  43  *      This padding is necessary only for attributes that are NOT
  44  *      in the dictionary, and then only because the rest of the
  45  *      code accesses vp->name directly, rather than through an
  46  *      accessor function.
  47  *
  48  *      The name padding only has to large enough for:
  49  *
  50  *              Vendor-65535-Attr-65535
  51  *
  52  *      i.e. 23 characters, plus a zero.  We add another 8 bytes for
  53  *      padding, because the VALUE_PAIR structure may be un-aligned.
  54  *
  55  *      The result is that for the normal case, the server uses a less
  56  *      memory (36 bytes * number of VALUE_PAIRs).
  57  */
  58 #define FR_VP_NAME_PAD (32)
  59 #define FR_VP_NAME_LEN (24)
  60
  61 VALUE_PAIR *pairalloc(DICT_ATTR *da)
  62 {
  63         size_t name_len = 0;
  64         VALUE_PAIR *vp;
  65
  66         /*
  67          *      Not in the dictionary: the name is allocated AFTER
  68          *      the VALUE_PAIR struct.
  69          */
  70         if (!da) name_len = FR_VP_NAME_PAD;
  71
  72         vp = malloc(sizeof(*vp) + name_len);
  73         if (!vp) return NULL;
  74         memset(vp, 0, sizeof(*vp));
  75
  76         if (da) {
  77                 vp->attribute = da->attr;
  78                 vp->vendor = da->vendor;
  79                 vp->type = da->type;
  80                 vp->name = da->name;
  81                 vp->flags = da->flags;
  82         } else {
  83                 vp->attribute = 0;
  84                 vp->vendor = 0;
  85                 vp->type = PW_TYPE_OCTETS;
  86                 vp->name = NULL;
  87                 memset(&vp->flags, 0, sizeof(vp->flags));
  88                 vp->flags.unknown_attr = 1;
  89         }
  90
  91         switch (vp->type) {
  92                 case PW_TYPE_BYTE:
  93                         vp->length = 1;
  94                         break;
  95
  96                 case PW_TYPE_SHORT:
  97                         vp->length = 2;
  98                         break;
  99
 100                 case PW_TYPE_INTEGER:
 101                 case PW_TYPE_IPADDR:
 102                 case PW_TYPE_DATE:
 103                 case PW_TYPE_SIGNED:
 104                         vp->length = 4;
 105                         break;
 106
 107                 case PW_TYPE_IFID:
 108                         vp->length = sizeof(vp->vp_ifid);
 109                         break;
 110
 111                 case PW_TYPE_IPV6ADDR:
 112                         vp->length = sizeof(vp->vp_ipv6addr);
 113                         break;
 114
 115                 case PW_TYPE_IPV6PREFIX:
 116                         vp->length = sizeof(vp->vp_ipv6prefix);
 117                         break;
 118
 119                 case PW_TYPE_ETHERNET:
 120                         vp->length = sizeof(vp->vp_ether);
 121                         break;
 122
 123                 case PW_TYPE_TLV:
 124                         vp->vp_tlv = NULL;
 125                         vp->length = 0;
 126                         break;
 127
 128                 case PW_TYPE_COMBO_IP:
 129                 default:
 130                         vp->length = 0;
 131                         break;
 132         }
 133
 134         return vp;
 135 }
 136
 137 /*
 138  *      Create a new valuepair.
 139  */
 140 VALUE_PAIR *paircreate_raw(int attr, int vendor, int type, VALUE_PAIR *vp)
 141 {
 142         char *p = (char *) (vp + 1);
 143
 144         if (!vp->flags.unknown_attr) {
 145                 pairfree(&vp);
 146                 return NULL;
 147         }
 148
 149         vp->vendor = vendor;
 150         vp->attribute = attr;
 151         vp->operator = T_OP_EQ;
 152         vp->name = p;
 153         vp->type = type;
 154         vp->length = 0;
 155         memset(&vp->flags, 0, sizeof(vp->flags));
 156         vp->flags.unknown_attr = 1;
 157
 158         if (!vp_print_name(p, FR_VP_NAME_LEN, vp->attribute, vp->vendor)) {
 159                 free(vp);
 160                 return NULL;
 161         }
 162
 163         return vp;
 164 }
 165
 166 /*
 167  *      Create a new valuepair.
 168  */
 169 VALUE_PAIR *paircreate(int attr, int vendor, int type)
 170 {
 171         VALUE_PAIR      *vp;
 172         DICT_ATTR       *da;
 173
 174         da = dict_attrbyvalue(attr, vendor);
 175         if ((vp = pairalloc(da)) == NULL) {
 176                 fr_strerror_printf("out of memory");
 177                 return NULL;
 178         }
 179         vp->operator = T_OP_EQ;
 180
 181         /*
 182          *      It isn't in the dictionary: update the name.
 183          */
 184         if (!da) return paircreate_raw(attr, vendor, type, vp);
 185
 186         return vp;
 187 }
 188
 189 /*
 190  *      release the memory used by a single attribute-value pair
 191  *      just a wrapper around free() for now.
 192  */
 193 void pairbasicfree(VALUE_PAIR *pair)
 194 {
 195         if (pair->type == PW_TYPE_TLV) free(pair->vp_tlv);
 196         /* clear the memory here */
 197         memset(pair, 0, sizeof(*pair));
 198         free(pair);
 199 }
 200
 201 /*
 202  *      Release the memory used by a list of attribute-value
 203  *      pairs, and sets the pair pointer to NULL.
 204  */
 205 void pairfree(VALUE_PAIR **pair_ptr)
 206 {
 207         VALUE_PAIR      *next, *pair;
 208
 209         if (!pair_ptr) return;
 210         pair = *pair_ptr;
 211
 212         while (pair != NULL) {
 213                 next = pair->next;
 214                 pairbasicfree(pair);
 215                 pair = next;
 216         }
 217
 218         *pair_ptr = NULL;
 219 }
 220
 221
 222 /*
 223  *      Find the pair with the matching attribute
 224  */
 225 VALUE_PAIR * pairfind(VALUE_PAIR *first, int attr, int vendor)
 226 {
 227         while (first) {
 228                 if ((first->attribute == attr) && (first->vendor == vendor)) {
 229                         return first;
 230                 }
 231                 first = first->next;
 232         }
 233
 234         return NULL;
 235 }
 236
 237
 238 /*
 239  *      Delete the pair(s) with the matching attribute
 240  */
 241 void pairdelete(VALUE_PAIR **first, int attr, int vendor)
 242 {
 243         VALUE_PAIR *i, *next;
 244         VALUE_PAIR **last = first;
 245
 246         for(i = *first; i; i = next) {
 247                 next = i->next;
 248                 if ((i->attribute == attr) && (i->vendor == vendor)) {
 249                         *last = next;
 250                         pairbasicfree(i);
 251                 } else {
 252                         last = &i->next;
 253                 }
 254         }
 255 }
 256
 257 /*
 258  *      Add a pair at the end of a VALUE_PAIR list.
 259  */
 260 void pairadd(VALUE_PAIR **first, VALUE_PAIR *add)
 261 {
 262         VALUE_PAIR *i;
 263
 264         if (!add) return;
 265
 266         if (*first == NULL) {
 267                 *first = add;
 268                 return;
 269         }
 270         for(i = *first; i->next; i = i->next)
 271                 ;
 272         i->next = add;
 273 }
 274
 275 /*
 276  *      Add or replace a pair at the end of a VALUE_PAIR list.
 277  */
 278 void pairreplace(VALUE_PAIR **first, VALUE_PAIR *replace)
 279 {
 280         VALUE_PAIR *i, *next;
 281         VALUE_PAIR **prev = first;
 282
 283         if (*first == NULL) {
 284                 *first = replace;
 285                 return;
 286         }
 287
 288         /*
 289          *      Not an empty list, so find item if it is there, and
 290          *      replace it. Note, we always replace the first one, and
 291          *      we ignore any others that might exist.
 292          */
 293         for(i = *first; i; i = next) {
 294                 next = i->next;
 295
 296                 /*
 297                  *      Found the first attribute, replace it,
 298                  *      and return.
 299                  */
 300                 if ((i->attribute == replace->attribute) &&
 301                     (i->vendor == replace->vendor)) {
 302                         *prev = replace;
 303
 304                         /*
 305                          *      Should really assert that replace->next == NULL
 306                          */
 307                         replace->next = next;
 308                         pairbasicfree(i);
 309                         return;
 310                 }
 311
 312                 /*
 313                  *      Point to where the attribute should go.
 314                  */
 315                 prev = &i->next;
 316         }
 317
 318         /*
 319          *      If we got here, we didn't find anything to replace, so
 320          *      stopped at the last item, which we just append to.
 321          */
 322         *prev = replace;
 323 }
 324
 325
 326 /*
 327  *      Copy just one VP.
 328  */
 329 VALUE_PAIR *paircopyvp(const VALUE_PAIR *vp)
 330 {
 331         size_t name_len;
 332         VALUE_PAIR *n;
 333
 334         if (!vp->flags.unknown_attr) {
 335                 name_len = 0;
 336         } else {
 337                 name_len = FR_VP_NAME_PAD;
 338         }
 339
 340         if ((n = malloc(sizeof(*n) + name_len)) == NULL) {
 341                 fr_strerror_printf("out of memory");
 342                 return NULL;
 343         }
 344         memcpy(n, vp, sizeof(*n) + name_len);
 345
 346         /*
 347          *      Reset the name field to point to the NEW attribute,
 348          *      rather than to the OLD one.
 349          */
 350         if (vp->flags.unknown_attr) n->name = (char *) (n + 1);
 351
 352         n->next = NULL;
 353
 354         if ((n->type == PW_TYPE_TLV) &&
 355             (n->vp_tlv != NULL)) {
 356                 n->vp_tlv = malloc(n->length);
 357                 memcpy(n->vp_tlv, vp->vp_tlv, n->length);
 358         }
 359
 360         return n;
 361 }
 362
 363
 364 /*
 365  *      Copy just a certain type of pairs.
 366  */
 367 VALUE_PAIR *paircopy2(VALUE_PAIR *vp, int attr, int vendor)
 368 {
 369         VALUE_PAIR      *first, *n, **last;
 370
 371         first = NULL;
 372         last = &first;
 373
 374         while (vp) {
 375                 if ((attr >= 0) &&
 376                     !((vp->attribute == attr) && (vp->vendor == vendor))) {
 377                         vp = vp->next;
 378                         continue;
 379                 }
 380
 381                 n = paircopyvp(vp);
 382                 if (!n) return first;
 383                 *last = n;
 384                 last = &n->next;
 385                 vp = vp->next;
 386         }
 387         return first;
 388 }
 389
 390
 391 /*
 392  *      Copy a pairlist.
 393  */
 394 VALUE_PAIR *paircopy(VALUE_PAIR *vp)
 395 {
 396         return paircopy2(vp, -1, 0);
 397 }
 398
 399
 400 /*
 401  *      Move attributes from one list to the other
 402  *      if not already present.
 403  */
 404 void pairmove(VALUE_PAIR **to, VALUE_PAIR **from)
 405 {
 406         VALUE_PAIR **tailto, *i, *j, *next;
 407         VALUE_PAIR *tailfrom = NULL;
 408         VALUE_PAIR *found;
 409         int has_password = 0;
 410
 411         /*
 412          *      First, see if there are any passwords here, and
 413          *      point "tailto" to the end of the "to" list.
 414          */
 415         tailto = to;
 416         for(i = *to; i; i = i->next) {
 417                 if (i->attribute == PW_USER_PASSWORD ||
 418                     i->attribute == PW_CRYPT_PASSWORD)
 419                         has_password = 1;
 420                 tailto = &i->next;
 421         }
 422
 423         /*
 424          *      Loop over the "from" list.
 425          */
 426         for(i = *from; i; i = next) {
 427                 next = i->next;
 428
 429                 /*
 430                  *      If there was a password in the "to" list,
 431                  *      do not move any other password from the
 432                  *      "from" to the "to" list.
 433                  */
 434                 if (has_password &&
 435                     (i->attribute == PW_USER_PASSWORD ||
 436                      i->attribute == PW_CRYPT_PASSWORD)) {
 437                         tailfrom = i;
 438                         continue;
 439                 }
 440
 441                 switch (i->operator) {
 442                         /*
 443                          *      These are COMPARISON attributes
 444                          *      from a check list, and are not
 445                          *      supposed to be copied!
 446                          */
 447                         case T_OP_NE:
 448                         case T_OP_GE:
 449                         case T_OP_GT:
 450                         case T_OP_LE:
 451                         case T_OP_LT:
 452                         case T_OP_CMP_TRUE:
 453                         case T_OP_CMP_FALSE:
 454                         case T_OP_CMP_EQ:
 455                                 tailfrom = i;
 456                                 continue;
 457
 458                         default:
 459                                 break;
 460                 }
 461
 462                 /*
 463                  *      If the attribute is already present in "to",
 464                  *      do not move it from "from" to "to". We make
 465                  *      an exception for "Hint" which can appear multiple
 466                  *      times, and we never move "Fall-Through".
 467                  */
 468                 if (i->attribute == PW_FALL_THROUGH ||
 469                     (i->attribute != PW_HINT && i->attribute != PW_FRAMED_ROUTE)) {
 470
 471                         found = pairfind(*to, i->attribute, i->vendor);
 472                         switch (i->operator) {
 473
 474                           /*
 475                            *    If matching attributes are found,
 476                            *    delete them.
 477                            */
 478                         case T_OP_SUB:          /* -= */
 479                                 if (found) {
 480                                         if (!i->vp_strvalue[0] ||
 481                                             (strcmp((char *)found->vp_strvalue,
 482                                                     (char *)i->vp_strvalue) == 0)){
 483                                                 pairdelete(to, found->attribute, found->vendor);
 484
 485                                                 /*
 486                                                  *      'tailto' may have been
 487                                                  *      deleted...
 488                                                  */
 489                                                 tailto = to;
 490                                                 for(j = *to; j; j = j->next) {
 491                                                         tailto = &j->next;
 492                                                 }
 493                                         }
 494                                 }
 495                                 tailfrom = i;
 496                                 continue;
 497                                 break;
 498
 499 /* really HAVE_REGEX_H */
 500 #if 0
 501                                 /*
 502                                  *  Attr-Name =~ "s/find/replace/"
 503                                  *
 504                                  *  Very bad code.  Barely working,
 505                                  *  if at all.
 506                                  */
 507
 508                         case T_OP_REG_EQ:
 509                           if (found &&
 510                               (i->vp_strvalue[0] == 's')) {
 511                             regex_t             reg;
 512                             regmatch_t          match[1];
 513
 514                             char *str;
 515                             char *p, *q;
 516
 517                             p = i->vp_strvalue + 1;
 518                             q = strchr(p + 1, *p);
 519                             if (!q || (q[strlen(q) - 1] != *p)) {
 520                               tailfrom = i;
 521                               continue;
 522                             }
 523                             str = strdup(i->vp_strvalue + 2);
 524                             q = strchr(str, *p);
 525                             *(q++) = '\0';
 526                             q[strlen(q) - 1] = '\0';
 527
 528                             regcomp(&reg, str, 0);
 529                             if (regexec(&reg, found->vp_strvalue,
 530                                         1, match, 0) == 0) {
 531                               fprintf(stderr, "\"%s\" will have %d to %d replaced with %s\n",
 532                                       found->vp_strvalue, match[0].rm_so,
 533                                       match[0].rm_eo, q);
 534
 535                             }
 536                             regfree(&reg);
 537                             free(str);
 538                           }
 539                           tailfrom = i; /* don't copy it over */
 540                           continue;
 541                           break;
 542 #endif
 543                         case T_OP_EQ:           /* = */
 544                                 /*
 545                                  *  FIXME: Tunnel attributes with
 546                                  *  different tags are different
 547                                  *  attributes.
 548                                  */
 549                                 if (found) {
 550                                         tailfrom = i;
 551                                         continue; /* with the loop */
 552                                 }
 553                                 break;
 554
 555                           /*
 556                            *  If a similar attribute is found,
 557                            *  replace it with the new one.  Otherwise,
 558                            *  add the new one to the list.
 559                            */
 560                         case T_OP_SET:          /* := */
 561                                 if (found) {
 562                                         VALUE_PAIR *mynext = found->next;
 563
 564                                         /*
 565                                          *      Do NOT call pairdelete()
 566                                          *      here, due to issues with
 567                                          *      re-writing "request->username".
 568                                          *
 569                                          *      Everybody calls pairmove,
 570                                          *      and expects it to work.
 571                                          *      We can't update request->username
 572                                          *      here, so instead we over-write
 573                                          *      the vp that it's pointing to.
 574                                          */
 575                                         memcpy(found, i, sizeof(*found));
 576                                         found->next = mynext;
 577
 578                                         pairdelete(&found->next, found->attribute, found->vendor);
 579
 580                                         /*
 581                                          *      'tailto' may have been
 582                                          *      deleted...
 583                                          */
 584                                         for(j = found; j; j = j->next) {
 585                                                 tailto = &j->next;
 586                                         }
 587                                         continue;
 588                                 }
 589                                 break;
 590
 591                           /*
 592                            *  Add the new element to the list, even
 593                            *  if similar ones already exist.
 594                            */
 595                         default:
 596                         case T_OP_ADD: /* += */
 597                                 break;
 598                         }
 599                 }
 600                 if (tailfrom)
 601                         tailfrom->next = next;
 602                 else
 603                         *from = next;
 604
 605                 /*
 606                  *      If ALL of the 'to' attributes have been deleted,
 607                  *      then ensure that the 'tail' is updated to point
 608                  *      to the head.
 609                  */
 610                 if (!*to) {
 611                         tailto = to;
 612                 }
 613                 *tailto = i;
 614                 if (i) {
 615                         i->next = NULL;
 616                         tailto = &i->next;
 617                 }
 618         }
 619 }
 620
 621 /*
 622  *      Move one kind of attributes from one list to the other
 623  */
 624 void pairmove2(VALUE_PAIR **to, VALUE_PAIR **from, int attr, int vendor)
 625 {
 626         VALUE_PAIR *to_tail, *i, *next;
 627         VALUE_PAIR *iprev = NULL;
 628
 629         /*
 630          *      Find the last pair in the "to" list and put it in "to_tail".
 631          */
 632         if (*to != NULL) {
 633                 to_tail = *to;
 634                 for(i = *to; i; i = i->next)
 635                         to_tail = i;
 636         } else
 637                 to_tail = NULL;
 638
 639         for(i = *from; i; i = next) {
 640                 next = i->next;
 641
 642                 /*
 643                  *      vendor=0, attr = PW_VENDOR_SPECIFIC means
 644                  *      "match any vendor attribute".
 645                  */
 646                 if ((vendor == 0) && (attr == PW_VENDOR_SPECIFIC)) {
 647                         /*
 648                          *      It's a VSA: move it over.
 649                          */
 650                         if (i->vendor != 0) goto move;
 651
 652                         /*
 653                          *      It's Vendor-Specific: move it over.
 654                          */
 655                         if (i->attribute == attr) goto move;
 656
 657                         /*
 658                          *      It's not a VSA: ignore it.
 659                          */
 660                         iprev = i;
 661                         continue;
 662                 }
 663
 664                 /*
 665                  *      If it isn't an exact match, ignore it.
 666                  */
 667                 if (!((i->vendor == vendor) && (i->attribute == attr))) {
 668                         iprev = i;
 669                         continue;
 670                 }
 671
 672         move:
 673                 /*
 674                  *      Remove the attribute from the "from" list.
 675                  */
 676                 if (iprev)
 677                         iprev->next = next;
 678                 else
 679                         *from = next;
 680
 681                 /*
 682                  *      Add the attribute to the "to" list.
 683                  */
 684                 if (to_tail)
 685                         to_tail->next = i;
 686                 else
 687                         *to = i;
 688                 to_tail = i;
 689                 i->next = NULL;
 690         }
 691 }
 692
 693
 694 /*
 695  *      Sort of strtok/strsep function.
 696  */
 697 static char *mystrtok(char **ptr, const char *sep)
 698 {
 699         char    *res;
 700
 701         if (**ptr == 0)
 702                 return NULL;
 703         while (**ptr && strchr(sep, **ptr))
 704                 (*ptr)++;
 705         if (**ptr == 0)
 706                 return NULL;
 707         res = *ptr;
 708         while (**ptr && strchr(sep, **ptr) == NULL)
 709                 (*ptr)++;
 710         if (**ptr != 0)
 711                 *(*ptr)++ = 0;
 712         return res;
 713 }
 714
 715 /*
 716  *      Turn printable string into time_t
 717  *      Returns -1 on error, 0 on OK.
 718  */
 719 static int gettime(const char *valstr, time_t *date)
 720 {
 721         int             i;
 722         time_t          t;
 723         struct tm       *tm, s_tm;
 724         char            buf[64];
 725         char            *p;
 726         char            *f[4];
 727         char            *tail = '\0';
 728
 729         /*
 730          * Test for unix timestamp date
 731          */
 732         *date = strtoul(valstr, &tail, 10);
 733         if (*tail == '\0') {
 734                 return 0;
 735         }
 736
 737         tm = &s_tm;
 738         memset(tm, 0, sizeof(*tm));
 739         tm->tm_isdst = -1;      /* don't know, and don't care about DST */
 740
 741         strlcpy(buf, valstr, sizeof(buf));
 742
 743         p = buf;
 744         f[0] = mystrtok(&p, " \t");
 745         f[1] = mystrtok(&p, " \t");
 746         f[2] = mystrtok(&p, " \t");
 747         f[3] = mystrtok(&p, " \t"); /* may, or may not, be present */
 748         if (!f[0] || !f[1] || !f[2]) return -1;
 749
 750         /*
 751          *      The time has a colon, where nothing else does.
 752          *      So if we find it, bubble it to the back of the list.
 753          */
 754         if (f[3]) {
 755                 for (i = 0; i < 3; i++) {
 756                         if (strchr(f[i], ':')) {
 757                                 p = f[3];
 758                                 f[3] = f[i];
 759                                 f[i] = p;
 760                                 break;
 761                         }
 762                 }
 763         }
 764
 765         /*
 766          *  The month is text, which allows us to find it easily.
 767          */
 768         tm->tm_mon = 12;
 769         for (i = 0; i < 3; i++) {
 770                 if (isalpha( (int) *f[i])) {
 771                         /*
 772                          *  Bubble the month to the front of the list
 773                          */
 774                         p = f[0];
 775                         f[0] = f[i];
 776                         f[i] = p;
 777
 778                         for (i = 0; i < 12; i++) {
 779                                 if (strncasecmp(months[i], f[0], 3) == 0) {
 780                                         tm->tm_mon = i;
 781                                         break;
 782                                 }
 783                         }
 784                 }
 785         }
 786
 787         /* month not found? */
 788         if (tm->tm_mon == 12) return -1;
 789
 790         /*
 791          *  The year may be in f[1], or in f[2]
 792          */
 793         tm->tm_year = atoi(f[1]);
 794         tm->tm_mday = atoi(f[2]);
 795
 796         if (tm->tm_year >= 1900) {
 797                 tm->tm_year -= 1900;
 798
 799         } else {
 800                 /*
 801                  *  We can't use 2-digit years any more, they make it
 802                  *  impossible to tell what's the day, and what's the year.
 803                  */
 804                 if (tm->tm_mday < 1900) return -1;
 805
 806                 /*
 807                  *  Swap the year and the day.
 808                  */
 809                 i = tm->tm_year;
 810                 tm->tm_year = tm->tm_mday - 1900;
 811                 tm->tm_mday = i;
 812         }
 813
 814         /*
 815          *  If the day is out of range, die.
 816          */
 817         if ((tm->tm_mday < 1) || (tm->tm_mday > 31)) {
 818                 return -1;
 819         }
 820
 821         /*
 822          *      There may be %H:%M:%S.  Parse it in a hacky way.
 823          */
 824         if (f[3]) {
 825                 f[0] = f[3];    /* HH */
 826                 f[1] = strchr(f[0], ':'); /* find : separator */
 827                 if (!f[1]) return -1;
 828
 829                 *(f[1]++) = '\0'; /* nuke it, and point to MM:SS */
 830
 831                 f[2] = strchr(f[1], ':'); /* find : separator */
 832                 if (f[2]) {
 833                   *(f[2]++) = '\0';     /* nuke it, and point to SS */
 834                   tm->tm_sec = atoi(f[2]);
 835                 }                       /* else leave it as zero */
 836
 837                 tm->tm_hour = atoi(f[0]);
 838                 tm->tm_min = atoi(f[1]);
 839         }
 840
 841         /*
 842          *  Returns -1 on error.
 843          */
 844         t = mktime(tm);
 845         if (t == (time_t) -1) return -1;
 846
 847         *date = t;
 848
 849         return 0;
 850 }
 851
 852 static const char *hextab = "0123456789abcdef";
 853
 854 /*
 855  *  Parse a string value into a given VALUE_PAIR
 856  *
 857  *  FIXME: we probably want to fix this function to accept
 858  *  octets as values for any type of attribute.  We should then
 859  *  double-check the parsed value, to be sure it's legal for that
 860  *  type (length, etc.)
 861  */
 862 static uint32_t getint(const char *value, char **end)
 863 {
 864         if ((value[0] == '0') && (value[1] == 'x')) {
 865                 return strtoul(value, end, 16);
 866         }
 867
 868         return strtoul(value, end, 10);
 869 }
 870
 871 static int check_for_whitespace(const char *value)
 872 {
 873         while (*value) {
 874                 if (!isspace((int) *value)) return 0;
 875
 876                 value++;
 877         }
 878
 879         return 1;
 880 }
 881
 882
 883 VALUE_PAIR *pairparsevalue(VALUE_PAIR *vp, const char *value)
 884 {
 885         char            *p, *s=0;
 886         const char      *cp, *cs;
 887         int             x;
 888         size_t          length;
 889         DICT_VALUE      *dval;
 890
 891         if (!value) return NULL;
 892
 893         /*
 894          *      Even for integers, dates and ip addresses we
 895          *      keep the original string in vp->vp_strvalue.
 896          */
 897         if (vp->type != PW_TYPE_TLV) {
 898                 strlcpy(vp->vp_strvalue, value, sizeof(vp->vp_strvalue));
 899                 vp->length = strlen(vp->vp_strvalue);
 900         }
 901
 902         switch(vp->type) {
 903                 case PW_TYPE_STRING:
 904                         /*
 905                          *      Do escaping here
 906                          */
 907                         p = vp->vp_strvalue;
 908                         cp = value;
 909                         length = 0;
 910
 911                         while (*cp && (length < (sizeof(vp->vp_strvalue) - 1))) {
 912                                 char c = *cp++;
 913
 914                                 if (c == '\\') {
 915                                         switch (*cp) {
 916                                         case 'r':
 917                                                 c = '\r';
 918                                                 cp++;
 919                                                 break;
 920                                         case 'n':
 921                                                 c = '\n';
 922                                                 cp++;
 923                                                 break;
 924                                         case 't':
 925                                                 c = '\t';
 926                                                 cp++;
 927                                                 break;
 928                                         case '"':
 929                                                 c = '"';
 930                                                 cp++;
 931                                                 break;
 932                                         case '\'':
 933                                                 c = '\'';
 934                                                 cp++;
 935                                                 break;
 936                                         case '`':
 937                                                 c = '`';
 938                                                 cp++;
 939                                                 break;
 940                                         case '\0':
 941                                                 c = '\\'; /* no cp++ */
 942                                                 break;
 943                                         default:
 944                                                 if ((cp[0] >= '0') &&
 945                                                     (cp[0] <= '9') &&
 946                                                     (cp[1] >= '0') &&
 947                                                     (cp[1] <= '9') &&
 948                                                     (cp[2] >= '0') &&
 949                                                     (cp[2] <= '9') &&
 950                                                     (sscanf(cp, "%3o", &x) == 1)) {
 951                                                         c = x;
 952                                                         cp += 3;
 953                                                 } /* else just do '\\' */
 954                                         }
 955                                 }
 956                                 *p++ = c;
 957                                 length++;
 958                         }
 959                         vp->vp_strvalue[length] = '\0';
 960                         vp->length = length;
 961                         break;
 962
 963                 case PW_TYPE_IPADDR:
 964                         /*
 965                          *      It's a comparison, not a real IP.
 966                          */
 967                         if ((vp->operator == T_OP_REG_EQ) ||
 968                             (vp->operator == T_OP_REG_NE)) {
 969                                 break;
 970                         }
 971
 972                         /*
 973                          *      FIXME: complain if hostname
 974                          *      cannot be resolved, or resolve later!
 975                          */
 976                         s = NULL;
 977                         if ((p = strrchr(value, '+')) != NULL && !p[1]) {
 978                                 cs = s = strdup(value);
 979                                 if (!s) return NULL;
 980                                 p = strrchr(s, '+');
 981                                 *p = 0;
 982                                 vp->flags.addport = 1;
 983                         } else {
 984                                 p = NULL;
 985                                 cs = value;
 986                         }
 987
 988                         {
 989                                 fr_ipaddr_t ipaddr;
 990
 991                                 if (ip_hton(cs, AF_INET, &ipaddr) < 0) {
 992                                         free(s);
 993                                         fr_strerror_printf("Failed to find IP address for %s", cs);
 994                                         return NULL;
 995                                 }
 996
 997                                 vp->vp_ipaddr = ipaddr.ipaddr.ip4addr.s_addr;
 998                         }
 999                         free(s);
1000                         vp->length = 4;
1001                         break;
1002
1003                 case PW_TYPE_BYTE:
1004                         vp->length = 1;
1005
1006                         /*
1007                          *      Note that ALL integers are unsigned!
1008                          */
1009                         vp->vp_integer = getint(value, &p);
1010                         if (!*p) {
1011                                 if (vp->vp_integer > 255) {
1012                                         fr_strerror_printf("Byte value \"%s\" is larger than 255", value);
1013                                         return NULL;
1014                                 }
1015                                 break;
1016                         }
1017                         if (check_for_whitespace(p)) break;
1018                         goto check_for_value;
1019
1020                 case PW_TYPE_SHORT:
1021                         /*
1022                          *      Note that ALL integers are unsigned!
1023                          */
1024                         vp->vp_integer = getint(value, &p);
1025                         vp->length = 2;
1026                         if (!*p) {
1027                                 if (vp->vp_integer > 65535) {
1028                                         fr_strerror_printf("Byte value \"%s\" is larger than 65535", value);
1029                                         return NULL;
1030                                 }
1031                                 break;
1032                         }
1033                         if (check_for_whitespace(p)) break;
1034                         goto check_for_value;
1035
1036                 case PW_TYPE_INTEGER:
1037                         /*
1038                          *      Note that ALL integers are unsigned!
1039                          */
1040                         vp->vp_integer = getint(value, &p);
1041                         vp->length = 4;
1042                         if (!*p) break;
1043                         if (check_for_whitespace(p)) break;
1044
1045         check_for_value:
1046                         /*
1047                          *      Look for the named value for the given
1048                          *      attribute.
1049                          */
1050                         if ((dval = dict_valbyname(vp->attribute, vp->vendor, value)) == NULL) {
1051                                 fr_strerror_printf("Unknown value %s for attribute %s",
1052                                            value, vp->name);
1053                                 return NULL;
1054                         }
1055                         vp->vp_integer = dval->value;
1056                         break;
1057
1058                 case PW_TYPE_DATE:
1059                         {
1060                                 /*
1061                                  *      time_t may be 64 bits, whule vp_date
1062                                  *      MUST be 32-bits.  We need an
1063                                  *      intermediary variable to handle
1064                                  *      the conversions.
1065                                  */
1066                                 time_t date;
1067
1068                                 if (gettime(value, &date) < 0) {
1069                                         fr_strerror_printf("failed to parse time string "
1070                                                    "\"%s\"", value);
1071                                         return NULL;
1072                                 }
1073
1074                                 vp->vp_date = date;
1075                         }
1076                         vp->length = 4;
1077                         break;
1078
1079                 case PW_TYPE_ABINARY:
1080 #ifdef ASCEND_BINARY
1081                         if (strncasecmp(value, "0x", 2) == 0) {
1082                                 vp->type = PW_TYPE_OCTETS;
1083                                 goto do_octets;
1084                         }
1085
1086                         if (ascend_parse_filter(vp) < 0 ) {
1087                                 fr_strerror_printf("failed to parse Ascend binary attribute: %s",
1088                                            fr_strerror());
1089                                 return NULL;
1090                         }
1091                         break;
1092
1093                         /*
1094                          *      If Ascend binary is NOT defined,
1095                          *      then fall through to raw octets, so that
1096                          *      the user can at least make them by hand...
1097                          */
1098         do_octets:
1099 #endif
1100                         /* raw octets: 0x01020304... */
1101                 case PW_TYPE_OCTETS:
1102                         if (strncasecmp(value, "0x", 2) == 0) {
1103                                 uint8_t *us;
1104                                 cp = value + 2;
1105                                 us = vp->vp_octets;
1106                                 vp->length = 0;
1107
1108
1109                                 /*
1110                                  *      There is only one character,
1111                                  *      die.
1112                                  */
1113                                 if ((strlen(cp) & 0x01) != 0) {
1114                                         fr_strerror_printf("Hex string is not an even length string.");
1115                                         return NULL;
1116                                 }
1117
1118
1119                                 while (*cp &&
1120                                        (vp->length < MAX_STRING_LEN)) {
1121                                         unsigned int tmp;
1122
1123                                         if (sscanf(cp, "%02x", &tmp) != 1) {
1124                                                 fr_strerror_printf("Non-hex characters at %c%c", cp[0], cp[1]);
1125                                                 return NULL;
1126                                         }
1127
1128                                         cp += 2;
1129                                         *(us++) = tmp;
1130                                         vp->length++;
1131                                 }
1132                         }
1133                         break;
1134
1135                 case PW_TYPE_IFID:
1136                         if (ifid_aton(value, (void *) &vp->vp_ifid) == NULL) {
1137                                 fr_strerror_printf("failed to parse interface-id "
1138                                            "string \"%s\"", value);
1139                                 return NULL;
1140                         }
1141                         vp->length = 8;
1142                         break;
1143
1144                 case PW_TYPE_IPV6ADDR:
1145                         {
1146                                 fr_ipaddr_t ipaddr;
1147
1148                                 if (ip_hton(value, AF_INET6, &ipaddr) < 0) {
1149                                         char buffer[1024];
1150
1151                                         strlcpy(buffer, fr_strerror(), sizeof(buffer));
1152
1153                                         fr_strerror_printf("failed to parse IPv6 address "
1154                                                            "string \"%s\": %s", value, buffer);
1155                                         return NULL;
1156                                 }
1157                                 vp->vp_ipv6addr = ipaddr.ipaddr.ip6addr;
1158                                 vp->length = 16; /* length of IPv6 address */
1159                         }
1160                         break;
1161
1162                 case PW_TYPE_IPV6PREFIX:
1163                         p = strchr(value, '/');
1164                         if (!p || ((p - value) >= 256)) {
1165                                 fr_strerror_printf("invalid IPv6 prefix "
1166                                            "string \"%s\"", value);
1167                                 return NULL;
1168                         } else {
1169                                 unsigned int prefix;
1170                                 char buffer[256], *eptr;
1171
1172                                 memcpy(buffer, value, p - value);
1173                                 buffer[p - value] = '\0';
1174
1175                                 if (inet_pton(AF_INET6, buffer, vp->vp_octets + 2) <= 0) {
1176                                         fr_strerror_printf("failed to parse IPv6 address "
1177                                                    "string \"%s\"", value);
1178                                         return NULL;
1179                                 }
1180
1181                                 prefix = strtoul(p + 1, &eptr, 10);
1182                                 if ((prefix > 128) || *eptr) {
1183                                         fr_strerror_printf("failed to parse IPv6 address "
1184                                                    "string \"%s\"", value);
1185                                         return NULL;
1186                                 }
1187                                 vp->vp_octets[1] = prefix;
1188                         }
1189                         vp->vp_octets[0] = '\0';
1190                         vp->length = 16 + 2;
1191                         break;
1192
1193                 case PW_TYPE_ETHERNET:
1194                         {
1195                                 const char *c1, *c2;
1196
1197                                 length = 0;
1198                                 cp = value;
1199                                 while (*cp) {
1200                                         if (cp[1] == ':') {
1201                                                 c1 = hextab;
1202                                                 c2 = memchr(hextab, tolower((int) cp[0]), 16);
1203                                                 cp += 2;
1204                                         } else if ((cp[1] != '\0') &&
1205                                                    ((cp[2] == ':') ||
1206                                                     (cp[2] == '\0'))) {
1207                                                    c1 = memchr(hextab, tolower((int) cp[0]), 16);
1208                                                    c2 = memchr(hextab, tolower((int) cp[1]), 16);
1209                                                    cp += 2;
1210                                                    if (*cp == ':') cp++;
1211                                         } else {
1212                                                 c1 = c2 = NULL;
1213                                         }
1214                                         if (!c1 || !c2 || (length >= sizeof(vp->vp_ether))) {
1215                                                 fr_strerror_printf("failed to parse Ethernet address \"%s\"", value);
1216                                                 return NULL;
1217                                         }
1218                                         vp->vp_ether[length] = ((c1-hextab)<<4) + (c2-hextab);
1219                                         length++;
1220                                 }
1221                         }
1222                         vp->length = 6;
1223                         break;
1224
1225                 case PW_TYPE_COMBO_IP:
1226                         if (inet_pton(AF_INET6, value, vp->vp_strvalue) > 0) {
1227                                 vp->type = PW_TYPE_IPV6ADDR;
1228                                 vp->length = 16; /* length of IPv6 address */
1229                                 vp->vp_strvalue[vp->length] = '\0';
1230
1231                         } else {
1232                                 fr_ipaddr_t ipaddr;
1233
1234                                 if (ip_hton(value, AF_INET, &ipaddr) < 0) {
1235                                         fr_strerror_printf("Failed to find IPv4 address for %s", value);
1236                                         return NULL;
1237                                 }
1238
1239                                 vp->type = PW_TYPE_IPADDR;
1240                                 vp->vp_ipaddr = ipaddr.ipaddr.ip4addr.s_addr;
1241                                 vp->length = 4;
1242                         }
1243                         break;
1244
1245                 case PW_TYPE_SIGNED: /* Damned code for 1 WiMAX attribute */
1246                         vp->vp_signed = (int32_t) strtol(value, &p, 10);
1247                         vp->length = 4;
1248                         break;
1249
1250                 case PW_TYPE_TLV: /* don't use this! */
1251                         if (strncasecmp(value, "0x", 2) != 0) {
1252                                 fr_strerror_printf("Invalid TLV specification");
1253                                 return NULL;
1254                         }
1255                         length = strlen(value + 2) / 2;
1256                         if (vp->length < length) {
1257                                 free(vp->vp_tlv);
1258                                 vp->vp_tlv = NULL;
1259                         }
1260                         vp->vp_tlv = malloc(length);
1261                         if (!vp->vp_tlv) {
1262                                 fr_strerror_printf("No memory");
1263                                 return NULL;
1264                         }
1265                         if (fr_hex2bin(value + 2, vp->vp_tlv,
1266                                        length) != length) {
1267                                 fr_strerror_printf("Invalid hex data in TLV");
1268                                 return NULL;
1269                         }
1270                         vp->length = length;
1271                         break;
1272
1273                         /*
1274                          *  Anything else.
1275                          */
1276                 default:
1277                         fr_strerror_printf("unknown attribute type %d", vp->type);
1278                         return NULL;
1279         }
1280
1281         return vp;
1282 }
1283
1284 /*
1285  *      Create a VALUE_PAIR from an ASCII attribute and value,
1286  *      where the attribute name is in the form:
1287  *
1288  *      Attr-%d
1289  *      Vendor-%d-Attr-%d
1290  *      VendorName-Attr-%d
1291  */
1292 static VALUE_PAIR *pairmake_any(const char *attribute, const char *value,
1293                                 int operator)
1294 {
1295         int             attr, vendor;
1296         size_t          size;
1297         const char      *p = attribute;
1298         char            *q;
1299         VALUE_PAIR      *vp;
1300
1301         /*
1302          *      Unknown attributes MUST be of type 'octets'
1303          */
1304         if (value && (strncasecmp(value, "0x", 2) != 0)) {
1305                 fr_strerror_printf("Invalid octet string \"%s\" for attribute name \"%s\"", value, attribute);
1306                 return NULL;
1307         }
1308
1309         vendor = 0;
1310
1311         /*
1312          *      Pull off vendor prefix first.
1313          */
1314         if (strncasecmp(p, "Attr-", 5) != 0) {
1315                 if (strncasecmp(p, "Vendor-", 7) == 0) {
1316                         vendor = (int) strtol(p + 7, &q, 10);
1317                         if ((vendor == 0) || (vendor > FR_MAX_VENDOR)) {
1318                                 fr_strerror_printf("Invalid vendor value in attribute name \"%s\"", attribute);
1319                                 return NULL;
1320                         }
1321
1322                         p = q;
1323
1324                 } else {        /* must be vendor name */
1325                         char buffer[256];
1326
1327                         q = strchr(p, '-');
1328
1329                         if (!q) {
1330                                 fr_strerror_printf("Invalid vendor name in attribute name \"%s\"", attribute);
1331                                 return NULL;
1332                         }
1333
1334                         if ((size_t) (q - p) >= sizeof(buffer)) {
1335                                 fr_strerror_printf("Vendor name too long in attribute name \"%s\"", attribute);
1336                                 return NULL;
1337                         }
1338
1339                         memcpy(buffer, p, (q - p));
1340                         buffer[q - p] = '\0';
1341
1342                         vendor = dict_vendorbyname(buffer);
1343                         if (!vendor) {
1344                                 fr_strerror_printf("Unknown vendor name in attribute name \"%s\"", attribute);
1345                                 return NULL;
1346                         }
1347
1348                         p = q;
1349                 }
1350
1351                 if (*p != '-') {
1352                         fr_strerror_printf("Invalid text following vendor definition in attribute name \"%s\"", attribute);
1353                         return NULL;
1354                 }
1355                 p++;
1356         }
1357
1358         /*
1359          *      Attr-%d
1360          */
1361         if (strncasecmp(p, "Attr-", 5) != 0) {
1362                 fr_strerror_printf("Invalid format in attribute name \"%s\"", attribute);
1363                 return NULL;
1364         }
1365
1366         attr = strtol(p + 5, &q, 10);
1367
1368         /*
1369          *      Invalid, or trailing text after number.
1370          */
1371         if ((attr == 0) || *q) {
1372                 fr_strerror_printf("Invalid value in attribute name \"%s\"", attribute);
1373                 return NULL;
1374         }
1375
1376         /*
1377          *      Double-check the size of attr.
1378          */
1379         if (vendor) {
1380                 DICT_VENDOR *dv = dict_vendorbyvalue(vendor);
1381
1382                 if (!dv) {
1383                         if (attr > 255) {
1384                         attr_error:
1385                                 fr_strerror_printf("Invalid attribute number in attribute name \"%s\"", attribute);
1386                                 return NULL;
1387                         }
1388
1389                 } else switch (dv->type) {
1390                         case 1:
1391                                 if (attr > 255) goto attr_error;
1392                                 break;
1393
1394                         case 2:
1395                                 if (attr > 65535) goto attr_error;
1396                                 break;
1397
1398                         case 4:
1399                                 break;
1400
1401                         default:
1402                                 fr_strerror_printf("Internal sanity check failed");
1403                                 return NULL;
1404                 }
1405         }
1406
1407         /*
1408          *      We've now parsed the attribute properly, Let's create
1409          *      it.  This next stop also looks the attribute up in the
1410          *      dictionary, and creates the appropriate type for it.
1411          */
1412         if ((vp = paircreate(attr, vendor, PW_TYPE_OCTETS)) == NULL) {
1413                 fr_strerror_printf("out of memory");
1414                 return NULL;
1415         }
1416
1417         vp->operator = (operator == 0) ? T_OP_EQ : operator;
1418         if (!value) return vp;
1419
1420         size = strlen(value + 2);
1421
1422         /*
1423          *      We may be reading something like Attr-5.  i.e.
1424          *      who-ever wrote the text didn't understand it, but we
1425          *      do.
1426          */
1427         switch (vp->type) {
1428         default:
1429                 if (size == (vp->length * 2)) break;
1430                 vp->type = PW_TYPE_OCTETS;
1431                 /* FALL-THROUGH */
1432
1433         case PW_TYPE_STRING:
1434         case PW_TYPE_OCTETS:
1435         case PW_TYPE_ABINARY:
1436                 vp->length = size >> 1;
1437                 break;
1438         }
1439
1440         if (fr_hex2bin(value + 2, vp->vp_octets, size) != vp->length) {
1441                 fr_strerror_printf("Invalid hex string");
1442                 free(vp);
1443                 return NULL;
1444         }
1445
1446         /*
1447          *      Move contents around based on type.  This is
1448          *      to work around the historical use of "lvalue".
1449          */
1450         switch (vp->type) {
1451         case PW_TYPE_DATE:
1452         case PW_TYPE_IPADDR:
1453         case PW_TYPE_INTEGER:
1454                 memcpy(&vp->lvalue, vp->vp_octets, sizeof(vp->lvalue));
1455                 vp->vp_strvalue[0] = '\0';
1456                 break;
1457
1458         default:
1459                 break;
1460         }
1461
1462         return vp;
1463 }
1464
1465
1466 /*
1467  *      Create a VALUE_PAIR from an ASCII attribute and value.
1468  */
1469 VALUE_PAIR *pairmake(const char *attribute, const char *value, int operator)
1470 {
1471         DICT_ATTR       *da;
1472         VALUE_PAIR      *vp;
1473         char            *tc, *ts;
1474         signed char     tag;
1475         int             found_tag;
1476         char            buffer[64];
1477         const char      *attrname = attribute;
1478
1479         /*
1480          *    Check for tags in 'Attribute:Tag' format.
1481          */
1482         found_tag = 0;
1483         tag = 0;
1484
1485         ts = strrchr(attribute, ':');
1486         if (ts && !ts[1]) {
1487                 fr_strerror_printf("Invalid tag for attribute %s", attribute);
1488                 return NULL;
1489         }
1490
1491         if (ts && ts[1]) {
1492                 strlcpy(buffer, attribute, sizeof(buffer));
1493                 attrname = buffer;
1494                 ts = strrchr(attrname, ':');
1495
1496                  /* Colon found with something behind it */
1497                  if (ts[1] == '*' && ts[2] == 0) {
1498                          /* Wildcard tag for check items */
1499                          tag = TAG_ANY;
1500                          *ts = 0;
1501                  } else if ((ts[1] >= '0') && (ts[1] <= '9')) {
1502                          /* It's not a wild card tag */
1503                          tag = strtol(ts + 1, &tc, 0);
1504                          if (tc && !*tc && TAG_VALID_ZERO(tag))
1505                                  *ts = 0;
1506                          else tag = 0;
1507                  } else {
1508                          fr_strerror_printf("Invalid tag for attribute %s", attribute);
1509                          return NULL;
1510                  }
1511                  found_tag = 1;
1512         }
1513
1514         /*
1515          *      It's not found in the dictionary, so we use
1516          *      another method to create the attribute.
1517          */
1518         if ((da = dict_attrbyname(attrname)) == NULL) {
1519                 return pairmake_any(attrname, value, operator);
1520         }
1521
1522         if ((vp = pairalloc(da)) == NULL) {
1523                 fr_strerror_printf("out of memory");
1524                 return NULL;
1525         }
1526         vp->operator = (operator == 0) ? T_OP_EQ : operator;
1527
1528         /*      Check for a tag in the 'Merit' format of:
1529          *      :Tag:Value.  Print an error if we already found
1530          *      a tag in the Attribute.
1531          */
1532
1533         if (value && (*value == ':' && da->flags.has_tag)) {
1534                 /* If we already found a tag, this is invalid */
1535                 if(found_tag) {
1536                         fr_strerror_printf("Duplicate tag %s for attribute %s",
1537                                    value, vp->name);
1538                         DEBUG("Duplicate tag %s for attribute %s\n",
1539                                    value, vp->name);
1540                         pairbasicfree(vp);
1541                         return NULL;
1542                 }
1543                 /* Colon found and attribute allows a tag */
1544                 if (value[1] == '*' && value[2] == ':') {
1545                        /* Wildcard tag for check items */
1546                        tag = TAG_ANY;
1547                        value += 3;
1548                 } else {
1549                        /* Real tag */
1550                        tag = strtol(value + 1, &tc, 0);
1551                        if (tc && *tc==':' && TAG_VALID_ZERO(tag))
1552                             value = tc + 1;
1553                        else tag = 0;
1554                 }
1555                 found_tag = 1;
1556         }
1557
1558         if (found_tag) {
1559           vp->flags.tag = tag;
1560         }
1561
1562         switch (vp->operator) {
1563         default:
1564                 break;
1565
1566                 /*
1567                  *      For =* and !* operators, the value is irrelevant
1568                  *      so we return now.
1569                  */
1570         case T_OP_CMP_TRUE:
1571         case T_OP_CMP_FALSE:
1572                 vp->vp_strvalue[0] = '\0';
1573                 vp->length = 0;
1574                 return vp;
1575                 break;
1576
1577                 /*
1578                  *      Regular expression comparison of integer attributes
1579                  *      does a STRING comparison of the names of their
1580                  *      integer attributes.
1581                  */
1582         case T_OP_REG_EQ:       /* =~ */
1583         case T_OP_REG_NE:       /* !~ */
1584                 if (!value) {
1585                         fr_strerror_printf("No regular expression found in %s",
1586                                            vp->name);
1587                         pairbasicfree(vp);
1588                         return NULL;
1589                 }
1590
1591                 strlcpy(vp->vp_strvalue, value, sizeof(vp->vp_strvalue));
1592                 vp->length = strlen(vp->vp_strvalue);
1593                 /*
1594                  *      If anything goes wrong, this is a run-time error,
1595                  *      not a compile-time error.
1596                  */
1597                 return vp;
1598
1599         }
1600
1601         /*
1602          *      FIXME: if (strcasecmp(attribute, vp->name) != 0)
1603          *      then the user MAY have typed in the attribute name
1604          *      as Vendor-%d-Attr-%d, and the value MAY be octets.
1605          *
1606          *      We probably want to fix pairparsevalue to accept
1607          *      octets as values for any attribute.
1608          */
1609         if (value && (pairparsevalue(vp, value) == NULL)) {
1610                 pairbasicfree(vp);
1611                 return NULL;
1612         }
1613
1614         return vp;
1615 }
1616
1617
1618 /*
1619  *      [a-zA-Z0-9_-:]+
1620  */
1621 static const int valid_attr_name[256] = {
1622         0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1623         0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1624         0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0,
1625         1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0,
1626         0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1627         1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 1,
1628         0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1629         1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0,
1630         0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1631         0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1632         0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1633         0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1634         0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1635         0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1636         0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1637         0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
1638 };
1639
1640 /*
1641  *      Read a valuepair from a buffer, and advance pointer.
1642  *      Sets *eol to T_EOL if end of line was encountered.
1643  */
1644 VALUE_PAIR *pairread(const char **ptr, FR_TOKEN *eol)
1645 {
1646         char            buf[64];
1647         char            attr[64];
1648         char            value[1024], *q;
1649         const char      *p;
1650         FR_TOKEN        token, t, xlat;
1651         VALUE_PAIR      *vp;
1652         size_t          len;
1653
1654         *eol = T_OP_INVALID;
1655
1656         p = *ptr;
1657         while ((*p == ' ') || (*p == '\t')) p++;
1658
1659         if (!*p) {
1660                 *eol = T_OP_INVALID;
1661                 fr_strerror_printf("No token read where we expected an attribute name");
1662                 return NULL;
1663         }
1664
1665         if (*p == '#') {
1666                 *eol = T_HASH;
1667                 fr_strerror_printf("Read a comment instead of a token");
1668                 return NULL;
1669         }
1670
1671         q = attr;
1672         for (len = 0; len < sizeof(attr); len++) {
1673                 if (valid_attr_name[(int)*p]) {
1674                         *q++ = *p++;
1675                         continue;
1676                 }
1677                 break;
1678         }
1679
1680         if (len == sizeof(attr)) {
1681                 *eol = T_OP_INVALID;
1682                 fr_strerror_printf("Attribute name is too long");
1683                 return NULL;
1684         }
1685
1686         /*
1687          *      We may have Foo-Bar:= stuff, so back up.
1688          */
1689         if ((len > 0) && (attr[len - 1] == ':')) {
1690                 p--;
1691                 len--;
1692         }
1693
1694         attr[len] = '\0';
1695         *ptr = p;
1696
1697         /* Now we should have an operator here. */
1698         token = gettoken(ptr, buf, sizeof(buf));
1699         if (token < T_EQSTART || token > T_EQEND) {
1700                 fr_strerror_printf("expecting operator");
1701                 return NULL;
1702         }
1703
1704         /* Read value.  Note that empty string values are allowed */
1705         xlat = gettoken(ptr, value, sizeof(value));
1706         if (xlat == T_EOL) {
1707                 fr_strerror_printf("failed to get value");
1708                 return NULL;
1709         }
1710
1711         /*
1712          *      Peek at the next token. Must be T_EOL, T_COMMA, or T_HASH
1713          */
1714         p = *ptr;
1715         t = gettoken(&p, buf, sizeof(buf));
1716         if (t != T_EOL && t != T_COMMA && t != T_HASH) {
1717                 fr_strerror_printf("Expected end of line or comma");
1718                 return NULL;
1719         }
1720
1721         *eol = t;
1722         if (t == T_COMMA) {
1723                 *ptr = p;
1724         }
1725
1726         vp = NULL;
1727         switch (xlat) {
1728                 /*
1729                  *      Make the full pair now.
1730                  */
1731         default:
1732                 vp = pairmake(attr, value, token);
1733                 break;
1734
1735                 /*
1736                  *      Perhaps do xlat's
1737                  */
1738         case T_DOUBLE_QUOTED_STRING:
1739                 p = strchr(value, '%');
1740                 if (p && (p[1] == '{')) {
1741                         if (strlen(value) >= sizeof(vp->vp_strvalue)) {
1742                                 fr_strerror_printf("Value too long");
1743                                 return NULL;
1744                         }
1745                         vp = pairmake(attr, NULL, token);
1746                         if (!vp) {
1747                                 *eol = T_OP_INVALID;
1748                                 return NULL;
1749                         }
1750
1751                         strlcpy(vp->vp_strvalue, value, sizeof(vp->vp_strvalue));
1752                         vp->flags.do_xlat = 1;
1753                         vp->length = 0;
1754                 } else {
1755                         /*
1756                          *      Parse && escape it, as defined by the
1757                          *      data type.
1758                          */
1759                         vp = pairmake(attr, value, token);
1760                         if (!vp) {
1761                                 *eol = T_OP_INVALID;
1762                                 return NULL;
1763                         }
1764                 }
1765                 break;
1766
1767         case T_SINGLE_QUOTED_STRING:
1768                 vp = pairmake(attr, NULL, token);
1769                 if (!vp) {
1770                         *eol = T_OP_INVALID;
1771                         return NULL;
1772                 }
1773
1774                 /*
1775                  *      String and octet types get copied verbatim.
1776                  */
1777                 if ((vp->type == PW_TYPE_STRING) ||
1778                     (vp->type == PW_TYPE_OCTETS)) {
1779                         strlcpy(vp->vp_strvalue, value,
1780                                 sizeof(vp->vp_strvalue));
1781                         vp->length = strlen(vp->vp_strvalue);
1782
1783                         /*
1784                          *      Everything else gets parsed: it's
1785                          *      DATA, not a string!
1786                          */
1787                 } else if (!pairparsevalue(vp, value)) {
1788                         pairfree(&vp);
1789                         *eol = T_OP_INVALID;
1790                         return NULL;
1791                 }
1792                 break;
1793
1794                 /*
1795                  *      Mark the pair to be allocated later.
1796                  */
1797         case T_BACK_QUOTED_STRING:
1798                 if (strlen(value) >= sizeof(vp->vp_strvalue)) {
1799                         fr_strerror_printf("Value too long");
1800                         return NULL;
1801                 }
1802
1803                 vp = pairmake(attr, NULL, token);
1804                 if (!vp) {
1805                         *eol = T_OP_INVALID;
1806                         return NULL;
1807                 }
1808
1809                 vp->flags.do_xlat = 1;
1810                 strlcpy(vp->vp_strvalue, value, sizeof(vp->vp_strvalue));
1811                 vp->length = 0;
1812                 break;
1813         }
1814
1815         /*
1816          *      If we didn't make a pair, return an error.
1817          */
1818         if (!vp) {
1819                 *eol = T_OP_INVALID;
1820                 return NULL;
1821         }
1822
1823         return vp;
1824 }
1825
1826 /*
1827  *      Read one line of attribute/value pairs. This might contain
1828  *      multiple pairs seperated by comma's.
1829  */
1830 FR_TOKEN userparse(const char *buffer, VALUE_PAIR **first_pair)
1831 {
1832         VALUE_PAIR      *vp;
1833         const char      *p;
1834         FR_TOKEN        last_token = T_OP_INVALID;
1835         FR_TOKEN        previous_token;
1836
1837         /*
1838          *      We allow an empty line.
1839          */
1840         if (buffer[0] == 0)
1841                 return T_EOL;
1842
1843         p = buffer;
1844         do {
1845                 previous_token = last_token;
1846                 if ((vp = pairread(&p, &last_token)) == NULL) {
1847                         return last_token;
1848                 }
1849                 pairadd(first_pair, vp);
1850         } while (*p && (last_token == T_COMMA));
1851
1852         /*
1853          *      Don't tell the caller that there was a comment.
1854          */
1855         if (last_token == T_HASH) {
1856                 return previous_token;
1857         }
1858
1859         /*
1860          *      And return the last token which we read.
1861          */
1862         return last_token;
1863 }
1864
1865 /*
1866  *      Read valuepairs from the fp up to End-Of-File.
1867  *
1868  *      Hmm... this function is only used by radclient..
1869  */
1870 VALUE_PAIR *readvp2(FILE *fp, int *pfiledone, const char *errprefix)
1871 {
1872         char buf[8192];
1873         FR_TOKEN last_token = T_EOL;
1874         VALUE_PAIR *vp;
1875         VALUE_PAIR *list;
1876         int error = 0;
1877
1878         list = NULL;
1879
1880         while (!error && fgets(buf, sizeof(buf), fp) != NULL) {
1881                 /*
1882                  *      If we get a '\n' by itself, we assume that's
1883                  *      the end of that VP
1884                  */
1885                 if ((buf[0] == '\n') && (list)) {
1886                         return list;
1887                 }
1888                 if ((buf[0] == '\n') && (!list)) {
1889                         continue;
1890                 }
1891
1892                 /*
1893                  *      Comments get ignored
1894                  */
1895                 if (buf[0] == '#') continue;
1896
1897                 /*
1898                  *      Read all of the attributes on the current line.
1899                  */
1900                 vp = NULL;
1901                 last_token = userparse(buf, &vp);
1902                 if (!vp) {
1903                         if (last_token != T_EOL) {
1904                                 fr_perror("%s", errprefix);
1905                                 error = 1;
1906                                 break;
1907                         }
1908                         break;
1909                 }
1910
1911                 pairadd(&list, vp);
1912                 buf[0] = '\0';
1913         }
1914
1915         if (error) pairfree(&list);
1916
1917         *pfiledone = 1;
1918
1919         return error ? NULL: list;
1920 }
1921
1922
1923
1924 /*
1925  *      Compare two pairs, using the operator from "one".
1926  *
1927  *      i.e. given two attributes, it does:
1928  *
1929  *      (two->data) (one->operator) (one->data)
1930  *
1931  *      e.g. "foo" != "bar"
1932  *
1933  *      Returns true (comparison is true), or false (comparison is not true);
1934  *
1935  *      FIXME: Ignores tags!
1936  */
1937 int paircmp(VALUE_PAIR *one, VALUE_PAIR *two)
1938 {
1939         int compare;
1940
1941         switch (one->operator) {
1942         case T_OP_CMP_TRUE:
1943                 return (two != NULL);
1944
1945         case T_OP_CMP_FALSE:
1946                 return (two == NULL);
1947
1948                 /*
1949                  *      One is a regex, compile it, print two to a string,
1950                  *      and then do string comparisons.
1951                  */
1952         case T_OP_REG_EQ:
1953         case T_OP_REG_NE:
1954 #ifndef HAVE_REGEX_H
1955                 return -1;
1956 #else
1957                 {
1958                         regex_t reg;
1959                         char buffer[MAX_STRING_LEN * 4 + 1];
1960
1961                         compare = regcomp(&reg, one->vp_strvalue,
1962                                           REG_EXTENDED);
1963                         if (compare != 0) {
1964                                 regerror(compare, &reg, buffer, sizeof(buffer));
1965                                 fr_strerror_printf("Illegal regular expression in attribute: %s: %s",
1966                                            one->name, buffer);
1967                                 return -1;
1968                         }
1969
1970                         vp_prints_value(buffer, sizeof(buffer), two, 0);
1971
1972                         /*
1973                          *      Don't care about substring matches,
1974                          *      oh well...
1975                          */
1976                         compare = regexec(&reg, buffer, 0, NULL, 0);
1977
1978                         regfree(&reg);
1979                         if (one->operator == T_OP_REG_EQ) return (compare == 0);
1980                         return (compare != 0);
1981                 }
1982 #endif
1983
1984         default:                /* we're OK */
1985                 break;
1986         }
1987
1988         /*
1989          *      After doing the previous check for special comparisons,
1990          *      do the per-type comparison here.
1991          */
1992         switch (one->type) {
1993         case PW_TYPE_ABINARY:
1994         case PW_TYPE_OCTETS:
1995         {
1996                 size_t length;
1997
1998                 if (one->length < two->length) {
1999                         length = one->length;
2000                 } else {
2001                         length = two->length;
2002                 }
2003
2004                 if (length) {
2005                         compare = memcmp(two->vp_octets, one->vp_octets,
2006                                          length);
2007                         if (compare != 0) break;
2008                 }
2009
2010                 /*
2011                  *      Contents are the same.  The return code
2012                  *      is therefore the difference in lengths.
2013                  *
2014                  *      i.e. "0x00" is smaller than "0x0000"
2015                  */
2016                 compare = two->length - one->length;
2017         }
2018                 break;
2019
2020         case PW_TYPE_STRING:
2021                 compare = strcmp(two->vp_strvalue, one->vp_strvalue);
2022                 break;
2023
2024         case PW_TYPE_BYTE:
2025         case PW_TYPE_SHORT:
2026         case PW_TYPE_INTEGER:
2027         case PW_TYPE_DATE:
2028                 compare = two->vp_integer - one->vp_integer;
2029                 break;
2030
2031         case PW_TYPE_IPADDR:
2032                 compare = ntohl(two->vp_ipaddr) - ntohl(one->vp_ipaddr);
2033                 break;
2034
2035         case PW_TYPE_IPV6ADDR:
2036                 compare = memcmp(&two->vp_ipv6addr, &one->vp_ipv6addr,
2037                                  sizeof(two->vp_ipv6addr));
2038                 break;
2039
2040         case PW_TYPE_IPV6PREFIX:
2041                 compare = memcmp(&two->vp_ipv6prefix, &one->vp_ipv6prefix,
2042                                  sizeof(two->vp_ipv6prefix));
2043                 break;
2044
2045         case PW_TYPE_IFID:
2046                 compare = memcmp(&two->vp_ifid, &one->vp_ifid,
2047                                  sizeof(two->vp_ifid));
2048                 break;
2049
2050         default:
2051                 return 0;       /* unknown type */
2052         }
2053
2054         /*
2055          *      Now do the operator comparison.
2056          */
2057         switch (one->operator) {
2058         case T_OP_CMP_EQ:
2059                 return (compare == 0);
2060
2061         case T_OP_NE:
2062                 return (compare != 0);
2063
2064         case T_OP_LT:
2065                 return (compare < 0);
2066
2067         case T_OP_GT:
2068                 return (compare > 0);
2069
2070         case T_OP_LE:
2071                 return (compare <= 0);
2072
2073         case T_OP_GE:
2074                 return (compare >= 0);
2075
2076         default:
2077                 return 0;
2078         }
2079
2080         return 0;
2081 }