![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to ringbuf.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Synchronet] / sbbs / src / sbbs3|
Return to ringbuf.c CVS log | Up to [Synchronet] / sbbs / src / sbbs3 |
1.1 root 1: /* ringbuf.c */
2:
3: /* Synchronet ring buffer routines */
4:
5: /* $Id: ringbuf.c,v 1.27 2005/10/21 21:52:45 deuce Exp $ */
6:
7: /****************************************************************************
8: * @format.tab-size 4 (Plain Text/Source Code File Header) *
9: * @format.use-tabs true (see http://www.synchro.net/ptsc_hdr.html) *
10: * *
11: * Copyright 2005 Rob Swindell - http://www.synchro.net/copyright.html *
12: * *
13: * This program is free software; you can redistribute it and/or *
14: * modify it under the terms of the GNU General Public License *
15: * as published by the Free Software Foundation; either version 2 *
16: * of the License, or (at your option) any later version. *
17: * See the GNU General Public License for more details: gpl.txt or *
18: * http://www.fsf.org/copyleft/gpl.html *
19: * *
20: * Anonymous FTP access to the most recent released source is available at *
21: * ftp://vert.synchro.net, ftp://cvs.synchro.net and ftp://ftp.synchro.net *
22: * *
23: * Anonymous CVS access to the development source and modification history *
24: * is available at cvs.synchro.net:/cvsroot/sbbs, example: *
25: * cvs -d :pserver:[email protected]:/cvsroot/sbbs login *
26: * (just hit return, no password is necessary) *
27: * cvs -d :pserver:[email protected]:/cvsroot/sbbs checkout src *
28: * *
29: * For Synchronet coding style and modification guidelines, see *
30: * http://www.synchro.net/source.html *
31: * *
32: * You are encouraged to submit any modifications (preferably in Unix diff *
33: * format) via e-mail to [email protected] *
34: * *
35: * Note: If this box doesn't appear square, then you need to fix your tabs. *
36: ****************************************************************************/
37:
38: /* Pre-define RINGBUF_USE_STD_RTL to use standard C runtime library symbols
39: * for malloc, free, and memcpy
40: */
41:
42: #ifdef VTOOLSD
43: #include <vtoolsd.h>
44: #include LOCKED_CODE_SEGMENT
45: #include LOCKED_DATA_SEGMENT
46: #endif
47:
48: #include "ringbuf.h"
49: #include "genwrap.h" /* SLEEP() */
50:
51: #ifdef RINGBUF_USE_STD_RTL
52:
53: #ifndef VTOOLSD
54:
55: /* FreeBSD uses <stdlib.h> instead of <malloc.h> */
56: #ifdef __unix__
57: #include <stdlib.h>
58: #else
59: #include <malloc.h> /* malloc prototype */
60: #endif
61: #include <string.h> /* memcpy prototype */
62: #endif /* !VTOOLSD */
63:
64: #define os_malloc malloc
65: #define rb_malloc malloc
66: #define os_free free
67: #define rb_free free
68: #define os_memcpy memcpy
69: #define rb_memcpy memcpy
70:
71: #else
72:
73: void (*rb_free)(void *);
74: void *(*rb_memcpy)(void *, const void *, size_t);
75:
76: #endif
77: /****************************************************************************/
78: /* Returns 0 on success, non-zero on failure */
79: /****************************************************************************/
80: int RINGBUFCALL RingBufInit( RingBuf* rb, DWORD size
81: #ifndef RINGBUF_USE_STD_RTL
82: ,void *(os_malloc)(size_t)
83: ,void (os_free)(void *)
84: ,void *(os_memcpy)(void *, const void *, size_t)
85: #endif
86: )
87: {
88: memset(rb,0,sizeof(RingBuf));
89: if((rb->pStart=(BYTE *)os_malloc(size+1))==NULL)
90: return(-1);
91: #ifndef RINGBUF_USE_STD_RTL
92: rb_free=os_free;
93: rb_memcpy=os_memcpy;
94: #endif
95: rb->pHead=rb->pTail=rb->pStart;
96: rb->pEnd=rb->pStart+size;
97: rb->size=size;
98: #ifdef RINGBUF_SEM
99: sem_init(&rb->sem,0,0);
100: sem_init(&rb->highwater_sem,0,0);
101: #endif
102: #ifdef RINGBUF_EVENT
103: rb->empty_event=CreateEvent(NULL,TRUE,TRUE,NULL);
104: #endif
105: #ifdef RINGBUF_MUTEX
106: pthread_mutex_init(&rb->mutex,NULL);
107: #endif
108: return(0);
109: }
110:
111: void RINGBUFCALL RingBufDispose( RingBuf* rb)
112: {
113: if(rb->pStart!=NULL)
114: os_free(rb->pStart);
115: #ifdef RINGBUF_SEM
116: sem_post(&rb->sem); /* just incase someone's waiting */
117: while(sem_destroy(&rb->sem)==-1 && errno==EBUSY) {
118: SLEEP(1);
119: sem_post(&rb->sem);
120: }
121: while(sem_destroy(&rb->highwater_sem)==-1 && errno==EBUSY) {
122: SLEEP(1);
123: sem_post(&rb->highwater_sem);
124: }
125: #endif
126: #ifdef RINGBUF_EVENT
127: if(rb->empty_event!=NULL)
128: CloseEvent(rb->empty_event);
129: #endif
130: #ifdef RINGBUF_MUTEX
131: while(pthread_mutex_destroy(&rb->mutex)==EBUSY)
132: SLEEP(1);
133: #endif
134: memset(rb,0,sizeof(RingBuf));
135: }
136:
137: #define RINGBUF_FILL_LEVEL(rb) (rb->pHead >= rb->pTail ? (rb->pHead - rb->pTail) \
138: : (rb->size - (rb->pTail - (rb->pHead + 1))))
139:
140: DWORD RINGBUFCALL RingBufFull( RingBuf* rb )
141: {
142: DWORD retval;
143:
144: #ifdef RINGBUF_MUTEX
145: pthread_mutex_lock(&rb->mutex);
146: #endif
147:
148: retval = RINGBUF_FILL_LEVEL(rb);
149:
150: #ifdef RINGBUF_EVENT
151: if(rb->empty_event!=NULL) {
152: if(retval==0)
153: SetEvent(rb->empty_event);
154: else
155: ResetEvent(rb->empty_event);
156: }
157: #endif
158:
159: #ifdef RINGBUF_MUTEX
160: pthread_mutex_unlock(&rb->mutex);
161: #endif
162:
163: return(retval);
164: }
165:
166: DWORD RINGBUFCALL RingBufFree( RingBuf* rb )
167: {
168: DWORD retval;
169:
170: retval = (rb->size - RingBufFull( rb ));
171:
172: return(retval);
173: }
174:
175: DWORD RINGBUFCALL RingBufWrite( RingBuf* rb, BYTE* src, DWORD cnt )
176: {
177: DWORD max, first, remain;
178:
179: if(rb->pStart==NULL)
180: return(0);
181:
182: #ifdef RINGBUF_MUTEX
183: pthread_mutex_lock(&rb->mutex);
184: #endif
185:
186: /* allowed to write at pEnd */
187: max = (((DWORD) rb->pEnd) - ((DWORD) rb->pHead)) + 1;
188:
189: /*
190: * we assume the caller has checked that there is enough room. For this reason
191: * we do not have to worry about head wrapping past the tail
192: */
193:
194: if( max >= cnt ) {
195: first = cnt;
196: remain = 0;
197: } else {
198: first = max;
199: remain = cnt - first;
200: }
201:
202: rb_memcpy( rb->pHead, src, first );
203: rb->pHead += first;
204: src += first;
205:
206: if(remain) {
207:
208: rb->pHead = rb->pStart;
209: rb_memcpy(rb->pHead, src, remain);
210: rb->pHead += remain;
211: }
212:
213: if(rb->pHead > rb->pEnd)
214: rb->pHead = rb->pStart;
215:
216: #ifdef RINGBUF_SEM
217: sem_post(&rb->sem);
218: if(rb->highwater_mark!=0 && RINGBUF_FILL_LEVEL(rb)>=rb->highwater_mark)
219: sem_post(&rb->highwater_sem);
220: #endif
221: #ifdef RINGBUF_EVENT
222: if(rb->empty_event!=NULL)
223: ResetEvent(rb->empty_event);
224: #endif
225:
226: #ifdef RINGBUF_MUTEX
227: pthread_mutex_unlock(&rb->mutex);
228: #endif
229:
230: return(cnt);
231: }
232:
233: /* Pass NULL dst to just foward pointer (after Peek) */
234: DWORD RINGBUFCALL RingBufRead( RingBuf* rb, BYTE* dst, DWORD cnt )
235: {
236: DWORD max, first, remain, len;
237:
238: #ifdef RINGBUF_MUTEX
239: pthread_mutex_lock(&rb->mutex);
240: #endif
241:
242: len = RINGBUF_FILL_LEVEL(rb);
243:
244: if( len < cnt )
245: cnt = len;
246:
247: /* allowed to read at pEnd */
248: max = (((DWORD) rb->pEnd) - ((DWORD) rb->pTail)) + 1;
249:
250: if( max >= cnt ) {
251: first = cnt;
252: remain = 0;
253: } else {
254: first = max;
255: remain = cnt - first;
256: }
257:
258: if(first && dst!=NULL) {
259: rb_memcpy( dst, rb->pTail, first );
260: dst += first;
261: }
262: rb->pTail += first;
263:
264: if( remain ){
265:
266: rb->pTail = rb->pStart;
267: if(dst!=NULL)
268: rb_memcpy( dst, rb->pTail, remain );
269: rb->pTail += remain;
270: }
271:
272: if(rb->pTail > rb->pEnd)
273: rb->pTail = rb->pStart;
274:
275: #ifdef RINGBUF_SEM /* clear/signal semaphores, if appropriate */
276: if(RINGBUF_FILL_LEVEL(rb) == 0) /* empty */
277: sem_reset(&rb->sem);
278: if(RINGBUF_FILL_LEVEL(rb) < rb->highwater_mark)
279: sem_reset(&rb->highwater_sem);
280: #endif
281:
282: #ifdef RINGBUF_EVENT
283: if(rb->empty_event!=NULL && RINGBUF_FILL_LEVEL(rb)==0)
284: SetEvent(rb->empty_event);
285: #endif
286:
287: #ifdef RINGBUF_MUTEX
288: pthread_mutex_unlock(&rb->mutex);
289: #endif
290:
291: return(cnt);
292: }
293:
294: DWORD RINGBUFCALL RingBufPeek( RingBuf* rb, BYTE* dst, DWORD cnt)
295: {
296: DWORD max, first, remain, len;
297:
298: len = RingBufFull( rb );
299: if( len == 0 )
300: return(0);
301:
302: #ifdef RINGBUF_MUTEX
303: pthread_mutex_lock(&rb->mutex);
304: #endif
305:
306: if( len < cnt )
307: cnt = len;
308:
309: /* allowed to read at pEnd */
310: max = (((DWORD) rb->pEnd) - ((DWORD) rb->pTail)) + 1;
311:
312: if( max >= cnt ) {
313: first = cnt;
314: remain = 0;
315: } else {
316: first = max;
317: remain = cnt - first;
318: }
319:
320: rb_memcpy( dst, rb->pTail, first );
321: dst += first;
322:
323: if(remain) {
324: rb_memcpy( dst, rb->pStart, remain );
325: }
326:
327: #ifdef RINGBUF_MUTEX
328: pthread_mutex_unlock(&rb->mutex);
329: #endif
330:
331: return(cnt);
332: }
333:
334: /* Reset head and tail pointers */
335: void RINGBUFCALL RingBufReInit(RingBuf* rb)
336: {
337: #ifdef RINGBUF_MUTEX
338: pthread_mutex_lock(&rb->mutex);
339: #endif
340: rb->pHead = rb->pTail = rb->pStart;
341: #ifdef RINGBUF_SEM
342: sem_reset(&rb->sem);
343: sem_reset(&rb->highwater_sem);
344: #endif
345: #ifdef RINGBUF_MUTEX
346: pthread_mutex_unlock(&rb->mutex);
347: #endif
348: }
349:
350: /* End of RINGBUF.C */
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.