1/*	$NetBSD: thr_stub.c,v 1.1.1.4 2010/12/12 15:21:43 adam Exp $	*/
2
3/* thr_stub.c - stubs for the threads */
4/* OpenLDAP: pkg/ldap/libraries/libldap_r/thr_stub.c,v 1.27.2.11 2010/04/13 20:23:03 kurt Exp */
5/* This work is part of OpenLDAP Software <http://www.openldap.org/>.
6 *
7 * Copyright 1998-2010 The OpenLDAP Foundation.
8 * All rights reserved.
9 *
10 * Redistribution and use in source and binary forms, with or without
11 * modification, are permitted only as authorized by the OpenLDAP
12 * Public License.
13 *
14 * A copy of this license is available in file LICENSE in the
15 * top-level directory of the distribution or, alternatively, at
16 * <http://www.OpenLDAP.org/license.html>.
17 */
18
19#include "portable.h"
20
21#if defined( NO_THREADS )
22
23#include "ldap_pvt_thread.h" /* Get the thread interface */
24#define LDAP_THREAD_IMPLEMENTATION
25#define LDAP_THREAD_POOL_IMPLEMENTATION
26#include "ldap_thr_debug.h"  /* May rename the symbols defined below */
27
28/***********************************************************************
29 *                                                                     *
30 * no threads package defined for this system - fake ok returns from   *
31 * all threads routines (making it single-threaded).                   *
32 *                                                                     *
33 ***********************************************************************/
34
35int
36ldap_int_thread_initialize( void )
37{
38	return 0;
39}
40
41int
42ldap_int_thread_destroy( void )
43{
44	return 0;
45}
46
47static void* ldap_int_status = NULL;
48
49int
50ldap_pvt_thread_create( ldap_pvt_thread_t * thread,
51	int detach,
52	void *(*start_routine)(void *),
53	void *arg)
54{
55	if( ! detach ) ldap_int_status = NULL;
56	start_routine( arg );
57	return 0;
58}
59
60void
61ldap_pvt_thread_exit( void *retval )
62{
63	if( retval != NULL ) {
64		ldap_int_status = retval;
65	}
66	return;
67}
68
69int
70ldap_pvt_thread_join( ldap_pvt_thread_t thread, void **status )
71{
72	if(status != NULL) *status = ldap_int_status;
73	return 0;
74}
75
76int
77ldap_pvt_thread_kill( ldap_pvt_thread_t thread, int signo )
78{
79	return 0;
80}
81
82int
83ldap_pvt_thread_yield( void )
84{
85	return 0;
86}
87
88int
89ldap_pvt_thread_cond_init( ldap_pvt_thread_cond_t *cond )
90{
91	return 0;
92}
93
94int
95ldap_pvt_thread_cond_destroy( ldap_pvt_thread_cond_t *cond )
96{
97	return 0;
98}
99
100int
101ldap_pvt_thread_cond_signal( ldap_pvt_thread_cond_t *cond )
102{
103	return 0;
104}
105
106int
107ldap_pvt_thread_cond_broadcast( ldap_pvt_thread_cond_t *cond )
108{
109	return 0;
110}
111
112int
113ldap_pvt_thread_cond_wait( ldap_pvt_thread_cond_t *cond,
114			  ldap_pvt_thread_mutex_t *mutex )
115{
116	return 0;
117}
118
119int
120ldap_pvt_thread_mutex_init( ldap_pvt_thread_mutex_t *mutex )
121{
122	return 0;
123}
124
125int
126ldap_pvt_thread_mutex_destroy( ldap_pvt_thread_mutex_t *mutex )
127{
128	return 0;
129}
130
131int
132ldap_pvt_thread_mutex_lock( ldap_pvt_thread_mutex_t *mutex )
133{
134	return 0;
135}
136
137int
138ldap_pvt_thread_mutex_trylock( ldap_pvt_thread_mutex_t *mutex )
139{
140	return 0;
141}
142
143int
144ldap_pvt_thread_mutex_unlock( ldap_pvt_thread_mutex_t *mutex )
145{
146	return 0;
147}
148
149/*
150 * NO_THREADS requires a separate tpool implementation since
151 * generic ldap_pvt_thread_pool_wrapper loops forever.
152 */
153int
154ldap_pvt_thread_pool_init (
155	ldap_pvt_thread_pool_t *pool_out,
156	int max_concurrency, int max_pending )
157{
158	*pool_out = (ldap_pvt_thread_pool_t) 0;
159	return(0);
160}
161
162int
163ldap_pvt_thread_pool_submit (
164	ldap_pvt_thread_pool_t *pool,
165	ldap_pvt_thread_start_t *start_routine, void *arg )
166{
167	(start_routine)(NULL, arg);
168	return(0);
169}
170
171int
172ldap_pvt_thread_pool_retract (
173	ldap_pvt_thread_pool_t *pool,
174	ldap_pvt_thread_start_t *start_routine, void *arg )
175{
176	return(0);
177}
178
179int
180ldap_pvt_thread_pool_maxthreads ( ldap_pvt_thread_pool_t *tpool, int max_threads )
181{
182	return(0);
183}
184
185int
186ldap_pvt_thread_pool_query( ldap_pvt_thread_pool_t *tpool,
187	ldap_pvt_thread_pool_param_t param, void *value )
188{
189	*(int *)value = -1;
190	return(-1);
191}
192
193int
194ldap_pvt_thread_pool_backload (
195	ldap_pvt_thread_pool_t *pool )
196{
197	return(0);
198}
199
200int
201ldap_pvt_thread_pool_destroy (
202	ldap_pvt_thread_pool_t *pool, int run_pending )
203{
204	return(0);
205}
206
207int ldap_pvt_thread_pool_getkey (
208	void *ctx, void *key, void **data, ldap_pvt_thread_pool_keyfree_t **kfree )
209{
210	return(0);
211}
212
213int ldap_pvt_thread_pool_setkey (
214	void *ctx, void *key,
215	void *data, ldap_pvt_thread_pool_keyfree_t *kfree,
216	void **olddatap, ldap_pvt_thread_pool_keyfree_t **oldkfreep )
217{
218	if ( olddatap ) *olddatap = NULL;
219	if ( oldkfreep ) *oldkfreep = 0;
220	return(0);
221}
222
223void ldap_pvt_thread_pool_purgekey( void *key )
224{
225}
226
227int ldap_pvt_thread_pool_pause (
228	ldap_pvt_thread_pool_t *tpool )
229{
230	return(0);
231}
232
233int ldap_pvt_thread_pool_resume (
234	ldap_pvt_thread_pool_t *tpool )
235{
236	return(0);
237}
238
239int ldap_pvt_thread_pool_pausing( ldap_pvt_thread_pool_t *tpool )
240{
241	return(0);
242}
243
244ldap_pvt_thread_pool_pausecheck( ldap_pvt_thread_pool_t *tpool )
245{
246	return(0);
247}
248
249void *ldap_pvt_thread_pool_context( )
250{
251	return(NULL);
252}
253
254void ldap_pvt_thread_pool_context_reset( void *vctx )
255{
256}
257
258ldap_pvt_thread_t
259ldap_pvt_thread_self( void )
260{
261	return(0);
262}
263
264int
265ldap_pvt_thread_key_create( ldap_pvt_thread_key_t *key )
266{
267	return(0);
268}
269
270int
271ldap_pvt_thread_key_destroy( ldap_pvt_thread_key_t key )
272{
273	return(0);
274}
275
276int
277ldap_pvt_thread_key_setdata( ldap_pvt_thread_key_t key, void *data )
278{
279	return(0);
280}
281
282int
283ldap_pvt_thread_key_getdata( ldap_pvt_thread_key_t key, void **data )
284{
285	return(0);
286}
287
288ldap_pvt_thread_t
289ldap_pvt_thread_pool_tid( void *vctx )
290{
291
292	return(0);
293}
294
295#endif /* NO_THREADS */
296