connection.c 15.4 KB
Newer Older
Kurt Zeilenga's avatar
Kurt Zeilenga committed
1
#include "portable.h"
Kurt Zeilenga's avatar
Kurt Zeilenga committed
2
3
4
5
6
7
8
9
10

#include <stdio.h>

#include <ac/errno.h>
#include <ac/signal.h>
#include <ac/socket.h>
#include <ac/string.h>
#include <ac/time.h>

Kurt Zeilenga's avatar
Kurt Zeilenga committed
11
12
#include "slap.h"

13
14
15
16
17
18
19
20
21
22
/* protected by connections_mutex */
static ldap_pvt_thread_mutex_t connections_mutex;
static Connection *connections = NULL;
static int conn_index = -1;
static long conn_nextid = 0;

static Connection* connection_get( int s );

static int connection_input( Connection *c );

23
24
25
static int connection_op_activate( Connection *conn, Operation *op );
static int connection_resched( Connection *conn );

Kurt Zeilenga's avatar
Kurt Zeilenga committed
26
27
28
29
30
struct co_arg {
	Connection	*co_conn;
	Operation	*co_op;
};

31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
/*
 * Initialize connection management infrastructure.
 */
int connections_init(void)
{
	int i;

	assert( connections == NULL );

	if( connections != NULL) { /* probably should assert this */
		Debug( LDAP_DEBUG_ANY, "connections_init: already initialized.\n",
			0, 0, 0 );
		return -1;
	}

	/* should check return of every call */
	ldap_pvt_thread_mutex_init( &connections_mutex );

	connections = (Connection *) calloc( dtblsize, sizeof(Connection) );

	if( connections == NULL ) {
		Debug( LDAP_DEBUG_ANY,
			"connections_init: allocation (%d*%ld) of connection array failed.\n",
			dtblsize, (long) sizeof(Connection), 0 );
		return -1;
	}

	/*
	 * per entry initialization of the Connection array initialization
	 * will be done by connection_init()
	 */ 

	return 0;
}

static Connection* connection_get( int s )
{
	Connection *c = NULL;

	assert( connections != NULL );

	if(s < 0) {
		return NULL;
	}

#ifndef HAVE_WINSOCK
	assert( connections[s].c_struct_state == SLAP_C_USED );
	assert( connections[s].c_conn_state != SLAP_C_INVALID );
	assert( connections[s].c_sb.sb_sd != -1 );

	c = &connections[s];
#else
	{
		int i;

		for(i=0; i<dtblsize; i++) {
			if( connections[i].c_struct_state == SLAP_C_STRUCT_UNINITIALIZED ) {
				assert( connections[i].c_conn_state == SLAP_C_INVALID );
				assert( connections[s].c_sb.sb_sd == 0 );
				break;
			}

			if( connections[i].c_struct_state == SLAP_C_STRUCT_UNUSED ) {
				assert( connections[i].c_conn_state == SLAP_C_INVALID );
				assert( connections[s].c_sb.sb_sd == -1 );
				continue;
			}

			assert( connections[i].c_struct_state == SLAP_C_STRUCT_USED );
			assert( connections[i].c_conn_state != SLAP_C_INVALID );
			assert( connections[s].c_sb.sb_sd != -1 );

			if( connections[i].c_sb.sb_sd == s ) {
				c = &connections[s];
				break;
			}
		}
	}
#endif
110

111
	if( c != NULL ) {
112
113
114
115
116
		/* we do this BEFORE locking to aid in debugging */
		Debug( LDAP_DEBUG_TRACE,
			"connection_get(%d): got connid=%ld\n",
			s, c->c_connid, 0 );

117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
		ldap_pvt_thread_mutex_lock( &c->c_mutex );
	}
	return c;
}

static void connection_return( Connection *c )
{
	ldap_pvt_thread_mutex_unlock( &c->c_mutex );
}

