1 /*- 2 * SPDX-License-Identifier: BSD-2-Clause-FreeBSD 3 * 4 * Copyright (c) 2003 Poul-Henning Kamp 5 * All rights reserved. 6 * 7 * Redistribution and use in source and binary forms, with or without 8 * modification, are permitted provided that the following conditions 9 * are met: 10 * 1. Redistributions of source code must retain the above copyright 11 * notice, this list of conditions and the following disclaimer. 12 * 2. Redistributions in binary form must reproduce the above copyright 13 * notice, this list of conditions and the following disclaimer in the 14 * documentation and/or other materials provided with the distribution. 15 * 3. The names of the authors may not be used to endorse or promote 16 * products derived from this software without specific prior written 17 * permission. 18 * 19 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND 20 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 21 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 22 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE 23 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 24 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 25 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 26 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 27 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 28 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 29 * SUCH DAMAGE. 30 * 31 * $FreeBSD$ 32 */ 33 34 #include <stdio.h> 35 #include <inttypes.h> 36 #include <stdlib.h> 37 #include <string.h> 38 #include <unistd.h> 39 #include <errno.h> 40 #include <fcntl.h> 41 #include <ctype.h> 42 #include <sys/stat.h> 43 #include <sys/mman.h> 44 #include <sys/queue.h> 45 #include <sys/sbuf.h> 46 #include <sys/sysctl.h> 47 #include <err.h> 48 #include <bsdxml.h> 49 #include <libgeom.h> 50 51 struct mystate { 52 struct gmesh *mesh; 53 struct gclass *class; 54 struct ggeom *geom; 55 struct gprovider *provider; 56 struct gconsumer *consumer; 57 int level; 58 struct sbuf *sbuf[20]; 59 struct gconf *config; 60 int nident; 61 XML_Parser parser; 62 int error; 63 }; 64 65 static void 66 StartElement(void *userData, const char *name, const char **attr) 67 { 68 struct mystate *mt; 69 void *id; 70 void *ref; 71 int i; 72 73 mt = userData; 74 mt->level++; 75 mt->sbuf[mt->level] = sbuf_new_auto(); 76 id = NULL; 77 ref = NULL; 78 for (i = 0; attr[i] != NULL; i += 2) { 79 if (!strcmp(attr[i], "id")) { 80 id = (void *)strtoul(attr[i + 1], NULL, 0); 81 mt->nident++; 82 } else if (!strcmp(attr[i], "ref")) { 83 ref = (void *)strtoul(attr[i + 1], NULL, 0); 84 } else 85 printf("%*.*s[%s = %s]\n", 86 mt->level + 1, mt->level + 1, "", 87 attr[i], attr[i + 1]); 88 } 89 if (!strcmp(name, "class") && mt->class == NULL) { 90 mt->class = calloc(1, sizeof *mt->class); 91 if (mt->class == NULL) { 92 mt->error = errno; 93 XML_StopParser(mt->parser, 0); 94 warn("Cannot allocate memory during processing of '%s' " 95 "element", name); 96 return; 97 } 98 mt->class->lg_id = id; 99 LIST_INSERT_HEAD(&mt->mesh->lg_class, mt->class, lg_class); 100 LIST_INIT(&mt->class->lg_geom); 101 LIST_INIT(&mt->class->lg_config); 102 return; 103 } 104 if (!strcmp(name, "geom") && mt->geom == NULL) { 105 mt->geom = calloc(1, sizeof *mt->geom); 106 if (mt->geom == NULL) { 107 mt->error = errno; 108 XML_StopParser(mt->parser, 0); 109 warn("Cannot allocate memory during processing of '%s' " 110 "element", name); 111 return; 112 } 113 mt->geom->lg_id = id; 114 LIST_INSERT_HEAD(&mt->class->lg_geom, mt->geom, lg_geom); 115 LIST_INIT(&mt->geom->lg_provider); 116 LIST_INIT(&mt->geom->lg_consumer); 117 LIST_INIT(&mt->geom->lg_config); 118 return; 119 } 120 if (!strcmp(name, "class") && mt->geom != NULL) { 121 mt->geom->lg_class = ref; 122 return; 123 } 124 if (!strcmp(name, "consumer") && mt->consumer == NULL) { 125 mt->consumer = calloc(1, sizeof *mt->consumer); 126 if (mt->consumer == NULL) { 127 mt->error = errno; 128 XML_StopParser(mt->parser, 0); 129 warn("Cannot allocate memory during processing of '%s' " 130 "element", name); 131 return; 132 } 133 mt->consumer->lg_id = id; 134 LIST_INSERT_HEAD(&mt->geom->lg_consumer, mt->consumer, 135 lg_consumer); 136 LIST_INIT(&mt->consumer->lg_config); 137 return; 138 } 139 if (!strcmp(name, "geom") && mt->consumer != NULL) { 140 mt->consumer->lg_geom = ref; 141 return; 142 } 143 if (!strcmp(name, "provider") && mt->consumer != NULL) { 144 mt->consumer->lg_provider = ref; 145 return; 146 } 147 if (!strcmp(name, "provider") && mt->provider == NULL) { 148 mt->provider = calloc(1, sizeof *mt->provider); 149 if (mt->provider == NULL) { 150 mt->error = errno; 151 XML_StopParser(mt->parser, 0); 152 warn("Cannot allocate memory during processing of '%s' " 153 "element", name); 154 return; 155 } 156 mt->provider->lg_id = id; 157 LIST_INSERT_HEAD(&mt->geom->lg_provider, mt->provider, 158 lg_provider); 159 LIST_INIT(&mt->provider->lg_consumers); 160 LIST_INIT(&mt->provider->lg_config); 161 return; 162 } 163 if (!strcmp(name, "geom") && mt->provider != NULL) { 164 mt->provider->lg_geom = ref; 165 return; 166 } 167 if (!strcmp(name, "config")) { 168 if (mt->provider != NULL) { 169 mt->config = &mt->provider->lg_config; 170 return; 171 } 172 if (mt->consumer != NULL) { 173 mt->config = &mt->consumer->lg_config; 174 return; 175 } 176 if (mt->geom != NULL) { 177 mt->config = &mt->geom->lg_config; 178 return; 179 } 180 if (mt->class != NULL) { 181 mt->config = &mt->class->lg_config; 182 return; 183 } 184 } 185 } 186 187 static void 188 EndElement(void *userData, const char *name) 189 { 190 struct mystate *mt; 191 struct gconf *c; 192 struct gconfig *gc; 193 char *p; 194 195 mt = userData; 196 p = NULL; 197 if (sbuf_finish(mt->sbuf[mt->level]) == 0) 198 p = strdup(sbuf_data(mt->sbuf[mt->level])); 199 sbuf_delete(mt->sbuf[mt->level]); 200 mt->sbuf[mt->level] = NULL; 201 mt->level--; 202 if (p == NULL) { 203 mt->error = errno; 204 XML_StopParser(mt->parser, 0); 205 warn("Cannot allocate memory during processing of '%s' " 206 "element", name); 207 return; 208 } 209 if (strlen(p) == 0) { 210 free(p); 211 p = NULL; 212 } 213 214 if (!strcmp(name, "name")) { 215 if (mt->provider != NULL) { 216 mt->provider->lg_name = p; 217 return; 218 } else if (mt->geom != NULL) { 219 mt->geom->lg_name = p; 220 return; 221 } else if (mt->class != NULL) { 222 mt->class->lg_name = p; 223 return; 224 } 225 } 226 if (!strcmp(name, "rank") && mt->geom != NULL) { 227 mt->geom->lg_rank = strtoul(p, NULL, 0); 228 free(p); 229 return; 230 } 231 if (!strcmp(name, "mode") && mt->provider != NULL) { 232 mt->provider->lg_mode = p; 233 return; 234 } 235 if (!strcmp(name, "mode") && mt->consumer != NULL) { 236 mt->consumer->lg_mode = p; 237 return; 238 } 239 if (!strcmp(name, "mediasize") && mt->provider != NULL) { 240 mt->provider->lg_mediasize = strtoumax(p, NULL, 0); 241 free(p); 242 return; 243 } 244 if (!strcmp(name, "sectorsize") && mt->provider != NULL) { 245 mt->provider->lg_sectorsize = strtoul(p, NULL, 0); 246 free(p); 247 return; 248 } 249 if (!strcmp(name, "stripesize") && mt->provider != NULL) { 250 mt->provider->lg_stripesize = strtoumax(p, NULL, 0); 251 free(p); 252 return; 253 } 254 if (!strcmp(name, "stripeoffset") && mt->provider != NULL) { 255 mt->provider->lg_stripeoffset = strtoumax(p, NULL, 0); 256 free(p); 257 return; 258 } 259 260 if (!strcmp(name, "config")) { 261 mt->config = NULL; 262 free(p); 263 return; 264 } 265 266 if (mt->config != NULL || (!strcmp(name, "wither") && 267 (mt->provider != NULL || mt->geom != NULL))) { 268 if (mt->config != NULL) 269 c = mt->config; 270 else if (mt->provider != NULL) 271 c = &mt->provider->lg_config; 272 else 273 c = &mt->geom->lg_config; 274 gc = calloc(1, sizeof *gc); 275 if (gc == NULL) { 276 mt->error = errno; 277 XML_StopParser(mt->parser, 0); 278 warn("Cannot allocate memory during processing of '%s' " 279 "element", name); 280 free(p); 281 return; 282 } 283 gc->lg_name = strdup(name); 284 if (gc->lg_name == NULL) { 285 mt->error = errno; 286 XML_StopParser(mt->parser, 0); 287 warn("Cannot allocate memory during processing of '%s' " 288 "element", name); 289 free(gc); 290 free(p); 291 return; 292 } 293 gc->lg_val = p; 294 LIST_INSERT_HEAD(c, gc, lg_config); 295 return; 296 } 297 298 if (p != NULL) { 299 #if DEBUG_LIBGEOM > 0 300 printf("Unexpected XML: name=%s data=\"%s\"\n", name, p); 301 #endif 302 free(p); 303 } 304 305 if (!strcmp(name, "consumer") && mt->consumer != NULL) { 306 mt->consumer = NULL; 307 return; 308 } 309 if (!strcmp(name, "provider") && mt->provider != NULL) { 310 mt->provider = NULL; 311 return; 312 } 313 if (!strcmp(name, "geom") && mt->consumer != NULL) { 314 return; 315 } 316 if (!strcmp(name, "geom") && mt->provider != NULL) { 317 return; 318 } 319 if (!strcmp(name, "geom") && mt->geom != NULL) { 320 mt->geom = NULL; 321 return; 322 } 323 if (!strcmp(name, "class") && mt->geom != NULL) { 324 return; 325 } 326 if (!strcmp(name, "class") && mt->class != NULL) { 327 mt->class = NULL; 328 return; 329 } 330 } 331 332 static void 333 CharData(void *userData , const XML_Char *s , int len) 334 { 335 struct mystate *mt; 336 const char *b, *e; 337 338 mt = userData; 339 340 b = s; 341 e = s + len - 1; 342 while (isspace(*b) && b < e) 343 b++; 344 while (isspace(*e) && e > b) 345 e--; 346 if (e != b || (*b && !isspace(*b))) 347 sbuf_bcat(mt->sbuf[mt->level], b, e - b + 1); 348 } 349 350 struct gident * 351 geom_lookupid(struct gmesh *gmp, const void *id) 352 { 353 struct gident *gip; 354 355 for (gip = gmp->lg_ident; gip->lg_id != NULL; gip++) 356 if (gip->lg_id == id) 357 return (gip); 358 return (NULL); 359 } 360 361 int 362 geom_xml2tree(struct gmesh *gmp, char *p) 363 { 364 XML_Parser parser; 365 struct mystate *mt; 366 struct gclass *cl; 367 struct ggeom *ge; 368 struct gprovider *pr; 369 struct gconsumer *co; 370 int error, i; 371 372 memset(gmp, 0, sizeof *gmp); 373 LIST_INIT(&gmp->lg_class); 374 parser = XML_ParserCreate(NULL); 375 if (parser == NULL) 376 return (ENOMEM); 377 mt = calloc(1, sizeof *mt); 378 if (mt == NULL) { 379 XML_ParserFree(parser); 380 return (ENOMEM); 381 } 382 mt->mesh = gmp; 383 mt->parser = parser; 384 error = 0; 385 XML_SetUserData(parser, mt); 386 XML_SetElementHandler(parser, StartElement, EndElement); 387 XML_SetCharacterDataHandler(parser, CharData); 388 i = XML_Parse(parser, p, strlen(p), 1); 389 if (mt->error != 0) 390 error = mt->error; 391 else if (i != 1) { 392 error = XML_GetErrorCode(parser) == XML_ERROR_NO_MEMORY ? 393 ENOMEM : EILSEQ; 394 } 395 XML_ParserFree(parser); 396 if (error != 0) { 397 free(mt); 398 return (error); 399 } 400 gmp->lg_ident = calloc(sizeof *gmp->lg_ident, mt->nident + 1); 401 free(mt); 402 if (gmp->lg_ident == NULL) 403 return (ENOMEM); 404 i = 0; 405 /* Collect all identifiers */ 406 LIST_FOREACH(cl, &gmp->lg_class, lg_class) { 407 gmp->lg_ident[i].lg_id = cl->lg_id; 408 gmp->lg_ident[i].lg_ptr = cl; 409 gmp->lg_ident[i].lg_what = ISCLASS; 410 i++; 411 LIST_FOREACH(ge, &cl->lg_geom, lg_geom) { 412 gmp->lg_ident[i].lg_id = ge->lg_id; 413 gmp->lg_ident[i].lg_ptr = ge; 414 gmp->lg_ident[i].lg_what = ISGEOM; 415 i++; 416 LIST_FOREACH(pr, &ge->lg_provider, lg_provider) { 417 gmp->lg_ident[i].lg_id = pr->lg_id; 418 gmp->lg_ident[i].lg_ptr = pr; 419 gmp->lg_ident[i].lg_what = ISPROVIDER; 420 i++; 421 } 422 LIST_FOREACH(co, &ge->lg_consumer, lg_consumer) { 423 gmp->lg_ident[i].lg_id = co->lg_id; 424 gmp->lg_ident[i].lg_ptr = co; 425 gmp->lg_ident[i].lg_what = ISCONSUMER; 426 i++; 427 } 428 } 429 } 430 /* Substitute all identifiers */ 431 LIST_FOREACH(cl, &gmp->lg_class, lg_class) { 432 LIST_FOREACH(ge, &cl->lg_geom, lg_geom) { 433 ge->lg_class = 434 geom_lookupid(gmp, ge->lg_class)->lg_ptr; 435 LIST_FOREACH(pr, &ge->lg_provider, lg_provider) { 436 pr->lg_geom = 437 geom_lookupid(gmp, pr->lg_geom)->lg_ptr; 438 } 439 LIST_FOREACH(co, &ge->lg_consumer, lg_consumer) { 440 co->lg_geom = 441 geom_lookupid(gmp, co->lg_geom)->lg_ptr; 442 if (co->lg_provider != NULL) { 443 co->lg_provider = 444 geom_lookupid(gmp, 445 co->lg_provider)->lg_ptr; 446 LIST_INSERT_HEAD( 447 &co->lg_provider->lg_consumers, 448 co, lg_consumers); 449 } 450 } 451 } 452 } 453 return (0); 454 } 455 456 int 457 geom_gettree(struct gmesh *gmp) 458 { 459 char *p; 460 int error; 461 462 p = geom_getxml(); 463 if (p == NULL) 464 return (errno); 465 error = geom_xml2tree(gmp, p); 466 free(p); 467 return (error); 468 } 469 470 static void 471 delete_config(struct gconf *gp) 472 { 473 struct gconfig *cf; 474 475 for (;;) { 476 cf = LIST_FIRST(gp); 477 if (cf == NULL) 478 return; 479 LIST_REMOVE(cf, lg_config); 480 free(cf->lg_name); 481 free(cf->lg_val); 482 free(cf); 483 } 484 } 485 486 void 487 geom_deletetree(struct gmesh *gmp) 488 { 489 struct gclass *cl; 490 struct ggeom *ge; 491 struct gprovider *pr; 492 struct gconsumer *co; 493 494 free(gmp->lg_ident); 495 gmp->lg_ident = NULL; 496 for (;;) { 497 cl = LIST_FIRST(&gmp->lg_class); 498 if (cl == NULL) 499 break; 500 LIST_REMOVE(cl, lg_class); 501 delete_config(&cl->lg_config); 502 if (cl->lg_name) free(cl->lg_name); 503 for (;;) { 504 ge = LIST_FIRST(&cl->lg_geom); 505 if (ge == NULL) 506 break; 507 LIST_REMOVE(ge, lg_geom); 508 delete_config(&ge->lg_config); 509 if (ge->lg_name) free(ge->lg_name); 510 for (;;) { 511 pr = LIST_FIRST(&ge->lg_provider); 512 if (pr == NULL) 513 break; 514 LIST_REMOVE(pr, lg_provider); 515 delete_config(&pr->lg_config); 516 if (pr->lg_name) free(pr->lg_name); 517 if (pr->lg_mode) free(pr->lg_mode); 518 free(pr); 519 } 520 for (;;) { 521 co = LIST_FIRST(&ge->lg_consumer); 522 if (co == NULL) 523 break; 524 LIST_REMOVE(co, lg_consumer); 525 delete_config(&co->lg_config); 526 if (co->lg_mode) free(co->lg_mode); 527 free(co); 528 } 529 free(ge); 530 } 531 free(cl); 532 } 533 } 534