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