![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to xcmd.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [MW Coherent from dump] / coherent / g / usr / lib / uucp / tay104|
Return to xcmd.c CVS log | Up to [MW Coherent from dump] / coherent / g / usr / lib / uucp / tay104 |
1.1 root 1: /* xcmd.c
2: Routines to handle work requests.
3:
4: Copyright (C) 1991, 1992 Ian Lance Taylor
5:
6: This file is part of the Taylor UUCP package.
7:
8: This program is free software; you can redistribute it and/or
9: modify it under the terms of the GNU General Public License as
10: published by the Free Software Foundation; either version 2 of the
11: License, or (at your option) any later version.
12:
13: This program is distributed in the hope that it will be useful, but
14: WITHOUT ANY WARRANTY; without even the implied warranty of
15: MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16: General Public License for more details.
17:
18: You should have received a copy of the GNU General Public License
19: along with this program; if not, write to the Free Software
20: Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
21:
22: The author of the program may be contacted at [email protected] or
23: c/o Infinity Development Systems, P.O. Box 520, Waltham, MA 02254.
24: */
25:
26: #include "uucp.h"
27:
28: #if USE_RCS_ID
29: const char xcmd_rcsid[] = "$Id: xcmd.c,v 1.1 93/07/30 08:00:19 bin Exp Locker: bin $";
30: #endif
31:
32: #include <errno.h>
33:
34: #include "uudefs.h"
35: #include "uuconf.h"
36: #include "system.h"
37: #include "prot.h"
38: #include "trans.h"
39:
40: /* Local functions. */
41:
42: static boolean flocal_xcmd_request P((struct stransfer *qtrans,
43: struct sdaemon *qdaemon));
44: static boolean flocal_xcmd_await_reply P((struct stransfer *qtrans,
45: struct sdaemon *qdaemon,
46: const char *zdata, size_t cdata));
47: static boolean fremote_xcmd_reply P((struct stransfer *qtrans,
48: struct sdaemon *qdaemon));
49:
50: /* Handle a local work request. We just set up the request for
51: transmission. */
52:
53: boolean
54: flocal_xcmd_init (qdaemon, qcmd)
55: struct sdaemon *qdaemon;
56: struct scmd *qcmd;
57: {
58: struct stransfer *qtrans;
59:
60: qtrans = qtransalc (qcmd);
61: qtrans->psendfn = flocal_xcmd_request;
62:
63: return fqueue_local (qdaemon, qtrans);
64: }
65:
66: /* Send the execution request to the remote system. */
67:
68: static boolean
69: flocal_xcmd_request (qtrans, qdaemon)
70: struct stransfer *qtrans;
71: struct sdaemon *qdaemon;
72: {
73: size_t clen;
74: char *zsend;
75: boolean fret;
76:
77: ulog (LOG_NORMAL, "Requesting work: %s to %s", qtrans->s.zfrom,
78: qtrans->s.zto);
79:
80: /* We send the string
81: X from to user options
82: We put a dash in front of options. */
83: clen = (strlen (qtrans->s.zfrom) + strlen (qtrans->s.zto)
84: + strlen (qtrans->s.zuser) + strlen (qtrans->s.zoptions) + 7);
85: zsend = zbufalc (clen);
86: sprintf (zsend, "X %s %s %s -%s", qtrans->s.zfrom, qtrans->s.zto,
87: qtrans->s.zuser, qtrans->s.zoptions);
88:
89: fret = (*qdaemon->qproto->pfsendcmd) (qdaemon, zsend, qtrans->ilocal,
90: qtrans->iremote);
91: ubuffree (zsend);
92: if (! fret)
93: {
94: utransfree (qtrans);
95: return FALSE;
96: }
97:
98: qtrans->fcmd = TRUE;
99: qtrans->precfn = flocal_xcmd_await_reply;
100:
101: return fqueue_receive (qdaemon, qtrans);
102: }
103:
104: /* Get a reply to an execution request from the remote system. */
105:
106: /*ARGSUSED*/
107: static boolean
108: flocal_xcmd_await_reply (qtrans, qdaemon, zdata, cdata)
109: struct stransfer *qtrans;
110: struct sdaemon *qdaemon;
111: const char *zdata;
112: size_t cdata;
113: {
114: qtrans->precfn = NULL;
115:
116: if (zdata[0] != 'X'
117: || (zdata[1] != 'Y' && zdata[1] != 'N'))
118: {
119: ulog (LOG_ERROR, "Bad response to work request");
120: utransfree (qtrans);
121: return FALSE;
122: }
123:
124: if (zdata[1] == 'N')
125: {
126: ulog (LOG_ERROR, "%s: work request denied", qtrans->s.zfrom);
127: (void) fmail_transfer (FALSE, qtrans->s.zuser, (const char *) NULL,
128: "work request denied",
129: qtrans->s.zfrom, qdaemon->qsys->uuconf_zname,
130: qtrans->s.zto, (const char *) NULL,
131: (const char *) NULL);
132: }
133:
134: (void) fsysdep_did_work (qtrans->s.pseq);
135: utransfree (qtrans);
136:
137: return TRUE;
138: }
139:
140: /* Handle a remote work request. This just queues up the requests for
141: later processing. */
142:
143: boolean
144: fremote_xcmd_init (qdaemon, qcmd, iremote)
145: struct sdaemon *qdaemon;
146: struct scmd *qcmd;
147: int iremote;
148: {
149: const struct uuconf_system *qsys;
150: const char *zexclam;
151: const struct uuconf_system *qdestsys;
152: struct uuconf_system sdestsys;
153: char *zdestfile;
154: boolean fmkdirs;
155: struct stransfer *qtrans;
156: char *zuser;
157: char aboptions[5];
158: char *zfrom;
159: boolean fret;
160: char *zfile;
161:
162: ulog (LOG_NORMAL, "Work requested: %s to %s", qcmd->zfrom,
163: qcmd->zto);
164:
165: qsys = qdaemon->qsys;
166:
167: zexclam = strchr (qcmd->zto, '!');
168: if (zexclam == NULL
169: || zexclam == qcmd->zto
170: || strncmp (qdaemon->zlocalname, qcmd->zto,
171: (size_t) (zexclam - qcmd->zto)) == 0)
172: {
173: const char *zconst;
174:
175: /* The files are supposed to be copied to the local system. */
176: qdestsys = NULL;
177: if (zexclam == NULL)
178: zconst = qcmd->zto;
179: else
180: zconst = zexclam + 1;
181:
182: zdestfile = zsysdep_local_file (zconst, qsys->uuconf_zpubdir);
183: if (zdestfile == NULL)
184: return FALSE;
185:
186: zuser = NULL;
187: fmkdirs = strchr (qcmd->zoptions, 'f') != NULL;
188: }
189: else
190: {
191: size_t clen;
192: char *zcopy;
193: int iuuconf;
194: char *zoptions;
195:
196: clen = zexclam - qcmd->zto;
197: zcopy = zbufalc (clen + 1);
198: memcpy (zcopy, qcmd->zto, clen);
199: zcopy[clen] = '\0';
200:
201: iuuconf = uuconf_system_info (qdaemon->puuconf, zcopy, &sdestsys);
202: if (iuuconf == UUCONF_NOT_FOUND)
203: {
204: if (! funknown_system (qdaemon->puuconf, zcopy, &sdestsys))
205: {
206: ulog (LOG_ERROR, "%s: System not found", zcopy);
207: ubuffree (zcopy);
208: qtrans = qtransalc (qcmd);
209: qtrans->psendfn = fremote_xcmd_reply;
210: qtrans->pinfo = (pointer) "XN";
211: qtrans->iremote = iremote;
212: return fqueue_remote (qdaemon, qtrans);
213: }
214: }
215: else if (iuuconf != UUCONF_SUCCESS)
216: {
217: ulog_uuconf (LOG_ERROR, qdaemon->puuconf, iuuconf);
218: ubuffree (zcopy);
219: return FALSE;
220: }
221:
222: ubuffree (zcopy);
223:
224: qdestsys = &sdestsys;
225: zdestfile = zbufcpy (zexclam + 1);
226:
227: zuser = zbufalc (strlen (qdestsys->uuconf_zname)
228: + strlen (qcmd->zuser) + sizeof "!");
229: sprintf (zuser, "%s!%s", qdestsys->uuconf_zname, qcmd->zuser);
230: zoptions = aboptions;
231: *zoptions++ = 'C';
232: if (strchr (qcmd->zoptions, 'd') != NULL)
233: *zoptions++ = 'd';
234: if (strchr (qcmd->zoptions, 'm') != NULL)
235: *zoptions++ = 'm';
236: *zoptions = '\0';
237: fmkdirs = TRUE;
238: }
239:
240: /* At this point we prepare to confirm the remote request. We could
241: actually fork here and let the child spool up the requests. */
242: qtrans = qtransalc (qcmd);
243: qtrans->psendfn = fremote_xcmd_reply;
244: qtrans->pinfo = (pointer) "XY";
245: qtrans->iremote = iremote;
246: if (! fqueue_remote (qdaemon, qtrans))
247: {
248: ubuffree (zdestfile);
249: ubuffree (zuser);
250: return FALSE;
251: }
252:
253: /* Now we have to process each source file. The source
254: specification may or may use wildcards. */
255: zfrom = zsysdep_local_file (qcmd->zfrom, qsys->uuconf_zpubdir);
256: if (zfrom == NULL)
257: {
258: ubuffree (zdestfile);
259: ubuffree (zuser);
260: return FALSE;
261: }
262:
263: if (! fsysdep_wildcard_start (zfrom))
264: {
265: ubuffree (zfrom);
266: ubuffree (zdestfile);
267: ubuffree (zuser);
268: return FALSE;
269: }
270:
271: fret = TRUE;
272:
273: while ((zfile = zsysdep_wildcard (zfrom)) != NULL)
274: {
275: char *zto;
276: char abtname[CFILE_NAME_LEN];
277:
278: if (! fsysdep_file_exists (zfile))
279: {
280: ulog (LOG_ERROR, "%s: no such file", zfile);
281: continue;
282: }
283:
284: /* Make sure the remote system is permitted to read the
285: specified file. */
286: if (! fin_directory_list (zfile, qsys->uuconf_pzremote_send,
287: qsys->uuconf_zpubdir, TRUE, TRUE,
288: (const char *) NULL))
289: {
290: ulog (LOG_ERROR, "%s: not permitted to send", zfile);
291: break;
292: }
293:
294: if (qdestsys != NULL)
295: {
296: /* We really should get the original grade here. */
297: zto = zsysdep_data_file_name (qdestsys, qdaemon->zlocalname,
298: BDEFAULT_UUCP_GRADE, FALSE,
299: abtname, (char *) NULL,
300: (char *) NULL);
301: if (zto == NULL)
302: {
303: fret = FALSE;
304: break;
305: }
306: }
307: else
308: {
309: zto = zsysdep_add_base (zdestfile, zfile);
310: if (zto == NULL)
311: {
312: fret = FALSE;
313: break;
314: }
315: /* We only accept a local destination if the remote system
316: has the right to create files there. */
317: if (! fin_directory_list (zto, qsys->uuconf_pzremote_receive,
318: qsys->uuconf_zpubdir, TRUE, FALSE,
319: (const char *) NULL))
320: {
321: ulog (LOG_ERROR, "%s: not permitted to receive", zto);
322: ubuffree (zto);
323: break;
324: }
325: }
326:
327: /* Copy the file either to the final destination or to the
328: spool directory. */
329: if (! fcopy_file (zfile, zto, qdestsys == NULL, fmkdirs))
330: {
331: ubuffree (zto);
332: break;
333: }
334:
335: ubuffree (zto);
336:
337: /* If there is a destination system, queue it up. */
338: if (qdestsys != NULL)
339: {
340: struct scmd ssend;
341: char *zjobid;
342:
343: ssend.bcmd = 'S';
344: ssend.pseq = NULL;
345: ssend.zfrom = zfile;
346: ssend.zto = zdestfile;
347: ssend.zuser = zuser;
348: ssend.zoptions = aboptions;
349: ssend.ztemp = abtname;
350: ssend.imode = ixsysdep_file_mode (zfile);
351: ssend.znotify = "";
352: ssend.cbytes = -1;
353: ssend.zcmd = NULL;
354: ssend.ipos = 0;
355:
356: zjobid = zsysdep_spool_commands (qdestsys, BDEFAULT_UUCP_GRADE,
357: 1, &ssend);
358: if (zjobid == NULL)
359: break;
360: ubuffree (zjobid);
361: }
362:
363: ubuffree (zfile);
364: }
365:
366: if (zfile != NULL)
367: ubuffree (zfile);
368:
369: (void) fsysdep_wildcard_end ();
370:
371: ubuffree (zdestfile);
372: if (qdestsys != NULL)
373: (void) uuconf_system_free (qdaemon->puuconf, &sdestsys);
374:
375: ubuffree (zfrom);
376: ubuffree (zuser);
377:
378: return fret;
379: }
380:
381: /* Reply to a remote work request. */
382:
383: static boolean
384: fremote_xcmd_reply (qtrans, qdaemon)
385: struct stransfer *qtrans;
386: struct sdaemon *qdaemon;
387: {
388: boolean fret;
389:
390: fret = (*qdaemon->qproto->pfsendcmd) (qdaemon,
391: (const char *) qtrans->pinfo,
392: qtrans->ilocal,
393: qtrans->iremote);
394: utransfree (qtrans);
395: return fret;
396: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.