private IQueryable <LdapEvent> SearchEvent(IQueryable <Event> events, LdapClientConnection connection)
{
var now = DateTime.Now.Date;
if (!_admins.ContainsKey(connection.Id))
{
events = events
.Where(x => x.RegistrationStart != null || x.IsPermanentAndPublic)
.Where(x => x.RegistrationStart <= now || x.IsPermanentAndPublic)
.Where(x => x.End != null || x.IsPermanentAndPublic)
.Where(x => x.End >= now || x.IsPermanentAndPublic);
}
var filter = events
.Select(x => new LdapEvent
{
Id = x.Id,
Name = x.Name,
Description = x.DescriptionDe,
Location = x.Location
})
.Where(x => x.Name != null);
return(filter);
}
public TestLdapServer(DbContextOptions <Guru3Context> context)
: base(389, null)
{
_contextOptions = context;
_connection = new LdapClientConnection(null, null, new CancellationTokenSource());
}
protected override async Task <ResultCode> OnSaslBindAsync(LdapDistinguishedName bindDN, string username, ReadOnlyMemory <byte> password, LdapClientConnection connection)
{
if (String.IsNullOrEmpty(username))
{
Console.WriteLine($"bind to {bindDN} (anon) [{connection.Id}]");
return(ResultCode.Success);
}
using (var context = GetContext())
{
Console.WriteLine($"bind to {bindDN} ({username}) [{connection.Id}]");
var eventId = await context.Events.Where(x => x.Name == username).Select(x => x.Id).FirstOrDefaultAsync(connection.CancellationToken);
if (eventId != default)
{
Sessions.AddOrUpdate(connection.Id, eventId, (x, y) => eventId);
if (!String.IsNullOrEmpty(AdminToken))
{
var pass = Encoding.UTF8.GetString(password.Span);
if (pass == AdminToken)
{
_admins.AddOrUpdate(connection.Id, true, (x, y) => true);
}
}
return(ResultCode.Success);
}
else
{
return(ResultCode.InvalidCredentials);
}
}
}
protected override Task <ResultCode> OnBindAsync(LdapDistinguishedName bindDN, ReadOnlyMemory <byte> password, LdapClientConnection connection)
{
var username = bindDN.RDNs.SelectMany(x => x.Values).Select(x => x.Value).FirstOrDefault();
return(OnSaslBindAsync(bindDN, username, password, connection));
}
private IQueryable <LdapEvent> SearchEvent(IQueryable <Event> events, LdapSearchRequest request, LdapClientConnection connection)
{
return(SearchEvent(events, connection).Where(FilterEvent(request.Filter)));
}
private async Task <IEnumerable <LdapRequestMessage> > SearchEventAsync(IQueryable <Event> query, LdapSearchRequest request, LdapClientConnection connection, CancellationToken cancellationToken)
{
var eventQuery = SearchEvent(query, request, connection);
if (request.SizeLimit > 0)
{
eventQuery = eventQuery.Take(request.SizeLimit);
}
var result = await eventQuery.ToArrayAsync(cancellationToken);
var events = result.Select(x => new OrganizationalUnitObjectClass
{
Ou = { Entries = { x.Name } },
Description = String.IsNullOrEmpty(x.Description)
? null
: new DescriptionAttribute {
Entries = { x.Description }
},
Locality = String.IsNullOrEmpty(x.Location) ? null : new LocalityAttribute {
Entries = { x.Location }
}
}).ToList();
var results = new List <LdapRequestMessage>(events.Count);
foreach (var item in events)
{
var attributes = item.GetAttributes(request.Attributes, request.TypesOnly);
var dn = new LdapDistinguishedName(item.Ou.Name, item.Ou.Entries[0], RootDN);
results.Add(request.Result(dn, attributes.ToArray(), new LdapControl[0]));
}
return(results);
}
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);
}
}
}
