connection.c 16.5 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
/* 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;

19
20
21
22
23
24
25
26
27
28
29
30
/* structure state (protected by connections_mutex) */
#define SLAP_C_UNINITIALIZED	0x0	/* MUST BE ZERO (0) */
#define SLAP_C_UNUSED			0x1
#define SLAP_C_USED				0x2

/* connection state (protected by c_mutex ) */
#define SLAP_C_INVALID			0x0	/* MUST BE ZERO (0) */
#define SLAP_C_INACTIVE			0x1	/* zero threads */
#define SLAP_C_ACTIVE			0x2 /* one or more threads */
#define SLAP_C_BINDING			0x3	/* binding */
#define SLAP_C_CLOSING			0x4	/* closing */

31
32
33
34
static Connection* connection_get( int s );

static int connection_input( Connection *c );

35
36
37
static int connection_op_activate( Connection *conn, Operation *op );
static int connection_resched( Connection *conn );

Kurt Zeilenga's avatar
Kurt Zeilenga committed
38
39
40
41
42
struct co_arg {
	Connection	*co_conn;
	Operation	*co_op;
};

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
110
111
112
113
114
115
116
117
118
119
120
121
/*
 * 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
122

123
	if( c != NULL ) {
124
125
126
127
128
		/* 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 );

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
		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 );
}

303
304
305
306
307
308
309
310
311
312
313
314
315
316
void connection_closing( Connection *c )
{
	assert( connections != NULL );
	assert( c != NULL );
	assert( c->c_struct_state == SLAP_C_USED );
	assert( c->c_conn_state != SLAP_C_INVALID );

	if( c->c_conn_state != SLAP_C_CLOSING ) {
		/* don't listen on this port anymore */
		slapd_clr_read( c->c_sb.sb_sd, 1 );
		c->c_conn_state = SLAP_C_CLOSING;
	}
}

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
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
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
417
418
419
420
421
422
/*
 * 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.
 */

