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