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, Version 1.0 only
6 * (the "License"). You may not use this file except in compliance
7 * with the License.
8 *
9 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
10 * or http://www.opensolaris.org/os/licensing.
11 * See the License for the specific language governing permissions
12 * and limitations under the License.
13 *
14 * When distributing Covered Code, include this CDDL HEADER in each
15 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
16 * If applicable, add the following below this CDDL HEADER, with the
17 * fields enclosed by brackets "[]" replaced with your own identifying
18 * information: Portions Copyright [yyyy] [name of copyright owner]
19 *
20 * CDDL HEADER END
21 */
22 /*
23 * Copyright 2005 Sun Microsystems, Inc. All rights reserved.
24 * Use is subject to license terms.
25 */
26
27 /* Copyright (c) 1984, 1986, 1987, 1988, 1989 AT&T */
28 /* All Rights Reserved */
29
30 #pragma ident "%Z%%M% %I% %E% SMI"
31
32 /* LINTLIBRARY */
33
34 # include <errno.h>
35 # include <string.h>
36 #include <syslog.h>
37
38 # include "lp.h"
39 # include "msgs.h"
40
41 extern char Resync[];
42 extern char Endsync[];
43 static int Had_Full_Buffer = 1;
44 int Garbage_Bytes = 0;
45 int Garbage_Messages= 0;
46
47 static int _buffer(int);
48
49 /*
50 ** A real message is written in one piece, and the write
51 ** is atomic. Thus, even if the O_NDELAY flag is set,
52 ** if we read part of the real message, we can continue
53 ** to read the rest of it in as many steps as we want
54 ** (up to the size of the message, of course!) without
55 ** UNIX returning 0 because no data is available.
56 ** So, a real message doesn't have to be read in one piece,
57 ** which is good since we don't know how much to read!
58 **
59 ** Fake messages, or improperly written messages, don't
60 ** have this nice property.
61 **
62 ** INTERRUPTED READS:
63 **
64 ** If a signal occurs during an attempted read, we can exit.
65 ** The caller can retry the read and we will correctly restart
66 ** it. The correctness of this assertion can be seen by noticing
67 ** that at the beginning of each READ below, we can go back
68 ** to the first statement executed (the first READ below)
69 ** and correctly reexecute the code.
70 **
71 ** If the last writer closed the fifo, we'll read 0 bytes
72 ** (at least on the subsequent read). If we were in the
73 ** middle of reading a message, we were reading a bogus
74 ** message (but see below).
75 **
76 ** If we read less than we expect, it's because we were
77 ** reading a fake message (but see below).
78 **
79 ** HOWEVER: In the last two cases, we may have ONE OR MORE
80 ** REAL MESSAGES snuggled in amongst the trash!
81 **
82 ** All this verbal rambling is preface to let you understand why we
83 ** buffer the data (which is a shame, but necessary).
84 */
85
86 /*
87 ** As long as we get real messages, we can avoid needless function calls.
88 ** The SYNC argument in this macro should be set if the resynch. bytes
89 ** have been read--i.e. if the rest of the message is trying to be read.
90 ** In this case, if we had not read a full buffer last time, then we
91 ** must be in the middle of a bogus message.
92 */
93
94 #define UNSYNCHED_READ(N) \
95 if (fbp->psave_end - fbp->psave < N || fbp->psave >= fbp->psave_end) \
96 { \
97 switch (_buffer(fifo)) \
98 { \
99 case -1: \
100 return (-1); \
101 case 0: \
102 if (fbp->psave_end > fbp->psave) \
103 goto SyncUp; \
104 return (0); \
105 } \
106 }
107
108 #define SYNCHED_READ(N) \
109 if (fbp->psave_end - fbp->psave < N || fbp->psave >= fbp->psave_end) \
110 { \
111 switch (_buffer(fifo)) \
112 { \
113 case -1: \
114 return (-1); \
115 case 0: \
116 if (fbp->psave_end > fbp->psave) \
117 goto SyncUp; \
118 return (0); \
119 } \
120 if (!Had_Full_Buffer) \
121 goto SyncUp; \
122 }
123
124 /*
125 ** read_fifo() - READ A BUFFER WITH HEADER AND CHECKSUM
126 */
127 int
read_fifo(fifo,buf,size)128 read_fifo (fifo, buf, size)
129 int fifo;
130 char *buf;
131 unsigned int size;
132 {
133 register fifobuffer_t *fbp;
134 register unsigned int real_chksum,
135 chksum,
136 real_size;
137
138 /*
139 ** Make sure we start on a message boundary. The first
140 ** line of defense is to look for the resync. bytes.
141 **
142 ** The "SyncUp" label is global to this routine (below this point)
143 ** and is called whenever we determine that we're out
144 ** of sync. with the incoming bytes.
145 */
146
147 if (!(fbp=GetFifoBuffer (fifo)))
148 return -1;
149
150 UNSYNCHED_READ (HEAD_RESYNC_LEN);
151 while (*fbp->psave != Resync[0] || *(fbp->psave + 1) != Resync[1])
152 {
153 SyncUp:
154 #if defined(TRACE_MESSAGES)
155 if (trace_messages)
156 syslog(LOG_DEBUG, "DISCARD %c\n", *fbp->psave);
157 #endif
158 fbp->psave++;
159 Garbage_Bytes++;
160 UNSYNCHED_READ (HEAD_RESYNC_LEN);
161 }
162
163
164 /*
165 ** We're sync'd, so read the full header.
166 */
167
168 SYNCHED_READ (HEAD_LEN);
169
170
171 /*
172 ** If the header size is smaller than the minimum size for a header,
173 ** or larger than allowed, we must assume that we really aren't
174 ** synchronized.
175 */
176
177 real_size = stoh(fbp->psave + HEAD_SIZE);
178 if (real_size < CONTROL_LEN || MSGMAX < real_size)
179 {
180 #if defined(TRACE_MESSAGES)
181 if (trace_messages)
182 syslog(LOG_DEBUG, "BAD SIZE\n");
183 #endif
184 goto SyncUp;
185 }
186
187 /*
188 ** We have the header. Now we can finally read the rest of the
189 ** message...
190 */
191
192 SYNCHED_READ (real_size);
193
194
195 /*
196 ** ...but did we read a real message?...
197 */
198
199 if
200 (
201 *(fbp->psave + TAIL_ENDSYNC(real_size)) != Endsync[0]
202 || *(fbp->psave + TAIL_ENDSYNC(real_size) + 1) != Endsync[1]
203 )
204 {
205 #if defined(TRACE_MESSAGES)
206 if (trace_messages)
207 syslog(LOG_DEBUG, "BAD ENDSYNC\n");
208 #endif
209 Garbage_Messages++;
210 goto SyncUp;
211 }
212
213 chksum = stoh(fbp->psave + TAIL_CHKSUM(real_size));
214 CALC_CHKSUM (fbp->psave, real_size, real_chksum);
215 if (real_chksum != chksum)
216 {
217 #if defined(TRACE_MESSAGES)
218 if (trace_messages)
219 syslog(LOG_DEBUG, "BAD CHKSUM\n");
220 #endif
221 Garbage_Messages++;
222 goto SyncUp;
223 }
224
225 /*
226 ** ...yes!...but can the caller handle the message?
227 */
228
229 if (size < real_size)
230 {
231 errno = E2BIG;
232 return (-1);
233 }
234
235
236 /*
237 ** Yes!! We can finally copy the message into the caller's buffer
238 ** and remove it from our buffer. That wasn't so bad, was it?
239 */
240
241 #if defined(TRACE_MESSAGES)
242 if (trace_messages)
243 syslog(LOG_DEBUG, "MESSAGE: %-.*s", real_size, fbp->psave);
244 #endif
245 (void)memcpy (buf, fbp->psave, real_size);
246 fbp->psave += real_size;
247 return (real_size);
248 }
249
250 int
peek3_2(fifo)251 peek3_2 (fifo)
252 int fifo;
253 {
254 register fifobuffer_t *fbp;
255 register unsigned int real_size;
256
257 /*
258 ** Make sure we start on a message boundary. The first
259 ** line of defense is to look for the resync. bytes.
260 **
261 ** The "SyncUp" label is global to this routine (below this point)
262 ** and is called whenever we determine that we're out
263 ** of sync. with the incoming bytes.
264 */
265
266 if (!(fbp=GetFifoBuffer (fifo)))
267 return -1;
268 UNSYNCHED_READ (HEAD_RESYNC_LEN);
269 while (*fbp->psave != Resync[0] || *(fbp->psave + 1) != Resync[1])
270 {
271 SyncUp:
272 fbp->psave++;
273 Garbage_Bytes++;
274 UNSYNCHED_READ (HEAD_RESYNC_LEN);
275 }
276
277
278 /*
279 ** We're sync'd, so read the full header.
280 */
281
282 SYNCHED_READ (HEAD_LEN);
283
284
285 /*
286 ** If the header size is smaller than the minimum size for a header,
287 ** or larger than allowed, we must assume that we really aren't
288 ** synchronized.
289 */
290
291 real_size = stoh(fbp->psave + HEAD_SIZE);
292 if (real_size < CONTROL_LEN || MSGMAX < real_size)
293 {
294 goto SyncUp;
295 }
296
297 return(real_size);
298 }
299
300 static int
_buffer(int fifo)301 _buffer(int fifo)
302 {
303 int n, nbytes, count = 0;
304 register fifobuffer_t *fbp;
305
306 /*
307 ** As long as we get real messages, and if we chose
308 ** SAVE_SIZE well, we shouldn't have to move the data
309 ** in the "else" branch below: Each time we call "read"
310 ** we aren't likely to get as many bytes as we ask for,
311 ** just as many as are in the fifo, AND THIS SHOULD
312 ** REPRESENT AN INTEGRAL NUMBER OF MESSAGES. Since
313 ** the "read_fifo" routine reads complete messages,
314 ** it will end its read at the end of the message,
315 ** which (eventually) will make "psave_end" == "psave".
316 */
317
318 /*
319 ** If the buffer is empty, there's nothing to move.
320 */
321 if (!(fbp = GetFifoBuffer (fifo)))
322 return -1;
323 if (fbp->psave_end == fbp->psave)
324 fbp->psave = fbp->psave_end = fbp->save; /* sane pointers! */
325
326 /*
327 ** If the buffer has data at the high end, move it down.
328 */
329 else
330 if (fbp->psave != fbp->save) /* sane pointers! */
331 {
332 /*
333 ** Move the data still left in the buffer to the
334 ** front, so we can read as much as possible into
335 ** buffer after it.
336 */
337
338 memmove(fbp->save, fbp->psave, fbp->psave_end - fbp->psave);
339
340 fbp->psave_end = fbp->save + (fbp->psave_end - fbp->psave);
341 fbp->psave = fbp->save; /* sane pointers! */
342 }
343
344 /*
345 ** The "fbp->psave" and "fbp->psave_end" pointers must be in a sane
346 ** state when we get here, in case the "read()" gets interrupted.
347 ** When that happens, we return to the caller who may try
348 ** to restart us! Sane: fbp->psave == fbp->save (HERE!)
349 */
350
351 nbytes = MSGMAX - (fbp->psave_end - fbp->save);
352
353 while ((n = read(fifo, fbp->psave_end, nbytes)) == 0 && count < 60)
354 {
355 (void) sleep ((unsigned) 1);
356 count++;
357 }
358
359 if (n > 0)
360 fbp->psave_end += n;
361
362 Had_Full_Buffer = fbp->full;
363 fbp->full = (nbytes == n);
364
365 return (n);
366 }
367