![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to uuxqt.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [MW Coherent from dump] / coherent / a / usr / bob / uusrc / src|
Return to uuxqt.c CVS log | Up to [MW Coherent from dump] / coherent / a / usr / bob / uusrc / src |
1.1 root 1: /*
2: * uuxqt.c
3: *
4: * Execute local commands spooled by remote sites.
5: *
6: * copyright (x) richard h. lamb 1985, 1986, 1987
7: * changes (massive) copyright (c) 1989-1991 by Mark Williams Company
8: */
9:
10: #include <stdio.h>
11: #include <signal.h>
12: #include <access.h>
13: #include <sys/param.h>
14: #include <sys/stat.h>
15: #include "dirent.h"
16: #include "dcp.h"
17: #include "perm.h"
18:
19: /*
20: * Global Variables Definitions
21: */
22:
23: char directory[CTLFLEN]; /* directory for control files */
24: char xfile[CTLFLEN]; /* "X.*" control file name */
25: FILE *xfp = NULL; /* Opened "X.*" FILE pointer */
26: int processid; /* process id of this uuxqt */
27: char line[BUFSIZ]; /* Reading a text line */
28:
29: static char command[BUFSIZ], input[60], output[60];
30: static char orig_user[128];
31: static char orig_system[SITELEN+1];
32: static char notifywho[BUFSIZ];
33: static char *allowed;
34:
35: static int failstatus_req;
36: static int succstatus_req;
37: static char errbuf1[BUFSIZ];
38: static char errbuf2[BUFSIZ];
39: static char errbuf3[BUFSIZ];
40: static char reason[80];
41:
42: static char *sep = " \t\n";
43:
44: char *rmtname = NULL;
45: char **zenvp; /* Globally Available envp */
46:
47: extern int optind;
48: extern int optopt;
49: extern char *optarg;
50:
51: /*
52: * Extern Function Declarations
53: */
54:
55: extern char *strtok();
56: extern char *index();
57:
58: catchsegv()
59: {
60: fatal("Segmentation violation -- uuxqt aborted");
61: }
62:
63: catchterm()
64: {
65: fatal("Local signal -- uuxqt aborted");
66: }
67:
68: main(argc, argv, envp)
69: int argc;
70: char *argv[], *envp[];
71: {
72: char xqtdir[LOGFLEN];
73: char ch;
74:
75: while ( (ch=getopt(argc, argv, "x:vV")) != EOF ) {
76: switch (ch) {
77: case 'x':
78: debuglevel = atoi(optarg);
79: break;
80: case 'v':
81: case 'V':
82: fatal("uuxqt: Version %s", VERSION);
83: case '?':
84: default:
85: fatal("Improper option usage: %c", optopt);
86: }
87: }
88:
89: bedaemon(); /* detach from controlling terminal */
90:
91: zenvp = envp;
92: processid = getpid();
93: signal(SIGINT, SIG_IGN);
94: signal(SIGHUP, SIG_IGN);
95: signal(SIGQUIT, SIG_IGN);
96: signal(SIGTERM, catchterm);
97: signal(SIGSEGV, catchsegv);
98: open_debug("uuxqt", 0);
99: sprintf(xqtdir, "%s/.Xqtdir", SPOOLDIR);
100: if (chdir(xqtdir) != 0)
101: fatal("can't chdir to: %s", xqtdir);
102: dcxqt();
103: close_debug();
104: exit(0);
105: }
106:
107: dcxqt()
108: {
109: if ( lockexist("uuxqt") )
110: return;
111:
112: if ( lockit("uuxqt") < 0 )
113: fatal("Can't lock uuxqt");
114:
115: if ( dscan_start() ) {
116: while ( dscan() ) {
117: if ( xscan_start() ) {
118: while ( xscan() )
119: dcxqt_work();
120: xscan_done();
121: }
122: }
123: dscan_done();
124: }
125: if ( lockrm("uuxqt") < 0 )
126: printmsg(M_LOG, "error unlocking uuxqt");
127: }
128:
129: /*
130: * Perform the work specified in the "X.*" control file: "xfile"
131: */
132:
133: dcxqt_work()
134: {
135: static char lastsite[SITELEN] = "\0";
136: int filewait = 0;
137: int removethis = 0;
138: int did_work = 0;
139: int fnd;
140: int execval;
141: char *sp, *osp;
142:
143: if ( (xfp=fopen(xfile, "r")) == NULL )
144: return;
145:
146: reason[0] = input[0] = output[0] = command[0] =
147: notifywho[0] = orig_user[0] = orig_system[0] =
148: errbuf1[0] = errbuf2[0] = errbuf3[0] = '\0';
149: failstatus_req = succstatus_req = fnd = 0;
150:
151: while ( fgets(line, BUFSIZ, xfp) != NULL ) {
152: sp = strtok(line, sep);
153: switch(line[0]) {
154: case 'C':
155: sp = strtok(NULL, "#\n");
156: strcpy(command, sp);
157: break;
158: case 'F':
159: sp = strtok(NULL, sep);
160: osp = strtok(NULL, sep);
161: sprintf(input,"%s/%s", directory, sp);
162: filewait |= isfileabsent(input);
163:
164: if (filewait == 0 && osp != NULL) {
165: if (link(input, osp) == -1) {
166: sprintf(errbuf1,
167: "Cannot link %s to %s.\n",
168: input, osp);
169: removethis = 1;
170: }
171: ul(input);
172: input[0] = '\0';
173: }
174: break;
175: case 'I':
176: sp = strtok(NULL, sep);
177: sprintf(input, "%s/%s", directory, sp);
178: break;
179: case 'M':
180: strcpy(errbuf2,
181: "Execute M record not supported");
182: break;
183: case 'O':
184: sp = strtok(NULL, sep);
185: sprintf(output, "%s/%s", directory, sp);
186: break;
187: case 'R':
188: strcpy (notifywho, sp = strtok(NULL, sep));
189: break;
190: case 'U':
191: strcpy(orig_user, sp = strtok(NULL, sep));
192: strncpy(orig_system,sp=strtok(NULL, sep), SITELEN);
193: if ( strncmp(orig_system, lastsite, SITELEN) != 0) {
194: strncpy(lastsite, orig_system, SITELEN);
195: rmtname = &lastsite[0];
196: open_the_logfile("uuxqt");
197: plog(M_INFO, "Starting Xqt {%d} (V%s)",
198: processid, VERSION);
199: perm_get(orig_system, NULL);
200: allowed = perm_value(commands_e);
201: }
202: break;
203: case 'Z':
204: failstatus_req = 1;
205: break;
206: case 'n':
207: succstatus_req = 1;
208: break;
209: case '#':
210: break;
211: default:
212: sprintf(errbuf3, "Unknown command %s", sp);
213: break;
214: }
215: }
216:
217: if (strlen(notifywho) < 1)
218: strcpy (notifywho, orig_user);
219: if (strlen(errbuf1) > 0)
220: plog(M_INFO, errbuf1);
221: if (strlen(errbuf2) > 0)
222: plog(M_INFO, errbuf2);
223: if (strlen(errbuf3) > 0)
224: plog(M_INFO, errbuf3);
225:
226: plog(M_INFO, "%s (<%s >%s)", command, input, output);
227: if (removethis) {
228: unlinkfiles();
229: } else if (filewait)
230: plog(M_INFO, "Waiting for files");
231: else {
232: did_work ++;
233: if ( (execval=shell2(command, input, output)) != 0 ) {
234: plog(M_INFO, "Command failed, status %d (0x%04x)",
235: execval, execval);
236: strcpy(reason, "Exit status not zero");
237: }
238: if (succstatus_req || (failstatus_req && (execval != 0)))
239: remote_status(execval);
240: unlinkfiles();
241: }
242: if (did_work > 0) {
243: plog(M_INFO, "Finished {%d}", processid);
244: }
245: fclose(xfp);
246: }
247:
248: unlinkfiles()
249: {
250: char *osp, *sp;
251:
252: rewind(xfp);
253: while(fgets(line, BUFSIZ, xfp) != NULL) {
254: sp = strtok(line, sep);
255: switch(line[0]) {
256: case 'C':
257: break;
258: case 'F':
259: sp = strtok(NULL, sep);
260: osp = strtok(NULL, sep);
261: ul(sp);
262: if (osp != NULL)
263: ul(osp);
264: break;
265: case 'I':case 'M':case 'O':
266: case 'U':case 'Z':case 'n':
267: default:
268: break;
269:
270: }
271: }
272: ul(xfile);
273: ul(input);
274: ul(output);
275: }
276:
277: static
278: ul(fn)
279: char *fn;
280: {
281: int status;
282: if (strlen(fn) < 1)
283: return;
284: status = unlink(fn);
285: }
286:
287: remote_status(val)
288: int val;
289: {
290: static char pbuf[BUFSIZ];
291:
292: FILE *fmp;
293: (void) signal(SIGPIPE, SIG_IGN);
294: sprintf(pbuf, "mail -auucp %s!%s ", orig_system, notifywho);
295: if ((fmp = popen(pbuf, "w")) == NULL)
296: plog(M_INFO, "Cannot send remote status mail");
297: else {
298: fprintf(fmp, "From: UUXQT V%s\n", VERSION);
299: fprintf(fmp, "Subject: UUXQT remote execution status\n\n");
300: fprintf(fmp,
301: "Command \"%s\" %s.\n\tStatus %d (0x%04x)",
302: command, val ? "failed" : "succeeded", val, val);
303: if (strlen(reason) > 0)
304: fprintf(fmp, "\nReason: %s", reason);
305: fprintf(fmp, "\n");
306: if (pclose(fmp) != 0)
307: plog(M_INFO, "Remote status mail failed");
308: plog(M_INFO, "Remote status mail posted to %s!%s",
309: orig_system, notifywho);
310: }
311: }
312:
313: isfileabsent(fn)
314: char *fn;
315: {
316: return access(fn, AREAD);
317: }
318:
319: #define MAXENVS 200
320: static char *uuenvp[MAXENVS];
321: static char uu_user[BUFSIZ];
322: static char uu_mach[BUFSIZ];
323:
324: shell2(command, inname, outname)
325: char *command;
326: char *inname;
327: char *outname;
328: {
329: int waitstat;
330: int fd, i;
331: int waitpid, cpid;
332:
333: if ( !permission(command) ) {
334: strcpy(reason, "No permission to execute command");
335: plog(M_INFO, "No permission to execute: %s", command);
336: if (failstatus_req)
337: remote_status(-1);
338: return 0;
339: }
340:
341: sprintf(uu_user, "UU_USER=%s", notifywho);
342: sprintf(uu_mach, "UU_MACHINE=%s", orig_system);
343: uuenvp[0] = uu_user;
344: uuenvp[1] = uu_mach;
345: for (i=2; (zenvp[i]!=NULL) && (i<MAXENVS); i++)
346: uuenvp[i] = zenvp[i-2];
347: if ((cpid = fork()) < 0) {
348: plog(M_INFO, "couldn't fork");
349: return -1;
350: }
351: if (cpid == 0) {
352: if (strlen(inname) != 0) {
353: fd = open(inname, 0);
354: dup2(fd, 0);
355: if (fd > 0)
356: close(fd);
357: }
358: if (strlen(outname) != 0) {
359: fd = creat(outname, 0644);
360: dup2(fd, 1);
361: if (fd > 1)
362: close(fd);
363: }
364: execle("/bin/sh", "sh", "-c", command, (char *)0, uuenvp);
365: plog(M_INFO, "Could not exec /bin/sh");
366: exit(0177);
367: }
368: while (((waitpid = wait(&waitstat)) != cpid) && (waitpid > 0))
369: ;
370: return waitstat;
371: }
372:
373: permission(command)
374: char *command;
375: {
376: char *sp, *cp, *spcp;
377: int ok;
378:
379: if ( (spcp=index(command, ' ')) != NULL )
380: *spcp = '\0';
381:
382: sp = allowed;
383: ok = 0;
384: do {
385: if ( (cp=index(sp, ':')) != NULL )
386: *cp = '\0';
387: if ( strcmp(command, sp) == 0 )
388: ok = 1;
389: if ( cp != NULL )
390: *cp++ = ':';
391: } while ( !ok && ((sp=cp) != NULL) );
392:
393: if ( spcp != NULL )
394: *spcp = ' ';
395: return(ok);
396: }
397:
398: /*
399: * Directory Scan Functions:
400: *
401: * dscan_start() : Opens SPOOLDIR to scan for sitename subdirectories
402: * : Returns: (1) opened ok, (0) error
403: * dscan() : Sets variable "directory" to next directory
404: * : Returns: (1) found directory, (0) no directory
405: * dscan_done() : Done scanning SPOOLDIR for directories
406: *
407: * xscan_start() : Opens "directory" to scan for "X.*" control files
408: * : Returns: (1) opened ok, (0) error
409: * xscan() : Sets variable "xfile" to next such "X.*" control file
410: * : Returns: (1) found file, (0) no file
411: * xscan_done() : Done scanning "directory" for "X.*" control files
412: */
413:
414: static DIR *sdirp, *xdirp;
415: extern DIR *opendir();
416: extern struct direct *readdir();
417:
418: dscan_start()
419: {
420: if ( (sdirp=opendir(SPOOLDIR)) == NULL ) {
421: printmsg(M_LOG, "Cannot open spool directory: %s", SPOOLDIR);
422: return(0);
423: }
424: return(1);
425: }
426:
427: dscan()
428: {
429: struct stat statbuf;
430: struct dirent *mdp;
431:
432: while( (mdp=readdir(sdirp)) != NULL ) {
433: if ( mdp->d_name[0] == '.' )
434: continue;
435: sprintf(directory, "%s/%s", SPOOLDIR, mdp->d_name);
436: stat(directory, &statbuf);
437: if ( statbuf.st_mode & S_IFDIR )
438: return(1);
439: }
440: return(0);
441: }
442:
443: dscan_done()
444: {
445: closedir(sdirp);
446: }
447:
448: xscan_start()
449: {
450: if ( (xdirp=opendir(directory)) == NULL ) {
451: printmsg(M_LOG, "Cannot open spool directory: %s", directory);
452: return(0);
453: }
454: return(1);
455: }
456:
457: xscan()
458: {
459: struct stat statbuf;
460: struct dirent *xdp;
461:
462: while( (xdp=readdir(xdirp)) != NULL ) {
463: if ( strncmp(xdp->d_name, "X.", 2) == 0 ) {
464: sprintf(xfile, "%s/%s", directory, xdp->d_name);
465: stat(xfile, &statbuf);
466: if ( statbuf.st_mode & S_IFDIR )
467: continue;
468: return(1);
469: }
470: }
471: return(0);
472: }
473:
474: xscan_done()
475: {
476: closedir(xdirp);
477: }
478:
479: fatal(x)
480: {
481: printmsg(M_FATAL, "%r", &x);
482: if ( lockexist("uuxqt") )
483: lockrm("uuxqt");
484: close_logfile();
485: close_debug();
486: exit(1);
487: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.