bc42355a69f7e9927d06ab3468bb13fb03fb7614
[obnox/wireshark/wip.git] / epan / dissectors / packet-ldap.c
1 /* Do not modify this file.                                                   */
2 /* It is created automatically by the ASN.1 to Wireshark dissector compiler   */
3 /* packet-ldap.c                                                              */
4 /* ../../tools/asn2wrs.py -b -p ldap -c ./ldap.cnf -s ./packet-ldap-template -D . Lightweight-Directory-Access-Protocol-V3.asn */
5
6 /* Input file: packet-ldap-template.c */
7
8 #line 1 "../../asn1/ldap/packet-ldap-template.c"
9 /* packet-ldap.c
10  * Routines for ldap packet dissection
11  *
12  * See RFC 1777 (LDAP v2), RFC 2251 (LDAP v3), and RFC 2222 (SASL).
13  *
14  * $Id$
15  *
16  * Wireshark - Network traffic analyzer
17  * By Gerald Combs <gerald@wireshark.org>
18  * Copyright 1998 Gerald Combs
19  *
20  * This program is free software; you can redistribute it and/or
21  * modify it under the terms of the GNU General Public License
22  * as published by the Free Software Foundation; either version 2
23  * of the License, or (at your option) any later version.
24  *
25  * This program is distributed in the hope that it will be useful,
26  * but WITHOUT ANY WARRANTY; without even the implied warranty of
27  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
28  * GNU General Public License for more details.
29  *
30  * You should have received a copy of the GNU General Public License
31  * along with this program; if not, write to the Free Software
32  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
33  */
34
35 /*
36  * This is not a complete implementation. It doesn't handle the full version 3, more specifically,
37  * it handles only the commands of version 2, but any additional characteristics of the ver3 command are supported.
38  * It's also missing extensible search filters.
39  *
40  * There should probably be alot more error checking, I simply assume that if we have a full packet, it will be a complete
41  * and correct packet.
42  *
43  * AFAIK, it will handle all messages used by the OpenLDAP 1.2.9 server and libraries which was my goal. I do plan to add
44  * the remaining commands as time permits but this is not a priority to me. Send me an email if you need it and I'll see what
45  * I can do.
46  *
47  * Doug Nazar
48  * nazard@dragoninc.on.ca
49  */
50
51 /*
52  * 11/11/2002 - Fixed problem when decoding LDAP with desegmentation enabled and the
53  *              ASN.1 BER Universal Class Tag: "Sequence Of" header is encapsulated across 2
54  *              TCP segments.
55  *
56  * Ronald W. Henderson
57  * ronald.henderson@cognicaseusa.com
58  */
59
60 /*
61  * 20-JAN-2004 - added decoding of MS-CLDAP netlogon RPC
62  *               using information from the SNIA 2003 conference paper :
63  *               Active Directory Domain Controller Location Service
64  *                    by Anthony Liguori
65  * ronnie sahlberg
66  */
67
68 /*
69  * 17-DEC-2004 - added basic decoding for LDAP Controls
70  * 20-DEC-2004 - added handling for GSS-API encrypted blobs
71  *
72  * Stefan Metzmacher <metze@samba.org>
73  *
74  * 15-NOV-2005 - Changed to use the asn2wrs compiler
75  * Anders Broman <anders.broman@ericsson.com>
76  */
77
78 /*
79  * 3-AUG-2008 - Extended the cldap support to include all netlogon data types.
80  *                              Updated cldap_netlogon_flags to include Windows 2008 flags
81  *                              Expanded the ntver ldap option with bit field
82  *
83  * Gary Reynolds <gazzadownunder@yahoo.co.uk>
84  */
85
86 /*
87  * 09-DEC-2009 - Added support for RFC4533
88  *               Content Synchronization Operation (aka syncrepl)
89  * 11-DEC-2009 - Added support for IntermediateResponse (LDAP v3 from RFC 4511)
90  * Mathieu Parent <math.parent@gmail.com>
91  */
92
93 #ifdef HAVE_CONFIG_H
94 # include "config.h"
95 #endif
96
97 #include <string.h>
98 #include <ctype.h>
99
100 #include <glib.h>
101
102 #include <epan/packet.h>
103 #include <epan/conversation.h>
104 #include <epan/prefs.h>
105 #include <epan/tap.h>
106 #include <epan/emem.h>
107 #include <epan/oids.h>
108 #include <epan/strutil.h>
109 #include <epan/dissectors/packet-frame.h>
110 #include <epan/dissectors/packet-tcp.h>
111 #include <epan/dissectors/packet-windows-common.h>
112 #include <epan/dissectors/packet-dcerpc.h>
113 #include <epan/asn1.h>
114 #include <epan/expert.h>
115
116 #include "packet-ldap.h"
117 #include "packet-ntlmssp.h"
118 #include "packet-ssl.h"
119 #include "packet-smb-common.h"
120
121 #include "packet-ber.h"
122 #include "packet-per.h"
123 #include "packet-dns.h"
124
125 #define PNAME  "Lightweight Directory Access Protocol"
126 #define PSNAME "LDAP"
127 #define PFNAME "ldap"
128
129 /* Initialize the protocol and registered fields */
130 static int ldap_tap = -1;
131 static int proto_ldap = -1;
132 static int proto_cldap = -1;
133
134 static int hf_ldap_sasl_buffer_length = -1;
135 static int hf_ldap_response_in = -1;
136 static int hf_ldap_response_to = -1;
137 static int hf_ldap_time = -1;
138 static int hf_ldap_guid = -1;
139
140 static int hf_mscldap_ntver_flags = -1;
141 static int hf_mscldap_ntver_flags_v1 = -1;
142 static int hf_mscldap_ntver_flags_v5 = -1;
143 static int hf_mscldap_ntver_flags_v5ex = -1;
144 static int hf_mscldap_ntver_flags_v5ep = -1;
145 static int hf_mscldap_ntver_flags_vcs = -1;
146 static int hf_mscldap_ntver_flags_vnt4 = -1;
147 static int hf_mscldap_ntver_flags_vpdc = -1;
148 static int hf_mscldap_ntver_flags_vip = -1;
149 static int hf_mscldap_ntver_flags_vl = -1;
150 static int hf_mscldap_ntver_flags_vgc = -1;
151
152 static int hf_mscldap_netlogon_ipaddress_family = -1;
153 static int hf_mscldap_netlogon_ipaddress_port = -1;
154 static int hf_mscldap_netlogon_ipaddress = -1;
155 static int hf_mscldap_netlogon_ipaddress_ipv4 = -1;
156 static int hf_mscldap_netlogon_opcode = -1;
157 static int hf_mscldap_netlogon_flags = -1;
158 static int hf_mscldap_netlogon_flags_pdc = -1;
159 static int hf_mscldap_netlogon_flags_gc = -1;
160 static int hf_mscldap_netlogon_flags_ldap = -1;
161 static int hf_mscldap_netlogon_flags_ds = -1;
162 static int hf_mscldap_netlogon_flags_kdc = -1;
163 static int hf_mscldap_netlogon_flags_timeserv = -1;
164 static int hf_mscldap_netlogon_flags_closest = -1;
165 static int hf_mscldap_netlogon_flags_writable = -1;
166 static int hf_mscldap_netlogon_flags_good_timeserv = -1;
167 static int hf_mscldap_netlogon_flags_ndnc = -1;
168 static int hf_mscldap_netlogon_flags_fnc = -1;
169 static int hf_mscldap_netlogon_flags_dnc = -1;
170 static int hf_mscldap_netlogon_flags_dns = -1;
171 static int hf_mscldap_netlogon_flags_wdc = -1;
172 static int hf_mscldap_netlogon_flags_rodc = -1;
173 static int hf_mscldap_domain_guid = -1;
174 static int hf_mscldap_forest = -1;
175 static int hf_mscldap_domain = -1;
176 static int hf_mscldap_hostname = -1;
177 static int hf_mscldap_nb_domain = -1;
178 static int hf_mscldap_nb_hostname = -1;
179 static int hf_mscldap_username = -1;
180 static int hf_mscldap_sitename = -1;
181 static int hf_mscldap_clientsitename = -1;
182 static int hf_mscldap_netlogon_lm_token = -1;
183 static int hf_mscldap_netlogon_nt_token = -1;
184 static int hf_ldap_sid = -1;
185 static int hf_ldap_AccessMask_ADS_CREATE_CHILD = -1;
186 static int hf_ldap_AccessMask_ADS_DELETE_CHILD = -1;
187 static int hf_ldap_AccessMask_ADS_LIST = -1;
188 static int hf_ldap_AccessMask_ADS_SELF_WRITE = -1;
189 static int hf_ldap_AccessMask_ADS_READ_PROP = -1;
190 static int hf_ldap_AccessMask_ADS_WRITE_PROP = -1;
191 static int hf_ldap_AccessMask_ADS_DELETE_TREE = -1;
192 static int hf_ldap_AccessMask_ADS_LIST_OBJECT = -1;
193 static int hf_ldap_AccessMask_ADS_CONTROL_ACCESS = -1;
194
195
196 /*--- Included file: packet-ldap-hf.c ---*/
197 #line 1 "../../asn1/ldap/packet-ldap-hf.c"
198 static int hf_ldap_LDAPMessage_PDU = -1;          /* LDAPMessage */
199 static int hf_ldap_SearchControlValue_PDU = -1;   /* SearchControlValue */
200 static int hf_ldap_SortKeyList_PDU = -1;          /* SortKeyList */
201 static int hf_ldap_SortResult_PDU = -1;           /* SortResult */
202 static int hf_ldap_DirSyncControlValue_PDU = -1;  /* DirSyncControlValue */
203 static int hf_ldap_PasswdModifyRequestValue_PDU = -1;  /* PasswdModifyRequestValue */
204 static int hf_ldap_CancelRequestValue_PDU = -1;   /* CancelRequestValue */
205 static int hf_ldap_SyncRequestValue_PDU = -1;     /* SyncRequestValue */
206 static int hf_ldap_SyncStateValue_PDU = -1;       /* SyncStateValue */
207 static int hf_ldap_SyncDoneValue_PDU = -1;        /* SyncDoneValue */
208 static int hf_ldap_SyncInfoValue_PDU = -1;        /* SyncInfoValue */
209 static int hf_ldap_PasswordPolicyResponseValue_PDU = -1;  /* PasswordPolicyResponseValue */
210 static int hf_ldap_messageID = -1;                /* MessageID */
211 static int hf_ldap_protocolOp = -1;               /* ProtocolOp */
212 static int hf_ldap_controls = -1;                 /* Controls */
213 static int hf_ldap_bindRequest = -1;              /* BindRequest */
214 static int hf_ldap_bindResponse = -1;             /* BindResponse */
215 static int hf_ldap_unbindRequest = -1;            /* UnbindRequest */
216 static int hf_ldap_searchRequest = -1;            /* SearchRequest */
217 static int hf_ldap_searchResEntry = -1;           /* SearchResultEntry */
218 static int hf_ldap_searchResDone = -1;            /* SearchResultDone */
219 static int hf_ldap_searchResRef = -1;             /* SearchResultReference */
220 static int hf_ldap_modifyRequest = -1;            /* ModifyRequest */
221 static int hf_ldap_modifyResponse = -1;           /* ModifyResponse */
222 static int hf_ldap_addRequest = -1;               /* AddRequest */
223 static int hf_ldap_addResponse = -1;              /* AddResponse */
224 static int hf_ldap_delRequest = -1;               /* DelRequest */
225 static int hf_ldap_delResponse = -1;              /* DelResponse */
226 static int hf_ldap_modDNRequest = -1;             /* ModifyDNRequest */
227 static int hf_ldap_modDNResponse = -1;            /* ModifyDNResponse */
228 static int hf_ldap_compareRequest = -1;           /* CompareRequest */
229 static int hf_ldap_compareResponse = -1;          /* CompareResponse */
230 static int hf_ldap_abandonRequest = -1;           /* AbandonRequest */
231 static int hf_ldap_extendedReq = -1;              /* ExtendedRequest */
232 static int hf_ldap_extendedResp = -1;             /* ExtendedResponse */
233 static int hf_ldap_intermediateResponse = -1;     /* IntermediateResponse */
234 static int hf_ldap_AttributeDescriptionList_item = -1;  /* AttributeDescription */
235 static int hf_ldap_attributeDesc = -1;            /* AttributeDescription */
236 static int hf_ldap_assertionValue = -1;           /* AssertionValue */
237 static int hf_ldap_type = -1;                     /* AttributeDescription */
238 static int hf_ldap_vals = -1;                     /* SET_OF_AttributeValue */
239 static int hf_ldap_vals_item = -1;                /* AttributeValue */
240 static int hf_ldap_resultCode = -1;               /* T_resultCode */
241 static int hf_ldap_matchedDN = -1;                /* LDAPDN */
242 static int hf_ldap_errorMessage = -1;             /* ErrorMessage */
243 static int hf_ldap_referral = -1;                 /* Referral */
244 static int hf_ldap_Referral_item = -1;            /* LDAPURL */
245 static int hf_ldap_Controls_item = -1;            /* Control */
246 static int hf_ldap_controlType = -1;              /* ControlType */
247 static int hf_ldap_criticality = -1;              /* BOOLEAN */
248 static int hf_ldap_controlValue = -1;             /* T_controlValue */
249 static int hf_ldap_version = -1;                  /* INTEGER_1_127 */
250 static int hf_ldap_name = -1;                     /* LDAPDN */
251 static int hf_ldap_authentication = -1;           /* AuthenticationChoice */
252 static int hf_ldap_simple = -1;                   /* Simple */
253 static int hf_ldap_sasl = -1;                     /* SaslCredentials */
254 static int hf_ldap_ntlmsspNegotiate = -1;         /* T_ntlmsspNegotiate */
255 static int hf_ldap_ntlmsspAuth = -1;              /* T_ntlmsspAuth */
256 static int hf_ldap_mechanism = -1;                /* Mechanism */
257 static int hf_ldap_credentials = -1;              /* Credentials */
258 static int hf_ldap_bindResponse_resultCode = -1;  /* BindResponse_resultCode */
259 static int hf_ldap_bindResponse_matchedDN = -1;   /* T_bindResponse_matchedDN */
260 static int hf_ldap_serverSaslCreds = -1;          /* ServerSaslCreds */
261 static int hf_ldap_baseObject = -1;               /* LDAPDN */
262 static int hf_ldap_scope = -1;                    /* T_scope */
263 static int hf_ldap_derefAliases = -1;             /* T_derefAliases */
264 static int hf_ldap_sizeLimit = -1;                /* INTEGER_0_maxInt */
265 static int hf_ldap_timeLimit = -1;                /* INTEGER_0_maxInt */
266 static int hf_ldap_typesOnly = -1;                /* BOOLEAN */
267 static int hf_ldap_filter = -1;                   /* T_filter */
268 static int hf_ldap_searchRequest_attributes = -1;  /* AttributeDescriptionList */
269 static int hf_ldap_and = -1;                      /* T_and */
270 static int hf_ldap_and_item = -1;                 /* T_and_item */
271 static int hf_ldap_or = -1;                       /* T_or */
272 static int hf_ldap_or_item = -1;                  /* T_or_item */
273 static int hf_ldap_not = -1;                      /* T_not */
274 static int hf_ldap_equalityMatch = -1;            /* T_equalityMatch */
275 static int hf_ldap_substrings = -1;               /* SubstringFilter */
276 static int hf_ldap_greaterOrEqual = -1;           /* T_greaterOrEqual */
277 static int hf_ldap_lessOrEqual = -1;              /* T_lessOrEqual */
278 static int hf_ldap_present = -1;                  /* T_present */
279 static int hf_ldap_approxMatch = -1;              /* T_approxMatch */
280 static int hf_ldap_extensibleMatch = -1;          /* T_extensibleMatch */
281 static int hf_ldap_substringFilter_substrings = -1;  /* T_substringFilter_substrings */
282 static int hf_ldap_substringFilter_substrings_item = -1;  /* T_substringFilter_substrings_item */
283 static int hf_ldap_initial = -1;                  /* LDAPString */
284 static int hf_ldap_any = -1;                      /* LDAPString */
285 static int hf_ldap_final = -1;                    /* LDAPString */
286 static int hf_ldap_matchingRule = -1;             /* MatchingRuleId */
287 static int hf_ldap_matchValue = -1;               /* AssertionValue */
288 static int hf_ldap_dnAttributes = -1;             /* T_dnAttributes */
289 static int hf_ldap_objectName = -1;               /* LDAPDN */
290 static int hf_ldap_searchResultEntry_attributes = -1;  /* PartialAttributeList */
291 static int hf_ldap_PartialAttributeList_item = -1;  /* PartialAttributeList_item */
292 static int hf_ldap__untag_item = -1;              /* LDAPURL */
293 static int hf_ldap_object = -1;                   /* LDAPDN */
294 static int hf_ldap_modifyRequest_modification = -1;  /* ModifyRequest_modification */
295 static int hf_ldap_modifyRequest_modification_item = -1;  /* T_modifyRequest_modification_item */
296 static int hf_ldap_operation = -1;                /* T_operation */
297 static int hf_ldap_modification = -1;             /* AttributeTypeAndValues */
298 static int hf_ldap_entry = -1;                    /* LDAPDN */
299 static int hf_ldap_attributes = -1;               /* AttributeList */
300 static int hf_ldap_AttributeList_item = -1;       /* AttributeList_item */
301 static int hf_ldap_newrdn = -1;                   /* RelativeLDAPDN */
302 static int hf_ldap_deleteoldrdn = -1;             /* BOOLEAN */
303 static int hf_ldap_newSuperior = -1;              /* LDAPDN */
304 static int hf_ldap_ava = -1;                      /* AttributeValueAssertion */
305 static int hf_ldap_requestName = -1;              /* LDAPOID */
306 static int hf_ldap_requestValue = -1;             /* T_requestValue */
307 static int hf_ldap_extendedResponse_resultCode = -1;  /* ExtendedResponse_resultCode */
308 static int hf_ldap_responseName = -1;             /* ResponseName */
309 static int hf_ldap_response = -1;                 /* OCTET_STRING */
310 static int hf_ldap_intermediateResponse_responseValue = -1;  /* T_intermediateResponse_responseValue */
311 static int hf_ldap_size = -1;                     /* INTEGER */
312 static int hf_ldap_cookie = -1;                   /* OCTET_STRING */
313 static int hf_ldap_SortKeyList_item = -1;         /* SortKeyList_item */
314 static int hf_ldap_attributeType = -1;            /* AttributeDescription */
315 static int hf_ldap_orderingRule = -1;             /* MatchingRuleId */
316 static int hf_ldap_reverseOrder = -1;             /* BOOLEAN */
317 static int hf_ldap_sortResult = -1;               /* T_sortResult */
318 static int hf_ldap_value = -1;                    /* INTEGER */
319 static int hf_ldap_flags = -1;                    /* DirSyncFlags */
320 static int hf_ldap_maxBytes = -1;                 /* INTEGER */
321 static int hf_ldap_userIdentity = -1;             /* OCTET_STRING */
322 static int hf_ldap_oldPasswd = -1;                /* OCTET_STRING */
323 static int hf_ldap_newPasswd = -1;                /* OCTET_STRING */
324 static int hf_ldap_genPasswd = -1;                /* OCTET_STRING */
325 static int hf_ldap_cancelID = -1;                 /* MessageID */
326 static int hf_ldap_mode = -1;                     /* T_mode */
327 static int hf_ldap_reloadHint = -1;               /* BOOLEAN */
328 static int hf_ldap_state = -1;                    /* T_state */
329 static int hf_ldap_entryUUID = -1;                /* SyncUUID */
330 static int hf_ldap_refreshDeletes = -1;           /* BOOLEAN */
331 static int hf_ldap_newcookie = -1;                /* OCTET_STRING */
332 static int hf_ldap_refreshDelete = -1;            /* T_refreshDelete */
333 static int hf_ldap_refreshDone = -1;              /* BOOLEAN */
334 static int hf_ldap_refreshPresent = -1;           /* T_refreshPresent */
335 static int hf_ldap_syncIdSet = -1;                /* T_syncIdSet */
336 static int hf_ldap_syncUUIDs = -1;                /* SET_OF_SyncUUID */
337 static int hf_ldap_syncUUIDs_item = -1;           /* SyncUUID */
338 static int hf_ldap_warning = -1;                  /* T_warning */
339 static int hf_ldap_timeBeforeExpiration = -1;     /* INTEGER_0_maxInt */
340 static int hf_ldap_graceAuthNsRemaining = -1;     /* INTEGER_0_maxInt */
341 static int hf_ldap_error = -1;                    /* T_error */
342
343 /*--- End of included file: packet-ldap-hf.c ---*/
344 #line 188 "../../asn1/ldap/packet-ldap-template.c"
345
346 /* Initialize the subtree pointers */
347 static gint ett_ldap = -1;
348 static gint ett_ldap_msg = -1;
349 static gint ett_ldap_sasl_blob = -1;
350 static gint ett_ldap_payload = -1;
351 static gint ett_mscldap_netlogon_flags = -1;
352 static gint ett_mscldap_ntver_flags = -1;
353 static gint ett_mscldap_ipdetails = -1;
354
355
356 /*--- Included file: packet-ldap-ett.c ---*/
357 #line 1 "../../asn1/ldap/packet-ldap-ett.c"
358 static gint ett_ldap_LDAPMessage = -1;
359 static gint ett_ldap_ProtocolOp = -1;
360 static gint ett_ldap_AttributeDescriptionList = -1;
361 static gint ett_ldap_AttributeValueAssertion = -1;
362 static gint ett_ldap_Attribute = -1;
363 static gint ett_ldap_SET_OF_AttributeValue = -1;
364 static gint ett_ldap_LDAPResult = -1;
365 static gint ett_ldap_Referral = -1;
366 static gint ett_ldap_Controls = -1;
367 static gint ett_ldap_Control = -1;
368 static gint ett_ldap_BindRequest_U = -1;
369 static gint ett_ldap_AuthenticationChoice = -1;
370 static gint ett_ldap_SaslCredentials = -1;
371 static gint ett_ldap_BindResponse_U = -1;
372 static gint ett_ldap_SearchRequest_U = -1;
373 static gint ett_ldap_Filter = -1;
374 static gint ett_ldap_T_and = -1;
375 static gint ett_ldap_T_or = -1;
376 static gint ett_ldap_SubstringFilter = -1;
377 static gint ett_ldap_T_substringFilter_substrings = -1;
378 static gint ett_ldap_T_substringFilter_substrings_item = -1;
379 static gint ett_ldap_MatchingRuleAssertion = -1;
380 static gint ett_ldap_SearchResultEntry_U = -1;
381 static gint ett_ldap_PartialAttributeList = -1;
382 static gint ett_ldap_PartialAttributeList_item = -1;
383 static gint ett_ldap_SEQUENCE_OF_LDAPURL = -1;
384 static gint ett_ldap_ModifyRequest_U = -1;
385 static gint ett_ldap_ModifyRequest_modification = -1;
386 static gint ett_ldap_T_modifyRequest_modification_item = -1;
387 static gint ett_ldap_AttributeTypeAndValues = -1;
388 static gint ett_ldap_AddRequest_U = -1;
389 static gint ett_ldap_AttributeList = -1;
390 static gint ett_ldap_AttributeList_item = -1;
391 static gint ett_ldap_ModifyDNRequest_U = -1;
392 static gint ett_ldap_CompareRequest_U = -1;
393 static gint ett_ldap_ExtendedRequest_U = -1;
394 static gint ett_ldap_ExtendedResponse_U = -1;
395 static gint ett_ldap_IntermediateResponse_U = -1;
396 static gint ett_ldap_SearchControlValue = -1;
397 static gint ett_ldap_SortKeyList = -1;
398 static gint ett_ldap_SortKeyList_item = -1;
399 static gint ett_ldap_SortResult = -1;
400 static gint ett_ldap_DirSyncFlagsSubEntry = -1;
401 static gint ett_ldap_DirSyncControlValue = -1;
402 static gint ett_ldap_PasswdModifyRequestValue = -1;
403 static gint ett_ldap_PasswdModifyResponseValue = -1;
404 static gint ett_ldap_CancelRequestValue = -1;
405 static gint ett_ldap_SyncRequestValue = -1;
406 static gint ett_ldap_SyncStateValue = -1;
407 static gint ett_ldap_SyncDoneValue = -1;
408 static gint ett_ldap_SyncInfoValue = -1;
409 static gint ett_ldap_T_refreshDelete = -1;
410 static gint ett_ldap_T_refreshPresent = -1;
411 static gint ett_ldap_T_syncIdSet = -1;
412 static gint ett_ldap_SET_OF_SyncUUID = -1;
413 static gint ett_ldap_PasswordPolicyResponseValue = -1;
414 static gint ett_ldap_T_warning = -1;
415
416 /*--- End of included file: packet-ldap-ett.c ---*/
417 #line 199 "../../asn1/ldap/packet-ldap-template.c"
418
419 static dissector_table_t ldap_name_dissector_table=NULL;
420 static const char *object_identifier_id = NULL; /* LDAP OID */
421
422 static gboolean do_protocolop = FALSE;
423 static gchar    *attr_type = NULL;
424 static gboolean is_binary_attr_type = FALSE;
425 static gboolean ldap_found_in_frame = FALSE;
426
427 #define TCP_PORT_LDAP                   389
428 #define TCP_PORT_LDAPS                  636
429 #define UDP_PORT_CLDAP                  389
430 #define TCP_PORT_GLOBALCAT_LDAP         3268 /* Windows 2000 Global Catalog */
431
432 /* desegmentation of LDAP */
433 static gboolean ldap_desegment = TRUE;
434 static guint global_ldap_tcp_port = TCP_PORT_LDAP;
435 static guint global_ldaps_tcp_port = TCP_PORT_LDAPS;
436 static guint tcp_port = 0;
437 static guint ssl_port = 0;
438
439 static dissector_handle_t gssapi_handle;
440 static dissector_handle_t gssapi_wrap_handle;
441 static dissector_handle_t ntlmssp_handle;
442 static dissector_handle_t spnego_handle;
443 static dissector_handle_t ssl_handle;
444 static dissector_handle_t ldap_handle ;
445
446 static void prefs_register_ldap(void); /* forward declaration for use in preferences registration */
447
448
449 /* different types of rpc calls ontop of ms cldap */
450 #define MSCLDAP_RPC_NETLOGON    1
451
452 /* Message type Choice values */
453 static const value_string ldap_ProtocolOp_choice_vals[] = {
454   {   0, "bindRequest" },
455   {   1, "bindResponse" },
456   {   2, "unbindRequest" },
457   {   3, "searchRequest" },
458   {   4, "searchResEntry" },
459   {   5, "searchResDone" },
460   {       6, "searchResRef" },
461   {   7, "modifyRequest" },
462   {   8, "modifyResponse" },
463   {   9, "addRequest" },
464   {  10, "addResponse" },
465   {  11, "delRequest" },
466   {  12, "delResponse" },
467   {  13, "modDNRequest" },
468   {  14, "modDNResponse" },
469   {  15, "compareRequest" },
470   {  16, "compareResponse" },
471   {  17, "abandonRequest" },
472   {  18, "extendedReq" },
473   {  19, "extendedResp" },
474   {  20, "intermediateResponse" },
475   { 0, NULL }
476 };
477
478 #define LOGON_PRIMARY_QUERY             7
479 #define LOGON_PRIMARY_RESPONSE         12
480 #define LOGON_SAM_LOGON_REQUEST        18
481 #define LOGON_SAM_LOGON_RESPONSE       19
482 #define LOGON_SAM_PAUSE_RESPONSE       20
483 #define LOGON_SAM_USER_UNKNOWN         21
484 #define LOGON_SAM_LOGON_RESPONSE_EX    23
485 #define LOGON_SAM_PAUSE_RESPONSE_EX    24
486 #define LOGON_SAM_USER_UNKNOWN_EX      25
487
488 static const value_string netlogon_opcode_vals[] = {
489         { LOGON_PRIMARY_QUERY,         "LOGON_PRIMARY_QUERY" },
490         { LOGON_PRIMARY_RESPONSE,      "LOGON_PRIMARY_RESPONSE" },
491         { LOGON_SAM_LOGON_REQUEST,     "LOGON_SAM_LOGON_REQUEST" },
492         { LOGON_SAM_LOGON_RESPONSE,    "LOGON_SAM_LOGON_RESPONSE" },
493         { LOGON_SAM_PAUSE_RESPONSE,    "LOGON_SAM_PAUSE_RESPONSE" },
494         { LOGON_SAM_LOGON_RESPONSE_EX, "LOGON_SAM_LOGON_RESPONSE_EX" },
495         { LOGON_SAM_PAUSE_RESPONSE_EX, "LOGON_SAM_PAUSE_RESPONSE_EX" },
496         { LOGON_SAM_USER_UNKNOWN_EX,   "LOGON_SAM_USER_UNKNOWN_EX" },
497         { 0, NULL }
498 };
499
500 /*
501  * Data structure attached to a conversation, giving authentication
502  * information from a bind request.
503  * We keep a linked list of them, so that we can free up all the
504  * authentication mechanism strings.
505  */
506 typedef struct ldap_conv_info_t {
507   struct ldap_conv_info_t *next;
508   guint auth_type;              /* authentication type */
509   char *auth_mech;              /* authentication mechanism */
510   guint32 first_auth_frame;     /* first frame that would use a security layer */
511   GHashTable *unmatched;
512   GHashTable *matched;
513   gboolean is_mscldap;
514   guint32  num_results;
515   gboolean start_tls_pending;
516   guint32  start_tls_frame;
517 } ldap_conv_info_t;
518 static ldap_conv_info_t *ldap_info_items;
519
520 static guint
521 ldap_info_hash_matched(gconstpointer k)
522 {
523   const ldap_call_response_t *key = k;
524
525   return key->messageId;
526 }
527
528 static gint
529 ldap_info_equal_matched(gconstpointer k1, gconstpointer k2)
530 {
531   const ldap_call_response_t *key1 = k1;
532   const ldap_call_response_t *key2 = k2;
533
534   if( key1->req_frame && key2->req_frame && (key1->req_frame!=key2->req_frame) ){
535     return 0;
536   }
537   /* a response may span multiple frames
538   if( key1->rep_frame && key2->rep_frame && (key1->rep_frame!=key2->rep_frame) ){
539     return 0;
540   }
541   */
542
543   return key1->messageId==key2->messageId;
544 }
545
546 static guint
547 ldap_info_hash_unmatched(gconstpointer k)
548 {
549   const ldap_call_response_t *key = k;
550
551   return key->messageId;
552 }
553
554 static gint
555 ldap_info_equal_unmatched(gconstpointer k1, gconstpointer k2)
556 {
557   const ldap_call_response_t *key1 = k1;
558   const ldap_call_response_t *key2 = k2;
559
560   return key1->messageId==key2->messageId;
561 }
562
563
564  /* These are the NtVer flags
565         http://msdn.microsoft.com/en-us/library/cc201035.aspx
566  */
567
568 static const true_false_string tfs_ntver_v1 = {
569         "Client requested version 1 netlogon response",
570         "Version 1 netlogon response not requested"
571 };
572
573 static const true_false_string tfs_ntver_v5 = {
574         "Client requested version 5 netlogon response",
575         "Version 5 netlogon response not requested"
576 };
577 static const true_false_string tfs_ntver_v5ex = {
578         "Client requested version 5 extended netlogon response",
579         "Version 5 extended response not requested"
580 };
581 static const true_false_string tfs_ntver_v5ep = {
582         "Client has requested IP address of the server",
583         "IP address of server not requested"
584 };
585 static const true_false_string tfs_ntver_vcs = {
586         "Client has asked for the closest site information",
587         "Closest site information not requested"
588 };
589 static const true_false_string tfs_ntver_vnt4 = {
590         "Client is requesting server to avoid NT4 emulation",
591         "Only full AD DS requested"
592 };
593 static const true_false_string tfs_ntver_vpdc = {
594         "Client has requested the Primary Domain Controller",
595         "Primary Domain Controller not requested"
596 };
597 static const true_false_string tfs_ntver_vip = {
598         "Client has requested IP details (obsolete)",
599         "IP details not requested (obsolete)"
600 };
601 static const true_false_string tfs_ntver_vl = {
602         "Client indicated that it is the local machine",
603         "Client is not the local machine"
604 };static const true_false_string tfs_ntver_vgc = {
605         "Client has requested a Global Catalog server",
606         "Global Catalog not requested"
607 };
608
609
610 /* MS-ADTS specification, section 7.3.1.1, NETLOGON_NT_VERSION Options Bits */
611 static int dissect_mscldap_ntver_flags(proto_tree *parent_tree, tvbuff_t *tvb, int offset)
612 {
613   guint32 flags;
614   proto_item *item;
615   proto_tree *tree=NULL;
616   guint fields[] = {
617                      hf_mscldap_ntver_flags_v1,
618                      hf_mscldap_ntver_flags_v5,
619                      hf_mscldap_ntver_flags_v5ex,
620                      hf_mscldap_ntver_flags_v5ep,
621                      hf_mscldap_ntver_flags_vcs,
622                      hf_mscldap_ntver_flags_vnt4,
623                      hf_mscldap_ntver_flags_vpdc,
624                      hf_mscldap_ntver_flags_vip,
625                      hf_mscldap_ntver_flags_vl,
626                      hf_mscldap_ntver_flags_vgc,
627                      0 };
628
629   guint  *field;
630   header_field_info *hfi;
631   gboolean one_bit_set = FALSE;
632
633   flags=tvb_get_letohl(tvb, offset);
634   item=proto_tree_add_item(parent_tree, hf_mscldap_ntver_flags, tvb, offset, 4, TRUE);
635   if(parent_tree){
636     tree = proto_item_add_subtree(item, ett_mscldap_ntver_flags);
637   }
638
639   proto_item_append_text(item, " (");
640
641   for(field = fields; *field; field++) {
642     proto_tree_add_boolean(tree, *field, tvb, offset, 4, flags);
643     hfi = proto_registrar_get_nth(*field);
644
645     if(flags & hfi->bitmask) {
646
647       if(one_bit_set)
648         proto_item_append_text(item, ", ");
649       else
650         one_bit_set = TRUE;
651
652       proto_item_append_text(item, "%s", hfi->name);
653
654     }
655   }
656
657   proto_item_append_text(item, ")");
658
659   offset += 4;
660
661   return offset;
662 }
663
664 /* This string contains the last LDAPString that was decoded */
665 static const char *attributedesc_string=NULL;
666
667 /* This string contains the last AssertionValue that was decoded */
668 static char *ldapvalue_string=NULL;
669
670 /* if the octet string contain all printable ASCII characters, then
671  * display it as a string, othervise just display it in hex.
672  */
673 static int
674 dissect_ldap_AssertionValue(gboolean implicit_tag, tvbuff_t *tvb, int offset, asn1_ctx_t *actx _U_, proto_tree *tree, int hf_index)
675 {
676         gint8 class;
677         gboolean pc, ind, is_ascii;
678         gint32 tag;
679         guint32 len, i;
680         const guchar *str;
681
682         if(!implicit_tag){
683                 offset=get_ber_identifier(tvb, offset, &class, &pc, &tag);
684                 offset=get_ber_length(tvb, offset, &len, &ind);
685         } else {
686                 len=tvb_length_remaining(tvb,offset);
687         }
688
689         if(len==0){
690                 return offset;
691         }
692
693
694         /*
695          * Some special/wellknown attributes in common LDAP (read AD)
696          * are neither ascii strings nor blobs of hex data.
697          * Special case these attributes and decode them more nicely.
698          *
699          * Add more special cases as required to prettify further
700          * (there cant be that many ones that are truly interesting)
701          */
702         if(attributedesc_string && !strncmp("DomainSid", attributedesc_string, 9)){
703                 tvbuff_t *sid_tvb;
704                 char *tmpstr;
705
706                 /* this octet string contains an NT SID */
707                 sid_tvb=tvb_new_subset(tvb, offset, len, len);
708                 dissect_nt_sid(sid_tvb, 0, tree, "SID", &tmpstr, hf_index);
709                 ldapvalue_string=tmpstr;
710
711                 goto finished;
712         } else if ( (len==16) /* GUIDs are always 16 bytes */
713         && (attributedesc_string && !strncmp("DomainGuid", attributedesc_string, 10))) {
714                 guint8 drep[4] = { 0x10, 0x00, 0x00, 0x00}; /* fake DREP struct */
715                 e_uuid_t uuid;
716
717                 /* This octet string contained a GUID */
718                 dissect_dcerpc_uuid_t(tvb, offset, actx->pinfo, tree, drep, hf_ldap_guid, &uuid);
719
720                 ldapvalue_string=ep_alloc(1024);
721                 g_snprintf(ldapvalue_string, 1023, "%08x-%04x-%04x-%02x%02x-%02x%02x%02x%02x%02x%02x",
722                           uuid.Data1, uuid.Data2, uuid.Data3,
723                           uuid.Data4[0], uuid.Data4[1],
724                           uuid.Data4[2], uuid.Data4[3],
725                           uuid.Data4[4], uuid.Data4[5],
726                           uuid.Data4[6], uuid.Data4[7]);
727
728                 goto finished;
729         } else if (attributedesc_string && !strncmp("NtVer", attributedesc_string, 5)){
730                 guint32 flags;
731
732                 len = 0;
733                 /* get flag value to populate ldapvalue_string */
734                 flags=tvb_get_letohl(tvb, offset);
735
736                 ldapvalue_string=ep_alloc(1024);
737                 g_snprintf(ldapvalue_string, 1023, "0x%08x",flags);
738
739                 /* populate bitmask subtree */
740                 offset = dissect_mscldap_ntver_flags(tree, tvb, offset);
741
742                 goto finished;
743
744
745         }
746
747         /*
748          * It was not one of our "wellknown" attributes so make the best
749          * we can and just try to see if it is an ascii string or if it
750          * is a binary blob.
751          *
752          * XXX - should we support reading RFC 2252-style schemas
753          * for LDAP, and using that to determine how to display
754          * attribute values and assertion values?
755          *
756          * -- I dont think there are full schemas available that describe the
757          *  interesting cases i.e. AD -- ronnie
758          */
759         str=tvb_get_ptr(tvb, offset, len);
760         is_ascii=TRUE;
761         for(i=0;i<len;i++){
762                 if(!isascii(str[i]) || !isprint(str[i])){
763                         is_ascii=FALSE;
764                         break;
765                 }
766         }
767
768         /* convert the string into a printable string */
769         if(is_ascii){
770                 ldapvalue_string=ep_strndup(str, len);
771         } else {
772                 ldapvalue_string=ep_alloc(3*len);
773                 for(i=0;i<len;i++){
774                         g_snprintf(ldapvalue_string+i*3,3,"%02x",str[i]&0xff);
775                         ldapvalue_string[3*i+2]=':';
776                 }
777                 ldapvalue_string[3*len-1]=0;
778         }
779
780         proto_tree_add_string(tree, hf_index, tvb, offset, len, ldapvalue_string);
781
782
783 finished:
784         offset+=len;
785         return offset;
786 }
787
788 /* This string contains the last Filter item that was decoded */
789 static const char *Filter_string=NULL;
790 static const char *and_filter_string=NULL;
791 static const char *or_filter_string=NULL;
792 static const char *substring_value=NULL;
793 static const char *substring_item_init=NULL;
794 static const char *substring_item_any=NULL;
795 static const char *substring_item_final=NULL;
796 static const char *matching_rule_string=NULL;
797 static gboolean matching_rule_dnattr=FALSE;
798
799 #define MAX_FILTER_LEN 4096
800 static gint Filter_length;
801
802 #define MAX_FILTER_ELEMENTS 200
803 static gint Filter_elements;
804
805 /* Global variables */
806 char *mechanism = NULL;
807 static gint MessageID =-1;
808 static gint ProtocolOp = -1;
809 static gint result = 0;
810 static proto_item *ldm_tree = NULL; /* item to add text to */
811
812 static void ldap_do_protocolop(packet_info *pinfo)
813 {
814   const gchar* valstr;
815
816   if (do_protocolop)  {
817
818     valstr = val_to_str(ProtocolOp, ldap_ProtocolOp_choice_vals, "Unknown (%%u)");
819
820     col_append_fstr(pinfo->cinfo, COL_INFO, "%s(%u) ", valstr, MessageID);
821
822     if(ldm_tree)
823       proto_item_append_text(ldm_tree, " %s(%d)", valstr, MessageID);
824
825     do_protocolop = FALSE;
826
827   }
828 }
829
830 static ldap_call_response_t *
831 ldap_match_call_response(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, guint messageId, guint protocolOpTag)
832 {
833   ldap_call_response_t lcr, *lcrp=NULL;
834   ldap_conv_info_t *ldap_info = (ldap_conv_info_t *)pinfo->private_data;
835
836   /* first see if we have already matched this */
837
838       lcr.messageId=messageId;
839       switch(protocolOpTag){
840         case LDAP_REQ_BIND:
841         case LDAP_REQ_SEARCH:
842         case LDAP_REQ_MODIFY:
843         case LDAP_REQ_ADD:
844         case LDAP_REQ_DELETE:
845         case LDAP_REQ_MODRDN:
846         case LDAP_REQ_COMPARE:
847         case LDAP_REQ_EXTENDED:
848           lcr.is_request=TRUE;
849           lcr.req_frame=pinfo->fd->num;
850           lcr.rep_frame=0;
851           break;
852         case LDAP_RES_BIND:
853         case LDAP_RES_SEARCH_ENTRY:
854         case LDAP_RES_SEARCH_REF:
855         case LDAP_RES_SEARCH_RESULT:
856         case LDAP_RES_MODIFY:
857         case LDAP_RES_ADD:
858         case LDAP_RES_DELETE:
859         case LDAP_RES_MODRDN:
860         case LDAP_RES_COMPARE:
861         case LDAP_RES_EXTENDED:
862         case LDAP_RES_INTERMEDIATE:
863           lcr.is_request=FALSE;
864           lcr.req_frame=0;
865           lcr.rep_frame=pinfo->fd->num;
866           break;
867       }
868       lcrp=g_hash_table_lookup(ldap_info->matched, &lcr);
869
870       if(lcrp){
871
872         lcrp->is_request=lcr.is_request;
873
874       } else {
875
876                   /* we haven't found a match - try and match it up */
877
878   switch(protocolOpTag){
879       case LDAP_REQ_BIND:
880       case LDAP_REQ_SEARCH:
881       case LDAP_REQ_MODIFY:
882       case LDAP_REQ_ADD:
883       case LDAP_REQ_DELETE:
884       case LDAP_REQ_MODRDN:
885       case LDAP_REQ_COMPARE:
886       case LDAP_REQ_EXTENDED:
887
888                 /* this a a request - add it to the unmatched list */
889
890         /* check that we dont already have one of those in the
891            unmatched list and if so remove it */
892
893         lcr.messageId=messageId;
894         lcrp=g_hash_table_lookup(ldap_info->unmatched, &lcr);
895         if(lcrp){
896           g_hash_table_remove(ldap_info->unmatched, lcrp);
897         }
898         /* if we cant reuse the old one, grab a new chunk */
899         if(!lcrp){
900           lcrp=se_alloc(sizeof(ldap_call_response_t));
901         }
902         lcrp->messageId=messageId;
903         lcrp->req_frame=pinfo->fd->num;
904         lcrp->req_time=pinfo->fd->abs_ts;
905         lcrp->rep_frame=0;
906         lcrp->protocolOpTag=protocolOpTag;
907         lcrp->is_request=TRUE;
908         g_hash_table_insert(ldap_info->unmatched, lcrp, lcrp);
909         return NULL;
910         break;
911       case LDAP_RES_BIND:
912       case LDAP_RES_SEARCH_ENTRY:
913       case LDAP_RES_SEARCH_REF:
914       case LDAP_RES_SEARCH_RESULT:
915       case LDAP_RES_MODIFY:
916       case LDAP_RES_ADD:
917       case LDAP_RES_DELETE:
918       case LDAP_RES_MODRDN:
919       case LDAP_RES_COMPARE:
920       case LDAP_RES_EXTENDED:
921       case LDAP_RES_INTERMEDIATE:
922
923                 /* this is a result - it should be in our unmatched list */
924
925         lcr.messageId=messageId;
926         lcrp=g_hash_table_lookup(ldap_info->unmatched, &lcr);
927
928         if(lcrp){
929
930           if(!lcrp->rep_frame){
931             g_hash_table_remove(ldap_info->unmatched, lcrp);
932             lcrp->rep_frame=pinfo->fd->num;
933             lcrp->is_request=FALSE;
934             g_hash_table_insert(ldap_info->matched, lcrp, lcrp);
935           }
936         }
937
938         break;
939           }
940
941         }
942     /* we have found a match */
943
944     if(lcrp){
945       proto_item *it;
946
947       if(lcrp->is_request){
948         it=proto_tree_add_uint(tree, hf_ldap_response_in, tvb, 0, 0, lcrp->rep_frame);
949         PROTO_ITEM_SET_GENERATED(it);
950       } else {
951         nstime_t ns;
952         it=proto_tree_add_uint(tree, hf_ldap_response_to, tvb, 0, 0, lcrp->req_frame);
953         PROTO_ITEM_SET_GENERATED(it);
954         nstime_delta(&ns, &pinfo->fd->abs_ts, &lcrp->req_time);
955         it=proto_tree_add_time(tree, hf_ldap_time, tvb, 0, 0, &ns);
956         PROTO_ITEM_SET_GENERATED(it);
957       }
958     }
959
960     return lcrp;
961 }
962
963
964 /*--- Included file: packet-ldap-fn.c ---*/
965 #line 1 "../../asn1/ldap/packet-ldap-fn.c"
966 /*--- Cyclic dependencies ---*/
967
968 /* Filter -> Filter/and -> Filter/and/_item -> Filter */
969 /* Filter -> Filter/or -> Filter/or/_item -> Filter */
970 /* Filter -> Filter/not -> Filter */
971 static int dissect_ldap_Filter(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_);
972
973
974
975
976 static int
977 dissect_ldap_MessageID(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) {
978 #line 98 "../../asn1/ldap/ldap.cnf"
979
980     offset = dissect_ber_integer(implicit_tag, actx, tree, tvb, offset, hf_index,
981                                                 &MessageID);
982
983
984   ldm_tree = tree;
985
986
987
988   return offset;
989 }
990
991
992
993 static int
994 dissect_ldap_INTEGER_1_127(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) {
995   offset = dissect_ber_integer(implicit_tag, actx, tree, tvb, offset, hf_index,
996                                                 NULL);
997
998   return offset;
999 }
1000
1001
1002
1003 static int
1004 dissect_ldap_LDAPString(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) {
1005 #line 324 "../../asn1/ldap/ldap.cnf"
1006   tvbuff_t      *parameter_tvb = NULL;
1007   const char    *ldapstring = NULL;
1008   gchar         *sc = NULL; /* semi-colon pointer */
1009
1010     offset = dissect_ber_octet_string(implicit_tag, actx, tree, tvb, offset, hf_index,
1011                                        &parameter_tvb);
1012
1013
1014   if (parameter_tvb || (hf_index == hf_ldap_baseObject)) {
1015
1016      ldap_do_protocolop(actx->pinfo);
1017
1018      if(parameter_tvb)
1019         ldapstring = tvb_get_ephemeral_string(parameter_tvb, 0, tvb_length_remaining(parameter_tvb, 0));
1020
1021      if(hf_index == hf_ldap_baseObject) {
1022         /* this is search - put it on the scanline */
1023         if(!ldapstring || !*ldapstring)
1024           ldapstring = "<ROOT>";
1025
1026     col_append_fstr(actx->pinfo->cinfo, COL_INFO, "\"%s\" ", ldapstring);
1027
1028         if(ldm_tree)
1029           proto_item_append_text(ldm_tree, " \"%s\"", ldapstring);
1030
1031
1032         if(!parameter_tvb) {
1033
1034           proto_item_append_text(actx->created_item, " (%s)", ldapstring);
1035         }
1036
1037      } else if ((hf_index == hf_ldap_errorMessage) && ldapstring && *ldapstring) { /* only show message if not success */
1038         col_append_fstr(actx->pinfo->cinfo, COL_INFO, "(%s) ", ldapstring);
1039
1040         if(ldm_tree)
1041           proto_item_append_text(ldm_tree, " (%s)", ldapstring);
1042
1043      } else if ((hf_index == hf_ldap_objectName) ||
1044                 (hf_index == hf_ldap_name) ||
1045                 (hf_index == hf_ldap_entry) ||
1046                 (hf_index == hf_ldap_object) ||
1047                 (hf_index == hf_ldap_delRequest) ) {
1048
1049         if(!ldapstring || !*ldapstring)
1050           ldapstring = "<ROOT>";
1051
1052     col_append_fstr(actx->pinfo->cinfo, COL_INFO, "\"%s\" ", ldapstring);
1053
1054     if(ldm_tree)
1055           proto_item_append_text(ldm_tree, " \"%s\"", ldapstring);
1056      } else if (hf_index == hf_ldap_attributeDesc){
1057         /* remember the attribute description */
1058         attributedesc_string=ldapstring;
1059      } else if (hf_index == hf_ldap_initial){
1060         /* remember the substring item */
1061         substring_item_init=ldapstring;
1062      } else if (hf_index == hf_ldap_any){
1063         /* remember the substring item */
1064         substring_item_any=ldapstring;
1065      } else if (hf_index == hf_ldap_final){
1066         /* remember the substring item */
1067         substring_item_final=ldapstring;
1068      } else if (hf_index == hf_ldap_matchingRule){
1069         /* remember the matching rule */
1070         matching_rule_string=ldapstring;
1071      } else if (hf_index == hf_ldap_present){
1072         /* remember the present name */
1073         Filter_string=ldapstring;
1074      } else if (hf_index == hf_ldap_type) {
1075         /* remember attribute type name */
1076         attr_type = ep_strdup(ldapstring);
1077
1078         /* append it to the parent entry */
1079         proto_item_append_text(tree, " %s", attr_type);
1080
1081         /* remove the ";binary" component if present */
1082         if((sc = strchr(attr_type, ';')) != NULL) {
1083                 if(!strcmp(sc, ";binary")) {
1084                         *sc = '\0'; /* terminate the string */
1085                         is_binary_attr_type = TRUE;
1086                 }
1087         } else {
1088                 is_binary_attr_type = FALSE;
1089         }
1090
1091      }
1092
1093   }
1094
1095
1096
1097   return offset;
1098 }
1099
1100
1101
1102 static int
1103 dissect_ldap_LDAPDN(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) {
1104   offset = dissect_ldap_LDAPString(implicit_tag, tvb, offset, actx, tree, hf_index);
1105
1106   return offset;
1107 }
1108
1109
1110
1111 static int
1112 dissect_ldap_Simple(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) {
1113 #line 167 "../../asn1/ldap/ldap.cnf"
1114 ldap_conv_info_t *ldap_info;
1115
1116   offset = dissect_ber_octet_string(implicit_tag, actx, tree, tvb, offset, hf_index,
1117                                        NULL);
1118
1119
1120         ldap_info = actx->pinfo->private_data;
1121         ldap_info->auth_type = LDAP_AUTH_SIMPLE;
1122
1123         actx->pinfo->private_data = ldap_info;
1124
1125
1126
1127   return offset;
1128 }
1129
1130
1131
1132 static int
1133 dissect_ldap_Mechanism(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) {
1134 #line 177 "../../asn1/ldap/ldap.cnf"
1135
1136 ldap_conv_info_t *ldap_info;
1137 tvbuff_t        *parameter_tvb;
1138 char *mechanism = NULL;
1139   offset = dissect_ber_octet_string(implicit_tag, actx, tree, tvb, offset, hf_index,
1140                                        &parameter_tvb);
1141
1142         ldap_info = actx->pinfo->private_data;
1143         ldap_info->auth_type = LDAP_AUTH_SASL;
1144
1145         if (!parameter_tvb)
1146                 return offset;
1147
1148     /*
1149      * We need to remember the authentication type and mechanism for this
1150      * conversation.
1151      *
1152      * XXX - actually, we might need to remember more than one
1153      * type and mechanism, if you can unbind and rebind with a
1154      * different type and/or mechanism.
1155      */
1156     if(!actx->pinfo->fd->flags.visited) {
1157         mechanism = tvb_get_string(parameter_tvb, 0, tvb_length_remaining(parameter_tvb,0));
1158         ldap_info->first_auth_frame = 0;        /* not known until we see the bind reply */
1159         /*
1160          * If the mechanism in this request is an empty string (which is
1161          * returned as a null pointer), use the saved mechanism instead.
1162          * Otherwise, if the saved mechanism is an empty string (null),
1163          * save this mechanism.
1164          */
1165         if (mechanism == NULL) {
1166             mechanism = ldap_info->auth_mech;
1167         } else {
1168           g_free(ldap_info->auth_mech);
1169           ldap_info->auth_mech = mechanism;
1170         }
1171         actx->pinfo->private_data = ldap_info;
1172     }
1173
1174
1175   return offset;
1176 }
1177
1178
1179
1180 static int
1181 dissect_ldap_Credentials(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) {
1182 #line 214 "../../asn1/ldap/ldap.cnf"
1183
1184 tvbuff_t        *parameter_tvb;
1185 ldap_conv_info_t *ldap_info;
1186 gint8 class;
1187 gboolean pc;
1188 gint32 tag;
1189
1190   offset = dissect_ber_octet_string(implicit_tag, actx, tree, tvb, offset, hf_index,
1191                                        &parameter_tvb);
1192
1193
1194         if (!parameter_tvb)
1195                 return offset;
1196
1197         ldap_info = actx->pinfo->private_data;
1198         get_ber_identifier(parameter_tvb, 0, &class, &pc, &tag);
1199
1200         /*if ((ldap_info->auth_mech != NULL) && (strcmp(ldap_info->auth_mech, "GSS-SPNEGO") == 0) && (class==BER_CLASS_CON)) {*/
1201         if ((ldap_info->auth_mech != NULL) && (class==BER_CLASS_CON)) {
1202           /*
1203            * This is a GSS-API token ancapsulated within GSS-SPNEGO.
1204            * We need to check the first byte to check whether the blob
1205            * contains SPNEGO or GSSAPI.
1206            * All SPNEGO PDUs are of class CONSTRUCTED while
1207            * GSS PDUs are class APPLICATION
1208            */
1209           if (parameter_tvb && (tvb_length(parameter_tvb) > 0))
1210             call_dissector(spnego_handle, parameter_tvb, actx->pinfo, tree);
1211         }
1212         /*if ((ldap_info->auth_mech != NULL) && ((strcmp(ldap_info->auth_mech, "GSSAPI") == 0) || (class==BER_CLASS_APP))) {*/
1213         if ((ldap_info->auth_mech != NULL) && (class==BER_CLASS_APP)) {
1214           /*
1215            * This is a raw GSS-API token.
1216            */
1217           if (parameter_tvb && (tvb_length(parameter_tvb) > 0)) {
1218             call_dissector(gssapi_handle, parameter_tvb, actx->pinfo, tree);
1219           }
1220         }
1221         actx->pinfo->private_data = ldap_info;
1222
1223
1224
1225
1226   return offset;
1227 }
1228
1229
1230 static const ber_sequence_t SaslCredentials_sequence[] = {
1231   { &hf_ldap_mechanism      , BER_CLASS_UNI, BER_UNI_TAG_OCTETSTRING, BER_FLAGS_NOOWNTAG, dissect_ldap_Mechanism },
1232   { &hf_ldap_credentials    , BER_CLASS_UNI, BER_UNI_TAG_OCTETSTRING, BER_FLAGS_OPTIONAL|BER_FLAGS_NOOWNTAG, dissect_ldap_Credentials },
1233   { NULL, 0, 0, 0, NULL }
1234 };
1235
1236 static int
1237 dissect_ldap_SaslCredentials(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) {
1238   offset = dissect_ber_sequence(implicit_tag, actx, tree, tvb, offset,
1239                                    SaslCredentials_sequence, hf_index, ett_ldap_SaslCredentials);
1240
1241   return offset;
1242 }
1243
1244
1245
1246 static int
1247 dissect_ldap_T_ntlmsspNegotiate(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) {
1248 #line 705 "../../asn1/ldap/ldap.cnf"
1249         /* make sure the protocol op comes first */
1250         ldap_do_protocolop(actx->pinfo);
1251
1252         call_dissector(ntlmssp_handle, tvb, actx->pinfo, tree);
1253         offset+=tvb_length_remaining(tvb, offset);
1254
1255
1256
1257   return offset;
1258 }
1259
1260
1261
1262 static int
1263 dissect_ldap_T_ntlmsspAuth(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) {
1264 #line 712 "../../asn1/ldap/ldap.cnf"
1265         /* make sure the protocol op comes first */
1266         ldap_do_protocolop(actx->pinfo);
1267
1268         call_dissector(ntlmssp_handle, tvb, actx->pinfo, tree);
1269         offset+=tvb_length_remaining(tvb, offset);
1270
1271
1272
1273   return offset;
1274 }
1275
1276
1277 static const value_string ldap_AuthenticationChoice_vals[] = {
1278   {   0, "simple" },
1279   {   3, "sasl" },
1280   {  10, "ntlmsspNegotiate" },
1281   {  11, "ntlmsspAuth" },
1282   { 0, NULL }
1283 };
1284
1285 static const ber_choice_t AuthenticationChoice_choice[] = {
1286   {   0, &hf_ldap_simple         , BER_CLASS_CON, 0, BER_FLAGS_IMPLTAG, dissect_ldap_Simple },
1287   {   3, &hf_ldap_sasl           , BER_CLASS_CON, 3, BER_FLAGS_IMPLTAG, dissect_ldap_SaslCredentials },
1288   {  10, &hf_ldap_ntlmsspNegotiate, BER_CLASS_CON, 10, BER_FLAGS_IMPLTAG, dissect_ldap_T_ntlmsspNegotiate },
1289   {  11, &hf_ldap_ntlmsspAuth    , BER_CLASS_CON, 11, BER_FLAGS_IMPLTAG, dissect_ldap_T_ntlmsspAuth },
1290   { 0, NULL, 0, 0, 0, NULL }
1291 };
1292
1293 static int
1294 dissect_ldap_AuthenticationChoice(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) {
1295 #line 495 "../../asn1/ldap/ldap.cnf"
1296   gint branch = -1;
1297   gint auth = -1;
1298   const gchar *valstr;
1299
1300     offset = dissect_ber_choice(actx, tree, tvb, offset,
1301                                  AuthenticationChoice_choice, hf_index, ett_ldap_AuthenticationChoice,
1302                                  &branch);
1303
1304
1305   ldap_do_protocolop(actx->pinfo);
1306
1307   if((branch > -1) && (branch < (gint)(sizeof AuthenticationChoice_choice/sizeof AuthenticationChoice_choice[0])))
1308     auth = AuthenticationChoice_choice[branch].value;
1309
1310   valstr = val_to_str(auth, ldap_AuthenticationChoice_vals, "Unknown auth(%u)");
1311
1312   /* If auth is NTLM (10 or 11) don't add to column as the NTLM dissection will do this */
1313   if ((auth !=  10) && (auth != 11))
1314     col_append_fstr(actx->pinfo->cinfo, COL_INFO, "%s ", valstr);
1315
1316   if(ldm_tree)
1317     proto_item_append_text(ldm_tree, " %s", valstr);
1318
1319
1320
1321
1322   return offset;
1323 }
1324
1325
1326 static const ber_sequence_t BindRequest_U_sequence[] = {
1327   { &hf_ldap_version        , BER_CLASS_UNI, BER_UNI_TAG_INTEGER, BER_FLAGS_NOOWNTAG, dissect_ldap_INTEGER_1_127 },
1328   { &hf_ldap_name           , BER_CLASS_UNI, BER_UNI_TAG_OCTETSTRING, BER_FLAGS_NOOWNTAG, dissect_ldap_LDAPDN },
1329   { &hf_ldap_authentication , BER_CLASS_ANY/*choice*/, -1/*choice*/, BER_FLAGS_NOOWNTAG|BER_FLAGS_NOTCHKTAG, dissect_ldap_AuthenticationChoice },
1330   { NULL, 0, 0, 0, NULL }
1331 };
1332
1333 static int
1334 dissect_ldap_BindRequest_U(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) {
1335   offset = dissect_ber_sequence(implicit_tag, actx, tree, tvb, offset,
1336                                    BindRequest_U_sequence, hf_index, ett_ldap_BindRequest_U);
1337
1338   return offset;
1339 }
1340
1341
1342
1343 static int
1344 dissect_ldap_BindRequest(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) {
1345   offset = dissect_ber_tagged_type(implicit_tag, actx, tree, tvb, offset,
1346                                       hf_index, BER_CLASS_APP, 0, TRUE, dissect_ldap_BindRequest_U);
1347
1348   return offset;
1349 }
1350
1351
1352 static const value_string ldap_BindResponse_resultCode_vals[] = {
1353   {   0, "success" },
1354   {   1, "operationsError" },
1355   {   2, "protocolError" },
1356   {   3, "timeLimitExceeded" },
1357   {   4, "sizeLimitExceeded" },
1358   {   5, "compareFalse" },
1359   {   6, "compareTrue" },
1360   {   7, "authMethodNotSupported" },
1361   {   8, "strongAuthRequired" },
1362   {  10, "referral" },
1363   {  11, "adminLimitExceeded" },
1364   {  12, "unavailableCriticalExtension" },
1365   {  13, "confidentialityRequired" },
1366   {  14, "saslBindInProgress" },
1367   {  16, "noSuchAttribute" },
1368   {  17, "undefinedAttributeType" },
1369   {  18, "inappropriateMatching" },
1370   {  19, "constraintViolation" },
1371   {  20, "attributeOrValueExists" },
1372   {  21, "invalidAttributeSyntax" },
1373   {  32, "noSuchObject" },
1374   {  33, "aliasProblem" },
1375   {  34, "invalidDNSyntax" },
1376   {  36, "aliasDereferencingProblem" },
1377   {  48, "inappropriateAuthentication" },
1378   {  49, "invalidCredentials" },
1379   {  50, "insufficientAccessRights" },
1380   {  51, "busy" },
1381   {  52, "unavailable" },
1382   {  53, "unwillingToPerform" },
1383   {  54, "loopDetect" },
1384   {  64, "namingViolation" },
1385   {  65, "objectClassViolation" },
1386   {  66, "notAllowedOnNonLeaf" },
1387   {  67, "notAllowedOnRDN" },
1388   {  68, "entryAlreadyExists" },
1389   {  69, "objectClassModsProhibited" },
1390   {  71, "affectsMultipleDSAs" },
1391   {  80, "other" },
1392   { 118, "canceled" },
1393   { 119, "noSuchOperation" },
1394   { 120, "tooLate" },
1395   { 121, "cannotCancel" },
1396   { 0, NULL }
1397 };
1398
1399
1400 static int
1401 dissect_ldap_BindResponse_resultCode(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) {
1402 #line 444 "../../asn1/ldap/ldap.cnf"
1403
1404   const gchar *valstr;
1405
1406     offset = dissect_ber_integer(implicit_tag, actx, tree, tvb, offset, hf_index,
1407                                   &result);
1408
1409
1410   ldap_do_protocolop(actx->pinfo);
1411
1412   valstr = val_to_str(result, ldap_BindResponse_resultCode_vals, "Unknown result(%u)");
1413
1414   col_append_fstr(actx->pinfo->cinfo, COL_INFO, "%s ", valstr);
1415
1416   if(ldm_tree)
1417     proto_item_append_text(ldm_tree, " %s", valstr);
1418
1419
1420
1421
1422   return offset;
1423 }
1424
1425
1426
1427 static int
1428 dissect_ldap_T_bindResponse_matchedDN(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) {
1429 #line 719 "../../asn1/ldap/ldap.cnf"
1430         tvbuff_t *new_tvb=NULL;
1431
1432         offset = dissect_ber_octet_string(FALSE, actx, tree, tvb, offset, hf_ldap_matchedDN, &new_tvb);
1433
1434         if(  new_tvb
1435         &&  (tvb_length(new_tvb)>=7)
1436         &&  (!tvb_memeql(new_tvb, 0, "NTLMSSP", 7))){
1437
1438                 /* make sure the protocol op comes first */
1439                 ldap_do_protocolop(actx->pinfo);
1440
1441                 call_dissector(ntlmssp_handle, new_tvb, actx->pinfo, tree);
1442         }
1443         return offset;
1444
1445
1446
1447   return offset;
1448 }
1449
1450
1451
1452 static int
1453 dissect_ldap_ErrorMessage(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) {
1454   offset = dissect_ldap_LDAPString(implicit_tag, tvb, offset, actx, tree, hf_index);
1455
1456   return offset;
1457 }
1458
1459
1460
1461 static int
1462 dissect_ldap_LDAPURL(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) {
1463   offset = dissect_ber_octet_string(implicit_tag, actx, tree, tvb, offset, hf_index,
1464                                        NULL);
1465
1466 #line 51 "../../asn1/ldap/ldap.cnf"
1467         PROTO_ITEM_SET_URL(actx->created_item);
1468
1469
1470   return offset;
1471 }
1472
1473
1474 static const ber_sequence_t Referral_sequence_of[1] = {
1475   { &hf_ldap_Referral_item  , BER_CLASS_UNI, BER_UNI_TAG_OCTETSTRING, BER_FLAGS_NOOWNTAG, dissect_ldap_LDAPURL },
1476 };
1477
1478 static int
1479 dissect_ldap_Referral(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) {
1480   offset = dissect_ber_sequence_of(implicit_tag, actx, tree, tvb, offset,
1481                                       Referral_sequence_of, hf_index, ett_ldap_Referral);
1482
1483   return offset;
1484 }
1485
1486
1487
1488 static int
1489 dissect_ldap_ServerSaslCreds(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) {
1490 #line 254 "../../asn1/ldap/ldap.cnf"
1491
1492 tvbuff_t        *parameter_tvb = NULL;
1493 ldap_conv_info_t *ldap_info;
1494
1495   offset = dissect_ber_octet_string(implicit_tag, actx, tree, tvb, offset, hf_index,
1496                                        &parameter_tvb);
1497
1498         if (!parameter_tvb)
1499                 return offset;
1500         ldap_info = actx->pinfo->private_data;
1501     switch (ldap_info->auth_type) {
1502
1503       /* For Kerberos V4, dissect it as a ticket. */
1504       /* XXX - what about LDAP_AUTH_SIMPLE? */
1505
1506     case LDAP_AUTH_SASL:
1507       /*
1508        * All frames after this are assumed to use a security layer.
1509        *
1510        * XXX - won't work if there's another reply, with the security
1511        * layer, starting in the same TCP segment that ends this
1512        * reply, but as LDAP is a request/response protocol, and
1513        * as the client probably can't start using authentication until
1514        * it gets the bind reply and the server won't send a reply until
1515        * it gets a request, that probably won't happen.
1516        *
1517        * XXX - that assumption is invalid; it's not clear where the
1518        * hell you find out whether there's any security layer.  In
1519        * one capture, we have two GSS-SPNEGO negotiations, both of
1520        * which select MS KRB5, and the only differences in the tokens
1521        * is in the RC4-HMAC ciphertext.  The various
1522        * draft-ietf--cat-sasl-gssapi-NN.txt drafts seem to imply
1523        * that the RFC 2222 spoo with the bitmask and maximum
1524        * output message size stuff is done - but where does that
1525        * stuff show up?  Is it in the ciphertext, which means it's
1526        * presumably encrypted?
1527        *
1528        * Grrr.  We have to do a gross heuristic, checking whether the
1529        * putative LDAP message begins with 0x00 or not, making the
1530        * assumption that we won't have more than 2^24 bytes of
1531        * encapsulated stuff.
1532        */
1533       ldap_info->first_auth_frame = actx->pinfo->fd->num + 1;
1534       if (ldap_info->auth_mech != NULL &&
1535           strcmp(ldap_info->auth_mech, "GSS-SPNEGO") == 0) {
1536         /* It could be the second leg of GSS-SPNEGO wrapping NTLMSSP
1537          * which might not be wrapped in GSS-SPNEGO but be a raw
1538          * NTLMSSP blob
1539          */
1540         if ( (tvb_length(parameter_tvb)>=7)
1541         &&   (!tvb_memeql(parameter_tvb, 0, "NTLMSSP", 7))){
1542           call_dissector(ntlmssp_handle, parameter_tvb, actx->pinfo, tree);
1543           break;
1544         }
1545         /*
1546          * This is a GSS-API token.
1547          */
1548         if(parameter_tvb && (tvb_length(parameter_tvb) > 0))
1549           call_dissector(spnego_handle, parameter_tvb, actx->pinfo, tree);
1550       } else if (ldap_info->auth_mech != NULL &&
1551           strcmp(ldap_info->auth_mech, "GSSAPI") == 0) {
1552         /*
1553          * This is a GSS-API token.
1554          */
1555         if(parameter_tvb && (tvb_length(parameter_tvb) > 0))
1556           call_dissector(gssapi_handle, parameter_tvb, actx->pinfo, tree);
1557                 }
1558         break;
1559         }
1560         actx->pinfo->private_data = ldap_info;
1561
1562
1563
1564   return offset;
1565 }
1566
1567
1568 static const ber_sequence_t BindResponse_U_sequence[] = {
1569   { &hf_ldap_bindResponse_resultCode, BER_CLASS_UNI, BER_UNI_TAG_ENUMERATED, BER_FLAGS_NOOWNTAG, dissect_ldap_BindResponse_resultCode },
1570   { &hf_ldap_bindResponse_matchedDN, BER_CLASS_UNI, BER_UNI_TAG_OCTETSTRING, BER_FLAGS_NOOWNTAG, dissect_ldap_T_bindResponse_matchedDN },
1571   { &hf_ldap_errorMessage   , BER_CLASS_UNI, BER_UNI_TAG_OCTETSTRING, BER_FLAGS_NOOWNTAG, dissect_ldap_ErrorMessage },
1572   { &hf_ldap_referral       , BER_CLASS_CON, 3, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_ldap_Referral },
1573   { &hf_ldap_serverSaslCreds, BER_CLASS_CON, 7, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_ldap_ServerSaslCreds },
1574   { NULL, 0, 0, 0, NULL }
1575 };
1576
1577 static int
1578 dissect_ldap_BindResponse_U(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) {
1579   offset = dissect_ber_sequence(implicit_tag, actx, tree, tvb, offset,
1580                                    BindResponse_U_sequence, hf_index, ett_ldap_BindResponse_U);
1581
1582   return offset;
1583 }
1584
1585
1586
1587 static int
1588 dissect_ldap_BindResponse(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) {
1589   offset = dissect_ber_tagged_type(implicit_tag, actx, tree, tvb, offset,
1590                                       hf_index, BER_CLASS_APP, 1, TRUE, dissect_ldap_BindResponse_U);
1591
1592   return offset;
1593 }
1594
1595
1596
1597 static int
1598 dissect_ldap_NULL(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) {
1599   offset = dissect_ber_null(implicit_tag, actx, tree, tvb, offset, hf_index);
1600
1601   return offset;
1602 }
1603
1604
1605
1606 static int
1607 dissect_ldap_UnbindRequest(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) {
1608 #line 517 "../../asn1/ldap/ldap.cnf"
1609
1610  implicit_tag = TRUE; /* correct problem with asn2wrs */
1611
1612    offset = dissect_ber_tagged_type(implicit_tag, actx, tree, tvb, offset,
1613                                       hf_index, BER_CLASS_APP, 2, TRUE, dissect_ldap_NULL);
1614
1615
1616  ldap_do_protocolop(actx->pinfo);
1617
1618
1619
1620
1621
1622
1623
1624   return offset;
1625 }
1626
1627
1628 static const value_string ldap_T_scope_vals[] = {
1629   {   0, "baseObject" },
1630   {   1, "singleLevel" },
1631   {   2, "wholeSubtree" },
1632   { 0, NULL }
1633 };
1634
1635
1636 static int
1637 dissect_ldap_T_scope(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) {
1638 #line 412 "../../asn1/ldap/ldap.cnf"
1639
1640   guint32 scope = 0xffff;
1641   const gchar *valstr;
1642
1643     offset = dissect_ber_integer(implicit_tag, actx, tree, tvb, offset, hf_index,
1644                                   &scope);
1645
1646
1647   ldap_do_protocolop(actx->pinfo);
1648
1649   valstr = val_to_str(scope, ldap_T_scope_vals, "Unknown scope(%u)");
1650
1651   col_append_fstr(actx->pinfo->cinfo, COL_INFO, "%s ", valstr);
1652
1653   if(ldm_tree)
1654     proto_item_append_text(ldm_tree, " %s", valstr);
1655
1656
1657
1658   return offset;
1659 }
1660
1661
1662 static const value_string ldap_T_derefAliases_vals[] = {
1663   {   0, "neverDerefAliases" },
1664   {   1, "derefInSearching" },
1665   {   2, "derefFindingBaseObj" },
1666   {   3, "derefAlways" },
1667   { 0, NULL }
1668 };
1669
1670
1671 static int
1672 dissect_ldap_T_derefAliases(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) {
1673   offset = dissect_ber_integer(implicit_tag, actx, tree, tvb, offset, hf_index,
1674                                   NULL);
1675
1676   return offset;
1677 }
1678
1679
1680
1681 static int
1682 dissect_ldap_INTEGER_0_maxInt(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) {
1683   offset = dissect_ber_integer(implicit_tag, actx, tree, tvb, offset, hf_index,
1684                                                 NULL);
1685
1686   return offset;
1687 }
1688
1689
1690
1691 static int
1692 dissect_ldap_BOOLEAN(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) {
1693   offset = dissect_ber_boolean(implicit_tag, actx, tree, tvb, offset, hf_index, NULL);
1694
1695   return offset;
1696 }
1697
1698
1699
1700 static int
1701 dissect_ldap_T_and_item(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) {
1702   offset = dissect_ldap_Filter(implicit_tag, tvb, offset, actx, tree, hf_index);
1703
1704 #line 563 "../../asn1/ldap/ldap.cnf"
1705         if(and_filter_string){
1706                 and_filter_string=ep_strdup_printf("(&%s%s)",and_filter_string,Filter_string);
1707         } else {
1708                 and_filter_string=Filter_string;
1709         }
1710
1711
1712   return offset;
1713 }
1714
1715
1716 static const ber_sequence_t T_and_set_of[1] = {
1717   { &hf_ldap_and_item       , BER_CLASS_ANY/*choice*/, -1/*choice*/, BER_FLAGS_NOOWNTAG|BER_FLAGS_NOTCHKTAG, dissect_ldap_T_and_item },
1718 };
1719
1720 static int
1721 dissect_ldap_T_and(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) {
1722 #line 570 "../../asn1/ldap/ldap.cnf"
1723         proto_tree *tr=NULL;
1724         proto_item *it=NULL;
1725         const char *old_and_filter_string=and_filter_string;
1726
1727         and_filter_string=NULL;
1728         if(tree){
1729                 it=proto_tree_add_text(tree, tvb, offset, tvb_length_remaining(tvb, offset), "and: ");
1730                 tr=proto_item_add_subtree(it, ett_ldap_T_and);
1731                 tree = tr;
1732         }
1733
1734   offset = dissect_ber_set_of(implicit_tag, actx, tree, tvb, offset,
1735                                  T_and_set_of, hf_index, ett_ldap_T_and);
1736
1737
1738         if(and_filter_string) {
1739                 proto_item_append_text(it, "%s", and_filter_string);
1740                 Filter_string=ep_strdup_printf("%s",and_filter_string);
1741         }
1742         and_filter_string=old_and_filter_string;
1743
1744
1745
1746   return offset;
1747 }
1748
1749
1750
1751 static int
1752 dissect_ldap_T_or_item(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) {
1753   offset = dissect_ldap_Filter(implicit_tag, tvb, offset, actx, tree, hf_index);
1754
1755 #line 590 "../../asn1/ldap/ldap.cnf"
1756         if(or_filter_string){
1757                 or_filter_string=ep_strdup_printf("(|%s%s)",or_filter_string,Filter_string);
1758         } else {
1759                 or_filter_string=Filter_string;
1760         }
1761
1762
1763
1764   return offset;
1765 }
1766
1767
1768 static const ber_sequence_t T_or_set_of[1] = {
1769   { &hf_ldap_or_item        , BER_CLASS_ANY/*choice*/, -1/*choice*/, BER_FLAGS_NOOWNTAG|BER_FLAGS_NOTCHKTAG, dissect_ldap_T_or_item },
1770 };
1771
1772 static int
1773 dissect_ldap_T_or(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) {
1774 #line 598 "../../asn1/ldap/ldap.cnf"
1775         proto_tree *tr=NULL;
1776         proto_item *it=NULL;
1777         const char *old_or_filter_string=or_filter_string;
1778
1779         or_filter_string=NULL;
1780         if(tree){
1781                 it=proto_tree_add_text(tree, tvb, offset, tvb_length_remaining(tvb, offset), "or: ");
1782                 tr=proto_item_add_subtree(it, ett_ldap_T_or);
1783                 tree = tr;
1784         }
1785   offset = dissect_ber_set_of(implicit_tag, actx, tree, tvb, offset,
1786                                  T_or_set_of, hf_index, ett_ldap_T_or);
1787
1788         if(or_filter_string) {
1789                 proto_item_append_text(it, "%s", or_filter_string);
1790                 Filter_string=ep_strdup_printf("%s",or_filter_string);
1791         }
1792         or_filter_string=old_or_filter_string;
1793
1794
1795
1796   return offset;
1797 }
1798
1799
1800
1801 static int
1802 dissect_ldap_T_not(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) {
1803   offset = dissect_ldap_Filter(implicit_tag, tvb, offset, actx, tree, hf_index);
1804
1805 #line 619 "../../asn1/ldap/ldap.cnf"
1806         Filter_string=ep_strdup_printf("(!%s)",string_or_null(Filter_string));
1807
1808
1809   return offset;
1810 }
1811
1812
1813
1814 static int
1815 dissect_ldap_AttributeDescription(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) {
1816   offset = dissect_ldap_LDAPString(implicit_tag, tvb, offset, actx, tree, hf_index);
1817
1818   return offset;
1819 }
1820
1821
1822
1823 static const ber_sequence_t AttributeValueAssertion_sequence[] = {
1824   { &hf_ldap_attributeDesc  , BER_CLASS_UNI, BER_UNI_TAG_OCTETSTRING, BER_FLAGS_NOOWNTAG, dissect_ldap_AttributeDescription },
1825   { &hf_ldap_assertionValue , BER_CLASS_UNI, BER_UNI_TAG_OCTETSTRING, BER_FLAGS_NOOWNTAG, dissect_ldap_AssertionValue },
1826   { NULL, 0, 0, 0, NULL }
1827 };
1828
1829 static int
1830 dissect_ldap_AttributeValueAssertion(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) {
1831   offset = dissect_ber_sequence(implicit_tag, actx, tree, tvb, offset,
1832                                    AttributeValueAssertion_sequence, hf_index, ett_ldap_AttributeValueAssertion);
1833
1834   return offset;
1835 }
1836
1837
1838
1839 static int
1840 dissect_ldap_T_equalityMatch(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) {
1841   offset = dissect_ldap_AttributeValueAssertion(implicit_tag, tvb, offset, actx, tree, hf_index);
1842
1843 #line 540 "../../asn1/ldap/ldap.cnf"
1844         Filter_string=ep_strdup_printf("(%s=%s)",
1845                                        string_or_null(attributedesc_string),
1846                                        string_or_null(ldapvalue_string));
1847
1848
1849
1850   return offset;
1851 }
1852
1853
1854 static const value_string ldap_T_substringFilter_substrings_item_vals[] = {
1855   {   0, "initial" },
1856   {   1, "any" },
1857   {   2, "final" },
1858   { 0, NULL }
1859 };
1860
1861 static const ber_choice_t T_substringFilter_substrings_item_choice[] = {
1862   {   0, &hf_ldap_initial        , BER_CLASS_CON, 0, BER_FLAGS_IMPLTAG, dissect_ldap_LDAPString },
1863   {   1, &hf_ldap_any            , BER_CLASS_CON, 1, BER_FLAGS_IMPLTAG, dissect_ldap_LDAPString },
1864   {   2, &hf_ldap_final          , BER_CLASS_CON, 2, BER_FLAGS_IMPLTAG, dissect_ldap_LDAPString },
1865   { 0, NULL, 0, 0, 0, NULL }
1866 };
1867
1868 static int
1869 dissect_ldap_T_substringFilter_substrings_item(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) {
1870   offset = dissect_ber_choice(actx, tree, tvb, offset,
1871                                  T_substringFilter_substrings_item_choice, hf_index, ett_ldap_T_substringFilter_substrings_item,
1872                                  NULL);
1873
1874 #line 645 "../../asn1/ldap/ldap.cnf"
1875         if (substring_item_final) {
1876                 substring_value=ep_strdup_printf("%s%s",
1877                                                  (substring_value?substring_value:"*"),
1878                                                  substring_item_final);
1879         } else if (substring_item_any) {
1880                 substring_value=ep_strdup_printf("%s%s*",
1881                                                  (substring_value?substring_value:"*"),
1882                                                  substring_item_any);
1883         } else if (substring_item_init) {
1884                 substring_value=ep_strdup_printf("%s*",
1885                                                  substring_item_init);
1886         }
1887
1888
1889   return offset;
1890 }
1891
1892
1893 static const ber_sequence_t T_substringFilter_substrings_sequence_of[1] = {
1894   { &hf_ldap_substringFilter_substrings_item, BER_CLASS_ANY/*choice*/, -1/*choice*/, BER_FLAGS_NOOWNTAG|BER_FLAGS_NOTCHKTAG, dissect_ldap_T_substringFilter_substrings_item },
1895 };
1896
1897 static int
1898 dissect_ldap_T_substringFilter_substrings(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) {
1899   offset = dissect_ber_sequence_of(implicit_tag, actx, tree, tvb, offset,
1900                                       T_substringFilter_substrings_sequence_of, hf_index, ett_ldap_T_substringFilter_substrings);
1901
1902   return offset;
1903 }
1904
1905
1906 static const ber_sequence_t SubstringFilter_sequence[] = {
1907   { &hf_ldap_type           , BER_CLASS_UNI, BER_UNI_TAG_OCTETSTRING, BER_FLAGS_NOOWNTAG, dissect_ldap_AttributeDescription },
1908   { &hf_ldap_substringFilter_substrings, BER_CLASS_UNI, BER_UNI_TAG_SEQUENCE, BER_FLAGS_NOOWNTAG, dissect_ldap_T_substringFilter_substrings },
1909   { NULL, 0, 0, 0, NULL }
1910 };
1911
1912 static int
1913 dissect_ldap_SubstringFilter(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) {
1914 #line 659 "../../asn1/ldap/ldap.cnf"
1915         proto_tree *tr=NULL;
1916         proto_item *it=NULL;
1917         const char *old_substring_value=substring_value;
1918
1919         attr_type=NULL;
1920         substring_value=NULL;
1921         substring_item_init=NULL;
1922         substring_item_any=NULL;
1923         substring_item_final=NULL;
1924         if(tree){
1925                 it=proto_tree_add_text(tree, tvb, offset, tvb_length_remaining(tvb, offset), "substring: ");
1926                 tr=proto_item_add_subtree(it, ett_ldap_SubstringFilter);
1927                 tree = tr;
1928         }
1929   offset = dissect_ber_sequence(implicit_tag, actx, tree, tvb, offset,
1930                                    SubstringFilter_sequence, hf_index, ett_ldap_SubstringFilter);
1931
1932         Filter_string=ep_strdup_printf("(%s=%s)",
1933                 string_or_null(attr_type),
1934                 string_or_null(substring_value));
1935         proto_item_append_text(it, "%s", Filter_string);
1936         substring_value=old_substring_value;
1937
1938
1939
1940   return offset;
1941 }
1942
1943
1944
1945 static int
1946 dissect_ldap_T_greaterOrEqual(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) {
1947   offset = dissect_ldap_AttributeValueAssertion(implicit_tag, tvb, offset, actx, tree, hf_index);
1948
1949 #line 546 "../../asn1/ldap/ldap.cnf"
1950         Filter_string=ep_strdup_printf("(%s>=%s)",
1951                                        string_or_null(attributedesc_string),
1952                                        string_or_null(ldapvalue_string));
1953
1954
1955
1956   return offset;
1957 }
1958
1959
1960
1961 static int
1962 dissect_ldap_T_lessOrEqual(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) {
1963   offset = dissect_ldap_AttributeValueAssertion(implicit_tag, tvb, offset, actx, tree, hf_index);
1964
1965 #line 552 "../../asn1/ldap/ldap.cnf"
1966         Filter_string=ep_strdup_printf("(%s<=%s)",
1967                                        string_or_null(attributedesc_string),
1968                                        string_or_null(ldapvalue_string));
1969
1970
1971
1972   return offset;
1973 }
1974
1975
1976
1977 static int
1978 dissect_ldap_T_present(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) {
1979   offset = dissect_ldap_AttributeDescription(implicit_tag, tvb, offset, actx, tree, hf_index);
1980
1981 #line 616 "../../asn1/ldap/ldap.cnf"
1982         Filter_string=ep_strdup_printf("(%s=*)",string_or_null(Filter_string));
1983
1984
1985   return offset;
1986 }
1987
1988
1989
1990 static int
1991 dissect_ldap_T_approxMatch(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) {
1992   offset = dissect_ldap_AttributeValueAssertion(implicit_tag, tvb, offset, actx, tree, hf_index);
1993
1994 #line 558 "../../asn1/ldap/ldap.cnf"
1995         Filter_string=ep_strdup_printf("(%s~=%s)",
1996                                        string_or_null(attributedesc_string),
1997                                        string_or_null(ldapvalue_string));
1998
1999
2000   return offset;
2001 }
2002
2003
2004
2005 static int
2006 dissect_ldap_MatchingRuleId(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) {
2007   offset = dissect_ldap_LDAPString(implicit_tag, tvb, offset, actx, tree, hf_index);
2008
2009   return offset;
2010 }
2011
2012
2013
2014 static int
2015 dissect_ldap_T_dnAttributes(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) {
2016 #line 622 "../../asn1/ldap/ldap.cnf"
2017         gboolean val;
2018
2019 offset = dissect_ber_boolean(implicit_tag, actx, tree, tvb, offset, hf_index, &val);
2020
2021
2022                 matching_rule_dnattr = val;
2023
2024
2025
2026
2027   return offset;
2028 }
2029
2030
2031 static const ber_sequence_t MatchingRuleAssertion_sequence[] = {
2032   { &hf_ldap_matchingRule   , BER_CLASS_CON, 1, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_ldap_MatchingRuleId },
2033   { &hf_ldap_type           , BER_CLASS_CON, 2, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_ldap_AttributeDescription },
2034   { &hf_ldap_matchValue     , BER_CLASS_CON, 3, BER_FLAGS_IMPLTAG, dissect_ldap_AssertionValue },
2035   { &hf_ldap_dnAttributes   , BER_CLASS_CON, 4, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_ldap_T_dnAttributes },
2036   { NULL, 0, 0, 0, NULL }
2037 };
2038
2039 static int
2040 dissect_ldap_MatchingRuleAssertion(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) {
2041   offset = dissect_ber_sequence(implicit_tag, actx, tree, tvb, offset,
2042                                    MatchingRuleAssertion_sequence, hf_index, ett_ldap_MatchingRuleAssertion);
2043
2044   return offset;
2045 }
2046
2047
2048
2049 static int
2050 dissect_ldap_T_extensibleMatch(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) {
2051 #line 631 "../../asn1/ldap/ldap.cnf"
2052         attr_type=NULL;
2053         matching_rule_string=NULL;
2054         ldapvalue_string=NULL;
2055         matching_rule_dnattr=FALSE;
2056
2057
2058   offset = dissect_ldap_MatchingRuleAssertion(implicit_tag, tvb, offset, actx, tree, hf_index);
2059
2060 #line 637 "../../asn1/ldap/ldap.cnf"
2061         Filter_string=ep_strdup_printf("(%s:%s%s%s=%s)",
2062                                         (attr_type?attr_type:""),
2063                                         (matching_rule_dnattr?"dn:":""),
2064                                         (matching_rule_string?matching_rule_string:""),
2065                                         (matching_rule_string?":":""),
2066                                         string_or_null(ldapvalue_string));
2067
2068
2069   return offset;
2070 }
2071
2072
2073 static const value_string ldap_Filter_vals[] = {
2074   {   0, "and" },
2075   {   1, "or" },
2076   {   2, "not" },
2077   {   3, "equalityMatch" },
2078   {   4, "substrings" },
2079   {   5, "greaterOrEqual" },
2080   {   6, "lessOrEqual" },
2081   {   7, "present" },
2082   {   8, "approxMatch" },
2083   {   9, "extensibleMatch" },
2084   { 0, NULL }
2085 };
2086
2087 static const ber_choice_t Filter_choice[] = {
2088   {   0, &hf_ldap_and            , BER_CLASS_CON, 0, BER_FLAGS_IMPLTAG, dissect_ldap_T_and },
2089   {   1, &hf_ldap_or             , BER_CLASS_CON, 1, BER_FLAGS_IMPLTAG, dissect_ldap_T_or },
2090   {   2, &hf_ldap_not            , BER_CLASS_CON, 2, BER_FLAGS_IMPLTAG, dissect_ldap_T_not },
2091   {   3, &hf_ldap_equalityMatch  , BER_CLASS_CON, 3, BER_FLAGS_IMPLTAG, dissect_ldap_T_equalityMatch },
2092   {   4, &hf_ldap_substrings     , BER_CLASS_CON, 4, BER_FLAGS_IMPLTAG, dissect_ldap_SubstringFilter },
2093   {   5, &hf_ldap_greaterOrEqual , BER_CLASS_CON, 5, BER_FLAGS_IMPLTAG, dissect_ldap_T_greaterOrEqual },
2094   {   6, &hf_ldap_lessOrEqual    , BER_CLASS_CON, 6, BER_FLAGS_IMPLTAG, dissect_ldap_T_lessOrEqual },
2095   {   7, &hf_ldap_present        , BER_CLASS_CON, 7, BER_FLAGS_IMPLTAG, dissect_ldap_T_present },
2096   {   8, &hf_ldap_approxMatch    , BER_CLASS_CON, 8, BER_FLAGS_IMPLTAG, dissect_ldap_T_approxMatch },
2097   {   9, &hf_ldap_extensibleMatch, BER_CLASS_CON, 9, BER_FLAGS_IMPLTAG, dissect_ldap_T_extensibleMatch },
2098   { 0, NULL, 0, 0, 0, NULL }
2099 };
2100
2101 static int
2102 dissect_ldap_Filter(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) {
2103 #line 681 "../../asn1/ldap/ldap.cnf"
2104         proto_tree *tr=NULL;
2105         proto_item *it=NULL;
2106         attributedesc_string=NULL;
2107
2108         if (Filter_length++ > MAX_FILTER_LEN) {
2109                 expert_add_info_format(actx->pinfo, tree, PI_UNDECODED, PI_ERROR, "Filter length exceeds %u. Giving up.", MAX_FILTER_LEN);
2110                 THROW(ReportedBoundsError);
2111         }
2112
2113         if (Filter_elements++ > MAX_FILTER_ELEMENTS) {
2114                 expert_add_info_format(actx->pinfo, tree, PI_UNDECODED, PI_ERROR, "Found more than %u filter elements. Giving up.", MAX_FILTER_ELEMENTS);
2115                 THROW(ReportedBoundsError);
2116         }
2117
2118         if(tree){
2119                 it=proto_tree_add_text(tree, tvb, offset, tvb_length_remaining(tvb, offset), "Filter: ");
2120                 tr=proto_item_add_subtree(it, ett_ldap_Filter);
2121                 tree = tr;
2122         }
2123   offset = dissect_ber_choice(actx, tree, tvb, offset,
2124                                  Filter_choice, hf_index, ett_ldap_Filter,
2125                                  NULL);
2126
2127         if(Filter_string)
2128                 proto_item_append_text(it, "%s", string_or_null(Filter_string));
2129
2130
2131
2132   return offset;
2133 }
2134
2135
2136
2137 static int
2138 dissect_ldap_T_filter(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) {
2139 #line 529 "../../asn1/ldap/ldap.cnf"
2140         Filter_string=NULL;
2141         Filter_elements = 0;
2142         Filter_length = 0;
2143
2144
2145   offset = dissect_ldap_Filter(implicit_tag, tvb, offset, actx, tree, hf_index);
2146
2147 #line 534 "../../asn1/ldap/ldap.cnf"
2148         Filter_string=NULL;
2149         and_filter_string=NULL;
2150         Filter_elements = 0;
2151         Filter_length = 0;
2152
2153
2154   return offset;
2155 }
2156
2157
2158 static const ber_sequence_t AttributeDescriptionList_sequence_of[1] = {
2159   { &hf_ldap_AttributeDescriptionList_item, BER_CLASS_UNI, BER_UNI_TAG_OCTETSTRING, BER_FLAGS_NOOWNTAG, dissect_ldap_AttributeDescription },
2160 };
2161
2162 static int
2163 dissect_ldap_AttributeDescriptionList(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) {
2164   offset = dissect_ber_sequence_of(implicit_tag, actx, tree, tvb, offset,
2165                                       AttributeDescriptionList_sequence_of, hf_index, ett_ldap_AttributeDescriptionList);
2166
2167   return offset;
2168 }
2169
2170
2171 static const ber_sequence_t SearchRequest_U_sequence[] = {
2172   { &hf_ldap_baseObject     , BER_CLASS_UNI, BER_UNI_TAG_OCTETSTRING, BER_FLAGS_NOOWNTAG, dissect_ldap_LDAPDN },
2173   { &hf_ldap_scope          , BER_CLASS_UNI, BER_UNI_TAG_ENUMERATED, BER_FLAGS_NOOWNTAG, dissect_ldap_T_scope },
2174   { &hf_ldap_derefAliases   , BER_CLASS_UNI, BER_UNI_TAG_ENUMERATED, BER_FLAGS_NOOWNTAG, dissect_ldap_T_derefAliases },
2175   { &hf_ldap_sizeLimit      , BER_CLASS_UNI, BER_UNI_TAG_INTEGER, BER_FLAGS_NOOWNTAG, dissect_ldap_INTEGER_0_maxInt },
2176   { &hf_ldap_timeLimit      , BER_CLASS_UNI, BER_UNI_TAG_INTEGER, BER_FLAGS_NOOWNTAG, dissect_ldap_INTEGER_0_maxInt },
2177   { &hf_ldap_typesOnly      , BER_CLASS_UNI, BER_UNI_TAG_BOOLEAN, BER_FLAGS_NOOWNTAG, dissect_ldap_BOOLEAN },
2178   { &hf_ldap_filter         , BER_CLASS_ANY/*choice*/, -1/*choice*/, BER_FLAGS_NOOWNTAG|BER_FLAGS_NOTCHKTAG, dissect_ldap_T_filter },
2179   { &hf_ldap_searchRequest_attributes, BER_CLASS_UNI, BER_UNI_TAG_SEQUENCE, BER_FLAGS_NOOWNTAG, dissect_ldap_AttributeDescriptionList },
2180   { NULL, 0, 0, 0, NULL }
2181 };
2182
2183 static int
2184 dissect_ldap_SearchRequest_U(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) {
2185   offset = dissect_ber_sequence(implicit_tag, actx, tree, tvb, offset,
2186                                    SearchRequest_U_sequence, hf_index, ett_ldap_SearchRequest_U);
2187
2188   return offset;
2189 }
2190
2191
2192
2193 static int
2194 dissect_ldap_SearchRequest(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) {
2195   offset = dissect_ber_tagged_type(implicit_tag, actx, tree, tvb, offset,
2196                                       hf_index, BER_CLASS_APP, 3, TRUE, dissect_ldap_SearchRequest_U);
2197
2198   return offset;
2199 }
2200
2201
2202
2203 static int
2204 dissect_ldap_AttributeValue(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) {
2205 #line 460 "../../asn1/ldap/ldap.cnf"
2206
2207   tvbuff_t      *next_tvb = NULL;
2208   gchar         *string;
2209   guint32       i, len;
2210   int           old_offset = offset;
2211
2212   /* attr_type, should be set before calling this function */
2213
2214   /* extract the value of the octetstring */
2215   offset = dissect_ber_octet_string(FALSE, actx, NULL, tvb, offset, hf_index, &next_tvb);
2216
2217   /* if we have an attribute type that isn't binary see if there is a better dissector */
2218   if(!attr_type || !next_tvb || !dissector_try_string(ldap_name_dissector_table, attr_type, next_tvb, actx->pinfo, tree)) {
2219         offset = old_offset;
2220
2221         /* do the default thing */
2222           offset = dissect_ber_octet_string(implicit_tag, actx, tree, tvb, offset, hf_index,
2223                                        NULL);
2224
2225
2226   }
2227
2228   len = tvb_length_remaining(next_tvb, 0);
2229
2230   for(i = 0; i < len; i++)
2231     if(!g_ascii_isprint(tvb_get_guint8(next_tvb, i)))
2232       break;
2233
2234   if(i == len) {
2235     string = tvb_get_ephemeral_string(next_tvb, 0, tvb_length_remaining(next_tvb, 0));
2236
2237
2238     proto_item_set_text(actx->created_item, "%s", string);
2239
2240   }
2241
2242
2243
2244   return offset;
2245 }
2246
2247
2248 static const ber_sequence_t SET_OF_AttributeValue_set_of[1] = {
2249   { &hf_ldap_vals_item      , BER_CLASS_UNI, BER_UNI_TAG_OCTETSTRING, BER_FLAGS_NOOWNTAG, dissect_ldap_AttributeValue },
2250 };
2251
2252 static int
2253 dissect_ldap_SET_OF_AttributeValue(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) {
2254   offset = dissect_ber_set_of(implicit_tag, actx, tree, tvb, offset,
2255                                  SET_OF_AttributeValue_set_of, hf_index, ett_ldap_SET_OF_AttributeValue);
2256
2257   return offset;
2258 }
2259
2260
2261 static const ber_sequence_t PartialAttributeList_item_sequence[] = {
2262   { &hf_ldap_type           , BER_CLASS_UNI, BER_UNI_TAG_OCTETSTRING, BER_FLAGS_NOOWNTAG, dissect_ldap_AttributeDescription },
2263   { &hf_ldap_vals           , BER_CLASS_UNI, BER_UNI_TAG_SET, BER_FLAGS_NOOWNTAG, dissect_ldap_SET_OF_AttributeValue },
2264   { NULL, 0, 0, 0, NULL }
2265 };
2266
2267 static int
2268 dissect_ldap_PartialAttributeList_item(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) {
2269   offset = dissect_ber_sequence(implicit_tag, actx, tree, tvb, offset,
2270                                    PartialAttributeList_item_sequence, hf_index, ett_ldap_PartialAttributeList_item);
2271
2272   return offset;
2273 }
2274
2275
2276 static const ber_sequence_t PartialAttributeList_sequence_of[1] = {
2277   { &hf_ldap_PartialAttributeList_item, BER_CLASS_UNI, BER_UNI_TAG_SEQUENCE, BER_FLAGS_NOOWNTAG, dissect_ldap_PartialAttributeList_item },
2278 };
2279
2280 static int
2281 dissect_ldap_PartialAttributeList(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) {
2282   offset = dissect_ber_sequence_of(implicit_tag, actx, tree, tvb, offset,
2283                                       PartialAttributeList_sequence_of, hf_index, ett_ldap_PartialAttributeList);
2284
2285   return offset;
2286 }
2287
2288
2289 static const ber_sequence_t SearchResultEntry_U_sequence[] = {
2290   { &hf_ldap_objectName     , BER_CLASS_UNI, BER_UNI_TAG_OCTETSTRING, BER_FLAGS_NOOWNTAG, dissect_ldap_LDAPDN },
2291   { &hf_ldap_searchResultEntry_attributes, BER_CLASS_UNI, BER_UNI_TAG_SEQUENCE, BER_FLAGS_NOOWNTAG, dissect_ldap_PartialAttributeList },
2292   { NULL, 0, 0, 0, NULL }
2293 };
2294
2295 static int
2296 dissect_ldap_SearchResultEntry_U(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) {
2297   offset = dissect_ber_sequence(implicit_tag, actx, tree, tvb, offset,
2298                                    SearchResultEntry_U_sequence, hf_index, ett_ldap_SearchResultEntry_U);
2299
2300   return offset;
2301 }
2302
2303
2304
2305 static int
2306 dissect_ldap_SearchResultEntry(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) {
2307   offset = dissect_ber_tagged_type(implicit_tag, actx, tree, tvb, offset,
2308                                       hf_index, BER_CLASS_APP, 4, TRUE, dissect_ldap_SearchResultEntry_U);
2309
2310   return offset;
2311 }
2312
2313
2314 static const value_string ldap_T_resultCode_vals[] = {
2315   {   0, "success" },
2316   {   1, "operationsError" },
2317   {   2, "protocolError" },
2318   {   3, "timeLimitExceeded" },
2319   {   4, "sizeLimitExceeded" },
2320   {   5, "compareFalse" },
2321   {   6, "compareTrue" },
2322   {   7, "authMethodNotSupported" },
2323   {   8, "strongAuthRequired" },
2324   {  10, "referral" },
2325   {  11, "adminLimitExceeded" },
2326   {  12, "unavailableCriticalExtension" },
2327   {  13, "confidentialityRequired" },
2328   {  14, "saslBindInProgress" },
2329   {  16, "noSuchAttribute" },
2330   {  17, "undefinedAttributeType" },
2331   {  18, "inappropriateMatching" },
2332   {  19, "constraintViolation" },
2333   {  20, "attributeOrValueExists" },
2334   {  21, "invalidAttributeSyntax" },
2335   {  32, "noSuchObject" },
2336   {  33, "aliasProblem" },
2337   {  34, "invalidDNSyntax" },
2338   {  36, "aliasDereferencingProblem" },
2339   {  48, "inappropriateAuthentication" },
2340   {  49, "invalidCredentials" },
2341   {  50, "insufficientAccessRights" },
2342   {  51, "busy" },
2343   {  52, "unavailable" },
2344   {  53, "unwillingToPerform" },
2345   {  54, "loopDetect" },
2346   {  64, "namingViolation" },
2347   {  65, "objectClassViolation" },
2348   {  66, "notAllowedOnNonLeaf" },
2349   {  67, "notAllowedOnRDN" },
2350   {  68, "entryAlreadyExists" },
2351   {  69, "objectClassModsProhibited" },
2352   {  71, "affectsMultipleDSAs" },
2353   {  80, "other" },
2354   { 118, "canceled" },
2355   { 119, "noSuchOperation" },
2356   { 120, "tooLate" },
2357   { 121, "cannotCancel" },
2358   { 0, NULL }
2359 };
2360
2361
2362 static int
2363 dissect_ldap_T_resultCode(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) {
2364 #line 428 "../../asn1/ldap/ldap.cnf"
2365
2366   const gchar *valstr;
2367
2368     offset = dissect_ber_integer(implicit_tag, actx, tree, tvb, offset, hf_index,
2369                                   &result);
2370
2371
2372   ldap_do_protocolop(actx->pinfo);
2373
2374   valstr = val_to_str(result, ldap_T_resultCode_vals, "Unknown result(%u)");
2375
2376   col_append_fstr(actx->pinfo->cinfo, COL_INFO, "%s ", valstr);
2377
2378   if(ldm_tree)
2379     proto_item_append_text(ldm_tree, " %s", valstr);
2380
2381
2382
2383
2384   return offset;
2385 }
2386
2387
2388 static const ber_sequence_t LDAPResult_sequence[] = {
2389   { &hf_ldap_resultCode     , BER_CLASS_UNI, BER_UNI_TAG_ENUMERATED, BER_FLAGS_NOOWNTAG, dissect_ldap_T_resultCode },
2390   { &hf_ldap_matchedDN      , BER_CLASS_UNI, BER_UNI_TAG_OCTETSTRING, BER_FLAGS_NOOWNTAG, dissect_ldap_LDAPDN },
2391   { &hf_ldap_errorMessage   , BER_CLASS_UNI, BER_UNI_TAG_OCTETSTRING, BER_FLAGS_NOOWNTAG, dissect_ldap_ErrorMessage },
2392   { &hf_ldap_referral       , BER_CLASS_CON, 3, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_ldap_Referral },
2393   { NULL, 0, 0, 0, NULL }
2394 };
2395
2396 static int
2397 dissect_ldap_LDAPResult(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) {
2398   offset = dissect_ber_sequence(implicit_tag, actx, tree, tvb, offset,
2399                                    LDAPResult_sequence, hf_index, ett_ldap_LDAPResult);
2400
2401   return offset;
2402 }
2403
2404
2405
2406 static int
2407 dissect_ldap_SearchResultDone(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) {
2408   offset = dissect_ber_tagged_type(implicit_tag, actx, tree, tvb, offset,
2409                                       hf_index, BER_CLASS_APP, 5, TRUE, dissect_ldap_LDAPResult);
2410
2411   return offset;
2412 }
2413
2414
2415 static const ber_sequence_t SEQUENCE_OF_LDAPURL_sequence_of[1] = {
2416   { &hf_ldap__untag_item    , BER_CLASS_UNI, BER_UNI_TAG_OCTETSTRING, BER_FLAGS_NOOWNTAG, dissect_ldap_LDAPURL },
2417 };
2418
2419 static int
2420 dissect_ldap_SEQUENCE_OF_LDAPURL(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) {
2421   offset = dissect_ber_sequence_of(implicit_tag, actx, tree, tvb, offset,
2422                                       SEQUENCE_OF_LDAPURL_sequence_of, hf_index, ett_ldap_SEQUENCE_OF_LDAPURL);
2423
2424   return offset;
2425 }
2426
2427
2428
2429 static int
2430 dissect_ldap_SearchResultReference(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) {
2431 #line 822 "../../asn1/ldap/ldap.cnf"
2432
2433    offset = dissect_ber_tagged_type(implicit_tag, actx, tree, tvb, offset,
2434                                       hf_index, BER_CLASS_APP, 19, TRUE, dissect_ldap_SEQUENCE_OF_LDAPURL);
2435
2436
2437  ldap_do_protocolop(actx->pinfo);
2438
2439
2440
2441
2442   return offset;
2443 }
2444
2445
2446 static const value_string ldap_T_operation_vals[] = {
2447   {   0, "add" },
2448   {   1, "delete" },
2449   {   2, "replace" },
2450   { 0, NULL }
2451 };
2452
2453
2454 static int
2455 dissect_ldap_T_operation(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) {
2456   offset = dissect_ber_integer(implicit_tag, actx, tree, tvb, offset, hf_index,
2457                                   NULL);
2458
2459   return offset;
2460 }
2461
2462
2463 static const ber_sequence_t AttributeTypeAndValues_sequence[] = {
2464   { &hf_ldap_type           , BER_CLASS_UNI, BER_UNI_TAG_OCTETSTRING, BER_FLAGS_NOOWNTAG, dissect_ldap_AttributeDescription },
2465   { &hf_ldap_vals           , BER_CLASS_UNI, BER_UNI_TAG_SET, BER_FLAGS_NOOWNTAG, dissect_ldap_SET_OF_AttributeValue },
2466   { NULL, 0, 0, 0, NULL }
2467 };
2468
2469 static int
2470 dissect_ldap_AttributeTypeAndValues(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) {
2471   offset = dissect_ber_sequence(implicit_tag, actx, tree, tvb, offset,
2472                                    AttributeTypeAndValues_sequence, hf_index, ett_ldap_AttributeTypeAndValues);
2473
2474   return offset;
2475 }
2476
2477
2478 static const ber_sequence_t T_modifyRequest_modification_item_sequence[] = {
2479   { &hf_ldap_operation      , BER_CLASS_UNI, BER_UNI_TAG_ENUMERATED, BER_FLAGS_NOOWNTAG, dissect_ldap_T_operation },
2480   { &hf_ldap_modification   , BER_CLASS_UNI, BER_UNI_TAG_SEQUENCE, BER_FLAGS_NOOWNTAG, dissect_ldap_AttributeTypeAndValues },
2481   { NULL, 0, 0, 0, NULL }
2482 };
2483
2484 static int
2485 dissect_ldap_T_modifyRequest_modification_item(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) {
2486   offset = dissect_ber_sequence(implicit_tag, actx, tree, tvb, offset,
2487                                    T_modifyRequest_modification_item_sequence, hf_index, ett_ldap_T_modifyRequest_modification_item);
2488
2489   return offset;
2490 }
2491
2492
2493 static const ber_sequence_t ModifyRequest_modification_sequence_of[1] = {
2494   { &hf_ldap_modifyRequest_modification_item, BER_CLASS_UNI, BER_UNI_TAG_SEQUENCE, BER_FLAGS_NOOWNTAG, dissect_ldap_T_modifyRequest_modification_item },
2495 };
2496
2497 static int
2498 dissect_ldap_ModifyRequest_modification(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) {
2499   offset = dissect_ber_sequence_of(implicit_tag, actx, tree, tvb, offset,
2500                                       ModifyRequest_modification_sequence_of, hf_index, ett_ldap_ModifyRequest_modification);
2501
2502   return offset;
2503 }
2504
2505
2506 static const ber_sequence_t ModifyRequest_U_sequence[] = {
2507   { &hf_ldap_object         , BER_CLASS_UNI, BER_UNI_TAG_OCTETSTRING, BER_FLAGS_NOOWNTAG, dissect_ldap_LDAPDN },
2508   { &hf_ldap_modifyRequest_modification, BER_CLASS_UNI, BER_UNI_TAG_SEQUENCE, BER_FLAGS_NOOWNTAG, dissect_ldap_ModifyRequest_modification },
2509   { NULL, 0, 0, 0, NULL }
2510 };
2511
2512 static int
2513 dissect_ldap_ModifyRequest_U(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) {
2514   offset = dissect_ber_sequence(implicit_tag, actx, tree, tvb, offset,
2515                                    ModifyRequest_U_sequence, hf_index, ett_ldap_ModifyRequest_U);
2516
2517   return offset;
2518 }
2519
2520
2521
2522 static int
2523 dissect_ldap_ModifyRequest(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) {
2524   offset = dissect_ber_tagged_type(implicit_tag, actx, tree, tvb, offset,
2525                                       hf_index, BER_CLASS_APP, 6, TRUE, dissect_ldap_ModifyRequest_U);
2526
2527   return offset;
2528 }
2529
2530
2531
2532 static int
2533 dissect_ldap_ModifyResponse(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) {
2534   offset = dissect_ber_tagged_type(implicit_tag, actx, tree, tvb, offset,
2535                                       hf_index, BER_CLASS_APP, 7, TRUE, dissect_ldap_LDAPResult);
2536
2537   return offset;
2538 }
2539
2540
2541 static const ber_sequence_t AttributeList_item_sequence[] = {
2542   { &hf_ldap_type           , BER_CLASS_UNI, BER_UNI_TAG_OCTETSTRING, BER_FLAGS_NOOWNTAG, dissect_ldap_AttributeDescription },
2543   { &hf_ldap_vals           , BER_CLASS_UNI, BER_UNI_TAG_SET, BER_FLAGS_NOOWNTAG, dissect_ldap_SET_OF_AttributeValue },
2544   { NULL, 0, 0, 0, NULL }
2545 };
2546
2547 static int
2548 dissect_ldap_AttributeList_item(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) {
2549   offset = dissect_ber_sequence(implicit_tag, actx, tree, tvb, offset,
2550                                    AttributeList_item_sequence, hf_index, ett_ldap_AttributeList_item);
2551
2552   return offset;
2553 }
2554
2555
2556 static const ber_sequence_t AttributeList_sequence_of[1] = {
2557   { &hf_ldap_AttributeList_item, BER_CLASS_UNI, BER_UNI_TAG_SEQUENCE, BER_FLAGS_NOOWNTAG, dissect_ldap_AttributeList_item },
2558 };
2559
2560 static int
2561 dissect_ldap_AttributeList(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) {
2562   offset = dissect_ber_sequence_of(implicit_tag, actx, tree, tvb, offset,
2563                                       AttributeList_sequence_of, hf_index, ett_ldap_AttributeList);
2564
2565   return offset;
2566 }
2567
2568
2569 static const ber_sequence_t AddRequest_U_sequence[] = {
2570   { &hf_ldap_entry          , BER_CLASS_UNI, BER_UNI_TAG_OCTETSTRING, BER_FLAGS_NOOWNTAG, dissect_ldap_LDAPDN },
2571   { &hf_ldap_attributes     , BER_CLASS_UNI, BER_UNI_TAG_SEQUENCE, BER_FLAGS_NOOWNTAG, dissect_ldap_AttributeList },
2572   { NULL, 0, 0, 0, NULL }
2573 };
2574
2575 static int
2576 dissect_ldap_AddRequest_U(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) {
2577   offset = dissect_ber_sequence(implicit_tag, actx, tree, tvb, offset,
2578                                    AddRequest_U_sequence, hf_index, ett_ldap_AddRequest_U);
2579
2580   return offset;
2581 }
2582
2583
2584
2585 static int
2586 dissect_ldap_AddRequest(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) {
2587   offset = dissect_ber_tagged_type(implicit_tag, actx, tree, tvb, offset,
2588                                       hf_index, BER_CLASS_APP, 8, TRUE, dissect_ldap_AddRequest_U);
2589
2590   return offset;
2591 }
2592
2593
2594
2595 static int
2596 dissect_ldap_AddResponse(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) {
2597   offset = dissect_ber_tagged_type(implicit_tag, actx, tree, tvb, offset,
2598                                       hf_index, BER_CLASS_APP, 9, TRUE, dissect_ldap_LDAPResult);
2599
2600   return offset;
2601 }
2602
2603
2604
2605 static int
2606 dissect_ldap_DelRequest(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) {
2607   offset = dissect_ber_tagged_type(implicit_tag, actx, tree, tvb, offset,
2608                                       hf_index, BER_CLASS_APP, 10, TRUE, dissect_ldap_LDAPDN);
2609
2610   return offset;
2611 }
2612
2613
2614
2615 static int
2616 dissect_ldap_DelResponse(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) {
2617   offset = dissect_ber_tagged_type(implicit_tag, actx, tree, tvb, offset,
2618                                       hf_index, BER_CLASS_APP, 11, TRUE, dissect_ldap_LDAPResult);
2619
2620   return offset;
2621 }
2622
2623
2624
2625 static int
2626 dissect_ldap_RelativeLDAPDN(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) {
2627   offset = dissect_ldap_LDAPString(implicit_tag, tvb, offset, actx, tree, hf_index);
2628
2629   return offset;
2630 }
2631
2632
2633 static const ber_sequence_t ModifyDNRequest_U_sequence[] = {
2634   { &hf_ldap_entry          , BER_CLASS_UNI, BER_UNI_TAG_OCTETSTRING, BER_FLAGS_NOOWNTAG, dissect_ldap_LDAPDN },
2635   { &hf_ldap_newrdn         , BER_CLASS_UNI, BER_UNI_TAG_OCTETSTRING, BER_FLAGS_NOOWNTAG, dissect_ldap_RelativeLDAPDN },
2636   { &hf_ldap_deleteoldrdn   , BER_CLASS_UNI, BER_UNI_TAG_BOOLEAN, BER_FLAGS_NOOWNTAG, dissect_ldap_BOOLEAN },
2637   { &hf_ldap_newSuperior    , BER_CLASS_CON, 0, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_ldap_LDAPDN },
2638   { NULL, 0, 0, 0, NULL }
2639 };
2640
2641 static int
2642 dissect_ldap_ModifyDNRequest_U(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) {
2643   offset = dissect_ber_sequence(implicit_tag, actx, tree, tvb, offset,
2644                                    ModifyDNRequest_U_sequence, hf_index, ett_ldap_ModifyDNRequest_U);
2645
2646   return offset;
2647 }
2648
2649
2650
2651 static int
2652 dissect_ldap_ModifyDNRequest(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) {
2653   offset = dissect_ber_tagged_type(implicit_tag, actx, tree, tvb, offset,
2654                                       hf_index, BER_CLASS_APP, 12, TRUE, dissect_ldap_ModifyDNRequest_U);
2655
2656   return offset;
2657 }
2658
2659
2660
2661 static int
2662 dissect_ldap_ModifyDNResponse(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) {
2663   offset = dissect_ber_tagged_type(implicit_tag, actx, tree, tvb, offset,
2664                                       hf_index, BER_CLASS_APP, 13, TRUE, dissect_ldap_LDAPResult);
2665
2666   return offset;
2667 }
2668
2669
2670 static const ber_sequence_t CompareRequest_U_sequence[] = {
2671   { &hf_ldap_entry          , BER_CLASS_UNI, BER_UNI_TAG_OCTETSTRING, BER_FLAGS_NOOWNTAG, dissect_ldap_LDAPDN },
2672   { &hf_ldap_ava            , BER_CLASS_UNI, BER_UNI_TAG_SEQUENCE, BER_FLAGS_NOOWNTAG, dissect_ldap_AttributeValueAssertion },
2673   { NULL, 0, 0, 0, NULL }
2674 };
2675
2676 static int
2677 dissect_ldap_CompareRequest_U(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) {
2678   offset = dissect_ber_sequence(implicit_tag, actx, tree, tvb, offset,
2679                                    CompareRequest_U_sequence, hf_index, ett_ldap_CompareRequest_U);
2680
2681   return offset;
2682 }
2683
2684
2685
2686 static int
2687 dissect_ldap_CompareRequest(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) {
2688   offset = dissect_ber_tagged_type(implicit_tag, actx, tree, tvb, offset,
2689                                       hf_index, BER_CLASS_APP, 14, TRUE, dissect_ldap_CompareRequest_U);
2690
2691   return offset;
2692 }
2693
2694
2695
2696 static int
2697 dissect_ldap_CompareResponse(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) {
2698   offset = dissect_ber_tagged_type(implicit_tag, actx, tree, tvb, offset,
2699                                       hf_index, BER_CLASS_APP, 15, TRUE, dissect_ldap_LDAPResult);
2700
2701   return offset;
2702 }
2703
2704
2705
2706 static int
2707 dissect_ldap_AbandonRequest(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) {
2708 #line 829 "../../asn1/ldap/ldap.cnf"
2709
2710    offset = dissect_ber_tagged_type(implicit_tag, actx, tree, tvb, offset,
2711                                       hf_index, BER_CLASS_APP, 16, TRUE, dissect_ldap_MessageID);
2712
2713
2714  ldap_do_protocolop(actx->pinfo);
2715
2716
2717
2718   return offset;
2719 }
2720
2721
2722
2723 static int
2724 dissect_ldap_LDAPOID(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) {
2725 #line 54 "../../asn1/ldap/ldap.cnf"
2726
2727         tvbuff_t        *parameter_tvb;
2728         const gchar *name;
2729
2730
2731   offset = dissect_ber_octet_string(implicit_tag, actx, tree, tvb, offset, hf_index,
2732                                        &parameter_tvb);
2733
2734 #line 61 "../../asn1/ldap/ldap.cnf"
2735
2736         object_identifier_id = NULL;
2737
2738         if (!parameter_tvb)
2739                 return offset;
2740
2741         object_identifier_id = tvb_get_ephemeral_string(parameter_tvb, 0, tvb_length_remaining(parameter_tvb,0));
2742         name = oid_resolved_from_string(object_identifier_id);
2743
2744         if(name){
2745                 proto_item_append_text(actx->created_item, " (%s)", name);
2746
2747                 if((hf_index == hf_ldap_requestName) || (hf_index == hf_ldap_responseName)) {
2748                         ldap_do_protocolop(actx->pinfo);
2749                         col_append_fstr(actx->pinfo->cinfo, COL_INFO, "%s ", name);
2750                 }
2751         }
2752
2753         if(((hf_index == hf_ldap_responseName) || (hf_index == hf_ldap_requestName)) &&
2754             !strcmp(object_identifier_id, "1.3.6.1.4.1.1466.20037")) {
2755
2756                 /* we have agreed start_tls */
2757                 ldap_conv_info_t *ldap_info = NULL;
2758
2759                 ldap_info = (ldap_conv_info_t *)actx->pinfo->private_data;
2760
2761                 if(ldap_info) {
2762                         if(hf_index == hf_ldap_responseName)
2763                                 /* TLS in the next frame */
2764                                 ldap_info->start_tls_frame = (actx->pinfo->fd->num) + 1;
2765                         else
2766                                 /* remember we have asked to start_tls */
2767                                 ldap_info->start_tls_pending = TRUE;
2768                 }
2769         }
2770
2771
2772   return offset;
2773 }
2774
2775
2776
2777 static int
2778 dissect_ldap_T_requestValue(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) {
2779 #line 754 "../../asn1/ldap/ldap.cnf"
2780
2781         if((object_identifier_id != NULL) && oid_has_dissector(object_identifier_id)) {
2782                 offset = call_ber_oid_callback(object_identifier_id, tvb, offset, actx->pinfo, tree);
2783         } else {
2784                   offset = dissect_ber_octet_string(implicit_tag, actx, tree, tvb, offset, hf_index,
2785                                        NULL);
2786
2787         }
2788
2789
2790
2791   return offset;
2792 }
2793
2794
2795 static const ber_sequence_t ExtendedRequest_U_sequence[] = {
2796   { &hf_ldap_requestName    , BER_CLASS_CON, 0, BER_FLAGS_IMPLTAG, dissect_ldap_LDAPOID },
2797   { &hf_ldap_requestValue   , BER_CLASS_CON, 1, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_ldap_T_requestValue },
2798   { NULL, 0, 0, 0, NULL }
2799 };
2800
2801 static int
2802 dissect_ldap_ExtendedRequest_U(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) {
2803   offset = dissect_ber_sequence(implicit_tag, actx, tree, tvb, offset,
2804                                    ExtendedRequest_U_sequence, hf_index, ett_ldap_ExtendedRequest_U);
2805
2806   return offset;
2807 }
2808
2809
2810
2811 static int
2812 dissect_ldap_ExtendedRequest(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) {
2813   offset = dissect_ber_tagged_type(implicit_tag, actx, tree, tvb, offset,
2814                                       hf_index, BER_CLASS_APP, 23, TRUE, dissect_ldap_ExtendedRequest_U);
2815
2816   return offset;
2817 }
2818
2819
2820 static const value_string ldap_ExtendedResponse_resultCode_vals[] = {
2821   {   0, "success" },
2822   {   1, "operationsError" },
2823   {   2, "protocolError" },
2824   {   3, "timeLimitExceeded" },
2825   {   4, "sizeLimitExceeded" },
2826   {   5, "compareFalse" },
2827   {   6, "compareTrue" },
2828   {   7, "authMethodNotSupported" },
2829   {   8, "strongAuthRequired" },
2830   {  10, "referral" },
2831   {  11, "adminLimitExceeded" },
2832   {  12, "unavailableCriticalExtension" },
2833   {  13, "confidentialityRequired" },
2834   {  14, "saslBindInProgress" },
2835   {  16, "noSuchAttribute" },
2836   {  17, "undefinedAttributeType" },
2837   {  18, "inappropriateMatching" },
2838   {  19, "constraintViolation" },
2839   {  20, "attributeOrValueExists" },
2840   {  21, "invalidAttributeSyntax" },
2841   {  32, "noSuchObject" },
2842   {  33, "aliasProblem" },
2843   {  34, "invalidDNSyntax" },
2844   {  36, "aliasDereferencingProblem" },
2845   {  48, "inappropriateAuthentication" },
2846   {  49, "invalidCredentials" },
2847   {  50, "insufficientAccessRights" },
2848   {  51, "busy" },
2849   {  52, "unavailable" },
2850   {  53, "unwillingToPerform" },
2851   {  54, "loopDetect" },
2852   {  64, "namingViolation" },
2853   {  65, "objectClassViolation" },
2854   {  66, "notAllowedOnNonLeaf" },
2855   {  67, "notAllowedOnRDN" },
2856   {  68, "entryAlreadyExists" },
2857   {  69, "objectClassModsProhibited" },
2858   {  71, "affectsMultipleDSAs" },
2859   {  80, "other" },
2860   { 118, "canceled" },
2861   { 119, "noSuchOperation" },
2862   { 120, "tooLate" },
2863   { 121, "cannotCancel" },
2864   { 0, NULL }
2865 };
2866
2867
2868 static int
2869 dissect_ldap_ExtendedResponse_resultCode(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) {
2870   offset = dissect_ber_integer(implicit_tag, actx, tree, tvb, offset, hf_index,
2871                                   NULL);
2872
2873   return offset;
2874 }
2875
2876
2877
2878 static int
2879 dissect_ldap_ResponseName(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) {
2880   offset = dissect_ldap_LDAPOID(implicit_tag, tvb, offset, actx, tree, hf_index);
2881
2882   return offset;
2883 }
2884
2885
2886
2887 static int
2888 dissect_ldap_OCTET_STRING(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) {
2889   offset = dissect_ber_octet_string(implicit_tag, actx, tree, tvb, offset, hf_index,
2890                                        NULL);
2891
2892   return offset;
2893 }
2894
2895
2896 static const ber_sequence_t ExtendedResponse_U_sequence[] = {
2897   { &hf_ldap_extendedResponse_resultCode, BER_CLASS_UNI, BER_UNI_TAG_ENUMERATED, BER_FLAGS_NOOWNTAG, dissect_ldap_ExtendedResponse_resultCode },
2898   { &hf_ldap_matchedDN      , BER_CLASS_UNI, BER_UNI_TAG_OCTETSTRING, BER_FLAGS_NOOWNTAG, dissect_ldap_LDAPDN },
2899   { &hf_ldap_errorMessage   , BER_CLASS_UNI, BER_UNI_TAG_OCTETSTRING, BER_FLAGS_NOOWNTAG, dissect_ldap_ErrorMessage },
2900   { &hf_ldap_referral       , BER_CLASS_CON, 3, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_ldap_Referral },
2901   { &hf_ldap_responseName   , BER_CLASS_CON, 10, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_ldap_ResponseName },
2902   { &hf_ldap_response       , BER_CLASS_CON, 11, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_ldap_OCTET_STRING },
2903   { NULL, 0, 0, 0, NULL }
2904 };
2905
2906 static int
2907 dissect_ldap_ExtendedResponse_U(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) {
2908   offset = dissect_ber_sequence(implicit_tag, actx, tree, tvb, offset,
2909                                    ExtendedResponse_U_sequence, hf_index, ett_ldap_ExtendedResponse_U);
2910
2911   return offset;
2912 }
2913
2914
2915
2916 static int
2917 dissect_ldap_ExtendedResponse(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) {
2918   offset = dissect_ber_tagged_type(implicit_tag, actx, tree, tvb, offset,
2919                                       hf_index, BER_CLASS_APP, 24, TRUE, dissect_ldap_ExtendedResponse_U);
2920
2921   return offset;
2922 }
2923
2924
2925
2926 static int
2927 dissect_ldap_T_intermediateResponse_responseValue(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) {
2928 #line 762 "../../asn1/ldap/ldap.cnf"
2929
2930         const gchar *name;
2931
2932
2933 #line 766 "../../asn1/ldap/ldap.cnf"
2934         if(ldm_tree && object_identifier_id) {
2935                 proto_item_set_text(ldm_tree, "%s %s", "IntermediateResponse", object_identifier_id);
2936                 name = oid_resolved_from_string(object_identifier_id);
2937                 if(name)
2938                         proto_item_append_text(ldm_tree, " (%s)", name);
2939         }
2940         if((object_identifier_id != NULL) && oid_has_dissector(object_identifier_id)) {
2941                 offset = call_ber_oid_callback(object_identifier_id, tvb, offset, actx->pinfo, tree);
2942         } else {
2943                   offset = dissect_ber_octet_string(implicit_tag, actx, tree, tvb, offset, hf_index,
2944                                        NULL);
2945
2946         }
2947
2948
2949
2950   return offset;
2951 }
2952
2953
2954 static const ber_sequence_t IntermediateResponse_U_sequence[] = {
2955   { &hf_ldap_responseName   , BER_CLASS_CON, 0, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_ldap_ResponseName },
2956   { &hf_ldap_intermediateResponse_responseValue, BER_CLASS_CON, 1, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_ldap_T_intermediateResponse_responseValue },
2957   { NULL, 0, 0, 0, NULL }
2958 };
2959
2960 static int
2961 dissect_ldap_IntermediateResponse_U(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) {
2962   offset = dissect_ber_sequence(implicit_tag, actx, tree, tvb, offset,
2963                                    IntermediateResponse_U_sequence, hf_index, ett_ldap_IntermediateResponse_U);
2964
2965   return offset;
2966 }
2967
2968
2969
2970 static int
2971 dissect_ldap_IntermediateResponse(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) {
2972   offset = dissect_ber_tagged_type(implicit_tag, actx, tree, tvb, offset,
2973                                       hf_index, BER_CLASS_APP, 25, TRUE, dissect_ldap_IntermediateResponse_U);
2974
2975   return offset;
2976 }
2977
2978
2979 static const value_string ldap_ProtocolOp_vals[] = {
2980   {   0, "bindRequest" },
2981   {   1, "bindResponse" },
2982   {   2, "unbindRequest" },
2983   {   3, "searchRequest" },
2984   {   4, "searchResEntry" },
2985   {   5, "searchResDone" },
2986   {  19, "searchResRef" },
2987   {   6, "modifyRequest" },
2988   {   7, "modifyResponse" },
2989   {   8, "addRequest" },
2990   {   9, "addResponse" },
2991   {  10, "delRequest" },
2992   {  11, "delResponse" },
2993   {  12, "modDNRequest" },
2994   {  13, "modDNResponse" },
2995   {  14, "compareRequest" },
2996   {  15, "compareResponse" },
2997   {  16, "abandonRequest" },
2998   {  23, "extendedReq" },
2999   {  24, "extendedResp" },
3000   {  25, "intermediateResponse" },
3001   { 0, NULL }
3002 };
3003
3004 static const ber_choice_t ProtocolOp_choice[] = {
3005   {   0, &hf_ldap_bindRequest    , BER_CLASS_APP, 0, BER_FLAGS_NOOWNTAG, dissect_ldap_BindRequest },
3006   {   1, &hf_ldap_bindResponse   , BER_CLASS_APP, 1, BER_FLAGS_NOOWNTAG, dissect_ldap_BindResponse },
3007   {   2, &hf_ldap_unbindRequest  , BER_CLASS_APP, 2, BER_FLAGS_NOOWNTAG, dissect_ldap_UnbindRequest },
3008   {   3, &hf_ldap_searchRequest  , BER_CLASS_APP, 3, BER_FLAGS_NOOWNTAG, dissect_ldap_SearchRequest },
3009   {   4, &hf_ldap_searchResEntry , BER_CLASS_APP, 4, BER_FLAGS_NOOWNTAG, dissect_ldap_SearchResultEntry },
3010   {   5, &hf_ldap_searchResDone  , BER_CLASS_APP, 5, BER_FLAGS_NOOWNTAG, dissect_ldap_SearchResultDone },
3011   {  19, &hf_ldap_searchResRef   , BER_CLASS_APP, 19, BER_FLAGS_NOOWNTAG, dissect_ldap_SearchResultReference },
3012   {   6, &hf_ldap_modifyRequest  , BER_CLASS_APP, 6, BER_FLAGS_NOOWNTAG, dissect_ldap_ModifyRequest },
3013   {   7, &hf_ldap_modifyResponse , BER_CLASS_APP, 7, BER_FLAGS_NOOWNTAG, dissect_ldap_ModifyResponse },
3014   {   8, &hf_ldap_addRequest     , BER_CLASS_APP, 8, BER_FLAGS_NOOWNTAG, dissect_ldap_AddRequest },
3015   {   9, &hf_ldap_addResponse    , BER_CLASS_APP, 9, BER_FLAGS_NOOWNTAG, dissect_ldap_AddResponse },
3016   {  10, &hf_ldap_delRequest     , BER_CLASS_APP, 10, BER_FLAGS_NOOWNTAG, dissect_ldap_DelRequest },
3017   {  11, &hf_ldap_delResponse    , BER_CLASS_APP, 11, BER_FLAGS_NOOWNTAG, dissect_ldap_DelResponse },
3018   {  12, &hf_ldap_modDNRequest   , BER_CLASS_APP, 12, BER_FLAGS_NOOWNTAG, dissect_ldap_ModifyDNRequest },
3019   {  13, &hf_ldap_modDNResponse  , BER_CLASS_APP, 13, BER_FLAGS_NOOWNTAG, dissect_ldap_ModifyDNResponse },
3020   {  14, &hf_ldap_compareRequest , BER_CLASS_APP, 14, BER_FLAGS_NOOWNTAG, dissect_ldap_CompareRequest },
3021   {  15, &hf_ldap_compareResponse, BER_CLASS_APP, 15, BER_FLAGS_NOOWNTAG, dissect_ldap_CompareResponse },
3022   {  16, &hf_ldap_abandonRequest , BER_CLASS_APP, 16, BER_FLAGS_NOOWNTAG, dissect_ldap_AbandonRequest },
3023   {  23, &hf_ldap_extendedReq    , BER_CLASS_APP, 23, BER_FLAGS_NOOWNTAG, dissect_ldap_ExtendedRequest },
3024   {  24, &hf_ldap_extendedResp   , BER_CLASS_APP, 24, BER_FLAGS_NOOWNTAG, dissect_ldap_ExtendedResponse },
3025   {  25, &hf_ldap_intermediateResponse, BER_CLASS_APP, 25, BER_FLAGS_NOOWNTAG, dissect_ldap_IntermediateResponse },
3026   { 0, NULL, 0, 0, 0, NULL }
3027 };
3028
3029 static int
3030 dissect_ldap_ProtocolOp(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) {
3031 #line 106 "../../asn1/ldap/ldap.cnf"
3032
3033   ldap_call_response_t *lcrp;
3034   ldap_conv_info_t *ldap_info = (ldap_conv_info_t *)actx->pinfo->private_data;
3035   do_protocolop = TRUE;
3036
3037
3038   offset = dissect_ber_choice(actx, tree, tvb, offset,
3039                                  ProtocolOp_choice, hf_index, ett_ldap_ProtocolOp,
3040                                  &ProtocolOp);
3041
3042 #line 112 "../../asn1/ldap/ldap.cnf"
3043
3044   if (ProtocolOp == -1) {
3045     return offset;
3046   }
3047
3048   /* ProtocolOp is the index, not the tag so convert it to the tag value */
3049   ProtocolOp = ldap_ProtocolOp_vals[ProtocolOp].value;
3050
3051   lcrp=ldap_match_call_response(tvb, actx->pinfo, tree, MessageID, ProtocolOp);
3052   if(lcrp){
3053     tap_queue_packet(ldap_tap, actx->pinfo, lcrp);
3054   }
3055
3056   /* XXX: the count will not work if the results span multiple TCP packets */
3057
3058   if(ldap_info && tree) { /* only count once - on tree pass */
3059     switch(ProtocolOp) {
3060
3061     case LDAP_RES_SEARCH_ENTRY:
3062         ldap_info->num_results++;
3063
3064         proto_item_append_text(tree, " [%d result%s]",
3065                         ldap_info->num_results, ldap_info->num_results == 1 ? "" : "s");
3066
3067         break;
3068
3069     case LDAP_RES_SEARCH_RESULT:
3070
3071         col_append_fstr(actx->pinfo->cinfo, COL_INFO, " [%d result%s]",
3072                         ldap_info->num_results, ldap_info->num_results == 1 ? "" : "s");
3073
3074         proto_item_append_text(tree, " [%d result%s]",
3075                         ldap_info->num_results, ldap_info->num_results == 1 ? "" : "s");
3076
3077         ldap_info->num_results = 0;
3078         break;
3079      default:
3080         break;
3081     }
3082   }
3083
3084   if(ldap_info && (ProtocolOp == LDAP_RES_EXTENDED)) {
3085         /* this is an extend result */
3086
3087         if(ldap_info->start_tls_pending && !ldap_info->start_tls_frame) {
3088                 /* XXX: some directories do not correctly return the responseName in the extendedResponse so we don't know start_tls has been negotiated */
3089
3090                 col_append_str(actx->pinfo->cinfo, COL_INFO, "[LDAP_START_TLS_OID responseName missing] ");
3091                 ldap_info->start_tls_frame = (actx->pinfo->fd->num) + 1;
3092         }
3093
3094         ldap_info->start_tls_pending = FALSE;
3095   }
3096
3097
3098   return offset;
3099 }
3100
3101
3102
3103 static int
3104 dissect_ldap_ControlType(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) {
3105   offset = dissect_ldap_LDAPOID(implicit_tag, tvb, offset, actx, tree, hf_index);
3106
3107   return offset;
3108 }
3109
3110
3111
3112 static int
3113 dissect_ldap_T_controlValue(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) {
3114 #line 735 "../../asn1/ldap/ldap.cnf"
3115         gint8 class;
3116         gboolean pc, ind;
3117         gint32 tag;
3118         guint32 len;
3119
3120         if((object_identifier_id != NULL) && oid_has_dissector(object_identifier_id)) {
3121                 /* remove the OCTET STRING encoding */
3122                 offset=dissect_ber_identifier(actx->pinfo, NULL, tvb, offset, &class, &pc, &tag);
3123                 offset=dissect_ber_length(actx->pinfo, NULL, tvb, offset, &len, &ind);
3124
3125                 call_ber_oid_callback(object_identifier_id, tvb, offset, actx->pinfo, tree);
3126
3127                 offset += len;
3128         } else {
3129                   offset = dissect_ber_octet_string(implicit_tag, actx, tree, tvb, offset, hf_index,
3130                                        NULL);
3131
3132         }
3133
3134
3135
3136
3137   return offset;
3138 }
3139
3140
3141 static const ber_sequence_t Control_sequence[] = {
3142   { &hf_ldap_controlType    , BER_CLASS_UNI, BER_UNI_TAG_OCTETSTRING, BER_FLAGS_NOOWNTAG, dissect_ldap_ControlType },
3143   { &hf_ldap_criticality    , BER_CLASS_UNI, BER_UNI_TAG_BOOLEAN, BER_FLAGS_OPTIONAL|BER_FLAGS_NOOWNTAG, dissect_ldap_BOOLEAN },
3144   { &hf_ldap_controlValue   , BER_CLASS_UNI, BER_UNI_TAG_OCTETSTRING, BER_FLAGS_OPTIONAL|BER_FLAGS_NOOWNTAG, dissect_ldap_T_controlValue },
3145   { NULL, 0, 0, 0, NULL }
3146 };
3147
3148 static int
3149 dissect_ldap_Control(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) {
3150   offset = dissect_ber_sequence(implicit_tag, actx, tree, tvb, offset,
3151                                    Control_sequence, hf_index, ett_ldap_Control);
3152
3153   return offset;
3154 }
3155
3156
3157 static const ber_sequence_t Controls_sequence_of[1] = {
3158   { &hf_ldap_Controls_item  , BER_CLASS_UNI, BER_UNI_TAG_SEQUENCE, BER_FLAGS_NOOWNTAG, dissect_ldap_Control },
3159 };
3160
3161 static int
3162 dissect_ldap_Controls(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) {
3163   offset = dissect_ber_sequence_of(implicit_tag, actx, tree, tvb, offset,
3164                                       Controls_sequence_of, hf_index, ett_ldap_Controls);
3165
3166   return offset;
3167 }
3168
3169
3170 static const ber_sequence_t LDAPMessage_sequence[] = {
3171   { &hf_ldap_messageID      , BER_CLASS_UNI, BER_UNI_TAG_INTEGER, BER_FLAGS_NOOWNTAG, dissect_ldap_MessageID },
3172   { &hf_ldap_protocolOp     , BER_CLASS_ANY/*choice*/, -1/*choice*/, BER_FLAGS_NOOWNTAG|BER_FLAGS_NOTCHKTAG, dissect_ldap_ProtocolOp },
3173   { &hf_ldap_controls       , BER_CLASS_CON, 0, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_ldap_Controls },
3174   { NULL, 0, 0, 0, NULL }
3175 };
3176
3177 static int
3178 dissect_ldap_LDAPMessage(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) {
3179   offset = dissect_ber_sequence(implicit_tag, actx, tree, tvb, offset,
3180                                    LDAPMessage_sequence, hf_index, ett_ldap_LDAPMessage);
3181
3182   return offset;
3183 }
3184
3185
3186
3187
3188
3189 static int
3190 dissect_ldap_INTEGER(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) {
3191   offset = dissect_ber_integer(implicit_tag, actx, tree, tvb, offset, hf_index,
3192                                                 NULL);
3193
3194   return offset;
3195 }
3196
3197
3198 static const ber_sequence_t SearchControlValue_sequence[] = {
3199   { &hf_ldap_size           , BER_CLASS_UNI, BER_UNI_TAG_INTEGER, BER_FLAGS_NOOWNTAG, dissect_ldap_INTEGER },
3200   { &hf_ldap_cookie         , BER_CLASS_UNI, BER_UNI_TAG_OCTETSTRING, BER_FLAGS_NOOWNTAG, dissect_ldap_OCTET_STRING },
3201   { NULL, 0, 0, 0, NULL }
3202 };
3203
3204 static int
3205 dissect_ldap_SearchControlValue(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) {
3206   offset = dissect_ber_sequence(implicit_tag, actx, tree, tvb, offset,
3207                                    SearchControlValue_sequence, hf_index, ett_ldap_SearchControlValue);
3208
3209   return offset;
3210 }
3211
3212
3213 static const ber_sequence_t SortKeyList_item_sequence[] = {
3214   { &hf_ldap_attributeType  , BER_CLASS_UNI, BER_UNI_TAG_OCTETSTRING, BER_FLAGS_NOOWNTAG, dissect_ldap_AttributeDescription },
3215   { &hf_ldap_orderingRule   , BER_CLASS_CON, 0, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_ldap_MatchingRuleId },
3216   { &hf_ldap_reverseOrder   , BER_CLASS_CON, 1, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_ldap_BOOLEAN },
3217   { NULL, 0, 0, 0, NULL }
3218 };
3219
3220 static int
3221 dissect_ldap_SortKeyList_item(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) {
3222   offset = dissect_ber_sequence(implicit_tag, actx, tree, tvb, offset,
3223                                    SortKeyList_item_sequence, hf_index, ett_ldap_SortKeyList_item);
3224
3225   return offset;
3226 }
3227
3228
3229 static const ber_sequence_t SortKeyList_sequence_of[1] = {
3230   { &hf_ldap_SortKeyList_item, BER_CLASS_UNI, BER_UNI_TAG_SEQUENCE, BER_FLAGS_NOOWNTAG, dissect_ldap_SortKeyList_item },
3231 };
3232
3233 static int
3234 dissect_ldap_SortKeyList(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) {
3235   offset = dissect_ber_sequence_of(implicit_tag, actx, tree, tvb, offset,
3236                                       SortKeyList_sequence_of, hf_index, ett_ldap_SortKeyList);
3237
3238   return offset;
3239 }
3240
3241
3242 static const value_string ldap_T_sortResult_vals[] = {
3243   {   0, "success" },
3244   {   1, "operationsError" },
3245   {   3, "timeLimitExceeded" },
3246   {   8, "strongAuthRequired" },
3247   {  11, "adminLimitExceeded" },
3248   {  16, "noSuchAttribute" },
3249   {  18, "inappropriateMatching" },
3250   {  50, "insufficientAccessRights" },
3251   {  51, "busy" },
3252   {  53, "unwillingToPerform" },
3253   {  80, "other" },
3254   { 0, NULL }
3255 };
3256
3257
3258 static int
3259 dissect_ldap_T_sortResult(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) {
3260   offset = dissect_ber_integer(implicit_tag, actx, tree, tvb, offset, hf_index,
3261                                   NULL);
3262
3263   return offset;
3264 }
3265
3266
3267 static const ber_sequence_t SortResult_sequence[] = {
3268   { &hf_ldap_sortResult     , BER_CLASS_UNI, BER_UNI_TAG_ENUMERATED, BER_FLAGS_NOOWNTAG, dissect_ldap_T_sortResult },
3269   { &hf_ldap_attributeType  , BER_CLASS_CON, 0, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_ldap_AttributeDescription },
3270   { NULL, 0, 0, 0, NULL }
3271 };
3272
3273 static int
3274 dissect_ldap_SortResult(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) {
3275   offset = dissect_ber_sequence(implicit_tag, actx, tree, tvb, offset,
3276                                    SortResult_sequence, hf_index, ett_ldap_SortResult);
3277
3278   return offset;
3279 }
3280
3281
3282 static const ber_sequence_t DirSyncFlagsSubEntry_sequence[] = {
3283   { &hf_ldap_value          , BER_CLASS_CON, 0, BER_FLAGS_IMPLTAG, dissect_ldap_INTEGER },
3284   { NULL, 0, 0, 0, NULL }
3285 };
3286
3287 static int
3288 dissect_ldap_DirSyncFlagsSubEntry(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) {
3289   offset = dissect_ber_sequence(implicit_tag, actx, tree, tvb, offset,
3290                                    DirSyncFlagsSubEntry_sequence, hf_index, ett_ldap_DirSyncFlagsSubEntry);
3291
3292   return offset;
3293 }
3294
3295
3296
3297 static int
3298 dissect_ldap_DirSyncFlags(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) {
3299 #line 779 "../../asn1/ldap/ldap.cnf"
3300         gint8 class;
3301         gboolean pc;
3302         gint32 tag;
3303         guint32 len;
3304         gint32 val;
3305         header_field_info *hfinfo;
3306
3307         int otheroffset = offset;
3308         if(!implicit_tag){
3309                 otheroffset=dissect_ber_identifier(actx->pinfo, tree, tvb, otheroffset, &class, &pc, &tag);
3310                 otheroffset=dissect_ber_length(actx->pinfo, tree, tvb, offset, &len, NULL);
3311         } else {
3312                 gint32 remaining=tvb_length_remaining(tvb, offset);
3313                 len=remaining>0 ? remaining : 0;
3314         }
3315
3316         offset = dissect_ber_integer(implicit_tag, actx, tree, tvb, offset, -1, &val);
3317
3318         hfinfo = proto_registrar_get_nth(hf_index);
3319
3320         if (val >0) {
3321                 proto_tree *subtree = NULL;
3322                 proto_item *item = NULL;
3323                 item = proto_tree_add_text(tree, tvb, otheroffset+1, len, "%s: 0x%08x", hfinfo->name, val);
3324                 subtree = proto_item_add_subtree(item, ett_ldap_DirSyncFlagsSubEntry);
3325
3326                 if (val & 0x1) {
3327                         proto_tree_add_text(subtree, tvb, otheroffset+1, len, "Flag Object_Security");
3328                 }
3329                 if (val & 0x800) {
3330                         proto_tree_add_text(subtree, tvb, otheroffset+1, len, "Flag Ancestor_First");
3331                 }
3332                 if (val & 0x2000) {
3333                         proto_tree_add_text(subtree, tvb, otheroffset+1, len, "Flag Public_Data_Only");
3334                 }
3335                 if (val & 0x80000000) {
3336                         proto_tree_add_text(subtree, tvb, otheroffset+1, len, "Flag Incremental_Value");
3337                 }
3338         } else {
3339                 proto_tree_add_text(tree, tvb, otheroffset+len, len, "%s: 0", hfinfo->name);
3340         }
3341
3342
3343
3344   return offset;
3345 }
3346
3347
3348 static const ber_sequence_t DirSyncControlValue_sequence[] = {
3349   { &hf_ldap_flags          , BER_CLASS_UNI, BER_UNI_TAG_INTEGER, BER_FLAGS_NOOWNTAG, dissect_ldap_DirSyncFlags },
3350   { &hf_ldap_maxBytes       , BER_CLASS_UNI, BER_UNI_TAG_INTEGER, BER_FLAGS_NOOWNTAG, dissect_ldap_INTEGER },
3351   { &hf_ldap_cookie         , BER_CLASS_UNI, BER_UNI_TAG_OCTETSTRING, BER_FLAGS_NOOWNTAG, dissect_ldap_OCTET_STRING },
3352   { NULL, 0, 0, 0, NULL }
3353 };
3354
3355 static int
3356 dissect_ldap_DirSyncControlValue(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) {
3357   offset = dissect_ber_sequence(implicit_tag, actx, tree, tvb, offset,
3358                                    DirSyncControlValue_sequence, hf_index, ett_ldap_DirSyncControlValue);
3359
3360   return offset;
3361 }
3362
3363
3364 static const ber_sequence_t PasswdModifyRequestValue_sequence[] = {
3365   { &hf_ldap_userIdentity   , BER_CLASS_CON, 0, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_ldap_OCTET_STRING },
3366   { &hf_ldap_oldPasswd      , BER_CLASS_CON, 1, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_ldap_OCTET_STRING },
3367   { &hf_ldap_newPasswd      , BER_CLASS_CON, 2, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_ldap_OCTET_STRING },
3368   { NULL, 0, 0, 0, NULL }
3369 };
3370
3371 static int
3372 dissect_ldap_PasswdModifyRequestValue(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) {
3373   offset = dissect_ber_sequence(implicit_tag, actx, tree, tvb, offset,
3374                                    PasswdModifyRequestValue_sequence, hf_index, ett_ldap_PasswdModifyRequestValue);
3375
3376   return offset;
3377 }
3378
3379
3380 static const ber_sequence_t PasswdModifyResponseValue_sequence[] = {
3381   { &hf_ldap_genPasswd      , BER_CLASS_CON, 0, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_ldap_OCTET_STRING },
3382   { NULL, 0, 0, 0, NULL }
3383 };
3384
3385 static int
3386 dissect_ldap_PasswdModifyResponseValue(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) {
3387   offset = dissect_ber_sequence(implicit_tag, actx, tree, tvb, offset,
3388                                    PasswdModifyResponseValue_sequence, hf_index, ett_ldap_PasswdModifyResponseValue);
3389
3390   return offset;
3391 }
3392
3393
3394 static const ber_sequence_t CancelRequestValue_sequence[] = {
3395   { &hf_ldap_cancelID       , BER_CLASS_UNI, BER_UNI_TAG_INTEGER, BER_FLAGS_NOOWNTAG, dissect_ldap_MessageID },
3396   { NULL, 0, 0, 0, NULL }
3397 };
3398
3399 static int
3400 dissect_ldap_CancelRequestValue(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) {
3401   offset = dissect_ber_sequence(implicit_tag, actx, tree, tvb, offset,
3402                                    CancelRequestValue_sequence, hf_index, ett_ldap_CancelRequestValue);
3403
3404   return offset;
3405 }
3406
3407
3408 static const value_string ldap_T_mode_vals[] = {
3409   {   1, "refreshOnly" },
3410   {   3, "refreshAndPersist" },
3411   { 0, NULL }
3412 };
3413
3414
3415 static int
3416 dissect_ldap_T_mode(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) {
3417   offset = dissect_ber_integer(implicit_tag, actx, tree, tvb, offset, hf_index,
3418                                   NULL);
3419
3420   return offset;
3421 }
3422
3423
3424 static const ber_sequence_t SyncRequestValue_sequence[] = {
3425   { &hf_ldap_mode           , BER_CLASS_UNI, BER_UNI_TAG_ENUMERATED, BER_FLAGS_NOOWNTAG, dissect_ldap_T_mode },
3426   { &hf_ldap_cookie         , BER_CLASS_UNI, BER_UNI_TAG_OCTETSTRING, BER_FLAGS_OPTIONAL|BER_FLAGS_NOOWNTAG, dissect_ldap_OCTET_STRING },
3427   { &hf_ldap_reloadHint     , BER_CLASS_UNI, BER_UNI_TAG_BOOLEAN, BER_FLAGS_OPTIONAL|BER_FLAGS_NOOWNTAG, dissect_ldap_BOOLEAN },
3428   { NULL, 0, 0, 0, NULL }
3429 };
3430
3431 static int
3432 dissect_ldap_SyncRequestValue(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) {
3433   offset = dissect_ber_sequence(implicit_tag, actx, tree, tvb, offset,
3434                                    SyncRequestValue_sequence, hf_index, ett_ldap_SyncRequestValue);
3435
3436   return offset;
3437 }
3438
3439
3440 static const value_string ldap_T_state_vals[] = {
3441   {   0, "present" },
3442   {   1, "add" },
3443   {   2, "modify" },
3444   {   3, "delete" },
3445   { 0, NULL }
3446 };
3447
3448
3449 static int
3450 dissect_ldap_T_state(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) {
3451   offset = dissect_ber_integer(implicit_tag, actx, tree, tvb, offset, hf_index,
3452                                   NULL);
3453
3454   return offset;
3455 }
3456
3457
3458
3459 static int
3460 dissect_ldap_SyncUUID(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) {
3461   offset = dissect_ber_octet_string(implicit_tag, actx, tree, tvb, offset, hf_index,
3462                                        NULL);
3463
3464   return offset;
3465 }
3466
3467
3468 static const ber_sequence_t SyncStateValue_sequence[] = {
3469   { &hf_ldap_state          , BER_CLASS_UNI, BER_UNI_TAG_ENUMERATED, BER_FLAGS_NOOWNTAG, dissect_ldap_T_state },
3470   { &hf_ldap_entryUUID      , BER_CLASS_UNI, BER_UNI_TAG_OCTETSTRING, BER_FLAGS_NOOWNTAG, dissect_ldap_SyncUUID },
3471   { &hf_ldap_cookie         , BER_CLASS_UNI, BER_UNI_TAG_OCTETSTRING, BER_FLAGS_OPTIONAL|BER_FLAGS_NOOWNTAG, dissect_ldap_OCTET_STRING },
3472   { NULL, 0, 0, 0, NULL }
3473 };
3474
3475 static int
3476 dissect_ldap_SyncStateValue(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) {
3477   offset = dissect_ber_sequence(implicit_tag, actx, tree, tvb, offset,
3478                                    SyncStateValue_sequence, hf_index, ett_ldap_SyncStateValue);
3479
3480   return offset;
3481 }
3482
3483
3484 static const ber_sequence_t SyncDoneValue_sequence[] = {
3485   { &hf_ldap_cookie         , BER_CLASS_UNI, BER_UNI_TAG_OCTETSTRING, BER_FLAGS_OPTIONAL|BER_FLAGS_NOOWNTAG, dissect_ldap_OCTET_STRING },
3486   { &hf_ldap_refreshDeletes , BER_CLASS_UNI, BER_UNI_TAG_BOOLEAN, BER_FLAGS_OPTIONAL|BER_FLAGS_NOOWNTAG, dissect_ldap_BOOLEAN },
3487   { NULL, 0, 0, 0, NULL }
3488 };
3489
3490 static int
3491 dissect_ldap_SyncDoneValue(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) {
3492   offset = dissect_ber_sequence(implicit_tag, actx, tree, tvb, offset,
3493                                    SyncDoneValue_sequence, hf_index, ett_ldap_SyncDoneValue);
3494
3495   return offset;
3496 }
3497
3498
3499 static const ber_sequence_t T_refreshDelete_sequence[] = {
3500   { &hf_ldap_cookie         , BER_CLASS_UNI, BER_UNI_TAG_OCTETSTRING, BER_FLAGS_OPTIONAL|BER_FLAGS_NOOWNTAG, dissect_ldap_OCTET_STRING },
3501   { &hf_ldap_refreshDone    , BER_CLASS_UNI, BER_UNI_TAG_BOOLEAN, BER_FLAGS_OPTIONAL|BER_FLAGS_NOOWNTAG, dissect_ldap_BOOLEAN },
3502   { NULL, 0, 0, 0, NULL }
3503 };
3504
3505 static int
3506 dissect_ldap_T_refreshDelete(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) {
3507   offset = dissect_ber_sequence(implicit_tag, actx, tree, tvb, offset,
3508                                    T_refreshDelete_sequence, hf_index, ett_ldap_T_refreshDelete);
3509
3510   return offset;
3511 }
3512
3513
3514 static const ber_sequence_t T_refreshPresent_sequence[] = {
3515   { &hf_ldap_cookie         , BER_CLASS_UNI, BER_UNI_TAG_OCTETSTRING, BER_FLAGS_OPTIONAL|BER_FLAGS_NOOWNTAG, dissect_ldap_OCTET_STRING },
3516   { &hf_ldap_refreshDone    , BER_CLASS_UNI, BER_UNI_TAG_BOOLEAN, BER_FLAGS_OPTIONAL|BER_FLAGS_NOOWNTAG, dissect_ldap_BOOLEAN },
3517   { NULL, 0, 0, 0, NULL }
3518 };
3519
3520 static int
3521 dissect_ldap_T_refreshPresent(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) {
3522   offset = dissect_ber_sequence(implicit_tag, actx, tree, tvb, offset,
3523                                    T_refreshPresent_sequence, hf_index, ett_ldap_T_refreshPresent);
3524
3525   return offset;
3526 }
3527
3528
3529 static const ber_sequence_t SET_OF_SyncUUID_set_of[1] = {
3530   { &hf_ldap_syncUUIDs_item , BER_CLASS_UNI, BER_UNI_TAG_OCTETSTRING, BER_FLAGS_NOOWNTAG, dissect_ldap_SyncUUID },
3531 };
3532
3533 static int
3534 dissect_ldap_SET_OF_SyncUUID(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) {
3535   offset = dissect_ber_set_of(implicit_tag, actx, tree, tvb, offset,
3536                                  SET_OF_SyncUUID_set_of, hf_index, ett_ldap_SET_OF_SyncUUID);
3537
3538   return offset;
3539 }
3540
3541
3542 static const ber_sequence_t T_syncIdSet_sequence[] = {
3543   { &hf_ldap_cookie         , BER_CLASS_UNI, BER_UNI_TAG_OCTETSTRING, BER_FLAGS_OPTIONAL|BER_FLAGS_NOOWNTAG, dissect_ldap_OCTET_STRING },
3544   { &hf_ldap_refreshDeletes , BER_CLASS_UNI, BER_UNI_TAG_BOOLEAN, BER_FLAGS_OPTIONAL|BER_FLAGS_NOOWNTAG, dissect_ldap_BOOLEAN },
3545   { &hf_ldap_syncUUIDs      , BER_CLASS_UNI, BER_UNI_TAG_SET, BER_FLAGS_NOOWNTAG, dissect_ldap_SET_OF_SyncUUID },
3546   { NULL, 0, 0, 0, NULL }
3547 };
3548
3549 static int
3550 dissect_ldap_T_syncIdSet(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) {
3551   offset = dissect_ber_sequence(implicit_tag, actx, tree, tvb, offset,
3552                                    T_syncIdSet_sequence, hf_index, ett_ldap_T_syncIdSet);
3553
3554   return offset;
3555 }
3556
3557
3558 static const value_string ldap_SyncInfoValue_vals[] = {
3559   {   0, "newcookie" },
3560   {   1, "refreshDelete" },
3561   {   2, "refreshPresent" },
3562   {   3, "syncIdSet" },
3563   { 0, NULL }
3564 };
3565
3566 static const ber_choice_t SyncInfoValue_choice[] = {
3567   {   0, &hf_ldap_newcookie      , BER_CLASS_CON, 0, BER_FLAGS_IMPLTAG, dissect_ldap_OCTET_STRING },
3568   {   1, &hf_ldap_refreshDelete  , BER_CLASS_CON, 1, BER_FLAGS_IMPLTAG, dissect_ldap_T_refreshDelete },
3569   {   2, &hf_ldap_refreshPresent , BER_CLASS_CON, 2, BER_FLAGS_IMPLTAG, dissect_ldap_T_refreshPresent },
3570   {   3, &hf_ldap_syncIdSet      , BER_CLASS_CON, 3, BER_FLAGS_IMPLTAG, dissect_ldap_T_syncIdSet },
3571   { 0, NULL, 0, 0, 0, NULL }
3572 };
3573
3574 static int
3575 dissect_ldap_SyncInfoValue(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) {
3576   offset = dissect_ber_choice(actx, tree, tvb, offset,
3577                                  SyncInfoValue_choice, hf_index, ett_ldap_SyncInfoValue,
3578                                  NULL);
3579
3580   return offset;
3581 }
3582
3583
3584 static const value_string ldap_T_warning_vals[] = {
3585   {   0, "timeBeforeExpiration" },
3586   {   1, "graceAuthNsRemaining" },
3587   { 0, NULL }
3588 };
3589
3590 static const ber_choice_t T_warning_choice[] = {
3591   {   0, &hf_ldap_timeBeforeExpiration, BER_CLASS_CON, 0, BER_FLAGS_IMPLTAG, dissect_ldap_INTEGER_0_maxInt },
3592   {   1, &hf_ldap_graceAuthNsRemaining, BER_CLASS_CON, 1, BER_FLAGS_IMPLTAG, dissect_ldap_INTEGER_0_maxInt },
3593   { 0, NULL, 0, 0, 0, NULL }
3594 };
3595
3596 static int
3597 dissect_ldap_T_warning(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) {
3598   offset = dissect_ber_choice(actx, tree, tvb, offset,
3599                                  T_warning_choice, hf_index, ett_ldap_T_warning,
3600                                  NULL);
3601
3602   return offset;
3603 }
3604
3605
3606 static const value_string ldap_T_error_vals[] = {
3607   {   0, "passwordExpired" },
3608   {   1, "accountLocked" },
3609   {   2, "changeAfterReset" },
3610   {   3, "passwordModNotAllowed" },
3611   {   4, "mustSupplyOldPassword" },
3612   {   5, "insufficientPasswordQuality" },
3613   {   6, "passwordTooShort" },
3614   {   7, "passwordTooYoung" },
3615   {   8, "passwordInHistory" },
3616   { 0, NULL }
3617 };
3618
3619
3620 static int
3621 dissect_ldap_T_error(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) {
3622   offset = dissect_ber_integer(implicit_tag, actx, tree, tvb, offset, hf_index,
3623                                   NULL);
3624
3625   return offset;
3626 }
3627
3628
3629 static const ber_sequence_t PasswordPolicyResponseValue_sequence[] = {
3630   { &hf_ldap_warning        , BER_CLASS_CON, 0, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_ldap_T_warning },
3631   { &hf_ldap_error          , BER_CLASS_CON, 1, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_ldap_T_error },
3632   { NULL, 0, 0, 0, NULL }
3633 };
3634
3635 static int
3636 dissect_ldap_PasswordPolicyResponseValue(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) {
3637   offset = dissect_ber_sequence(implicit_tag, actx, tree, tvb, offset,
3638                                    PasswordPolicyResponseValue_sequence, hf_index, ett_ldap_PasswordPolicyResponseValue);
3639
3640   return offset;
3641 }
3642
3643 /*--- PDUs ---*/
3644
3645 static void dissect_LDAPMessage_PDU(tvbuff_t *tvb _U_, packet_info *pinfo _U_, proto_tree *tree _U_) {
3646   asn1_ctx_t asn1_ctx;
3647   asn1_ctx_init(&asn1_ctx, ASN1_ENC_BER, TRUE, pinfo);
3648   dissect_ldap_LDAPMessage(FALSE, tvb, 0, &asn1_ctx, tree, hf_ldap_LDAPMessage_PDU);
3649 }
3650 static void dissect_SearchControlValue_PDU(tvbuff_t *tvb _U_, packet_info *pinfo _U_, proto_tree *tree _U_) {
3651   asn1_ctx_t asn1_ctx;
3652   asn1_ctx_init(&asn1_ctx, ASN1_ENC_BER, TRUE, pinfo);
3653   dissect_ldap_SearchControlValue(FALSE, tvb, 0, &asn1_ctx, tree, hf_ldap_SearchControlValue_PDU);
3654 }
3655 static void dissect_SortKeyList_PDU(tvbuff_t *tvb _U_, packet_info *pinfo _U_, proto_tree *tree _U_) {
3656   asn1_ctx_t asn1_ctx;
3657   asn1_ctx_init(&asn1_ctx, ASN1_ENC_BER, TRUE, pinfo);
3658   dissect_ldap_SortKeyList(FALSE, tvb, 0, &asn1_ctx, tree, hf_ldap_SortKeyList_PDU);
3659 }
3660 static void dissect_SortResult_PDU(tvbuff_t *tvb _U_, packet_info *pinfo _U_, proto_tree *tree _U_) {
3661   asn1_ctx_t asn1_ctx;
3662   asn1_ctx_init(&asn1_ctx, ASN1_ENC_BER, TRUE, pinfo);
3663   dissect_ldap_SortResult(FALSE, tvb, 0, &asn1_ctx, tree, hf_ldap_SortResult_PDU);
3664 }
3665 static void dissect_DirSyncControlValue_PDU(tvbuff_t *tvb _U_, packet_info *pinfo _U_, proto_tree *tree _U_) {
3666   asn1_ctx_t asn1_ctx;
3667   asn1_ctx_init(&asn1_ctx, ASN1_ENC_BER, TRUE, pinfo);
3668   dissect_ldap_DirSyncControlValue(FALSE, tvb, 0, &asn1_ctx, tree, hf_ldap_DirSyncControlValue_PDU);
3669 }
3670 static void dissect_PasswdModifyRequestValue_PDU(tvbuff_t *tvb _U_, packet_info *pinfo _U_, proto_tree *tree _U_) {
3671   asn1_ctx_t asn1_ctx;
3672   asn1_ctx_init(&asn1_ctx, ASN1_ENC_BER, TRUE, pinfo);
3673   dissect_ldap_PasswdModifyRequestValue(FALSE, tvb, 0, &asn1_ctx, tree, hf_ldap_PasswdModifyRequestValue_PDU);
3674 }
3675 static void dissect_CancelRequestValue_PDU(tvbuff_t *tvb _U_, packet_info *pinfo _U_, proto_tree *tree _U_) {
3676   asn1_ctx_t asn1_ctx;
3677   asn1_ctx_init(&asn1_ctx, ASN1_ENC_BER, TRUE, pinfo);
3678   dissect_ldap_CancelRequestValue(FALSE, tvb, 0, &asn1_ctx, tree, hf_ldap_CancelRequestValue_PDU);
3679 }
3680 static void dissect_SyncRequestValue_PDU(tvbuff_t *tvb _U_, packet_info *pinfo _U_, proto_tree *tree _U_) {
3681   asn1_ctx_t asn1_ctx;
3682   asn1_ctx_init(&asn1_ctx, ASN1_ENC_BER, TRUE, pinfo);
3683   dissect_ldap_SyncRequestValue(FALSE, tvb, 0, &asn1_ctx, tree, hf_ldap_SyncRequestValue_PDU);
3684 }
3685 static void dissect_SyncStateValue_PDU(tvbuff_t *tvb _U_, packet_info *pinfo _U_, proto_tree *tree _U_) {
3686   asn1_ctx_t asn1_ctx;
3687   asn1_ctx_init(&asn1_ctx, ASN1_ENC_BER, TRUE, pinfo);
3688   dissect_ldap_SyncStateValue(FALSE, tvb, 0, &asn1_ctx, tree, hf_ldap_SyncStateValue_PDU);
3689 }
3690 static void dissect_SyncDoneValue_PDU(tvbuff_t *tvb _U_, packet_info *pinfo _U_, proto_tree *tree _U_) {
3691   asn1_ctx_t asn1_ctx;
3692   asn1_ctx_init(&asn1_ctx, ASN1_ENC_BER, TRUE, pinfo);
3693   dissect_ldap_SyncDoneValue(FALSE, tvb, 0, &asn1_ctx, tree, hf_ldap_SyncDoneValue_PDU);
3694 }
3695 static void dissect_SyncInfoValue_PDU(tvbuff_t *tvb _U_, packet_info *pinfo _U_, proto_tree *tree _U_) {
3696   asn1_ctx_t asn1_ctx;
3697   asn1_ctx_init(&asn1_ctx, ASN1_ENC_BER, TRUE, pinfo);
3698   dissect_ldap_SyncInfoValue(FALSE, tvb, 0, &asn1_ctx, tree, hf_ldap_SyncInfoValue_PDU);
3699 }
3700 static void dissect_PasswordPolicyResponseValue_PDU(tvbuff_t *tvb _U_, packet_info *pinfo _U_, proto_tree *tree _U_) {
3701   asn1_ctx_t asn1_ctx;
3702   asn1_ctx_init(&asn1_ctx, ASN1_ENC_BER, TRUE, pinfo);
3703   dissect_ldap_PasswordPolicyResponseValue(FALSE, tvb, 0, &asn1_ctx, tree, hf_ldap_PasswordPolicyResponseValue_PDU);
3704 }
3705
3706
3707 /*--- End of included file: packet-ldap-fn.c ---*/
3708 #line 745 "../../asn1/ldap/packet-ldap-template.c"
3709
3710 static void
3711 dissect_ldap_payload(tvbuff_t *tvb, packet_info *pinfo,
3712                      proto_tree *tree, ldap_conv_info_t *ldap_info,
3713                      gboolean is_mscldap)
3714 {
3715   int offset = 0;
3716   guint length_remaining;
3717   guint msg_len = 0;
3718   int messageOffset = 0;
3719   guint headerLength = 0;
3720   guint length = 0;
3721   tvbuff_t *msg_tvb = NULL;
3722   gint8 class;
3723   gboolean pc, ind = 0;
3724   gint32 ber_tag;
3725
3726   attributedesc_string=NULL;
3727
3728
3729 one_more_pdu:
3730
3731     length_remaining = tvb_ensure_length_remaining(tvb, offset);
3732
3733     if (length_remaining < 6) return;
3734
3735     /*
3736      * OK, try to read the "Sequence Of" header; this gets the total
3737      * length of the LDAP message.
3738      */
3739         messageOffset = get_ber_identifier(tvb, offset, &class, &pc, &ber_tag);
3740         messageOffset = get_ber_length(tvb, messageOffset, &msg_len, &ind);
3741
3742     /* sanity check */
3743     if((msg_len<4) || (msg_len>10000000)) return;
3744
3745     if ( (class==BER_CLASS_UNI) && (ber_tag==BER_UNI_TAG_SEQUENCE) ) {
3746         /*
3747          * Add the length of the "Sequence Of" header to the message
3748          * length.
3749          */
3750         headerLength = messageOffset - offset;
3751         msg_len += headerLength;
3752         if (msg_len < headerLength) {
3753             /*
3754              * The message length was probably so large that the total length
3755              * overflowed.
3756              *
3757              * Report this as an error.
3758              */
3759             show_reported_bounds_error(tvb, pinfo, tree);
3760             return;
3761         }
3762     } else {
3763         /*
3764          * We couldn't parse the header; just make it the amount of data
3765          * remaining in the tvbuff, so we'll give up on this segment
3766          * after attempting to parse the message - there's nothing more
3767          * we can do.  "dissect_ldap_message()" will display the error.
3768          */
3769         msg_len = length_remaining;
3770     }
3771
3772     /*
3773      * Construct a tvbuff containing the amount of the payload we have
3774      * available.  Make its reported length the amount of data in the
3775      * LDAP message.
3776      *
3777      * XXX - if reassembly isn't enabled. the subdissector will throw a
3778      * BoundsError exception, rather than a ReportedBoundsError exception.
3779      * We really want a tvbuff where the length is "length", the reported
3780      * length is "plen", and the "if the snapshot length were infinite"
3781      * length is the minimum of the reported length of the tvbuff handed
3782      * to us and "plen", with a new type of exception thrown if the offset
3783      * is within the reported length but beyond that third length, with
3784      * that exception getting the "Unreassembled Packet" error.
3785      */
3786     length = length_remaining;
3787     if (length > msg_len) length = msg_len;
3788     msg_tvb = tvb_new_subset(tvb, offset, length, msg_len);
3789
3790     /*
3791      * Now dissect the LDAP message.
3792      */
3793     ldap_info->is_mscldap = is_mscldap;
3794     pinfo->private_data = ldap_info;
3795     dissect_LDAPMessage_PDU(msg_tvb, pinfo, tree);
3796
3797     offset += msg_len;
3798
3799     /* If this was a sasl blob there might be another PDU following in the
3800      * same blob
3801      */
3802     if(tvb_length_remaining(tvb, offset)>=6){
3803         tvb = tvb_new_subset(tvb, offset, tvb_length_remaining(tvb, offset), -1);
3804         offset = 0;
3805
3806         goto one_more_pdu;
3807     }
3808
3809 }
3810
3811 static void
3812 ldap_frame_end(void)
3813 {
3814    ldap_found_in_frame = FALSE;
3815 }
3816
3817 static void
3818 dissect_ldap_pdu(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, gboolean is_mscldap)
3819 {
3820   int offset = 0;
3821   conversation_t *conversation;
3822   gboolean doing_sasl_security = FALSE;
3823   guint length_remaining;
3824   ldap_conv_info_t *ldap_info = NULL;
3825   proto_item *ldap_item = NULL;
3826   proto_tree *ldap_tree = NULL;
3827
3828   ldm_tree = NULL;
3829
3830   conversation = find_or_create_conversation(pinfo);
3831
3832   /*
3833    * Do we already have a type and mechanism?
3834    */
3835   ldap_info = conversation_get_proto_data(conversation, proto_ldap);
3836   if (ldap_info == NULL) {
3837     /* No.  Attach that information to the conversation, and add
3838      * it to the list of information structures.
3839      */
3840     ldap_info = g_malloc0(sizeof(ldap_conv_info_t));
3841     ldap_info->matched=g_hash_table_new(ldap_info_hash_matched, ldap_info_equal_matched);
3842     ldap_info->unmatched=g_hash_table_new(ldap_info_hash_unmatched, ldap_info_equal_unmatched);
3843
3844     conversation_add_proto_data(conversation, proto_ldap, ldap_info);
3845
3846     ldap_info->next = ldap_info_items;
3847     ldap_info_items = ldap_info;
3848
3849   }
3850
3851   switch (ldap_info->auth_type) {
3852     case LDAP_AUTH_SASL:
3853     /*
3854      * It's SASL; are we using a security layer?
3855      */
3856     if (ldap_info->first_auth_frame != 0 &&
3857        pinfo->fd->num >= ldap_info->first_auth_frame) {
3858         doing_sasl_security = TRUE;     /* yes */
3859     }
3860   }
3861
3862     length_remaining = tvb_ensure_length_remaining(tvb, offset);
3863
3864     /* It might still be a packet containing a SASL security layer
3865      * but its just that we never saw the BIND packet.
3866      * check if it looks like it could&nbs