423
424
static void *
connection_operation( void *arg_v )
Kurt Zeilenga's avatar
Kurt Zeilenga committed
425
{
426
	struct co_arg	*arg = arg_v;
427
428
	int tag = arg->co_op->o_tag;
	Connection *conn = arg->co_conn;
Kurt Zeilenga's avatar
Kurt Zeilenga committed
429

430
#ifdef LDAP_COUNTERS
Kurt Zeilenga's avatar
Kurt Zeilenga committed
431
432
433
	ldap_pvt_thread_mutex_lock( &num_ops_mutex );
	num_ops_initiated++;
	ldap_pvt_thread_mutex_unlock( &num_ops_mutex );
434
#endif
Kurt Zeilenga's avatar
Kurt Zeilenga committed
435

436
	switch ( tag ) {
Kurt Zeilenga's avatar
Kurt Zeilenga committed
437
	case LDAP_REQ_BIND:
438
		do_bind( conn, arg->co_op );
Kurt Zeilenga's avatar
Kurt Zeilenga committed
439
440
		break;

Kurt Zeilenga's avatar
Kurt Zeilenga committed
441
#ifdef LDAP_COMPAT30
Kurt Zeilenga's avatar
Kurt Zeilenga committed
442
443
444
	case LDAP_REQ_UNBIND_30:
#endif
	case LDAP_REQ_UNBIND:
445
		do_unbind( conn, arg->co_op );
Kurt Zeilenga's avatar
Kurt Zeilenga committed
446
447
448
		break;

	case LDAP_REQ_ADD:
449
		do_add( conn, arg->co_op );
Kurt Zeilenga's avatar
Kurt Zeilenga committed
450
451
		break;

Kurt Zeilenga's avatar
Kurt Zeilenga committed
452
#ifdef LDAP_COMPAT30
Kurt Zeilenga's avatar
Kurt Zeilenga committed
453
454
455
	case LDAP_REQ_DELETE_30:
#endif
	case LDAP_REQ_DELETE:
456
		do_delete( conn, arg->co_op );
Kurt Zeilenga's avatar
Kurt Zeilenga committed
457
458
459
		break;

	case LDAP_REQ_MODRDN:
460
		do_modrdn( conn, arg->co_op );
Kurt Zeilenga's avatar
Kurt Zeilenga committed
461
462
463
		break;

	case LDAP_REQ_MODIFY:
464
		do_modify( conn, arg->co_op );
Kurt Zeilenga's avatar
Kurt Zeilenga committed
465
466
467
		break;

	case LDAP_REQ_COMPARE:
468
		do_compare( conn, arg->co_op );
Kurt Zeilenga's avatar
Kurt Zeilenga committed
469
470
471
		break;

	case LDAP_REQ_SEARCH:
472
		do_search( conn, arg->co_op );
Kurt Zeilenga's avatar
Kurt Zeilenga committed
473
474
		break;

Kurt Zeilenga's avatar
Kurt Zeilenga committed
475
#ifdef LDAP_COMPAT30
Kurt Zeilenga's avatar
Kurt Zeilenga committed
476
477
478
	case LDAP_REQ_ABANDON_30:
#endif
	case LDAP_REQ_ABANDON:
479
		do_abandon( conn, arg->co_op );
Kurt Zeilenga's avatar
Kurt Zeilenga committed
480
481
482
		break;

	default:
483
		Debug( LDAP_DEBUG_ANY, "unknown request 0x%lx\n",
Kurt Zeilenga's avatar
Kurt Zeilenga committed
484
485
486
487
		    arg->co_op->o_tag, 0, 0 );
		break;
	}

488
#ifdef LDAP_COUNTERS
Kurt Zeilenga's avatar
Kurt Zeilenga committed
489
490
491
	ldap_pvt_thread_mutex_lock( &num_ops_mutex );
	num_ops_completed++;
	ldap_pvt_thread_mutex_unlock( &num_ops_mutex );
492
493
494
#endif

	ldap_pvt_thread_mutex_lock( &conn->c_mutex );
495

496
#ifdef LDAP_COUNTERS
Kurt Zeilenga's avatar
Kurt Zeilenga committed
497
	conn->c_n_ops_completed++;
498
#endif
Kurt Zeilenga's avatar
Kurt Zeilenga committed
499

500
501
502
	slap_op_remove( &conn->c_ops, arg->co_op );
	slap_op_free( arg->co_op );
	arg->co_op = NULL;
503
	arg->co_conn = NULL;
Kurt Zeilenga's avatar
Kurt Zeilenga committed
504
	free( (char *) arg );
505
	arg = NULL;
Kurt Zeilenga's avatar
Kurt Zeilenga committed
506

507
508
509
510
511
	switch( tag ) {
#ifdef LDAP_COMPAT30
	case LDAP_REQ_UNBIND_30:
#endif
	case LDAP_REQ_UNBIND:
512
		connection_closing( conn );
513
514
515
516
517
518
		break;

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

521
522
523
524
525
526
527
	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
528

529
	ldap_pvt_thread_mutex_lock( &active_threads_mutex );
Kurt Zeilenga's avatar
Kurt Zeilenga committed
530
	active_threads--;
531
	if( active_threads < 1 ) {
532
		ldap_pvt_thread_cond_signal(&active_threads_cond);
533
	}
534
	ldap_pvt_thread_mutex_unlock( &active_threads_mutex );
535
536
537

	connection_resched( conn );

538
539
	ldap_pvt_thread_mutex_unlock( &conn->c_mutex );

540
	return NULL;
Kurt Zeilenga's avatar
Kurt Zeilenga committed
541
542
}

543
544
545
546
547
548
549
550
551
552
553
554
555
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 );
556
		ldap_pvt_thread_mutex_unlock( &connections_mutex );
557
558
559
		return -1;
	}

560
561
562
563
564
565
566
567
568
569
	if( c->c_conn_state == SLAP_C_CLOSING ) {
		Debug( LDAP_DEBUG_TRACE,
			"connection_read(%d): closing, ignoring input for id=%ld\n",
			s, c->c_connid, 0 );

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

570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
	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 );

590
		connection_closing( c );
591
592
593
594
595
596
597
598
599
600
		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
601
602
603
    Connection *conn
)
{
604
	Operation *op;
Kurt Zeilenga's avatar
Kurt Zeilenga committed
605
606
607
608
609
610
611
	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 );
612
		return -1;
