usr.bin/mkcsmapper/yacc.y

   1 /* $FreeBSD$ */
   2 /*     $NetBSD: yacc.y,v 1.11 2016/06/28 09:22:16 wiz Exp $    */
   3
   4 %{
   5 /*-
   6  * SPDX-License-Identifier: BSD-2-Clause
   7  *
   8  * Copyright (c)2003, 2006 Citrus Project,
   9  * All rights reserved.
  10  *
  11  * Redistribution and use in source and binary forms, with or without
  12  * modification, are permitted provided that the following conditions
  13  * are met:
  14  * 1. Redistributions of source code must retain the above copyright
  15  *    notice, this list of conditions and the following disclaimer.
  16  * 2. Redistributions in binary form must reproduce the above copyright
  17  *    notice, this list of conditions and the following disclaimer in the
  18  *    documentation and/or other materials provided with the distribution.
  19  *
  20  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  21  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  22  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  23  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  24  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  25  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  26  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  27  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  28  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  29  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  30  * SUCH DAMAGE.
  31  */
  32
  33 #include <sys/cdefs.h>
  34 #include <sys/types.h>
  35
  36 #include <assert.h>
  37 #include <err.h>
  38 #include <errno.h>
  39 #include <limits.h>
  40 #include <stdio.h>
  41 #include <stdlib.h>
  42 #include <string.h>
  43 #include <unistd.h>
  44 #include <arpa/inet.h>
  45
  46 #include "ldef.h"
  47
  48 #ifndef __packed
  49 #define __packed
  50 #endif
  51
  52 #include "citrus_namespace.h"
  53 #include "citrus_types.h"
  54 #include "citrus_mapper_std_file.h"
  55 #include "citrus_region.h"
  56 #include "citrus_db_factory.h"
  57 #include "citrus_db_hash.h"
  58 #include "citrus_lookup_factory.h"
  59 #include "citrus_pivot_factory.h"
  60
  61 extern FILE             *yyin;
  62
  63 int                      debug = 0;
  64
  65 static linear_zone_t     rowcol[_CITRUS_MAPPER_STD_ROWCOL_MAX];
  66 static char             *map_name;
  67 static char             *output = NULL;
  68 static void             *table = NULL;
  69 static size_t            rowcol_len = 0;
  70 static size_t            table_size;
  71 static u_int32_t         done_flag = 0;
  72 static u_int32_t         dst_ilseq, dst_invalid, dst_unit_bits, oob_mode;
  73 static u_int32_t         rowcol_bits = 0, rowcol_mask = 0;
  74 static u_int32_t         src_next;
  75 static int               map_type;
  76 static void              (*putfunc)(void *, size_t, u_int32_t) = NULL;
  77
  78 #define DF_TYPE                 0x00000001
  79 #define DF_NAME                 0x00000002
  80 #define DF_SRC_ZONE             0x00000004
  81 #define DF_DST_INVALID          0x00000008
  82 #define DF_DST_ILSEQ            0x00000010
  83 #define DF_DST_UNIT_BITS        0x00000020
  84 #define DF_OOB_MODE             0x00000040
  85
  86 static void     dump_file(void);
  87 static void     setup_map(void);
  88 static void     set_type(int);
  89 static void     set_name(char *);
  90 static void     set_src_zone(u_int32_t);
  91 static void     set_dst_invalid(u_int32_t);
  92 static void     set_dst_ilseq(u_int32_t);
  93 static void     set_dst_unit_bits(u_int32_t);
  94 static void     set_oob_mode(u_int32_t);
  95 static int      check_src(u_int32_t, u_int32_t);
  96 static void     store(const linear_zone_t *, u_int32_t, int);
  97 static void     put8(void *, size_t, u_int32_t);
  98 static void     put16(void *, size_t, u_int32_t);
  99 static void     put32(void *, size_t, u_int32_t);
 100 static void     set_range(u_int32_t, u_int32_t);
 101 static void     set_src(linear_zone_t *, u_int32_t, u_int32_t);
 102 %}
 103
 104 %union {
 105         u_int32_t        i_value;
 106         char            *s_value;
 107         linear_zone_t    lz_value;
 108 }
 109
 110 %token                  R_TYPE R_NAME R_SRC_ZONE R_DST_UNIT_BITS
 111 %token                  R_DST_INVALID R_DST_ILSEQ
 112 %token                  R_BEGIN_MAP R_END_MAP R_INVALID R_ROWCOL
 113 %token                  R_ILSEQ R_OOB_MODE
 114 %token                  R_LN
 115 %token <i_value>        L_IMM
 116 %token <s_value>        L_STRING
 117
 118 %type <lz_value>        src
 119 %type <i_value>         dst types oob_mode_sel zone
 120
 121 %%
 122
 123 file            : property mapping lns
 124                 { dump_file(); }
 125
 126 property        : /* empty */
 127                 | property R_LN
 128                 | property name
 129                 | property type
 130                 | property src_zone
 131                 | property dst_invalid
 132                 | property dst_ilseq
 133                 | property dst_unit_bits
 134                 | property oob_mode
 135
 136 name            : R_NAME L_STRING { set_name($2); $2 = NULL; }
 137 type            : R_TYPE types { set_type($2); }
 138 types           : R_ROWCOL { $$ = R_ROWCOL; }
 139 range           : L_IMM '-' L_IMM { set_range($1, $3); }
 140
 141 ranges          : /* empty */
 142                 | ranges range '/'
 143
 144 src_zone        : R_SRC_ZONE zone { set_src_zone($2); }
 145 zone            : range {
 146                         $$ = 32;
 147                 }
 148                 | range '/' range '/' ranges L_IMM {
 149                         $$ = $6;
 150                 }
 151
 152 dst_invalid     : R_DST_INVALID L_IMM { set_dst_invalid($2); }
 153 dst_ilseq       : R_DST_ILSEQ L_IMM { set_dst_ilseq($2); }
 154 dst_unit_bits   : R_DST_UNIT_BITS L_IMM { set_dst_unit_bits($2); }
 155 oob_mode        : R_OOB_MODE oob_mode_sel { set_oob_mode($2); }
 156
 157 oob_mode_sel    : R_INVALID { $$ = _CITRUS_MAPPER_STD_OOB_NONIDENTICAL; }
 158                 | R_ILSEQ { $$ = _CITRUS_MAPPER_STD_OOB_ILSEQ; }
 159
 160 mapping         : begin_map map_elems R_END_MAP
 161 begin_map       : R_BEGIN_MAP lns { setup_map(); }
 162
 163 map_elems       : /* empty */
 164                 | map_elems map_elem lns
 165
 166 map_elem        : src '=' dst
 167                 { store(&$1, $3, 0); }
 168                 | src '=' L_IMM '-'
 169                 { store(&$1, $3, 1); }
 170 dst             : L_IMM
 171                 {
 172                         $$ = $1;
 173                 }
 174                 | R_INVALID
 175                 {
 176                         $$ = dst_invalid;
 177                 }
 178                 | R_ILSEQ
 179                 {
 180                         $$ = dst_ilseq;
 181                 }
 182
 183 src             : /* empty */
 184                 {
 185                         set_src(&$$, src_next, src_next);
 186                 }
 187                 | L_IMM
 188                 {
 189                         set_src(&$$, $1, $1);
 190                 }
 191                 | L_IMM '-' L_IMM
 192                 {
 193                         set_src(&$$, $1, $3);
 194                 }
 195                 | '-' L_IMM
 196                 {
 197                         set_src(&$$, src_next, $2);
 198                 }
 199 lns             : R_LN
 200                 | lns R_LN
 201
 202 %%
 203
 204 static void
 205 warning(const char *s)
 206 {
 207
 208         fprintf(stderr, "%s in %d\n", s, linenumber);
 209 }
 210
 211 int
 212 yyerror(const char *s)
 213 {
 214
 215         warning(s);
 216         exit(1);
 217 }
 218
 219 void
 220 put8(void *ptr, size_t ofs, u_int32_t val)
 221 {
 222
 223         *((u_int8_t *)ptr + ofs) = val;
 224 }
 225
 226 void
 227 put16(void *ptr, size_t ofs, u_int32_t val)
 228 {
 229
 230         u_int16_t oval = htons(val);
 231         memcpy((u_int16_t *)ptr + ofs, &oval, 2);
 232 }
 233
 234 void
 235 put32(void *ptr, size_t ofs, u_int32_t val)
 236 {
 237
 238         u_int32_t oval = htonl(val);
 239         memcpy((u_int32_t *)ptr + ofs, &oval, 4);
 240 }
 241
 242 static void
 243 alloc_table(void)
 244 {
 245         linear_zone_t *p;
 246         size_t i;
 247         uint32_t val = 0;
 248
 249         i = rowcol_len;
 250         p = &rowcol[--i];
 251         table_size = p->width;
 252         while (i > 0) {
 253                 p = &rowcol[--i];
 254                 table_size *= p->width;
 255         }
 256         table = (void *)malloc(table_size * dst_unit_bits / 8);
 257         if (table == NULL) {
 258                 perror("malloc");
 259                 exit(1);
 260         }
 261
 262         switch (oob_mode) {
 263         case _CITRUS_MAPPER_STD_OOB_NONIDENTICAL:
 264                 val = dst_invalid;
 265                 break;
 266         case _CITRUS_MAPPER_STD_OOB_ILSEQ:
 267                 val = dst_ilseq;
 268                 break;
 269         default:
 270                 break;
 271         }
 272         for (i = 0; i < table_size; i++)
 273                 (*putfunc)(table, i, val);
 274 }
 275
 276 static void
 277 setup_map(void)
 278 {
 279
 280         if ((done_flag & DF_SRC_ZONE)==0) {
 281                 fprintf(stderr, "SRC_ZONE is mandatory.\n");
 282                 exit(1);
 283         }
 284         if ((done_flag & DF_DST_UNIT_BITS)==0) {
 285                 fprintf(stderr, "DST_UNIT_BITS is mandatory.\n");
 286                 exit(1);
 287         }
 288
 289         if ((done_flag & DF_DST_INVALID) == 0)
 290                 dst_invalid = 0xFFFFFFFF;
 291         if ((done_flag & DF_DST_ILSEQ) == 0)
 292                 dst_ilseq = 0xFFFFFFFE;
 293         if ((done_flag & DF_OOB_MODE) == 0)
 294                 oob_mode = _CITRUS_MAPPER_STD_OOB_NONIDENTICAL;
 295
 296         alloc_table();
 297 }
 298
 299 static void
 300 create_rowcol_info(struct _region *r)
 301 {
 302         void *ptr;
 303         size_t i, len, ofs;
 304
 305         ofs = 0;
 306         ptr = malloc(_CITRUS_MAPPER_STD_ROWCOL_INFO_SIZE);
 307         if (ptr == NULL)
 308                 err(EXIT_FAILURE, "malloc");
 309         put32(ptr, ofs, rowcol_bits); ofs++;
 310         put32(ptr, ofs, dst_invalid); ofs++;
 311
 312         /* XXX: keep backward compatibility */
 313         switch (rowcol_len) {
 314         case 1:
 315                 put32(ptr, ofs, 0); ofs++;
 316                 put32(ptr, ofs, 0); ofs++;
 317         /*FALLTHROUGH*/
 318         case 2:
 319                 len = 0;
 320                 break;
 321         default:
 322                 len = rowcol_len;
 323         }
 324         for (i = 0; i < rowcol_len; ++i) {
 325                 put32(ptr, ofs, rowcol[i].begin); ofs++;
 326                 put32(ptr, ofs, rowcol[i].end); ofs++;
 327         }
 328         put32(ptr, ofs, dst_unit_bits); ofs++;
 329         put32(ptr, ofs, len); ofs++;
 330
 331         _region_init(r, ptr, ofs * 4);
 332 }
 333
 334
 335 static void
 336 create_rowcol_ext_ilseq_info(struct _region *r)
 337 {
 338         void *ptr;
 339         size_t ofs;
 340
 341         ofs = 0;
 342         ptr = malloc(_CITRUS_MAPPER_STD_ROWCOL_EXT_ILSEQ_SIZE);
 343         if (ptr == NULL)
 344                 err(EXIT_FAILURE, "malloc");
 345
 346         put32(ptr, ofs, oob_mode); ofs++;
 347         put32(ptr, ofs, dst_ilseq); ofs++;
 348
 349         _region_init(r, ptr, _CITRUS_MAPPER_STD_ROWCOL_EXT_ILSEQ_SIZE);
 350 }
 351
 352 #define CHKERR(ret, func, a)                                            \
 353 do {                                                                    \
 354         ret = func a;                                                   \
 355         if (ret)                                                        \
 356                 errx(EXIT_FAILURE, "%s: %s", #func, strerror(ret));     \
 357 } while (/*CONSTCOND*/0)
 358
 359 static void
 360 dump_file(void)
 361 {
 362         struct _db_factory *df;
 363         struct _region data;
 364         void *serialized;
 365         FILE *fp;
 366         size_t size;
 367         int ret;
 368
 369         /*
 370          * build database
 371          */
 372         CHKERR(ret, _db_factory_create, (&df, _db_hash_std, NULL));
 373
 374         /* store type */
 375         CHKERR(ret, _db_factory_addstr_by_s,
 376             (df, _CITRUS_MAPPER_STD_SYM_TYPE, _CITRUS_MAPPER_STD_TYPE_ROWCOL));
 377
 378         /* store info */
 379         create_rowcol_info(&data);
 380         CHKERR(ret, _db_factory_add_by_s,
 381             (df, _CITRUS_MAPPER_STD_SYM_INFO, &data, 1));
 382
 383         /* ilseq extension */
 384         create_rowcol_ext_ilseq_info(&data);
 385         CHKERR(ret, _db_factory_add_by_s,
 386             (df, _CITRUS_MAPPER_STD_SYM_ROWCOL_EXT_ILSEQ, &data, 1));
 387
 388         /* store table */
 389         _region_init(&data, table, table_size*dst_unit_bits/8);
 390         CHKERR(ret, _db_factory_add_by_s,
 391             (df, _CITRUS_MAPPER_STD_SYM_TABLE, &data, 1));
 392
 393         /*
 394          * dump database to file
 395          */
 396         fp = output ? fopen(output, "wb") : stdout;
 397
 398         if (fp == NULL) {
 399                 perror("fopen");
 400                 exit(1);
 401         }
 402
 403         /* dump database body */
 404         size = _db_factory_calc_size(df);
 405         serialized = malloc(size);
 406         _region_init(&data, serialized, size);
 407         CHKERR(ret, _db_factory_serialize,
 408             (df, _CITRUS_MAPPER_STD_MAGIC, &data));
 409         if (fwrite(serialized, size, 1, fp) != 1)
 410                 err(EXIT_FAILURE, "fwrite");
 411
 412         fclose(fp);
 413 }
 414
 415 static void
 416 /*ARGSUSED*/
 417 set_type(int type)
 418 {
 419
 420         if (done_flag & DF_TYPE) {
 421                 warning("TYPE is duplicated. ignored this one");
 422                 return;
 423         }
 424
 425         map_type = type;
 426
 427         done_flag |= DF_TYPE;
 428 }
 429
 430 static void
 431 /*ARGSUSED*/
 432 set_name(char *str)
 433 {
 434
 435         if (done_flag & DF_NAME) {
 436                 warning("NAME is duplicated. ignored this one");
 437                 return;
 438         }
 439
 440         map_name = str;
 441
 442         done_flag |= DF_NAME;
 443 }
 444
 445 static void
 446 set_src_zone(u_int32_t val)
 447 {
 448         linear_zone_t *p;
 449         size_t i;
 450
 451         if (done_flag & DF_SRC_ZONE) {
 452                 warning("SRC_ZONE is duplicated. ignored this one");
 453                 return;
 454         }
 455         rowcol_bits = val;
 456
 457         /* sanity check */
 458         switch (rowcol_bits) {
 459         case 8: case 16: case 32:
 460                 if (rowcol_len <= 32 / rowcol_bits)
 461                         break;
 462         /*FALLTHROUGH*/
 463         default:
 464                 goto bad;
 465         }
 466         rowcol_mask = 1 << (rowcol_bits - 1);
 467         rowcol_mask |= rowcol_mask - 1;
 468         for (i = 0; i < rowcol_len; ++i) {
 469                 p = &rowcol[i];
 470                 if (p->end > rowcol_mask)
 471                         goto bad;
 472         }
 473         done_flag |= DF_SRC_ZONE;
 474         return;
 475
 476 bad:
 477         yyerror("Illegal argument for SRC_ZONE");
 478 }
 479
 480 static void
 481 set_dst_invalid(u_int32_t val)
 482 {
 483
 484         if (done_flag & DF_DST_INVALID) {
 485                 warning("DST_INVALID is duplicated. ignored this one");
 486                 return;
 487         }
 488
 489         dst_invalid = val;
 490
 491         done_flag |= DF_DST_INVALID;
 492 }
 493
 494 static void
 495 set_dst_ilseq(u_int32_t val)
 496 {
 497
 498         if (done_flag & DF_DST_ILSEQ) {
 499                 warning("DST_ILSEQ is duplicated. ignored this one");
 500                 return;
 501         }
 502
 503         dst_ilseq = val;
 504
 505         done_flag |= DF_DST_ILSEQ;
 506 }
 507
 508 static void
 509 set_oob_mode(u_int32_t val)
 510 {
 511
 512         if (done_flag & DF_OOB_MODE) {
 513                 warning("OOB_MODE is duplicated. ignored this one");
 514                 return;
 515         }
 516
 517         oob_mode = val;
 518
 519         done_flag |= DF_OOB_MODE;
 520 }
 521
 522 static void
 523 set_dst_unit_bits(u_int32_t val)
 524 {
 525
 526         if (done_flag & DF_DST_UNIT_BITS) {
 527                 warning("DST_UNIT_BITS is duplicated. ignored this one");
 528                 return;
 529         }
 530
 531         switch (val) {
 532         case 8:
 533                 putfunc = &put8;
 534                 dst_unit_bits = val;
 535                 break;
 536         case 16:
 537                 putfunc = &put16;
 538                 dst_unit_bits = val;
 539                 break;
 540         case 32:
 541                 putfunc = &put32;
 542                 dst_unit_bits = val;
 543                 break;
 544         default:
 545                 yyerror("Illegal argument for DST_UNIT_BITS");
 546         }
 547         done_flag |= DF_DST_UNIT_BITS;
 548 }
 549
 550 static int
 551 check_src(u_int32_t begin, u_int32_t end)
 552 {
 553         linear_zone_t *p;
 554         size_t i;
 555         u_int32_t m, n;
 556
 557         if (begin > end)
 558                 return (1);
 559         if (begin < end) {
 560                 m = begin & ~rowcol_mask;
 561                 n = end & ~rowcol_mask;
 562                 if (m != n)
 563                         return (1);
 564         }
 565         for (i = rowcol_len * rowcol_bits, p = &rowcol[0]; i > 0; ++p) {
 566                 i -= rowcol_bits;
 567                 m = (begin >> i) & rowcol_mask;
 568                 if (m < p->begin || m > p->end)
 569                         return (1);
 570         }
 571         if (begin < end) {
 572                 n = end & rowcol_mask;
 573                 --p;
 574                 if (n < p->begin || n > p->end)
 575                         return (1);
 576         }
 577         return (0);
 578 }
 579
 580 static void
 581 store(const linear_zone_t *lz, u_int32_t dst, int inc)
 582 {
 583         linear_zone_t *p;
 584         size_t i, ofs;
 585         u_int32_t n;
 586
 587         ofs = 0;
 588         for (i = rowcol_len * rowcol_bits, p = &rowcol[0]; i > 0; ++p) {
 589                 i -= rowcol_bits;
 590                 n = ((lz->begin >> i) & rowcol_mask) - p->begin;
 591                 ofs = (ofs * p->width) + n;
 592         }
 593         n = lz->width;
 594         while (n-- > 0) {
 595                 (*putfunc)(table, ofs++, dst);
 596                 if (inc)
 597                         dst++;
 598         }
 599 }
 600
 601 static void
 602 set_range(u_int32_t begin, u_int32_t end)
 603 {
 604         linear_zone_t *p;
 605
 606         if (rowcol_len >= _CITRUS_MAPPER_STD_ROWCOL_MAX)
 607                 goto bad;
 608         p = &rowcol[rowcol_len++];
 609
 610         if (begin > end)
 611                 goto bad;
 612         p->begin = begin, p->end = end;
 613         p->width = end - begin + 1;
 614
 615         return;
 616
 617 bad:
 618         yyerror("Illegal argument for SRC_ZONE");
 619 }
 620
 621 static void
 622 set_src(linear_zone_t *lz, u_int32_t begin, u_int32_t end)
 623 {
 624
 625         if (check_src(begin, end) != 0)
 626                 yyerror("illegal zone");
 627
 628         lz->begin = begin, lz->end = end;
 629         lz->width = end - begin + 1;
 630
 631         src_next = end + 1;
 632 }
 633
 634 static void
 635 do_mkdb(FILE *in)
 636 {
 637         FILE *out;
 638         int ret;
 639
 640         /* dump DB to file */
 641         out = output ? fopen(output, "wb") : stdout;
 642
 643         if (out == NULL)
 644                 err(EXIT_FAILURE, "fopen");
 645
 646         ret = _lookup_factory_convert(out, in);
 647         fclose(out);
 648         if (ret && output)
 649                 unlink(output); /* dump failure */
 650 }
 651
 652 static void
 653 do_mkpv(FILE *in)
 654 {
 655         FILE *out;
 656         int ret;
 657
 658         /* dump pivot to file */
 659         out = output ? fopen(output, "wb") : stdout;
 660
 661         if (out == NULL)
 662                 err(EXIT_FAILURE, "fopen");
 663
 664         ret = _pivot_factory_convert(out, in);
 665         fclose(out);
 666         if (ret && output)
 667                 unlink(output); /* dump failure */
 668         if (ret)
 669                 errx(EXIT_FAILURE, "%s\n", strerror(ret));
 670 }
 671
 672 static void
 673 usage(void)
 674 {
 675         fprintf(stderr, "Usage: %s [-d] [-m|-p] [-o outfile] [infile]\n",
 676             getprogname());
 677         exit(EXIT_FAILURE);
 678 }
 679
 680 int
 681 main(int argc, char **argv)
 682 {
 683         FILE *in = NULL;
 684         int ch, mkdb = 0, mkpv = 0;
 685
 686         while ((ch = getopt(argc, argv, "do:mp")) != EOF) {
 687                 switch (ch) {
 688                 case 'd':
 689                         debug = 1;
 690                         break;
 691                 case 'o':
 692                         output = strdup(optarg);
 693                         break;
 694                 case 'm':
 695                         mkdb = 1;
 696                         break;
 697                 case 'p':
 698                         mkpv = 1;
 699                         break;
 700                 default:
 701                         usage();
 702                 }
 703         }
 704
 705         argc -= optind;
 706         argv += optind;
 707         switch (argc) {
 708         case 0:
 709                 in = stdin;
 710                 break;
 711         case 1:
 712                 in = fopen(argv[0], "r");
 713                 if (!in)
 714                         err(EXIT_FAILURE, "%s", argv[0]);
 715                 break;
 716         default:
 717                 usage();
 718         }
 719
 720         if (mkdb)
 721                 do_mkdb(in);
 722         else if (mkpv)
 723                 do_mkpv(in);
 724         else {
 725                 yyin = in;
 726                 yyparse();
 727         }
 728
 729         return (0);
 730 }