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