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