1 /* 2 * Copyright (c) 1990 Carnegie Mellon University 3 * All Rights Reserved. 4 * 5 * Permission to use, copy, modify and distribute this software and its 6 * documentation is hereby granted, provided that both the copyright 7 * notice and this permission notice appear in all copies of the 8 * software, derivative works or modified versions, and any portions 9 * thereof, and that both notices appear in supporting documentation. 10 * 11 * THE SOFTWARE IS PROVIDED "AS IS" AND CARNEGIE MELLON UNIVERSITY 12 * DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING ALL 13 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT 14 * SHALL CARNEGIE MELLON UNIVERSITY BE LIABLE FOR ANY SPECIAL, DIRECT, 15 * INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER 16 * RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF 17 * CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN 18 * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. 19 * 20 * Users of this software agree to return to Carnegie Mellon any 21 * improvements or extensions that they make and grant Carnegie the 22 * rights to redistribute these changes. 23 * 24 * Export of this software is permitted only after complying with the 25 * regulations of the U.S. Deptartment of Commerce relating to the 26 * Export of Technical Data. 27 */ 28 /* 29 * setpath --- smart interface for setting path variables 30 * 31 * usage: setpath(paths, cmds, localsyspath, dosuffix, printerrors) 32 * char **paths, **cmds, *localsyspath; 33 * int dosuffix, printerrors; 34 * 35 * The 'paths' argument is a list of pointers to path lists of the 36 * form "name=value" where name is the name of the path and value 37 * is a colon separated list of directories. There can never be 38 * more than MAXDIRS (64) directories in a path. 39 * 40 * The 'cmds' argument may be a sequence of any of the following: 41 * -r reset path to default 42 * -i newpath insert newpath before localsyspath 43 * -ia oldpath newpath insert newpath after oldpath 44 * -ib oldpath newpath insert newpath before oldpath 45 * -i# newpath insert newpath at position # 46 * -d oldpath delete oldpath 47 * -d# delete path at position # 48 * -c oldpath newpath change oldpath to newpath 49 * -c# newpath change position # to newpath 50 * 51 * The "-i newpath" command is equivilent to "-ib 'localsyspath' newpath". 52 * 53 * If 'dosuffix' is true, the appropriate suffix will be added to 54 * all command operands for any system path in 'paths'. 55 * 56 * Both of the 'paths' and 'cmds' lists are terminated by a NULL 57 * entry. 58 * 59 * if 'printerrors' is true, setpath will printf error diagnostics. 60 * 61 * WARNING !!!: Under no circumstances should anyone change this 62 * module without fully understanding the impact on the C shell. 63 * The C shell has it's own malloc and printf routines and this 64 * module was carefully written taking that into account. Do not 65 * use any stdio routines from this module except printf. 66 * 67 ********************************************************************** 68 * HISTORY 69 * 70 * Revision 1.4 90/12/11 17:58:44 mja 71 * Add copyright/disclaimer for distribution. 72 * 73 * 05-Jun-88 Glenn Marcy (gm0w) at Carnegie-Mellon University 74 * Make all non-entry points static. 75 * 76 * 30-Apr-88 Glenn Marcy (gm0w) at Carnegie-Mellon University 77 * Added -r switch to reset paths to their default values. 78 * 79 * 06-Jan-86 Glenn Marcy (gm0w) at Carnegie-Mellon University 80 * Created from old setpath program for the shell. 81 * 82 ********************************************************************** 83 */ 84 #include "sh.h" 85 RCSID("$tcsh: ma.setp.c,v 1.19 2007/11/20 20:03:51 christos Exp $") 86 87 #ifdef MACH 88 89 #define MAXDIRS 64 /* max directories on a path */ 90 #ifndef NULL 91 # define NULL 0 92 #endif 93 94 static int npaths; /* # pathlist arguments */ 95 96 static struct pelem { 97 struct pelem *pnext; /* pointer to next path */ 98 char *pname; /* name of pathlist */ 99 char *psuf; /* suffix for pathlist */ 100 char *pdef; /* default for pathlist */ 101 int pdirs; /* # directories on each pathlist */ 102 char *pdir[MAXDIRS]; /* directory names for each pathlist */ 103 } *pathhead = NULL; 104 105 static struct { 106 char *name; 107 char *suffix; 108 char *defalt; 109 } syspath[] = { 110 "PATH", "/bin", ":/usr/ucb:/bin:/usr/bin", 111 "CPATH", "/include", ":/usr/include", 112 "LPATH", "/lib", ":/lib:/usr/lib", 113 "MPATH", "/man", ":/usr/man", 114 "EPATH", "/maclib", "", 115 0, 0, 0 116 }; 117 118 static int sflag; 119 static int eflag; 120 121 #define INVALID { \ 122 if (eflag) xprintf(CGETS(10, 1, \ 123 "setpath: invalid command '%s'.\n"), cmd); \ 124 freepaths(); \ 125 return(-1); \ 126 } 127 128 #define TOOFEW { \ 129 if (eflag) xprintf(CGETS(10, 2, \ 130 "setpath: insufficient arguments to command '%s'.\n"), cmd); \ 131 freepaths(); \ 132 return(-1); \ 133 } 134 135 static int initpaths (char **); 136 static void savepaths (char **); 137 static void freepaths (void); 138 static void tcsh_rcmd (char *); 139 static void icmd (char *, char *); 140 static void iacmd (char *, char *); 141 static void ibcmd (char *, char *); 142 static void incmd (char *, int); 143 static void insert (struct pelem *, int, char *); 144 static void dcmd (char *); 145 static void dncmd (int); 146 static void delete (struct pelem *, int); 147 static void ccmd (char *, char *); 148 static void cncmd (char *, int); 149 static void change (struct pelem *, int, char *); 150 static int locate (struct pelem *, char *); 151 152 153 154 int 155 setpath(char **paths, char **cmds, char *localsyspath, int dosuffix, 156 int printerrors) 157 { 158 char *cmd, *cmd1, *cmd2; 159 int ncmd; 160 161 sflag = dosuffix; 162 eflag = printerrors; 163 if (initpaths(paths) < 0) 164 return(-1); 165 if (npaths == 0) 166 return(0); 167 for (ncmd = 0; cmd = cmds[ncmd]; ncmd++) { 168 if (cmd[0] != '-') 169 INVALID; 170 cmd1 = cmds[ncmd+1]; 171 cmd2 = cmds[ncmd+2]; 172 switch (cmd[1]) { 173 case 'r': 174 if (cmd[2] != '\0') 175 INVALID; 176 tcsh_rcmd(localsyspath); 177 break; 178 case 'i': 179 if (cmd[2] == '\0') { 180 ncmd++; 181 if (cmd1 == NULL) TOOFEW; 182 icmd(cmd1, localsyspath); 183 } else if (isdigit(cmd[2])) { 184 ncmd++; 185 if (cmd1 == NULL) TOOFEW; 186 incmd(cmd1, atoi(cmd+2)); 187 } else if (cmd[3] != '\0' || (cmd[2] != 'a' && cmd[2] != 'b')) { 188 INVALID; 189 } else { 190 ncmd += 2; 191 if (cmd1 == NULL || cmd2 == NULL) TOOFEW; 192 if (cmd[2] == 'a') 193 iacmd(cmd1, cmd2); 194 else 195 ibcmd(cmd1, cmd2); 196 } 197 break; 198 case 'd': 199 if (cmd[2] == '\0') { 200 ncmd++; 201 if (cmd1 == NULL) TOOFEW; 202 dcmd(cmd1); 203 } else if (isdigit(cmd[2])) 204 dncmd(atoi(cmd+2)); 205 else { 206 INVALID; 207 } 208 break; 209 case 'c': 210 if (cmd[2] == '\0') { 211 ncmd += 2; 212 if (cmd1 == NULL || cmd2 == NULL) TOOFEW; 213 ccmd(cmd1, cmd2); 214 } else if (isdigit(cmd[2])) { 215 ncmd++; 216 if (cmd1 == NULL) TOOFEW; 217 cncmd(cmd1, atoi(cmd+2)); 218 } else { 219 INVALID; 220 } 221 break; 222 default: 223 INVALID; 224 } 225 } 226 savepaths(paths); 227 freepaths(); 228 return(0); 229 } 230 231 static int 232 initpaths(char **paths) 233 { 234 char *path, *val, *p, *q; 235 int i, done; 236 struct pelem *pe, *pathend; 237 238 freepaths(); 239 for (npaths = 0; path = paths[npaths]; npaths++) { 240 val = index(path, '='); 241 if (val == NULL) { 242 if (eflag) 243 xprintf(CGETS(10, 3, 244 "setpath: value missing in path '%s'\n"), path); 245 freepaths(); 246 return(-1); 247 } 248 *val++ = '\0'; 249 pe = xmalloc(sizeof(struct pelem)); 250 setzero(pe, sizeof(struct pelem)); 251 if (pathhead == NULL) 252 pathhead = pathend = pe; 253 else { 254 pathend->pnext = pe; 255 pathend = pe; 256 } 257 p = strsave(path); 258 pe->pname = p; 259 pe->psuf = ""; 260 pe->pdef = ""; 261 for (i = 0; syspath[i].name; i++) 262 if (strcmp(pe->pname, syspath[i].name) == 0) { 263 pe->psuf = syspath[i].suffix; 264 pe->pdef = syspath[i].defalt; 265 break; 266 } 267 q = val; 268 for (;;) { 269 q = index(p = q, ':'); 270 done = (q == NULL); 271 if (!done) 272 *q++ = '\0'; 273 p = strsave(p); 274 pe->pdir[pe->pdirs] = p; 275 pe->pdirs++; 276 if (done) 277 break; 278 } 279 } 280 return(0); 281 } 282 283 static void 284 savepaths(char **paths) 285 { 286 char *p, *q; 287 int npath, i, len; 288 struct pelem *pe; 289 290 for (npath = 0, pe = pathhead; pe; npath++, pe = pe->pnext) { 291 len = strlen(pe->pname) + 1; 292 if (pe->pdirs == 0) 293 len++; 294 else for (i = 0; i < pe->pdirs; i++) 295 len += strlen(pe->pdir[i]) + 1; 296 p = xmalloc((unsigned)len); 297 paths[npath] = p; 298 for (q = pe->pname; *p = *q; p++, q++); 299 *p++ = '='; 300 if (pe->pdirs != 0) { 301 for (i = 0; i < pe->pdirs; i++) { 302 for (q = pe->pdir[i]; *p = *q; p++, q++); 303 *p++ = ':'; 304 } 305 p--; 306 } 307 *p = '\0'; 308 } 309 } 310 311 static void 312 freepaths(void) 313 { 314 char *p; 315 int i; 316 struct pelem *pe; 317 318 if (npaths == 0 || pathhead == NULL) 319 return; 320 while (pe = pathhead) { 321 if (pe->pname) { 322 for (i = 0; i < pe->pdirs; i++) { 323 if (pe->pdir[i] == NULL) 324 continue; 325 p = pe->pdir[i]; 326 pe->pdir[i] = NULL; 327 xfree((ptr_t) p); 328 } 329 pe->pdirs = 0; 330 p = pe->pname; 331 pe->pname = NULL; 332 xfree((ptr_t) p); 333 } 334 pathhead = pe->pnext; 335 xfree((ptr_t) pe); 336 } 337 npaths = 0; 338 } 339 340 /*********************************************** 341 *** R E S E T A P A T H N A M E *** 342 ***********************************************/ 343 344 static void 345 tcsh_rcmd(char *localsyspath) /* reset path with localsyspath */ 346 { 347 int n, done; 348 char *new, *p; 349 struct pelem *pe; 350 char newbuf[MAXPATHLEN+1];/*FIXBUF*/ 351 352 for (pe = pathhead; pe; pe = pe->pnext) { 353 new = newbuf; 354 *new = '\0'; 355 if (localsyspath != NULL) { 356 *new = ':'; 357 (void) strcpy(new + 1, localsyspath); 358 (void) strcat(new, pe->psuf); 359 } 360 (void) strcat(new, pe->pdef); 361 for (n = 0; n < pe->pdirs; n++) { 362 if (pe->pdir[n] == NULL) 363 continue; 364 p = pe->pdir[n]; 365 pe->pdir[n] = NULL; 366 xfree((ptr_t) p); 367 } 368 pe->pdirs = 0; 369 for (;;) { 370 new = index(p = new, ':'); 371 done = (new == NULL); 372 if (!done) 373 *new++ = '\0'; 374 p = strsave(p); 375 pe->pdir[pe->pdirs] = p; 376 pe->pdirs++; 377 if (done) 378 break; 379 } 380 } 381 } 382 383 /*********************************************** 384 *** I N S E R T A P A T H N A M E *** 385 ***********************************************/ 386 387 static void 388 icmd(char *path, char *localsyspath) /* insert path before localsyspath */ 389 { 390 int n; 391 char *new; 392 struct pelem *pe; 393 char newbuf[MAXPATHLEN+1];/*FIXBUF*/ 394 395 for (pe = pathhead; pe; pe = pe->pnext) { 396 if (sflag) 397 new = localsyspath; 398 else { 399 new = newbuf; 400 (void) strcpy(new, localsyspath); 401 (void) strcat(new, pe->psuf); 402 } 403 n = locate(pe, new); 404 if (n >= 0) 405 insert(pe, n, path); 406 else 407 insert(pe, 0, path); 408 } 409 } 410 411 static void 412 iacmd(char *inpath, char *path) /* insert path after inpath */ 413 { 414 int n; 415 struct pelem *pe; 416 417 for (pe = pathhead; pe; pe = pe->pnext) { 418 n = locate(pe, inpath); 419 if (n >= 0) 420 insert(pe, n + 1, path); 421 else 422 xprintf(CGETS(10, 4, "setpath: %s not found in %s\n"), 423 inpath, pe->pname); 424 } 425 } 426 427 static void 428 ibcmd(char *inpath, char *path) /* insert path before inpath */ 429 { 430 int n; 431 struct pelem *pe; 432 433 for (pe = pathhead; pe; pe = pe->pnext) { 434 n = locate(pe, inpath); 435 if (n >= 0) 436 insert(pe, n, path); 437 else 438 xprintf(CGETS(10, 4, "setpath: %s not found in %s\n"), 439 inpath, pe->pname); 440 } 441 } 442 443 static void 444 incmd(char *path, int n) /* insert path at position n */ 445 { 446 struct pelem *pe; 447 448 for (pe = pathhead; pe; pe = pe->pnext) 449 insert(pe, n, path); 450 } 451 452 static void 453 insert(struct pelem *pe, int loc, char *key) 454 { 455 int i; 456 char *new; 457 char newbuf[2000];/*FIXBUF*/ 458 459 if (sflag) { /* add suffix */ 460 new = newbuf; 461 (void) strcpy(new, key); 462 (void) strcat(new, pe->psuf); 463 } else 464 new = key; 465 new = strsave(new); 466 for (i = pe->pdirs; i > loc; --i) 467 pe->pdir[i] = pe->pdir[i-1]; 468 if (loc > pe->pdirs) 469 loc = pe->pdirs; 470 pe->pdir[loc] = new; 471 pe->pdirs++; 472 } 473 474 /*********************************************** 475 *** D E L E T E A P A T H N A M E *** 476 ***********************************************/ 477 478 static void 479 dcmd(char *path) /* delete path */ 480 { 481 int n; 482 struct pelem *pe; 483 484 for (pe = pathhead; pe; pe = pe->pnext) { 485 n = locate(pe, path); 486 if (n >= 0) 487 delete(pe, n); 488 else 489 xprintf(CGETS(10, 4, "setpath: %s not found in %s\n"), 490 path, pe->pname); 491 } 492 } 493 494 static void 495 dncmd(int n) /* delete at position n */ 496 { 497 struct pelem *pe; 498 499 for (pe = pathhead; pe; pe = pe->pnext) { 500 if (n < pe->pdirs) 501 delete(pe, n); 502 else 503 xprintf(CGETS(10, 5, 504 "setpath: %d not valid position in %s\n"), 505 n, pe->pname); 506 } 507 } 508 509 static void 510 delete(struct pelem *pe, int n) 511 { 512 int d; 513 514 xfree((ptr_t) (pe->pdir[n])); 515 for (d = n; d < pe->pdirs - 1; d++) 516 pe->pdir[d] = pe->pdir[d+1]; 517 --pe->pdirs; 518 } 519 520 /*********************************************** 521 *** C H A N G E A P A T H N A M E *** 522 ***********************************************/ 523 524 static void 525 ccmd(char *inpath, char *path) /* change inpath to path */ 526 { 527 int n; 528 struct pelem *pe; 529 530 for (pe = pathhead; pe; pe = pe->pnext) { 531 n = locate(pe, inpath); 532 if (n >= 0) 533 change(pe, n, path); 534 else 535 xprintf(CGETS(10, 4, "setpath: %s not found in %s\n"), 536 inpath, pe->pname); 537 } 538 } 539 540 static void 541 cncmd(char *path, int n) /* change at position n to path */ 542 { 543 struct pelem *pe; 544 545 for (pe = pathhead; pe; pe = pe->pnext) { 546 if (n < pe->pdirs) 547 change(pe, n, path); 548 else 549 xprintf(CGETS(10, 5, 550 "setpath: %d not valid position in %s\n"), 551 n, pe->pname); 552 } 553 } 554 555 static void 556 change(struct pelem *pe, int loc, char *key) 557 { 558 char *new; 559 char newbuf[MAXPATHLEN+1];/*FIXBUF*/ 560 561 if (sflag) { /* append suffix */ 562 new = newbuf; 563 (void) strcpy(new, key); 564 (void) strcat(new, pe->psuf); 565 } else 566 new = key; 567 new = strsave(new); 568 xfree((ptr_t) (pe->pdir[loc])); 569 pe->pdir[loc] = new; 570 } 571 572 /*************************************** 573 *** F I N D P A T H N A M E *** 574 ***************************************/ 575 576 static int 577 locate(struct pelem *pe, char *key) 578 { 579 int i; 580 char *realkey; 581 char keybuf[MAXPATHLEN+1];/*FIXBUF*/ 582 583 if (sflag) { 584 realkey = keybuf; 585 (void) strcpy(realkey, key); 586 (void) strcat(realkey, pe->psuf); 587 } else 588 realkey = key; 589 for (i = 0; i < pe->pdirs; i++) 590 if (strcmp(pe->pdir[i], realkey) == 0) 591 break; 592 return((i < pe->pdirs) ? i : -1); 593 } 594 #endif 595