]> git.sur5r.net Git - openldap/blob - servers/slapd/bind.c
Initial revision
[openldap] / servers / slapd / bind.c
1 /* bind.c - decode an ldap bind operation and pass it to a backend db */
2
3 /*
4  * Copyright (c) 1995 Regents of the University of Michigan.
5  * All rights reserved.
6  *
7  * Redistribution and use in source and binary forms are permitted
8  * provided that this notice is preserved and that due credit is given
9  * to the University of Michigan at Ann Arbor. The name of the University
10  * may not be used to endorse or promote products derived from this
11  * software without specific prior written permission. This software
12  * is provided ``as is'' without express or implied warranty.
13  */
14
15 #include <stdio.h>
16 #include <string.h>
17 #include <sys/types.h>
18 #include <sys/socket.h>
19 #include "slap.h"
20
21 extern Backend  *select_backend();
22
23 extern char     *default_referral;
24
25 void
26 do_bind(
27     Connection  *conn,
28     Operation   *op
29 )
30 {
31         BerElement      *ber = op->o_ber;
32         int             version, method, len, rc;
33         char            *dn;
34         struct berval   cred;
35         Backend         *be;
36
37         Debug( LDAP_DEBUG_TRACE, "do_bind\n", 0, 0, 0 );
38
39         /*
40          * Parse the bind request.  It looks like this:
41          *
42          *      BindRequest ::= SEQUENCE {
43          *              version         INTEGER,                 -- version
44          *              name            DistinguishedName,       -- dn
45          *              authentication  CHOICE {
46          *                      simple          [0] OCTET STRING -- passwd
47          *                      krbv42ldap      [1] OCTET STRING
48          *                      krbv42dsa       [1] OCTET STRING
49          *              }
50          *      }
51          */
52
53 #ifdef COMPAT30
54         /*
55          * in version 3.0 there is an extra SEQUENCE tag after the
56          * BindRequest SEQUENCE tag.
57          */
58
59         {
60         BerElement      tber;
61         unsigned long   tlen, ttag;
62
63         tber = *op->o_ber;
64         ttag = ber_skip_tag( &tber, &tlen );
65         if ( ber_peek_tag( &tber, &tlen ) == LBER_SEQUENCE ) {
66                 Debug( LDAP_DEBUG_ANY, "version 3.0 detected\n", 0, 0, 0 );
67                 conn->c_version = 30;
68                 rc = ber_scanf(ber, "{{iato}}", &version, &dn, &method, &cred);
69         } else {
70                 rc = ber_scanf( ber, "{iato}", &version, &dn, &method, &cred );
71         }
72         }
73 #else
74         rc = ber_scanf( ber, "{iato}", &version, &dn, &method, &cred );
75 #endif
76         if ( rc == LBER_ERROR ) {
77                 Debug( LDAP_DEBUG_ANY, "ber_scanf failed\n", 0, 0, 0 );
78                 send_ldap_result( conn, op, LDAP_PROTOCOL_ERROR, NULL,
79                     "decoding error" );
80                 return;
81         }
82 #ifdef COMPAT30
83         if ( conn->c_version == 30 ) {
84                 switch ( method ) {
85                 case LDAP_AUTH_SIMPLE_30:
86                         method = LDAP_AUTH_SIMPLE;
87                         break;
88 #ifdef KERBEROS
89                 case LDAP_AUTH_KRBV41_30:
90                         method = LDAP_AUTH_KRBV41;
91                         break;
92                 case LDAP_AUTH_KRBV42_30:
93                         method = LDAP_AUTH_KRBV42;
94                         break;
95 #endif
96                 }
97         }
98 #endif /* compat30 */
99         dn_normalize( dn );
100
101         Statslog( LDAP_DEBUG_STATS, "conn=%d op=%d BIND dn=\"%s\" method=%d\n",
102             conn->c_connid, op->o_opid, dn, method, 0 );
103
104         if ( version != LDAP_VERSION2 ) {
105                 if ( dn != NULL ) {
106                         free( dn );
107                 }
108                 if ( cred.bv_val != NULL ) {
109                         free( cred.bv_val );
110                 }
111
112                 Debug( LDAP_DEBUG_ANY, "unknown version %d\n", version, 0, 0 );
113                 send_ldap_result( conn, op, LDAP_PROTOCOL_ERROR, NULL,
114                     "version not supported" );
115                 return;
116         }
117
118         Debug( LDAP_DEBUG_TRACE, "do_bind: version %d dn (%s) method %d\n",
119             version, dn, method );
120
121         /* accept null binds */
122         if ( dn == NULL || *dn == '\0' ) {
123                 if ( dn != NULL ) {
124                         free( dn );
125                 }
126                 if ( cred.bv_val != NULL ) {
127                         free( cred.bv_val );
128                 }
129
130                 send_ldap_result( conn, op, LDAP_SUCCESS, NULL, NULL );
131                 return;
132         }
133
134         /*
135          * We could be serving multiple database backends.  Select the
136          * appropriate one, or send a referral to our "referral server"
137          * if we don't hold it.
138          */
139
140         if ( (be = select_backend( dn )) == NULL ) {
141                 free( dn );
142                 if ( cred.bv_val != NULL ) {
143                         free( cred.bv_val );
144                 }
145                 if ( cred.bv_len == 0 ) {
146                         send_ldap_result( conn, op, LDAP_SUCCESS, NULL, NULL );
147                 } else {
148                         send_ldap_result( conn, op, LDAP_PARTIAL_RESULTS, NULL,
149                             default_referral );
150                 }
151                 return;
152         }
153
154         if ( be->be_bind != NULL ) {
155                 if ( (*be->be_bind)( be, conn, op, dn, method, &cred ) == 0 ) {
156                         pthread_mutex_lock( &conn->c_dnmutex );
157                         if ( conn->c_dn != NULL ) {
158                                 free( conn->c_dn );
159                         }
160                         conn->c_dn = strdup( dn );
161                         pthread_mutex_unlock( &conn->c_dnmutex );
162
163                         /* send this here to avoid a race condition */
164                         send_ldap_result( conn, op, LDAP_SUCCESS, NULL, NULL );
165                 }
166         } else {
167                 send_ldap_result( conn, op, LDAP_UNWILLING_TO_PERFORM, NULL,
168                     "Function not implemented" );
169         }
170
171         free( dn );
172         if ( cred.bv_val != NULL ) {
173                 free( cred.bv_val );
174         }
175 }