public void SendLoginResponse(byte[] data)
{
var iPkt = new UA_LOGIN_REQ();
iPkt.SetData(data);
SysCons.LogInfo("UA_LOGIN_REQ UserID({0}) CodePage({1}) Version({2}.{3})", iPkt.UserID, iPkt.CodePage, iPkt.MajorVer, iPkt.MinorVer);
Username = iPkt.UserID;
Password = iPkt.UserPW;
AccountID = (uint)AuthDB.GetAccountID(Username);
using (var oPkt = new AU_COMMERCIAL_SETTING_NFY())
{
oPkt.BuildPacket();
Client.Send(oPkt.Data);
}
using (var oPkt = new AU_LOGIN_RES())
{
oPkt.UserID = iPkt.UserID;
oPkt.AccountID = AccountID;
oPkt.AllowedFunctionForDeveloper = 65535;
oPkt.AuthKey = "SE@WASDE#$RFWD@D";
oPkt.ResultCode = (ushort)AuthDB.CheckAccount(this.Username, this.Password);
oPkt.lastServerID = 255;
oPkt.lastChannelID = 255;
oPkt.BuildCharServerList();
oPkt.BuildPacket();
Client.Send(oPkt.Data);
}
}
public void MsgPackReader(string file, bool JSON)
{
MsgPack MsgPack = file.ReadMP(JSON);
if (MsgPack.Element("AuthDB", out MsgPack AuthDB))
{
if (AuthDB.ElementArray("Category", out MsgPack Temp))
{
Category = new string[Temp.Array.Length];
for (int i = 0; i < Category.Length; i++)
{
Category[i] = Temp[i].ReadString();
}
}
if (AuthDB.ElementArray("UID", out Temp))
{
_UID = new UID[Temp.Array.Length];
for (int i = 0; i < _UID.Length; i++)
{
_UID[i].Category = Temp[i].ReadString("C");
_UID[i].OrgUid = Temp[i].ReadNInt32("O");
_UID[i].Size = Temp[i].ReadNInt32("S");
_UID[i].Value = Temp[i].ReadString("V");
}
}
}
MsgPack = MsgPack.New;
}
public void SendLoginResponse(byte[] data)
{
Packet oPkt = new Packet();
oPkt.Opcode = (ushort)PacketOpcodes.AU_COMMERCIAL_SETTING_NFY;
oPkt.BuildPacket();
this.Client.Send(oPkt.Data);
UA_LOGIN_REQ inPkt = new UA_LOGIN_REQ();
inPkt.SetData(data);
SysCons.LogInfo("UA_LOGIN_REQ {0} CodePage({1}) {2}.{3}", inPkt.UserID, inPkt.CodePage, inPkt.MajorVer, inPkt.MinorVer);
this.Username = inPkt.UserID;
this.Password = inPkt.UserPW;
this.AccountID = (uint)AuthDB.GetAccountID(this.Username);
AU_LOGIN_RES sPkt = new AU_LOGIN_RES();
sPkt.UserID = inPkt.UserID;
sPkt.AccountID = this.AccountID;
sPkt.AllowedFunctionForDeveloper = 65535;
sPkt.AuthKey = Encoding.ASCII.GetBytes("SE@WASDE#$RFWD@D");
sPkt.ResultCode = (ushort)AuthDB.CheckAccount(this.Username, this.Password);
sPkt.lastServerID = 255;
sPkt.lastChannelID = 255;
sPkt.BuildCharServerList();
sPkt.BuildPacket();
this.Client.Send(sPkt.Data);
}
public void Merge(Environment other, string after, bool withAuth)
{
if (withAuth)
{
AuthDB.Merge(other.AuthDB);
}
var next = after;
foreach (var fw in other.frameworks)
{
Merge(fw, next);
next = fw.Name;
}
}
public bool IsAuthorized(string domain, string username, string machine, AuthType defaultAuth)
{
try {
var ans = AuthDB.Domains.Length > 0
? AuthDB.IsAuthorized(domain, username, machine)
: defaultAuth == AuthType.allow
;
logger.Debug(
"Authorization {0} for environment '{1}'{2}.",
ans ? "granted" : "denied",
Name,
String.IsNullOrWhiteSpace(Group) ? String.Empty : $", group '{Group}'"
);
return(ans);
}
catch (Exception ex) {
logger.Error(ex, "Authorization failed");
return(false);
}
}
public void MsgPackReader(string file, bool JSON)
{
MsgPack MsgPack = file.ReadMP(JSON);
if (MsgPack.Element("AuthDB", out MsgPack AuthDB))
{
if (AuthDB.Element("Category", out MsgPack Temp, typeof(object[])))
{
this.Category = new string[((object[])Temp.Object).Length];
MsgPack Category;
for (int i = 0; i < this.Category.Length; i++)
{
if (Temp[i].GetType() == typeof(MsgPack))
{
Category = (MsgPack)Temp[i]; this.Category[i] = Category.ReadString();
}
}
}
if (AuthDB.Element("UID", out Temp, typeof(object[])))
{
_UID = new UID[((object[])Temp.Object).Length];
MsgPack UID;
for (int i = 0; i < _UID.Length; i++)
{
if (Temp[i].GetType() == typeof(MsgPack))
{
UID = (MsgPack)Temp[i];
_UID[i].Category = UID.ReadString("C");
_UID[i].OrgUid = UID.ReadNInt32("O");
_UID[i].Size = UID.ReadNInt32("S");
_UID[i].Value = UID.ReadString("V");
}
}
}
}
MsgPack = null;
}
public static void XMLReader(ref AUTH Data, string file)
{
KKtXml Xml = new KKtXml();
Xml.OpenXml(file + ".xml", true);
foreach (XElement AuthDB in Xml.doc.Elements("AuthDB"))
{
foreach (XAttribute Entry in AuthDB.Attributes())
{
if (Entry.Name == "Signature")
{
Data.Signature = BitConverter.ToInt32(KKtText.ToASCII(Entry.Value), 0);
}
}
foreach (XElement Child0 in AuthDB.Elements())
{
if (Child0.Name == "Categories")
{
foreach (XAttribute Entry in Child0.Attributes())
{
if (Entry.Name == "Length")
{
Data.Category = new string[int.Parse(Entry.Value)];
}
}
int i = 0;
foreach (XElement Category in Child0.Elements())
{
Data.Category[i] = "";
foreach (XAttribute Entry in Category.Attributes())
{
if (Entry.Name == "Value")
{
Data.Category[i] = Entry.Value;
}
}
i++;
}
}
if (Child0.Name == "UIDs")
{
foreach (XAttribute Entry in Child0.Attributes())
{
if (Entry.Name == "Length")
{
Data.UID = new UID[int.Parse(Entry.Value)];
}
}
int i = 0;
foreach (XElement UID in Child0.Elements())
{
Data.UID[i].Category = "";
Data.UID[i].Size = -1;
Data.UID[i].Value = "";
foreach (XAttribute Entry in UID.Attributes())
{
if (Entry.Name == "Category")
{
Data.UID[i].Category = Entry.Value;
}
if (Entry.Name == "Size")
{
Data.UID[i].Size = int.Parse(Entry.Value);
}
if (Entry.Name == "Value")
{
Data.UID[i].Value = Entry.Value;
}
}
i++;
}
}
}
}
}
public static Environment Load(string path)
{
try {
logger.Trace($"Loading Environment '{path}'.");
if (!IsEnvironment(path))
{
throw new Exception($"Environment '{path}' does not exist.");
}
var ef = Path.Combine(path, ENVROOTFILE);
var env = IEntityExtensions.Deserialize <Environment>(ef);
var uf = Path.Combine(path, AUTHDBFILE);
if (File.Exists(uf))
{
var other = AuthDB.Load(uf);
env.AuthDB.Merge(other);
}
for (var i = env.Auths.Length - 1; i >= 0; --i)
{
var impPath = env.Auths[i].GetRootedPath(path);
var other = AuthDB.Load(impPath);
env.AuthDB.Merge(other);
}
var inext = env.Imports.Length;
for (var i = 0; i < env.Imports.Length; ++i)
{
var imp = env.Imports[i];
if (!String.IsNullOrEmpty(imp.After))
{
inext = i;
break;
}
var impPath = imp.GetRootedPath(path);
env.Import(impPath, imp.After, imp.WithAuth);
}
foreach (var f in Directory.EnumerateFiles(path, "*.xml"))
{
var fn = Path.GetFileName(f);
if (Strings.IsReserved(fn[0]))
{
continue;
}
var fw = Framework.Load(f);
env.Merge(fw, fw.After);
}
for (var i = inext; i < env.Imports.Length; ++i)
{
var imp = env.Imports[i];
var impPath = imp.GetRootedPath(path);
env.Import(impPath, imp.After.IfNull(LAST), imp.WithAuth);
}
try {
var hse = new HashSet <string>(StringComparer.OrdinalIgnoreCase);
var hsa = new HashSet <string>(StringComparer.OrdinalIgnoreCase);
foreach (var f in env.frameworks)
{
foreach (var ev in f.EVars)
{
if (!hse.Add(ev.Name))
{
throw new ValidationException($"Environment variable '{ev.Name}' is duplicated.");
}
}
foreach (var ai in f.Addins)
{
if (!hsa.Add(ai.QFileName))
{
throw new ValidationException($"Addin '{ai.QFileName}' is duplicated.");
}
}
foreach (var b in f.Boxes)
{
foreach (var c in b.Controls)
{
c.SetParent(f);
}
}
}
}
catch (ValidationException vex) {
vex.Parents.Add($"Environment => {env.Name}");
throw;
}
return(env);
}
catch (Exception ex) {
if (!(ex is ValidationException vex))
{
logger.Debug(ex, $"Error loading Environment '{path}'");
vex = new ValidationException($"{ex.Message}", ex);
}
vex.Parents.Add(path);
throw vex;
}
}
