![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to sendf.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Power 6/32 Unix Tahoe 4.2BSD] / cci / usr / src / usr.bin / bsc / cmd / batch|
Return to sendf.c CVS log | Up to [Power 6/32 Unix Tahoe 4.2BSD] / cci / usr / src / usr.bin / bsc / cmd / batch |
1.1 root 1: /* D.L.Buck and Associates, Inc. - %H%
2: *
3: * COPYRIGHT NOTICE:
4: * Copyright c %H% - An unpublished work by
5: * D.L.Buck and Associates, Inc.
6: *
7: * PROPRIETARY RIGHTS NOTICE:
8: * All rights reserved. This document and program contains
9: * proprietary information of D.L.Buck and Associates,Inc.
10: * of San Jose, California, U.S.A., embodying confidential
11: * information, ideas, and expressions, no part of which
12: * may be reproduced, or transmitted in any form or by any
13: * means, electronic, mechanical, or otherwise, without
14: * the written permission of D.L.Buck and Associates, Inc.
15: *
16: * NAME
17: * sendf
18: *
19: * SYNOPSIS
20: * sendf(sendfile)
21: * char *sendfile;
22: *
23: * DESCRIPTION
24: * Send a file -- called from bscd
25: */
26:
27: #include <stdio.h>
28: #include <errno.h>
29: #include <sys/types.h>
30: #include <sys/stat.h>
31: #include <sys/ioctl.h>
32: #include <bsc/bscio.h>
33: #include "local.h"
34:
35: #define YES 1
36: #define NO 0
37: #define DLE 0x10
38: #define IUS 0x1f
39: #define ETX 0x03
40: #define ASCENQ 0x05
41: #define ASCETB 0x17
42: #define ASCSYN 0x16
43: #define EBCENQ 0x2d
44: #define EBCETB 0x26
45: #define EBCSYN 0x32
46:
47: #ifndef lint
48: static char sccsid[] = "%W% %Q%";
49: #endif
50:
51: extern char note[];
52: extern char hostname[];
53: extern char auditlock[];
54: extern char lockfile[];
55: extern char user[];
56: extern char emsg[];
57:
58: extern int errno;
59: extern int mail;
60: extern int recsize;
61: extern int recblk;
62: extern int recsep;
63: extern int ius;
64: extern int compress;
65: extern int blksize;
66: extern int trnsp;
67: extern int ascii;
68: extern int blocks;
69: extern int devfd;
70: extern int total_bl;
71: extern int transp_ok;
72: extern int rviab;
73: extern int set_trnsp;
74:
75: extern struct bscio c_params;
76: extern struct bscio s_params;
77:
78: char *rdptr;
79: char *cpout;
80: char *inend;
81: char *outptr;
82: char *outend;
83:
84: char inbuff[512];
85: char outbuff[512];
86: char temp[1024];
87: char a_msg[150];
88:
89: int eof;
90: int tranrcd;
91: int rcds;
92: char *index();
93: void exit();
94:
95: sendf(sendfile)
96: char *sendfile;
97: {
98:
99: int outspace;
100: int len = 0; /* length of record read in */
101: int sendfd; /* sendfile file descriptor */
102: unsigned rd_amt;
103: int count;
104:
105: struct stat s; /* file statistics structure */
106:
107: /* assume file to be sent is not transparent, and tell the daemon so */
108: ioctl(devfd,BSCNTRNS,0);
109:
110: /* open file to be sent */
111: if ((sendfd = open(sendfile,0)) == -1)
112: { fprintf(stderr,
113: "bscd <%s>: cannot open <%s>\n",
114: hostname,sendfile);
115: sprintf(note,
116: "Couldn't open <%s>\n",
117: sendfile);
118: notefile(user,sendfile,note);
119: unlink(auditlock);
120: unlink(lockfile);
121: exit (1); }
122:
123: /* stat to see how big it is */
124: stat(sendfile,&s);
125:
126: /* inform the AUDIT file */
127: sprintf(a_msg, "Transmission of <%s> (%ld bytes) begun",
128: sendfile,s.st_size);
129: write_aud("S",a_msg);
130:
131: /* set up beginning inbuff and outbuff and their attendant pointers */
132: rdptr = cpout = &inbuff[0];
133: inend = &inbuff[sizeof inbuff];
134: outptr = &outbuff[0];
135: outend = &outbuff[blksize] - 4; /* leave room for STX, ETX... */
136: rcds = 0;
137: count = 0;
138: eof = NO;
139: tranrcd = NO;
140:
141: rd_amt = (sizeof inbuff) - 1;
142: if (ius) --outend;
143:
144: len = read(sendfd,inbuff,rd_amt);
145: if (len == -1)
146: return(-1);
147: rdptr = &inbuff[len];
148:
149: if (len == 0)
150: eof = YES;
151:
152: /* copy from inbuff to outbuff and process data --
153: first read in # of bytes you just copied to the outbuff */
154: while (1)
155: { outspace = outend - outptr;
156: if (ius) /* leave room for IUS and 1 or 2 byte CRC */
157: outspace -= (ascii)?2:3;
158:
159: /* do_copy copies up to recsize or newline bytes into temporary buffer
160: and sets tranrcd if transparent character(s) found */
161: count = do_copy(outspace,recsize,sendfd);
162:
163: if (count == 0)
164: break;
165:
166: /* if count is -1, there wasn't enough room for another record.
167: flush outbuff and continue on (merrily) */
168: if (count == -1) {
169: if (flushbuf(outbuff,
170: (unsigned)(outptr-outbuff)) == -1) {
171: if (c_params.b_flags != BSCRVI ||
172: (c_params.b_flags == BSCRVI && rviab)) {
173: close(sendfd);
174: return(-1);
175: }
176: }
177:
178: outptr = &outbuff[0];
179: rcds = 0;
180: continue;
181: }
182:
183: /* if normal rcd, replace newline with recsep and cat to outbuff */
184: if (!tranrcd)
185: { if (temp[count-1] != '\n')
186: ++count;
187: temp[count-1] = recsep;
188: if (ius && rcds != recblk - 1)
189: { temp[count] = IUS; /* 2780 unit seperator */
190: ++count;
191: /* add dummy character(s) to leave room for CRC added
192: by driver; 1 dummy for ascii, 2 dummies for ebcdic.
193: */
194: temp[count] = ' ';
195: ++count;
196: if (!ascii) {
197: temp[count] = ' ';
198: ++count;
199: }
200: }
201:
202: if (!ascii)
203: ascebc(temp,count);
204:
205: if (compress)
206: count = do_compress(temp,count);
207:
208: /* copy all characters to outbuff (even nulls) */
209: bcopy(outptr,temp,count);
210:
211: /* increment buffer pointers, get number of bytes to
212: read next, compute space taken up in inbuff */
213: ++rcds;
214: outptr += count;
215:
216: if (rcds == recblk)
217: { if (*--outptr != IUS)
218: ++outptr;
219: if (flushbuf(outbuff,
220: (unsigned)(outptr-outbuff)) == -1) {
221: if (c_params.b_flags != BSCRVI ||
222: (c_params.b_flags == BSCRVI && rviab)) {
223: close(sendfd);
224: return(-1);
225: }
226: }
227: outptr = &outbuff[0];
228: rcds = 0; }
229:
230: continue;
231: }
232:
233: /* transparent data processing */
234: if (outptr != outbuff &&
235: flushbuf(outbuff,(unsigned)(outptr-outbuff)) == -1) {
236: close(sendfd);
237: return(-1);
238: }
239:
240: ioctl(devfd,BSCTRNSP,0);
241: set_trnsp = YES;
242:
243: if (flushbuf(temp,(unsigned)count) == -1) {
244: if (c_params.b_flags != BSCRVI ||
245: (c_params.b_flags == BSCRVI && rviab)) {
246: close(sendfd);
247: return(-1);
248: }
249: }
250:
251: ioctl(devfd,BSCNTRNS,0);
252: outptr = &outbuff[0];
253: rcds = 0;
254: continue;
255: }
256: if (outptr != outbuff)
257: if (flushbuf(outbuff,(unsigned)(outptr-outbuff)) == -1) {
258: if (c_params.b_flags != BSCRVI ||
259: (c_params.b_flags == BSCRVI && rviab)) {
260: close(sendfd);
261: return(-1);
262: }
263: }
264:
265: close(sendfd);
266: if (!transp_ok && trnsp)
267: return(-1);
268: else
269: return(0);
270: }
271:
272: /* do_copy - copy recsize (or to newline size) chunk from inbuff to
273: temp buff for processing and replenish the inbuff */
274: char asctrans[7] = {DLE,IUS,ETX,ASCENQ,ASCETB,ASCSYN};
275:
276: do_copy(availspace,size,sfd)
277: int availspace,size,sfd;
278: {
279: register char *tmptr;
280: register char *cp = cpout;
281: register int count = 0;
282: int len;
283: unsigned rdamt;
284: unsigned part_amt;
285: int dlecount = 0;
286:
287: char c;
288:
289: tmptr = &temp[0];
290: if (trnsp)
291: tranrcd = YES;
292:
293: while (count < size && cp != rdptr && (tmptr-&temp[0] < availspace))
294: { ++count;
295: *tmptr++ = c = *cp++;
296: if (cp== inend)
297: cp= &inbuff[0];
298:
299: if (!tranrcd) {
300: tranrcd = (index(asctrans,c))?YES:NO;
301: if (tranrcd && !transp_ok) {
302: outptr = outbuff;
303: trnsp = YES;
304: return(0);
305: }
306: }
307:
308: if (tranrcd)
309: { if (c == DLE)
310: { ++dlecount;
311: ++count;
312: *tmptr++ = DLE; }
313: }
314: else if (c == '\n')
315: break;
316: }
317: if (tmptr - &temp[0] >= availspace)
318: return(-1);
319: rdamt = count - dlecount;
320: if (!tranrcd && *cp == '\n' && tmptr[-1] != '\n' && count >= size) {
321: ++cp;
322: if (cp == inend)
323: cp = &inbuff[0];
324: }
325: cpout = cp;
326:
327: /* read the next # of bytes into inbuff */
328: if (!eof && rdamt) {
329: if ((rdptr + rdamt) > inend) {
330: part_amt = (int)(inend - rdptr);
331:
332: len = read(sfd,rdptr,part_amt);
333: if (len == part_amt) {
334: rdptr = inbuff;
335: rdamt -= part_amt;
336: }
337: else {
338: eof = YES;
339: rdamt = 0;
340: }
341: }
342:
343: if (rdamt) {
344: len = read(sfd,rdptr,rdamt);
345: if (len != rdamt)
346: eof = YES;
347: }
348: /* position the read ptr after what's been read in */
349: rdptr += len;
350: if (rdptr >= inend)
351: rdptr -= sizeof inbuff;
352: }
353:
354: return(count);
355: }
356:
357: /* flushbuf -- write contents of outbuff to the bsc device */
358: flushbuf(buffer,count)
359: register char *buffer;
360: register unsigned count;
361: {
362: /* if eof was encountered, set BSCLAST flag */
363: if (eof && cpout == rdptr)
364: ioctl(devfd,BSCLAST,0);
365:
366: if (!tranrcd && (count >2) && (outptr[-2] == IUS || outptr[-3] == IUS))
367: count -= (outptr[-2] == IUS)?2:3;
368:
369: if (write(devfd,buffer,count) == count)
370: { ++blocks;
371: return(0); }
372: if (errno == EINVAL && count > s_params.b_blks)
373: abort();
374: ioctl(devfd, BSCGET, &c_params);
375: return(-1);
376: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.