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 2006 Sun Microsystems, Inc. All rights reserved.
23 * Use is subject to license terms.
24 *
25 * logadm/kw.c -- manage keywords table
26 *
27 * this module expands things like $file.$n in "templates".
28 * calling kw_init() sets the current "filename" used for
29 * $file, $dirname, and $basename.
30 *
31 * any time-based expansions, like $secs, or all the strftime()
32 * percent sequences, are based on the exact same point in time.
33 * so calling kw_expand() on something like "file-%T" will return
34 * the same thing when called multiple times during the same logadm run.
35 */
36
37 #pragma ident "%Z%%M% %I% %E% SMI"
38
39 #include <stdio.h>
40 #include <libintl.h>
41 #include <stdlib.h>
42 #include <sys/types.h>
43 #include <sys/stat.h>
44 #include <sys/utsname.h>
45 #include <sys/systeminfo.h>
46 #include <strings.h>
47 #include <time.h>
48 #include <ctype.h>
49 #include <zone.h>
50 #include "err.h"
51 #include "lut.h"
52 #include "fn.h"
53 #include "kw.h"
54
55 /* forward declarations for functions used internally by this module */
56 static void kw_printer(const char *lhs, void *rhs, void *arg);
57
58 /*
59 * absurdly long length to hold sprintf of a %d,
60 * or strftime() expansion of a *single* percent sequence
61 */
62 #define MAXDIGITS 100
63
64 static struct lut *Keywords; /* lookup table for keywords */
65
66 extern time_t Now; /* time used for keyword expansions */
67
68 /*
69 * kw_init -- initialize keywords based on given filename
70 */
71 void
kw_init(struct fn * fnp,struct fn * nfnp)72 kw_init(struct fn *fnp, struct fn *nfnp)
73 {
74 static char *fullpath;
75 static char *nfullpath;
76 static char *splitpath;
77 static char secs[MAXDIGITS];
78 static struct utsname un;
79 static char platform[SYS_NMLN];
80 static char isa[SYS_NMLN];
81 static char domain[256];
82 static char *home;
83 static char *user;
84 static char *logname;
85 static char zonename[ZONENAME_MAX];
86 static zoneid_t zoneid;
87 static int initialized;
88 char *ptr;
89
90 /* make a copy of the string for $file */
91 if (fullpath)
92 FREE(fullpath);
93 fullpath = STRDUP(fn_s(fnp));
94 Keywords = lut_add(Keywords, "file", fullpath);
95
96 /* make a copy of the string for $nfile */
97 if (nfullpath)
98 FREE(nfullpath);
99 if (nfnp == NULL) {
100 nfullpath = NULL;
101 Keywords = lut_add(Keywords, "nfile", "");
102 } else {
103 nfullpath = STRDUP(fn_s(nfnp));
104 Keywords = lut_add(Keywords, "nfile", nfullpath);
105 }
106
107 /* make a copy of the string for $dirname/$basename */
108 if (splitpath)
109 FREE(splitpath);
110 splitpath = STRDUP(fn_s(fnp));
111
112 if ((ptr = strrchr(splitpath, '/')) == NULL) {
113 Keywords = lut_add(Keywords, "basename", splitpath);
114 Keywords = lut_add(Keywords, "dirname", ".");
115 } else {
116 *ptr++ = '\0';
117 Keywords = lut_add(Keywords, "basename", ptr);
118 Keywords = lut_add(Keywords, "dirname", splitpath);
119 }
120
121 if (initialized)
122 return; /* rest of the keywords don't change */
123
124 (void) snprintf(secs, MAXDIGITS, "%d", (int)Now);
125 Keywords = lut_add(Keywords, "secs", secs);
126
127 if (uname(&un) < 0)
128 err(EF_SYS, "uname");
129
130 Keywords = lut_add(Keywords, "nodename", un.nodename);
131 Keywords = lut_add(Keywords, "release", un.release);
132 Keywords = lut_add(Keywords, "machine", un.machine);
133
134 if (sysinfo(SI_ARCHITECTURE, isa, sizeof (isa)) == -1)
135 err(EF_WARN|EF_SYS, "sysinfo(SI_ARCHITECTURE) failed.");
136 else
137 Keywords = lut_add(Keywords, "isa", isa);
138
139 if (sysinfo(SI_PLATFORM, platform, sizeof (platform)) == -1)
140 err(EF_WARN|EF_SYS, "sysinfo(SI_PLATFORM) failed.");
141 else
142 Keywords = lut_add(Keywords, "platform", platform);
143
144 if (sysinfo(SI_SRPC_DOMAIN, domain, sizeof (domain)) == -1)
145 err(EF_WARN|EF_SYS, "sysinfo(SI_SRPC_DOMAIN) failed.");
146 else
147 Keywords = lut_add(Keywords, "domain", domain);
148
149 if ((home = getenv("HOME")) != NULL)
150 Keywords = lut_add(Keywords, "home", STRDUP(home));
151
152 if ((user = getenv("USER")) != NULL)
153 Keywords = lut_add(Keywords, "user", STRDUP(user));
154
155 if ((logname = getenv("LOGNAME")) != NULL)
156 Keywords = lut_add(Keywords, "logname", STRDUP(logname));
157
158 zoneid = getzoneid();
159 if ((getzonenamebyid(zoneid, zonename, sizeof (zonename))) == -1)
160 err(EF_WARN|EF_SYS, "getzonenamebyid() failed.");
161 else
162 Keywords = lut_add(Keywords, "zonename", STRDUP(zonename));
163
164 initialized = 1;
165 }
166
167 /* helper function for kw_print() */
168 static void
kw_printer(const char * lhs,void * rhs,void * arg)169 kw_printer(const char *lhs, void *rhs, void *arg)
170 {
171 FILE *stream = (FILE *)arg;
172
173 (void) fprintf(stream, "%20.20s %s\n", lhs, (char *)rhs);
174 }
175
176 /*
177 * kw_print -- spew the entire keywords table to stream
178 *
179 * this routine is used to dump the keywords table for debugging.
180 */
181 void
kw_print(FILE * stream)182 kw_print(FILE *stream)
183 {
184 lut_walk(Keywords, kw_printer, stream);
185 }
186
187 /*
188 * kw_expand -- expand src into dst with given n value for $n (or $N)
189 *
190 * n == -1 means expand src into a reglob
191 * if gz is true, include ".gz" extension
192 *
193 * returns true if template contains $n or $N (implying rotation of files)
194 */
195 boolean_t
kw_expand(struct fn * src,struct fn * dst,int n,boolean_t gz)196 kw_expand(struct fn *src, struct fn *dst, int n, boolean_t gz)
197 {
198 int c;
199 char buf[MAXDIGITS];
200 boolean_t hasn = B_FALSE;
201 struct fn *kw = fn_new(NULL);
202 char *ptr;
203 struct tm *gmt_tm = localtime(&Now);
204
205 while ((c = fn_getc(src)) != '\0')
206 switch (c) {
207 case '.':
208 case '(':
209 case ')':
210 case '^':
211 case '+':
212 case '{':
213 case '}':
214 /* when building an re, escape with a backslash */
215 if (n < 0)
216 fn_putc(dst, '\\');
217 fn_putc(dst, c);
218 break;
219 case '?':
220 /* when building an re, change '?' to a single dot */
221 if (n < 0)
222 fn_putc(dst, '.');
223 break;
224 case '*':
225 /* when building an re, change '*' to ".*" */
226 if (n < 0)
227 fn_putc(dst, '.');
228 fn_putc(dst, '*');
229 break;
230 case '$':
231 /* '$' marks the start of a keyword */
232 switch (c = fn_getc(src)) {
233 case '$':
234 /* double '$' stands for a single '$' */
235 if (n < 0)
236 fn_putc(dst, '\\');
237 fn_putc(dst, '$');
238 break;
239 case '#':
240 /*
241 * $# expands to nothing, but forces an end
242 * of keyword, allow juxtaposition of a
243 * keyword with lower-case characters
244 */
245 break;
246 case 'n':
247 case 'N':
248 if (c == 'N' || !islower(fn_peekc(src))) {
249 /*
250 * we've found $n or $N, if we're
251 * building an re, build one that
252 * matches a number, otherwise
253 * expand the keyword to the n
254 * passed in to this function
255 */
256 hasn = B_TRUE;
257 if (n < 0)
258 fn_puts(dst, "([0-9]+)$0");
259 else {
260 (void) snprintf(buf,
261 MAXDIGITS, "%d",
262 (c == 'n') ? n : n + 1);
263 fn_puts(dst, buf);
264 }
265 break;
266 }
267 /*FALLTHROUGH*/
268 default:
269 /* gather up the keyword name */
270 fn_renew(kw, NULL);
271 fn_putc(kw, c);
272 while (islower(fn_peekc(src)))
273 fn_putc(kw, fn_getc(src));
274
275 /* lookup keyword */
276 if ((ptr = (char *)lut_lookup(Keywords,
277 fn_s(kw))) == NULL) {
278 /* nope, copy it unexpanded */
279 if (n < 0)
280 fn_putc(dst, '\\');
281 fn_putc(dst, '$');
282 fn_putfn(dst, kw);
283 } else
284 fn_puts(dst, ptr);
285 }
286 break;
287 case '%':
288 /*
289 * % sequence for strftime(), if we're building
290 * an re, we take our best guess at the re for
291 * this sequence, otherwise we pass it to strftime()
292 */
293 if (n < 0) {
294 /*
295 * the regex for a percent sequence is
296 * usually just ".*" unless it is one
297 * of the common cases we know about
298 * that are numeric. in those cases, we
299 * tighten up the regex to just match digits.
300 *
301 * while it is gross that we embed knowledge
302 * of strftime() sequences here, they are
303 * specified in a standard so aren't
304 * expected to change often, and it *really*
305 * cuts down on the possibility that we'll
306 * expire a file that isn't an old log file.
307 */
308 if ((c = fn_getc(src)) == 'E' || c == 'O') {
309 c = fn_getc(src);
310 fn_puts(dst, ".*");
311 } else
312 switch (c) {
313 case 'd':
314 case 'g':
315 case 'G':
316 case 'H':
317 case 'I':
318 case 'j':
319 case 'm':
320 case 'M':
321 case 'S':
322 case 'u':
323 case 'U':
324 case 'V':
325 case 'w':
326 case 'W':
327 case 'y':
328 case 'Y':
329 /* pure numeric cases */
330 fn_puts(dst, "[0-9]+");
331 break;
332 case 'e':
333 case 'k':
334 case 'l':
335 /* possible space then num */
336 fn_puts(dst, " *[0-9]+");
337 break;
338 case 'D': /* %m/%d/%y */
339 /* adds slashes! */
340 fn_puts(dst,
341 "[0-9]+/[0-9]+/[0-9]+");
342 break;
343 case 'R': /* %H:%M */
344 fn_puts(dst, "[0-9]+:[0-9]+");
345 break;
346 case 'T': /* %H:%M:%S */
347 fn_puts(dst,
348 "[0-9]+:[0-9]+:[0-9]+");
349 break;
350 default:
351 fn_puts(dst, ".*");
352 }
353 } else {
354 char tbuf[4];
355
356 /* copy % sequence to tbuf */
357 tbuf[0] = '%';
358 tbuf[1] = fn_getc(src);
359 if (tbuf[1] == 'E' || tbuf[1] == 'O') {
360 /* "extended" sequence */
361 tbuf[2] = fn_getc(src);
362 tbuf[3] = '\0';
363 } else
364 tbuf[2] = '\0';
365
366 if (strftime(buf, MAXDIGITS, tbuf, gmt_tm) == 0)
367 /* just copy %x */
368 fn_puts(dst, tbuf);
369 else
370 fn_puts(dst, buf);
371 }
372 break;
373 default:
374 /* nothing special, just copy it */
375 fn_putc(dst, c);
376 }
377
378 if (gz) {
379 if (n < 0)
380 fn_puts(dst, "(\\.gz){0,1}");
381 else
382 fn_puts(dst, ".gz");
383 }
384
385 fn_free(kw);
386 return (hasn);
387 }
388
389 #ifdef TESTMODULE
390
391 time_t Now;
392
393 /*
394 * test main for kw module, usage: a.out fname [template...]
395 */
396 int
main(int argc,char * argv[])397 main(int argc, char *argv[])
398 {
399 int i;
400 struct fn *src = fn_new(NULL);
401 struct fn *dst = fn_new(NULL);
402
403 err_init(argv[0]);
404 setbuf(stdout, NULL);
405
406 Now = time(0);
407
408 if (argc < 2)
409 err(0, "first arg must be fname");
410
411 kw_init(fn_new(argv[1]), NULL);
412
413 kw_print(stdout);
414
415 for (i = 2; i < argc; i++) {
416 int n;
417
418 for (n = -1; n < 2; n++) {
419 fn_renew(src, argv[i]);
420 fn_renew(dst, NULL);
421 printf("expand<%s> n %d hasn %d ",
422 argv[i], n, kw_expand(src, dst, n, B_FALSE));
423 printf("result <%s>\n", fn_s(dst));
424 }
425 }
426
427 err_done(0);
428 /* NOTREACHED */
429 return (0);
430 }
431
432 #endif /* TESTMODULE */
433