예제 #1
0
        public void CanParseDN(string dn, string expected = null)
        {
            var parsed = new LdapDistinguishedName(dn);

            if (expected is null)
            {
                expected = dn;
            }
            Assert.Equal(expected, parsed.ToString());
        }
예제 #2
0
        protected override async Task <IEnumerable <LdapRequestMessage> > OnSearchAsync(LdapSearchRequest request, LdapClientConnection connection, CancellationToken cancellationToken)
        {
            Console.WriteLine($"search for {request.Filter} in {request.BaseObject} ({request.Scope}) [{connection.Id}]");
            using (var context = GetContext())
            {
                IQueryable <Event> dbEvents = context.Events;
                if (Sessions.TryGetValue(connection.Id, out var eventId))
                {
                    dbEvents = dbEvents.Where(x => x.Id == eventId);
                }
                if (String.Equals(request.BaseObject.ToString(), RootDN.ToString(), StringComparison.OrdinalIgnoreCase))
                {
                    if (request.Scope == SearchScope.BaseObject)
                    {
                        //search root
                        var attributes = GetRootDSE().GetAttributes(request.Attributes, request.TypesOnly);
                        var result     = request.Result(RootDN, attributes.ToArray(), new LdapControl[0]);
                        return(new[] { result });
                    }
                    else
                    {
                        //search events
                        var events = await SearchEventAsync(dbEvents, request, connection, cancellationToken);

                        var results = events.ToList();

                        if (request.Scope == SearchScope.WholeSubtree)
                        {
                            //include extensions
                            var dbExtensions = SearchEvent(dbEvents, connection).Join(context.Extensions, x => x.Id, x => x.EventId, (x, y) => y);
                            var extension    = await SearchExtensionAsync(dbExtensions, request, cancellationToken);

                            if (request.SizeLimit > 0)
                            {
                                extension = extension.Take(request.SizeLimit - results.Count);
                            }
                            results.AddRange(extension);
                        }
                        return(results);
                    }
                }
                else
                {
                    var rdns = request.BaseObject.RDNs;
                    if (rdns.Count <= 2 || rdns.Count > 4)
                    {
                        return(new LdapRequestMessage[0]);
                    }

                    //search extensions
                    IQueryable <Extension> query = SearchEvent(dbEvents, connection).Join(context.Extensions, x => x.Id, x => x.EventId, (x, y) => y);

                    if (rdns.Count >= 3)
                    {
                        var eventName = rdns[rdns.Count - 3].Values[0].Value;
                        if (rdns.Count == 3 && request.Scope == SearchScope.BaseObject)
                        {
                            //get event
                            var events = await SearchEventAsync(dbEvents.Where(x => x.Name == eventName), request, connection, cancellationToken);

                            return(events.ToList());
                        }
                        query = query.Where(x => x.Event.Name == eventName);
                    }

                    if (rdns.Count == 4)
                    {
                        if (request.Scope != SearchScope.BaseObject)
                        {
                            return(new LdapRequestMessage[0]);
                        }

                        var extension = rdns[0].Values[0].Value;
                        query = query.Where(x => x.Number == extension);
                    }

                    if (Sessions.TryGetValue(connection.Id, out eventId))
                    {
                        query = query.Where(x => x.EventId == eventId);
                    }
                    var result = await SearchExtensionAsync(query, request, cancellationToken);

                    return(result);
                }
            }
        }