usr/src/lib/libdscfg/common/cfg_local.c

   1 /*
   2  * CDDL HEADER START
   3  *
   4  * The contents of this file are subject to the terms of the
   5  * Common Development and Distribution License (the "License").
   6  * You may not use this file except in compliance with the License.
   7  *
   8  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
   9  * or http://www.opensolaris.org/os/licensing.
  10  * See the License for the specific language governing permissions
  11  * and limitations under the License.
  12  *
  13  * When distributing Covered Code, include this CDDL HEADER in each
  14  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
  15  * If applicable, add the following below this CDDL HEADER, with the
  16  * fields enclosed by brackets "[]" replaced with your own identifying
  17  * information: Portions Copyright [yyyy] [name of copyright owner]
  18  *
  19  * CDDL HEADER END
  20  */
  21 /*
  22  * Copyright 2008 Sun Microsystems, Inc.  All rights reserved.
  23  * Use is subject to license terms.
  24  */
  25
  26 #include <stdio.h>
  27
  28 #include <sys/types.h>
  29 #include <sys/vtoc.h>
  30 #include <sys/wait.h>
  31 #include <stdio.h>
  32 #include <sys/mnttab.h>
  33 #include <errno.h>
  34 #include <limits.h>
  35 #include <fcntl.h>
  36 #include <string.h>
  37 #include <strings.h>
  38 #include <stdlib.h>
  39 #include <unistd.h>
  40 #include <sys/mman.h>
  41
  42 #include <locale.h>
  43 #include <langinfo.h>
  44 #include <libintl.h>
  45 #include <stdarg.h>
  46 #include <netdb.h>
  47 #include <ctype.h>
  48 #include <sys/stat.h>
  49 #include <sys/utsname.h>
  50
  51 #include "cfg_impl.h"
  52 #include "cfg.h"
  53 #include "cfg_local.h"
  54
  55 #if 0
  56 #define DEBUG_CFGLIST
  57 #define DEBUG_CFGLISTRM
  58 #endif
  59
  60 extern  int     cfg_severity;
  61 extern  char    *cfg_perror_str;
  62
  63 long
  64 get_bsize(cfp_t *cfp, char *name)
  65 {
  66         char char_name[PATH_MAX];
  67         char *rest;
  68         struct vtoc vtoc;
  69         int slice;
  70         int fd;
  71
  72         if (strlen(name) >= PATH_MAX - 1)
  73                 return (0);
  74
  75         rest = strstr(name, "/dsk/");
  76         if (rest == NULL) {
  77                 if ((rest = strstr(name, "/rdsk/")) == NULL)
  78                         return (0);
  79                 strcpy(char_name, name);
  80                 goto do_open;
  81
  82         }
  83         strcpy(char_name, name);
  84         char_name[strlen(name) - strlen(rest)] = 0;
  85         strcat(char_name, "/rdsk/");
  86         strcat(char_name, rest + 5);
  87
  88 do_open:
  89         fd = open(char_name, O_RDONLY);
  90         if (fd < 0)
  91                 return (0);
  92
  93         slice = read_vtoc(fd, &vtoc);
  94         if (slice < 0) {
  95                 (void) close(fd);
  96                 return (0);
  97         }
  98
  99         (void) close(fd);
 100         if (vtoc.v_part[slice].p_start < CFG_VTOC_SIZE)
 101                 cfp->cf_flag |= CFG_NOWRVTOC;
 102
 103         return (vtoc.v_part[slice].p_size);
 104 }
 105
 106 /*
 107  * round up to the next block size
 108  */
 109 int
 110 get_block_size(int size)
 111 {
 112         int ret;
 113
 114         if (size % CFG_BLOCK_SIZE != 0)
 115                 ret = size + CFG_BLOCK_SIZE - (size % CFG_BLOCK_SIZE);
 116         else
 117                 ret = size;
 118         return (ret);
 119 }
 120
 121 /*
 122  * get a chunk of mem rounded up to next block size
 123  */
 124 char *
 125 get_block_buf(int size)
 126 {
 127         int blk_size;
 128         char *blk_buf;
 129
 130         blk_size = get_block_size(size);
 131
 132         if ((blk_buf = (char *)calloc(blk_size, sizeof (char))) == NULL) {
 133                 cfg_severity = CFG_EFATAL;
 134                 cfg_perror_str = dgettext("cfg", strerror(errno));
 135                 return (NULL);
 136         }
 137         return (blk_buf);
 138 }
 139
 140 void
 141 free_block_buf(char *buf)
 142 {
 143         if (buf)
 144                 free(buf);
 145 }
 146
 147 void
 148 localcf_close(cfp_t *cfp)
 149 {
 150         fsync(cfp->cf_fd);
 151         cfp_unlock(cfp);
 152         close(cfp->cf_fd);
 153 }
 154
 155
 156 /*
 157  * cfg_open
 158  * Open the current configuration file
 159  * Sets file descriptor in cfp->cf_fd for use by other routines
 160  */
 161 cfp_t *
 162 localcf_open(cfp_t *cfp, char *name)
 163 {
 164         struct stat sb;
 165         int rc;
 166
 167
 168         if (name == NULL) {
 169                 cfg_perror_str = dgettext("cfg",
 170                     "cfg_open: unable to open configuration location");
 171                 cfg_severity = CFG_EFATAL;
 172                 return (NULL);
 173         }
 174
 175         cfp->cf_fd = open(name, O_RDWR|O_CREAT|O_DSYNC|O_RSYNC, 0640);
 176         if (cfp->cf_fd == -1) {
 177                 if ((cfp->cf_fd = open(name, O_RDONLY, 0640)) == -1) {
 178                         cfg_perror_str = dgettext("cfg",
 179                             "cfg_open: unable to open configuration location");
 180                         cfg_severity = CFG_EFATAL;
 181                         return (NULL);
 182                 }
 183                 cfp->cf_flag |= CFG_RDONLY;
 184         }
 185
 186         if (fstat(cfp->cf_fd, &sb) == -1) {
 187                 close(cfp->cf_fd);
 188                 cfg_perror_str = dgettext("cfg",
 189                     "cfg_open: unable to stat configuration location");
 190                 cfg_severity = CFG_EFATAL;
 191                 return (NULL);
 192         }
 193
 194
 195         if (S_ISBLK(sb.st_mode) || S_ISCHR(sb.st_mode)) {
 196                 cfp->cf_size = get_bsize(cfp, name);
 197
 198                 /* skip the vtoc if necessary */
 199                 if (cfp->cf_flag & CFG_NOWRVTOC) {
 200                         do {
 201                                 rc = lseek(cfp->cf_fd, CFG_VTOC_SKIP, SEEK_SET);
 202                         } while (rc == -1 && errno == EINTR);
 203
 204                         if (rc == -1) {
 205                                 cfg_perror_str = dgettext("cfg",
 206                                     strerror(errno));
 207                                 cfg_severity = CFG_EFATAL;
 208                                 close(cfp->cf_fd);
 209                                 return (NULL);
 210                         }
 211                 }
 212
 213         } else if (S_ISREG(sb.st_mode)) {
 214                 cfp->cf_flag |= CFG_FILE;
 215                 cfp->cf_size = FBA_NUM(FBA_SIZE(1) - 1 + sb.st_size);
 216         } else {
 217                 cfg_perror_str = dgettext("cfg", "cfg_open: unknown file type");
 218                 cfg_severity = CFG_EFATAL;
 219                 close(cfp->cf_fd);
 220                 cfp->cf_fd = NULL;
 221                 return (NULL);
 222         }
 223         return (cfp);
 224 }
 225
 226 int
 227 localcf_seekblk(cfp_t *cfp, int off, int mode)
 228 {
 229         int rc;
 230
 231         do {
 232                 rc = lseek(cfp->cf_fd, off, mode);
 233         } while (rc == -1 && errno == EINTR);
 234
 235         return (rc);
 236 }
 237
 238 int
 239 localcf_readblk(cfp_t *cfp, void *buf, int size)
 240 {
 241         int rc;
 242
 243         do {
 244                 rc = read(cfp->cf_fd, buf, size);
 245         } while (rc == -1 && errno == EINTR);
 246
 247         return (rc);
 248 }
 249
 250 int
 251 localcf_writeblk(cfp_t *cfp, void *buf, int size)
 252 {
 253         int rc;
 254
 255         do {
 256                 rc = write(cfp->cf_fd, buf, size);
 257         } while (rc == -1 && errno == EINTR);
 258
 259         return (rc);
 260 }
 261
 262 int
 263 localcf_seek(cfp_t *cfp, int off, int mode)
 264 {
 265         int rc;
 266         int offset;
 267
 268         offset = get_block_size(off);
 269
 270         if ((mode == SEEK_SET) && (cfp->cf_flag & CFG_NOWRVTOC)) {
 271                 offset += CFG_VTOC_SKIP;
 272         }
 273
 274         do {
 275                 rc = lseek(cfp->cf_fd, offset, mode);
 276         } while (rc == -1 && errno == EINTR);
 277
 278         return (rc);
 279 }
 280
 281 int
 282 localcf_read(cfp_t *cfp, void *buf, int size)
 283 {
 284         int rc;
 285         int blk_size;
 286         char *blk_buf;
 287
 288         blk_size = get_block_size(size);
 289         if ((blk_buf = get_block_buf(size)) == NULL)
 290                 return (-1);
 291
 292         do {
 293                 rc = read(cfp->cf_fd, blk_buf, blk_size);
 294         } while (rc == -1 && errno == EINTR);
 295
 296         bcopy(blk_buf, buf, size);
 297         free_block_buf(blk_buf);
 298
 299         return (rc);
 300 }
 301
 302 int
 303 localcf_write(cfp_t *cfp, void *buf, int size)
 304 {
 305         int rc;
 306         int blk_size;
 307         char *blk_buf;
 308
 309         blk_size = get_block_size(size);
 310         if ((blk_buf = get_block_buf(size)) == NULL)
 311                 return (-1);
 312
 313         bcopy(buf, blk_buf, size);
 314
 315         do {
 316                 rc = write(cfp->cf_fd, blk_buf, blk_size);
 317         } while (rc == -1 && errno == EINTR);
 318
 319         free_block_buf(blk_buf);
 320
 321         return (rc);
 322 }
 323 /*
 324  * Routines which operate on internal version of configuration
 325  */
 326
 327 /*
 328  * Add entry to end  of configuration section
 329  */
 330
 331 int
 332 addcfline(cfp_t *cfp, char *line, int table_index)
 333 {
 334         int len = strlen(line)+1;
 335         int newsize = DEFAULT_ENTRY_SIZE / 2;
 336         cfgheader_t *hd;
 337         cfglist_t *cfl;
 338         char *q;
 339
 340 #ifdef DEBUG_CFGLIST
 341         fprintf(stderr, "addcfline: pre l_size %d h_cfgsizes[%d]"
 342             " %d l_free %u adding len %d\n",
 343             cfp->cf_head->h_cfgs[table_index].l_size, table_index,
 344             cfp->cf_head->h_cfgsizes[table_index],
 345             cfp->cf_head->h_cfgs[table_index].l_free, len);
 346 #endif
 347
 348         hd = cfp->cf_head;
 349         cfl = &cfp->cf_head->h_cfgs[table_index];
 350         if (cfl->l_free < len) {
 351
 352 #ifdef DEBUG_CFGLIST
 353                 fprintf(stderr, "resizing l_entry from %d to %d\n",
 354                     cfl->l_size + cfl->l_free, cfl->l_size +
 355                     cfl->l_free + newsize);
 356 #endif
 357                 cfl->l_entry = (char *)realloc(cfl->l_entry, (cfl->l_size +
 358                     cfl->l_free + newsize) * sizeof (char));
 359                 if (cfl->l_entry == NULL) {
 360                         errno = ENOMEM;
 361                         return (-1);
 362                 }
 363                 cfl->l_free += newsize;
 364
 365         }
 366         cfl->l_free -= len;
 367
 368         /* out of list slots, get some more */
 369         if (cfl->l_nentry % DEFAULT_NENTRIES == 0) {
 370                 /*
 371                  * first, figure out how much bigger, than realloc
 372                  */
 373
 374 #ifdef DEBUG_CFGLIST
 375                 fprintf(stderr,
 376                     "list %d getting more nentries, I have %d\n",
 377                     table_index, cfl->l_nentry);
 378 #endif
 379                 cfl->l_esiz = (int *)
 380                     realloc(cfl->l_esiz, (cfl->l_nentry + DEFAULT_NENTRIES) *
 381                     sizeof (int));
 382                 if (cfl->l_esiz == NULL) {
 383                         errno = ENOMEM;
 384                         return (-1);
 385                 }
 386         }
 387
 388
 389         cfl->l_esiz[cfl->l_nentry] = len;
 390         cfl->l_nentry++;
 391
 392         /* add line to end of list */
 393         q = cfl->l_entry + cfl->l_size;
 394
 395         strcpy(q, line);
 396         q += len;
 397
 398         /* set sizes */
 399         hd->h_cfgs[table_index].l_size += len;
 400         hd->h_cfgsizes[table_index] = cfl->l_size;
 401         cfp->cf_head->h_csize += len;
 402
 403 #ifdef DEBUG_CFGLIST
 404         fprintf(stderr, "addcfline: post l_size %d h_cfgsizes[%d]"
 405             " %d l_free %u\n h_csize %d\n",
 406             cfp->cf_head->h_cfgs[table_index].l_size,
 407             table_index, cfp->cf_head->h_cfgsizes[table_index],
 408             cfp->cf_head->h_cfgs[table_index].l_free, cfp->cf_head->h_csize);
 409 #endif
 410
 411         return (1);
 412 }
 413
 414 /*
 415  * remove entry from configuration section
 416  */
 417 int
 418 remcfline(cfp_t *cfp, int table_offset, int setnum)
 419 {
 420         cfgheader_t *ch;
 421         char *p, *q;
 422         int len;
 423         int copylen;
 424         int i;
 425         cfglist_t *cfl;
 426         ch = cfp->cf_head;
 427
 428         cfl = &cfp->cf_head->h_cfgs[table_offset];
 429
 430         q = cfl->l_entry;
 431
 432         if (cfl->l_size == 0) {
 433                 /* list is empty */
 434                 return (-1);
 435         }
 436
 437         if (!q) { /* somethings wrong here */
 438                 return (-1);
 439         }
 440
 441
 442         for (i = 1; i < setnum; i++) {
 443                 q += cfl->l_esiz[i - 1];
 444                 if (i >= cfl->l_nentry) { /* end of list */
 445                         return (-1);
 446                 }
 447         }
 448
 449         if (q >= cfl->l_entry + cfl->l_size)
 450                 return (-1);
 451
 452         len = cfl->l_esiz[i - 1];
 453
 454
 455 #ifdef DEBUG_CFGLISTRM
 456         fprintf(stderr, "remcfline: pre: l_size %d h_cfgsizes[%d] %d free %d"
 457             " removing len %d\n",
 458             ch->h_cfgs[table_offset].l_size, table_offset,
 459             ch->h_cfgsizes[table_offset],
 460             ch->h_cfgs[table_offset].l_free, len);
 461 #endif
 462
 463         p = q + len; /* next string */
 464
 465         if (!(p >= cfl->l_entry + cfl->l_size)) {
 466                 /* if we didn't delete the last string in list */
 467                 /* LINTED possible overflow */
 468                 copylen = cfl->l_entry + cfl->l_size - p;
 469                 bcopy(p, q, copylen);
 470                 copylen = (cfl->l_nentry - i) * sizeof (int);
 471                 bcopy(&cfl->l_esiz[i], &cfl->l_esiz[i - 1], copylen);
 472         }
 473
 474         /* decrement the number of sets in this list */
 475         cfl->l_nentry--;
 476         /* not really necessary, but.. */
 477         cfl->l_esiz[cfl->l_nentry] = 0;
 478
 479         cfl->l_size -= len;
 480         cfl->l_free += len;
 481
 482         p = cfl->l_entry + cfl->l_size;
 483         bzero(p, cfl->l_free);
 484
 485         ch->h_cfgsizes[table_offset] = cfl->l_size;
 486         ch->h_csize -= len;
 487
 488
 489 #ifdef DEBUG_CFGLIST
 490         fprintf(stderr,
 491             "remcfline: post: l_size %d h_cfgsizes[%d] %d free %d\n ",
 492             ch->h_cfgs[table_offset].l_size, table_offset,
 493             ch->h_cfgsizes[table_offset], ch->h_cfgs[table_offset].l_free);
 494 #endif
 495
 496         return (0);
 497
 498 }
 499 /*
 500  * Read entry from configuration section
 501  */
 502 char *
 503 readcfline(cfp_t *cfp, char *buf, int table_offset, int num)
 504 {
 505
 506         char *q;
 507         int i;
 508         cfgheader_t *ch;
 509         cfglist_t  *cfl;
 510
 511         /* this means they couldn't even find it in the parser tree */
 512         if (table_offset < 0)
 513                 return (NULL);
 514
 515         ch = cfp->cf_head;
 516         cfl = &ch->h_cfgs[table_offset];
 517
 518         q = cfl->l_entry;
 519
 520         for (i = 1; i < num; i++) {
 521                 q += cfl->l_esiz[i - 1];
 522                 if (i >= cfl->l_nentry) /* end of list */
 523                         return (NULL);
 524         }
 525
 526         if (q >= cfl->l_entry + cfl->l_size)
 527                 return (NULL);
 528         strcpy(buf, q);
 529         return (q);
 530 }
 531
 532
 533 /*
 534  * overwrite from current position with new value
 535  */
 536 int
 537 replacecfline(cfp_t *cfp, char *line, int table_offset, int num)
 538 {
 539 /*
 540  * take a table offset and a num to replace
 541  * index in, bump the list up, leaving a hole big
 542  * enough for the new string, or bcopying the rest of the list
 543  * down only leaving a hole big enough.
 544  * make sure not to overflow the
 545  * allocated list size.
 546  */
 547         cfgheader_t *ch;
 548         cfglist_t  *cfl;
 549         char *p, *q;
 550         int len = strlen(line) + 1;
 551         int diff = 0;
 552         int i;
 553         int newsize = DEFAULT_ENTRY_SIZE / 2;
 554
 555
 556         ch = cfp->cf_head;
 557         cfl = &ch->h_cfgs[table_offset];
 558
 559         q = cfl->l_entry;
 560         for (i = 1; i < num; i++) {
 561                 q += cfl->l_esiz[i - 1];
 562                 if (i >= cfl->l_nentry) /* end of list */
 563                         return (-1);
 564         }
 565         diff = len - cfl->l_esiz[i - 1];
 566         /* check for > 0, comparing uint to int */
 567         if ((diff > 0) && (diff > cfl->l_free)) {
 568                 /*
 569                  * we are going to overflow, get more mem, but only
 570                  * 1/2 as much as initial calloc, we don't need to be greedy
 571                  */
 572 #ifdef DEBUG_CFGLIST
 573                 fprintf(stderr,
 574                     "resizing at replacecfline from %d to %d \n",
 575                     cfl->l_size + cfl->l_free, cfl->l_size +
 576                     cfl->l_free + newsize);
 577 #endif
 578                 cfl->l_entry = (char *)realloc(cfl->l_entry,
 579                     (cfl->l_size + cfl->l_free + newsize) * sizeof (char));
 580                 if (cfl->l_entry == NULL) {
 581                         errno = ENOMEM;
 582                         return (-1);
 583                 }
 584                 cfl->l_free += (DEFAULT_ENTRY_SIZE / 2);
 585
 586                 /* re-find q, we could have a whole new chunk of memory here */
 587                 q = cfl->l_entry;
 588                 for (i = 1; i < num; i++) {
 589                         q += cfl->l_esiz[i - 1];
 590                         if (i >= cfl->l_nentry) /* end of list */
 591                                 return (-1);
 592                 }
 593         }
 594
 595         p = q + cfl->l_esiz[i - 1]; /* next string */
 596         cfl->l_esiz[i - 1] += diff; /* the new entry size */
 597         if (diff != 0) { /* move stuff over/back for correct fit */
 598                 /* LINTED possible overflow */
 599                 bcopy(p, p + diff, (cfl->l_entry + cfl->l_size - p));
 600                 cfl->l_free -= diff; /* 0 - (-1) = 1 */
 601                 cfl->l_size += diff;
 602
 603                 /* total of all h_cfgs[n].l_entry */
 604                 cfp->cf_head->h_csize += diff;
 605                 cfp->cf_head->h_cfgsizes[table_offset] = cfl->l_size; /* disk */
 606                 bzero((cfl->l_entry + cfl->l_size), cfl->l_free);
 607         }
 608
 609         strcpy(q, line);
 610         return (1);
 611
 612 }
 613
 614 static cfg_io_t _cfg_raw_io_def = {
 615         NULL,
 616         "Local",
 617         localcf_open,
 618         localcf_close,
 619         localcf_seek,
 620         localcf_read,
 621         localcf_write,
 622         readcfline,
 623         addcfline,
 624         remcfline,
 625         replacecfline,
 626
 627 };
 628
 629 static cfg_io_t _cfg_block_io_def = {
 630         NULL,
 631         "Local",
 632         localcf_open,
 633         localcf_close,
 634         localcf_seekblk,
 635         localcf_readblk,
 636         localcf_writeblk,
 637         readcfline,
 638         addcfline,
 639         remcfline,
 640         replacecfline,
 641 };
 642
 643 cfg_io_t *
 644 cfg_raw_io_provider(void)
 645 {
 646         return (&_cfg_raw_io_def);
 647 }
 648
 649 cfg_io_t *
 650 cfg_block_io_provider(void)
 651 {
 652         return (&_cfg_block_io_def);
 653 }