503a969a1894c544b7b9b61b70699e26babd3e83
[metze/wireshark/wip.git] / epan / dissectors / packet-ldap.c
1 /* Do not modify this file. Changes will be overwritten.                      */
2 /* Generated 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 . -O ../../epan/dissectors 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 4511 (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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 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 a lot 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 #include "config.h"
94
95 #include <string.h>
96 #include <ctype.h>
97
98 #include <glib.h>
99
100 #include <epan/packet.h>
101 #include <epan/conversation.h>
102 #include <epan/prefs.h>
103 #include <epan/tap.h>
104 #include <epan/emem.h>
105 #include <epan/oids.h>
106 #include <epan/strutil.h>
107 #include <epan/show_exception.h>
108 #include <epan/dissectors/packet-frame.h>
109 #include <epan/dissectors/packet-tcp.h>
110 #include <epan/dissectors/packet-windows-common.h>
111 #include <epan/dissectors/packet-dcerpc.h>
112 #include <epan/asn1.h>
113 #include <epan/expert.h>
114 #include <epan/uat.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 = (const ldap_call_response_t *)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 = (const ldap_call_response_t*)k1;
532   const ldap_call_response_t *key2 = (const ldap_call_response_t*)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 = (const ldap_call_response_t*)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 = (const ldap_call_response_t*)k1;
558   const ldap_call_response_t *key2 = (const ldap_call_response_t*)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 /* Stuff for generation/handling of fields for custom AttributeValues */
610 typedef struct _attribute_type_t {
611   gchar* attribute_type;
612   gchar* attribute_desc;
613 } attribute_type_t;
614
615 static attribute_type_t* attribute_types = NULL;
616 static guint num_attribute_types = 0;
617
618 static GHashTable* attribute_types_hash = NULL;
619
620 static void
621 attribute_types_update_cb(void *r, const char **err)
622 {
623   attribute_type_t *rec = (attribute_type_t *)r;
624   char c;
625
626   if (rec->attribute_type == NULL) {
627     *err = ep_strdup_printf("Attribute type can't be empty");
628     return;
629   }
630
631   g_strstrip(rec->attribute_type);
632   if (rec->attribute_type[0] == 0) {
633     *err = ep_strdup_printf("Attribute type can't be empty");
634     return;
635   }
636
637   /* Check for invalid characters (to avoid asserting out when
638    * registering the field).
639    */
640   c = proto_check_field_name(rec->attribute_type);
641   if (c) {
642     *err = ep_strdup_printf("Attribute type can't contain '%c'", c);
643     return;
644   }
645
646   *err = NULL;
647 }
648
649 static void *
650 attribute_types_copy_cb(void* n, const void* o, size_t siz _U_)
651 {
652   attribute_type_t* new_rec = (attribute_type_t*)n;
653   const attribute_type_t* old_rec = (const attribute_type_t*)o;
654
655   new_rec->attribute_type = g_strdup(old_rec->attribute_type);
656   new_rec->attribute_desc = g_strdup(old_rec->attribute_desc);
657
658   return new_rec;
659 }
660
661 static void
662 attribute_types_free_cb(void*r)
663 {
664   attribute_type_t* rec = (attribute_type_t*)r;
665
666   if (rec->attribute_type) g_free(rec->attribute_type);
667   if (rec->attribute_desc) g_free(rec->attribute_desc);
668 }
669
670 UAT_CSTRING_CB_DEF(attribute_types, attribute_type, attribute_type_t)
671 UAT_CSTRING_CB_DEF(attribute_types, attribute_desc, attribute_type_t)
672
673 /*
674  *
675  */
676 static gint*
677 get_hf_for_header(char* attribute_type)
678 {
679   gint* hf_id = NULL;
680
681   if (attribute_types_hash) {
682     hf_id = (gint*) g_hash_table_lookup(attribute_types_hash, attribute_type);
683   } else {
684     hf_id = NULL;
685   }
686
687   return hf_id;
688 }
689
690 /*
691  *
692  */
693 static void
694 attribute_types_initialize_cb(void)
695 {
696   static hf_register_info* hf;
697   gint* hf_id;
698   guint i;
699   gchar* attribute_type;
700
701   if (attribute_types_hash) {
702     guint hf_size = g_hash_table_size (attribute_types_hash);
703     /* Unregister all fields */
704     for (i = 0; i < hf_size; i++) {
705       proto_unregister_field (proto_ldap, *(hf[i].p_id));
706
707       g_free (hf[i].p_id);
708       g_free ((char *) hf[i].hfinfo.name);
709       g_free ((char *) hf[i].hfinfo.abbrev);
710       g_free ((char *) hf[i].hfinfo.blurb);
711     }
712     g_hash_table_destroy (attribute_types_hash);
713     g_free (hf);
714     attribute_types_hash = NULL;
715   }
716
717   if (num_attribute_types) {
718     attribute_types_hash = g_hash_table_new(g_str_hash, g_str_equal);
719     hf = g_new0(hf_register_info,num_attribute_types);
720
721     for (i = 0; i < num_attribute_types; i++) {
722       hf_id = g_new(gint,1);
723       *hf_id = -1;
724       attribute_type = g_strdup(attribute_types[i].attribute_type);
725
726       hf[i].p_id = hf_id;
727       hf[i].hfinfo.name = attribute_type;
728       hf[i].hfinfo.abbrev = g_strdup_printf("ldap.AttributeValue.%s", attribute_type);
729       hf[i].hfinfo.type = FT_STRING;
730       hf[i].hfinfo.display = BASE_NONE;
731       hf[i].hfinfo.strings = NULL;
732       hf[i].hfinfo.blurb = g_strdup(attribute_types[i].attribute_desc);
733       hf[i].hfinfo.same_name_prev = NULL;
734       hf[i].hfinfo.same_name_next = NULL;
735
736       g_hash_table_insert(attribute_types_hash, attribute_type, hf_id);
737     }
738
739     proto_register_field_array(proto_ldap, hf, num_attribute_types);
740   }
741 }
742
743 /* MS-ADTS specification, section 7.3.1.1, NETLOGON_NT_VERSION Options Bits */
744 static int dissect_mscldap_ntver_flags(proto_tree *parent_tree, tvbuff_t *tvb, int offset)
745 {
746   guint32 flags;
747   proto_item *item;
748   proto_tree *tree=NULL;
749   guint fields[] = {
750                      hf_mscldap_ntver_flags_v1,
751                      hf_mscldap_ntver_flags_v5,
752                      hf_mscldap_ntver_flags_v5ex,
753                      hf_mscldap_ntver_flags_v5ep,
754                      hf_mscldap_ntver_flags_vcs,
755                      hf_mscldap_ntver_flags_vnt4,
756                      hf_mscldap_ntver_flags_vpdc,
757                      hf_mscldap_ntver_flags_vip,
758                      hf_mscldap_ntver_flags_vl,
759                      hf_mscldap_ntver_flags_vgc,
760                      0 };
761
762   guint  *field;
763   header_field_info *hfi;
764   gboolean one_bit_set = FALSE;
765
766   flags=tvb_get_letohl(tvb, offset);
767   item=proto_tree_add_item(parent_tree, hf_mscldap_ntver_flags, tvb, offset, 4, ENC_LITTLE_ENDIAN);
768   if(parent_tree){
769     tree = proto_item_add_subtree(item, ett_mscldap_ntver_flags);
770   }
771
772   proto_item_append_text(item, " (");
773
774   for(field = fields; *field; field++) {
775     proto_tree_add_boolean(tree, *field, tvb, offset, 4, flags);
776     hfi = proto_registrar_get_nth(*field);
777
778     if(flags & hfi->bitmask) {
779
780       if(one_bit_set)
781         proto_item_append_text(item, ", ");
782       else
783         one_bit_set = TRUE;
784
785       proto_item_append_text(item, "%s", hfi->name);
786
787     }
788   }
789
790   proto_item_append_text(item, ")");
791
792   offset += 4;
793
794   return offset;
795 }
796
797 /* This string contains the last LDAPString that was decoded */
798 static const char *attributedesc_string=NULL;
799
800 /* This string contains the last AssertionValue that was decoded */
801 static char *ldapvalue_string=NULL;
802
803 /* if the octet string contain all printable ASCII characters, then
804  * display it as a string, othervise just display it in hex.
805  */
806 static int
807 dissect_ldap_AssertionValue(gboolean implicit_tag, tvbuff_t *tvb, int offset, asn1_ctx_t *actx _U_, proto_tree *tree, int hf_index)
808 {
809         gint8 ber_class;
810         gboolean pc, ind, is_ascii;
811         gint32 tag;
812         guint32 len, i;
813         const guchar *str;
814
815         if(!implicit_tag){
816                 offset=get_ber_identifier(tvb, offset, &ber_class, &pc, &tag);
817                 offset=get_ber_length(tvb, offset, &len, &ind);
818         } else {
819                 len=tvb_length_remaining(tvb,offset);
820         }
821
822         if(len==0){
823                 return offset;
824         }
825
826
827         /*
828          * Some special/wellknown attributes in common LDAP (read AD)
829          * are neither ascii strings nor blobs of hex data.
830          * Special case these attributes and decode them more nicely.
831          *
832          * Add more special cases as required to prettify further
833          * (there cant be that many ones that are truly interesting)
834          */
835         if(attributedesc_string && !strncmp("DomainSid", attributedesc_string, 9)){
836                 tvbuff_t *sid_tvb;
837                 char *tmpstr;
838
839                 /* this octet string contains an NT SID */
840                 sid_tvb=tvb_new_subset(tvb, offset, len, len);
841                 dissect_nt_sid(sid_tvb, 0, tree, "SID", &tmpstr, hf_index);
842                 ldapvalue_string=tmpstr;
843
844                 goto finished;
845         } else if ( (len==16) /* GUIDs are always 16 bytes */
846         && (attributedesc_string && !strncmp("DomainGuid", attributedesc_string, 10))) {
847                 guint8 drep[4] = { 0x10, 0x00, 0x00, 0x00}; /* fake DREP struct */
848                 e_uuid_t uuid;
849
850                 /* This octet string contained a GUID */
851                 dissect_dcerpc_uuid_t(tvb, offset, actx->pinfo, tree, drep, hf_ldap_guid, &uuid);
852
853                 ldapvalue_string=(char*)ep_alloc(1024);
854                 g_snprintf(ldapvalue_string, 1023, "%08x-%04x-%04x-%02x%02x-%02x%02x%02x%02x%02x%02x",
855                           uuid.Data1, uuid.Data2, uuid.Data3,
856                           uuid.Data4[0], uuid.Data4[1],
857                           uuid.Data4[2], uuid.Data4[3],
858                           uuid.Data4[4], uuid.Data4[5],
859                           uuid.Data4[6], uuid.Data4[7]);
860
861                 goto finished;
862         } else if (attributedesc_string && !strncmp("NtVer", attributedesc_string, 5)){
863                 guint32 flags;
864
865                 len = 0;
866                 /* get flag value to populate ldapvalue_string */
867                 flags=tvb_get_letohl(tvb, offset);
868
869                 ldapvalue_string=(char*)ep_alloc(1024);
870                 g_snprintf(ldapvalue_string, 1023, "0x%08x",flags);
871
872                 /* populate bitmask subtree */
873                 offset = dissect_mscldap_ntver_flags(tree, tvb, offset);
874
875                 goto finished;
876
877
878         }
879
880         /*
881          * It was not one of our "wellknown" attributes so make the best
882          * we can and just try to see if it is an ascii string or if it
883          * is a binary blob.
884          *
885          * XXX - should we support reading RFC 2252-style schemas
886          * for LDAP, and using that to determine how to display
887          * attribute values and assertion values?
888          *
889          * -- I dont think there are full schemas available that describe the
890          *  interesting cases i.e. AD -- ronnie
891          */
892         str=tvb_get_ptr(tvb, offset, len);
893         is_ascii=TRUE;
894         for(i=0;i<len;i++){
895                 if(!isascii(str[i]) || !isprint(str[i])){
896                         is_ascii=FALSE;
897                         break;
898                 }
899         }
900
901         /* convert the string into a printable string */
902         if(is_ascii){
903                 ldapvalue_string=ep_strndup(str, len);
904         } else {
905                 ldapvalue_string=(char*)ep_alloc(3*len);
906                 for(i=0;i<len;i++){
907                         g_snprintf(ldapvalue_string+i*3,3,"%02x",str[i]&0xff);
908                         ldapvalue_string[3*i+2]=':';
909                 }
910                 ldapvalue_string[3*len-1]=0;
911         }
912
913         proto_tree_add_string(tree, hf_index, tvb, offset, len, ldapvalue_string);
914
915
916 finished:
917         offset+=len;
918         return offset;
919 }
920
921 /* This string contains the last Filter item that was decoded */
922 static const char *Filter_string=NULL;
923 static const char *and_filter_string=NULL;
924 static const char *or_filter_string=NULL;
925 static const char *substring_value=NULL;
926 static const char *substring_item_init=NULL;
927 static const char *substring_item_any=NULL;
928 static const char *substring_item_final=NULL;
929 static const char *matching_rule_string=NULL;
930 static gboolean matching_rule_dnattr=FALSE;
931
932 #define MAX_FILTER_LEN 4096
933 static gint Filter_length;
934
935 #define MAX_FILTER_ELEMENTS 200
936 static gint Filter_elements;
937
938 /* Global variables */
939 static gint MessageID =-1;
940 static gint ProtocolOp = -1;
941 static gint result = 0;
942 static proto_item *ldm_tree = NULL; /* item to add text to */
943
944 static void ldap_do_protocolop(packet_info *pinfo)
945 {
946   const gchar* valstr;
947
948   if (do_protocolop)  {
949
950     valstr = val_to_str(ProtocolOp, ldap_ProtocolOp_choice_vals, "Unknown (%%u)");
951
952     col_append_fstr(pinfo->cinfo, COL_INFO, "%s(%u) ", valstr, MessageID);
953
954     if(ldm_tree)
955       proto_item_append_text(ldm_tree, " %s(%d)", valstr, MessageID);
956
957     do_protocolop = FALSE;
958
959   }
960 }
961
962 static ldap_call_response_t *
963 ldap_match_call_response(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, guint messageId, guint protocolOpTag)
964 {
965   ldap_call_response_t lcr, *lcrp=NULL;
966   ldap_conv_info_t *ldap_info = (ldap_conv_info_t *)pinfo->private_data;
967
968   /* first see if we have already matched this */
969
970       lcr.messageId=messageId;
971       switch(protocolOpTag){
972         case LDAP_REQ_BIND:
973         case LDAP_REQ_SEARCH:
974         case LDAP_REQ_MODIFY:
975         case LDAP_REQ_ADD:
976         case LDAP_REQ_DELETE:
977         case LDAP_REQ_MODRDN:
978         case LDAP_REQ_COMPARE:
979         case LDAP_REQ_EXTENDED:
980           lcr.is_request=TRUE;
981           lcr.req_frame=pinfo->fd->num;
982           lcr.rep_frame=0;
983           break;
984         case LDAP_RES_BIND:
985         case LDAP_RES_SEARCH_ENTRY:
986         case LDAP_RES_SEARCH_REF:
987         case LDAP_RES_SEARCH_RESULT:
988         case LDAP_RES_MODIFY:
989         case LDAP_RES_ADD:
990         case LDAP_RES_DELETE:
991         case LDAP_RES_MODRDN:
992         case LDAP_RES_COMPARE:
993         case LDAP_RES_EXTENDED:
994         case LDAP_RES_INTERMEDIATE:
995           lcr.is_request=FALSE;
996           lcr.req_frame=0;
997           lcr.rep_frame=pinfo->fd->num;
998           break;
999       }
1000       lcrp=(ldap_call_response_t *)g_hash_table_lookup(ldap_info->matched, &lcr);
1001
1002       if(lcrp){
1003
1004         lcrp->is_request=lcr.is_request;
1005
1006       } else {
1007
1008                   /* we haven't found a match - try and match it up */
1009
1010   switch(protocolOpTag){
1011       case LDAP_REQ_BIND:
1012       case LDAP_REQ_SEARCH:
1013       case LDAP_REQ_MODIFY:
1014       case LDAP_REQ_ADD:
1015       case LDAP_REQ_DELETE:
1016       case LDAP_REQ_MODRDN:
1017       case LDAP_REQ_COMPARE:
1018       case LDAP_REQ_EXTENDED:
1019
1020                 /* this a a request - add it to the unmatched list */
1021
1022         /* check that we dont already have one of those in the
1023            unmatched list and if so remove it */
1024
1025         lcr.messageId=messageId;
1026         lcrp=(ldap_call_response_t *)g_hash_table_lookup(ldap_info->unmatched, &lcr);
1027         if(lcrp){
1028           g_hash_table_remove(ldap_info->unmatched, lcrp);
1029         }
1030         /* if we cant reuse the old one, grab a new chunk */
1031         if(!lcrp){
1032           lcrp=se_new(ldap_call_response_t);
1033         }
1034         lcrp->messageId=messageId;
1035         lcrp->req_frame=pinfo->fd->num;
1036         lcrp->req_time=pinfo->fd->abs_ts;
1037         lcrp->rep_frame=0;
1038         lcrp->protocolOpTag=protocolOpTag;
1039         lcrp->is_request=TRUE;
1040         g_hash_table_insert(ldap_info->unmatched, lcrp, lcrp);
1041         return NULL;
1042         break;
1043       case LDAP_RES_BIND:
1044       case LDAP_RES_SEARCH_ENTRY:
1045       case LDAP_RES_SEARCH_REF:
1046       case LDAP_RES_SEARCH_RESULT:
1047       case LDAP_RES_MODIFY:
1048       case LDAP_RES_ADD:
1049       case LDAP_RES_DELETE:
1050       case LDAP_RES_MODRDN:
1051       case LDAP_RES_COMPARE:
1052       case LDAP_RES_EXTENDED:
1053       case LDAP_RES_INTERMEDIATE:
1054
1055                 /* this is a result - it should be in our unmatched list */
1056
1057         lcr.messageId=messageId;
1058         lcrp=(ldap_call_response_t *)g_hash_table_lookup(ldap_info->unmatched, &lcr);
1059
1060         if(lcrp){
1061
1062           if(!lcrp->rep_frame){
1063             g_hash_table_remove(ldap_info->unmatched, lcrp);
1064             lcrp->rep_frame=pinfo->fd->num;
1065             lcrp->is_request=FALSE;
1066             g_hash_table_insert(ldap_info->matched, lcrp, lcrp);
1067           }
1068         }
1069
1070         break;
1071           }
1072
1073         }
1074     /* we have found a match */
1075
1076     if(lcrp){
1077       proto_item *it;
1078
1079       if(lcrp->is_request){
1080         it=proto_tree_add_uint(tree, hf_ldap_response_in, tvb, 0, 0, lcrp->rep_frame);
1081         PROTO_ITEM_SET_GENERATED(it);
1082       } else {
1083         nstime_t ns;
1084         it=proto_tree_add_uint(tree, hf_ldap_response_to, tvb, 0, 0, lcrp->req_frame);
1085         PROTO_ITEM_SET_GENERATED(it);
1086         nstime_delta(&ns, &pinfo->fd->abs_ts, &lcrp->req_time);
1087         it=proto_tree_add_time(tree, hf_ldap_time, tvb, 0, 0, &ns);
1088         PROTO_ITEM_SET_GENERATED(it);
1089       }
1090     }
1091
1092     return lcrp;
1093 }
1094
1095
1096 /*--- Included file: packet-ldap-fn.c ---*/
1097 #line 1 "../../asn1/ldap/packet-ldap-fn.c"
1098 /*--- Cyclic dependencies ---*/
1099
1100 /* Filter -> Filter/and -> Filter/and/_item -> Filter */
1101 /* Filter -> Filter/or -> Filter/or/_item -> Filter */
1102 /* Filter -> Filter/not -> Filter */
1103 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_);
1104
1105
1106
1107
1108 static int
1109 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_) {
1110 #line 98 "../../asn1/ldap/ldap.cnf"
1111
1112     offset = dissect_ber_integer(implicit_tag, actx, tree, tvb, offset, hf_index,
1113                                                 &MessageID);
1114
1115
1116   ldm_tree = tree;
1117
1118
1119
1120   return offset;
1121 }
1122
1123
1124
1125 static int
1126 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_) {
1127   offset = dissect_ber_integer(implicit_tag, actx, tree, tvb, offset, hf_index,
1128                                                 NULL);
1129
1130   return offset;
1131 }
1132
1133
1134
1135 static int
1136 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_) {
1137 #line 322 "../../asn1/ldap/ldap.cnf"
1138   tvbuff_t      *parameter_tvb = NULL;
1139   const char    *ldapstring = NULL;
1140   gchar         *sc = NULL; /* semi-colon pointer */
1141
1142     offset = dissect_ber_octet_string(implicit_tag, actx, tree, tvb, offset, hf_index,
1143                                        &parameter_tvb);
1144
1145
1146   if (parameter_tvb || (hf_index == hf_ldap_baseObject)) {
1147
1148      ldap_do_protocolop(actx->pinfo);
1149
1150      if(parameter_tvb)
1151         ldapstring = tvb_get_ephemeral_string(parameter_tvb, 0, tvb_length_remaining(parameter_tvb, 0));
1152
1153      if(hf_index == hf_ldap_baseObject) {
1154         /* this is search - put it on the scanline */
1155         if(!ldapstring || !*ldapstring)
1156           ldapstring = "<ROOT>";
1157
1158     col_append_fstr(actx->pinfo->cinfo, COL_INFO, "\"%s\" ", ldapstring);
1159
1160         if(ldm_tree)
1161           proto_item_append_text(ldm_tree, " \"%s\"", ldapstring);
1162
1163
1164         if(!parameter_tvb) {
1165
1166           proto_item_append_text(actx->created_item, " (%s)", ldapstring);
1167         }
1168
1169      } else if ((hf_index == hf_ldap_errorMessage) && ldapstring && *ldapstring) { /* only show message if not success */
1170         col_append_fstr(actx->pinfo->cinfo, COL_INFO, "(%s) ", ldapstring);
1171
1172         if(ldm_tree)
1173           proto_item_append_text(ldm_tree, " (%s)", ldapstring);
1174
1175      } else if ((hf_index == hf_ldap_objectName) ||
1176                 (hf_index == hf_ldap_name) ||
1177                 (hf_index == hf_ldap_entry) ||
1178                 (hf_index == hf_ldap_object) ||
1179                 (hf_index == hf_ldap_delRequest) ) {
1180
1181         if(!ldapstring || !*ldapstring)
1182           ldapstring = "<ROOT>";
1183
1184     col_append_fstr(actx->pinfo->cinfo, COL_INFO, "\"%s\" ", ldapstring);
1185
1186     if(ldm_tree)
1187           proto_item_append_text(ldm_tree, " \"%s\"", ldapstring);
1188      } else if (hf_index == hf_ldap_attributeDesc){
1189         /* remember the attribute description */
1190         attributedesc_string=ldapstring;
1191      } else if (hf_index == hf_ldap_initial){
1192         /* remember the substring item */
1193         substring_item_init=ldapstring;
1194      } else if (hf_index == hf_ldap_any){
1195         /* remember the substring item */
1196         substring_item_any=ldapstring;
1197      } else if (hf_index == hf_ldap_final){
1198         /* remember the substring item */
1199         substring_item_final=ldapstring;
1200      } else if (hf_index == hf_ldap_matchingRule){
1201         /* remember the matching rule */
1202         matching_rule_string=ldapstring;
1203      } else if (hf_index == hf_ldap_present){
1204         /* remember the present name */
1205         Filter_string=ldapstring;
1206      } else if (hf_index == hf_ldap_type) {
1207         /* remember attribute type name */
1208         attr_type = ep_strdup(ldapstring);
1209
1210         /* append it to the parent entry */
1211         proto_item_append_text(tree, " %s", attr_type);
1212
1213         /* remove the ";binary" component if present */
1214         if((sc = strchr(attr_type, ';')) != NULL) {
1215                 if(!strcmp(sc, ";binary")) {
1216                         *sc = '\0'; /* terminate the string */
1217                         is_binary_attr_type = TRUE;
1218                 }
1219         } else {
1220                 is_binary_attr_type = FALSE;
1221         }
1222
1223      }
1224
1225   }
1226
1227
1228
1229   return offset;
1230 }
1231
1232
1233
1234 static int
1235 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_) {
1236   offset = dissect_ldap_LDAPString(implicit_tag, tvb, offset, actx, tree, hf_index);
1237
1238   return offset;
1239 }
1240
1241
1242
1243 static int
1244 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_) {
1245 #line 167 "../../asn1/ldap/ldap.cnf"
1246 ldap_conv_info_t *ldap_info;
1247
1248   offset = dissect_ber_octet_string(implicit_tag, actx, tree, tvb, offset, hf_index,
1249                                        NULL);
1250
1251
1252         ldap_info = (ldap_conv_info_t *)actx->pinfo->private_data;
1253         ldap_info->auth_type = LDAP_AUTH_SIMPLE;
1254
1255         actx->pinfo->private_data = ldap_info;
1256
1257
1258
1259   return offset;
1260 }
1261
1262
1263
1264 static int
1265 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_) {
1266 #line 177 "../../asn1/ldap/ldap.cnf"
1267
1268 ldap_conv_info_t *ldap_info;
1269 tvbuff_t        *parameter_tvb;
1270 char *mechanism = NULL;
1271   offset = dissect_ber_octet_string(implicit_tag, actx, tree, tvb, offset, hf_index,
1272                                        &parameter_tvb);
1273
1274         ldap_info = (ldap_conv_info_t *)actx->pinfo->private_data;
1275         ldap_info->auth_type = LDAP_AUTH_SASL;
1276
1277         if (!parameter_tvb)
1278                 return offset;
1279
1280     /*
1281      * We need to remember the authentication type and mechanism for this
1282      * conversation.
1283      *
1284      * XXX - actually, we might need to remember more than one
1285      * type and mechanism, if you can unbind and rebind with a
1286      * different type and/or mechanism.
1287      */
1288     if(!actx->pinfo->fd->flags.visited) {
1289         mechanism = tvb_get_string(parameter_tvb, 0, tvb_length_remaining(parameter_tvb,0));
1290         ldap_info->first_auth_frame = 0;        /* not known until we see the bind reply */
1291         /*
1292          * If the mechanism in this request is an empty string (which is
1293          * returned as a null pointer), use the saved mechanism instead.
1294          * Otherwise, if the saved mechanism is an empty string (null),
1295          * save this mechanism.
1296          */
1297         if (mechanism != NULL) {
1298           g_free(ldap_info->auth_mech);
1299           ldap_info->auth_mech = mechanism;
1300         }
1301         actx->pinfo->private_data = ldap_info;
1302     }
1303
1304
1305   return offset;
1306 }
1307
1308
1309
1310 static int
1311 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_) {
1312 #line 212 "../../asn1/ldap/ldap.cnf"
1313
1314 tvbuff_t        *parameter_tvb;
1315 ldap_conv_info_t *ldap_info;
1316 gint8 ber_class;
1317 gboolean pc;
1318 gint32 tag;
1319
1320   offset = dissect_ber_octet_string(implicit_tag, actx, tree, tvb, offset, hf_index,
1321                                        &parameter_tvb);
1322
1323
1324         if (!parameter_tvb)
1325                 return offset;
1326
1327         ldap_info = (ldap_conv_info_t *)actx->pinfo->private_data;
1328         get_ber_identifier(parameter_tvb, 0, &ber_class, &pc, &tag);
1329
1330         /*if ((ldap_info->auth_mech != NULL) && (strcmp(ldap_info->auth_mech, "GSS-SPNEGO") == 0) && (ber_class==BER_CLASS_CON)) {*/
1331         if ((ldap_info->auth_mech != NULL) && (ber_class==BER_CLASS_CON)) {
1332           /*
1333            * This is a GSS-API token ancapsulated within GSS-SPNEGO.
1334            * We need to check the first byte to check whether the blob
1335            * contains SPNEGO or GSSAPI.
1336            * All SPNEGO PDUs are of class CONSTRUCTED while
1337            * GSS PDUs are class APPLICATION
1338            */
1339           if (parameter_tvb && (tvb_length(parameter_tvb) > 0))
1340             call_dissector(spnego_handle, parameter_tvb, actx->pinfo, tree);
1341         }
1342         /*if ((ldap_info->auth_mech != NULL) && ((strcmp(ldap_info->auth_mech, "GSSAPI") == 0) || (ber_class==BER_CLASS_APP))) {*/
1343         if ((ldap_info->auth_mech != NULL) && (ber_class==BER_CLASS_APP)) {
1344           /*
1345            * This is a raw GSS-API token.
1346            */
1347           if (parameter_tvb && (tvb_length(parameter_tvb) > 0)) {
1348             call_dissector(gssapi_handle, parameter_tvb, actx->pinfo, tree);
1349           }
1350         }
1351         actx->pinfo->private_data = ldap_info;
1352
1353
1354
1355
1356   return offset;
1357 }
1358
1359
1360 static const ber_sequence_t SaslCredentials_sequence[] = {
1361   { &hf_ldap_mechanism      , BER_CLASS_UNI, BER_UNI_TAG_OCTETSTRING, BER_FLAGS_NOOWNTAG, dissect_ldap_Mechanism },
1362   { &hf_ldap_credentials    , BER_CLASS_UNI, BER_UNI_TAG_OCTETSTRING, BER_FLAGS_OPTIONAL|BER_FLAGS_NOOWNTAG, dissect_ldap_Credentials },
1363   { NULL, 0, 0, 0, NULL }
1364 };
1365
1366 static int
1367 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_) {
1368   offset = dissect_ber_sequence(implicit_tag, actx, tree, tvb, offset,
1369                                    SaslCredentials_sequence, hf_index, ett_ldap_SaslCredentials);
1370
1371   return offset;
1372 }
1373
1374
1375
1376 static int
1377 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_) {
1378 #line 704 "../../asn1/ldap/ldap.cnf"
1379         /* make sure the protocol op comes first */
1380         ldap_do_protocolop(actx->pinfo);
1381
1382         call_dissector(ntlmssp_handle, tvb, actx->pinfo, tree);
1383         offset+=tvb_length_remaining(tvb, offset);
1384
1385
1386
1387   return offset;
1388 }
1389
1390
1391
1392 static int
1393 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_) {
1394 #line 711 "../../asn1/ldap/ldap.cnf"
1395         /* make sure the protocol op comes first */
1396         ldap_do_protocolop(actx->pinfo);
1397
1398         call_dissector(ntlmssp_handle, tvb, actx->pinfo, tree);
1399         offset+=tvb_length_remaining(tvb, offset);
1400
1401
1402
1403   return offset;
1404 }
1405
1406
1407 static const value_string ldap_AuthenticationChoice_vals[] = {
1408   {   0, "simple" },
1409   {   3, "sasl" },
1410   {  10, "ntlmsspNegotiate" },
1411   {  11, "ntlmsspAuth" },
1412   { 0, NULL }
1413 };
1414
1415 static const ber_choice_t AuthenticationChoice_choice[] = {
1416   {   0, &hf_ldap_simple         , BER_CLASS_CON, 0, BER_FLAGS_IMPLTAG, dissect_ldap_Simple },
1417   {   3, &hf_ldap_sasl           , BER_CLASS_CON, 3, BER_FLAGS_IMPLTAG, dissect_ldap_SaslCredentials },
1418   {  10, &hf_ldap_ntlmsspNegotiate, BER_CLASS_CON, 10, BER_FLAGS_IMPLTAG, dissect_ldap_T_ntlmsspNegotiate },
1419   {  11, &hf_ldap_ntlmsspAuth    , BER_CLASS_CON, 11, BER_FLAGS_IMPLTAG, dissect_ldap_T_ntlmsspAuth },
1420   { 0, NULL, 0, 0, 0, NULL }
1421 };
1422
1423 static int
1424 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_) {
1425 #line 494 "../../asn1/ldap/ldap.cnf"
1426   gint branch = -1;
1427   gint auth = -1;
1428   const gchar *valstr;
1429
1430     offset = dissect_ber_choice(actx, tree, tvb, offset,
1431                                  AuthenticationChoice_choice, hf_index, ett_ldap_AuthenticationChoice,
1432                                  &branch);
1433
1434
1435   ldap_do_protocolop(actx->pinfo);
1436
1437   if((branch > -1) && (branch < (gint)(sizeof AuthenticationChoice_choice/sizeof AuthenticationChoice_choice[0])))
1438     auth = AuthenticationChoice_choice[branch].value;
1439
1440   valstr = val_to_str(auth, ldap_AuthenticationChoice_vals, "Unknown auth(%u)");
1441
1442   /* If auth is NTLM (10 or 11) don't add to column as the NTLM dissection will do this */
1443   if ((auth !=  10) && (auth != 11))
1444     col_append_fstr(actx->pinfo->cinfo, COL_INFO, "%s ", valstr);
1445
1446   if(ldm_tree)
1447     proto_item_append_text(ldm_tree, " %s", valstr);
1448
1449
1450
1451
1452   return offset;
1453 }
1454
1455
1456 static const ber_sequence_t BindRequest_U_sequence[] = {
1457   { &hf_ldap_version        , BER_CLASS_UNI, BER_UNI_TAG_INTEGER, BER_FLAGS_NOOWNTAG, dissect_ldap_INTEGER_1_127 },
1458   { &hf_ldap_name           , BER_CLASS_UNI, BER_UNI_TAG_OCTETSTRING, BER_FLAGS_NOOWNTAG, dissect_ldap_LDAPDN },
1459   { &hf_ldap_authentication , BER_CLASS_ANY/*choice*/, -1/*choice*/, BER_FLAGS_NOOWNTAG|BER_FLAGS_NOTCHKTAG, dissect_ldap_AuthenticationChoice },
1460   { NULL, 0, 0, 0, NULL }
1461 };
1462
1463 static int
1464 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_) {
1465   offset = dissect_ber_sequence(implicit_tag, actx, tree, tvb, offset,
1466                                    BindRequest_U_sequence, hf_index, ett_ldap_BindRequest_U);
1467
1468   return offset;
1469 }
1470
1471
1472
1473 static int
1474 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_) {
1475   offset = dissect_ber_tagged_type(implicit_tag, actx, tree, tvb, offset,
1476                                       hf_index, BER_CLASS_APP, 0, TRUE, dissect_ldap_BindRequest_U);
1477
1478   return offset;
1479 }
1480
1481
1482 static const value_string ldap_BindResponse_resultCode_vals[] = {
1483   {   0, "success" },
1484   {   1, "operationsError" },
1485   {   2, "protocolError" },
1486   {   3, "timeLimitExceeded" },
1487   {   4, "sizeLimitExceeded" },
1488   {   5, "compareFalse" },
1489   {   6, "compareTrue" },
1490   {   7, "authMethodNotSupported" },
1491   {   8, "strongAuthRequired" },
1492   {  10, "referral" },
1493   {  11, "adminLimitExceeded" },
1494   {  12, "unavailableCriticalExtension" },
1495   {  13, "confidentialityRequired" },
1496   {  14, "saslBindInProgress" },
1497   {  16, "noSuchAttribute" },
1498   {  17, "undefinedAttributeType" },
1499   {  18, "inappropriateMatching" },
1500   {  19, "constraintViolation" },
1501   {  20, "attributeOrValueExists" },
1502   {  21, "invalidAttributeSyntax" },
1503   {  32, "noSuchObject" },
1504   {  33, "aliasProblem" },
1505   {  34, "invalidDNSyntax" },
1506   {  36, "aliasDereferencingProblem" },
1507   {  48, "inappropriateAuthentication" },
1508   {  49, "invalidCredentials" },
1509   {  50, "insufficientAccessRights" },
1510   {  51, "busy" },
1511   {  52, "unavailable" },
1512   {  53, "unwillingToPerform" },
1513   {  54, "loopDetect" },
1514   {  64, "namingViolation" },
1515   {  65, "objectClassViolation" },
1516   {  66, "notAllowedOnNonLeaf" },
1517   {  67, "notAllowedOnRDN" },
1518   {  68, "entryAlreadyExists" },
1519   {  69, "objectClassModsProhibited" },
1520   {  71, "affectsMultipleDSAs" },
1521   {  80, "other" },
1522   { 118, "canceled" },
1523   { 119, "noSuchOperation" },
1524   { 120, "tooLate" },
1525   { 121, "cannotCancel" },
1526   { 0, NULL }
1527 };
1528
1529
1530 static int
1531 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_) {
1532 #line 442 "../../asn1/ldap/ldap.cnf"
1533
1534   const gchar *valstr;
1535
1536     offset = dissect_ber_integer(implicit_tag, actx, tree, tvb, offset, hf_index,
1537                                   &result);
1538
1539
1540   ldap_do_protocolop(actx->pinfo);
1541
1542   valstr = val_to_str(result, ldap_BindResponse_resultCode_vals, "Unknown result(%u)");
1543
1544   col_append_fstr(actx->pinfo->cinfo, COL_INFO, "%s ", valstr);
1545
1546   if(ldm_tree)
1547     proto_item_append_text(ldm_tree, " %s", valstr);
1548
1549
1550
1551
1552   return offset;
1553 }
1554
1555
1556
1557 static int
1558 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_) {
1559 #line 718 "../../asn1/ldap/ldap.cnf"
1560         tvbuff_t *new_tvb=NULL;
1561
1562         offset = dissect_ber_octet_string(FALSE, actx, tree, tvb, offset, hf_ldap_matchedDN, &new_tvb);
1563
1564         if(  new_tvb
1565         &&  (tvb_length(new_tvb)>=7)
1566         &&  (!tvb_memeql(new_tvb, 0, "NTLMSSP", 7))){
1567
1568                 /* make sure the protocol op comes first */
1569                 ldap_do_protocolop(actx->pinfo);
1570
1571                 call_dissector(ntlmssp_handle, new_tvb, actx->pinfo, tree);
1572         }
1573         return offset;
1574
1575
1576
1577   return offset;
1578 }
1579
1580
1581
1582 static int
1583 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_) {
1584   offset = dissect_ldap_LDAPString(implicit_tag, tvb, offset, actx, tree, hf_index);
1585
1586   return offset;
1587 }
1588
1589
1590
1591 static int
1592 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_) {
1593   offset = dissect_ber_octet_string(implicit_tag, actx, tree, tvb, offset, hf_index,
1594                                        NULL);
1595
1596 #line 51 "../../asn1/ldap/ldap.cnf"
1597         PROTO_ITEM_SET_URL(actx->created_item);
1598
1599
1600   return offset;
1601 }
1602
1603
1604 static const ber_sequence_t Referral_sequence_of[1] = {
1605   { &hf_ldap_Referral_item  , BER_CLASS_UNI, BER_UNI_TAG_OCTETSTRING, BER_FLAGS_NOOWNTAG, dissect_ldap_LDAPURL },
1606 };
1607
1608 static int
1609 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_) {
1610   offset = dissect_ber_sequence_of(implicit_tag, actx, tree, tvb, offset,
1611                                       Referral_sequence_of, hf_index, ett_ldap_Referral);
1612
1613   return offset;
1614 }
1615
1616
1617
1618 static int
1619 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_) {
1620 #line 252 "../../asn1/ldap/ldap.cnf"
1621
1622 tvbuff_t        *parameter_tvb = NULL;
1623 ldap_conv_info_t *ldap_info;
1624
1625   offset = dissect_ber_octet_string(implicit_tag, actx, tree, tvb, offset, hf_index,
1626                                        &parameter_tvb);
1627
1628         if (!parameter_tvb)
1629                 return offset;
1630         ldap_info = (ldap_conv_info_t *)actx->pinfo->private_data;
1631     switch (ldap_info->auth_type) {
1632
1633       /* For Kerberos V4, dissect it as a ticket. */
1634       /* XXX - what about LDAP_AUTH_SIMPLE? */
1635
1636     case LDAP_AUTH_SASL:
1637       /*
1638        * All frames after this are assumed to use a security layer.
1639        *
1640        * XXX - won't work if there's another reply, with the security
1641        * layer, starting in the same TCP segment that ends this
1642        * reply, but as LDAP is a request/response protocol, and
1643        * as the client probably can't start using authentication until
1644        * it gets the bind reply and the server won't send a reply until
1645        * it gets a request, that probably won't happen.
1646        *
1647        * XXX - that assumption is invalid; it's not clear where the
1648        * hell you find out whether there's any security layer.  In
1649        * one capture, we have two GSS-SPNEGO negotiations, both of
1650        * which select MS KRB5, and the only differences in the tokens
1651        * is in the RC4-HMAC ciphertext.  The various
1652        * draft-ietf--cat-sasl-gssapi-NN.txt drafts seem to imply
1653        * that the RFC 2222 spoo with the bitmask and maximum
1654        * output message size stuff is done - but where does that
1655        * stuff show up?  Is it in the ciphertext, which means it's
1656        * presumably encrypted?
1657        *
1658        * Grrr.  We have to do a gross heuristic, checking whether the
1659        * putative LDAP message begins with 0x00 or not, making the
1660        * assumption that we won't have more than 2^24 bytes of
1661        * encapsulated stuff.
1662        */
1663       ldap_info->first_auth_frame = actx->pinfo->fd->num + 1;
1664       if (ldap_info->auth_mech != NULL &&
1665           strcmp(ldap_info->auth_mech, "GSS-SPNEGO") == 0) {
1666         /* It could be the second leg of GSS-SPNEGO wrapping NTLMSSP
1667          * which might not be wrapped in GSS-SPNEGO but be a raw
1668          * NTLMSSP blob
1669          */
1670         if ( (tvb_length(parameter_tvb)>=7)
1671         &&   (!tvb_memeql(parameter_tvb, 0, "NTLMSSP", 7))){
1672           call_dissector(ntlmssp_handle, parameter_tvb, actx->pinfo, tree);
1673           break;
1674         }
1675         /*
1676          * This is a GSS-API token.
1677          */
1678         if(parameter_tvb && (tvb_length(parameter_tvb) > 0))
1679           call_dissector(spnego_handle, parameter_tvb, actx->pinfo, tree);
1680       } else if (ldap_info->auth_mech != NULL &&
1681           strcmp(ldap_info->auth_mech, "GSSAPI") == 0) {
1682         /*
1683          * This is a GSS-API token.
1684          */
1685         if(parameter_tvb && (tvb_length(parameter_tvb) > 0))
1686           call_dissector(gssapi_handle, parameter_tvb, actx->pinfo, tree);
1687                 }
1688         break;
1689         }
1690         actx->pinfo->private_data = ldap_info;
1691
1692
1693
1694   return offset;
1695 }
1696
1697
1698 static const ber_sequence_t BindResponse_U_sequence[] = {
1699   { &hf_ldap_bindResponse_resultCode, BER_CLASS_UNI, BER_UNI_TAG_ENUMERATED, BER_FLAGS_NOOWNTAG, dissect_ldap_BindResponse_resultCode },
1700   { &hf_ldap_bindResponse_matchedDN, BER_CLASS_UNI, BER_UNI_TAG_OCTETSTRING, BER_FLAGS_NOOWNTAG, dissect_ldap_T_bindResponse_matchedDN },
1701   { &hf_ldap_errorMessage   , BER_CLASS_UNI, BER_UNI_TAG_OCTETSTRING, BER_FLAGS_NOOWNTAG, dissect_ldap_ErrorMessage },
1702   { &hf_ldap_referral       , BER_CLASS_CON, 3, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_ldap_Referral },
1703   { &hf_ldap_serverSaslCreds, BER_CLASS_CON, 7, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_ldap_ServerSaslCreds },
1704   { NULL, 0, 0, 0, NULL }
1705 };
1706
1707 static int
1708 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_) {
1709   offset = dissect_ber_sequence(implicit_tag, actx, tree, tvb, offset,
1710                                    BindResponse_U_sequence, hf_index, ett_ldap_BindResponse_U);
1711
1712   return offset;
1713 }
1714
1715
1716
1717 static int
1718 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_) {
1719   offset = dissect_ber_tagged_type(implicit_tag, actx, tree, tvb, offset,
1720                                       hf_index, BER_CLASS_APP, 1, TRUE, dissect_ldap_BindResponse_U);
1721
1722   return offset;
1723 }
1724
1725
1726
1727 static int
1728 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_) {
1729   offset = dissect_ber_null(implicit_tag, actx, tree, tvb, offset, hf_index);
1730
1731   return offset;
1732 }
1733
1734
1735
1736 static int
1737 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_) {
1738 #line 516 "../../asn1/ldap/ldap.cnf"
1739
1740  implicit_tag = TRUE; /* correct problem with asn2wrs */
1741
1742    offset = dissect_ber_tagged_type(implicit_tag, actx, tree, tvb, offset,
1743                                       hf_index, BER_CLASS_APP, 2, TRUE, dissect_ldap_NULL);
1744
1745
1746  ldap_do_protocolop(actx->pinfo);
1747
1748
1749
1750
1751
1752
1753
1754   return offset;
1755 }
1756
1757
1758 static const value_string ldap_T_scope_vals[] = {
1759   {   0, "baseObject" },
1760   {   1, "singleLevel" },
1761   {   2, "wholeSubtree" },
1762   { 0, NULL }
1763 };
1764
1765
1766 static int
1767 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_) {
1768 #line 410 "../../asn1/ldap/ldap.cnf"
1769
1770   guint32 scope = 0xffff;
1771   const gchar *valstr;
1772
1773     offset = dissect_ber_integer(implicit_tag, actx, tree, tvb, offset, hf_index,
1774                                   &scope);
1775
1776
1777   ldap_do_protocolop(actx->pinfo);
1778
1779   valstr = val_to_str(scope, ldap_T_scope_vals, "Unknown scope(%u)");
1780
1781   col_append_fstr(actx->pinfo->cinfo, COL_INFO, "%s ", valstr);
1782
1783   if(ldm_tree)
1784     proto_item_append_text(ldm_tree, " %s", valstr);
1785
1786
1787
1788   return offset;
1789 }
1790
1791
1792 static const value_string ldap_T_derefAliases_vals[] = {
1793   {   0, "neverDerefAliases" },
1794   {   1, "derefInSearching" },
1795   {   2, "derefFindingBaseObj" },
1796   {   3, "derefAlways" },
1797   { 0, NULL }
1798 };
1799
1800
1801 static int
1802 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_) {
1803   offset = dissect_ber_integer(implicit_tag, actx, tree, tvb, offset, hf_index,
1804                                   NULL);
1805
1806   return offset;
1807 }
1808
1809
1810
1811 static int
1812 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_) {
1813   offset = dissect_ber_integer(implicit_tag, actx, tree, tvb, offset, hf_index,
1814                                                 NULL);
1815
1816   return offset;
1817 }
1818
1819
1820
1821 static int
1822 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_) {
1823   offset = dissect_ber_boolean(implicit_tag, actx, tree, tvb, offset, hf_index, NULL);
1824
1825   return offset;
1826 }
1827
1828
1829
1830 static int
1831 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_) {
1832   offset = dissect_ldap_Filter(implicit_tag, tvb, offset, actx, tree, hf_index);
1833
1834 #line 562 "../../asn1/ldap/ldap.cnf"
1835         if(and_filter_string){
1836                 and_filter_string=ep_strdup_printf("(&%s%s)",and_filter_string,Filter_string);
1837         } else {
1838                 and_filter_string=Filter_string;
1839         }
1840
1841
1842   return offset;
1843 }
1844
1845
1846 static const ber_sequence_t T_and_set_of[1] = {
1847   { &hf_ldap_and_item       , BER_CLASS_ANY/*choice*/, -1/*choice*/, BER_FLAGS_NOOWNTAG|BER_FLAGS_NOTCHKTAG, dissect_ldap_T_and_item },
1848 };
1849
1850 static int
1851 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_) {
1852 #line 569 "../../asn1/ldap/ldap.cnf"
1853         proto_tree *tr=NULL;
1854         proto_item *it=NULL;
1855         const char *old_and_filter_string=and_filter_string;
1856
1857         and_filter_string=NULL;
1858         if(tree){
1859                 it=proto_tree_add_text(tree, tvb, offset, tvb_length_remaining(tvb, offset), "and: ");
1860                 tr=proto_item_add_subtree(it, ett_ldap_T_and);
1861                 tree = tr;
1862         }
1863
1864   offset = dissect_ber_set_of(implicit_tag, actx, tree, tvb, offset,
1865                                  T_and_set_of, hf_index, ett_ldap_T_and);
1866
1867
1868         if(and_filter_string) {
1869                 proto_item_append_text(it, "%s", and_filter_string);
1870                 Filter_string=ep_strdup_printf("%s",and_filter_string);
1871         }
1872         and_filter_string=old_and_filter_string;
1873
1874
1875
1876   return offset;
1877 }
1878
1879
1880
1881 static int
1882 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_) {
1883   offset = dissect_ldap_Filter(implicit_tag, tvb, offset, actx, tree, hf_index);
1884
1885 #line 589 "../../asn1/ldap/ldap.cnf"
1886         if(or_filter_string){
1887                 or_filter_string=ep_strdup_printf("(|%s%s)",or_filter_string,Filter_string);
1888         } else {
1889                 or_filter_string=Filter_string;
1890         }
1891
1892
1893
1894   return offset;
1895 }
1896
1897
1898 static const ber_sequence_t T_or_set_of[1] = {
1899   { &hf_ldap_or_item        , BER_CLASS_ANY/*choice*/, -1/*choice*/, BER_FLAGS_NOOWNTAG|BER_FLAGS_NOTCHKTAG, dissect_ldap_T_or_item },
1900 };
1901
1902 static int
1903 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_) {
1904 #line 597 "../../asn1/ldap/ldap.cnf"
1905         proto_tree *tr=NULL;
1906         proto_item *it=NULL;
1907         const char *old_or_filter_string=or_filter_string;
1908
1909         or_filter_string=NULL;
1910         if(tree){
1911                 it=proto_tree_add_text(tree, tvb, offset, tvb_length_remaining(tvb, offset), "or: ");
1912                 tr=proto_item_add_subtree(it, ett_ldap_T_or);
1913                 tree = tr;
1914         }
1915   offset = dissect_ber_set_of(implicit_tag, actx, tree, tvb, offset,
1916                                  T_or_set_of, hf_index, ett_ldap_T_or);
1917
1918         if(or_filter_string) {
1919                 proto_item_append_text(it, "%s", or_filter_string);
1920                 Filter_string=ep_strdup_printf("%s",or_filter_string);
1921         }
1922         or_filter_string=old_or_filter_string;
1923
1924
1925
1926   return offset;
1927 }
1928
1929
1930
1931 static int
1932 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_) {
1933   offset = dissect_ldap_Filter(implicit_tag, tvb, offset, actx, tree, hf_index);
1934
1935 #line 618 "../../asn1/ldap/ldap.cnf"
1936         Filter_string=ep_strdup_printf("(!%s)",string_or_null(Filter_string));
1937
1938
1939   return offset;
1940 }
1941
1942
1943
1944 static int
1945 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_) {
1946   offset = dissect_ldap_LDAPString(implicit_tag, tvb, offset, actx, tree, hf_index);
1947
1948   return offset;
1949 }
1950
1951
1952
1953 static const ber_sequence_t AttributeValueAssertion_sequence[] = {
1954   { &hf_ldap_attributeDesc  , BER_CLASS_UNI, BER_UNI_TAG_OCTETSTRING, BER_FLAGS_NOOWNTAG, dissect_ldap_AttributeDescription },
1955   { &hf_ldap_assertionValue , BER_CLASS_UNI, BER_UNI_TAG_OCTETSTRING, BER_FLAGS_NOOWNTAG, dissect_ldap_AssertionValue },
1956   { NULL, 0, 0, 0, NULL }
1957 };
1958
1959 static int
1960 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_) {
1961   offset = dissect_ber_sequence(implicit_tag, actx, tree, tvb, offset,
1962                                    AttributeValueAssertion_sequence, hf_index, ett_ldap_AttributeValueAssertion);
1963
1964   return offset;
1965 }
1966
1967
1968
1969 static int
1970 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_) {
1971   offset = dissect_ldap_AttributeValueAssertion(implicit_tag, tvb, offset, actx, tree, hf_index);
1972
1973 #line 539 "../../asn1/ldap/ldap.cnf"
1974         Filter_string=ep_strdup_printf("(%s=%s)",
1975                                        string_or_null(attributedesc_string),
1976                                        string_or_null(ldapvalue_string));
1977
1978
1979
1980   return offset;
1981 }
1982
1983
1984 static const value_string ldap_T_substringFilter_substrings_item_vals[] = {
1985   {   0, "initial" },
1986   {   1, "any" },
1987   {   2, "final" },
1988   { 0, NULL }
1989 };
1990
1991 static const ber_choice_t T_substringFilter_substrings_item_choice[] = {
1992   {   0, &hf_ldap_initial        , BER_CLASS_CON, 0, BER_FLAGS_IMPLTAG, dissect_ldap_LDAPString },
1993   {   1, &hf_ldap_any            , BER_CLASS_CON, 1, BER_FLAGS_IMPLTAG, dissect_ldap_LDAPString },
1994   {   2, &hf_ldap_final          , BER_CLASS_CON, 2, BER_FLAGS_IMPLTAG, dissect_ldap_LDAPString },
1995   { 0, NULL, 0, 0, 0, NULL }
1996 };
1997
1998 static int
1999 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_) {
2000   offset = dissect_ber_choice(actx, tree, tvb, offset,
2001                                  T_substringFilter_substrings_item_choice, hf_index, ett_ldap_T_substringFilter_substrings_item,
2002                                  NULL);
2003
2004 #line 644 "../../asn1/ldap/ldap.cnf"
2005         if (substring_item_final) {
2006                 substring_value=ep_strdup_printf("%s%s",
2007                                                  (substring_value?substring_value:"*"),
2008                                                  substring_item_final);
2009         } else if (substring_item_any) {
2010                 substring_value=ep_strdup_printf("%s%s*",
2011                                                  (substring_value?substring_value:"*"),
2012                                                  substring_item_any);
2013         } else if (substring_item_init) {
2014                 substring_value=ep_strdup_printf("%s*",
2015                                                  substring_item_init);
2016         }
2017
2018
2019   return offset;
2020 }
2021
2022
2023 static const ber_sequence_t T_substringFilter_substrings_sequence_of[1] = {
2024   { &hf_ldap_substringFilter_substrings_item, BER_CLASS_ANY/*choice*/, -1/*choice*/, BER_FLAGS_NOOWNTAG|BER_FLAGS_NOTCHKTAG, dissect_ldap_T_substringFilter_substrings_item },
2025 };
2026
2027 static int
2028 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_) {
2029   offset = dissect_ber_sequence_of(implicit_tag, actx, tree, tvb, offset,
2030                                       T_substringFilter_substrings_sequence_of, hf_index, ett_ldap_T_substringFilter_substrings);
2031
2032   return offset;
2033 }
2034
2035
2036 static const ber_sequence_t SubstringFilter_sequence[] = {
2037   { &hf_ldap_type           , BER_CLASS_UNI, BER_UNI_TAG_OCTETSTRING, BER_FLAGS_NOOWNTAG, dissect_ldap_AttributeDescription },
2038   { &hf_ldap_substringFilter_substrings, BER_CLASS_UNI, BER_UNI_TAG_SEQUENCE, BER_FLAGS_NOOWNTAG, dissect_ldap_T_substringFilter_substrings },
2039   { NULL, 0, 0, 0, NULL }
2040 };
2041
2042 static int
2043 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_) {
2044 #line 658 "../../asn1/ldap/ldap.cnf"
2045         proto_tree *tr=NULL;
2046         proto_item *it=NULL;
2047         const char *old_substring_value=substring_value;
2048
2049         attr_type=NULL;
2050         substring_value=NULL;
2051         substring_item_init=NULL;
2052         substring_item_any=NULL;
2053         substring_item_final=NULL;
2054         if(tree){
2055                 it=proto_tree_add_text(tree, tvb, offset, tvb_length_remaining(tvb, offset), "substring: ");
2056                 tr=proto_item_add_subtree(it, ett_ldap_SubstringFilter);
2057                 tree = tr;
2058         }
2059   offset = dissect_ber_sequence(implicit_tag, actx, tree, tvb, offset,
2060                                    SubstringFilter_sequence, hf_index, ett_ldap_SubstringFilter);
2061
2062         Filter_string=ep_strdup_printf("(%s=%s)",
2063                 string_or_null(attr_type),
2064                 string_or_null(substring_value));
2065         proto_item_append_text(it, "%s", Filter_string);
2066         substring_value=old_substring_value;
2067
2068
2069
2070   return offset;
2071 }
2072
2073
2074
2075 static int
2076 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_) {
2077   offset = dissect_ldap_AttributeValueAssertion(implicit_tag, tvb, offset, actx, tree, hf_index);
2078
2079 #line 545 "../../asn1/ldap/ldap.cnf"
2080         Filter_string=ep_strdup_printf("(%s>=%s)",
2081                                        string_or_null(attributedesc_string),
2082                                        string_or_null(ldapvalue_string));
2083
2084
2085
2086   return offset;
2087 }
2088
2089
2090
2091 static int
2092 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_) {
2093   offset = dissect_ldap_AttributeValueAssertion(implicit_tag, tvb, offset, actx, tree, hf_index);
2094
2095 #line 551 "../../asn1/ldap/ldap.cnf"
2096         Filter_string=ep_strdup_printf("(%s<=%s)",
2097                                        string_or_null(attributedesc_string),
2098                                        string_or_null(ldapvalue_string));
2099
2100
2101
2102   return offset;
2103 }
2104
2105
2106
2107 static int
2108 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_) {
2109   offset = dissect_ldap_AttributeDescription(implicit_tag, tvb, offset, actx, tree, hf_index);
2110
2111 #line 615 "../../asn1/ldap/ldap.cnf"
2112         Filter_string=ep_strdup_printf("(%s=*)",string_or_null(Filter_string));
2113
2114
2115   return offset;
2116 }
2117
2118
2119
2120 static int
2121 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_) {
2122   offset = dissect_ldap_AttributeValueAssertion(implicit_tag, tvb, offset, actx, tree, hf_index);
2123
2124 #line 557 "../../asn1/ldap/ldap.cnf"
2125         Filter_string=ep_strdup_printf("(%s~=%s)",
2126                                        string_or_null(attributedesc_string),
2127                                        string_or_null(ldapvalue_string));
2128
2129
2130   return offset;
2131 }
2132
2133
2134
2135 static int
2136 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_) {
2137   offset = dissect_ldap_LDAPString(implicit_tag, tvb, offset, actx, tree, hf_index);
2138
2139   return offset;
2140 }
2141
2142
2143
2144 static int
2145 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_) {
2146 #line 621 "../../asn1/ldap/ldap.cnf"
2147         gboolean val;
2148
2149 offset = dissect_ber_boolean(implicit_tag, actx, tree, tvb, offset, hf_index, &val);
2150
2151
2152                 matching_rule_dnattr = val;
2153
2154
2155
2156
2157   return offset;
2158 }
2159
2160
2161 static const ber_sequence_t MatchingRuleAssertion_sequence[] = {
2162   { &hf_ldap_matchingRule   , BER_CLASS_CON, 1, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_ldap_MatchingRuleId },
2163   { &hf_ldap_type           , BER_CLASS_CON, 2, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_ldap_AttributeDescription },
2164   { &hf_ldap_matchValue     , BER_CLASS_CON, 3, BER_FLAGS_IMPLTAG, dissect_ldap_AssertionValue },
2165   { &hf_ldap_dnAttributes   , BER_CLASS_CON, 4, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_ldap_T_dnAttributes },
2166   { NULL, 0, 0, 0, NULL }
2167 };
2168
2169 static int
2170 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_) {
2171   offset = dissect_ber_sequence(implicit_tag, actx, tree, tvb, offset,
2172                                    MatchingRuleAssertion_sequence, hf_index, ett_ldap_MatchingRuleAssertion);
2173
2174   return offset;
2175 }
2176
2177
2178
2179 static int
2180 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_) {
2181 #line 630 "../../asn1/ldap/ldap.cnf"
2182         attr_type=NULL;
2183         matching_rule_string=NULL;
2184         ldapvalue_string=NULL;
2185         matching_rule_dnattr=FALSE;
2186
2187
2188   offset = dissect_ldap_MatchingRuleAssertion(implicit_tag, tvb, offset, actx, tree, hf_index);
2189
2190 #line 636 "../../asn1/ldap/ldap.cnf"
2191         Filter_string=ep_strdup_printf("(%s:%s%s%s=%s)",
2192                                         (attr_type?attr_type:""),
2193                                         (matching_rule_dnattr?"dn:":""),
2194                                         (matching_rule_string?matching_rule_string:""),
2195                                         (matching_rule_string?":":""),
2196                                         string_or_null(ldapvalue_string));
2197
2198
2199   return offset;
2200 }
2201
2202
2203 static const value_string ldap_Filter_vals[] = {
2204   {   0, "and" },
2205   {   1, "or" },
2206   {   2, "not" },
2207   {   3, "equalityMatch" },
2208   {   4, "substrings" },
2209   {   5, "greaterOrEqual" },
2210   {   6, "lessOrEqual" },
2211   {   7, "present" },
2212   {   8, "approxMatch" },
2213   {   9, "extensibleMatch" },
2214   { 0, NULL }
2215 };
2216
2217 static const ber_choice_t Filter_choice[] = {
2218   {   0, &hf_ldap_and            , BER_CLASS_CON, 0, BER_FLAGS_IMPLTAG, dissect_ldap_T_and },
2219   {   1, &hf_ldap_or             , BER_CLASS_CON, 1, BER_FLAGS_IMPLTAG, dissect_ldap_T_or },
2220   {   2, &hf_ldap_not            , BER_CLASS_CON, 2, BER_FLAGS_IMPLTAG, dissect_ldap_T_not },
2221   {   3, &hf_ldap_equalityMatch  , BER_CLASS_CON, 3, BER_FLAGS_IMPLTAG, dissect_ldap_T_equalityMatch },
2222   {   4, &hf_ldap_substrings     , BER_CLASS_CON, 4, BER_FLAGS_IMPLTAG, dissect_ldap_SubstringFilter },
2223   {   5, &hf_ldap_greaterOrEqual , BER_CLASS_CON, 5, BER_FLAGS_IMPLTAG, dissect_ldap_T_greaterOrEqual },
2224   {   6, &hf_ldap_lessOrEqual    , BER_CLASS_CON, 6, BER_FLAGS_IMPLTAG, dissect_ldap_T_lessOrEqual },
2225   {   7, &hf_ldap_present        , BER_CLASS_CON, 7, BER_FLAGS_IMPLTAG, dissect_ldap_T_present },
2226   {   8, &hf_ldap_approxMatch    , BER_CLASS_CON, 8, BER_FLAGS_IMPLTAG, dissect_ldap_T_approxMatch },
2227   {   9, &hf_ldap_extensibleMatch, BER_CLASS_CON, 9, BER_FLAGS_IMPLTAG, dissect_ldap_T_extensibleMatch },
2228   { 0, NULL, 0, 0, 0, NULL }
2229 };
2230
2231 static int
2232 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_) {
2233 #line 680 "../../asn1/ldap/ldap.cnf"
2234         proto_tree *tr=NULL;
2235         proto_item *it=NULL;
2236         attributedesc_string=NULL;
2237
2238         if (Filter_length++ > MAX_FILTER_LEN) {
2239                 expert_add_info_format(actx->pinfo, tree, PI_UNDECODED, PI_ERROR, "Filter length exceeds %u. Giving up.", MAX_FILTER_LEN);
2240                 THROW(ReportedBoundsError);
2241         }
2242
2243         if (Filter_elements++ > MAX_FILTER_ELEMENTS) {
2244                 expert_add_info_format(actx->pinfo, tree, PI_UNDECODED, PI_ERROR, "Found more than %u filter elements. Giving up.", MAX_FILTER_ELEMENTS);
2245                 THROW(ReportedBoundsError);
2246         }
2247
2248         if(tree){
2249                 it=proto_tree_add_text(tree, tvb, offset, tvb_length_remaining(tvb, offset), "Filter: ");
2250                 tr=proto_item_add_subtree(it, ett_ldap_Filter);
2251                 tree = tr;
2252         }
2253   offset = dissect_ber_choice(actx, tree, tvb, offset,
2254                                  Filter_choice, hf_index, ett_ldap_Filter,
2255                                  NULL);
2256
2257         if(Filter_string)
2258                 proto_item_append_text(it, "%s", string_or_null(Filter_string));
2259
2260
2261
2262   return offset;
2263 }
2264
2265
2266
2267 static int
2268 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_) {
2269 #line 528 "../../asn1/ldap/ldap.cnf"
2270         Filter_string=NULL;
2271         Filter_elements = 0;
2272         Filter_length = 0;
2273
2274
2275   offset = dissect_ldap_Filter(implicit_tag, tvb, offset, actx, tree, hf_index);
2276
2277 #line 533 "../../asn1/ldap/ldap.cnf"
2278         Filter_string=NULL;
2279         and_filter_string=NULL;
2280         Filter_elements = 0;
2281         Filter_length = 0;
2282
2283
2284   return offset;
2285 }
2286
2287
2288 static const ber_sequence_t AttributeDescriptionList_sequence_of[1] = {
2289   { &hf_ldap_AttributeDescriptionList_item, BER_CLASS_UNI, BER_UNI_TAG_OCTETSTRING, BER_FLAGS_NOOWNTAG, dissect_ldap_AttributeDescription },
2290 };
2291
2292 static int
2293 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_) {
2294   offset = dissect_ber_sequence_of(implicit_tag, actx, tree, tvb, offset,
2295                                       AttributeDescriptionList_sequence_of, hf_index, ett_ldap_AttributeDescriptionList);
2296
2297   return offset;
2298 }
2299
2300
2301 static const ber_sequence_t SearchRequest_U_sequence[] = {
2302   { &hf_ldap_baseObject     , BER_CLASS_UNI, BER_UNI_TAG_OCTETSTRING, BER_FLAGS_NOOWNTAG, dissect_ldap_LDAPDN },
2303   { &hf_ldap_scope          , BER_CLASS_UNI, BER_UNI_TAG_ENUMERATED, BER_FLAGS_NOOWNTAG, dissect_ldap_T_scope },
2304   { &hf_ldap_derefAliases   , BER_CLASS_UNI, BER_UNI_TAG_ENUMERATED, BER_FLAGS_NOOWNTAG, dissect_ldap_T_derefAliases },
2305   { &hf_ldap_sizeLimit      , BER_CLASS_UNI, BER_UNI_TAG_INTEGER, BER_FLAGS_NOOWNTAG, dissect_ldap_INTEGER_0_maxInt },
2306   { &hf_ldap_timeLimit      , BER_CLASS_UNI, BER_UNI_TAG_INTEGER, BER_FLAGS_NOOWNTAG, dissect_ldap_INTEGER_0_maxInt },
2307   { &hf_ldap_typesOnly      , BER_CLASS_UNI, BER_UNI_TAG_BOOLEAN, BER_FLAGS_NOOWNTAG, dissect_ldap_BOOLEAN },
2308   { &hf_ldap_filter         , BER_CLASS_ANY/*choice*/, -1/*choice*/, BER_FLAGS_NOOWNTAG|BER_FLAGS_NOTCHKTAG, dissect_ldap_T_filter },
2309   { &hf_ldap_searchRequest_attributes, BER_CLASS_UNI, BER_UNI_TAG_SEQUENCE, BER_FLAGS_NOOWNTAG, dissect_ldap_AttributeDescriptionList },
2310   { NULL, 0, 0, 0, NULL }
2311 };
2312
2313 static int
2314 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_) {
2315   offset = dissect_ber_sequence(implicit_tag, actx, tree, tvb, offset,
2316                                    SearchRequest_U_sequence, hf_index, ett_ldap_SearchRequest_U);
2317
2318   return offset;
2319 }
2320
2321
2322
2323 static int
2324 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_) {
2325   offset = dissect_ber_tagged_type(implicit_tag, actx, tree, tvb, offset,
2326                                       hf_index, BER_CLASS_APP, 3, TRUE, dissect_ldap_SearchRequest_U);
2327
2328   return offset;
2329 }
2330
2331
2332
2333 static int
2334 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_) {
2335 #line 458 "../../asn1/ldap/ldap.cnf"
2336
2337   tvbuff_t      *next_tvb = NULL;
2338   gchar         *string;
2339   guint32       i, len;
2340   int           old_offset = offset;
2341   gint          *hf_id;
2342
2343   /* attr_type, should be set before calling this function */
2344
2345   /* extract the value of the octetstring */
2346   offset = dissect_ber_octet_string(FALSE, actx, NULL, tvb, offset, hf_index, &next_tvb);
2347
2348   /* first check if we have a custom attribute type configured */
2349   if ((hf_id = get_hf_for_header (attr_type)) != NULL)
2350     proto_tree_add_item (tree, *hf_id, next_tvb, 0, tvb_length_remaining(next_tvb, 0), ENC_UTF_8|ENC_NA);
2351
2352   /* if we have an attribute type that isn't binary see if there is a better dissector */
2353   else if(!attr_type || !next_tvb || !dissector_try_string(ldap_name_dissector_table, attr_type, next_tvb, actx->pinfo, tree)) {
2354     offset = old_offset;
2355
2356     /* do the default thing */
2357       offset = dissect_ber_octet_string(implicit_tag, actx, tree, tvb, offset, hf_index,
2358                                        NULL);
2359
2360
2361     len = tvb_length_remaining(next_tvb, 0);
2362
2363     for(i = 0; i < len; i++)
2364       if(!g_ascii_isprint(tvb_get_guint8(next_tvb, i)))
2365         break;
2366
2367     if(i == len) {
2368       string = tvb_get_ephemeral_string(next_tvb, 0, tvb_length_remaining(next_tvb, 0));
2369       proto_item_set_text(actx->created_item, "AttributeValue: %s", string);
2370     }
2371   }
2372
2373
2374
2375   return offset;
2376 }
2377
2378
2379 static const ber_sequence_t SET_OF_AttributeValue_set_of[1] = {
2380   { &hf_ldap_vals_item      , BER_CLASS_UNI, BER_UNI_TAG_OCTETSTRING, BER_FLAGS_NOOWNTAG, dissect_ldap_AttributeValue },
2381 };
2382
2383 static int
2384 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_) {
2385   offset = dissect_ber_set_of(implicit_tag, actx, tree, tvb, offset,
2386                                  SET_OF_AttributeValue_set_of, hf_index, ett_ldap_SET_OF_AttributeValue);
2387
2388   return offset;
2389 }
2390
2391
2392 static const ber_sequence_t PartialAttributeList_item_sequence[] = {
2393   { &hf_ldap_type           , BER_CLASS_UNI, BER_UNI_TAG_OCTETSTRING, BER_FLAGS_NOOWNTAG, dissect_ldap_AttributeDescription },
2394   { &hf_ldap_vals           , BER_CLASS_UNI, BER_UNI_TAG_SET, BER_FLAGS_NOOWNTAG, dissect_ldap_SET_OF_AttributeValue },
2395   { NULL, 0, 0, 0, NULL }
2396 };
2397
2398 static int
2399 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_) {
2400   offset = dissect_ber_sequence(implicit_tag, actx, tree, tvb, offset,
2401                                    PartialAttributeList_item_sequence, hf_index, ett_ldap_PartialAttributeList_item);
2402
2403   return offset;
2404 }
2405
2406
2407 static const ber_sequence_t PartialAttributeList_sequence_of[1] = {
2408   { &hf_ldap_PartialAttributeList_item, BER_CLASS_UNI, BER_UNI_TAG_SEQUENCE, BER_FLAGS_NOOWNTAG, dissect_ldap_PartialAttributeList_item },
2409 };
2410
2411 static int
2412 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_) {
2413   offset = dissect_ber_sequence_of(implicit_tag, actx, tree, tvb, offset,
2414                                       PartialAttributeList_sequence_of, hf_index, ett_ldap_PartialAttributeList);
2415
2416   return offset;
2417 }
2418
2419
2420 static const ber_sequence_t SearchResultEntry_U_sequence[] = {
2421   { &hf_ldap_objectName     , BER_CLASS_UNI, BER_UNI_TAG_OCTETSTRING, BER_FLAGS_NOOWNTAG, dissect_ldap_LDAPDN },
2422   { &hf_ldap_searchResultEntry_attributes, BER_CLASS_UNI, BER_UNI_TAG_SEQUENCE, BER_FLAGS_NOOWNTAG, dissect_ldap_PartialAttributeList },
2423   { NULL, 0, 0, 0, NULL }
2424 };
2425
2426 static int
2427 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_) {
2428   offset = dissect_ber_sequence(implicit_tag, actx, tree, tvb, offset,
2429                                    SearchResultEntry_U_sequence, hf_index, ett_ldap_SearchResultEntry_U);
2430
2431   return offset;
2432 }
2433
2434
2435
2436 static int
2437 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_) {
2438   offset = dissect_ber_tagged_type(implicit_tag, actx, tree, tvb, offset,
2439                                       hf_index, BER_CLASS_APP, 4, TRUE, dissect_ldap_SearchResultEntry_U);
2440
2441   return offset;
2442 }
2443
2444
2445 static const value_string ldap_T_resultCode_vals[] = {
2446   {   0, "success" },
2447   {   1, "operationsError" },
2448   {   2, "protocolError" },
2449   {   3, "timeLimitExceeded" },
2450   {   4, "sizeLimitExceeded" },
2451   {   5, "compareFalse" },
2452   {   6, "compareTrue" },
2453   {   7, "authMethodNotSupported" },
2454   {   8, "strongAuthRequired" },
2455   {  10, "referral" },
2456   {  11, "adminLimitExceeded" },
2457   {  12, "unavailableCriticalExtension" },
2458   {  13, "confidentialityRequired" },
2459   {  14, "saslBindInProgress" },
2460   {  16, "noSuchAttribute" },
2461   {  17, "undefinedAttributeType" },
2462   {  18, "inappropriateMatching" },
2463   {  19, "constraintViolation" },
2464   {  20, "attributeOrValueExists" },
2465   {  21, "invalidAttributeSyntax" },
2466   {  32, "noSuchObject" },
2467   {  33, "aliasProblem" },
2468   {  34, "invalidDNSyntax" },
2469   {  36, "aliasDereferencingProblem" },
2470   {  48, "inappropriateAuthentication" },
2471   {  49, "invalidCredentials" },
2472   {  50, "insufficientAccessRights" },
2473   {  51, "busy" },
2474   {  52, "unavailable" },
2475   {  53, "unwillingToPerform" },
2476   {  54, "loopDetect" },
2477   {  64, "namingViolation" },
2478   {  65, "objectClassViolation" },
2479   {  66, "notAllowedOnNonLeaf" },
2480   {  67, "notAllowedOnRDN" },
2481   {  68, "entryAlreadyExists" },
2482   {  69, "objectClassModsProhibited" },
2483   {  71, "affectsMultipleDSAs" },
2484   {  80, "other" },
2485   { 118, "canceled" },
2486   { 119, "noSuchOperation" },
2487   { 120, "tooLate" },
2488   { 121, "cannotCancel" },
2489   { 0, NULL }
2490 };
2491
2492
2493 static int
2494 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_) {
2495 #line 426 "../../asn1/ldap/ldap.cnf"
2496
2497   const gchar *valstr;
2498
2499     offset = dissect_ber_integer(implicit_tag, actx, tree, tvb, offset, hf_index,
2500                                   &result);
2501
2502
2503   ldap_do_protocolop(actx->pinfo);
2504
2505   valstr = val_to_str(result, ldap_T_resultCode_vals, "Unknown result(%u)");
2506
2507   col_append_fstr(actx->pinfo->cinfo, COL_INFO, "%s ", valstr);
2508
2509   if(ldm_tree)
2510     proto_item_append_text(ldm_tree, " %s", valstr);
2511
2512
2513
2514
2515   return offset;
2516 }
2517
2518
2519 static const ber_sequence_t LDAPResult_sequence[] = {
2520   { &hf_ldap_resultCode     , BER_CLASS_UNI, BER_UNI_TAG_ENUMERATED, BER_FLAGS_NOOWNTAG, dissect_ldap_T_resultCode },
2521   { &hf_ldap_matchedDN      , BER_CLASS_UNI, BER_UNI_TAG_OCTETSTRING, BER_FLAGS_NOOWNTAG, dissect_ldap_LDAPDN },
2522   { &hf_ldap_errorMessage   , BER_CLASS_UNI, BER_UNI_TAG_OCTETSTRING, BER_FLAGS_NOOWNTAG, dissect_ldap_ErrorMessage },
2523   { &hf_ldap_referral       , BER_CLASS_CON, 3, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_ldap_Referral },
2524   { NULL, 0, 0, 0, NULL }
2525 };
2526
2527 static int
2528 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_) {
2529   offset = dissect_ber_sequence(implicit_tag, actx, tree, tvb, offset,
2530                                    LDAPResult_sequence, hf_index, ett_ldap_LDAPResult);
2531
2532   return offset;
2533 }
2534
2535
2536
2537 static int
2538 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_) {
2539   offset = dissect_ber_tagged_type(implicit_tag, actx, tree, tvb, offset,
2540                                       hf_index, BER_CLASS_APP, 5, TRUE, dissect_ldap_LDAPResult);
2541
2542   return offset;
2543 }
2544
2545
2546 static const ber_sequence_t SEQUENCE_OF_LDAPURL_sequence_of[1] = {
2547   { &hf_ldap__untag_item    , BER_CLASS_UNI, BER_UNI_TAG_OCTETSTRING, BER_FLAGS_NOOWNTAG, dissect_ldap_LDAPURL },
2548 };
2549
2550 static int
2551 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_) {
2552   offset = dissect_ber_sequence_of(implicit_tag, actx, tree, tvb, offset,
2553                                       SEQUENCE_OF_LDAPURL_sequence_of, hf_index, ett_ldap_SEQUENCE_OF_LDAPURL);
2554
2555   return offset;
2556 }
2557
2558
2559
2560 static int
2561 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_) {
2562 #line 821 "../../asn1/ldap/ldap.cnf"
2563
2564    offset = dissect_ber_tagged_type(implicit_tag, actx, tree, tvb, offset,
2565                                       hf_index, BER_CLASS_APP, 19, TRUE, dissect_ldap_SEQUENCE_OF_LDAPURL);
2566
2567
2568  ldap_do_protocolop(actx->pinfo);
2569
2570
2571
2572
2573   return offset;
2574 }
2575
2576
2577 static const value_string ldap_T_operation_vals[] = {
2578   {   0, "add" },
2579   {   1, "delete" },
2580   {   2, "replace" },
2581   { 0, NULL }
2582 };
2583
2584
2585 static int
2586 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_) {
2587   offset = dissect_ber_integer(implicit_tag, actx, tree, tvb, offset, hf_index,
2588                                   NULL);
2589
2590   return offset;
2591 }
2592
2593
2594 static const ber_sequence_t AttributeTypeAndValues_sequence[] = {
2595   { &hf_ldap_type           , BER_CLASS_UNI, BER_UNI_TAG_OCTETSTRING, BER_FLAGS_NOOWNTAG, dissect_ldap_AttributeDescription },
2596   { &hf_ldap_vals           , BER_CLASS_UNI, BER_UNI_TAG_SET, BER_FLAGS_NOOWNTAG, dissect_ldap_SET_OF_AttributeValue },
2597   { NULL, 0, 0, 0, NULL }
2598 };
2599
2600 static int
2601 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_) {
2602   offset = dissect_ber_sequence(implicit_tag, actx, tree, tvb, offset,
2603                                    AttributeTypeAndValues_sequence, hf_index, ett_ldap_AttributeTypeAndValues);
2604
2605   return offset;
2606 }
2607
2608
2609 static const ber_sequence_t T_modifyRequest_modification_item_sequence[] = {
2610   { &hf_ldap_operation      , BER_CLASS_UNI, BER_UNI_TAG_ENUMERATED, BER_FLAGS_NOOWNTAG, dissect_ldap_T_operation },
2611   { &hf_ldap_modification   , BER_CLASS_UNI, BER_UNI_TAG_SEQUENCE, BER_FLAGS_NOOWNTAG, dissect_ldap_AttributeTypeAndValues },
2612   { NULL, 0, 0, 0, NULL }
2613 };
2614
2615 static int
2616 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_) {
2617   offset = dissect_ber_sequence(implicit_tag, actx, tree, tvb, offset,
2618                                    T_modifyRequest_modification_item_sequence, hf_index, ett_ldap_T_modifyRequest_modification_item);
2619
2620   return offset;
2621 }
2622
2623
2624 static const ber_sequence_t ModifyRequest_modification_sequence_of[1] = {
2625   { &hf_ldap_modifyRequest_modification_item, BER_CLASS_UNI, BER_UNI_TAG_SEQUENCE, BER_FLAGS_NOOWNTAG, dissect_ldap_T_modifyRequest_modification_item },
2626 };
2627
2628 static int
2629 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_) {
2630   offset = dissect_ber_sequence_of(implicit_tag, actx, tree, tvb, offset,
2631                                       ModifyRequest_modification_sequence_of, hf_index, ett_ldap_ModifyRequest_modification);
2632
2633   return offset;
2634 }
2635
2636
2637 static const ber_sequence_t ModifyRequest_U_sequence[] = {
2638   { &hf_ldap_object         , BER_CLASS_UNI, BER_UNI_TAG_OCTETSTRING, BER_FLAGS_NOOWNTAG, dissect_ldap_LDAPDN },
2639   { &hf_ldap_modifyRequest_modification, BER_CLASS_UNI, BER_UNI_TAG_SEQUENCE, BER_FLAGS_NOOWNTAG, dissect_ldap_ModifyRequest_modification },
2640   { NULL, 0, 0, 0, NULL }
2641 };
2642
2643 static int
2644 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_) {
2645   offset = dissect_ber_sequence(implicit_tag, actx, tree, tvb, offset,
2646                                    ModifyRequest_U_sequence, hf_index, ett_ldap_ModifyRequest_U);
2647
2648   return offset;
2649 }
2650
2651
2652
2653 static int
2654 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_) {
2655   offset = dissect_ber_tagged_type(implicit_tag, actx, tree, tvb, offset,
2656                                       hf_index, BER_CLASS_APP, 6, TRUE, dissect_ldap_ModifyRequest_U);
2657
2658   return offset;
2659 }
2660
2661
2662
2663 static int
2664 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_) {
2665   offset = dissect_ber_tagged_type(implicit_tag, actx, tree, tvb, offset,
2666                                       hf_index, BER_CLASS_APP, 7, TRUE, dissect_ldap_LDAPResult);
2667
2668   return offset;
2669 }
2670
2671
2672 static const ber_sequence_t AttributeList_item_sequence[] = {
2673   { &hf_ldap_type           , BER_CLASS_UNI, BER_UNI_TAG_OCTETSTRING, BER_FLAGS_NOOWNTAG, dissect_ldap_AttributeDescription },
2674   { &hf_ldap_vals           , BER_CLASS_UNI, BER_UNI_TAG_SET, BER_FLAGS_NOOWNTAG, dissect_ldap_SET_OF_AttributeValue },
2675   { NULL, 0, 0, 0, NULL }
2676 };
2677
2678 static int
2679 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_) {
2680   offset = dissect_ber_sequence(implicit_tag, actx, tree, tvb, offset,
2681                                    AttributeList_item_sequence, hf_index, ett_ldap_AttributeList_item);
2682
2683   return offset;
2684 }
2685
2686
2687 static const ber_sequence_t AttributeList_sequence_of[1] = {
2688   { &hf_ldap_AttributeList_item, BER_CLASS_UNI, BER_UNI_TAG_SEQUENCE, BER_FLAGS_NOOWNTAG, dissect_ldap_AttributeList_item },
2689 };
2690
2691 static int
2692 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_) {
2693   offset = dissect_ber_sequence_of(implicit_tag, actx, tree, tvb, offset,
2694                                       AttributeList_sequence_of, hf_index, ett_ldap_AttributeList);
2695
2696   return offset;
2697 }
2698
2699
2700 static const ber_sequence_t AddRequest_U_sequence[] = {
2701   { &hf_ldap_entry          , BER_CLASS_UNI, BER_UNI_TAG_OCTETSTRING, BER_FLAGS_NOOWNTAG, dissect_ldap_LDAPDN },
2702   { &hf_ldap_attributes     , BER_CLASS_UNI, BER_UNI_TAG_SEQUENCE, BER_FLAGS_NOOWNTAG, dissect_ldap_AttributeList },
2703   { NULL, 0, 0, 0, NULL }
2704 };
2705
2706 static int
2707 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_) {
2708   offset = dissect_ber_sequence(implicit_tag, actx, tree, tvb, offset,
2709                                    AddRequest_U_sequence, hf_index, ett_ldap_AddRequest_U);
2710
2711   return offset;
2712 }
2713
2714
2715
2716 static int
2717 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_) {
2718   offset = dissect_ber_tagged_type(implicit_tag, actx, tree, tvb, offset,
2719                                       hf_index, BER_CLASS_APP, 8, TRUE, dissect_ldap_AddRequest_U);
2720
2721   return offset;
2722 }
2723
2724
2725
2726 static int
2727 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_) {
2728   offset = dissect_ber_tagged_type(implicit_tag, actx, tree, tvb, offset,
2729                                       hf_index, BER_CLASS_APP, 9, TRUE, dissect_ldap_LDAPResult);
2730
2731   return offset;
2732 }
2733
2734
2735
2736 static int
2737 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_) {
2738   offset = dissect_ber_tagged_type(implicit_tag, actx, tree, tvb, offset,
2739                                       hf_index, BER_CLASS_APP, 10, TRUE, dissect_ldap_LDAPDN);
2740
2741   return offset;
2742 }
2743
2744
2745
2746 static int
2747 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_) {
2748   offset = dissect_ber_tagged_type(implicit_tag, actx, tree, tvb, offset,
2749                                       hf_index, BER_CLASS_APP, 11, TRUE, dissect_ldap_LDAPResult);
2750
2751   return offset;
2752 }
2753
2754
2755
2756 static int
2757 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_) {
2758   offset = dissect_ldap_LDAPString(implicit_tag, tvb, offset, actx, tree, hf_index);
2759
2760   return offset;
2761 }
2762
2763
2764 static const ber_sequence_t ModifyDNRequest_U_sequence[] = {
2765   { &hf_ldap_entry          , BER_CLASS_UNI, BER_UNI_TAG_OCTETSTRING, BER_FLAGS_NOOWNTAG, dissect_ldap_LDAPDN },
2766   { &hf_ldap_newrdn         , BER_CLASS_UNI, BER_UNI_TAG_OCTETSTRING, BER_FLAGS_NOOWNTAG, dissect_ldap_RelativeLDAPDN },
2767   { &hf_ldap_deleteoldrdn   , BER_CLASS_UNI, BER_UNI_TAG_BOOLEAN, BER_FLAGS_NOOWNTAG, dissect_ldap_BOOLEAN },
2768   { &hf_ldap_newSuperior    , BER_CLASS_CON, 0, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_ldap_LDAPDN },
2769   { NULL, 0, 0, 0, NULL }
2770 };
2771
2772 static int
2773 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_) {
2774   offset = dissect_ber_sequence(implicit_tag, actx, tree, tvb, offset,
2775                                    ModifyDNRequest_U_sequence, hf_index, ett_ldap_ModifyDNRequest_U);
2776
2777   return offset;
2778 }
2779
2780
2781
2782 static int
2783 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_) {
2784   offset = dissect_ber_tagged_type(implicit_tag, actx, tree, tvb, offset,
2785                                       hf_index, BER_CLASS_APP, 12, TRUE, dissect_ldap_ModifyDNRequest_U);
2786
2787   return offset;
2788 }
2789
2790
2791
2792 static int
2793 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_) {
2794   offset = dissect_ber_tagged_type(implicit_tag, actx, tree, tvb, offset,
2795                                       hf_index, BER_CLASS_APP, 13, TRUE, dissect_ldap_LDAPResult);
2796
2797   return offset;
2798 }
2799
2800
2801 static const ber_sequence_t CompareRequest_U_sequence[] = {
2802   { &hf_ldap_entry          , BER_CLASS_UNI, BER_UNI_TAG_OCTETSTRING, BER_FLAGS_NOOWNTAG, dissect_ldap_LDAPDN },
2803   { &hf_ldap_ava            , BER_CLASS_UNI, BER_UNI_TAG_SEQUENCE, BER_FLAGS_NOOWNTAG, dissect_ldap_AttributeValueAssertion },
2804   { NULL, 0, 0, 0, NULL }
2805 };
2806
2807 static int
2808 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_) {
2809   offset = dissect_ber_sequence(implicit_tag, actx, tree, tvb, offset,
2810                                    CompareRequest_U_sequence, hf_index, ett_ldap_CompareRequest_U);
2811
2812   return offset;
2813 }
2814
2815
2816
2817 static int
2818 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_) {
2819   offset = dissect_ber_tagged_type(implicit_tag, actx, tree, tvb, offset,
2820                                       hf_index, BER_CLASS_APP, 14, TRUE, dissect_ldap_CompareRequest_U);
2821
2822   return offset;
2823 }
2824
2825
2826
2827 static int
2828 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_) {
2829   offset = dissect_ber_tagged_type(implicit_tag, actx, tree, tvb, offset,
2830                                       hf_index, BER_CLASS_APP, 15, TRUE, dissect_ldap_LDAPResult);
2831
2832   return offset;
2833 }
2834
2835
2836
2837 static int
2838 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_) {
2839 #line 828 "../../asn1/ldap/ldap.cnf"
2840
2841    offset = dissect_ber_tagged_type(implicit_tag, actx, tree, tvb, offset,
2842                                       hf_index, BER_CLASS_APP, 16, TRUE, dissect_ldap_MessageID);
2843
2844
2845  ldap_do_protocolop(actx->pinfo);
2846
2847
2848
2849   return offset;
2850 }
2851
2852
2853
2854 static int
2855 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_) {
2856 #line 54 "../../asn1/ldap/ldap.cnf"
2857
2858         tvbuff_t        *parameter_tvb;
2859         const gchar *name;
2860
2861
2862   offset = dissect_ber_octet_string(implicit_tag, actx, tree, tvb, offset, hf_index,
2863                                        &parameter_tvb);
2864
2865 #line 61 "../../asn1/ldap/ldap.cnf"
2866
2867         object_identifier_id = NULL;
2868
2869         if (!parameter_tvb)
2870                 return offset;
2871
2872         object_identifier_id = tvb_get_ephemeral_string(parameter_tvb, 0, tvb_length_remaining(parameter_tvb,0));
2873         name = oid_resolved_from_string(object_identifier_id);
2874
2875         if(name){
2876                 proto_item_append_text(actx->created_item, " (%s)", name);
2877
2878                 if((hf_index == hf_ldap_requestName) || (hf_index == hf_ldap_responseName)) {
2879                         ldap_do_protocolop(actx->pinfo);
2880                         col_append_fstr(actx->pinfo->cinfo, COL_INFO, "%s ", name);
2881                 }
2882         }
2883
2884         if(((hf_index == hf_ldap_responseName) || (hf_index == hf_ldap_requestName)) &&
2885             !strcmp(object_identifier_id, "1.3.6.1.4.1.1466.20037")) {
2886
2887                 /* we have agreed start_tls */
2888                 ldap_conv_info_t *ldap_info = NULL;
2889
2890                 ldap_info = (ldap_conv_info_t *)actx->pinfo->private_data;
2891
2892                 if(ldap_info) {
2893                         if(hf_index == hf_ldap_responseName)
2894                                 /* TLS in the next frame */
2895                                 ldap_info->start_tls_frame = (actx->pinfo->fd->num) + 1;
2896                         else
2897                                 /* remember we have asked to start_tls */
2898                                 ldap_info->start_tls_pending = TRUE;
2899                 }
2900         }
2901
2902
2903   return offset;
2904 }
2905
2906
2907
2908 static int
2909 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_) {
2910 #line 753 "../../asn1/ldap/ldap.cnf"
2911
2912         if((object_identifier_id != NULL) && oid_has_dissector(object_identifier_id)) {
2913                 offset = call_ber_oid_callback(object_identifier_id, tvb, offset, actx->pinfo, tree);
2914         } else {
2915                   offset = dissect_ber_octet_string(implicit_tag, actx, tree, tvb, offset, hf_index,
2916                                        NULL);
2917
2918         }
2919
2920
2921
2922   return offset;
2923 }
2924
2925
2926 static const ber_sequence_t ExtendedRequest_U_sequence[] = {
2927   { &hf_ldap_requestName    , BER_CLASS_CON, 0, BER_FLAGS_IMPLTAG, dissect_ldap_LDAPOID },
2928   { &hf_ldap_requestValue   , BER_CLASS_CON, 1, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_ldap_T_requestValue },
2929   { NULL, 0, 0, 0, NULL }
2930 };
2931
2932 static int
2933 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_) {
2934   offset = dissect_ber_sequence(implicit_tag, actx, tree, tvb, offset,
2935                                    ExtendedRequest_U_sequence, hf_index, ett_ldap_ExtendedRequest_U);
2936
2937   return offset;
2938 }
2939
2940
2941
2942 static int
2943 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_) {
2944   offset = dissect_ber_tagged_type(implicit_tag, actx, tree, tvb, offset,
2945                                       hf_index, BER_CLASS_APP, 23, TRUE, dissect_ldap_ExtendedRequest_U);
2946
2947   return offset;
2948 }
2949
2950
2951 static const value_string ldap_ExtendedResponse_resultCode_vals[] = {
2952   {   0, "success" },
2953   {   1, "operationsError" },
2954   {   2, "protocolError" },
2955   {   3, "timeLimitExceeded" },
2956   {   4, "sizeLimitExceeded" },
2957   {   5, "compareFalse" },
2958   {   6, "compareTrue" },
2959   {   7, "authMethodNotSupported" },
2960   {   8, "strongAuthRequired" },
2961   {  10, "referral" },
2962   {  11, "adminLimitExceeded" },
2963   {  12, "unavailableCriticalExtension" },
2964   {  13, "confidentialityRequired" },
2965   {  14, "saslBindInProgress" },
2966   {  16, "noSuchAttribute" },
2967   {  17, "undefinedAttributeType" },
2968   {  18, "inappropriateMatching" },
2969   {  19, "constraintViolation" },
2970   {  20, "attributeOrValueExists" },
2971   {  21, "invalidAttributeSyntax" },
2972   {  32, "noSuchObject" },
2973   {  33, "aliasProblem" },
2974   {  34, "invalidDNSyntax" },
2975   {  36, "aliasDereferencingProblem" },
2976   {  48, "inappropriateAuthentication" },
2977   {  49, "invalidCredentials" },
2978   {  50, "insufficientAccessRights" },
2979   {  51, "busy" },
2980   {  52, "unavailable" },
2981   {  53, "unwillingToPerform" },
2982   {  54, "loopDetect" },
2983   {  64, "namingViolation" },
2984   {  65, "objectClassViolation" },
2985   {  66, "notAllowedOnNonLeaf" },
2986   {  67, "notAllowedOnRDN" },
2987   {  68, "entryAlreadyExists" },
2988   {  69, "objectClassModsProhibited" },
2989   {  71, "affectsMultipleDSAs" },
2990   {  80, "other" },
2991   { 118, "canceled" },
2992   { 119, "noSuchOperation" },
2993   { 120, "tooLate" },
2994   { 121, "cannotCancel" },
2995   { 0, NULL }
2996 };
2997
2998
2999 static int
3000 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_) {
3001   offset = dissect_ber_integer(implicit_tag, actx, tree, tvb, offset, hf_index,
3002                                   NULL);
3003
3004   return offset;
3005 }
3006
3007
3008
3009 static int
3010 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_) {
3011   offset = dissect_ldap_LDAPOID(implicit_tag, tvb, offset, actx, tree, hf_index);
3012
3013   return offset;
3014 }
3015
3016
3017
3018 static int
3019 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_) {
3020   offset = dissect_ber_octet_string(implicit_tag, actx, tree, tvb, offset, hf_index,
3021                                        NULL);
3022
3023   return offset;
3024 }
3025
3026
3027 static const ber_sequence_t ExtendedResponse_U_sequence[] = {
3028   { &hf_ldap_extendedResponse_resultCode, BER_CLASS_UNI, BER_UNI_TAG_ENUMERATED, BER_FLAGS_NOOWNTAG, dissect_ldap_ExtendedResponse_resultCode },
3029   { &hf_ldap_matchedDN      , BER_CLASS_UNI, BER_UNI_TAG_OCTETSTRING, BER_FLAGS_NOOWNTAG, dissect_ldap_LDAPDN },
3030   { &hf_ldap_errorMessage   , BER_CLASS_UNI, BER_UNI_TAG_OCTETSTRING, BER_FLAGS_NOOWNTAG, dissect_ldap_ErrorMessage },
3031   { &hf_ldap_referral       , BER_CLASS_CON, 3, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_ldap_Referral },
3032   { &hf_ldap_responseName   , BER_CLASS_CON, 10, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_ldap_ResponseName },
3033   { &hf_ldap_response       , BER_CLASS_CON, 11, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_ldap_OCTET_STRING },
3034   { NULL, 0, 0, 0, NULL }
3035 };
3036
3037 static int
3038 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_) {
3039   offset = dissect_ber_sequence(implicit_tag, actx, tree, tvb, offset,
3040                                    ExtendedResponse_U_sequence, hf_index, ett_ldap_ExtendedResponse_U);
3041
3042   return offset;
3043 }
3044
3045
3046
3047 static int
3048 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_) {
3049   offset = dissect_ber_tagged_type(implicit_tag, actx, tree, tvb, offset,
3050                                       hf_index, BER_CLASS_APP, 24, TRUE, dissect_ldap_ExtendedResponse_U);
3051
3052   return offset;
3053 }
3054
3055
3056
3057 static int
3058 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_) {
3059 #line 761 "../../asn1/ldap/ldap.cnf"
3060
3061         const gchar *name;
3062
3063
3064 #line 765 "../../asn1/ldap/ldap.cnf"
3065         if(ldm_tree && object_identifier_id) {
3066                 proto_item_set_text(ldm_tree, "%s %s", "IntermediateResponse", object_identifier_id);
3067                 name = oid_resolved_from_string(object_identifier_id);
3068                 if(name)
3069                         proto_item_append_text(ldm_tree, " (%s)", name);
3070         }
3071         if((object_identifier_id != NULL) && oid_has_dissector(object_identifier_id)) {
3072                 offset = call_ber_oid_callback(object_identifier_id, tvb, offset, actx->pinfo, tree);
3073         } else {
3074                   offset = dissect_ber_octet_string(implicit_tag, actx, tree, tvb, offset, hf_index,
3075                                        NULL);
3076
3077         }
3078
3079
3080
3081   return offset;
3082 }
3083
3084
3085 static const ber_sequence_t IntermediateResponse_U_sequence[] = {
3086   { &hf_ldap_responseName   , BER_CLASS_CON, 0, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_ldap_ResponseName },
3087   { &hf_ldap_intermediateResponse_responseValue, BER_CLASS_CON, 1, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_ldap_T_intermediateResponse_responseValue },
3088   { NULL, 0, 0, 0, NULL }
3089 };
3090
3091 static int
3092 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_) {
3093   offset = dissect_ber_sequence(implicit_tag, actx, tree, tvb, offset,
3094                                    IntermediateResponse_U_sequence, hf_index, ett_ldap_IntermediateResponse_U);
3095
3096   return offset;
3097 }
3098
3099
3100
3101 static int
3102 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_) {
3103   offset = dissect_ber_tagged_type(implicit_tag, actx, tree, tvb, offset,
3104                                       hf_index, BER_CLASS_APP, 25, TRUE, dissect_ldap_IntermediateResponse_U);
3105
3106   return offset;
3107 }
3108
3109
3110 static const value_string ldap_ProtocolOp_vals[] = {
3111   {   0, "bindRequest" },
3112   {   1, "bindResponse" },
3113   {   2, "unbindRequest" },
3114   {   3, "searchRequest" },
3115   {   4, "searchResEntry" },
3116   {   5, "searchResDone" },
3117   {  19, "searchResRef" },
3118   {   6, "modifyRequest" },
3119   {   7, "modifyResponse" },
3120   {   8, "addRequest" },
3121   {   9, "addResponse" },
3122   {  10, "delRequest" },
3123   {  11, "delResponse" },
3124   {  12, "modDNRequest" },
3125   {  13, "modDNResponse" },
3126   {  14, "compareRequest" },
3127   {  15, "compareResponse" },
3128   {  16, "abandonRequest" },
3129   {  23, "extendedReq" },
3130   {  24, "extendedResp" },
3131   {  25, "intermediateResponse" },
3132   { 0, NULL }
3133 };
3134
3135 static const ber_choice_t ProtocolOp_choice[] = {
3136   {   0, &hf_ldap_bindRequest    , BER_CLASS_APP, 0, BER_FLAGS_NOOWNTAG, dissect_ldap_BindRequest },
3137   {   1, &hf_ldap_bindResponse   , BER_CLASS_APP, 1, BER_FLAGS_NOOWNTAG, dissect_ldap_BindResponse },
3138   {   2, &hf_ldap_unbindRequest  , BER_CLASS_APP, 2, BER_FLAGS_NOOWNTAG, dissect_ldap_UnbindRequest },
3139   {   3, &hf_ldap_searchRequest  , BER_CLASS_APP, 3, BER_FLAGS_NOOWNTAG, dissect_ldap_SearchRequest },
3140   {   4, &hf_ldap_searchResEntry , BER_CLASS_APP, 4, BER_FLAGS_NOOWNTAG, dissect_ldap_SearchResultEntry },
3141   {   5, &hf_ldap_searchResDone  , BER_CLASS_APP, 5, BER_FLAGS_NOOWNTAG, dissect_ldap_SearchResultDone },
3142   {  19, &hf_ldap_searchResRef   , BER_CLASS_APP, 19, BER_FLAGS_NOOWNTAG, dissect_ldap_SearchResultReference },
3143   {   6, &hf_ldap_modifyRequest  , BER_CLASS_APP, 6, BER_FLAGS_NOOWNTAG, dissect_ldap_ModifyRequest },
3144   {   7, &hf_ldap_modifyResponse , BER_CLASS_APP, 7, BER_FLAGS_NOOWNTAG, dissect_ldap_ModifyResponse },
3145   {   8, &hf_ldap_addRequest     , BER_CLASS_APP, 8, BER_FLAGS_NOOWNTAG, dissect_ldap_AddRequest },
3146   {   9, &hf_ldap_addResponse    , BER_CLASS_APP, 9, BER_FLAGS_NOOWNTAG, dissect_ldap_AddResponse },
3147   {  10, &hf_ldap_delRequest     , BER_CLASS_APP, 10, BER_FLAGS_NOOWNTAG, dissect_ldap_DelRequest },
3148   {  11, &hf_ldap_delResponse    , BER_CLASS_APP, 11, BER_FLAGS_NOOWNTAG, dissect_ldap_DelResponse },
3149   {  12, &hf_ldap_modDNRequest   , BER_CLASS_APP, 12, BER_FLAGS_NOOWNTAG, dissect_ldap_ModifyDNRequest },
3150   {  13, &hf_ldap_modDNResponse  , BER_CLASS_APP, 13, BER_FLAGS_NOOWNTAG, dissect_ldap_ModifyDNResponse },
3151   {  14, &hf_ldap_compareRequest , BER_CLASS_APP, 14, BER_FLAGS_NOOWNTAG, dissect_ldap_CompareRequest },
3152   {  15, &hf_ldap_compareResponse, BER_CLASS_APP, 15, BER_FLAGS_NOOWNTAG, dissect_ldap_CompareResponse },
3153   {  16, &hf_ldap_abandonRequest , BER_CLASS_APP, 16, BER_FLAGS_NOOWNTAG, dissect_ldap_AbandonRequest },
3154   {  23, &hf_ldap_extendedReq    , BER_CLASS_APP, 23, BER_FLAGS_NOOWNTAG, dissect_ldap_ExtendedRequest },
3155   {  24, &hf_ldap_extendedResp   , BER_CLASS_APP, 24, BER_FLAGS_NOOWNTAG, dissect_ldap_ExtendedResponse },
3156   {  25, &hf_ldap_intermediateResponse, BER_CLASS_APP, 25, BER_FLAGS_NOOWNTAG, dissect_ldap_IntermediateResponse },
3157   { 0, NULL, 0, 0, 0, NULL }
3158 };
3159
3160 static int
3161 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_) {
3162 #line 106 "../../asn1/ldap/ldap.cnf"
3163
3164   ldap_call_response_t *lcrp;
3165   ldap_conv_info_t *ldap_info = (ldap_conv_info_t *)actx->pinfo->private_data;
3166   do_protocolop = TRUE;
3167
3168
3169   offset = dissect_ber_choice(actx, tree, tvb, offset,
3170                                  ProtocolOp_choice, hf_index, ett_ldap_ProtocolOp,
3171                                  &ProtocolOp);
3172
3173 #line 112 "../../asn1/ldap/ldap.cnf"
3174
3175   if (ProtocolOp == -1) {
3176     return offset;
3177   }
3178
3179   /* ProtocolOp is the index, not the tag so convert it to the tag value */
3180   ProtocolOp = ldap_ProtocolOp_vals[ProtocolOp].value;
3181
3182   lcrp=ldap_match_call_response(tvb, actx->pinfo, tree, MessageID, ProtocolOp);
3183   if(lcrp){
3184     tap_queue_packet(ldap_tap, actx->pinfo, lcrp);
3185   }
3186
3187   /* XXX: the count will not work if the results span multiple TCP packets */
3188
3189   if(ldap_info && tree) { /* only count once - on tree pass */
3190     switch(ProtocolOp) {
3191
3192     case LDAP_RES_SEARCH_ENTRY:
3193         ldap_info->num_results++;
3194
3195         proto_item_append_text(tree, " [%d result%s]",
3196                         ldap_info->num_results, ldap_info->num_results == 1 ? "" : "s");
3197
3198         break;
3199
3200     case LDAP_RES_SEARCH_RESULT:
3201
3202         col_append_fstr(actx->pinfo->cinfo, COL_INFO, " [%d result%s]",
3203                         ldap_info->num_results, ldap_info->num_results == 1 ? "" : "s");
3204
3205         proto_item_append_text(tree, " [%d result%s]",
3206                         ldap_info->num_results, ldap_info->num_results == 1 ? "" : "s");
3207
3208         ldap_info->num_results = 0;
3209         break;
3210      default:
3211         break;
3212     }
3213   }
3214
3215   if(ldap_info && (ProtocolOp == LDAP_RES_EXTENDED)) {
3216         /* this is an extend result */
3217
3218         if(ldap_info->start_tls_pending && !ldap_info->start_tls_frame) {
3219                 /* XXX: some directories do not correctly return the responseName in the extendedResponse so we don't know start_tls has been negotiated */
3220
3221                 col_append_str(actx->pinfo->cinfo, COL_INFO, "[LDAP_START_TLS_OID responseName missing] ");
3222                 ldap_info->start_tls_frame = (actx->pinfo->fd->num) + 1;
3223         }
3224
3225         ldap_info->start_tls_pending = FALSE;
3226   }
3227
3228
3229   return offset;
3230 }
3231
3232
3233
3234 static int
3235 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_) {
3236   offset = dissect_ldap_LDAPOID(implicit_tag, tvb, offset, actx, tree, hf_index);
3237
3238   return offset;
3239 }
3240
3241
3242
3243 static int
3244 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_) {
3245 #line 734 "../../asn1/ldap/ldap.cnf"
3246         gint8 ber_class;
3247         gboolean pc, ind;
3248         gint32 tag;
3249         guint32 len;
3250
3251         if((object_identifier_id != NULL) && oid_has_dissector(object_identifier_id)) {
3252                 /* remove the OCTET STRING encoding */
3253                 offset=dissect_ber_identifier(actx->pinfo, NULL, tvb, offset, &ber_class, &pc, &tag);
3254                 offset=dissect_ber_length(actx->pinfo, NULL, tvb, offset, &len, &ind);
3255
3256                 call_ber_oid_callback(object_identifier_id, tvb, offset, actx->pinfo, tree);
3257
3258                 offset += len;
3259         } else {
3260                   offset = dissect_ber_octet_string(implicit_tag, actx, tree, tvb, offset, hf_index,
3261                                        NULL);
3262
3263         }
3264
3265
3266
3267
3268   return offset;
3269 }
3270
3271
3272 static const ber_sequence_t Control_sequence[] = {
3273   { &hf_ldap_controlType    , BER_CLASS_UNI, BER_UNI_TAG_OCTETSTRING, BER_FLAGS_NOOWNTAG, dissect_ldap_ControlType },
3274   { &hf_ldap_criticality    , BER_CLASS_UNI, BER_UNI_TAG_BOOLEAN, BER_FLAGS_OPTIONAL|BER_FLAGS_NOOWNTAG, dissect_ldap_BOOLEAN },
3275   { &hf_ldap_controlValue   , BER_CLASS_UNI, BER_UNI_TAG_OCTETSTRING, BER_FLAGS_OPTIONAL|BER_FLAGS_NOOWNTAG, dissect_ldap_T_controlValue },
3276   { NULL, 0, 0, 0, NULL }
3277 };
3278
3279 static int
3280 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_) {
3281   offset = dissect_ber_sequence(implicit_tag, actx, tree, tvb, offset,
3282                                    Control_sequence, hf_index, ett_ldap_Control);
3283
3284   return offset;
3285 }
3286
3287
3288 static const ber_sequence_t Controls_sequence_of[1] = {
3289   { &hf_ldap_Controls_item  , BER_CLASS_UNI, BER_UNI_TAG_SEQUENCE, BER_FLAGS_NOOWNTAG, dissect_ldap_Control },
3290 };
3291
3292 static int
3293 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_) {
3294   offset = dissect_ber_sequence_of(implicit_tag, actx, tree, tvb, offset,
3295                                       Controls_sequence_of, hf_index, ett_ldap_Controls);
3296
3297   return offset;
3298 }
3299
3300
3301 static const ber_sequence_t LDAPMessage_sequence[] = {
3302   { &hf_ldap_messageID      , BER_CLASS_UNI, BER_UNI_TAG_INTEGER, BER_FLAGS_NOOWNTAG, dissect_ldap_MessageID },
3303   { &hf_ldap_protocolOp     , BER_CLASS_ANY/*choice*/, -1/*choice*/, BER_FLAGS_NOOWNTAG|BER_FLAGS_NOTCHKTAG, dissect_ldap_ProtocolOp },
3304   { &hf_ldap_controls       , BER_CLASS_CON, 0, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_ldap_Controls },
3305   { NULL, 0, 0, 0, NULL }
3306 };
3307
3308 static int
3309 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_) {
3310   offset = dissect_ber_sequence(implicit_tag, actx, tree, tvb, offset,
3311                                    LDAPMessage_sequence, hf_index, ett_ldap_LDAPMessage);
3312
3313   return offset;
3314 }
3315
3316
3317
3318
3319
3320 static int
3321 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_) {
3322   offset = dissect_ber_integer(implicit_tag, actx, tree, tvb, offset, hf_index,
3323                                                 NULL);
3324
3325   return offset;
3326 }
3327
3328
3329 static const ber_sequence_t SearchControlValue_sequence[] = {
3330   { &hf_ldap_size           , BER_CLASS_UNI, BER_UNI_TAG_INTEGER, BER_FLAGS_NOOWNTAG, dissect_ldap_INTEGER },
3331   { &hf_ldap_cookie         , BER_CLASS_UNI, BER_UNI_TAG_OCTETSTRING, BER_FLAGS_NOOWNTAG, dissect_ldap_OCTET_STRING },
3332   { NULL, 0, 0, 0, NULL }
3333 };
3334
3335 static int
3336 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_) {
3337   offset = dissect_ber_sequence(implicit_tag, actx, tree, tvb, offset,
3338                                    SearchControlValue_sequence, hf_index, ett_ldap_SearchControlValue);
3339
3340   return offset;
3341 }
3342
3343
3344 static const ber_sequence_t SortKeyList_item_sequence[] = {
3345   { &hf_ldap_attributeType  , BER_CLASS_UNI, BER_UNI_TAG_OCTETSTRING, BER_FLAGS_NOOWNTAG, dissect_ldap_AttributeDescription },
3346   { &hf_ldap_orderingRule   , BER_CLASS_CON, 0, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_ldap_MatchingRuleId },
3347   { &hf_ldap_reverseOrder   , BER_CLASS_CON, 1, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_ldap_BOOLEAN },
3348   { NULL, 0, 0, 0, NULL }
3349 };
3350
3351 static int
3352 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_) {
3353   offset = dissect_ber_sequence(implicit_tag, actx, tree, tvb, offset,
3354                                    SortKeyList_item_sequence, hf_index, ett_ldap_SortKeyList_item);
3355
3356   return offset;
3357 }
3358
3359
3360 static const ber_sequence_t SortKeyList_sequence_of[1] = {
3361   { &hf_ldap_SortKeyList_item, BER_CLASS_UNI, BER_UNI_TAG_SEQUENCE, BER_FLAGS_NOOWNTAG, dissect_ldap_SortKeyList_item },
3362 };
3363
3364 static int
3365 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_) {
3366   offset = dissect_ber_sequence_of(implicit_tag, actx, tree, tvb, offset,
3367                                       SortKeyList_sequence_of, hf_index, ett_ldap_SortKeyList);
3368
3369   return offset;
3370 }
3371
3372
3373 static const value_string ldap_T_sortResult_vals[] = {
3374   {   0, "success" },
3375   {   1, "operationsError" },
3376   {   3, "timeLimitExceeded" },
3377   {   8, "strongAuthRequired" },
3378   {  11, "adminLimitExceeded" },
3379   {  16, "noSuchAttribute" },
3380   {  18, "inappropriateMatching" },
3381   {  50, "insufficientAccessRights" },
3382   {  51, "busy" },
3383   {  53, "unwillingToPerform" },
3384   {  80, "other" },
3385   { 0, NULL }
3386 };
3387
3388
3389 static int
3390 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_) {
3391   offset = dissect_ber_integer(implicit_tag, actx, tree, tvb, offset, hf_index,
3392                                   NULL);
3393
3394   return offset;
3395 }
3396
3397
3398 static const ber_sequence_t SortResult_sequence[] = {
3399   { &hf_ldap_sortResult     , BER_CLASS_UNI, BER_UNI_TAG_ENUMERATED, BER_FLAGS_NOOWNTAG, dissect_ldap_T_sortResult },
3400   { &hf_ldap_attributeType  , BER_CLASS_CON, 0, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_ldap_AttributeDescription },
3401   { NULL, 0, 0, 0, NULL }
3402 };
3403
3404 static int
3405 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_) {
3406   offset = dissect_ber_sequence(implicit_tag, actx, tree, tvb, offset,
3407                                    SortResult_sequence, hf_index, ett_ldap_SortResult);
3408
3409   return offset;
3410 }
3411
3412
3413 static const ber_sequence_t DirSyncFlagsSubEntry_sequence[] = {
3414   { &hf_ldap_value          , BER_CLASS_CON, 0, BER_FLAGS_IMPLTAG, dissect_ldap_INTEGER },
3415   { NULL, 0, 0, 0, NULL }
3416 };
3417
3418 static int
3419 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_) {
3420   offset = dissect_ber_sequence(implicit_tag, actx, tree, tvb, offset,
3421                                    DirSyncFlagsSubEntry_sequence, hf_index, ett_ldap_DirSyncFlagsSubEntry);
3422
3423   return offset;
3424 }
3425
3426
3427
3428 static int
3429 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_) {
3430 #line 778 "../../asn1/ldap/ldap.cnf"
3431         gint8 ber_class;
3432         gboolean pc;
3433         gint32 tag;
3434         guint32 len;
3435         gint32 val;
3436         header_field_info *hfinfo;
3437
3438         int otheroffset = offset;
3439         if(!implicit_tag){
3440                 dissect_ber_identifier(actx->pinfo, tree, tvb, otheroffset, &ber_class, &pc, &tag);
3441                 otheroffset=dissect_ber_length(actx->pinfo, tree, tvb, offset, &len, NULL);
3442         } else {
3443                 gint32 remaining=tvb_length_remaining(tvb, offset);
3444                 len=remaining>0 ? remaining : 0;
3445         }
3446
3447         offset = dissect_ber_integer(implicit_tag, actx, tree, tvb, offset, -1, &val);
3448
3449         hfinfo = proto_registrar_get_nth(hf_index);
3450
3451         if (val >0) {
3452                 proto_tree *subtree = NULL;
3453                 proto_item *item = NULL;
3454                 item = proto_tree_add_text(tree, tvb, otheroffset+1, len, "%s: 0x%08x", hfinfo->name, val);
3455                 subtree = proto_item_add_subtree(item, ett_ldap_DirSyncFlagsSubEntry);
3456
3457                 if (val & 0x1) {
3458                         proto_tree_add_text(subtree, tvb, otheroffset+1, len, "Flag Object_Security");
3459                 }
3460                 if (val & 0x800) {
3461                         proto_tree_add_text(subtree, tvb, otheroffset+1, len, "Flag Ancestor_First");
3462                 }
3463                 if (val & 0x2000) {
3464                         proto_tree_add_text(subtree, tvb, otheroffset+1, len, "Flag Public_Data_Only");
3465                 }
3466                 if (val & 0x80000000) {
3467                         proto_tree_add_text(subtree, tvb, otheroffset+1, len, "Flag Incremental_Value");
3468                 }
3469         } else {
3470                 proto_tree_add_text(tree, tvb, otheroffset+len, len, "%s: 0", hfinfo->name);
3471         }
3472
3473
3474
3475   return offset;
3476 }
3477
3478
3479 static const ber_sequence_t DirSyncControlValue_sequence[] = {
3480   { &hf_ldap_flags          , BER_CLASS_UNI, BER_UNI_TAG_INTEGER, BER_FLAGS_NOOWNTAG, dissect_ldap_DirSyncFlags },
3481   { &hf_ldap_maxBytes       , BER_CLASS_UNI, BER_UNI_TAG_INTEGER, BER_FLAGS_NOOWNTAG, dissect_ldap_INTEGER },
3482   { &hf_ldap_cookie         , BER_CLASS_UNI, BER_UNI_TAG_OCTETSTRING, BER_FLAGS_NOOWNTAG, dissect_ldap_OCTET_STRING },
3483   { NULL, 0, 0, 0, NULL }
3484 };
3485
3486 static int
3487 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_) {
3488   offset = dissect_ber_sequence(implicit_tag, actx, tree, tvb, offset,
3489                                    DirSyncControlValue_sequence, hf_index, ett_ldap_DirSyncControlValue);
3490
3491   return offset;
3492 }
3493
3494
3495 static const ber_sequence_t PasswdModifyRequestValue_sequence[] = {
3496   { &hf_ldap_userIdentity   , BER_CLASS_CON, 0, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_ldap_OCTET_STRING },
3497   { &hf_ldap_oldPasswd      , BER_CLASS_CON, 1, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_ldap_OCTET_STRING },
3498   { &hf_ldap_newPasswd      , BER_CLASS_CON, 2, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_ldap_OCTET_STRING },
3499   { NULL, 0, 0, 0, NULL }
3500 };
3501
3502 static int
3503 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_) {
3504   offset = dissect_ber_sequence(implicit_tag, actx, tree, tvb, offset,
3505                                    PasswdModifyRequestValue_sequence, hf_index, ett_ldap_PasswdModifyRequestValue);
3506
3507   return offset;
3508 }
3509
3510
3511 static const ber_sequence_t PasswdModifyResponseValue_sequence[] = {
3512   { &hf_ldap_genPasswd      , BER_CLASS_CON, 0, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_ldap_OCTET_STRING },
3513   { NULL, 0, 0, 0, NULL }
3514 };
3515
3516 static int
3517 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_) {
3518   offset = dissect_ber_sequence(implicit_tag, actx, tree, tvb, offset,
3519                                    PasswdModifyResponseValue_sequence, hf_index, ett_ldap_PasswdModifyResponseValue);
3520
3521   return offset;
3522 }
3523
3524
3525 static const ber_sequence_t CancelRequestValue_sequence[] = {
3526   { &hf_ldap_cancelID       , BER_CLASS_UNI, BER_UNI_TAG_INTEGER, BER_FLAGS_NOOWNTAG, dissect_ldap_MessageID },
3527   { NULL, 0, 0, 0, NULL }
3528 };
3529
3530 static int
3531 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_) {
3532   offset = dissect_ber_sequence(implicit_tag, actx, tree, tvb, offset,
3533                                    CancelRequestValue_sequence, hf_index, ett_ldap_CancelRequestValue);
3534
3535   return offset;
3536 }
3537
3538
3539 static const value_string ldap_T_mode_vals[] = {
3540   {   1, "refreshOnly" },
3541   {   3, "refreshAndPersist" },
3542   { 0, NULL }
3543 };
3544
3545
3546 static int
3547 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_) {
3548   offset = dissect_ber_integer(implicit_tag, actx, tree, tvb, offset, hf_index,
3549                                   NULL);
3550
3551   return offset;
3552 }
3553
3554
3555 static const ber_sequence_t SyncRequestValue_sequence[] = {
3556   { &hf_ldap_mode           , BER_CLASS_UNI, BER_UNI_TAG_ENUMERATED, BER_FLAGS_NOOWNTAG, dissect_ldap_T_mode },
3557   { &hf_ldap_cookie         , BER_CLASS_UNI, BER_UNI_TAG_OCTETSTRING, BER_FLAGS_OPTIONAL|BER_FLAGS_NOOWNTAG, dissect_ldap_OCTET_STRING },
3558   { &hf_ldap_reloadHint     , BER_CLASS_UNI, BER_UNI_TAG_BOOLEAN, BER_FLAGS_OPTIONAL|BER_FLAGS_NOOWNTAG, dissect_ldap_BOOLEAN },
3559   { NULL, 0, 0, 0, NULL }
3560 };
3561
3562 static int
3563 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_) {
3564   offset = dissect_ber_sequence(implicit_tag, actx, tree, tvb, offset,
3565                                    SyncRequestValue_sequence, hf_index, ett_ldap_SyncRequestValue);
3566
3567   return offset;
3568 }
3569
3570
3571 static const value_string ldap_T_state_vals[] = {
3572   {   0, "present" },
3573   {   1, "add" },
3574   {   2, "modify" },
3575   {   3, "delete" },
3576   { 0, NULL }
3577 };
3578
3579
3580 static int
3581 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_) {
3582   offset = dissect_ber_integer(implicit_tag, actx, tree, tvb, offset, hf_index,
3583                                   NULL);
3584
3585   return offset;
3586 }
3587
3588
3589
3590 static int
3591 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_) {
3592   offset = dissect_ber_octet_string(implicit_tag, actx, tree, tvb, offset, hf_index,
3593                                        NULL);
3594
3595   return offset;
3596 }
3597
3598
3599 static const ber_sequence_t SyncStateValue_sequence[] = {
3600   { &hf_ldap_state          , BER_CLASS_UNI, BER_UNI_TAG_ENUMERATED, BER_FLAGS_NOOWNTAG, dissect_ldap_T_state },
3601   { &hf_ldap_entryUUID      , BER_CLASS_UNI, BER_UNI_TAG_OCTETSTRING, BER_FLAGS_NOOWNTAG, dissect_ldap_SyncUUID },
3602   { &hf_ldap_cookie         , BER_CLASS_UNI, BER_UNI_TAG_OCTETSTRING, BER_FLAGS_OPTIONAL|BER_FLAGS_NOOWNTAG, dissect_ldap_OCTET_STRING },
3603   { NULL, 0, 0, 0, NULL }
3604 };
3605
3606 static int
3607 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_) {
3608   offset = dissect_ber_sequence(implicit_tag, actx, tree, tvb, offset,
3609                                    SyncStateValue_sequence, hf_index, ett_ldap_SyncStateValue);
3610
3611   return offset;
3612 }
3613
3614
3615 static const ber_sequence_t SyncDoneValue_sequence[] = {
3616   { &hf_ldap_cookie         , BER_CLASS_UNI, BER_UNI_TAG_OCTETSTRING, BER_FLAGS_OPTIONAL|BER_FLAGS_NOOWNTAG, dissect_ldap_OCTET_STRING },
3617   { &hf_ldap_refreshDeletes , BER_CLASS_UNI, BER_UNI_TAG_BOOLEAN, BER_FLAGS_OPTIONAL|BER_FLAGS_NOOWNTAG, dissect_ldap_BOOLEAN },
3618   { NULL, 0, 0, 0, NULL }
3619 };
3620
3621 static int
3622 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_) {
3623   offset = dissect_ber_sequence(implicit_tag, actx, tree, tvb, offset,
3624                                    SyncDoneValue_sequence, hf_index, ett_ldap_SyncDoneValue);
3625
3626   return offset;
3627 }
3628
3629
3630 static const ber_sequence_t T_refreshDelete_sequence[] = {
3631   { &hf_ldap_cookie         , BER_CLASS_UNI, BER_UNI_TAG_OCTETSTRING, BER_FLAGS_OPTIONAL|BER_FLAGS_NOOWNTAG, dissect_ldap_OCTET_STRING },
3632   { &hf_ldap_refreshDone    , BER_CLASS_UNI, BER_UNI_TAG_BOOLEAN, BER_FLAGS_OPTIONAL|BER_FLAGS_NOOWNTAG, dissect_ldap_BOOLEAN },
3633   { NULL, 0, 0, 0, NULL }
3634 };
3635
3636 static int
3637 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_) {
3638   offset = dissect_ber_sequence(implicit_tag, actx, tree, tvb, offset,
3639                                    T_refreshDelete_sequence, hf_index, ett_ldap_T_refreshDelete);
3640
3641   return offset;
3642 }
3643
3644
3645 static const ber_sequence_t T_refreshPresent_sequence[] = {
3646   { &hf_ldap_cookie         , BER_CLASS_UNI, BER_UNI_TAG_OCTETSTRING, BER_FLAGS_OPTIONAL|BER_FLAGS_NOOWNTAG, dissect_ldap_OCTET_STRING },
3647   { &hf_ldap_refreshDone    , BER_CLASS_UNI, BER_UNI_TAG_BOOLEAN, BER_FLAGS_OPTIONAL|BER_FLAGS_NOOWNTAG, dissect_ldap_BOOLEAN },
3648   { NULL, 0, 0, 0, NULL }
3649 };
3650
3651 static int
3652 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_) {
3653   offset = dissect_ber_sequence(implicit_tag, actx, tree, tvb, offset,
3654                                    T_refreshPresent_sequence, hf_index, ett_ldap_T_refreshPresent);
3655
3656   return offset;
3657 }
3658
3659
3660 static const ber_sequence_t SET_OF_SyncUUID_set_of[1] = {
3661   { &hf_ldap_syncUUIDs_item , BER_CLASS_UNI, BER_UNI_TAG_OCTETSTRING, BER_FLAGS_NOOWNTAG, dissect_ldap_SyncUUID },
3662 };
3663
3664 static int
3665 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_) {
3666   offset = dissect_ber_set_of(implicit_tag, actx, tree, tvb, offset,
3667                                  SET_OF_SyncUUID_set_of, hf_index, ett_ldap_SET_OF_SyncUUID);
3668
3669   return offset;
3670 }
3671
3672
3673 static const ber_sequence_t T_syncIdSet_sequence[] = {
3674   { &hf_ldap_cookie         , BER_CLASS_UNI, BER_UNI_TAG_OCTETSTRING, BER_FLAGS_OPTIONAL|BER_FLAGS_NOOWNTAG, dissect_ldap_OCTET_STRING },
3675   { &hf_ldap_refreshDeletes , BER_CLASS_UNI, BER_UNI_TAG_BOOLEAN, BER_FLAGS_OPTIONAL|BER_FLAGS_NOOWNTAG, dissect_ldap_BOOLEAN },
3676   { &hf_ldap_syncUUIDs      , BER_CLASS_UNI, BER_UNI_TAG_SET, BER_FLAGS_NOOWNTAG, dissect_ldap_SET_OF_SyncUUID },
3677   { NULL, 0, 0, 0, NULL }
3678 };
3679
3680 static int
3681 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_) {
3682   offset = dissect_ber_sequence(implicit_tag, actx, tree, tvb, offset,
3683                                    T_syncIdSet_sequence, hf_index, ett_ldap_T_syncIdSet);
3684
3685   return offset;
3686 }
3687
3688
3689 static const value_string ldap_SyncInfoValue_vals[] = {
3690   {   0, "newcookie" },
3691   {   1, "refreshDelete" },
3692   {   2, "refreshPresent" },
3693   {   3, "syncIdSet" },
3694   { 0, NULL }
3695 };
3696
3697 static const ber_choice_t SyncInfoValue_choice[] = {
3698   {   0, &hf_ldap_newcookie      , BER_CLASS_CON, 0, BER_FLAGS_IMPLTAG, dissect_ldap_OCTET_STRING },
3699   {   1, &hf_ldap_refreshDelete  , BER_CLASS_CON, 1, BER_FLAGS_IMPLTAG, dissect_ldap_T_refreshDelete },
3700   {   2, &hf_ldap_refreshPresent , BER_CLASS_CON, 2, BER_FLAGS_IMPLTAG, dissect_ldap_T_refreshPresent },
3701   {   3, &hf_ldap_syncIdSet      , BER_CLASS_CON, 3, BER_FLAGS_IMPLTAG, dissect_ldap_T_syncIdSet },
3702   { 0, NULL, 0, 0, 0, NULL }
3703 };
3704
3705 static int
3706 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_) {
3707   offset = dissect_ber_choice(actx, tree, tvb, offset,
3708                                  SyncInfoValue_choice, hf_index, ett_ldap_SyncInfoValue,
3709                                  NULL);
3710
3711   return offset;
3712 }
3713
3714
3715 static const value_string ldap_T_warning_vals[] = {
3716   {   0, "timeBeforeExpiration" },
3717   {   1, "graceAuthNsRemaining" },
3718   { 0, NULL }
3719 };
3720
3721 static const ber_choice_t T_warning_choice[] = {
3722   {   0, &hf_ldap_timeBeforeExpiration, BER_CLASS_CON, 0, BER_FLAGS_IMPLTAG, dissect_ldap_INTEGER_0_maxInt },
3723   {   1, &hf_ldap_graceAuthNsRemaining, BER_CLASS_CON, 1, BER_FLAGS_IMPLTAG, dissect_ldap_INTEGER_0_maxInt },
3724   { 0, NULL, 0, 0, 0, NULL }
3725 };
3726
3727 static int
3728 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_) {
3729   offset = dissect_ber_choice(actx, tree, tvb, offset,
3730                                  T_warning_choice, hf_index, ett_ldap_T_warning,
3731                                  NULL);
3732
3733   return offset;
3734 }
3735
3736
3737 static const value_string ldap_T_error_vals[] = {
3738   {   0, "passwordExpired" },
3739   {   1, "accountLocked" },
3740   {   2, "changeAfterReset" },
3741   {   3, "passwordModNotAllowed" },
3742   {   4, "mustSupplyOldPassword" },
3743   {   5, "insufficientPasswordQuality" },
3744   {   6, "passwordTooShort" },
3745   {   7, "passwordTooYoung" },
3746   {   8, "passwordInHistory" },
3747   { 0, NULL }
3748 };
3749
3750
3751 static int
3752 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_) {
3753   offset = dissect_ber_integer(implicit_tag, actx, tree, tvb, offset, hf_index,
3754                                   NULL);
3755
3756   return offset;
3757 }
3758
3759
3760 static const ber_sequence_t PasswordPolicyResponseValue_sequence[] = {
3761   { &hf_ldap_warning        , BER_CLASS_CON, 0, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_ldap_T_warning },
3762   { &hf_ldap_error          , BER_CLASS_CON, 1, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_ldap_T_error },
3763   { NULL, 0, 0, 0, NULL }
3764 };
3765
3766 static int
3767 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_) {
3768   offset = dissect_ber_sequence(implicit_tag, actx, tree, tvb, offset,
3769                                    PasswordPolicyResponseValue_sequence, hf_index, ett_ldap_PasswordPolicyResponseValue);
3770
3771   return offset;
3772 }
3773
3774 /*--- PDUs ---*/
3775
3776 static void dissect_LDAPMessage_PDU(tvbuff_t *tvb _U_, packet_info *pinfo _U_, proto_tree *tree _U_) {
3777   asn1_ctx_t asn1_ctx;
3778   asn1_ctx_init(&asn1_ctx, ASN1_ENC_BER, TRUE, pinfo);
3779   dissect_ldap_LDAPMessage(FALSE, tvb, 0, &asn1_ctx, tree, hf_ldap_LDAPMessage_PDU);
3780 }
3781 static void dissect_SearchControlValue_PDU(tvbuff_t *tvb _U_, packet_info *pinfo _U_, proto_tree *tree _U_) {
3782   asn1_ctx_t asn1_ctx;
3783   asn1_ctx_init(&asn1_ctx, ASN1_ENC_BER, TRUE, pinfo);
3784   dissect_ldap_SearchControlValue(FALSE, tvb, 0, &asn1_ctx, tree, hf_ldap_SearchControlValue_PDU);
3785 }
3786 static void dissect_SortKeyList_PDU(tvbuff_t *tvb _U_, packet_info *pinfo _U_, proto_tree *tree _U_) {
3787   asn1_ctx_t asn1_ctx;
3788   asn1_ctx_init(&asn1_ctx, ASN1_ENC_BER, TRUE, pinfo);
3789   dissect_ldap_SortKeyList(FALSE, tvb, 0, &asn1_ctx, tree, hf_ldap_SortKeyList_PDU);
3790 }
3791 static void dissect_SortResult_PDU(tvbuff_t *tvb _U_, packet_info *pinfo _U_, proto_tree *tree _U_) {
3792   asn1_ctx_t asn1_ctx;
3793   asn1_ctx_init(&asn1_ctx, ASN1_ENC_BER, TRUE, pinfo);
3794   dissect_ldap_SortResult(FALSE, tvb, 0, &asn1_ctx, tree, hf_ldap_SortResult_PDU);
3795 }
3796 static void dissect_DirSyncControlValue_PDU(tvbuff_t *tvb _U_, packet_info *pinfo _U_, proto_tree *tree _U_) {
3797   asn1_ctx_t asn1_ctx;
3798   asn1_ctx_init(&asn1_ctx, ASN1_ENC_BER, TRUE, pinfo);
3799   dissect_ldap_DirSyncControlValue(FALSE, tvb, 0, &asn1_ctx, tree, hf_ldap_DirSyncControlValue_PDU);
3800 }
3801 static void dissect_PasswdModifyRequestValue_PDU(tvbuff_t *tvb _U_, packet_info *pinfo _U_, proto_tree *tree _U_) {
3802   asn1_ctx_t asn1_ctx;
3803   asn1_ctx_init(&asn1_ctx, ASN1_ENC_BER, TRUE, pinfo);
3804   dissect_ldap_PasswdModifyRequestValue(FALSE, tvb, 0, &asn1_ctx, tree, hf_ldap_PasswdModifyRequestValue_PDU);
3805 }
3806 static void dissect_CancelRequestValue_PDU(tvbuff_t *tvb _U_, packet_info *pinfo _U_, proto_tree *tree _U_) {
3807   asn1_ctx_t asn1_ctx;
3808   asn1_ctx_init(&asn1_ctx, ASN1_ENC_BER, TRUE, pinfo);
3809   dissect_ldap_CancelRequestValue(FALSE, tvb, 0, &asn1_ctx, tree, hf_ldap_CancelRequestValue_PDU);
3810 }
3811 static void dissect_SyncRequestValue_PDU(tvbuff_t *tvb _U_, packet_info *pinfo _U_, proto_tree *tree _U_) {
3812   asn1_ctx_t asn1_ctx;
3813   asn1_ctx_init(&asn1_ctx, ASN1_ENC_BER, TRUE, pinfo);
3814   dissect_ldap_SyncRequestValue(FALSE, tvb, 0, &asn1_ctx, tree, hf_ldap_SyncRequestValue_PDU);
3815 }
3816 static void dissect_SyncStateValue_PDU(tvbuff_t *tvb _U_, packet_info *pinfo _U_, proto_tree *tree _U_) {
3817   asn1_ctx_t asn1_ctx;
3818   asn1_ctx_init(&asn1_ctx, ASN1_ENC_BER, TRUE, pinfo);
3819   dissect_ldap_SyncStateValue(FALSE, tvb, 0, &asn1_ctx, tree, hf_ldap_SyncStateValue_PDU);
3820 }
3821 static void dissect_SyncDoneValue_PDU(tvbuff_t *tvb _U_, packet_info *pinfo _U_, proto_tree *tree _U_) {
3822   asn1_ctx_t asn1_ctx;
3823   asn1_ctx_init(&asn1_ctx, ASN1_ENC_BER, TRUE, pinfo);
3824   dissect_ldap_SyncDoneValue(FALSE, tvb, 0, &asn1_ctx, tree, hf_ldap_SyncDoneValue_PDU);
3825 }
3826 static void dissect_SyncInfoValue_PDU(tvbuff_t *tvb _U_, packet_info *pinfo _U_, proto_tree *tree _U_) {
3827   asn1_ctx_t asn1_ctx;
3828   asn1_ctx_init(&asn1_ctx, ASN1_ENC_BER, TRUE, pinfo);
3829   dissect_ldap_SyncInfoValue(FALSE, tvb, 0, &asn1_ctx, tree, hf_ldap_SyncInfoValue_PDU);
3830 }
3831 static void dissect_PasswordPolicyResponseValue_PDU(tvbuff_t *tvb _U_, packet_info *pinfo _U_, proto_tree *tree _U_) {
3832   asn1_ctx_t asn1_ctx;
3833   asn1_ctx_init(&asn1_ctx, ASN1_ENC_BER, TRUE, pinfo);
3834   dissect_ldap_PasswordPolicyResponseValue(FALSE, tvb, 0, &asn1_ctx, tree, hf_ldap_PasswordPolicyResponseValue_PDU);
3835 }
3836
3837
3838 /*--- End of included file: packet-ldap-fn.c ---*/
3839 #line 877 "../../asn1/ldap/packet-ldap-template.c"
3840
3841 static void
3842 dissect_ldap_payload(tvbuff_t *tvb, packet_info *pinfo,
3843                      proto_tree *tree, ldap_conv_info_t *ldap_info,
3844                      gboolean is_mscldap)
3845 {
3846   int offset = 0;
3847   guint length_remaining;
3848   guint msg_len = 0;
3849   int messageOffset = 0;
3850   guint headerLength = 0;
3851   guint length = 0;
3852   tvbuff_t *msg_tvb = NULL;
3853   gint8 ber_class;
3854   gboolean pc, ind = 0;
3855   gint32 ber_tag;
3856
3857   attributedesc_string=NULL;
3858
3859
3860 one_more_pdu:
3861
3862     length_remaining = tvb_ensure_length_remaining(tvb, offset);
3863
3864     if (length_remaining < 6) return;
3865
3866     /*
3867      * OK, try to read the "Sequence Of" header; this gets the total
3868      * length of the LDAP message.
3869      */
3870         messageOffset = get_ber_identifier(tvb, offset, &ber_class, &pc, &ber_tag);
3871         messageOffset = get_ber_length(tvb, messageOffset, &msg_len, &ind);
3872
3873     /* sanity check */
3874     if((msg_len<4) || (msg_len>10000000)) return;
3875
3876     if ( (ber_class==BER_CLASS_UNI) && (ber_tag==BER_UNI_TAG_SEQUENCE) ) {
3877         /*
3878          * Add the length of the "Sequence Of" header to the message
3879          * length.
3880          */
3881         headerLength = messageOffset - offset;
3882         msg_len += headerLength;
3883         if (msg_len < headerLength) {
3884             /*
3885              * The message length was probably so large that the total length
3886              * overflowed.
3887              *
3888              * Report this as an error.
3889              */
3890             show_reported_bounds_error(tvb, pinfo, tree);
3891             return;
3892         }
3893     } else {
3894         /*
3895          * We couldn't parse the header; just make it the amount of data
3896          * remaining in the tvbuff, so we'll give up on this segment
3897          * after attempting to parse the message - there's nothing more
3898          * we can do.  "dissect_ldap_message()" will display the error.
3899          */
3900         msg_len = length_remaining;
3901     }
3902
3903     /*
3904      * Construct a tvbuff containing the amount of the payload we have
3905      * available.  Make its reported length the amount of data in the
3906      * LDAP message.
3907      *
3908      * XXX - if reassembly isn't enabled. the subdissector will throw a
3909      * BoundsError exception, rather than a ReportedBoundsError exception.
3910      * We really want a tvbuff where the length is "length", the reported
3911      * length is "plen", and the "if the snapshot length were infinite"
3912      * length is the minimum of the reported length of the tvbuff handed
3913      * to us and "plen", with a new type of exception thrown if the offset
3914      * is within the reported length but beyond that third length, with
3915      * that exception getting the "Unreassembled Packet" error.
3916      */
3917     length = length_remaining;
3918     if (length > msg_len) length = msg_len;
3919     msg_tvb = tvb_new_subset(tvb, offset, length, msg_len);
3920
3921     /*
3922      * Now dissect the LDAP message.
3923      */
3924     ldap_info->is_mscldap = is_mscldap;
3925     pinfo->private_data = ldap_info;
3926     dissect_LDAPMessage_PDU(msg_tvb, pinfo, tree);
3927
3928     offset += msg_len;
3929
3930     /* If this was a sasl blob there might be another PDU following in the
3931      * same blob
3932      */
3933     if(tvb_length_remaining(tvb, offset)>=6){
3934         tvb = tvb_new_subset_remaining(tvb, offset);
3935         offset = 0;
3936
3937         goto one_more_pdu;
3938     }
3939
3940 }
3941
3942 static void
3943 ldap_frame_end(void)
3944 {
3945    ldap_found_in_frame = FALSE;
3946    attr_type = NULL;
3947    ldapvalue_string = NULL;
3948 /* ? */
3949    attributedesc_string = NULL;
3950    Filter_string = NULL;
3951    and_filter_string = NULL;
3952    object_identifier_id = NULL;
3953    or_filter_string = NULL;
3954
3955    substring_item_any = NULL;
3956    substring_item_final = NULL;
3957    substring_item_init = NULL;
3958    substring_value = NULL;
3959
3960    ldm_tree = NULL;
3961
3962    Filter_elements = 0;
3963    Filter_length = 0;
3964    do_protocolop = FALSE;
3965    result = 0;
3966
3967 /* seems to be ok, but reset just in case */
3968    matching_rule_string = NULL;
3969 }
3970
3971 static void
3972         dissect_ldap_pdu(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, gboolean is_mscldap)
3973 {
3974         int offset = 0;
3975         conversation_t *conversation;
3976         gboolean doing_sasl_security = FALSE;
3977         guint length_remaining;
3978         ldap_conv_info_t *ldap_info = NULL;
3979         proto_item *ldap_item = NULL;
3980         proto_tree *ldap_tree = NULL;
3981
3982         ldm_tree = NULL;
3983
3984         conversation = find_or_create_conversation(pinfo);
3985
3986         /*
3987         * Do we already have a type and mechanism?
3988         */
3989         ldap_info = (ldap_conv_info_t *)conversation_get_proto_data(conversation, proto_ldap);
3990         if (ldap_info == NULL) {
3991                 /* No.  Attach that information to the conversation, and add
3992                 * it to the list of information structures.
3993                 */
3994                 ldap_info = g_new0(ldap_conv_info_t,1);
3995                 ldap_info->matched=g_hash_table_new(ldap_info_hash_matched, ldap_info_equal_matched);
3996                 ldap_info->unmatched=g_hash_table_new(ldap_info_hash_unmatched, ldap_info_equal_unmatched);
3997
3998                 conversation_add_proto_data(conversation, proto_ldap, ldap_info);
3999
4000                 ldap_info->next = ldap_info_items;
4001                 ldap_info_items = ldap_info;
4002
4003         }
4004
4005         switch (ldap_info->auth_type) {
4006         case LDAP_AUTH_SASL:
4007                 /*
4008                 * It's SASL; are we using a security layer?
4009                 */
4010                 if (ldap_info->first_auth_frame != 0 &&
4011                         pinfo->fd->num >= ldap_info->first_auth_frame) {
4012                                 doing_sasl_security = TRUE;     /* yes */
4013                 }
4014         }
4015
4016         length_remaining = tvb_ensure_length_remaining(tvb, offset);
4017
4018         /* It might still be a packet containing a SASL security layer
4019         * but it's just that we never saw the BIND packet.
4020         * check if it looks like it could be a SASL blob here
4021         * and in that case just assume it is GSS-SPNEGO
4022         */
4023         i