public List <BootstrapServer> GetBootstrapServers()
{
List <BootstrapServer> result = _CachedBootstrapServers;
if (result == null)
{
lock (this)
{
result = _CachedBootstrapServers;
if (result == null)
{
result = new List <BootstrapServer>();
IMongoDatabase database = GetDatabase(DATABASE_NAME, false);
IMongoCollection <BsonDocument> collection = database.GetCollection <BsonDocument>("BootstrapServer");
IAsyncCursor <BsonDocument> mongoCursor = collection.FindSync(new BsonDocument());
while (mongoCursor.MoveNext())
{
foreach (BsonDocument item in mongoCursor.Current)
{
BootstrapServer bootstrapServer = new BootstrapServer();
bootstrapServer.Url = BsonHelper.GetString(item, "_id");
if (item.Contains("ServerIdentities"))
{
BsonArray array = item["ServerIdentities"].AsBsonArray;
foreach (BsonValue arrayItem in array)
{
BsonDocument pskIdentityDoc = arrayItem.AsBsonDocument;
if (pskIdentityDoc != null)
{
PSKIdentity pskIdentity = new PSKIdentity();
pskIdentity.Identity = BsonHelper.GetString(pskIdentityDoc, "_id");
pskIdentity.Secret = BsonHelper.GetString(pskIdentityDoc, "Secret");
bootstrapServer.AddServerIdentity(pskIdentity);
}
}
}
if (item.Contains("ServerCertificate"))
{
BsonDocument serverCertificateDoc = item["ServerCertificate"].AsBsonDocument;
if (serverCertificateDoc != null)
{
bootstrapServer.ServerCertificate = new Certificate();
bootstrapServer.ServerCertificate.CertificateFormat = (TCertificateFormat)BsonHelper.GetInt32(serverCertificateDoc, "_id");
bootstrapServer.ServerCertificate.RawCertificate = BsonHelper.GetString(serverCertificateDoc, "RawCertificate");
}
}
result.Add(bootstrapServer);
}
}
_CachedBootstrapServers = result;
}
}
}
return(result);
}
private void ValidatePSK(System.Object sender, ValidatePSKEventArgs args)
{
#if DEBUG
Console.WriteLine("Validating PSK identity: " + System.Text.Encoding.UTF8.GetString(args.Identity));
#endif
PSKIdentity pskIdentity = BusinessLogicFactory.Identities.GetPSKIdentity(System.Text.Encoding.UTF8.GetString(args.Identity));
if (pskIdentity != null)
{
args.Secret = StringUtils.HexStringToByteArray(pskIdentity.Secret);
}
}
private PSKIdentity LoadPSKIdentityFromDoc(BsonDocument doc)
{
PSKIdentity result = null;
if (doc != null)
{
result = new PSKIdentity();
result.Identity = BsonHelper.GetString(doc, "_id");
result.Secret = BsonHelper.GetString(doc, "Secret");
result.OrganisationID = BsonHelper.GetInt32(doc, "OrganisationID");
}
return(result);
}
public PSKIdentity GetPSKIdentity(string identity)
{
PSKIdentity result = null;
if (!_PSKIdentities.TryGetItem(identity, out result))
{
IMongoDatabase database = GetDatabase(DATABASE_NAME, true);
IMongoCollection <BsonDocument> collection = database.GetCollection <BsonDocument>(COLLECTION_NAME);
BsonDocument doc = collection.Find(Builders <BsonDocument> .Filter.Eq("_id", identity)).FirstOrDefault();
result = LoadPSKIdentityFromDoc(doc);
_PSKIdentities.Add(identity, result);
}
return(result);
}
public void SavePSKIdentity(PSKIdentity pskIdentity, TObjectState state)
{
if (pskIdentity.OrganisationID == 0)
{
throw new NotSupportedException();
}
if (state == TObjectState.Add)
{
pskIdentity.Identity = StringUtils.GuidEncode(Guid.NewGuid());
byte[] secretkey = new Byte[32];
System.Security.Cryptography.RNGCryptoServiceProvider rng = new System.Security.Cryptography.RNGCryptoServiceProvider();
rng.GetBytes(secretkey);
pskIdentity.Secret = StringUtils.HexString(secretkey);
}
DataAccessFactory.Identities.SavePSKIdentity(pskIdentity, state);
}
public void SavePSKIdentity(PSKIdentity pskIdentity, TObjectState state)
{
if (pskIdentity.OrganisationID == 0)
{
throw new NotSupportedException();
}
if (state == TObjectState.Add)
{
pskIdentity.Identity = StringUtils.GuidEncode(Guid.NewGuid());
byte[] secretkey = new Byte[32];
System.Security.Cryptography.RNGCryptoServiceProvider rng = new System.Security.Cryptography.RNGCryptoServiceProvider();
rng.GetBytes(secretkey);
pskIdentity.Secret = StringUtils.HexString(secretkey);
}
DataAccessFactory.Identities.SavePSKIdentity(pskIdentity, state);
}
public List <PSKIdentity> GetPSKIdentities(int organisationID)
{
List <PSKIdentity> pskIdentities = new List <PSKIdentity>();
IMongoDatabase database = GetDatabase(DATABASE_NAME, true);
IMongoCollection <BsonDocument> collection = database.GetCollection <BsonDocument>(COLLECTION_NAME);
FilterDefinition <BsonDocument> query = Builders <BsonDocument> .Filter.Eq("OrganisationID", organisationID);
IAsyncCursor <BsonDocument> mongoCursor = collection.FindSync(query);
while (mongoCursor.MoveNext())
{
foreach (BsonDocument doc in mongoCursor.Current)
{
PSKIdentity pskIdentity = LoadPSKIdentityFromDoc(doc);
if (pskIdentity != null)
{
pskIdentities.Add(pskIdentity);
}
}
}
return(pskIdentities);
}
public void SavePSKIdentity(PSKIdentity pskIdentity, TObjectState state)
{
IMongoDatabase database = GetDatabase(DATABASE_NAME, true);
IMongoCollection <BsonDocument> collection = database.GetCollection <BsonDocument>(COLLECTION_NAME);
EnsureIndexExists <BsonDocument>(collection, "OrganisationID");
FilterDefinition <BsonDocument> query = Builders <BsonDocument> .Filter.Eq("_id", pskIdentity.Identity);
if ((state == TObjectState.Add) || (state == TObjectState.Update))
{
BsonDocument doc = new BsonDocument();
BsonHelper.SetValue(doc, "_id", pskIdentity.Identity);
BsonHelper.SetValue(doc, "Secret", pskIdentity.Secret);
BsonHelper.SetValue(doc, "OrganisationID", pskIdentity.OrganisationID);
UpdateOptions options = new UpdateOptions();
options.IsUpsert = true;
collection.ReplaceOne(query, doc, options);
}
else if (state == TObjectState.Delete)
{
collection.DeleteOne(query);
}
BroadcastTableChange(COLLECTION_NAME, pskIdentity.Identity);
}
public List <Server> GetServers()
{
List <Server> result = _CachedLWM2MServers;
if (result == null)
{
lock (this)
{
result = _CachedLWM2MServers;
if (result == null)
{
result = new List <Server>();
IMongoDatabase database = GetDatabase(DATABASE_NAME, false);
IMongoCollection <BsonDocument> collection = database.GetCollection <BsonDocument>("Server");
IAsyncCursor <BsonDocument> mongoCursor = collection.FindSync(new BsonDocument());
while (mongoCursor.MoveNext())
{
foreach (BsonDocument item in mongoCursor.Current)
{
LWM2MServer lwm2mServer = new LWM2MServer();
lwm2mServer.Url = BsonHelper.GetString(item, "_id");
lwm2mServer.Lifetime = (uint)BsonHelper.GetInt64(item, "Lifetime");
lwm2mServer.DefaultMinimumPeriod = (uint?)BsonHelper.GetLong(item, "DefaultMinimumPeriod");
lwm2mServer.DefaultMaximumPeriod = (uint?)BsonHelper.GetLong(item, "DefaultMaximumPeriod");
lwm2mServer.DisableTimeout = (uint?)BsonHelper.GetLong(item, "DisableTimeout");
lwm2mServer.NotificationStoringWhenOffline = BsonHelper.GetBoolean(item, "NotificationStoringWhenOffline");
lwm2mServer.Binding = (TBindingMode)BsonHelper.GetInt32(item, "Binding");
if (item.Contains("ServerIdentities"))
{
BsonArray array = item["ServerIdentities"].AsBsonArray;
foreach (BsonValue arrayItem in array)
{
BsonDocument pskIdentityDoc = arrayItem.AsBsonDocument;
if (pskIdentityDoc != null)
{
PSKIdentity pskIdentity = new PSKIdentity();
pskIdentity.Identity = BsonHelper.GetString(pskIdentityDoc, "_id");
pskIdentity.Secret = BsonHelper.GetString(pskIdentityDoc, "Secret");
lwm2mServer.AddServerIdentity(pskIdentity);
}
}
}
if (item.Contains("ServerCertificate"))
{
BsonDocument serverCertificateDoc = item["ServerCertificate"].AsBsonDocument;
if (serverCertificateDoc != null)
{
lwm2mServer.ServerCertificate = new Certificate();
lwm2mServer.ServerCertificate.CertificateFormat = (TCertificateFormat)BsonHelper.GetInt32(serverCertificateDoc, "_id");
lwm2mServer.ServerCertificate.RawCertificate = BsonHelper.GetString(serverCertificateDoc, "RawCertificate");
}
}
Server server = new Server(lwm2mServer);
server.ShortServerID = result.Count + 1;
foreach (Model.Security endPoint in server.EndPoints)
{
endPoint.ShortServerID = server.ShortServerID;
}
#if DEBUG
if (lwm2mServer.Url.ToLower().Contains(Environment.MachineName.ToLower()))
{
result.Add(server);
}
#else
result.Add(server);
#endif
}
}
_CachedLWM2MServers = result;
}
}
}
return(result);
}
private void ProcessRegisterRequest(Exchange exchange)
{
Request request = exchange.Request;
LWM2MClient client = new LWM2MClient();
client.Server = _ServerEndPoint;
client.Address = request.Source;
client.Parse(request.UriQueries);
ObjectTypes objectTypes = new ObjectTypes();
objectTypes.Parse(request.PayloadString);
client.SupportedTypes = objectTypes;
client.EndPoint = exchange.EndPoint;
if (_SecureChannel != null)
{
CertificateInfo certificateInfo = _SecureChannel.GetClientCertificateInfo(client.Address);
if (certificateInfo == null)
{
string pskIdentity = _SecureChannel.GetClientPSKIdentity(client.Address);
if (!string.IsNullOrEmpty(pskIdentity))
{
Guid clientID;
PSKIdentity identity = DataAccessFactory.Identities.GetPSKIdentity(pskIdentity);
if (identity != null)
{
if (StringUtils.GuidTryDecode(pskIdentity, out clientID))
{
client.ClientID = clientID;
}
client.OrganisationID = identity.OrganisationID;
}
}
}
else
{
Console.WriteLine(certificateInfo.Subject.CommonName);
Console.WriteLine(certificateInfo.Subject.Organistion);
Guid clientID;
if (Guid.TryParse(certificateInfo.Subject.CommonName, out clientID))
{
client.ClientID = clientID;
}
int organisationID;
if (int.TryParse(certificateInfo.Subject.Organistion, out organisationID))
{
client.OrganisationID = organisationID;
}
}
}
if (client.ClientID != Guid.Empty && (client.OrganisationID > 0 || !SecureOnly) && !DataAccessFactory.Clients.IsBlacklisted(client.ClientID))
{
BusinessLogicFactory.Clients.AddClient(client);
}
Response response = Response.CreateResponse(request, StatusCode.Created);
//response.AddOption(Option.Create(OptionType.LocationPath, string.Concat("rd/",StringUtils.GuidEncode(client.ClientID))));
response.AddOption(Option.Create(OptionType.LocationPath, "rd"));
response.AddOption(Option.Create(OptionType.LocationPath, StringUtils.GuidEncode(client.ClientID)));
exchange.SendResponse(response);
ApplicationEventLog.Write(LogLevel.Information, string.Concat("Client registered ", client.Name, " address ", client.Address.ToString()));
}