long connection_init(
	int s,
	const char* name,
	const char* addr)
{
	long id;
	Connection *c;
	assert( connections != NULL );

	if( s < 0 ) {
		return -1;
	}

	assert( s >= 0 );
#ifndef HAVE_WINSOCK
	assert( s < dtblsize );
#endif

	ldap_pvt_thread_mutex_lock( &connections_mutex );

#ifndef HAVE_WINSOCK
	c = &connections[s];

#else
	{
		int i;

		for( i=0; i < dtblsize; i++ {
			if( connections[i].c_struct_state == SLAP_C_UNINITIALIZED ) {
				assert( connections[i].c_sb.sb_sd == 0 );
				c = &connections[i];
				break;
			}

			if( connections[i].c_struct_state == SLAP_C_UNUSED ) {
				assert( connections[i].c_sb.sb_sd == -1 );
				c = &connections[i];
				break;
			}

			assert( connections[i].c_struct_state == SLAP_C_USED );
			assert( connections[i].c_conn_state != SLAP_C_INVALID );
			assert( connections[i].c_sb.sb_sd != -1 );
		}

		if( c == NULL ) {
			ldap_pvt_thread_mutex_unlock( &connections_mutex );
			return -1;
		}
	}
#endif

	assert( c != NULL );
	assert( c->c_struct_state != SLAP_C_USED );
	assert( c->c_conn_state == SLAP_C_INVALID );

	if( c->c_struct_state == SLAP_C_UNINITIALIZED ) {
		c->c_dn = NULL;
		c->c_cdn = NULL;
		c->c_client_name = NULL;
		c->c_client_addr = NULL;
		c->c_ops = NULL;
		c->c_pending_ops = NULL;

		lber_pvt_sb_init( &c->c_sb );

		/* should check status of thread calls */
		ldap_pvt_thread_mutex_init( &c->c_mutex );
		ldap_pvt_thread_mutex_init( &c->c_write_mutex );
		ldap_pvt_thread_cond_init( &c->c_write_cv );

		c->c_struct_state = SLAP_C_UNUSED;
	}

	ldap_pvt_thread_mutex_lock( &c->c_mutex );

	assert( c->c_struct_state == SLAP_C_UNUSED );
	assert(	c->c_dn == NULL );
	assert(	c->c_cdn == NULL );
	assert( c->c_client_name == NULL );
	assert( c->c_client_addr == NULL );
	assert( c->c_ops == NULL );
	assert( c->c_pending_ops == NULL );

	c->c_client_name = ch_strdup( name == NULL ? "" : name );
	c->c_client_addr = ch_strdup( addr );

	c->c_n_ops_received = 0;
#ifdef LDAP_COUNTERS
	c->c_n_ops_executing = 0;
	c->c_n_ops_pending = 0;
	c->c_n_ops_completed = 0;
#endif

	c->c_starttime = slap_get_time();

	lber_pvt_sb_set_desc( &c->c_sb, s );
	lber_pvt_sb_set_io( &c->c_sb, &lber_pvt_sb_io_tcp, NULL );

	if( lber_pvt_sb_set_nonblock( &c->c_sb, 1 ) < 0 ) {
		Debug( LDAP_DEBUG_ANY,
			"connection_init(%d, %s, %s): set nonblocking failed\n",
			s, c->c_client_name, c->c_client_addr);
	}

	id = c->c_connid = conn_nextid++;

	c->c_conn_state = SLAP_C_INACTIVE;
	c->c_struct_state = SLAP_C_USED;

	ldap_pvt_thread_mutex_unlock( &c->c_mutex );
	ldap_pvt_thread_mutex_unlock( &connections_mutex );

	return id;
}

static void
connection_destroy( Connection *c )
{
	assert( connections != NULL );
	assert( c != NULL );
	assert( c->c_struct_state != SLAP_C_UNUSED );
	assert( c->c_conn_state != SLAP_C_INVALID );
	assert( c->c_ops == NULL );

	c->c_struct_state = SLAP_C_UNUSED;
	c->c_conn_state = SLAP_C_INVALID;

	c->c_version = 0;
	c->c_protocol = 0;

	c->c_starttime = 0;

	if(c->c_dn != NULL) {
		free(c->c_dn);
		c->c_dn = NULL;
	}
	if(c->c_cdn != NULL) {
		free(c->c_cdn);
		c->c_cdn = NULL;
	}
	if(c->c_client_name != NULL) {
		free(c->c_client_name);
		c->c_client_name = NULL;
	}
	if(c->c_client_addr != NULL) {
		free(c->c_client_addr);
		c->c_client_addr = NULL;
	}

	if ( lber_pvt_sb_in_use(&c->c_sb) ) {
		int sd = lber_pvt_sb_get_desc(&c->c_sb);

		slapd_remove( sd );
	   	lber_pvt_sb_close( &c->c_sb );

		Statslog( LDAP_DEBUG_STATS,
		    "conn=%d fd=%d closed.\n",
			c->c_connid, sd, 0, 0, 0 );
	}

   	lber_pvt_sb_destroy( &c->c_sb );
}

static void connection_close( Connection *c )
{
	assert( connections != NULL );
	assert( c != NULL );
	assert( c->c_struct_state == SLAP_C_USED );
	assert( c->c_conn_state == SLAP_C_CLOSING );

	if( c->c_ops != NULL ) {
		Debug( LDAP_DEBUG_TRACE,
			"connection_close: deferring conn=%ld sd=%d.\n",
			c->c_connid, c->c_sb.sb_sd, 0 );

		return;
	}

	Debug( LDAP_DEBUG_TRACE, "connection_close: conn=%ld sd=%d.\n",
		c->c_connid, c->c_sb.sb_sd, 0 );

	connection_destroy( c );
}

long connections_nextid(void)
{
	long id;
	assert( connections != NULL );

	ldap_pvt_thread_mutex_lock( &connections_mutex );

	id = conn_nextid;

	ldap_pvt_thread_mutex_unlock( &connections_mutex );

	return id;
}

Connection* connection_first(void)
{
	assert( connections != NULL );

	ldap_pvt_thread_mutex_lock( &connections_mutex );

	assert( conn_index == -1 );
	conn_index = 0;

	return connection_next(NULL);
}

Connection* connection_next(Connection *c)
{
	assert( connections != NULL );
	assert( conn_index != -1 );
	assert( conn_index <= dtblsize );

	if( c != NULL ) {
		ldap_pvt_thread_mutex_unlock( &c->c_mutex );
	}

	c = NULL;

	for(; conn_index < dtblsize; conn_index++) {
		if( connections[conn_index].c_struct_state == SLAP_C_UNINITIALIZED ) {
			assert( connections[conn_index].c_conn_state == SLAP_C_INVALID );
#ifndef HAVE_WINSOCK
			continue;
#else
			break;
#endif
		}

		if( connections[conn_index].c_struct_state == SLAP_C_USED ) {
			assert( connections[conn_index].c_conn_state != SLAP_C_INVALID );
			c = &connections[conn_index++];
			break;
		}

		assert( connections[conn_index].c_struct_state == SLAP_C_UNUSED );
		assert( connections[conn_index].c_conn_state == SLAP_C_INVALID );
	}

	if( c != NULL ) {
		ldap_pvt_thread_mutex_lock( &c->c_mutex );
	}

	return c;
}

void connection_done(Connection *c)
{
	assert( connections != NULL );
	assert( conn_index != -1 );
	assert( conn_index <= dtblsize );

	if( c != NULL ) {
		ldap_pvt_thread_mutex_unlock( &c->c_mutex );
	}

	conn_index = -1;
	ldap_pvt_thread_mutex_unlock( &connections_mutex );
}

Kurt Zeilenga's avatar
Kurt Zeilenga committed
391
392
393
394
395
396
/*
 * connection_activity - handle the request operation op on connection
 * conn.  This routine figures out what kind of operation it is and
 * calls the appropriate stub to handle it.
 */

397
398
static void *
connection_operation( void *arg_v )
Kurt Zeilenga's avatar
Kurt Zeilenga committed
399
{
400
	struct co_arg	*arg = arg_v;
401
402
	int tag = arg->co_op->o_tag;
	Connection *conn = arg->co_conn;
Kurt Zeilenga's avatar
Kurt Zeilenga committed
403

404
#ifdef LDAP_COUNTERS
405
	ldap_pvt_thread_mutex_lock( &ops_mutex );
Kurt Zeilenga's avatar
Kurt Zeilenga committed
406
	ops_initiated++;
407
	ldap_pvt_thread_mutex_unlock( &ops_mutex );
408
#endif
Kurt Zeilenga's avatar
Kurt Zeilenga committed
409

410
	switch ( tag ) {
Kurt Zeilenga's avatar
Kurt Zeilenga committed
411
	case LDAP_REQ_BIND:
412
		do_bind( conn, arg->co_op );
Kurt Zeilenga's avatar
Kurt Zeilenga committed
413
414
		break;

Kurt Zeilenga's avatar
Kurt Zeilenga committed
415
#ifdef LDAP_COMPAT30
Kurt Zeilenga's avatar
Kurt Zeilenga committed
416
417
418
	case LDAP_REQ_UNBIND_30:
#endif
	case LDAP_REQ_UNBIND:
419
		do_unbind( conn, arg->co_op );
Kurt Zeilenga's avatar
Kurt Zeilenga committed
420
421
422
		break;

	case LDAP_REQ_ADD:
423
		do_add( conn, arg->co_op );
Kurt Zeilenga's avatar
Kurt Zeilenga committed
424
425
		break;

Kurt Zeilenga's avatar
Kurt Zeilenga committed
426
#ifdef LDAP_COMPAT30
Kurt Zeilenga's avatar
Kurt Zeilenga committed
427
428
429
	case LDAP_REQ_DELETE_30:
#endif
	case LDAP_REQ_DELETE:
430
		do_delete( conn, arg->co_op );
Kurt Zeilenga's avatar
Kurt Zeilenga committed
431
432
433
		break;

	case LDAP_REQ_MODRDN:
434
		do_modrdn( conn, arg->co_op );
Kurt Zeilenga's avatar
Kurt Zeilenga committed
435
436
437
		break;

	case LDAP_REQ_MODIFY:
438
		do_modify( conn, arg->co_op );
Kurt Zeilenga's avatar
Kurt Zeilenga committed
439
440
441
		break;

	case LDAP_REQ_COMPARE:
442
		do_compare( conn, arg->co_op );
Kurt Zeilenga's avatar
Kurt Zeilenga committed
443
444
445
		break;

	case LDAP_REQ_SEARCH:
446
		do_search( conn, arg->co_op );
Kurt Zeilenga's avatar
Kurt Zeilenga committed
447
448
		break;

Kurt Zeilenga's avatar
Kurt Zeilenga committed
449
#ifdef LDAP_COMPAT30
Kurt Zeilenga's avatar
Kurt Zeilenga committed
450
451
452
	case LDAP_REQ_ABANDON_30:
#endif
	case LDAP_REQ_ABANDON:
453
		do_abandon( conn, arg->co_op );
Kurt Zeilenga's avatar
Kurt Zeilenga committed
454
455
456
		break;

	default:
457
		Debug( LDAP_DEBUG_ANY, "unknown request 0x%lx\n",
Kurt Zeilenga's avatar
Kurt Zeilenga committed
458
459
460
461
		    arg->co_op->o_tag, 0, 0 );
		break;
	}

462
#ifdef LDAP_COUNTERS
463
464
465
	ldap_pvt_thread_mutex_lock( &ops_mutex );
	ops_completed++;
	ldap_pvt_thread_mutex_unlock( &ops_mutex );
466
467
468
#endif

	ldap_pvt_thread_mutex_lock( &conn->c_mutex );
469

470
#ifdef LDAP_COUNTERS
471
	conn->c_ops_completed++;
472
#endif
Kurt Zeilenga's avatar
Kurt Zeilenga committed
473

474
475
476
	slap_op_remove( &conn->c_ops, arg->co_op );
	slap_op_free( arg->co_op );
	arg->co_op = NULL;
477
	arg->co_conn = NULL;
Kurt Zeilenga's avatar
Kurt Zeilenga committed
478
	free( (char *) arg );
479
	arg = NULL;
Kurt Zeilenga's avatar
Kurt Zeilenga committed
480

481
482
483
484
485
486
487
488
489
490
491
492
	switch( tag ) {
#ifdef LDAP_COMPAT30
	case LDAP_REQ_UNBIND_30:
#endif
	case LDAP_REQ_UNBIND:
		conn->c_conn_state = SLAP_C_CLOSING;
		break;

	case LDAP_REQ_BIND:
		if( conn->c_conn_state == SLAP_C_BINDING) {
			conn->c_conn_state = SLAP_C_ACTIVE;
		}
493
494
	}

495
496
497
498
499
500
501
	if( conn->c_conn_state == SLAP_C_CLOSING ) {
		Debug( LDAP_DEBUG_TRACE,
			"connection_operation: attempting closing conn=%ld sd=%d.\n",
			conn->c_connid, conn->c_sb.sb_sd, 0 );

		connection_close( conn );
	}
Kurt Zeilenga's avatar
Kurt Zeilenga committed
502

503
	ldap_pvt_thread_mutex_lock( &active_threads_mutex );
Kurt Zeilenga's avatar
Kurt Zeilenga committed
504
	active_threads--;
505
	if( active_threads < 1 ) {
506
		ldap_pvt_thread_cond_signal(&active_threads_cond);
507
	}
508
	ldap_pvt_thread_mutex_unlock( &active_threads_mutex );
509
510
511

	connection_resched( conn );

512
513
	ldap_pvt_thread_mutex_unlock( &conn->c_mutex );

514
	return NULL;
Kurt Zeilenga's avatar
Kurt Zeilenga committed
515
516
}

517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
int connection_read(int s)
{
	int rc = 0;
	Connection *c;
	assert( connections != NULL );

	ldap_pvt_thread_mutex_lock( &connections_mutex );

	c = connection_get( s );
	if( c == NULL ) {
		Debug( LDAP_DEBUG_ANY,
			"connection_read(%d): no connection!\n",
			s, 0, 0 );
		return -1;
	}

	Debug( LDAP_DEBUG_TRACE,
		"connection_read(%d): checking for input on id=%ld\n",
		s, c->c_connid, 0 );

#define CONNECTION_INPUT_LOOP 1

#ifdef DATA_READY_LOOP
	while(!rc && lber_pvt_sb_data_ready(&c->c_sb))
#elif CONNECTION_INPUT_LOOP
	while(!rc)
#endif
	{
		rc = connection_input( c );
	}

	if( rc < 0 ) {
		Debug( LDAP_DEBUG_TRACE,
			"connection_read(%d): input error id=%ld, closing.\n",
			s, c->c_connid, 0 );

		c->c_conn_state = SLAP_C_CLOSING;
		connection_close( c );
	}

	connection_return( c );
	ldap_pvt_thread_mutex_unlock( &connections_mutex );
	return 0;
}

static int
connection_input(
Kurt Zeilenga's avatar
Kurt Zeilenga committed
564
565
566
    Connection *conn
)
{
567
	Operation *op;
Kurt Zeilenga's avatar
Kurt Zeilenga committed
568
569
570
571
572
573
574
	unsigned long	tag, len;
	long		msgid;
	BerElement	*ber;

	if ( conn->c_currentber == NULL && (conn->c_currentber = ber_alloc())
	    == NULL ) {
		Debug( LDAP_DEBUG_ANY, "ber_alloc failed\n", 0, 0, 0 );
575
		return -1;
Kurt Zeilenga's avatar
Kurt Zeilenga committed
576
577
578
579
	}

	errno = 0;
	if ( (tag = ber_get_next( &conn->c_sb, &len, conn->c_currentber ))
580
581
	    != LDAP_TAG_MESSAGE )
	{
Kurt Zeilenga's avatar
Kurt Zeilenga committed
582
		Debug( LDAP_DEBUG_TRACE,
583
584
585
586
587
588
			"ber_get_next on fd %d failed errno %d (%s)\n",
			lber_pvt_sb_get_desc(&conn->c_sb), errno,
			errno > -1 && errno < sys_nerr ?  sys_errlist[errno] : "unknown" );
		Debug( LDAP_DEBUG_TRACE, "\t*** got %ld of %lu so far\n",
			(long)(conn->c_currentber->ber_rwptr - conn->c_currentber->ber_buf),
			conn->c_currentber->ber_len, 0 );
Kurt Zeilenga's avatar
Kurt Zeilenga committed
589
590
591
592
593
594

		if ( errno != EWOULDBLOCK && errno != EAGAIN ) {
			/* log, close and send error */
			ber_free( conn->c_currentber, 1 );
			conn->c_currentber = NULL;

595
			return -1;
Kurt Zeilenga's avatar
Kurt Zeilenga committed
596
597
		}

598
		return 1;
Kurt Zeilenga's avatar
Kurt Zeilenga committed
599
	}
600

Kurt Zeilenga's avatar
Kurt Zeilenga committed
601
602
603
604
605
	ber = conn->c_currentber;
	conn->c_currentber = NULL;

	if ( (tag = ber_get_int( ber, &msgid )) != LDAP_TAG_MSGID ) {
		/* log, close and send error */
606
		Debug( LDAP_DEBUG_ANY, "ber_get_int returns 0x%lx\n", tag, 0,
Kurt Zeilenga's avatar
Kurt Zeilenga committed
607
608
		    0 );
		ber_free( ber, 1 );
609
		return -1;
Kurt Zeilenga's avatar
Kurt Zeilenga committed
610
611
612
613
	}

	if ( (tag = ber_peek_tag( ber, &len )) == LBER_ERROR ) {
		/* log, close and send error */
614
		Debug( LDAP_DEBUG_ANY, "ber_peek_tag returns 0x%lx\n", tag, 0,
Kurt Zeilenga's avatar
Kurt Zeilenga committed
615
616
617
		    0 );
		ber_free( ber, 1 );

618
		return -1;
Kurt Zeilenga's avatar
Kurt Zeilenga committed
619
620
	}

Kurt Zeilenga's avatar
Kurt Zeilenga committed
621
#ifdef LDAP_COMPAT30
Kurt Zeilenga's avatar
Kurt Zeilenga committed
622
623
624
625
626
	if ( conn->c_version == 30 ) {
		(void) ber_skip_tag( ber, &len );
	}
#endif

627
	op = slap_op_alloc( ber, msgid, tag, conn->c_n_ops_received++ );
628

629
630
631
	if ( conn->c_conn_state == SLAP_C_BINDING
		|| conn->c_conn_state == SLAP_C_CLOSING )
	{
632
		Debug( LDAP_DEBUG_ANY, "deferring operation\n", 0, 0, 0 );
633
		slap_op_add( &conn->c_pending_ops, op );
634

635
636
637
	} else {
		connection_op_activate( conn, op );
	}
638

639
640
641
642
#ifdef NO_THREADS
	if ( conn->c_struct_state != SLAP_C_USED ) {
		/* connection must have got closed underneath us */
		return 1;
643
	}
644
645
#endif
	assert( conn->c_struct_state == SLAP_C_USED );
646

647
	return 0;
648
649
650
651
652
653
654
}

static int
connection_resched( Connection *conn )
{
	Operation *op;

655
	if( conn->c_conn_state != SLAP_C_ACTIVE ) {
656
657
658
659
660
661
662
663
664
665
		/* other states need different handling */
		return;
	}

	for( op = slap_op_pop( &conn->c_pending_ops );
		op != NULL;
		op = slap_op_pop( &conn->c_pending_ops ) )
	{
		connection_op_activate( conn, op );

666
		if ( conn->c_conn_state == SLAP_C_BINDING ) {
667
668
669
670
671
672
673
674
675
676
677
			break;
		}
	}
}

static int connection_op_activate( Connection *conn, Operation *op )
{
	struct co_arg *arg;
	char *tmpdn;
	int status;
	unsigned long tag = op->o_tag;
Kurt Zeilenga's avatar
Kurt Zeilenga committed
678
679

	if ( conn->c_dn != NULL ) {
680
		tmpdn = ch_strdup( conn->c_dn );
Kurt Zeilenga's avatar
Kurt Zeilenga committed
681
682
683
684
	} else {
		tmpdn = NULL;
	}

685
686
687
688
689
690
691
692
693
694
	arg = (struct co_arg *) ch_malloc( sizeof(struct co_arg) );
	arg->co_conn = conn;
	arg->co_op = op;

	arg->co_op->o_dn = ch_strdup( tmpdn != NULL ? tmpdn : "" );
	arg->co_op->o_ndn = dn_normalize_case( ch_strdup( arg->co_op->o_dn ) );

	slap_op_add( &conn->c_ops, arg->co_op );

	if(tag == LDAP_REQ_BIND) {
695
		conn->c_conn_state = SLAP_C_BINDING;
696
697
	}

Kurt Zeilenga's avatar
Kurt Zeilenga committed
698
699
700
701
	if ( tmpdn != NULL ) {
		free( tmpdn );
	}

702
703
704
705
	ldap_pvt_thread_mutex_lock( &active_threads_mutex );
	active_threads++;
	ldap_pvt_thread_mutex_unlock( &active_threads_mutex );

706
707
	status = ldap_pvt_thread_create( &arg->co_op->o_tid, 1,
					 connection_operation, (void *) arg );
708

709
	if ( status != 0 ) {
710
711
712
713
		Debug( LDAP_DEBUG_ANY,
		"ldap_pvt_thread_create failed (%d)\n", status, 0, 0 );

		/* should move op to pending list */
Kurt Zeilenga's avatar
Kurt Zeilenga committed
714
	}
715
716

	return status;
Kurt Zeilenga's avatar
Kurt Zeilenga committed
717
}
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743

int connection_write(int s)
{
	Connection *c;
	assert( connections != NULL );

	ldap_pvt_thread_mutex_lock( &connections_mutex );

	c = connection_get( s );
	if( c == NULL ) {
		Debug( LDAP_DEBUG_ANY,
			"connection_write(%d): no connection!\n",
			s, 0, 0 );
		return -1;
	}

	Debug( LDAP_DEBUG_TRACE,
		"connection_write(%d): waking output for id=%ld\n",
		s, c->c_connid, 0 );

	ldap_pvt_thread_cond_signal( &c->c_write_cv );

	connection_return( c );
	ldap_pvt_thread_mutex_unlock( &connections_mutex );
	return 0;
}