![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to dcp.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 / dcp|
Return to dcp.c CVS log | Up to [MW Coherent from dump] / coherent / a / usr / bob / uusrc / dcp |
1.1 root 1: /*
2: * dcp.c
3: *
4: * revised edition of dcp -- "dcp" a uucp clone
5: *
6: * copyright (c) richard h. lamb 1985, 1986, 1987
7: * changes copyright (c) stuart lynne may/1987
8: * changes copyright (c) peter housel nov/1988
9: * changes (massive) copyright (c) 1989-1991 by Mark Williams Company
10: *
11: * this program implements a uucico type file transfer and remote execution
12: * type protocol.
13: *
14: * Usage: uucico [-xn] [-r0] slave mode
15: * uucico [-xn] [-r1] -{sS}host call host
16: * uucico [-xn] [-r1] -{sS}all call all known hosts
17: * uucico [-xn] [-r1] -{c}all call all known hosts with queued files
18: * uucico [-xn] -r1 call uutouch queued hosts
19: */
20:
21: #include <sys/types.h>
22: #include <time.h>
23: #include <signal.h>
24: #include "dcp.h"
25: #include "perm.h"
26: #include "alarm.h"
27:
28: int pktsize; /* packet size for pro */
29: char xfromfile[BUFSIZ]; /* source of copy */
30: char xtofile[BUFSIZ]; /* destination of copy */
31: char *clinep[10]; /* pointer to fields from line from C. file */
32: char cline [BUFSIZ]; /* line from C. file */
33:
34: char *fromfilep, *tofilep, *usernamep, *optionp, *spoolfilep, *modep, *notifyp;
35:
36: int nclinep; /* number tokens in cline */
37: long bytecount; /* transfer byte count */
38:
39: int size; /* nbytes in buff */
40: char proto[5]; /* list of protocols */
41: int bad_count;
42: int total_errors;
43: unsigned int checksum();
44:
45: /*
46: * Global Variables
47: */
48:
49: int checkfirst = 0; /* check spooldir before calling */
50: int abort_cico = 0; /* Indicates Process Abort Signalled */
51: int sysended = 0; /* Indicates sysend() was called */
52: int processid; /* Current Process Id (uucico) */
53: int fpfd = -1; /* File Decriptor used for send&receive */
54: int role = SLAVE; /* Our role, either MASTER or SLAVE */
55: char *sysname = NULL; /* Command line -[sS]sysname argument */
56: char *rmtname = NULL; /* Remote System being processed now */
57: char *logname = NULL; /* In SLAVE mode, the login name */
58: int forcecall = 0; /* Ignore L.sys spec for time to call */
59: int terminatelevel = 0; /* Indicates return code for one call */
60: char cfile[CTLFLEN]; /* Current C.* Control Work File Name */
61: FILE *cfp = NULL; /* FILE Pointer for C.* files */
62: char *nodename; /* UUCP node name (or MYNAME, perhaps) */
63: char *version; /* Version Character String */
64: int stripflg = 0; /* Flag to strip chars to 7bits on read */
65:
66: /*
67: * Extern Function Declarations
68: */
69:
70: extern int catchhup(), catchquit(), catchterm(), catchsegv();
71: extern char *getenv();
72:
73: /*
74: * Local Variables
75: */
76:
77: static char state; /* system state */
78:
79: main(argc, argv)
80: int argc;
81: char *argv[];
82: {
83: time_t now;
84: static char buf[16];
85:
86: sprintf(buf, "%.14s%s", VERSION,
87: #if SGTTY
88: "S");
89: #elif TERMIO
90: "T");
91: #elif BBS
92: "SB");
93: #endif
94: version = &buf[0];
95:
96: while(--argc) {
97: if (**++argv != '-')
98: usage();
99: switch(argv[0][1]) {
100: case 'x':
101: debuglevel = atoi(&argv[0][2]); break;
102: case 'c':
103: checkfirst = 1;
104: role = MASTER;
105: sysname = &argv[0][2];
106: break;
107: case 'S':
108: forcecall = 1;
109: case 's':
110: role = MASTER;
111: sysname = &argv[0][2]; break;
112: case 'r':
113: role = atoi(&argv[0][2]); break;
114: case 'v':
115: case 'V':
116: fatal("uucico: Version %s", version);
117: default:
118: usage(); break;
119: }
120: }
121: if ( ((role!=MASTER) && ((role!=SLAVE) || (sysname!=NULL))) ||
122: ((role==MASTER) && (sysname==NULL)) )
123: usage();
124:
125: open_debug("uucico", role==SLAVE);
126: if ( debuglevel && !lsys_access() ) {
127: printmsg(M_LOG, "unauthorized debuglevel; reset to zero.");
128: debuglevel = 0;
129: }
130: processid = getpid();
131: timedout = 0;
132: INITALRM();
133: signal(SIGINT, SIG_IGN);
134: signal(SIGHUP, catchhup);
135: signal(SIGQUIT, catchquit);
136: signal(SIGTERM, catchterm);
137: signal(SIGSEGV, catchsegv);
138:
139: if (role == MASTER) {
140: time(&now);
141: printmsg(M_CALL,
142: "System Name \"%s\", debug=%d (%.24s) (V%s)",
143: sysname, debuglevel, ctime(&now), version);
144: lsys_open();
145: state = 'I';
146: while(!abort_cico) {
147: printmsg(M_DEBUG, "Mstate = %c", state);
148: switch(state) {
149: case 'I':
150: terminatelevel = 0;
151: if ( (state=getsystem()) != 'S' )
152: rmtname = NULL;
153: break;
154: case 'S':
155:
156: /* If our check first flag is NOT set, then we call regardless
157: * of if there files pending for transfer from this site.
158: * If our check flag is set, then we only call when a file is
159: * pending for transfer.
160: */
161: if(checkfirst == 0){
162: state = callup();
163: break;
164: }
165: if((checkfirst != 0) && (scandir() == 'S')){
166: state = callup();
167: }
168: else{
169: state = 'Y';
170: plog(M_CALL,"Attempting to call, checking for queued files.");
171: plog(M_CALL,"No Files pending");
172: }
173: break;
174:
175: case 'P':
176: perm_get(rmtname, NULL);
177: nodename = myname();
178: fixline();
179: state = startup();
180: break;
181: case 'D':
182: if ( (state=master()) != 'A' )
183: break;
184: case 'A':
185: terminatelevel++;
186: case 'Y':
187: state = sysend(); break;
188: }
189: if (state == 'A')
190: break;
191: }
192: lsys_close();
193: } else {
194: state = '0';
195: while(!abort_cico) {
196: printmsg(M_DEBUG, "Sstate = %c", state);
197: switch(state) {
198: case '0':
199: state = initline() ? 'I': 'Y';
200: break;
201: case 'I':
202: if ( (logname=getenv("USER")) == NULL )
203: fatal("Can't getenv USER");
204: time(&now);
205: printmsg(M_CALL,
206: "Logname \"%s\", debug=%d (%.24s) (V%s)",
207: logname, debuglevel, ctime(&now), version);
208: perm_get(NULL, logname);
209: nodename = myname();
210: state = startup();
211: break;
212: case 'R':
213: if ( (state=slave()) != 'A' )
214: break;
215: case 'A':
216: terminatelevel++;
217: case 'Y':
218: state = sysend();
219: break;
220: }
221: if (state == 'A')
222: break;
223: }
224: }
225: if ( !sysended )
226: sysend();
227: exec_xqt();
228: exit(0);
229: }
230:
231: /*
232: * master
233: */
234: master()
235: {
236: state = 'I';
237: while(!abort_cico) {
238: printmsg(M_CONVERSE, "Top level state (master mode) %c", state);
239: switch(state) {
240: case 'I': state = sinit(); break;
241: case 'B': state = scandir(); break;
242: case 'S': state = sendf(); break;
243: case 'Q': state = sbreak(); break;
244: case 'G': state = recvf(); break;
245: case 'C': state = 'Y'; break;
246: case 'Y': state = endp(); break;
247: case 'P': return ('Y');
248: case 'A': return ('A');
249: default: return ('A');
250: }
251: }
252: return('A');
253: }
254:
255: /*
256: * slave
257: */
258: slave()
259: {
260: state = 'I';
261: while(!abort_cico) {
262: printmsg(M_CONVERSE, "Top level state (slave mode) %c", state);
263: switch(state) {
264: case 'I': state = rinit(); break;
265: case 'F': state = recvf(); break;
266: case 'C': state = schkdir(); break;
267: case 'T': state = 'B'; break;
268: case 'B': state = scandir(); break;
269: case 'S': state = sendf(); break;
270: case 'Q': state = sbreak(); break;
271: case 'G': return ('Y');
272: case 'Y': state = endp(); break;
273: case 'P': return ('Y');
274: case 'A': return ('A');
275: default: return ('A');
276: }
277: }
278: return('A');
279: }
280:
281: /*
282: * r e c v f
283: *
284: * This is the state table switcher for receiving files.
285: */
286:
287: recvf()
288: {
289: state = 'F'; /* Receive-Init is the start state */
290: while(!abort_cico) {
291: printmsg(M_DEBUG, " recvf state: %c", state);
292: switch(state) {
293: case 'F': state = rmtcmd(); break; /* Rcv File */
294: case 'J': state = rdata(); break; /* Rcv Data */
295: case 'D': state = sdata(); break;
296: case 'Z': state = seof(); break;
297: case 'C': return ('C'); /* Complete state */
298: case 'A': return ('Y'); /* Abort state */
299: default: return ('Y'); /* Abort state */
300: }
301: }
302: return('A');
303: }
304:
305:
306: /*
307: * s e n d f
308: *
309: * Sendsw is the state table switcher for sending files. It loops until either
310: * it finishes, or an error is encountered. The routines called by sendsw
311: * are responsible for changing the state.
312: * -
313: * This routine is more properly called the command file reader.
314: * It needs to dispatch to sfile and rfile based upon decoding of records in
315: * the C.<> file.
316: *
317: */
318: sendf()
319: {
320: fpfd = -1; /* reset file getter/opener */
321: state = 'F'; /* Send initiate is the start state */
322: while(!abort_cico) { /* Do this as long as necessary */
323: printmsg(M_DEBUG, "sendf state: %c", state);
324: switch(state) {
325: case 'F': state = cdotcmd(); break; /* Send-File */
326: case 'J': state = rdata(); break;
327: case 'D': state = sdata(); break; /* Send-Data */
328: case 'Z': state = seof(); break; /* Send-EoF */
329: case 'B': return ('B'); /* Complete */
330: case 'A': return ('Y'); /* Abort */
331: default: return ('Y'); /* Unknown, fail */
332: }
333: }
334: return('A');
335: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.