read_fifo.c revision 7c478bd95313f5f23a4c958a745db2134aa03244
/*
* CDDL HEADER START
*
* The contents of this file are subject to the terms of the
* Common Development and Distribution License, Version 1.0 only
* (the "License"). You may not use this file except in compliance
* with the License.
*
* You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
* See the License for the specific language governing permissions
* and limitations under the License.
*
* When distributing Covered Code, include this CDDL HEADER in each
* file and include the License file at usr/src/OPENSOLARIS.LICENSE.
* If applicable, add the following below this CDDL HEADER, with the
* fields enclosed by brackets "[]" replaced with your own identifying
* information: Portions Copyright [yyyy] [name of copyright owner]
*
* CDDL HEADER END
*/
/*
* Copyright 1997 Sun Microsystems, Inc. All rights reserved.
* Use is subject to license terms.
*/
/* Copyright (c) 1984, 1986, 1987, 1988, 1989 AT&T */
/* All Rights Reserved */
#pragma ident "%Z%%M% %I% %E% SMI" /* SVr4.0 1.11 */
/* LINTLIBRARY */
# include <errno.h>
# include <string.h>
#include <syslog.h>
# include "lp.h"
# include "msgs.h"
extern char Resync[];
extern char Endsync[];
static int Had_Full_Buffer = 1;
int Garbage_Bytes = 0;
int Garbage_Messages= 0;
/*
** A real message is written in one piece, and the write
** is atomic. Thus, even if the O_NDELAY flag is set,
** if we read part of the real message, we can continue
** to read the rest of it in as many steps as we want
** (up to the size of the message, of course!) without
** UNIX returning 0 because no data is available.
** So, a real message doesn't have to be read in one piece,
** which is good since we don't know how much to read!
**
** Fake messages, or improperly written messages, don't
** have this nice property.
**
** INTERRUPTED READS:
**
** If a signal occurs during an attempted read, we can exit.
** The caller can retry the read and we will correctly restart
** it. The correctness of this assertion can be seen by noticing
** that at the beginning of each READ below, we can go back
** to the first statement executed (the first READ below)
** and correctly reexecute the code.
**
** If the last writer closed the fifo, we'll read 0 bytes
** (at least on the subsequent read). If we were in the
** middle of reading a message, we were reading a bogus
** message (but see below).
**
** If we read less than we expect, it's because we were
** reading a fake message (but see below).
**
** HOWEVER: In the last two cases, we may have ONE OR MORE
** REAL MESSAGES snuggled in amongst the trash!
**
** All this verbal rambling is preface to let you understand why we
** buffer the data (which is a shame, but necessary).
*/
/*
** As long as we get real messages, we can avoid needless function calls.
** The SYNC argument in this macro should be set if the resynch. bytes
** have been read--i.e. if the rest of the message is trying to be read.
** In this case, if we had not read a full buffer last time, then we
** must be in the middle of a bogus message.
*/
#define UNSYNCHED_READ(N) \
{ \
{ \
case -1: \
return (-1); \
case 0: \
goto SyncUp; \
return (0); \
} \
}
#define SYNCHED_READ(N) \
{ \
{ \
case -1: \
return (-1); \
case 0: \
goto SyncUp; \
return (0); \
} \
if (!Had_Full_Buffer) \
goto SyncUp; \
}
/*
** read_fifo() - READ A BUFFER WITH HEADER AND CHECKSUM
*/
int
int fifo;
char *buf;
unsigned int size;
{
register fifobuffer_t *fbp;
register unsigned int real_chksum,
/*
** Make sure we start on a message boundary. The first
** line of defense is to look for the resync. bytes.
**
** The "SyncUp" label is global to this routine (below this point)
** and is called whenever we determine that we're out
** of sync. with the incoming bytes.
*/
return -1;
{
#if defined(TRACE_MESSAGES)
if (trace_messages)
#endif
}
/*
** We're sync'd, so read the full header.
*/
/*
** If the header size is smaller than the minimum size for a header,
** or larger than allowed, we must assume that we really aren't
** synchronized.
*/
{
#if defined(TRACE_MESSAGES)
if (trace_messages)
#endif
goto SyncUp;
}
/*
** We have the header. Now we can finally read the rest of the
** message...
*/
/*
** ...but did we read a real message?...
*/
if
(
)
{
#if defined(TRACE_MESSAGES)
if (trace_messages)
#endif
goto SyncUp;
}
if (real_chksum != chksum)
{
#if defined(TRACE_MESSAGES)
if (trace_messages)
#endif
goto SyncUp;
}
/*
** ...yes!...but can the caller handle the message?
*/
{
return (-1);
}
/*
** Yes!! We can finally copy the message into the caller's buffer
** and remove it from our buffer. That wasn't so bad, was it?
*/
#if defined(TRACE_MESSAGES)
if (trace_messages)
#endif
return (real_size);
}
int
int fifo;
{
register fifobuffer_t *fbp;
register unsigned int real_size;
/*
** Make sure we start on a message boundary. The first
** line of defense is to look for the resync. bytes.
**
** The "SyncUp" label is global to this routine (below this point)
** and is called whenever we determine that we're out
** of sync. with the incoming bytes.
*/
return -1;
{
}
/*
** We're sync'd, so read the full header.
*/
/*
** If the header size is smaller than the minimum size for a header,
** or larger than allowed, we must assume that we really aren't
** synchronized.
*/
{
goto SyncUp;
}
return(real_size);
}
static int
int fifo;
{
register fifobuffer_t *fbp;
/*
** As long as we get real messages, and if we chose
** SAVE_SIZE well, we shouldn't have to move the data
** in the "else" branch below: Each time we call "read"
** we aren't likely to get as many bytes as we ask for,
** just as many as are in the fifo, AND THIS SHOULD
** REPRESENT AN INTEGRAL NUMBER OF MESSAGES. Since
** the "read_fifo" routine reads complete messages,
** it will end its read at the end of the message,
** which (eventually) will make "psave_end" == "psave".
*/
/*
** If the buffer is empty, there's nothing to move.
*/
return -1;
/*
** If the buffer has data at the high end, move it down.
*/
else
{
/*
** Move the data still left in the buffer to the
** front, so we can read as much as possible into
** buffer after it.
*/
}
/*
** The "fbp->psave" and "fbp->psave_end" pointers must be in a sane
** state when we get here, in case the "read()" gets interrupted.
** When that happens, we return to the caller who may try
** to restart us! Sane: fbp->psave == fbp->save (HERE!)
*/
{
(void) sleep ((unsigned) 1);
count++;
}
if (n > 0)
return (n);
}