1/*
2 * CDDL HEADER START
3 *
4 * The contents of this file are subject to the terms of the
5 * Common Development and Distribution License (the "License").
6 * You may not use this file except in compliance with the License.
7 *
8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9 * or http://www.opensolaris.org/os/licensing.
10 * See the License for the specific language governing permissions
11 * and limitations under the License.
12 *
13 * When distributing Covered Code, include this CDDL HEADER in each
14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15 * If applicable, add the following below this CDDL HEADER, with the
16 * fields enclosed by brackets "[]" replaced with your own identifying
17 * information: Portions Copyright [yyyy] [name of copyright owner]
18 *
19 * CDDL HEADER END
20 */
21/*
22 * Copyright 2007 Sun Microsystems, Inc.  All rights reserved.
23 * Use is subject to license terms.
24 */
25
26/*	Copyright (c) 1984, 1986, 1987, 1988, 1989 AT&T	*/
27/*	  All Rights Reserved  	*/
28
29
30#pragma ident	"%Z%%M%	%I%	%E% SMI"
31
32#include "uucp.h"
33
34#ifdef	E_PROTOCOL
35
36#ifndef MIN
37#define     MIN(a,b) (((a)<(b))?(a):(b))
38#endif
39
40#if defined(BSD4_2) || defined (ATTSVR4)
41#include <netinet/in.h>
42#endif /* BSD4_2 || ATTSVR4 */
43
44#define	EBUFSIZ	1024
45#define	EMESGLEN 20
46
47#define TBUFSIZE 1024
48#define TPACKSIZE	512
49
50extern long lseek();	/* Find offset into the file. */
51static jmp_buf Failbuf;
52extern int erdblk();
53extern unsigned msgtime;
54
55static char Erdstash[EBUFSIZ];
56static int Erdlen;
57
58/*
59 * error-free channel protocol
60 */
61/* ARGSUSED */
62static void
63ealarm(sig)
64int sig;
65{
66	longjmp(Failbuf, 1);
67}
68static void (*esig)();
69
70/*
71 * turn on protocol timer
72 */
73int
74eturnon()
75{
76	esig=signal(SIGALRM, ealarm);
77	return(0);
78}
79
80int
81eturnoff()
82{
83	signal(SIGALRM, esig);
84	return(0);
85}
86
87/*
88 * write message across link
89 *	type	-> message type
90 *	str	-> message body (ascii string)
91 *	fn	-> link file descriptor
92 * return
93 *	FAIL	-> write failed
94 *	SUCCESS	-> write succeeded
95 */
96int
97ewrmsg(type, str, fn)
98char *str;
99int fn;
100char type;
101{
102	return(etwrmsg(type, str, fn, 0));
103}
104
105/*
106 * read message from link
107 *	str	-> message buffer
108 *	fn	-> file descriptor
109 * return
110 *	FAIL	-> read timed out
111 *	SUCCESS	-> ok message in str
112 */
113int
114erdmsg(str, fn)
115char *str;
116{
117	return(etrdmsg(str, fn, 0));
118}
119
120/*
121 * read data from file fp1 and write
122 * on link
123 *	fp1	-> file descriptor
124 *	fn	-> link descriptor
125 * returns:
126 *	FAIL	->failure in link
127 *	SUCCESS	-> ok
128 */
129int
130ewrdata(fp1, fn)
131FILE *fp1;
132int	fn;
133{
134	int ret;
135	int	fd1;
136	int len;
137	unsigned long bytes;
138	char bufr[EBUFSIZ];
139	struct stat	statbuf;
140	off_t	msglen;
141	char	cmsglen[EMESGLEN];
142	off_t	startPoint;	/* Offset from begining of the file in
143				 *   case we are restarting from a check
144				 *   point.
145				 */
146
147	if (setjmp(Failbuf)) {
148		DEBUG(7, "ewrdata failed\n%s", "");
149		return(FAIL);
150	}
151	bytes = 0L;
152	fd1 = fileno(fp1);
153	fstat(fd1, &statbuf);
154	startPoint = lseek(fd1, 0L, 1);
155	if (startPoint < 0)
156	{
157		DEBUG(7, "ewrdata lseek failed.  Errno=%d\n", errno);
158		return(FAIL);
159	}
160	msglen = statbuf.st_size - startPoint;
161	if (msglen < 0)
162	{
163		DEBUG(7, "ewrdata: startPoint past end of file.\n%s", "");
164		return(FAIL);
165	}
166	sprintf(cmsglen, "%ld", (long) msglen);
167	DEBUG(9, "ewrdata writing %d ...", sizeof(cmsglen));
168	alarm(msgtime);
169	ret = (*Write)(fn, cmsglen, sizeof(cmsglen));
170	alarm(0);
171	DEBUG(9, "ret %d\n", ret);
172	if (ret != sizeof(cmsglen))
173		return(FAIL);
174	DEBUG(7, "ewrdata planning to send %ld bytes to remote.\n", msglen);
175	while ((len = read( fd1, bufr, EBUFSIZ )) > 0) {
176		DEBUG(9, "ewrdata writing %d ...", len);
177		alarm(msgtime);
178		bytes += len;
179		putfilesize(bytes);
180		ret = (*Write)(fn, bufr, (unsigned) len);
181		alarm(0);
182		DEBUG(9, "ewrdata ret %d\n", ret);
183		if (ret != len)
184			return(FAIL);
185		if ((msglen -= len) <= 0)
186			break;
187	}
188	if (len < 0 || (len == 0 && msglen != 0)) return(FAIL);
189	return(SUCCESS);
190}
191
192/*
193 * read data from link and
194 * write into file
195 *	fp2	-> file descriptor
196 *	fn	-> link descriptor
197 * returns:
198 *	SUCCESS	-> ok
199 *	FAIL	-> failure on link
200 */
201int
202erddata(fn, fp2)
203FILE *fp2;
204{
205	int ret;
206	int	fd2;
207	char bufr[EBUFSIZ];
208	int	len;
209	long	msglen, bytes;
210	char	cmsglen[EMESGLEN], *cptr, *erdptr = Erdstash;
211
212	DEBUG(9, "erddata wants %d\n", sizeof(cmsglen));
213	if (Erdlen > 0) {
214		DEBUG(9, "%d bytes stashed\n", Erdlen);
215		if (Erdlen >= sizeof(cmsglen)) {
216			memcpy(cmsglen, erdptr, sizeof(cmsglen));
217			Erdlen -= sizeof(cmsglen);
218			erdptr += sizeof(cmsglen);
219			ret = len = 0;
220		} else {
221			memcpy(cmsglen, Erdstash, Erdlen);
222			cptr = cmsglen + Erdlen;
223			len = sizeof(cmsglen) - Erdlen;
224			ret = erdblk(cptr, len, fn);
225			Erdlen = 0;
226		}
227	} else {
228		len = sizeof(cmsglen);
229		ret = erdblk(cmsglen, sizeof(cmsglen), fn);
230	}
231	if (ret != len)
232		return(FAIL);
233	ret = SUCCESS;
234	sscanf(cmsglen, "%ld", &msglen);
235	if ( ((msglen-1)/512 +1) > Ulimit )
236		ret = EFBIG;
237	DEBUG(7, "erddata file is %ld bytes\n", msglen);
238	fd2 = fileno( fp2 );
239
240	if (Erdlen > 0) {
241		DEBUG(9, "%d bytes stashed\n", Erdlen);
242		if (write(fileno(fp2), erdptr, Erdlen) != Erdlen)
243			return(FAIL);
244		msglen -= Erdlen;
245		Erdlen = 0;
246		DEBUG(7, "erddata remainder is %ld bytes\n", msglen);
247	}
248
249	for (;;) {
250		len = erdblk(bufr, (int) MIN(msglen, EBUFSIZ), fn);
251		DEBUG(9, "erdblk ret %d\n", len);
252		if (len < 0) {
253			DEBUG(7, "erdblk failed\n%s", "");
254			return(FAIL);
255		}
256
257		/*
258		 * handle the case for remote socket close.
259		 */
260		if (len == 0) {
261			ret = errno;
262			DEBUG(7, "erddata: remote socket closed, errno %d\n",
263				    ret);
264			break;
265		}
266		bytes += len;
267		putfilesize(bytes);
268		if ((msglen -= len) < 0) {
269			DEBUG(7, "erdblk read too much\n%s", "");
270			return(FAIL);
271		}
272		/* this write is to file -- use write(2), not (*Write) */
273		if ( ret == SUCCESS && write( fd2, bufr, len ) != len ) {
274			ret = errno;
275			DEBUG(7, "erddata: write to file failed, errno %d\n", ret);
276		}
277		if (msglen == 0)
278			break;
279	}
280	return(ret);
281}
282
283/*
284 * read block from link
285 * reads are timed
286 *	blk	-> address of buffer
287 *	len	-> size to read
288 *	fn	-> link descriptor
289 * returns:
290 *	FAIL	-> link error timeout on link
291 *	i	-> # of bytes read (must not be 0)
292 */
293int
294erdblk(blk, len,  fn)
295char *blk;
296{
297	int i, ret;
298
299	if(setjmp(Failbuf)) {
300		DEBUG(7, "timeout (%d sec)\n", msgtime);
301		return(FAIL);
302	}
303
304	alarm(msgtime);
305	for (i = 0; i < len; i += ret) {
306		DEBUG(9, "erdblk ask %d ", len - i);
307		if ((ret = (*Read)(fn, blk, (unsigned) len - i)) < 0) {
308			alarm(0);
309			DEBUG(7, "erdblk read failed\n%s", "");
310			return(FAIL);
311		}
312		DEBUG(9, "erdblk got %d\n", ret);
313		if (ret == 0)
314			break;
315		blk += ret;
316	}
317	alarm(0);
318	return(i);
319}
320
321struct tbuf {
322	long t_nbytes;
323	char t_data[TBUFSIZE];
324};
325
326/*
327 * read message from link
328 *	str	-> message buffer
329 *	fn	-> file descriptor
330 * return
331 *	FAIL	-> read timed out
332 *	SUCCESS	-> ok message in str
333 */
334int
335trdmsg(str, fn)
336char *str;
337{
338	return(etrdmsg(str, fn, TPACKSIZE));
339}
340
341/*
342 * write message across link
343 *	type	-> message type
344 *	str	-> message body (ascii string)
345 *	fn	-> link file descriptor
346 * return
347 *	FAIL	-> write failed
348 *	SUCCESS	-> write succeeded
349 */
350int
351twrmsg(type, str, fn)
352char type;
353char *str;
354{
355	return(etwrmsg(type, str, fn, TPACKSIZE));
356}
357
358/*
359 * read data from file fp1 and write on link
360 *	fp1	-> file descriptor
361 *	fn	-> link descriptor
362 * returns:
363 *	FAIL	->failure in link
364 *	SUCCESS	-> ok
365 */
366int
367twrdata(fp1, fn)
368FILE *fp1;
369int	fn;
370{
371	int ret;
372	int len;
373	unsigned long bytes;
374	struct tbuf bufr;
375	struct stat statbuf;
376
377	if (setjmp(Failbuf)) {
378		DEBUG(7, "twrdata failed\n", 0);
379		return(FAIL);
380	}
381	fstat(fileno(fp1), &statbuf);
382	bytes = 0L;
383	while ((len = read(fileno(fp1), bufr.t_data, TBUFSIZE)) > 0) {
384		bufr.t_nbytes = htonl((long)len);
385		DEBUG(7, "twrdata writing %d ...", len);
386		bytes += len;
387		putfilesize(bytes);
388		len += sizeof(long);
389		alarm(msgtime);
390		ret = (*Write)(fn, (char *)&bufr, (unsigned) len);
391		alarm(0);
392		DEBUG(7, "ret %d\n", ret);
393		if (ret != len)
394			return(FAIL);
395		if (len != TBUFSIZE+sizeof(long))
396			break;
397	}
398	bufr.t_nbytes = 0;
399	alarm(msgtime);
400	ret = write(fn, (char *)&bufr, sizeof(long));
401	alarm(0);
402	if (ret != sizeof(long))
403		return FAIL;
404	return(SUCCESS);
405}
406
407/*
408 * read data from link and write into file
409 *	fp2	-> file descriptor
410 *	fn	-> link descriptor
411 * returns:
412 *	SUCCESS	-> ok
413 *	FAIL	-> failure on link
414 */
415int
416trddata(fn, fp2)
417FILE *fp2;
418{
419	int len, nread;
420	long Nbytes;
421	unsigned long bytes = 0L;
422	char bufr[TBUFSIZE];
423
424	for (;;) {
425		len = erdblk((char *)&Nbytes, sizeof(Nbytes), fn);
426		DEBUG(7, "trddata ret %d\n", len);
427		if (len != sizeof(Nbytes))
428			return(FAIL);
429		Nbytes = ntohl(Nbytes);
430		DEBUG(7,"trddata expecting %ld bytes\n", Nbytes);
431		nread = Nbytes;
432		if (nread == 0)
433			break;
434		len = erdblk(bufr, nread, fn);
435		if (len != Nbytes)
436			return(FAIL);
437		bytes += len;
438		putfilesize(bytes);
439		if (write(fileno(fp2), bufr, len) != len)
440			return(FAIL);
441	}
442	return(SUCCESS);
443}
444
445/*
446 * read message from link
447 *	str	-> message buffer
448 *	fn	-> file descriptor
449 *	i	-> if non-zero, amount to read; o.w., read up to '\0'
450 * return
451 *	FAIL	-> read timed out
452 *	SUCCESS	-> ok message in str
453 *
454 * 'e' is fatally flawed -- in a byte stream world, rdmsg can pick up
455 * the cmsglen on a R request.  if this happens, we stash the excess
456 * where rddata can pick it up.
457 */
458
459int
460etrdmsg(str, fn, i)
461char *str;
462int i;
463{
464	int len;
465	int nullterm = 0;
466	char *null, *argstr;
467
468
469	if (i == 0) {
470		DEBUG(9, "etrdmsg looking for null terminator\n", 0);
471		nullterm++;
472		i = EBUFSIZ;
473		argstr = str;
474	}
475
476	if(setjmp(Failbuf)) {
477		DEBUG(7, "timeout (%d sec)\n", msgtime);
478		return(FAIL);
479	}
480
481	alarm(msgtime);
482	for (;;) {
483		DEBUG(9, "etrdmsg want %d ...", i);
484		len = (*Read)(fn, str, i);
485		DEBUG(9, "got %d\n", len);
486		if (len == 0)
487			continue;	/* timeout will get this */
488		if (len < 0) {
489			alarm(0);
490			return(FAIL);
491		}
492		str += len;
493		i -= len;
494		if (nullterm) {
495			/* no way can a msg be as long as EBUFSIZ-1 ... */
496			*str = 0;
497			null = strchr(argstr, '\0');
498			if (null != str) {
499				null++;	/* start of stash */
500				memcpy(Erdstash + Erdlen, null, str - null);
501				Erdlen += str - null;
502				break;
503			} else
504				argstr = str;
505		} else {
506			if (i == 0)
507				break;
508		}
509	}
510	alarm(0);
511	return(SUCCESS);
512}
513
514/*
515 * write message across link
516 *	type	-> message type
517 *	str	-> message body (ascii string)
518 *	fn	-> link file descriptor
519 *	len	-> if non-zero, amount to write;
520		   o.w., write up to '\0' (inclusive)
521 * return
522 *	FAIL	-> write failed
523 *	SUCCESS	-> write succeeded
524 */
525int
526etwrmsg(type, str, fn, len)
527char type;
528char *str;
529int fn, len;
530{
531	char bufr[EBUFSIZ], *endstr;
532	int ret;
533
534	bufr[0] = type;
535
536	/* point endstr to last character to be sent */
537	if ((endstr = strchr(str, '\n')) != 0)
538		*endstr = 0;
539	else
540		endstr = str + strlen(str);
541
542	memcpy(bufr+1, str, (endstr - str) + 1);	/* include '\0' */
543	if (len == 0)
544		len = (endstr - str) + 2;	/* include bufr[0] and '\0' */
545	else
546		bufr[len-1] = 0;		/* 't' needs this terminator */
547
548
549	if (setjmp(Failbuf)) {
550		DEBUG(7, "etwrmsg write failed\n", 0);
551		return(FAIL);
552	}
553	DEBUG(9, "etwrmsg want %d ... ", len);
554	alarm(msgtime);
555	ret = (*Write)(fn, bufr, (unsigned) len);
556	alarm(0);
557	DEBUG(9, "sent %d\n", ret);
558	if (ret != len)
559		return(FAIL);
560	return(SUCCESS);
561}
562#endif	/* E_PROTOCOL */
563