![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to cu.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSDTahoe / old|
Return to cu.c CVS log | Up to [CSRG BSD Unix] / 43BSDTahoe / old |
1.1 root 1: static char *sccsid = "@(#)cu.c 4.7 (Berkeley) 82/10/21";
2:
3: #include <stdio.h>
4: #include <signal.h>
5: #include <sgtty.h>
6:
7: /*
8: * defs that come from uucp.h
9: */
10: #define NAMESIZE 15
11: #define FAIL -1
12: #define SAME 0
13: #define SLCKTIME 5400 /* system/device timeout (LCK.. files) in seconds */
14: #define ASSERT(e, f, v) if (!(e)) {\
15: fprintf(stderr, "AERROR - (%s) ", "e");\
16: fprintf(stderr, f, v);\
17: cleanup(FAIL);\
18: }
19:
20: /*
21: * cu telno [-t] [-s speed] [-l line] [-a acu] [-p]
22: *
23: * -t is for dial-out to terminal.
24: * speeds are: 110, 134, 150, 300, 1200, 2400. 300 is default.
25: *
26: * -p says strip parity of characters transmitted. (to compensate
27: * for c100's)
28: *
29: * Escape with `~' at beginning of line.
30: * Ordinary diversions are ~<, ~> and ~>>.
31: * Silent output diversions are ~>: and ~>>:.
32: * Terminate output diversion with ~> alone.
33: * Quit is ~. and ~! gives local command or shell.
34: * Also ~$ for canned procedure pumping remote.
35: * ~%put from [to] and ~%take from [to] invoke builtins
36: */
37:
38: #define CRLF "\r\n"
39: #define wrc(ds) write(ds,&c,1)
40:
41:
42: char *devcul = "/dev/cul0";
43: char *devcua = "/dev/cua0";
44: char *lspeed = "300";
45:
46: int ln; /* fd for comm line */
47: char tkill, terase; /* current input kill & erase */
48: int efk; /* process of id of listener */
49: char c;
50: char oc;
51:
52: char *connmsg[] = {
53: "",
54: "line busy",
55: "call dropped",
56: "no carrier",
57: "can't fork",
58: "acu access",
59: "tty access",
60: "tty hung",
61: "usage: cu telno [-t] [-s speed] [-l line] [-a acu]",
62: "lock failed: line busy"
63: };
64:
65: rdc(ds) {
66:
67: ds=read(ds,&c,1);
68: oc = c;
69: c &= 0177;
70: return (ds);
71: }
72:
73: int intr;
74:
75: sig2()
76: {
77: signal(SIGINT, SIG_IGN);
78: intr = 1;
79: }
80:
81: int set14;
82:
83: xsleep(n)
84: {
85: xalarm(n);
86: pause();
87: xalarm(0);
88: }
89:
90: xalarm(n)
91: {
92: set14=n;
93: alarm(n);
94: }
95:
96: sig14()
97: {
98: signal(SIGALRM, sig14);
99: if (set14) alarm(1);
100: }
101:
102: int dout;
103: int nhup;
104: int dbflag;
105: int pflag; /* strip parity on chars sent to remote */
106: int nullbrk; /* turn breaks (nulls) into dels */
107: int pipes[2] = { -1, -1 };
108:
109: /*
110: * main: get connection, set speed for line.
111: * spawn child to invoke rd to read from line, output to fd 1
112: * main line invokes wr to read tty, write to line
113: */
114: main(ac,av)
115: char *av[];
116: {
117: int fk;
118: int speed;
119: char *telno;
120: struct sgttyb stbuf;
121: int cleanup();
122:
123: signal(SIGALRM, sig14);
124: signal(SIGINT, cleanup);
125: signal(SIGHUP, cleanup);
126: signal(SIGQUIT, cleanup);
127: if (ac < 2) {
128: prf(connmsg[8]);
129: exit(8);
130: }
131: for (; ac > 1; av++,ac--) {
132: if (av[1][0] != '-')
133: telno = av[1];
134: else switch(av[1][1]) {
135: case 't':
136: dout = 1;
137: --ac;
138: continue;
139: case 'b':
140: nullbrk++;
141: continue;
142: case 'd':
143: dbflag++;
144: continue;
145: case 'p':
146: pflag++;
147: continue;
148: case 's':
149: lspeed = av[2]; ++av; --ac;
150: break;
151: case 'l':
152: devcul = av[2]; ++av; --ac;
153: break;
154: case 'a':
155: devcua = av[2]; ++av; --ac;
156: break;
157: case '0': case '1': case '2': case '3': case '4':
158: case '5': case '6': case '7': case '8': case '9':
159: devcua[strlen(devcua)-1] = av[1][1];
160: devcul[strlen(devcul)-1] = av[1][1];
161: break;
162: default:
163: prf("Bad flag %s", av[1]);
164: break;
165: }
166: }
167: if (!exists(devcua) || !exists(devcul))
168: exit(9);
169: ln = conn(devcul, devcua, telno);
170: if (ln < 0) {
171: prf("Connect failed: %s",connmsg[-ln]);
172: cleanup(-ln);
173: }
174: switch(atoi(lspeed)) {
175: case 110:
176: speed = B110;break;
177: case 150:
178: speed = B150;break;
179: default:
180: case 300:
181: speed = B300;break;
182: case 1200:
183: speed = B1200;break;
184: case 2400:
185: speed = B2400;break;
186: }
187: stbuf.sg_ispeed = speed;
188: stbuf.sg_ospeed = speed;
189: stbuf.sg_flags = EVENP|ODDP;
190: if (!dout) {
191: stbuf.sg_flags |= RAW;
192: stbuf.sg_flags &= ~ECHO;
193: }
194: ioctl(ln, TIOCSETP, &stbuf);
195: ioctl(ln, TIOCEXCL, (struct sgttyb *)NULL);
196: ioctl(ln, TIOCHPCL, (struct sgttyb *)NULL);
197: prf("Connected");
198: pipe(pipes);
199: if (dout)
200: fk = -1;
201: else
202: fk = fork();
203: nhup = (int)signal(SIGINT, SIG_IGN);
204: if (fk == 0) {
205: chwrsig();
206: rd();
207: prf("\007Lost carrier");
208: cleanup(3);
209: }
210: mode(1);
211: efk = fk;
212: wr();
213: mode(0);
214: if (fk != -1) kill(fk, SIGKILL);
215: wait((int *)NULL);
216: stbuf.sg_ispeed = 0;
217: stbuf.sg_ospeed = 0;
218: ioctl(ln, TIOCSETP, &stbuf);
219: prf("Disconnected");
220: cleanup(0);
221: }
222:
223: /*
224: * conn: establish dial-out connection.
225: * Example: fd = conn("/dev/ttyh","/dev/dn1","4500");
226: * Returns descriptor open to tty for reading and writing.
227: * Negative values (-1...-7) denote errors in connmsg.
228: * Uses alarm and fork/wait; requires sig14 handler.
229: * Be sure to disconnect tty when done, via HUPCL or stty 0.
230: */
231:
232: conn(dev,acu,telno)
233: char *dev, *acu, *telno;
234: {
235: struct sgttyb stbuf;
236: extern errno;
237: char *p, *q, b[30];
238: char *ltail, *atail;
239: char *rindex();
240: int er, fk, dn, dh, t;
241: er=0;
242: fk=(-1);
243: atail = rindex(acu, '/')+1;
244: if (mlock(atail) == FAIL) {
245: er = 9;
246: goto X;
247: }
248: ltail = rindex(dev, '/')+1;
249: if (mlock(ltail) == FAIL) {
250: er = 9;
251: delock(atail);
252: goto X;
253: }
254: if ((dn=open(acu,1))<0) {
255: er=(errno == 6? 1:5);
256: goto X;
257: }
258: if ((fk=fork()) == (-1)) {
259: er=4;
260: goto X;
261: }
262: if (fk == 0) {
263: open(dev,2);
264: for (;;) pause();
265: }
266: xsleep(2);
267: /*
268: * copy phone #, assure EON
269: */
270: p=b;
271: q=telno;
272: while (*p++=(*q++))
273: ;
274: p--;
275: if (*(p-1)!='<') {
276: /*if (*(p-1)!='-') *p++='-';*/
277: *p++='<';
278: }
279: t=p-b;
280: xalarm(5*t);
281: t=write(dn,b,t);
282: xalarm(0);
283: if (t<0) {
284: er=2;
285: goto X;
286: }
287: /* close(dn) */
288: xalarm(40); /* was 5; sometimes missed carrier */
289: dh = open(dev,2);
290: xalarm(0);
291: if (dh<0) {
292: er=(errno == 4? 3:6);
293: goto X;
294: }
295: ioctl(dh, TIOCGETP, &stbuf);
296: stbuf.sg_flags &= ~ECHO;
297: xalarm(10);
298: ioctl(dh, TIOCSETP, &stbuf);
299: ioctl(dh, TIOCHPCL, (struct sgttyb *)NULL);
300: xalarm(0);
301: X:
302: if (er) close(dn);
303: delock(atail);
304: if (fk!=(-1)) {
305: kill(fk, SIGKILL);
306: xalarm(10);
307: while ((t=wait((int *)NULL))!=(-1) && t!=fk);
308: xalarm(0);
309: }
310: return (er? -er:dh);
311: }
312:
313: /*
314: * wr: write to remote: 0 -> line.
315: * ~. terminate
316: * ~<file send file
317: * ~! local login-style shell
318: * ~!cmd execute cmd locally
319: * ~$proc execute proc locally, send output to line
320: * ~%cmd execute builtin cmd (put and take)
321: * ~# send 1-sec break
322: * ~^Z suspend cu process.
323: */
324:
325: wr()
326: {
327: int ds,fk,lcl,x;
328: char *p,b[600];
329: for (;;) {
330: p=b;
331: while (rdc(0) == 1) {
332: if (p == b) lcl=(c == '~');
333: if (p == b+1 && b[0] == '~') lcl=(c!='~');
334: if (nullbrk && c == 0) oc=c=0177; /* fake break kludge */
335: if (!lcl) {
336: if(!pflag)c = oc;
337: if (wrc(ln) == 0) {
338: prf("line gone"); return;
339: }
340: c &= 0177;
341: }
342: if (lcl) {
343: if (c == 0177) c=tkill;
344: if (c == '\r' || c == '\n') goto A;
345: if (!dout) wrc(0);
346: }
347: *p++=c;
348: if (c == terase) {
349: p=p-2;
350: if (p<b) p=b;
351: }
352: if (c == tkill || c == 0177 || c == '\4' || c == '\r' || c == '\n') p=b;
353: }
354: return;
355: A:
356: if (!dout) echo("");
357: *p=0;
358: switch (b[1]) {
359: case '.':
360: case '\004':
361: return;
362: case '#':
363: ioctl(ln, TIOCSBRK, 0);
364: sleep(1);
365: ioctl(ln, TIOCCBRK, 0);
366: continue;
367: case '!':
368: case '$':
369: fk = fork();
370: if (fk == 0) {
371: char *getenv();
372: char *shell = getenv("SHELL");
373: if (shell == 0) shell = "/bin/sh";
374: close(1);
375: dup(b[1] == '$'? ln:2);
376: close(ln);
377: mode(0);
378: if (!nhup) signal(SIGINT, SIG_DFL);
379: if (b[2] == 0) execl(shell,shell,0);
380: /* if (b[2] == 0) execl(shell,"-",0); */
381: else execl(shell,"sh","-c",b+2,0);
382: prf("Can't execute shell");
383: exit(~0);
384: }
385: if (fk!=(-1)) {
386: while (wait(&x)!=fk);
387: }
388: mode(1);
389: if (b[1] == '!') echo("!");
390: else {
391: if (dout) echo("$");
392: }
393: break;
394: case '<':
395: if (b[2] == 0) break;
396: if ((ds=open(b+2,0))<0) {
397: prf("Can't divert %s",b+1);
398: break;
399: }
400: intr=x=0;
401: mode(2);
402: if (!nhup) signal(SIGINT, sig2);
403: while (!intr && rdc(ds) == 1) {
404: if (wrc(ln) == 0) {
405: x=1;
406: break;
407: }
408: }
409: signal(SIGINT, SIG_IGN);
410: close(ds);
411: mode(1);
412: if (x) return;
413: if (dout) echo("<");
414: break;
415: case '>':
416: case ':':
417: {
418: register char *q;
419:
420: if(pipes[1]==-1) {
421: prf("Can't tell other demon to divert");
422: break;
423: }
424: q = b+1;
425: if(*q=='>') q++;
426: write(pipes[1],q,strlen(q)+1);
427: if(dbflag) prf("msg to be delivered:"),prf(q);
428: if (efk != -1) kill(efk,SIGEMT);
429: }
430: break;
431: #ifdef SIGTSTP
432: #define CTRLZ 26
433: case CTRLZ:
434: mode(0);
435: kill(getpid(), SIGTSTP);
436: mode(1);
437: break;
438: #endif
439: case '%':
440: dopercen(&b[2]);
441: break;
442: default:
443: prf("Use `~~' to start line with `~'");
444: }
445: continue;
446: }
447: }
448:
449: dopercen(line)
450: register char *line;
451: {
452: char *args[10];
453: register narg, f;
454: int rcount;
455: for (narg = 0; narg < 10;) {
456: while(*line == ' ' || *line == '\t')
457: line++;
458: if (*line == '\0')
459: break;
460: args[narg++] = line;
461: while(*line != '\0' && *line != ' ' && *line != '\t')
462: line++;
463: if (*line == '\0')
464: break;
465: *line++ = '\0';
466: }
467: if (equal(args[0], "take")) {
468: if (narg < 2) {
469: prf("usage: ~%%take from [to]");
470: return;
471: }
472: if (narg < 3)
473: args[2] = args[1];
474: write(pipes[1], ">:/dev/null",sizeof(">:/dev/null"));
475: if(dbflag) prf("sending take message");
476: if (efk != -1) kill(efk,SIGEMT);
477: xsleep(5);
478: wrln("echo '~>");
479: wrln(args[2]);
480: wrln("'; tee /dev/null <");
481: wrln(args[1]);
482: wrln(";echo '~>'\n");
483: return;
484: } else if (equal(args[0], "put")) {
485: if (narg < 2) {
486: prf("usage: ~%%put from [to]");
487: return;
488: }
489: if (narg < 3)
490: args[2] = args[1];
491: if ((f = open(args[1], 0)) < 0) {
492: prf("cannot open: %s", args[1]);
493: return;
494: }
495: wrln("stty -echo;cat >");
496: wrln(args[2]);
497: wrln(";stty echo\n");
498: xsleep(5);
499: intr = 0;
500: if (!nhup)
501: signal(SIGINT, sig2);
502: mode(2);
503: rcount = 0;
504: while(!intr && rdc(f) == 1) {
505: rcount++;
506: if (c == tkill || c == terase)
507: wrln("\\");
508: if (wrc(ln) != 1) {
509: xsleep(2);
510: if (wrc(ln) != 1) {
511: prf("character missed");
512: intr = 1;
513: break;
514: }
515: }
516: }
517: signal(SIGINT, SIG_IGN);
518: close(f);
519: if (intr) {
520: wrln("\n");
521: prf("stopped after %d bytes", rcount);
522: }
523: wrln("\004");
524: xsleep(5);
525: mode(1);
526: return;
527: }
528: prf("~%%%s unknown\n", args[0]);
529: }
530:
531: equal(s1, s2)
532: register char *s1, *s2;
533: {
534: while (*s1++ == *s2)
535: if (*s2++ == '\0')
536: return(1);
537: return(0);
538: }
539:
540: wrln(s)
541: register char *s;
542: {
543: while (*s)
544: write(ln, s++, 1);
545: }
546: /* chwrsig: Catch orders from wr process
547: * to instigate diversion
548: */
549: int whoami;
550: chwrsig(){
551: int readmsg();
552: whoami = getpid();
553: signal(SIGEMT,readmsg);
554: }
555: int ds,slnt,taking;
556: int justrung;
557: readmsg(){
558: static char dobuff[128], morejunk[256];
559: int n;
560: justrung = 1;
561: signal(SIGEMT,readmsg);
562: if(dbflag) {
563: prf("About to read from pipe");
564: }
565: n = read(pipes[0],morejunk,256);
566: if(dbflag) {
567: prf("diversion mesg recieved is");
568: prf(morejunk);
569: prf(CRLF);
570: }
571: dodiver(morejunk);
572: }
573: dodiver(msg)
574: char *msg;
575: {
576: register char *cp = msg;
577:
578: if (*cp=='>') cp++;
579: if (*cp==':') {
580: cp++;
581: if(*cp==0) {
582: slnt ^= 1;
583: return;
584: } else {
585: slnt = 1;
586: }
587: }
588: if (ds >= 0) close(ds);
589: if (*cp==0) {
590: slnt = 0;
591: ds = -1;
592: return;
593: }
594: if (*msg!='>' || (ds=open(cp,1))<0) ds=creat(cp,0644);
595: lseek(ds, (long)0, 2);
596: if(ds < 0) prf("Creat failed:"), prf(cp);
597: if (ds<0) prf("Can't divert %s",cp+1);
598: }
599:
600:
601: /*
602: * rd: read from remote: line -> 1
603: * catch: diversion caught by interrupt routine
604: */
605:
606: #define ORDIN 0
607: #define SAWCR 1
608: #define EOL 2
609: #define SAWTL 3
610: #define DIVER 4
611:
612: rd()
613: {
614: extern int ds,slnt;
615: char rb[600], lb[600], *rlim, *llim, c;
616: register char *p,*q;
617: int cnt, state = 0, mustecho, oldslnt;
618:
619: ds=(-1);
620: p = lb; llim = lb+600;
621: agin:
622: while((cnt = read(ln,rb,600)) > 0) {
623: if(!slnt) write(1,rb,cnt);
624: if(ds < 0) continue;
625: oldslnt = slnt;
626: for( q=rb, rlim = rb + cnt - 1; q <= rlim; ) {
627: c = *q++ & 0177;
628: if(p < llim) *p++ = c;
629: switch(state) {
630: case ORDIN:
631: if(c=='\r') state = SAWCR;
632: break;
633: case SAWCR:
634: if(c=='\n') {
635: state = EOL;
636: p--;
637: p[-1] = '\n';
638: } else state = ORDIN;
639: break;
640: case EOL:
641: state = (c=='~' ? SAWTL :
642: (c=='\r' ? SAWCR : ORDIN));
643: break;
644: case SAWTL:
645: state = (c=='>' ? DIVER :
646: (c=='\r' ? SAWCR : ORDIN));
647: break;
648: case DIVER:
649: if(c=='\r') {
650: p--;
651: } else if (c=='\n') {
652: state = ORDIN;
653: p[-1] = 0;
654: dodiver(lb+2);
655: c = 0; p = lb;
656: }
657: }
658: if(slnt==0 && oldslnt) {
659: if(c=='\n') {
660: write(ln,lb,p-lb-1);
661: write(ln,CRLF,sizeof(CRLF));
662: } else if(q==rlim) {
663: write(ln,lb,p-lb);
664: c = '\n'; /*force flush to file*/
665: }
666: }
667: if(c=='\n') {
668: if(ds >= 0)
669: write(ds,lb,p-lb);
670: p = lb;
671: }
672: }
673: }
674: if(justrung) {
675: justrung = 0;
676: goto agin;
677: }
678: }
679:
680: struct {char lobyte; char hibyte;};
681: mode(f)
682: {
683: struct sgttyb stbuf;
684: if (dout) return;
685: ioctl(0, TIOCGETP, &stbuf);
686: tkill = stbuf.sg_kill;
687: terase = stbuf.sg_erase;
688: if (f == 0) {
689: stbuf.sg_flags &= ~RAW;
690: stbuf.sg_flags |= ECHO|CRMOD;
691: }
692: if (f == 1) {
693: stbuf.sg_flags |= RAW;
694: stbuf.sg_flags &= ~(ECHO|CRMOD);
695: }
696: if (f == 2) {
697: stbuf.sg_flags &= ~RAW;
698: stbuf.sg_flags &= ~(ECHO|CRMOD);
699: }
700: ioctl(0, TIOCSETP, &stbuf);
701: }
702:
703: echo(s)
704: char *s;
705: {
706: char *p;
707: for (p=s;*p;p++);
708: if (p>s) write(0,s,p-s);
709: write(0,CRLF, sizeof(CRLF));
710: }
711:
712: prf(f, s)
713: char *f;
714: char *s;
715: {
716: fprintf(stderr, f, s);
717: fprintf(stderr, CRLF);
718: }
719:
720: exists(devname)
721: char *devname;
722: {
723: if (access(devname, 0)==0)
724: return(1);
725: prf("%s does not exist", devname);
726: return(0);
727: }
728:
729: cleanup(code)
730: {
731: rmlock(NULL);
732: exit(code);
733: }
734:
735: /*
736: * This code is taken directly from uucp and follows the same
737: * conventions. This is important since uucp and cu should
738: * respect each others locks.
739: */
740:
741: /* ulockf 3.2 10/26/79 11:40:29 */
742: /* #include "uucp.h" */
743: #include <sys/types.h>
744: #include <sys/stat.h>
745:
746:
747:
748: /*******
749: * ulockf(file, atime)
750: * char *file;
751: * time_t atime;
752: *
753: * ulockf - this routine will create a lock file (file).
754: * If one already exists, the create time is checked for
755: * older than the age time (atime).
756: * If it is older, an attempt will be made to unlink it
757: * and create a new one.
758: *
759: * return codes: 0 | FAIL
760: */
761:
762: ulockf(file, atime)
763: char *file;
764: time_t atime;
765: {
766: struct stat stbuf;
767: time_t ptime;
768: int ret;
769: static int pid = -1;
770: static char tempfile[NAMESIZE];
771:
772: if (pid < 0) {
773: pid = getpid();
774: sprintf(tempfile, "/usr/spool/uucp/LTMP.%d", pid);
775: }
776: if (onelock(pid, tempfile, file) == -1) {
777: /* lock file exists */
778: /* get status to check age of the lock file */
779: ret = stat(file, &stbuf);
780: if (ret != -1) {
781: time(&ptime);
782: if ((ptime - stbuf.st_ctime) < atime) {
783: /* file not old enough to delete */
784: return(FAIL);
785: }
786: }
787: ret = unlink(file);
788: ret = onelock(pid, tempfile, file);
789: if (ret != 0)
790: return(FAIL);
791: }
792: stlock(file);
793: return(0);
794: }
795:
796:
797: #define MAXLOCKS 10 /* maximum number of lock files */
798: char *Lockfile[MAXLOCKS];
799: int Nlocks = 0;
800:
801: /***
802: * stlock(name) put name in list of lock files
803: * char *name;
804: *
805: * return codes: none
806: */
807:
808: stlock(name)
809: char *name;
810: {
811: char *p;
812: extern char *calloc();
813: int i;
814:
815: for (i = 0; i < Nlocks; i++) {
816: if (Lockfile[i] == NULL)
817: break;
818: }
819: ASSERT(i < MAXLOCKS, "TOO MANY LOCKS %d", i);
820: if (i >= Nlocks)
821: i = Nlocks++;
822: p = calloc(strlen(name) + 1, sizeof (char));
823: ASSERT(p != NULL, "CAN NOT ALLOCATE FOR %s", name);
824: strcpy(p, name);
825: Lockfile[i] = p;
826: return;
827: }
828:
829:
830: /***
831: * rmlock(name) remove all lock files in list
832: * char *name; or name
833: *
834: * return codes: none
835: */
836:
837: rmlock(name)
838: char *name;
839: {
840: int i;
841:
842: for (i = 0; i < Nlocks; i++) {
843: if (Lockfile[i] == NULL)
844: continue;
845: if (name == NULL
846: || strcmp(name, Lockfile[i]) == SAME) {
847: unlink(Lockfile[i]);
848: free(Lockfile[i]);
849: Lockfile[i] = NULL;
850: }
851: }
852: return;
853: }
854:
855:
856: /* this stuff from pjw */
857: /* /usr/pjw/bin/recover - check pids to remove unnecessary locks */
858: /* isalock(name) returns 0 if the name is a lock */
859: /* unlock(name) unlocks name if it is a lock*/
860: /* onelock(pid,tempfile,name) makes lock a name
861: on behalf of pid. Tempfile must be in the same
862: file system as name. */
863: /* lock(pid,tempfile,names) either locks all the
864: names or none of them */
865: isalock(name) char *name;
866: {
867: struct stat xstat;
868: if(stat(name,&xstat)<0) return(0);
869: if(xstat.st_size!=sizeof(int)) return(0);
870: return(1);
871: }
872: unlock(name) char *name;
873: {
874: if(isalock(name)) return(unlink(name));
875: else return(-1);
876: }
877: onelock(pid,tempfile,name) char *tempfile,*name;
878: { int fd;
879: fd=creat(tempfile,0444);
880: if(fd<0) return(-1);
881: write(fd,(char *) &pid,sizeof(int));
882: close(fd);
883: if(link(tempfile,name)<0)
884: { unlink(tempfile);
885: return(-1);
886: }
887: unlink(tempfile);
888: return(0);
889: }
890: lock(pid,tempfile,names) char *tempfile,**names;
891: { int i,j;
892: for(i=0;names[i]!=0;i++)
893: { if(onelock(pid,tempfile,names[i])==0) continue;
894: for(j=0;j<i;j++) unlink(names[j]);
895: return(-1);
896: }
897: return(0);
898: }
899:
900: #define LOCKPRE "/usr/spool/uucp/LCK."
901:
902: /***
903: * delock(s) remove a lock file
904: * char *s;
905: *
906: * return codes: 0 | FAIL
907: */
908:
909: delock(s)
910: char *s;
911: {
912: char ln[30];
913:
914: sprintf(ln, "%s.%s", LOCKPRE, s);
915: rmlock(ln);
916: }
917:
918:
919: /***
920: * mlock(sys) create system lock
921: * char *sys;
922: *
923: * return codes: 0 | FAIL
924: */
925:
926: mlock(sys)
927: char *sys;
928: {
929: char lname[30];
930: sprintf(lname, "%s.%s", LOCKPRE, sys);
931: return(ulockf(lname, (time_t) SLCKTIME ) < 0 ? FAIL : 0);
932: }
933:
934:
935:
936: /***
937: * ultouch() update access and modify times for lock files
938: *
939: * return code - none
940: */
941:
942: ultouch()
943: {
944: time_t time();
945: int i;
946: struct ut {
947: time_t actime;
948: time_t modtime;
949: } ut;
950:
951: ut.actime = time(&ut.modtime);
952: for (i = 0; i < Nlocks; i++) {
953: if (Lockfile[i] == NULL)
954: continue;
955: utime(Lockfile[i], &ut);
956: }
957: return;
958: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.