public void OnMessageReceived(WaveServerComponent dest, Enum msgID, WaveMessage data)
{
if (msgID is AggregateMessageMessageID)
{
if (data != null)
{
if ((AggregateMessageMessageID)msgID == AggregateMessageMessageID.AggregateMessage)
{
foreach (IFieldBase field in data.RootList)
{
if ((field is BinaryField) && (field.FieldID == (short)AggregateMessageFieldID.PackedMessage))
{
// we have embedded message - lets unpack and publish that
BinaryField tempBinary = (BinaryField)field;
if ((tempBinary.Data != null) && (tempBinary.Data.Length > 0))
{
Core.RouteServerMessage(new WaveMessage(tempBinary.Data));
}
}
}
}
}
}
}
protected override Frame ParseFrame(byte[] data)
{
int place = 0;
SingleByteField encodingField = new SingleByteField();
place += encodingField.Parse(data, place);
TextField imageFormatField = TextField.CreateTextField(true, EncodingScheme.Ascii);
place += imageFormatField.Parse(data, place);
SingleByteField pictureTypeField = new SingleByteField();
place += pictureTypeField.Parse(data, place);
TextField descriptionField = TextField.CreateTextField(true, (EncodingScheme)encodingField.Value);
place += descriptionField.Parse(data, place);
BinaryField dataField = new BinaryField();
place += dataField.Parse(data, place);
System.IO.MemoryStream memoryImageBuffer = new System.IO.MemoryStream(dataField.Data);
try {
Image image = Image.Load(memoryImageBuffer);
return(new PictureFrame(dataField.Data, image, descriptionField.Text, (PictureType)pictureTypeField.Value));
}
catch (ArgumentException) {
throw new FrameParsingException("Unrecognized picture format found in Picture frame.");
}
}
//TODO: Bad name: GetJsonObject is a method for odata serializing
internal static object GetJsonObject(Field field, string selfUrl)
{
object data;
if (field is ReferenceField)
{
return(ODataReference.Create(String.Concat(selfUrl, "/", field.Name)));
}
else if (field is BinaryField)
{
var binaryField = (BinaryField)field;
var binaryData = (BinaryData)binaryField.GetData();
return(ODataBinary.Create(BinaryField.GetBinaryUrl(field.Content.Id, field.Name, binaryData.Timestamp), null, binaryData.ContentType, null));
}
else if (ODataHandler.DeferredFieldNames.Contains(field.Name))
{
return(ODataReference.Create(String.Concat(selfUrl, "/", field.Name)));
}
data = field.GetData();
var nodeType = data as NodeType;
if (nodeType != null)
{
return(nodeType.Name);
}
return(data);
}
private unsafe bool WriteField(BinaryField fieldEnum, byte **ptr, long diff)
{
var field = (byte)((byte)fieldEnum << 3);
if (diff == 0)
{
return(false);
}
else if (diff >= byte.MinValue && diff <= byte.MaxValue)
{
field |= (byte)FieldSize.Byte;
*(*ptr) = field; (*ptr)++;
*(*ptr) = (byte)diff; (*ptr)++;
}
else if (diff >= short.MinValue && diff <= short.MaxValue)
{
field |= (byte)FieldSize.Short;
*(*ptr) = field; (*ptr)++;
*(short *)(*ptr) = (short)diff; (*ptr) += sizeof(short);
}
else if (diff >= int.MinValue && diff <= int.MaxValue)
{
field |= (byte)FieldSize.Int;
*(*ptr) = field; (*ptr)++;
*(int *)(*ptr) = (int)diff; (*ptr) += sizeof(int);
}
else
{
field |= (byte)FieldSize.Long;
*(*ptr) = field; (*ptr)++;
*(long *)(*ptr) = diff; (*ptr) += sizeof(long);
}
return(true);
}
public void Value()
{
byte[] value = Encoding.UTF7.GetBytes("Test FieldValue property.");
string stringValue = "Another value.";
BinaryField field = new BinaryField(18);
Assert.IsNull(field.Value);
field.Value = value;
Assert.IsTrue(field.Value is byte[]);
byte[] fieldValue = ( byte[])(field.Value);
Assert.IsTrue(value.Length == fieldValue.Length);
for (int i = 0; i < value.Length; i++)
{
Assert.IsTrue(value[i] == fieldValue[i]);
}
field.Value = stringValue;
fieldValue = ( byte[])(field.Value);
Assert.IsTrue(stringValue.Equals(Encoding.UTF7.GetString(fieldValue)));
try {
field.Value = field.FieldNumber;
Assert.Fail();
} catch (ArgumentException e) {
Assert.IsTrue(e.ParamName == "value");
}
}
internal static object GetJsonObject(Field field, string selfUrl, ODataRequest oDataRequest)
{
object data;
if (field is ReferenceField)
{
return(ODataReference.Create(String.Concat(selfUrl, "/", field.Name)));
}
else if (field is BinaryField binaryField)
{
try
{
// load binary fields only if the content is finalized
var binaryData = field.Content.ContentHandler.SavingState == ContentSavingState.Finalized
? (BinaryData)binaryField.GetData()
: null;
return(ODataBinary.Create(BinaryField.GetBinaryUrl(binaryField.Content.Id, binaryField.Name, binaryData?.Timestamp ?? default),
null, binaryData?.ContentType, null));
}
catch (Exception ex)
{
SnTrace.System.WriteError(
$"Error accessing field {field.Name} of {field.Content.Path} with user {User.Current.Username}: " +
ex.Message);
return(null);
}
}
else if (ODataMiddleware.DeferredFieldNames.Contains(field.Name))
{
return(ODataReference.Create(String.Concat(selfUrl, "/", field.Name)));
}
try
{
data = field.GetData();
}
catch (SenseNetSecurityException)
{
// The user does not have access to this field (e.g. cannot load
// a referenced content). In this case we serve a null value.
data = null;
SnTrace.Repository.Write("PERMISSION warning: user {0} does not have access to field '{1}' of {2}.", User.LoggedInUser.Username, field.Name, field.Content.Path);
}
if (data is NodeType nodeType)
{
return(nodeType.Name);
}
if (data is RichTextFieldValue rtfValue)
{
return(GetRichTextOutput(field.Name, rtfValue, oDataRequest));
}
return(data);
}
public void TestToString()
{
byte[] value = Encoding.UTF7.GetBytes("Test ToString method.");
BinaryField field = new BinaryField(12);
Assert.IsTrue(string.Empty.Equals(field.ToString()));
field.Value = value;
Assert.IsTrue(Encoding.UTF7.GetString(value).Equals(field.ToString()));
}
protected override Frame ParseFrame(byte[] data)
{
int place = 0;
BinaryField dataField = new BinaryField();
place += dataField.Parse(data, place);
return(new MusicCDIdentifierFrame(dataField.Data));
}
internal static object ProjectBinaryField(BinaryField field, string[] selection, HttpContext httpContext)
{
var allSelected = selection == null || selection.Length == 0 || selection[0] == "*";
var stream = DocumentBinaryProvider.Instance.GetStream(field.Content.ContentHandler,
field.Name, httpContext, out var contentType, out var binaryFileName);
var message = string.Empty;
var contentName = field.Content.Name;
var extension = Path.GetExtension(contentName)?.Trim('.');
var maxSize = SC.Settings.GetValue(Settings.SettingsName, Settings.MaxExpandableSize,
null, 1024 * 1024);
if (stream.Length > maxSize)
{
message = $"Size limit exceed. Limit: {maxSize}, size: {stream.Length}";
}
else
{
var whitelist = TextFileExtensions;
if (whitelist.Length > 0 && !whitelist.Contains(extension, StringComparer.OrdinalIgnoreCase))
{
message = $"Not a text file. The *.{extension} is restricted by the file extension list.";
}
}
var text = string.IsNullOrEmpty(message)
? ReadBinaryContent(stream, out message)
: null;
var result = new Dictionary <string, object>();
if (allSelected || selection.Contains(Expansion.FileName))
{
result.Add(Expansion.FileName, binaryFileName.ToString());
}
if (allSelected || selection.Contains(Expansion.ContentType))
{
result.Add(Expansion.ContentType, contentType);
}
if (allSelected || selection.Contains(Expansion.Length))
{
result.Add(Expansion.Length, stream.Length);
}
if (allSelected || selection.Contains(Expansion.Message))
{
result.Add(Expansion.Message, message);
}
if (allSelected || selection.Contains(Expansion.Text))
{
result.Add(Expansion.Text, text);
}
return(result);
}
public void NewComponent()
{
byte[] value = Encoding.UTF7.GetBytes("Test NewComponent method.");
BinaryField field = new BinaryField(18, value);
MessagingComponent component = field.NewComponent();
Assert.IsTrue(component is BinaryField);
Assert.IsTrue(field.FieldNumber ==
(( BinaryField)component).FieldNumber);
Assert.IsNull((( BinaryField)component).Value);
}
public void OnMessageReceived(WaveServerComponent dest, Enum msgID, WaveMessage data)
{
if (msgID is CacheAgentMessageID)
{
if (data != null)
{
switch ((CacheAgentMessageID)msgID)
{
case CacheAgentMessageID.RequestCacheHash:
{
WaveMessage msgOut = new WaveMessage();
msgOut.AddBinary(CacheAgentFieldID.CacheHash, Server.CalculateHash());
// return cache's own CIID (if any)
if (cacheID.HasValue)
{
msgOut.AddBinary(MessageOutFieldID.CacheItemID, cacheID.Value.ToByteArray());
}
msgOut.Send(WaveServerComponent.CacheAgent, CacheAgentMessageID.CacheHashCheck);
break;
}
case CacheAgentMessageID.SendWABCacheCIID:
{
BinaryField bin = (BinaryField)data[MessageOutFieldID.CacheItemID];
if (bin.Data != null)
{
CacheItemID temp = new CacheItemID(bin.Data);
if (!cacheID.HasValue || !cacheID.Value.Equals(temp))
{
cacheID = temp;
goto case CacheAgentMessageID.ClearCache;
}
}
break;
}
case CacheAgentMessageID.ClearCache:
{
Server.Clear();
break;
}
}
}
}
}
public void GetBytes()
{
byte[] value = Encoding.UTF7.GetBytes("Test GetBytes method.");
BinaryField field = new BinaryField(19, value);
byte[] binaryValue = field.GetBytes();
Assert.IsTrue(Encoding.UTF7.GetString(
binaryValue).Equals(Encoding.UTF7.GetString(value)));
field.Value = null;
binaryValue = field.GetBytes();
Assert.IsNull(binaryValue);
}
protected override Frame ParseFrame(byte[] data)
{
int place = 0;
TextField ownerField = TextField.CreateTextField(true, EncodingScheme.Ascii);
place += ownerField.Parse(data, place);
BinaryField dataField = new BinaryField();
place += dataField.Parse(data, place);
return(new UniqueFileIdentifierFrame(dataField.Data, ownerField.Text));
}
//"Tests the Write method of the class."
public void TestWrite()
{
for (int testCase = 0; testCase < 100; testCase++)
{
byte[] randomData = new byte[_randomNumberGenerator.Next(1, 50000)];
_randomNumberGenerator.NextBytes(randomData);
BinaryField field = new BinaryField(randomData, 0, randomData.Length);
MemoryStream stream = new MemoryStream();
field.WriteToStream(stream);
Assert.AreEqual(stream.Length, randomData.Length);
for (int i = 0; i < randomData.Length; i++)
{
Assert.AreEqual(randomData[i], stream.GetBuffer()[i]);
}
}
}
private void ModifySpecificContent(IFolder node, HttpPostedFile file, string path)
{
ContentFacade contentFacade = new ContentFacade();
contentFacade.Load(path);
if (contentFacade.CurrentContent != null)
{
BinaryField bf = contentFacade.CurrentContent.Fields["Binary"] as BinaryField;
if (bf != null)
{
BinaryData bd = CreateBinaryData(file);
bf.SetData(bd);
}
}
contentFacade.CurrentContent.Save();
}
public void TestClone()
{
byte[] value = Encoding.UTF7.GetBytes("Test Clone method.");
BinaryField field = new BinaryField(14);
BinaryField clonedField = ( BinaryField)(field.Clone());
Assert.IsNull(clonedField.Value);
Assert.IsTrue(field.FieldNumber == clonedField.FieldNumber);
field.Value = value;
clonedField = ( BinaryField)(field.Clone());
Assert.IsTrue(field.ToString().Equals(clonedField.ToString()));
Assert.IsTrue(field.Value != clonedField.Value);
}
//"Tests the Read method of the class."
public void TestRead()
{
for (int testCase = 0; testCase < 100; testCase++)
{
byte[] randomData = new byte[_randomNumberGenerator.Next(1, 50000)];
int offset = _randomNumberGenerator.Next(0, randomData.Length - 1);
_randomNumberGenerator.NextBytes(randomData);
BinaryField field = new BinaryField();
field.Parse(randomData, offset);
Assert.AreEqual(field.Data.Length, randomData.Length - offset);
Assert.AreEqual(field.Length, randomData.Length - offset);
Assert.AreEqual(field.Length, field.Data.Length);
for (int i = offset; i < randomData.Length; i++)
{
Assert.AreEqual(randomData[i], field.Data[i - offset]);
}
}
}
public void OnMessageReceived(WaveServerComponent dest, Enum msgID, WaveMessage data)
{
if (msgID is DefAgentMessageID)
{
if (data != null)
{
switch ((DefAgentMessageID)msgID)
{
case DefAgentMessageID.BulkDefinitionResponse:
{
if (data.RootList.Count > 0)
{
List <FieldList> definitions = new List <FieldList>(data.RootList.Count);
foreach (IFieldBase field in data.RootList)
{
BinaryField bin = field as BinaryField;
if ((bin != null) && (bin.Data != null))
{
WaveMessage msg = new WaveMessage(bin.Data);
if ((DefAgentMessageID)msg.MessageID == DefAgentMessageID.DefinitionResponse)
{
definitions.Add(msg.RootList);
}
}
}
UnpackDefinitions(definitions);
}
break;
}
case DefAgentMessageID.DefinitionResponse:
{
UnpackDefinition(data.RootList);
break;
}
}
}
}
}
private IEnumerable <Field> ExtractFields(string documentId, BinaryField binaryField, string domain)
{
try
{
using (var stream = new MemoryStream(binaryField.Data))
{
var extractedDoc = _textExtractorService.ExtractText(
new BinaryDocumentStream(documentId, domain, stream));
if (extractedDoc.TextExtractionException != null)
{
Log.Warning(
$"Error when extracting binary field {binaryField.Name} from {documentId}: {extractedDoc.TextExtractionException}");
return(new Field[]
{
new Field("ExtractionError",
$"Error when extracting binary field {binaryField.Name} from {documentId}: {extractedDoc.TextExtractionException}")
});
}
var doc = extractedDoc.ResultingDocument as AddDocument;
foreach (var field in doc.Fields)
{
field.Name = string.Format("{0}_extracted_{1}",
binaryField.Name,
field.Name.Replace(":", "-").Replace(" ", "-").Replace("(", "").Replace(")", ""));
}
return(doc.Fields);
}
}
catch (Exception e)
{
return(new[]
{
new Field("Error",
string.Format("Error when extracting text from binary field {0} in document {3} :{1} ({2})",
binaryField.Name,
e.Message,
e.InnerException != null ? e.InnerException.Message : "",
documentId))
});
}
}
public void Instantiation()
{
byte[] value = Encoding.UTF7.GetBytes("Test object instantiation.");
BinaryField field = new BinaryField(30);
Assert.IsTrue(field.FieldNumber == 30);
Assert.IsNull(field.Value);
field = new BinaryField(15, value);
Assert.IsTrue(field.FieldNumber == 15);
Assert.IsTrue(field.Value is byte[]);
byte[] fieldValue = ( byte[])(field.Value);
Assert.IsTrue(value.Length == fieldValue.Length);
for (int i = 0; i < value.Length; i++)
{
Assert.IsTrue(value[i] == fieldValue[i]);
}
}
protected override Frame ParseFrame(byte[] data)
{
int place = 0;
BinaryField dataField = new BinaryField();
place += dataField.Parse(data, place);
if (dataField.Data.Length != 4)
{
throw new FrameParsingException("Length of a Play Counter frame should be exactly 4. Larger frames are not yet supported.");
}
int counter =
(((int)dataField.Data[0]) << 24) +
(((int)dataField.Data[1]) << 16) +
(((int)dataField.Data[2]) << 8) +
((int)dataField.Data[3]);
return(new PlayCounterFrame(counter));
}
//TODO: Bad name: GetJsonObject is a method for odata serializing
internal static object GetJsonObject(Field field, string selfUrl)
{
object data;
if (field is ReferenceField)
{
return(ODataReference.Create(String.Concat(selfUrl, "/", field.Name)));
}
else if (field is BinaryField)
{
var binaryField = (BinaryField)field;
var binaryData = (BinaryData)binaryField.GetData();
return(ODataBinary.Create(BinaryField.GetBinaryUrl(field.Content.Id, field.Name, binaryData.Timestamp), null, binaryData.ContentType, null));
}
else if (ODataHandler.DeferredFieldNames.Contains(field.Name))
{
return(ODataReference.Create(String.Concat(selfUrl, "/", field.Name)));
}
try
{
data = field.GetData();
}
catch (SenseNetSecurityException)
{
// The user does not have access to this field (e.g. cannot load
// a referenced content). In this case we serve a null value.
data = null;
SnTrace.Repository.Write("PERMISSION warning: user {0} does not have access to field '{1}' of {2}.", User.LoggedInUser.Username, field.Name, field.Content.Path);
}
var nodeType = data as NodeType;
if (nodeType != null)
{
return(nodeType.Name);
}
return(data);
}
private void CreateSpecificContent(HttpContext context, string contentTypeName, IFolder parentNode, HttpPostedFile postedFile)
{
ContentFacade contentFacade = new ContentFacade();
contentFacade.CreateNew(contentTypeName, ((Node)parentNode));
if (CheckAllowedContentType(parentNode as GenericContent, contentFacade.CurrentContent.ContentHandler, context))
{
// set name
ShortTextField sf = contentFacade.CurrentContent.Fields["Name"] as ShortTextField;
var fn = System.IO.Path.GetFileName(postedFile.FileName);
sf.SetData(fn);
// set binary
BinaryData b = CreateBinaryData(postedFile);
BinaryField bf = contentFacade.CurrentContent.Fields["Binary"] as BinaryField;
bf.SetData(b);
contentFacade.CurrentContent.Save();
}
}
public void Format()
{
FormatterContext formatterContext = new FormatterContext(
FormatterContext.DefaultBufferSize);
BinaryField field = new BinaryField(1);
field.Value = "DATA";
BinaryFieldFormatter formatter;
string formattedData;
// Test fixed length formatting.
formatter = new BinaryFieldFormatter(37,
new FixedLengthManager(4), BinaryEncoder.GetInstance());
formatter.Format(field, ref formatterContext);
formattedData = formatterContext.GetDataAsString();
Assert.IsTrue(formattedData.Equals("DATA"));
formatterContext.Clear();
field.Value = "MORE DATA";
try {
formatter.Format(field, ref formatterContext);
Assert.Fail();
} catch (ArgumentOutOfRangeException e) {
Assert.IsTrue(e.ParamName.Equals("dataLength"));
}
// Test variable length formatting.
formatterContext.Clear();
formatter = new BinaryFieldFormatter(48, new VariableLengthManager(0,
999, StringLengthEncoder.GetInstance(999)),
BinaryEncoder.GetInstance());
formatter.Format(field, ref formatterContext);
formattedData = formatterContext.GetDataAsString();
Assert.IsTrue(formattedData.Equals("009MORE DATA"));
formatterContext.Clear();
formatter.Format(new BinaryField(5, null), ref formatterContext);
formattedData = formatterContext.GetDataAsString();
Assert.IsTrue(formattedData.Equals("000"));
}
protected override Frame ParseFrame(byte[] data)
{
//Text encoding $xx
//MIME type <text string> $00
//Filename <text string according to encoding> $00 (00)
//Content description <text string according to encóding> $00 (00)
//Encapsulated object <binary data>
int place = 0;
SingleByteField encodingField = new SingleByteField();
place += encodingField.Parse(data, place);
TextField mimeTypeField = TextField.CreateTextField(true, EncodingScheme.Ascii);
place += mimeTypeField.Parse(data, place);
TextField fileNameField = TextField.CreateTextField(true, (EncodingScheme)encodingField.Value);
place += fileNameField.Parse(data, place);
TextField contentDescriptionField = TextField.CreateTextField(true, (EncodingScheme)encodingField.Value);
place += contentDescriptionField.Parse(data, place);
BinaryField dataField = new BinaryField();
place += dataField.Parse(data, place);
return(new GeneralEncapsulatedObjectFrame(
fileNameField.Text,
contentDescriptionField.Text,
mimeTypeField.Text,
dataField.Data));
}
public void OnMessageReceived(WaveServerComponent dest, Enum msgID, WaveMessage data)
{
if (msgID is UserManagerMessageID)
{
if (data != null)
{
switch ((UserManagerMessageID)msgID)
{
case UserManagerMessageID.Challenge:
{
bool createAccount = false;
// check if there is login already (otherwise set defaults)
if (!Core.Application.HasLogin)
{
createAccount = true;
Core.Application.UpdateCredentials(GenerateNewUsername(), StringHelper.GetBytes(DefaultPassword));
}
// get CSL version
WaveCSLVersion serverCSL = (WaveCSLVersion)(data[UserManagerFieldID.CSLVersion].AsShort() ?? (short)WaveCSLVersion.Unknown);
switch (serverCSL)
{
case WaveCSLVersion.Version5:
case WaveCSLVersion.Version4:
Core.CSLVersion = serverCSL;
break;
default:
Core.CSLVersion = WaveCSLVersion.Version3;
break;
}
// get maximum protocol version
WaveProtocolVersion serverProto = (WaveProtocolVersion)(data[UserManagerFieldID.MaxWeMessageVersion].AsByte() ?? (byte)WaveProtocolVersion.Unknown);
switch (serverProto)
{
case WaveProtocolVersion.Version4:
Core.ProtocolVersion = WaveProtocolVersion.Version4;
break;
default:
Core.ProtocolVersion = WaveProtocolVersion.Version3;
break;
}
// get challenge
BinaryField challenge = (BinaryField)data[UserManagerFieldID.Challenge];
// assemble login message
WaveMessage msgOut = new WaveMessage();
msgOut.AddInt16(UserManagerFieldID.CSLVersion, (short)Core.CSLVersion);
msgOut.AddBoolean(UserManagerFieldID.EncryptSession, Core.UseEncryption);
msgOut.AddInt16(UserManagerFieldID.PriorityMask, NetworkAgent.PrioritiesActiveMask);
msgOut.AddBinary(UserManagerFieldID.UserCredentials, ProcessChallenge(challenge.Data, Core.Application, createAccount));
msgOut.AddBoolean(UserManagerFieldID.CreateAccount, createAccount);
// cache hash
byte[] cacheHash = Core.Cache.CacheHash;
msgOut.AddBinary(CacheAgentFieldID.CacheHashCompressed, (cacheHash.Length > 0) ? CompressionHelper.GZipBuffer(cacheHash) : cacheHash);
// cache ID (if any)
if (Core.Cache.CacheID.HasValue)
{
msgOut.AddBinary(MessageOutFieldID.CacheItemID, Core.Cache.CacheID.Value.ToByteArray());
}
// compiling device settings
FieldList deviceSettingsList = FieldList.CreateField(UserManagerFieldID.DeviceSettings);
deviceSettingsList.AddString(UserManagerFieldID.DeviceBuildID, Core.BuildID);
deviceSettingsList.AddBoolean(NaviAgentFieldID.DeviceSupportsTouch, true);
deviceSettingsList.AddInt16(NaviAgentFieldID.DeviceScreenResolutionWidth, 480);
deviceSettingsList.AddInt16(NaviAgentFieldID.DeviceScreenResolutionHeight, 800);
DeviceGroup[] devs = Core.System.SupportedDeviceGroups;
foreach (DeviceGroup dev in devs)
{
deviceSettingsList.AddInt16(NaviAgentFieldID.DeviceProfileGroup, (short)dev);
}
deviceSettingsList.AddString(UserManagerFieldID.LanguageID, CultureInfo.CurrentCulture.Name);
deviceSettingsList.AddString(UserManagerFieldID.Timezone, Core.Settings.TimeZone);
deviceSettingsList.AddBoolean(UserManagerFieldID.AlphaSupport, true);
deviceSettingsList.AddBoolean(UserManagerFieldID.CompressionSupport, true);
msgOut.AddFieldList(deviceSettingsList);
// compiling application request list
FieldList appRequestList = FieldList.CreateField(UserManagerFieldID.ApplicationRequest);
appRequestList.AddString(NaviAgentFieldID.ApplicationURN, Core.Application.URI);
appRequestList.AddInt16(NaviAgentFieldID.ApplicationRequestAction, (short)AppRequestAction.GetAppEntryPage);
msgOut.AddFieldList(appRequestList);
msgOut.Send(WaveServerComponent.UserManager, UserManagerMessageID.Login);
Core.UI.SignalViewNavigationStart(Core.UI.RootViewID);
break;
}
case UserManagerMessageID.EncryptionKeys:
{
// setting encryption (if allowed by build configuration)
if (Core.UseEncryption && (sessionHandshakeFish != null))
{
BinaryField sessionKeyField = (BinaryField)data[UserManagerFieldID.SessionKey];
byte[] sessionKey = (byte[])sessionKeyField.Data;
sessionHandshakeFish.Decrypt(sessionKey, sessionKey.Length);
BinaryField globalServerKeyField = (BinaryField)data[UserManagerFieldID.GlobalServerKey];
byte[] globalServerKey = (byte[])globalServerKeyField.Data;
sessionHandshakeFish.Decrypt(globalServerKey, globalServerKey.Length);
Core.NotifyEncryptionKeysChanged(this, sessionKey, globalServerKey);
}
else
{
Core.NotifyEncryptionKeysChanged(this, null, null);
}
// setting login data
StringField userName = (StringField)data[UserManagerFieldID.CreatedAccountUserName];
if (userName != null)
{
BinaryField userPass = (BinaryField)data[UserManagerFieldID.CreatedAccountPasswordHash];
if ((userPass != null) && (sessionHandshakeFish != null))
{
byte[] passBuffer = (byte[])userPass.Data.Clone();
sessionHandshakeFish.Decrypt(passBuffer, passBuffer.Length);
Core.Application.UpdateCredentials(userName.Data, passBuffer);
// no longer needed
sessionHandshakeFish = null;
}
}
break;
}
case UserManagerMessageID.LoginResponse:
{
if (!authenticated)
{
Int16Field loginStatus = (Int16Field)data[UserManagerFieldID.LoginStatus];
switch ((UserLoginStatus)loginStatus.Data)
{
case UserLoginStatus.Success:
{
// signal authentication success
Core.NotifyAuthentication(this, data[UserManagerFieldID.SessionInfo].AsByteArray());
// preparing login data message
FieldList appContext = (FieldList)data[UserManagerFieldID.ApplicationContext];
if (appContext != null)
{
int appID = appContext[MessageOutFieldID.ApplicationID].AsInteger() ?? 0;
string unqualifiedAppURI = appContext[UserManagerFieldID.ApplicationUnqualifiedURI].AsText();
string fullyQualifiedAppURI = appContext[UserManagerFieldID.ApplicationFullyQualifiedURI].AsText();
Core.NotifySuccessfulLogin(this, appID, unqualifiedAppURI, fullyQualifiedAppURI);
}
authenticated = true;
authenticatedEver = true;
break;
}
case UserLoginStatus.FailedInvalidCredentials:
Core.NotifyTerminateSession(this, SessionTerminationReasonCode.InvalidCredentials);
break;
case UserLoginStatus.FailedNoUser:
Core.NotifyTerminateSession(this, SessionTerminationReasonCode.NoSuchUser);
break;
}
}
break;
}
}
}
}
}
private ObjectDataFieldControl CreateControl(long typeId, int member, ObjectInfo objInfo)
{
ObjectDataFieldControl c = null;
Safir.Dob.Typesystem.MemberType memberType;
long complexType;
int typeSize;
bool isArray;
int arrLength;
string memberName = Safir.Dob.Typesystem.Members.GetInfo(typeId, member, out memberType, out complexType, out typeSize, out isArray, out arrLength);
switch (memberType)
{
case Safir.Dob.Typesystem.MemberType.EnumerationMemberType:
{
c = new EnumField(objInfo, member, complexType, memberName, arrLength);
break;
}
case Safir.Dob.Typesystem.MemberType.BooleanMemberType:
{
c = new BoolField(objInfo, member, memberName, arrLength);
break;
}
case Safir.Dob.Typesystem.MemberType.Int32MemberType:
{
c = new Int32Field(objInfo, member, memberName, arrLength);
break;
}
case Safir.Dob.Typesystem.MemberType.Int64MemberType:
{
c = new Int64Field(objInfo, member, memberName, arrLength);
break;
}
case Safir.Dob.Typesystem.MemberType.ChannelIdMemberType:
{
c = new ChannelIdField(objInfo, member, memberName, arrLength);
break;
}
case Safir.Dob.Typesystem.MemberType.HandlerIdMemberType:
{
c = new HandlerIdField(objInfo, member, memberName, arrLength);
break;
}
case Safir.Dob.Typesystem.MemberType.EntityIdMemberType:
{
c = new EntityIdField(objInfo, member, memberName, arrLength);
break;
}
case Safir.Dob.Typesystem.MemberType.InstanceIdMemberType:
{
c = new InstanceIdField(objInfo, member, memberName, arrLength);
break;
}
case Safir.Dob.Typesystem.MemberType.StringMemberType:
{
c = new StringField(objInfo, member, memberName, arrLength, typeSize);
break;
}
case Safir.Dob.Typesystem.MemberType.TypeIdMemberType:
{
c = new TypeIdField(objInfo, member, memberName, arrLength);
break;
}
case Safir.Dob.Typesystem.MemberType.ObjectMemberType:
{
c = new ObjectField(objInfo, member, complexType, memberName, arrLength);
break;
}
case Safir.Dob.Typesystem.MemberType.BinaryMemberType:
{
c = new BinaryField(objInfo, member, memberName, arrLength);
break;
}
case Safir.Dob.Typesystem.MemberType.Float32MemberType:
case Safir.Dob.Typesystem.MemberType.Ampere32MemberType:
case Safir.Dob.Typesystem.MemberType.CubicMeter32MemberType:
case Safir.Dob.Typesystem.MemberType.Hertz32MemberType:
case Safir.Dob.Typesystem.MemberType.Joule32MemberType:
case Safir.Dob.Typesystem.MemberType.Kelvin32MemberType:
case Safir.Dob.Typesystem.MemberType.Kilogram32MemberType:
case Safir.Dob.Typesystem.MemberType.Meter32MemberType:
case Safir.Dob.Typesystem.MemberType.MeterPerSecond32MemberType:
case Safir.Dob.Typesystem.MemberType.MeterPerSecondSquared32MemberType:
case Safir.Dob.Typesystem.MemberType.Newton32MemberType:
case Safir.Dob.Typesystem.MemberType.Pascal32MemberType:
case Safir.Dob.Typesystem.MemberType.Radian32MemberType:
case Safir.Dob.Typesystem.MemberType.RadianPerSecond32MemberType:
case Safir.Dob.Typesystem.MemberType.RadianPerSecondSquared32MemberType:
case Safir.Dob.Typesystem.MemberType.Second32MemberType:
case Safir.Dob.Typesystem.MemberType.SquareMeter32MemberType:
case Safir.Dob.Typesystem.MemberType.Steradian32MemberType:
case Safir.Dob.Typesystem.MemberType.Volt32MemberType:
case Safir.Dob.Typesystem.MemberType.Watt32MemberType:
{
c = new Float32Field(objInfo, member, memberName, arrLength,
Safir.Dob.Typesystem.Members.GetTypeName(typeId, member));
break;
}
case Safir.Dob.Typesystem.MemberType.Float64MemberType:
case Safir.Dob.Typesystem.MemberType.Ampere64MemberType:
case Safir.Dob.Typesystem.MemberType.CubicMeter64MemberType:
case Safir.Dob.Typesystem.MemberType.Hertz64MemberType:
case Safir.Dob.Typesystem.MemberType.Joule64MemberType:
case Safir.Dob.Typesystem.MemberType.Kelvin64MemberType:
case Safir.Dob.Typesystem.MemberType.Kilogram64MemberType:
case Safir.Dob.Typesystem.MemberType.Meter64MemberType:
case Safir.Dob.Typesystem.MemberType.MeterPerSecond64MemberType:
case Safir.Dob.Typesystem.MemberType.MeterPerSecondSquared64MemberType:
case Safir.Dob.Typesystem.MemberType.Newton64MemberType:
case Safir.Dob.Typesystem.MemberType.Pascal64MemberType:
case Safir.Dob.Typesystem.MemberType.Radian64MemberType:
case Safir.Dob.Typesystem.MemberType.RadianPerSecond64MemberType:
case Safir.Dob.Typesystem.MemberType.RadianPerSecondSquared64MemberType:
case Safir.Dob.Typesystem.MemberType.Second64MemberType:
case Safir.Dob.Typesystem.MemberType.SquareMeter64MemberType:
case Safir.Dob.Typesystem.MemberType.Steradian64MemberType:
case Safir.Dob.Typesystem.MemberType.Volt64MemberType:
case Safir.Dob.Typesystem.MemberType.Watt64MemberType:
{
c = new Float64Field(objInfo, member, memberName, arrLength,
Safir.Dob.Typesystem.Members.GetTypeName(typeId, member));
break;
}
}
if (c != null)
{
c.ParentObjectEditPanel = this;
}
return(c);
}
/// <summary>Copy constructor.</summary>
///
/// <param name="other">The other BinaryField object to copy</param>
public BinaryField(BinaryField other)
{
}
public static string GetBinaryUrl(int contentId, string propertyName, long checksum = 0)
{
return(BinaryField.GetBinaryUrl(contentId, propertyName, checksum));
}