Kurt Zeilenga's avatar
Kurt Zeilenga committed
613
614
615
616
	}

	errno = 0;
	if ( (tag = ber_get_next( &conn->c_sb, &len, conn->c_currentber ))
617
618
	    != LDAP_TAG_MESSAGE )
	{
Kurt Zeilenga's avatar
Kurt Zeilenga committed
619
		Debug( LDAP_DEBUG_TRACE,
620
621
622
			"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" );
623
624
		Debug( LDAP_DEBUG_TRACE,
			"\t*** got %ld of %lu so far\n",
625
626
			(long)(conn->c_currentber->ber_rwptr - conn->c_currentber->ber_buf),
			conn->c_currentber->ber_len, 0 );
Kurt Zeilenga's avatar
Kurt Zeilenga committed
627
628
629
630
631
632

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

633
			return -1;
Kurt Zeilenga's avatar
Kurt Zeilenga committed
634
635
		}

636
		return 1;
Kurt Zeilenga's avatar
Kurt Zeilenga committed
637
	}
638

Kurt Zeilenga's avatar
Kurt Zeilenga committed
639
640
641
642
643
	ber = conn->c_currentber;
	conn->c_currentber = NULL;

	if ( (tag = ber_get_int( ber, &msgid )) != LDAP_TAG_MSGID ) {
		/* log, close and send error */
644
		Debug( LDAP_DEBUG_ANY, "ber_get_int returns 0x%lx\n", tag, 0,
Kurt Zeilenga's avatar
Kurt Zeilenga committed
645
646
		    0 );
		ber_free( ber, 1 );
647
		return -1;
Kurt Zeilenga's avatar
Kurt Zeilenga committed
648
649
650
651
	}

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

656
		return -1;
Kurt Zeilenga's avatar
Kurt Zeilenga committed
657
658
	}

Kurt Zeilenga's avatar
Kurt Zeilenga committed
659
#ifdef LDAP_COMPAT30
Kurt Zeilenga's avatar
Kurt Zeilenga committed
660
661
662
663
664
	if ( conn->c_version == 30 ) {
		(void) ber_skip_tag( ber, &len );
	}
#endif

665
	op = slap_op_alloc( ber, msgid, tag, conn->c_n_ops_received++ );
666

667
668
669
	if ( conn->c_conn_state == SLAP_C_BINDING
		|| conn->c_conn_state == SLAP_C_CLOSING )
	{
670
		Debug( LDAP_DEBUG_ANY, "deferring operation\n", 0, 0, 0 );
671
		slap_op_add( &conn->c_pending_ops, op );
672

673
674
675
	} else {
		connection_op_activate( conn, op );
	}
676

677
678
679
680
#ifdef NO_THREADS
	if ( conn->c_struct_state != SLAP_C_USED ) {
		/* connection must have got closed underneath us */
		return 1;
681
	}
682
683
#endif
	assert( conn->c_struct_state == SLAP_C_USED );
684

685
	return 0;
686
687
688
689
690
691
692
}

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

693
	if( conn->c_conn_state != SLAP_C_ACTIVE ) {
694
695
696
697
698
699
700
701
702
703
		/* 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 );

704
		if ( conn->c_conn_state == SLAP_C_BINDING ) {
705
706
707
708
709
710
711
712
713
714
715
			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
716
717

	if ( conn->c_dn != NULL ) {
718
		tmpdn = ch_strdup( conn->c_dn );
Kurt Zeilenga's avatar
Kurt Zeilenga committed
719
720
721
722
	} else {
		tmpdn = NULL;
	}

723
724
725
726
727
728
729
730
731
732
	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) {
733
		conn->c_conn_state = SLAP_C_BINDING;
734
735
	}

Kurt Zeilenga's avatar
Kurt Zeilenga committed
736
737
738
739
	if ( tmpdn != NULL ) {
		free( tmpdn );
	}

740
741
742
743
	ldap_pvt_thread_mutex_lock( &active_threads_mutex );
	active_threads++;
	ldap_pvt_thread_mutex_unlock( &active_threads_mutex );

744
745
	status = ldap_pvt_thread_create( &arg->co_op->o_tid, 1,
					 connection_operation, (void *) arg );
746

747
	if ( status != 0 ) {
748
749
750
751
		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
752
	}
753
754

	return status;
Kurt Zeilenga's avatar
Kurt Zeilenga committed
755
}
756
757
758
759
760
761
762
763
764
765
766
767
768

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 );
769
		ldap_pvt_thread_mutex_unlock( &connections_mutex );
770
771
772
773
774
775
776
777
778
779
780
781
782
		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;
}