![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to ckcfn3.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [MW Coherent from dump] / coherent / e / bin / ckermit|
Return to ckcfn3.c CVS log | Up to [MW Coherent from dump] / coherent / e / bin / ckermit |
1.1 root 1: /* C K C F N 3 -- Packet buffer management for C-Kermit */
2:
3: /* (plus assorted functions tacked on at the end) */
4:
5: /*
6: Author: Frank da Cruz ([email protected], [email protected]),
7: Columbia University Center for Computing Activities.
8: First released January 1985.
9: Copyright (C) 1985, 1992, Trustees of Columbia University in the City of New
10: York. Permission is granted to any individual or institution to use this
11: software as long as it is not sold for profit. This copyright notice must be
12: retained. This software may not be included in commercial products without
13: written permission of Columbia University.
14: */
15:
16: #include "ckcdeb.h"
17: #include "ckcasc.h"
18: #include "ckcker.h"
19: #include "ckcxla.h"
20:
21: extern int unkcs, wmax, wcur, discard, bctu, bctl, local, fdispla;
22: extern CHAR *data;
23: extern char filnam[];
24: #ifndef NOFRILLS
25: extern int rprintf, rmailf; /* REMOTE MAIL, PRINT */
26: extern char optbuf[]; /* Options buffer for mail, print */
27: #endif /* NOFRILLS */
28: extern int wslots;
29: extern int fblksiz, frecl, forg, frecfm, fncact, fcctrl, lf_opts;
30: #ifdef DYNAMIC
31: extern CHAR *srvcmd;
32: #else
33: extern CHAR srvcmd[];
34: #endif
35:
36: extern int binary, spsiz;
37: extern int pktnum, cxseen, czseen, bsave, bsavef, nfils, stdinf;
38: extern int memstr, stdouf, keep, sndsrc, hcflg;
39: extern int server, en_cwd;
40:
41: extern int
42: atenci, atenco, atdati, atdato, atleni, atleno, atblki, atblko,
43: attypi, attypo, atsidi, atsido, atsysi, atsyso, atdisi, atdiso;
44:
45: #ifdef datageneral
46: extern int quiet;
47: #endif /* datageneral */
48:
49: extern long fsize, filcnt, ffc, tfc;
50:
51: #ifndef NOCSETS
52: extern int tcharset, fcharset;
53: extern int ntcsets;
54: extern struct csinfo tcsinfo[], fcsinfo[];
55:
56: /* Pointers to translation functions */
57: #ifdef CK_ANSIC
58: extern CHAR (*xls[MAXTCSETS+1][MAXFCSETS+1])(CHAR); /* Character set */
59: extern CHAR (*xlr[MAXTCSETS+1][MAXFCSETS+1])(CHAR); /* translation functions */
60: extern CHAR (*rx)(CHAR); /* Pointer to input character translation function */
61: extern CHAR (*sx)(CHAR); /* Pointer to output character translation function */
62: #else
63: extern CHAR (*xls[MAXTCSETS+1][MAXFCSETS+1])(); /* Character set */
64: extern CHAR (*xlr[MAXTCSETS+1][MAXFCSETS+1])(); /* translation functions. */
65: extern CHAR (*rx)(); /* Pointer to input character translation function */
66: extern CHAR (*sx)(); /* Pointer to output character translation function */
67: #endif /* CK_ANSIC */
68: #endif /* NOCSETS */
69:
70: /* Variables global to Kermit that are defined in this module */
71:
72: int winlo; /* packet number at low window edge */
73:
74: int sbufnum; /* number of free buffers */
75: int dum001 = 1234; /* protection... */
76: int sbufuse[MAXWS]; /* buffer in-use flag */
77: int dum003 = 1111;
78: int rbufnum; /* number of free buffers */
79: int dum002 = 4321; /* more protection */
80: int rbufuse[MAXWS]; /* buffer in-use flag */
81: int sseqtbl[64]; /* sequence # to buffer # table */
82: int rseqtbl[64]; /* sequence # to buffer # table */
83: int sacktbl[64]; /* sequence # ack table */
84:
85: #ifdef DYNAMIC
86: struct pktinfo *s_pkt = NULL; /* array of pktinfo structures */
87: struct pktinfo *r_pkt = NULL; /* array of pktinfo structures */
88: #else
89: struct pktinfo s_pkt[MAXWS]; /* array of pktinfo structures */
90: struct pktinfo r_pkt[MAXWS]; /* array of pktinfo structures */
91: #endif /* DYNAMIC */
92:
93: #ifdef DEBUG
94: char xbuf[200]; /* For debug logging */
95: #endif /* DEBUG */
96:
97: #ifdef DYNAMIC
98: CHAR *bigsbuf = NULL, *bigrbuf = NULL;
99: #else
100: char bigsbt[8]; /* Protection (shouldn't need this). */
101: /* BUT DON'T REMOVE IT! */
102: CHAR bigsbuf[SBSIZ + 5]; /* Send-packet buffer area */
103: char bigrbt[8]; /* Safety padding */
104: CHAR bigrbuf[RBSIZ + 5]; /* Receive-packet area */
105: #endif
106: int bigsbsiz = SBSIZ; /* Sizes of big send & rcv buffers. */
107: int bigrbsiz = RBSIZ;
108:
109: /* FUNCTIONS */
110:
111: /* For sanity, use "i" for buffer slots, "n" for packet numbers. */
112:
113: /* I N I B U F S */
114:
115: /*
116: Allocates the big send and receive buffers.
117: Call with size for big send buffer (s) and receive buffer (r).
118: These sizes can be different.
119: Attempts to allocate buffers of the requested size, but if it can't,
120: it will allocate smaller ones.
121: Sets global variables bigsbsiz and bigrbsiz to the actual sizes,
122: and bigsbuf and bigrbuf pointing to the actual buffers.
123: Designed to be called more than once.
124: Returns 0 on success, -1 on failure.
125: */
126:
127: CHAR *bigbufp = NULL;
128:
129: int
130: inibufs(s,r) int s, r; {
131: #ifdef DYNAMIC
132: int size, x;
133: long z;
134:
135: if (s < 80 || r < 80) return(-1); /* Validate arguments. */
136:
137: if (!s_pkt) { /* Allocate packet info structures */
138: if (!(s_pkt = (struct pktinfo *) malloc(sizeof(struct pktinfo)*MAXWS)))
139: fatal("ini_pkts: no memory for s_pkt");
140: }
141: for (x = 0; x < MAXWS; x++)
142: s_pkt[x].pk_adr = NULL; /* Initialize addresses */
143:
144: if (!r_pkt) {
145: if (!(r_pkt = (struct pktinfo *) malloc(sizeof(struct pktinfo)*MAXWS)))
146: fatal("ini_pkts: no memory for s_pkt");
147: }
148: for (x = 0; x < MAXWS; x++)
149: r_pkt[x].pk_adr = NULL; /* Initialize addresses */
150:
151: if (!srvcmd) { /* Allocate srvcmd buffer */
152: srvcmd = (CHAR *) malloc(r + 100);
153: if (!srvcmd) return(-1);
154: }
155: if (bigbufp) { /* Free previous buffers, if any. */
156: free(bigbufp);
157: bigbufp = NULL;
158: }
159: size = s + r + 40; /* Combined requested size + padding */
160:
161: /* Try to get the space. If malloc fails, try to get a little less. */
162: /* (Obviously, this algorithm can be refined.) */
163:
164: while (!(bigbufp = (CHAR *) malloc(size))) {
165: size = (size * 3) / 2; /* Failed, cut size by 1/3. */
166: if (size < 200) /* Try again until too small. */
167: return(-1);
168: }
169: debug(F101,"inibufs size","",size); /* OK, we got some space. */
170:
171: /*
172: Now divide the allocated space between the send and receive buffers in the
173: requested proportion. The natural formula would be (s / (s + r)) * size
174: (for the send buffer), but that doesn't work with integer arithmetic and we
175: can't use floating point because some machines don't have it. This can be
176: rearranged as (s * size) / (s + r). But (s * size) can be VERY large, too
177: large for 32 bits. So let's do it this way. This arithmetic works for
178: buffer sizes up to about 5,000,000.
179: */
180: #define FACTOR 20L
181: z = ( (long) s * FACTOR ) / ( (long) s + (long) r );
182: x = ( z * ( (long) size / FACTOR ) );
183: if (x < 0) return(-1); /* Catch overflow */
184:
185: bigsbsiz = x - 5; /* Size of send buffer */
186: bigsbuf = bigbufp; /* Address of send buffer */
187: debug(F101,"inibufs bigsbsiz","",bigsbsiz);
188:
189: bigrbsiz = size - x - 5; /* Size of receive buffer */
190: bigrbuf = bigbufp + x; /* Addresss of receive buffer */
191: debug(F101,"inibufs bigrbsiz","",bigrbsiz);
192:
193: return(0); /* Success */
194: #else /* No dynamic allocation */
195: bigsbsiz = SBSIZ; /* Just use the symbols */
196: bigrbsiz = RBSIZ; /* ... */
197: return(0); /* Success. */
198: #endif /* DYNAMIC */
199: }
200:
201:
202: /* M A K E B U F -- Makes and clears a new buffers. */
203:
204: /* Call with: */
205: /* slots: number of buffer slots to make, 1 to 31 */
206: /* bufsiz: size of the big buffer */
207: /* buf: address of the big buffer */
208: /* xx: pointer to array of pktinfo structures for these buffers */
209:
210: /* Subdivides the big buffer into "slots" buffers. */
211:
212: /* Returns: */
213: /* -1 if too many or too few slots requested, */
214: /* -2 if slots would be too small. */
215: /* n (positive) on success = size of one buffer. */
216: /* with pktinfo structure initialized for this set of buffers. */
217:
218: int
219: makebuf(slots,bufsiz,buf,xx)
220: /* makebuf */ int slots, bufsiz; CHAR buf[]; struct pktinfo *xx; {
221:
222: CHAR *a;
223: int i, size;
224:
225: debug(F101,"makebuf","",slots);
226: debug(F101,"makebuf bufsiz","",bufsiz);
227: debug(F101,"makebuf MAXWS","",MAXWS);
228:
229: if (slots > MAXWS || slots < 1) return(-1);
230: if (bufsiz < slots * 10 ) return(-2);
231:
232: size = bufsiz / slots; /* Divide up the big buffer. */
233: a = buf; /* Address of first piece. */
234:
235: for (i = 0; i < slots; i++) {
236: struct pktinfo *x = &xx[i];
237: x->bf_adr = a; /* Address of this buffer */
238: x->bf_len = size; /* Length of this buffer */
239: x->pk_len = 0; /* Length of data field */
240: x->pk_typ = ' '; /* packet type */
241: x->pk_seq = -1; /* packet sequence number */
242: x->pk_flg = 0; /* ack'd bit */
243: x->pk_rtr = 0; /* retransmissions */
244: *a = '\0'; /* Clear the buffer */
245: a += size; /* Position to next buffer slot */
246: }
247: return(size);
248: }
249:
250: /* M A K S B U F -- Makes the send-packet buffer */
251:
252: int
253: mksbuf(slots) int slots; {
254: int i, x;
255: sbufnum = 0;
256: if ((x = makebuf(slots,bigsbsiz,bigsbuf,s_pkt)) < 0) {
257: debug(F101,"mksbuf makebuf return","",x);
258: return(x);
259: }
260: debug(F101,"mksbuf makebuf return","",x);
261: for (i = 0; i < 64; i++) { /* Initialize sequence-number- */
262: sseqtbl[i] = -1; /* to-buffer-number table. */
263: sacktbl[i] = 0;
264: }
265: for (i = 0; i < MAXWS; i++)
266: sbufuse[i] = 0; /* Mark each buffer as free */
267: sbufnum = slots;
268: return(x);
269: }
270:
271: /* M A K R B U F -- Makes the receive-packet buffer */
272:
273: int
274: mkrbuf(slots) int slots; {
275: int i, x;
276: rbufnum = 0;
277: if ((x = makebuf(slots,bigrbsiz,bigrbuf,r_pkt)) < 0) {
278: debug(F101,"mkrbuf makebuf return","",x);
279: return(x);
280: }
281: debug(F101,"mkrbuf makebuf return","",x);
282: for (i = 0; i < 64; i++) { /* Initialize sequence-number- */
283: rseqtbl[i] = -1; /* to-buffer-number table. */
284: }
285: for (i = 0; i < MAXWS; i++)
286: rbufuse[i] = 0; /* Mark each buffer as free */
287: rbufnum = slots;
288: return(x);
289: }
290:
291: /* W I N D O W -- Resize the window to n */
292:
293: int
294: window(n) int n; {
295: debug(F101,"window","",n);
296: if (n < 1 || n > 31) return(-1);
297: if (mksbuf(n) < 0) return(-1);
298: if (mkrbuf(n) < 0) return(-1);
299: wslots = n;
300: #ifdef DEBUG
301: if (deblog) dumpsbuf();
302: if (deblog) dumprbuf();
303: #endif /* DEBUG */
304: return(0);
305: }
306:
307: /* G E T S B U F -- Allocate a send-buffer. */
308:
309: /* Call with packet sequence number to allocate buffer for. */
310: /* Returns: */
311: /* -4 if argument is invalid (negative, or greater than 63) */
312: /* -3 if buffers were thought to be available but really weren't (bug!) */
313: /* -2 if the number of free buffers is negative (bug!) */
314: /* -1 if no free buffers. */
315: /* 0 or positive, packet sequence number, with buffer allocated for it. */
316:
317: int
318: getsbuf(n) int n; { /* Allocate a send-buffer */
319: int i;
320: if (n < 0 || n > 63) {
321: debug(F101,"getsbuf bad arg","",n);
322: return(-4); /* Bad argument */
323: }
324: debug(F101,"getsbuf, packet","",n);
325: debug(F101,"getsbuf, sbufnum","",sbufnum);
326: if (sbufnum == 0) return(-1); /* No free buffers. */
327: if (sbufnum < 0) return(-2); /* Shouldn't happen. */
328: for (i = 0; i < wslots; i++) /* Find the first one not in use. */
329: if (sbufuse[i] == 0) { /* Got one? */
330: sbufuse[i] = 1; /* Mark it as in use. */
331: sbufnum--; /* One less free buffer. */
332: *s_pkt[i].bf_adr = '\0'; /* Zero the buffer data field */
333: s_pkt[i].pk_seq = n; /* Put in the sequence number */
334: sseqtbl[n] = i; /* Back pointer from sequence number */
335: sacktbl[n] = 0; /* ACK flag */
336: s_pkt[i].pk_len = 0; /* Data field length now zero. */
337: s_pkt[i].pk_typ = ' '; /* Blank the packet type too. */
338: s_pkt[i].pk_flg = 0; /* Zero the flags */
339: s_pkt[i].pk_rtr = 0; /* Zero the retransmission count */
340: data = s_pkt[i].bf_adr + 7; /* Set global "data" address. */
341: wcur = wslots - sbufnum; /* Current number of window slots */
342: if (i+1 > wmax) wmax = i+1; /* For statistics. */
343: return(n); /* Return its index. */
344: }
345: sbufnum = 0; /* Didn't find one. */
346: return(-3); /* Shouldn't happen! */
347: }
348:
349: int
350: getrbuf() { /* Allocate a receive buffer */
351: int i;
352: debug(F101,"getrbuf rbufnum","",rbufnum);
353: debug(F101,"getrbuf wslots","",wslots);
354: debug(F101,"getrbuf dum002","",dum002);
355: debug(F101,"getrbuf dum003","",dum003);
356: if (rbufnum == 0) return(-1); /* No free buffers. */
357: if (rbufnum < 0) return(-2); /* Shouldn't happen. */
358: for (i = 0; i < wslots; i++) /* Find the first one not in use. */
359: if (rbufuse[i] == 0) { /* Got one? */
360: rbufuse[i] = 1; /* Mark it as in use. */
361: *r_pkt[i].bf_adr = '\0'; /* Zero the buffer data field */
362: rbufnum--; /* One less free buffer. */
363: debug(F101,"getrbuf new rbufnum","",rbufnum);
364: #ifdef COMMENT
365: wcur = wslots - rbufnum; /* Current number of window slots */
366: #endif /* COMMENT */
367: if (i+1 > wmax) wmax = i+1; /* For statistics. */
368: return(i); /* Return its index. */
369: }
370: debug(F101,"getrbuf foulup","",i);
371: rbufnum = 0; /* Didn't find one. */
372: return(-3); /* Shouldn't happen! */
373: }
374:
375: /* F R E E S B U F -- Free send-buffer for given packet sequence number */
376:
377: /* Returns: */
378: /* 1 upon success */
379: /* -1 if specified buffer does not exist */
380:
381: int
382: freesbuf(n) int n; { /* Release send-buffer for packet n. */
383: int i;
384:
385: debug(F101,"freesbuf","",n);
386: if (n < 0 || n > 63) /* No such packet. */
387: return(-1);
388: i = sseqtbl[n]; /* Get the window slot number. */
389: if (i > -1 && i <= wslots) {
390: sseqtbl[n] = -1; /* If valid, remove from seqtbl */
391: sbufnum++; /* and count one more free buffer */
392: sbufuse[i] = 0; /* and mark it as free, */
393: } else {
394: debug(F101," sseqtbl[n]","",sseqtbl[n]);
395: return(-1);
396: }
397:
398: /* The following is done only so dumped buffers will look right. */
399:
400: if (1) {
401: *s_pkt[i].bf_adr = '\0'; /* Zero the buffer data field */
402: s_pkt[i].pk_seq = -1; /* Invalidate the sequence number */
403: s_pkt[i].pk_len = 0; /* Data field length now zero. */
404: s_pkt[i].pk_typ = ' '; /* Blank the packet type too. */
405: s_pkt[i].pk_flg = 0; /* And zero the flag */
406: s_pkt[i].pk_rtr = 0; /* And the retries field. */
407: }
408: return(1);
409: }
410:
411: int
412: freerbuf(i) int i; { /* Release receive-buffer slot "i". */
413: int n;
414:
415: /* NOTE !! Currently, this function frees the indicated buffer, but */
416: /* does NOT erase the data. The program counts on this. Will find a */
417: /* better way later.... */
418:
419: debug(F101,"freerbuf, slot","",i);
420: if (i < 0 || i >= wslots) { /* No such slot. */
421: debug(F101,"freerbuf no such slot","",i);
422: return(-1);
423: }
424: n = r_pkt[i].pk_seq; /* Get the packet sequence number */
425: debug(F101,"freerbuf, packet","",n);
426: if (n > -1 && n < 64) /* If valid, remove from seqtbl */
427: rseqtbl[n] = -1;
428: if (rbufuse[i] != 0) { /* If really allocated, */
429: rbufuse[i] = 0; /* mark it as free, */
430: rbufnum++; /* and count one more free buffer. */
431: debug(F101,"freerbuf, new rbufnum","",rbufnum);
432: }
433:
434: /* The following is done only so dumped buffers will look right. */
435:
436: if (1) {
437: /* *r_pkt[i].bf_adr = '\0'; */ /* Zero the buffer data field */
438: r_pkt[i].pk_seq = -1; /* And from packet list */
439: r_pkt[i].pk_len = 0; /* Data field length now zero. */
440: r_pkt[i].pk_typ = ' '; /* Blank the packet type too. */
441: r_pkt[i].pk_flg = 0; /* And zero the flag */
442: r_pkt[i].pk_rtr = 0; /* And the retries field. */
443: }
444: return(1);
445: }
446:
447: /* This is like freerbuf, except it's called with a packet sequence number */
448: /* rather than a packet buffer index. */
449:
450: VOID
451: freerpkt(seq) int seq; {
452: int k;
453: debug(F101,"freerpkt seq","",seq);
454: k = rseqtbl[seq];
455: debug(F101,"freerpkt k","",k);
456: if (k > -1) {
457: k = freerbuf(k);
458: debug(F101,"freerpkt freerbuf","",k);
459: }
460: }
461:
462:
463: /* C H K W I N -- Check if packet n is in window. */
464:
465: /* Returns: */
466: /* 0 if it is in the current window, */
467: /* +1 if it would have been in previous window (e.g. if ack was lost), */
468: /* -1 if it is outside any window (protocol error), */
469: /* -2 if either of the argument packet numbers is out of range. */
470:
471: /* Call with packet number to check (n), lowest packet number in window */
472: /* (bottom), and number of slots in window (slots). */
473:
474: int
475: chkwin(n,bottom,slots) int n, bottom, slots; {
476: int top, prev;
477:
478: debug(F101,"chkwin packet","",n);
479: debug(F101,"chkwin winlo","",bottom);
480: debug(F101,"chkwin slots","",slots);
481:
482: /* First do the easy and common cases, where the windows are not split. */
483:
484: if (n < 0 || n > 63 || bottom < 0 || bottom > 63)
485: return(-2);
486:
487: if (n == bottom) return(0); /* In a perfect world... */
488:
489: top = bottom + slots; /* Calculate window top. */
490: if (top < 64 && n < top && n >= bottom)
491: return(0); /* In current window. */
492:
493: prev = bottom - slots; /* Bottom of previous window. */
494: if (prev > -1 && n < bottom && n > prev)
495: return(1); /* In previous. */
496:
497: /* Now consider the case where the current window is split. */
498:
499: if (top > 63) { /* Wraparound... */
500: top -= 64; /* Get modulo-64 sequence number */
501: if (n < top || n >= bottom) {
502: return(0); /* In current window. */
503: } else { /* Not in current window. */
504: if (n < bottom && n >= prev) /* Previous window can't be split. */
505: return(1); /* In previous window. */
506: else
507: return(-1); /* Not in previous window. */
508: }
509: }
510:
511: /* Now the case where current window not split, but previous window is. */
512:
513: if (prev < 0) { /* Is previous window split? */
514: prev += 64; /* Yes. */
515: if (n < bottom || n >= prev)
516: return(1); /* In previous window. */
517: } else { /* Previous window not split. */
518: if (n < bottom && n >= prev)
519: return(1); /* In previous window. */
520: }
521:
522: /* It's not in the current window, and not in the previous window... */
523:
524: return(-1); /* So it's not in any window. */
525: }
526:
527: int
528: dumpsbuf() { /* Dump send-buffers */
529: #ifdef DEBUG
530: int j, x; /* to debug log. */
531:
532: if (! deblog) return(0);
533: x = zsoutl(ZDFILE,"SEND BUFFERS:");
534: if (x < 0) {
535: deblog = 0;
536: return(0);
537: }
538: x=zsoutl(ZDFILE,"buffer inuse address length data type seq flag retries");
539: if (x < 0) {
540: deblog = 0;
541: return(0);
542: }
543: for ( j = 0; j < wslots; j++ ) {
544: sprintf(xbuf,"%4d%6d%10d%5d%6d%4c%5d%5d%6d\n",
545: j,
546: sbufuse[j],
547: s_pkt[j].bf_adr,
548: s_pkt[j].bf_len,
549: s_pkt[j].pk_len,
550: s_pkt[j].pk_typ,
551: s_pkt[j].pk_seq,
552: s_pkt[j].pk_flg,
553: s_pkt[j].pk_rtr
554: );
555: if (zsout(ZDFILE,xbuf) < 0) {
556: deblog = 0;
557: return(0);
558: }
559: if (s_pkt[j].pk_adr) {
560: x = (int)strlen((char *) s_pkt[j].pk_adr);
561: if (x)
562: sprintf(xbuf,"[%.72s%s]\n",s_pkt[j].pk_adr, x > 72 ? "..." : "");
563: else
564: sprintf(xbuf,"[(empty string)]\n");
565: } else {
566: sprintf(xbuf,"[(null pointer)]\n");
567: }
568: if (zsout(ZDFILE,xbuf) < 0) {
569: deblog = 0;
570: return(0);
571: }
572: }
573: sprintf(xbuf,"free: %d, winlo: %d\n", sbufnum, winlo);
574: if (zsout(ZDFILE,xbuf) < 0) {
575: deblog = 0;
576: return(0);
577: }
578: return(0);
579: #endif /* DEBUG */
580: }
581: int
582: dumprbuf() { /* Dump receive-buffers */
583: #ifdef DEBUG
584: int j, x;
585: if (! deblog) return(0);
586: if (zsoutl(ZDFILE,"RECEIVE BUFFERS:") < 0) {
587: deblog = 0;
588: return(0);
589: }
590: x=zsoutl(ZDFILE,"buffer inuse address length data type seq flag retries");
591: if (x < 0) {
592: deblog = 0;
593: return(0);
594: }
595: for ( j = 0; j < wslots; j++ ) {
596: sprintf(xbuf,"%4d%6d%10d%5d%6d%4c%5d%5d%6d\n",
597: j,
598: rbufuse[j],
599: r_pkt[j].bf_adr,
600: r_pkt[j].bf_len,
601: r_pkt[j].pk_len,
602: r_pkt[j].pk_typ,
603: r_pkt[j].pk_seq,
604: r_pkt[j].pk_flg,
605: r_pkt[j].pk_rtr
606: );
607: if (zsout(ZDFILE,xbuf) < 0) {
608: deblog = 0;
609: return(0);
610: }
611: x = (int)strlen((char *)r_pkt[j].bf_adr);
612: sprintf(xbuf,"[%.72s%s]\n",r_pkt[j].bf_adr, x > 72 ? "..." : "");
613: if (zsout(ZDFILE,xbuf) < 0) {
614: deblog = 0;
615: return(0);
616: }
617: }
618: sprintf(xbuf,"free: %d, winlo: %d\n", rbufnum, winlo);
619: if (zsout(ZDFILE,xbuf) < 0) {
620: deblog = 0;
621: return(0);
622: }
623: return(0);
624: #endif /* DEBUG */
625: }
626:
627: /*** Some misc functions also moved here from the other ckcfn*.c modules ***/
628: /*** to even out the module sizes. ***/
629:
630: /* Attribute Packets. */
631:
632: /*
633: Call with xp == 0 if we're sending a real file (F packet),
634: or xp != 0 for screen data (X packet).
635: Returns 0 on success, -1 on failure.
636: */
637: int
638: sattr(xp) int xp; { /* Send Attributes */
639: int i, j, aln;
640: char *tp;
641: struct zattr x;
642:
643: if (zsattr(&x) < 0) return(-1); /* Get attributes or die trying */
644: if (nxtpkt() < 0) return(-1); /* Next packet number */
645: i = 0; /* i = Data field character number */
646: if (atsido) { /* System type */
647: data[i++] = '.';
648: data[i++] = tochar(x.systemid.len); /* Copy from attr structure */
649: for (j = 0; j < x.systemid.len; j++)
650: data[i++] = x.systemid.val[j];
651: }
652: if (attypo) { /* File type */
653: data[i++] = '"';
654: if (
655: #ifdef VMS
656: binary == XYFT_I || binary == XYFT_L || /* IMAGE or LABELED */
657: !strncmp(x.recfm.val,"F",1) /* or RECFM=Fxxxxxx */
658: #else
659: binary /* User said SET FILE TYPE BINARY */
660: #endif /* VMS */
661: ) { /* Binary */
662: data[i++] = tochar(2); /* Two characters */
663: data[i++] = 'B'; /* B for Binary */
664: data[i++] = '8'; /* 8-bit bytes (note assumption...) */
665: #ifdef VMS
666: if (binary != XYFT_I && binary != XYFT_L) binary = XYFT_B;
667: #endif /* VMS */
668: } else { /* Text */
669: data[i++] = tochar(3); /* Three characters */
670: data[i++] = 'A'; /* A = (extended) ASCII with CRLFs */
671: data[i++] = 'M'; /* M for carriage return */
672: data[i++] = 'J'; /* J for linefeed */
673: #ifdef VMS
674: binary = XYFT_T; /* We automatically detected text */
675: #endif /* VMS */
676:
677: #ifdef NOCSETS
678: data[i++] = '*'; /* Encoding */
679: data[i++] = tochar(1); /* Length of value is 1 */
680: data[i++] = 'A'; /* A for ASCII */
681: #else
682: if (tcharset == TC_TRANSP) /* Transfer character set */
683: tp = NULL;
684: else
685: tp = tcsinfo[tcharset].designator;
686: if ((tp != NULL) && (aln = (int)strlen(tp)) > 0) {
687: data[i++] = '*'; /* Encoding */
688: data[i++] = tochar(aln+1); /* Length of charset designator. */
689: data[i++] = 'C'; /* Text in specified character set. */
690: for (j = 0; j < aln; j++) /* Designator from tcsinfo struct */
691: data[i++] = *tp++; /* Example: *&I6/100 */
692: }
693: #endif /* NOCSETS */
694: }
695: }
696: if ((xp == 0) && (x.length > -1L)) { /* If it's a real file */
697:
698: if (atdato && (aln = x.date.len) > 0) { /* Creation date, if any */
699: data[i++] = '#';
700: data[i++] = tochar(aln);
701: for (j = 0; j < aln; j++)
702: data[i++] = x.date.val[j];
703: }
704: if (atleno) {
705: data[i] = '!'; /* File length in K */
706: sprintf((char *) &data[i+2],"%ld",x.lengthk);
707: aln = (int)strlen((char *)(data+i+2));
708: data[i+1] = tochar(aln);
709: i += aln + 2;
710:
711: data[i] = '1'; /* File length in bytes */
712: sprintf((char *) &data[i+2],"%ld",x.length);
713: aln = (int)strlen((char *)(data+i+2));
714: data[i+1] = tochar(aln);
715: i += aln + 2;
716: }
717: if (atblko && fblksiz) { /* Blocksize, if set */
718: data[i] = '(';
719: sprintf((char *) &data[i+2],"%d",fblksiz);
720: aln = (int)strlen((char *)(data+i+2));
721: data[i+1] = tochar(aln);
722: i += aln + 2;
723: }
724: }
725: #ifndef NOFRILLS
726: if ((rprintf || rmailf) && atdiso) { /* MAIL, or REMOTE PRINT? */
727: data[i++] = '+'; /* Disposition */
728: data[i++] = tochar((int)strlen(optbuf) + 1); /* Options, if any */
729: if (rprintf)
730: data[i++] = 'P'; /* P for Print */
731: else
732: data[i++] = 'M'; /* M for Mail */
733: for (j = 0; optbuf[j]; j++) /* Copy any options */
734: data[i++] = optbuf[j];
735: }
736: #endif /* NOFRILLS */
737: data[i] = '\0'; /* Make sure it's null-terminated */
738: aln = (int)strlen((char *)data); /* Get overall length of attributes */
739:
740: /* Change this code to break attribute data up into multiple packets! */
741:
742: j = (spsiz < 95) ? (92 - bctl) : (spsiz - 2 - bctl);
743: if (aln > j) { /* Check length of result */
744: spack('A',pktnum,0,(CHAR *)""); /* send an empty attribute packet */
745: debug(F101,"sattr pkt too long","",aln); /* if too long */
746: debug(F101,"sattr spsiz","",spsiz);
747: } else { /* Otherwise */
748: spack('A',pktnum,aln,data); /* send the real thing. */
749: debug(F111,"sattr",data,aln);
750: }
751:
752: return(0);
753: }
754:
755: static char *refused = "";
756:
757: static char *reason[] = {
758: "size", "type", "date", "creator", "account", "area", "password",
759: "blocksize", "access", "encoding", "disposition", "protection",
760: "protection", "origin", "format", "sys-dependent", "size" };
761: static int nreason = sizeof(reason) / sizeof(char *);
762:
763: char *
764: getreason(s) char *s; { /* Decode attribute refusal reason */
765: char c, *p;
766: p = s;
767: if (*p++ != 'N') return(""); /* Should start with N */
768: if ((c = *p) > SP) { /* get reason, */
769: c -= '!'; /* get offset */
770: p = ((unsigned int) ((CHAR) c) <= nreason) ? reason[c] : "unknown";
771: }
772: return(p);
773: }
774:
775: int
776: rsattr(s) CHAR *s; { /* Read response to attribute packet */
777: debug(F111,"rsattr: ",s,*s);
778: if (*s == 'N') { /* If it's 'N' followed by anything, */
779: refused = getreason((char *)s); /* they are refusing, get reason. */
780: debug(F110,"refused",refused,0);
781: tlog(F110,"refused",refused,0L);
782: return(-1);
783: } else refused = "";
784: return(0);
785: }
786:
787: int
788: gattr(s, yy) CHAR *s; struct zattr *yy; { /* Read incoming attribute packet */
789: char c;
790: int aln, i;
791: #define ABUFL 40 /* Temporary buffer for conversions */
792: char abuf[ABUFL];
793: #define FTBUFL 10 /* File type buffer */
794: static char ftbuf[FTBUFL];
795: #define DTBUFL 40 /* File creation date */
796: static char dtbuf[DTBUFL];
797: #define TSBUFL 10 /* Transfer syntax */
798: static char tsbuf[TSBUFL];
799: #define IDBUFL 10 /* System ID */
800: static char idbuf[IDBUFL];
801: #ifndef DYNAMIC
802: #define DSBUFL 100 /* Disposition */
803: static char dsbuf[DSBUFL];
804: #define SPBUFL 512 /* System-dependent parameters */
805: static char spbuf[SPBUFL];
806: #else
807: #define DSBUFL 100 /* Disposition */
808: static char *dsbuf = NULL;
809: #define SPBUFL 512 /* System-dependent parameters */
810: static char *spbuf = NULL;
811: #endif /* DYNAMIC */
812: #define RPBUFL 20 /* Attribute reply */
813: static char rpbuf[RPBUFL];
814:
815: char *rp; /* Pointer to reply buffer */
816: int retcode; /* Return code */
817:
818: /* fill in the attributes we have received */
819:
820: rp = rpbuf; /* Initialize reply buffer */
821: *rp++ = 'N'; /* for negative reply. */
822: retcode = 0; /* Initialize return code. */
823:
824: while (c = *s++) { /* Get attribute tag */
825: aln = xunchar(*s++); /* Length of attribute string */
826: switch (c) {
827: case '!': /* File length in K */
828: for (i = 0; (i < aln) && (i < ABUFL); i++) /* Copy it */
829: abuf[i] = *s++;
830: abuf[i] = '\0'; /* Terminate with null */
831: if (i < aln) s += (aln - i); /* If field was too long for buffer */
832: yy->lengthk = atol(abuf); /* Convert to number */
833: break;
834:
835: case '"': /* file type */
836: for (i = 0; (i < aln) && (i < FTBUFL); i++)
837: ftbuf[i] = *s++; /* Copy it into a static string */
838: ftbuf[i] = '\0';
839: if (i < aln) s += (aln - i);
840: if (attypi) { /* TYPE attribute is enabled? */
841: yy->type.val = ftbuf; /* Pointer to string */
842: yy->type.len = i; /* Length of string */
843: debug(F101,"gattr file type",tsbuf,i);
844: if (
845: *ftbuf != 'A' && *ftbuf != 'B' /* Unknown type? */
846: #ifdef VMS
847: /* or (VMS) our FILE TYPE is LABELED and the incoming file is text... */
848: || binary == XYFT_L && *ftbuf == 'A'
849: #endif /* VMS */
850: ) {
851: discard = 1; /* Reject the file */
852: retcode = -1;
853: *rp++ = c;
854: break;
855: }
856: /*
857: The following code moved here from opena() so we set binary mode
858: as soon as requested by the attribute packet. That way when the first
859: data packet comes, the mode of transfer can be displayed correctly
860: before opena() is called.
861: */
862: if (bsavef) { /* If somehow file mode */
863: binary = bsave; /* was saved but not restored, */
864: bsavef = 0; /* restore it. */
865: debug(F101,"gattr restoring binary","",binary);
866: }
867: if (yy->type.val[0] == 'A') { /* Check received attributes. */
868: bsave = binary; /* ASCII. Save global file type */
869: bsavef = 1; /* ( restore it in clsof() ) */
870: binary = XYFT_T; /* Set current type to Text. */
871: debug(F100,"gattr attribute A = text","",binary); /* */
872: } else if (yy->type.val[0] == 'B') {
873: bsave = binary; /* Binary. Save global file type */
874: bsavef = 1;
875: #ifdef VMS
876: if (binary != XYFT_L && binary != XYFT_U) /* VMS cases */
877: #endif /* VMS */
878: binary = XYFT_B;
879: debug(F101,"gattr attribute B = binary","",binary);
880: }
881: }
882: break;
883:
884: case '#': /* File creation date */
885: for (i = 0; (i < aln) && (i < DTBUFL); i++)
886: dtbuf[i] = *s++; /* Copy it into a static string */
887: if (i < aln) s += (aln - i);
888: dtbuf[i] = '\0';
889: if (atdati) {
890: yy->date.val = dtbuf; /* Pointer to string */
891: yy->date.len = i; /* Length of string */
892: if (fncact == XYFX_U) { /* Receiving in update mode? */
893: if (zstime(filnam,yy,1) > 0) { /* Compare dates */
894: discard = 1; /* If incoming file is older, */
895: *rp++ = c; /* discard it, reason = date. */
896: retcode = -1; /* Rejection notice. */
897: }
898: }
899: }
900: break;
901:
902: case '(': /* File Block Size */
903: for (i = 0; (i < aln) && (i < ABUFL); i++) /* Copy it */
904: abuf[i] = *s++;
905: abuf[i] = '\0'; /* Terminate with null */
906: if (i < aln) s += (aln - i);
907: if (atblki)
908: yy->blksize = atol(abuf); /* Convert to number */
909: break;
910:
911: case '*': /* Encoding (transfer syntax) */
912: for (i = 0; (i < aln) && (i < TSBUFL); i++)
913: tsbuf[i] = *s++; /* Copy it into a static string */
914: if (i < aln) s += (aln - i);
915: tsbuf[i] = '\0';
916: if (atenci) {
917: yy->encoding.val = tsbuf; /* Pointer to string */
918: yy->encoding.len = i; /* Length of string */
919: debug(F101,"gattr encoding",tsbuf,i);
920: switch (*tsbuf) {
921: #ifndef NOCSETS
922: case 'A': /* Normal (maybe extended) ASCII */
923: tcharset = TC_USASCII; /* Transparent chars untranslated */
924: break;
925: case 'C': /* Specified character set */
926: for (i = 0; i < ntcsets; i++) {
927: if (!strcmp(tcsinfo[i].designator,tsbuf+1)) break;
928: }
929: debug(F101,"gattr xfer charset lookup","",i);
930: if (i == ntcsets) { /* If unknown character set, */
931: debug(F110,"gattr: xfer charset unknown",tsbuf+1,0);
932: if (!unkcs) { /* and SET UNKNOWN DISCARD, */
933: retcode = -1; /* reject the file. */
934: *rp++ = c;
935: }
936: } else {
937: tcharset = tcsinfo[i].code; /* if known, use it */
938: rx = xlr[tcharset][fcharset]; /* xlation function */
939: }
940: debug(F101,"gattr tcharset","",tcharset);
941: break;
942: #endif /* NOCSETS */
943: default: /* Something else. */
944: debug(F110,"gattr unk encoding attribute",tsbuf,0);
945: if (!unkcs) { /* If SET UNK DISC */
946: retcode = -1; /* reject the file */
947: *rp++ = c;
948: }
949: break;
950: }
951: }
952: break;
953:
954: case '+': /* disposition */
955: #ifdef DYNAMIC
956: if (!dsbuf)
957: if ((dsbuf = malloc(DSBUFL+1)) == NULL)
958: fatal("gtattr: no memory for dsbuf");
959: #endif /* DYNAMIC */
960: for (i = 0; (i < aln) && (i < DSBUFL); i++)
961: dsbuf[i] = *s++; /* Copy it into a static string */
962: dsbuf[i] = '\0';
963: if (i < aln) s += (aln - i);
964: if (atdisi) {
965: yy->disp.val = dsbuf; /* Pointer to string */
966: yy->disp.len = i; /* Length of string */
967: if (
968: #ifndef datageneral /* MAIL supported only for */
969: #ifndef OS2 /* UNIX, VMS, and OS-9 */
970: #ifndef MAC
971: #ifndef GEMDOS
972: #ifndef AMIGA
973: *dsbuf != 'M' &&
974: #endif /* AMIGA */
975: #endif /* GEMDOS */
976: #endif /* MAC */
977: #endif /* OS/2 */
978: #endif /* datageneral */
979: *dsbuf != 'P') {
980: retcode = -1;
981: *rp++ = c;
982: }
983: }
984: break;
985:
986: case '.': /* Sender's system ID */
987: for (i = 0; (i < aln) && (i < IDBUFL); i++)
988: idbuf[i] = *s++; /* Copy it into a static string */
989: idbuf[i] = '\0';
990: if (i < aln) s += (aln - i);
991: if (atsidi) {
992: yy->systemid.val = idbuf; /* Pointer to string */
993: yy->systemid.len = i; /* Length of string */
994: }
995: break;
996:
997: case '0': /* System-dependent parameters */
998: #ifdef DYNAMIC
999: if (!spbuf && !(spbuf = malloc(SPBUFL)))
1000: fatal("gattr: no memory for spbuf");
1001: #endif /* DYNAMIC */
1002: for (i = 0; (i < aln) && (i < SPBUFL); i++)
1003: spbuf[i] = *s++; /* Copy it into a static string */
1004: spbuf[i] = '\0';
1005: if (i < aln) s += (aln - i);
1006: if (atsysi) {
1007: yy->sysparam.val = spbuf; /* Pointer to string */
1008: yy->sysparam.len = i; /* Length of string */
1009: }
1010: break;
1011:
1012: case '1': /* File length in bytes */
1013: for (i = 0; (i < aln) && (i < ABUFL); i++) /* Copy it */
1014: abuf[i] = *s++;
1015: abuf[i] = '\0'; /* Terminate with null */
1016: if (i < aln) s += (aln - i);
1017: yy->length = atol(abuf); /* Convert to number */
1018: debug(F111,"gattr length",abuf,(int) yy->length);
1019: break;
1020:
1021: default: /* Unknown attribute */
1022: s += aln; /* Just skip past it */
1023: break;
1024: }
1025: }
1026:
1027: /* Check file length now, because we also need to know the file type */
1028: /* in case zchkspa() differentiates text and binary (VMS version does) */
1029:
1030: if (atleni) { /* Length attribute enabled? */
1031: if (yy->length > -1L) { /* Length-in-bytes attribute rec'd? */
1032: if (!zchkspa(filnam,(yy->length))) { /* Check space */
1033: retcode = -1;
1034: *rp++ = '1';
1035: }
1036: } else if (yy->lengthk > -1L) { /* Length in K attribute rec'd? */
1037: if (!zchkspa(filnam,(yy->lengthk * 1024))) {
1038: retcode = -1; /* Check space */
1039: *rp++ = '!';
1040: }
1041: }
1042: }
1043: if (yy->length > -1L) { /* Get the file size */
1044: fsize = yy->length;
1045: } else if (yy->lengthk > -1L) {
1046: fsize = yy->lengthk * 1024L;
1047: } else fsize = -1L;
1048:
1049: #ifdef DEBUG
1050: if (deblog) {
1051: sprintf(abuf,"%ld",fsize);
1052: debug(F110,"gattr fsize",abuf,0);
1053: }
1054: #endif /* DEBUG */
1055: if (retcode == 0) rp = rpbuf; /* Null reply string if accepted */
1056: *rp = '\0'; /* End of reply string */
1057: yy->reply.val = rpbuf; /* Add it to attribute structure */
1058: yy->reply.len = (int)strlen(rpbuf);
1059: debug(F111,"gattr return",rpbuf,retcode);
1060: return(retcode);
1061: }
1062:
1063: /* I N I T A T T R -- Initialize file attribute structure */
1064:
1065: int
1066: initattr(yy) struct zattr *yy; {
1067: yy->lengthk = yy->length = -1L;
1068: yy->type.val = "";
1069: yy->type.len = 0;
1070: yy->date.val = "";
1071: yy->date.len = 0;
1072: yy->encoding.val = "";
1073: yy->encoding.len = 0;
1074: yy->disp.val = "";
1075: yy->disp.len = 0;
1076: yy->systemid.val = "";
1077: yy->systemid.len = 0;
1078: yy->sysparam.val = "";
1079: yy->sysparam.len = 0;
1080: yy->creator.val = "";
1081: yy->creator.len = 0;
1082: yy->account.val = "";
1083: yy->account.len = 0;
1084: yy->area.val = "";
1085: yy->area.len = 0;
1086: yy->passwd.val = "";
1087: yy->passwd.len = 0;
1088: yy->blksize = -1L;
1089: yy->access.val = "";
1090: yy->access.len = 0;
1091: yy->lprotect.val = "";
1092: yy->lprotect.len = 0;
1093: yy->gprotect.val = "";
1094: yy->gprotect.len = 0;
1095: yy->recfm.val = "";
1096: yy->recfm.len = 0;
1097: yy->reply.val = "";
1098: yy->reply.len = 0;
1099: return(0);
1100: }
1101:
1102: /* A D E B U -- Write attribute packet info to debug log */
1103:
1104: int
1105: adebu(f,zz) char *f; struct zattr *zz; {
1106: #ifdef DEBUG
1107: if (deblog == 0) return(0);
1108: debug(F110,"Attributes for incoming file ",f,0);
1109: debug(F101," length in K","",(int) zz->lengthk);
1110: debug(F111," file type",zz->type.val,zz->type.len);
1111: debug(F111," creation date",zz->date.val,zz->date.len);
1112: debug(F111," creator",zz->creator.val,zz->creator.len);
1113: debug(F111," account",zz->account.val,zz->account.len);
1114: debug(F111," area",zz->area.val,zz->area.len);
1115: debug(F111," password",zz->passwd.val,zz->passwd.len);
1116: debug(F101," blksize","",(int) zz->blksize);
1117: debug(F111," access",zz->access.val,zz->access.len);
1118: debug(F111," encoding",zz->encoding.val,zz->encoding.len);
1119: debug(F111," disposition",zz->disp.val,zz->disp.len);
1120: debug(F111," lprotection",zz->lprotect.val,zz->lprotect.len);
1121: debug(F111," gprotection",zz->gprotect.val,zz->gprotect.len);
1122: debug(F111," systemid",zz->systemid.val,zz->systemid.len);
1123: debug(F111," recfm",zz->recfm.val,zz->recfm.len);
1124: debug(F111," sysparam",zz->sysparam.val,zz->sysparam.len);
1125: debug(F101," length","",(int) zz->length);
1126: debug(F110," reply",zz->reply.val,0);
1127: #endif /* DEBUG */
1128: return(0);
1129: }
1130:
1131: /* O P E N A -- Open a file, with attributes. */
1132: /*
1133: This function tries to open a new file to put the arriving data in. The
1134: filename is the one in the srvcmd buffer. File collision actions are:
1135: OVERWRITE (the existing file is overwritten), RENAME (the new file is
1136: renamed), BACKUP (the existing file is renamed), DISCARD (the new file is
1137: refused), UPDATE (the incoming file replaces the existing file only if the
1138: incoming file has a newer creation date).
1139:
1140: Returns 0 on failure, nonzero on success.
1141: */
1142: int
1143: opena(f,zz) char *f; struct zattr *zz; {
1144: int x;
1145: static struct filinfo fcb; /* Must be static! */
1146:
1147: debug(F111,"opena discard",f,discard);
1148:
1149: adebu(f,zz); /* Write attributes to debug log */
1150:
1151: ffc = 0L; /* Init file character counter */
1152:
1153: #ifdef COMMENT
1154: /*
1155: This code moved to sattr().
1156: */
1157: if (bsavef) { /* If somehow file mode */
1158: binary = bsave; /* was saved but not restored, */
1159: bsavef = 0; /* restore it. */
1160: debug(F101,"opena restoring binary","",binary);
1161: }
1162: if (zz->type.val[0] == 'A') { /* Check received attributes */
1163: #ifdef VMS
1164: if (binary == XYFT_L) /* Refuse to receive a file in */
1165: return(0); /* labeled mode if sent as text. */
1166: #endif /* VMS */
1167: bsave = binary; /* ASCII. Save global file type */
1168: bsavef = 1; /* ( restore it in clsof() ) */
1169: binary = XYFT_T; /* Set current type to Text. */
1170: debug(F100,"opena attribute A = text","",binary);
1171: } else if (zz->type.val[0] == 'B') {
1172: bsave = binary; /* Binary. Save global file type */
1173: bsavef = 1;
1174: #ifdef VMS
1175: if (binary != XYFT_L && binary != XYFT_U) /* Special VMS cases */
1176: #endif /* VMS */
1177: binary = XYFT_B;
1178: debug(F101,"opena attribute B = binary","",binary);
1179: }
1180: #endif /* COMMENT */
1181:
1182: /* Set up file control structure */
1183:
1184: fcb.bs = fblksiz; /* Blocksize */
1185: #ifndef NOCSETS
1186: fcb.cs = fcharset; /* Character set */
1187: #else
1188: fcb.cs = 0; /* Character set */
1189: #endif /* NOCSETS */
1190: fcb.rl = frecl; /* Record Length */
1191: fcb.fmt = frecfm; /* Record Format */
1192: fcb.org = forg; /* Organization */
1193: fcb.cc = fcctrl; /* Carriage control */
1194: fcb.typ = binary; /* Type */
1195: fcb.dsp = (fncact == XYFX_A) ? XYFZ_A : XYFZ_N; /* Disposition */
1196: fcb.os_specific = '\0'; /* OS specific info */
1197: #ifdef VMS
1198: fcb.lblopts = lf_opts; /* VMS Labeled file options */
1199: #else
1200: fcb.lblopts = 0;
1201: #endif /* VMS */
1202:
1203: if (x = openo(f,zz,&fcb)) { /* Try to open the file. */
1204: tlog(F110," as",f,0L); /* OK, open, record name. */
1205: if (binary) { /* Log file mode in transaction log */
1206: tlog(F101," mode: binary","",(long) binary);
1207: } else { /* If text mode, check character set */
1208: tlog(F100," mode: text","",0L);
1209: #ifndef NOCSETS
1210: tlog(F110," file character set",fcsinfo[fcharset].name,0L);
1211: if (tcharset == TC_TRANSP)
1212: tlog(F110," xfer character set","transparent",0L);
1213: else
1214: tlog(F110," xfer character set",tcsinfo[tcharset].name,0L);
1215: #endif /* NOCSETS */
1216: debug(F111," opena charset",zz->encoding.val,zz->encoding.len);
1217: }
1218: if (fsize > -1L) screen(SCR_FS,0,fsize,"");
1219:
1220: #ifdef datageneral
1221: /* Need to turn on multi-tasking console interrupt task here, since multiple */
1222: /* files may be received. */
1223: if ((local) && (!quiet)) /* Only do this if local & not quiet */
1224: consta_mt(); /* Start the asynch read task */
1225: #endif /* datageneral */
1226:
1227: } else { /* Did not open file OK. */
1228: #ifdef ATTSV
1229: extern char *sys_errlist[];
1230: extern int errno;
1231: screen(SCR_EM,0,0l,sys_errlist[errno]);
1232: #else
1233: #ifdef BSD4
1234: extern char *sys_errlist[];
1235: extern int errno;
1236: screen(SCR_EM,0,0l,sys_errlist[errno]);
1237: #else
1238: screen(SCR_EM,0,0l,"Can't open output file");
1239: #endif /* BSD4 */
1240: #endif /* ATTSV */
1241:
1242: tlog(F110,"Failure to open",f,0L);
1243:
1244:
1245: }
1246: return(x); /* Pass on return code from openo */
1247: }
1248:
1249: /* C A N N E D -- Check if current file transfer cancelled */
1250:
1251: int
1252: canned(buf) CHAR *buf; {
1253: if (*buf == 'X') cxseen = 1;
1254: if (*buf == 'Z') czseen = 1;
1255: debug(F101,"canned: cxseen","",cxseen);
1256: debug(F101," czseen","",czseen);
1257: return((czseen || cxseen) ? 1 : 0);
1258: }
1259:
1260:
1261: /* O P E N I -- Open an existing file for input */
1262:
1263: int
1264: openi(name) char *name; {
1265: int x, filno;
1266: char *name2;
1267:
1268: if (memstr) return(1); /* Just return if file is memory. */
1269:
1270: debug(F110,"openi",name,0);
1271: debug(F101," sndsrc","",sndsrc);
1272:
1273: filno = (sndsrc == 0) ? ZSTDIO : ZIFILE; /* ... */
1274:
1275: debug(F101," file number","",filno);
1276:
1277: if (server && !en_cwd) { /* If running as server */
1278: zstrip(name,&name2); /* and CWD is disabled... */
1279: if ( /* check if pathname was included. */
1280: #ifdef VMS
1281: zchkpath(name)
1282: #else
1283: strcmp(name,name2)
1284: #endif /* VMS */
1285: ) {
1286: tlog(F110,name,"authorization failure",0L);
1287: debug(F110," openi authorization failure",name,0);
1288: return(0);
1289: } else name = name2;
1290: }
1291: if (zopeni(filno,name)) { /* Otherwise, try to open it. */
1292: debug(F110," ok",name,0);
1293: return(1);
1294: } else { /* If not found, */
1295: char xname[100]; /* convert the name */
1296: zrtol(name,xname); /* to local form and then */
1297: x = zopeni(filno,xname); /* try opening it again. */
1298: debug(F101," zopeni","",x);
1299: if (x) {
1300: debug(F110," ok",xname,0);
1301: return(1); /* It worked. */
1302: } else {
1303: #ifdef COMMENT
1304: screen(SCR_EM,0,0l,"Can't open file"); /* It didn't work. */
1305: #endif /* COMMENT */
1306: tlog(F110,xname,"could not be opened",0L);
1307: debug(F110," openi failed",xname,0);
1308: return(0);
1309: }
1310: }
1311: }
1312:
1313: /* O P E N O -- Open a new file for output. */
1314:
1315: int
1316: openo(name,zz,fcb) char *name; struct zattr *zz; struct filinfo *fcb; {
1317: char *name2;
1318:
1319: if (stdouf) /* Receiving to stdout? */
1320: return(zopeno(ZSTDIO,"",zz,NULL));
1321:
1322: debug(F110,"openo: name",name,0);
1323:
1324: if (cxseen || czseen || discard) { /* If interrupted, get out before */
1325: debug(F100," open cancelled","",0); /* destroying existing file. */
1326: return(1); /* Pretend to succeed. */
1327: }
1328: if (server && !en_cwd) { /* If running as server */
1329: zstrip(name,&name2); /* and CWD is disabled, */
1330: if (strcmp(name,name2)) { /* check if pathname was included. */
1331: tlog(F110,name,"authorization failure",0L);
1332: debug(F110," openo authorization failure",name,0);
1333: return(0);
1334: } else name = name2;
1335: }
1336:
1337: if (zopeno(ZOFILE,name,zz,fcb) == 0) { /* Try to open the file */
1338: debug(F110,"openo failed",name,0);
1339: tlog(F110,"Failure to open",name,0L);
1340: return(0);
1341: } else {
1342: debug(F110,"openo ok, name",name,0);
1343: return(1);
1344: }
1345: }
1346:
1347: /* O P E N T -- Open the terminal for output, in place of a file */
1348:
1349: int
1350: opent(zz) struct zattr *zz; {
1351: ffc = tfc = 0L;
1352: if (bsavef) { /* If somehow file mode */
1353: binary = bsave; /* was saved but not restored, */
1354: bsavef = 0; /* restore it. */
1355: debug(F101,"opena restoring binary","",binary);
1356: }
1357: bsave = binary;
1358: bsavef = 1;
1359: binary = XYFT_T;
1360: return(zopeno(ZCTERM,"",zz,NULL));
1361: }
1362:
1363: /* C L S I F -- Close the current input file. */
1364:
1365: int
1366: clsif() {
1367: int x = 0;
1368: #ifdef datageneral
1369: if ((local) && (!quiet)) /* Only do this if local & not quiet */
1370: if (nfils < 1) /* More files to send ... leave it on! */
1371: connoi_mt();
1372: #endif /* datageneral */
1373: if (memstr) { /* If input was memory string, */
1374: memstr = 0; /* indicate no more. */
1375: } else x = zclose(ZIFILE); /* else close input file. */
1376: if (cxseen || czseen) /* If interrupted */
1377: screen(SCR_ST,ST_INT,0l,""); /* say so */
1378: else if (discard) /* If I'm refusing */
1379: screen(SCR_ST,ST_REFU,0l,refused); /* say why */
1380: else { /* Otherwise */
1381: fstats(); /* update statistics */
1382: screen(SCR_ST,ST_OK,0l,""); /* and say transfer was OK */
1383: }
1384: hcflg = 0; /* Reset flags */
1385: *filnam = '\0'; /* and current file name */
1386: return(x);
1387: }
1388:
1389:
1390: /* C L S O F -- Close an output file. */
1391:
1392: /* Call with disp != 0 if file is to be discarded. */
1393: /* Returns -1 upon failure to close, 0 or greater on success. */
1394:
1395: int
1396: clsof(disp) int disp; {
1397: int x;
1398:
1399: debug(F101,"clsof disp","",disp);
1400: if (bsavef) { /* If we saved global file type */
1401: debug(F101,"clsof restoring binary","",binary);
1402: binary = bsave; /* restore it */
1403: bsavef = 0; /* only this once. */
1404: }
1405: #ifdef datageneral
1406: if ((local) && (!quiet)) /* Only do this if local & not quiet */
1407: connoi_mt();
1408: #endif /* datageneral */
1409: cxseen = 0; /* Reset per-file interruption flag */
1410: if ((x = zclose(ZOFILE)) < 0) { /* Try to close the file */
1411: tlog(F100,"Failure to close",filnam,0L);
1412: screen(SCR_ST,ST_ERR,0l,"");
1413: } else if (disp) { /* Interrupted or refused */
1414: if (keep == 0) { /* If not keep incomplete files */
1415: if (*filnam) zdelet(filnam); /* Delete it */
1416: debug(F100,"Discarded","",0);
1417: tlog(F100,"Discarded","",0L);
1418: screen(SCR_ST,ST_DISC,0l,"");
1419: } else { /* Keep incomplete copy */
1420: if (ffc) ffc++; /* This is off by one (why?) */
1421: fstats();
1422: debug(F100,"Incomplete","",0);
1423: tlog(F100,"Incomplete","",0L);
1424: screen(SCR_ST,ST_INC,0l,"");
1425: }
1426: } else { /* Nothing wrong, just keep it */
1427: debug(F100,"Closed","",0); /* and give comforting messages. */
1428: if (ffc) ffc++; /* Correct off-by-1 error */
1429: fstats();
1430: screen(SCR_ST,ST_OK,0l,"");
1431: }
1432: return(x); /* Send back zclose() return code. */
1433: }
1434:
1435: #ifdef SUNOS4S5
1436: tolower(c) char c; { return((c)-'A'+'a'); }
1437: toupper(c) char c; { return((c)-'a'+'A'); }
1438: #endif /* SUNOS4S5 */
1439:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.