Esempio n. 1
0
        /// <summary>
        /// Creates a SearchResultDone packet.
        /// </summary>
        /// <param name="context">The user context which contains message ID.</param>
        /// <param name="resultCode">Result code of previous request, as specified in RFC 2251.</param>
        /// <param name="matchedDn">Matched DN.</param>
        /// <param name="errorMessage">Error message for result code. Required.</param>
        /// <param name="referral">Referral. Optional.</param>
        /// <returns>The packet that contains the response.</returns>
        internal override AdtsSearchResultDonePacket CreateSearchResultDone(
            AdtsLdapContext context,
            MsLdap.ResultCode resultCode,
            string matchedDn,
            string errorMessage,
            string[] referral)
        {
            SearchResultDone searchResultDone = new SearchResultDone(
                new LDAPResult_resultCode((long)resultCode),
                new LDAPDN(matchedDn ?? string.Empty),
                new LDAPString(errorMessage ?? string.Empty),
                CreateReferral(referral));

            LDAPMessage_protocolOp operation = new LDAPMessage_protocolOp();

            operation.SetData(LDAPMessage_protocolOp.searchResDone, searchResultDone);

            LDAPMessage message = new LDAPMessage(new MessageID(context.MessageId), operation, null);
            AdtsSearchResultDonePacket packet = new AdtsSearchResultDonePacket();

            packet.ldapMessagev3 = message;
            packet.messageId     = context.MessageId;

            return(packet);
        }
        async Task <HandlerReply> IRequestHandler <SearchRequest> .Handle(ClientContext context, LdapEvents eventListener, SearchRequest operation)
        {
            SearchEvent searchEvent = new SearchEvent
            {
                SearchRequest = operation,
            };
            List <SearchResultReply> replies = await eventListener.OnSearchRequest(context, searchEvent);

            List <IProtocolOp> opReply = new List <IProtocolOp>();

            foreach (SearchResultReply reply in replies)
            {
                SearchResultEntry entry = new SearchResultEntry(reply);
                opReply.Add(entry);
            }

            var resultCode = (replies.Count > 0) ? LdapResult.ResultCodeEnum.Success : LdapResult.ResultCodeEnum.NoSuchObject;

            LdapResult       ldapResult       = new LdapResult(resultCode, null, null);
            SearchResultDone searchResultDone = new SearchResultDone(ldapResult);

            opReply.Add(searchResultDone);

            return(new HandlerReply(opReply));
        }
Esempio n. 3
0
        private static LdapPacket BuildError(LdapPacket request, LdapException ex)
        {
            BaseOperationDone operation = null;

            switch (request.ProtocolOperation.Tag.LdapCommand)
            {
            case LdapCommands.AddRequest:
                operation = new AddResponse();
                break;

            case LdapCommands.BindRequest:
                operation = new BindResponse();
                break;

            case LdapCommands.DelRequest:
                operation = new DelResponse();
                break;

            case LdapCommands.SearchRequest:
                operation = new SearchResultDone();
                break;

            case LdapCommands.ModifyRequest:
                operation = new ModifyResponse();
                break;
            }

            operation.Result = new LDAPResult
            {
                MatchedDN         = new DEROctetString(ex.Target),
                DiagnosticMessage = new DEROctetString(ex.Message),
                ResultCode        = new DEREnumerated <LDAPResultCodes>
                {
                    Value = ex.Code
                }
            };
            var ldapPacket = new LdapPacket
            {
                MessageId         = request.MessageId,
                ProtocolOperation = new DERProtocolOperation
                {
                    Operation = operation
                }
            };

            return(ldapPacket);
        }
        public static DERProtocolOperation Extract(ICollection <byte> buffer)
        {
            var result = new DERProtocolOperation();

            result.ExtractTagAndLength(buffer);
            switch (result.Tag.LdapCommand)
            {
            case LdapCommands.SearchRequest:
                result.Operation = SearchRequest.Extract(buffer);
                break;

            case LdapCommands.BindRequest:
                result.Operation = BindRequest.Extract(buffer);
                break;

            case LdapCommands.UnbindRequest:
                result.Operation = UnbindRequest.Extract(buffer);
                break;

            case LdapCommands.AddRequest:
                result.Operation = AddRequest.Extract(buffer);
                break;

            case LdapCommands.DelRequest:
                result.Operation = DelRequest.Extract(buffer, result.Length);
                break;

            case LdapCommands.ModifyDNRequest:
                result.Operation = ModifyDNRequest.Extract(buffer);
                break;

            case LdapCommands.CompareRequest:
                result.Operation = CompareRequest.Extract(buffer);
                break;

            case LdapCommands.AbandonRequest:
                result.Operation = AbandonRequest.Extract(buffer);
                break;

            case LdapCommands.ModifyRequest:
                result.Operation = ModifyRequest.Extract(buffer);
                break;

            case LdapCommands.SearchResultDone:
                result.Operation = SearchResultDone.Extract(buffer);
                break;

            case LdapCommands.BindResponse:
                result.Operation = BindResponse.Extract(buffer);
                break;

            case LdapCommands.AddResponse:
                result.Operation = AddResponse.Extract(buffer);
                break;

            case LdapCommands.SearchResultEntry:
                result.Operation = SearchResultEntry.Extract(buffer);
                break;
            }

            return(result);
        }