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, Version 1.0 only 6 * (the "License"). You may not use this file except in compliance 7 * with the License. 8 * 9 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE 10 * or http://www.opensolaris.org/os/licensing. 11 * See the License for the specific language governing permissions 12 * and limitations under the License. 13 * 14 * When distributing Covered Code, include this CDDL HEADER in each 15 * file and include the License file at usr/src/OPENSOLARIS.LICENSE. 16 * If applicable, add the following below this CDDL HEADER, with the 17 * fields enclosed by brackets "[]" replaced with your own identifying 18 * information: Portions Copyright [yyyy] [name of copyright owner] 19 * 20 * CDDL HEADER END 21 */ 22 /* Copyright (c) 1984, 1986, 1987, 1988, 1989 AT&T */ 23 /* All Rights Reserved */ 24 /* 25 * Copyright 2005 Sun Microsystems, Inc. All rights reserved. 26 * Use is subject to license terms. 27 */ 28 29 #pragma ident "%Z%%M% %I% %E% SMI" 30 31 32 #include <stdio.h> 33 #include <stdlib.h> 34 #include <strings.h> 35 #include <signal.h> 36 #include <sac.h> 37 #include <sys/types.h> 38 #include <sys/stat.h> 39 #include <unistd.h> 40 #include "misc.h" 41 #include "structs.h" 42 #include "extern.h" 43 44 45 /* 46 * error - print out an error message and die 47 * 48 * args: msg - message to be printed, Saferrno previously set 49 */ 50 51 void 52 error(msg) 53 char *msg; 54 { 55 (void) fprintf(stderr, "%s\n", msg); 56 quit(); 57 } 58 59 60 /* 61 * quit - exit the program with the status in Saferrno 62 */ 63 64 void 65 quit() 66 { 67 exit(Saferrno); 68 } 69 70 71 /* 72 * make_tempname - generate a temp name to be used for updating files. 73 * Names will be of the form HOME/xxx/.name, where HOME 74 * is from misc.h 75 * 76 * args: bname - the basename of the file. For example foo/_config 77 * will generate a tempname of HOME/foo/._config 78 */ 79 80 81 char * 82 make_tempname(bname) 83 char *bname; 84 { 85 static char buf[SIZE]; /* this is where we put the new name */ 86 char *p; /* work pointer */ 87 88 p = strrchr(bname, '/'); 89 if (p == NULL) 90 (void) sprintf(buf, "%s/.%s", HOME, bname); 91 else { 92 (void) strcpy(buf, HOME); 93 /* this zaps the trailing slash so the '.' can be stuck in */ 94 *p = '\0'; 95 (void) strcat(buf, "/"); 96 (void) strcat(buf, bname); 97 (void) strcat(buf, "/."); 98 (void) strcat(buf, (p + 1)); 99 *p = '/'; 100 } 101 return(buf); 102 } 103 104 105 /* 106 * open_temp - open up a temp file 107 * 108 * args: tname - temp file name 109 */ 110 111 112 113 FILE * 114 open_temp(tname) 115 char *tname; 116 { 117 FILE *fp; /* fp associated with tname */ 118 struct sigaction sigact; /* for signal handling */ 119 120 sigact.sa_flags = 0; 121 sigact.sa_handler = SIG_IGN; 122 (void) sigemptyset(&sigact.sa_mask); 123 (void) sigaddset(&sigact.sa_mask, SIGHUP); 124 (void) sigaddset(&sigact.sa_mask, SIGINT); 125 (void) sigaddset(&sigact.sa_mask, SIGQUIT); 126 (void) sigaction(SIGHUP, &sigact, NULL); 127 (void) sigaction(SIGINT, &sigact, NULL); 128 (void) sigaction(SIGQUIT, &sigact, NULL); 129 (void) umask(0333); 130 if (access(tname, 0) != -1) { 131 Saferrno = E_SAFERR; 132 error("tempfile busy; try again later"); 133 } 134 fp = fopen(tname, "w"); 135 if (fp == NULL) { 136 Saferrno = E_SYSERR; 137 error("cannot create tempfile"); 138 } 139 return(fp); 140 } 141 142 143 /* 144 * replace - replace one file with another, only returns on success 145 * 146 * args: fname - name of target file 147 * tname - name of source file 148 */ 149 150 151 void 152 replace(fname, tname) 153 char *fname; 154 char *tname; 155 { 156 char buf[SIZE]; /* scratch buffer */ 157 158 (void) sprintf(buf, "%s/%s", HOME, fname); 159 (void) unlink(buf); 160 if (rename(tname, buf) < 0) { 161 Saferrno = E_SYSERR; 162 (void) unlink(tname); 163 quit(); 164 } 165 } 166 167 168 /* 169 * copy_file - copy information from one file to another, return 0 on 170 * success, -1 on failure 171 * 172 * args: fp - source file's file pointer 173 * tfp - destination file's file pointer 174 * start - starting line number 175 * finish - ending line number (-1 indicates entire file) 176 */ 177 178 int 179 copy_file(FILE *fp, FILE *tfp, int start, int finish) 180 { 181 int i; /* loop variable */ 182 char dummy[SIZE]; /* scratch buffer */ 183 184 /* 185 * always start from the beginning because line numbers are absolute 186 */ 187 188 rewind(fp); 189 190 /* 191 * get to the starting point of interest 192 */ 193 194 if (start != 1) { 195 for (i = 1; i < start; i++) 196 if (!fgets(dummy, SIZE, fp)) 197 return(-1); 198 } 199 200 /* 201 * copy as much as was requested 202 */ 203 204 if (finish != -1) { 205 for (i = start; i <= finish; i++) { 206 if (!fgets(dummy, SIZE, fp)) 207 return(-1); 208 if (fputs(dummy, tfp) == EOF) 209 return(-1); 210 } 211 } 212 else { 213 for (;;) { 214 if (fgets(dummy, SIZE, fp) == NULL) { 215 if (feof(fp)) 216 break; 217 else 218 return(-1); 219 } 220 if (fputs(dummy, tfp) == EOF) 221 return(-1); 222 } 223 } 224 return(0); 225 } 226 227 228 /* 229 * find_pm - find an entry in _sactab for a particular port monitor 230 * 231 * args: fp - file pointer for _sactab 232 * pmtag - tag of port monitor we're looking for 233 */ 234 235 int 236 find_pm(FILE *fp, char *pmtag) 237 { 238 char *p; /* working pointer */ 239 int line = 0; /* line number we found entry on */ 240 struct sactab stab; /* place to hold parsed info */ 241 char buf[SIZE]; /* scratch buffer */ 242 243 while (fgets(buf, SIZE, fp)) { 244 line++; 245 p = trim(buf); 246 if (*p == '\0') 247 continue; 248 parse(p, &stab); 249 if (!(strcmp(stab.sc_tag, pmtag))) 250 return(line); 251 } 252 if (!feof(fp)) { 253 Saferrno = E_SYSERR; 254 error("error reading _sactab"); 255 /* NOTREACHED */ 256 return (0); 257 } 258 else 259 return(0); 260 } 261 262 263 /* 264 * do_config - take a config script and put it where it belongs or 265 * output an existing one. Saferrno is set if any errors 266 * are encountered. Calling routine may choose to quit or 267 * continue, in which case Saferrno will stay set, but may 268 * change value if another error is encountered. 269 * 270 * args: script - name of file containing script (if NULL, means output 271 * existing one instead) 272 * basename - name of script (relative to HOME (from misc.h)) 273 */ 274 275 int 276 do_config(char *script, char *basename) 277 { 278 FILE *ifp; /* file pointer for source file */ 279 FILE *ofp; /* file pointer for target file */ 280 struct stat statbuf; /* file status info */ 281 char *tname; /* name of tempfile */ 282 char buf[SIZE]; /* scratch buffer */ 283 284 if (script) { 285 /* we're installing a new configuration script */ 286 if (access(script, 0) == 0) { 287 if (stat(script, &statbuf) < 0) { 288 Saferrno = E_SYSERR; 289 (void) fprintf(stderr, "Could not stat <%s>\n", script); 290 return(1); 291 } 292 if ((statbuf.st_mode & S_IFMT) != S_IFREG) { 293 (void) fprintf(stderr, "warning - %s not a regular file - ignored\n", script); 294 return(1); 295 } 296 } 297 else { 298 Saferrno = E_NOEXIST; 299 (void) fprintf(stderr, "Invalid request, %s does not exist\n", script); 300 return(1); 301 } 302 ifp = fopen(script, "r"); 303 if (ifp == NULL) { 304 (void) fprintf(stderr, "Invalid request, can not open %s\n", script); 305 Saferrno = E_SYSERR; 306 return(1); 307 } 308 tname = make_tempname(basename); 309 /* note - open_temp only returns if successful */ 310 ofp = open_temp(tname); 311 while(fgets(buf, SIZE, ifp)) { 312 if (fputs(buf, ofp) == EOF) { 313 (void) unlink(tname); 314 Saferrno = E_SYSERR; 315 error("error in writing tempfile"); 316 } 317 } 318 (void) fclose(ifp); 319 if (fclose(ofp) == EOF) { 320 (void) unlink(tname); 321 Saferrno = E_SYSERR; 322 error("error closing tempfile"); 323 } 324 /* note - replace only returns if successful */ 325 replace(basename, tname); 326 return(0); 327 } 328 else { 329 /* we're outputting a configuration script */ 330 (void) sprintf(buf, "%s/%s", HOME, basename); 331 if (access(buf, 0) < 0) { 332 (void) fprintf(stderr, "Invalid request, script does not exist\n"); 333 Saferrno = E_NOEXIST; 334 return(1); 335 } 336 ifp = fopen(buf, "r"); 337 if (ifp == NULL) { 338 (void) fprintf(stderr, "Invalid request, can not open script\n"); 339 Saferrno = E_SYSERR; 340 return(1); 341 } 342 while (fgets(buf, SIZE, ifp)) 343 (void) fputs(buf, stdout); 344 (void) fclose(ifp); 345 return(0); 346 } 347 } 348