protected override async void implement()
{
a_key_data = p_crypto.Decrypt(a_key_data, private_key.data);
m_key key = m_key.create(a_key_data);
a_register_data = p_crypto.Decrypt(a_register_data, key);
var login = p_crypto.convert <m_register_x>(a_register_data);
if (!await check_login(login))
{
reply(new o()
{
z_error = e_error.invalid_parametrs
});
return;
}
var db = z_db.general_x <m.device>();
m.device device = new()
{
creation_time = DateTime.Now,
id = "d_" + login.a_xid,
iv16 = key.iv16,
key32 = key.key32,
};
await db.upsert(device);
await a.add_user(device.id, login.a_xid);
reply(new o()
{
a_deviceid = device.id
});
}
protected override async void implement()
{
a_key_data = p_crypto.Decrypt(a_key_data, private_key.data);
m_key key = m_key.create(a_key_data);
a_register_data = p_crypto.Decrypt(a_register_data, key);
m_register_c login = p_crypto.convert <m_register_c>(a_register_data);
if (!await check_login(login))
{
reply(new o()
{
z_error = e_error.invalid_device_info
});
return;
}
var db = z_db.general_x <m.device>();
m.device device = new()
{
creation_time = DateTime.Now,
id = "d_" + ObjectId.GenerateNewId(),
iv16 = key.iv16,
key32 = key.key32,
name = login.a_device_name
};
await db.upsert(device);
reply(new o()
{
a_deviceid = device.id
});
}
async Task <bool> check_login(m_register_c val)
{
await Task.CompletedTask;
return(val.a_skeletid == "wpf_skeleton" && val.a_password == "1234");
}
}
internal async Task <output> run <output>(string userid, layer_0.cell.y y) where output : o_base
{
m_y packet_y = new m_y()
{
userid = userid,
yid = y.z_yid,
data = JsonConvert.SerializeObject(y)
};
var data = p_crypto.convert(packet_y);
m_key key = a.api2.c_key;
if (key != null)
{
data = p_crypto.Encrypt(data, key);
}
m_packet packet = new m_packet()
{
deviceid = key?.id,
data = data
};
data = p_crypto.convert(packet);
m_xip xip = await a.c_x.get(y.z_xid);
data = await a.api1.c_exchange(xip, data);
if (key != null)
{
data = p_crypto.Decrypt(data, key);
}
var o = p_crypto.convert <output>(data);
if (a.api2.c_after != null)
{
await a.api2.c_after(y, o);
}
return(o);
}
public static byte[] create(m_key rsv) => p_crypto.combine(rsv.key32, rsv.iv16);
async void y_s(byte[] data, s_reply_data reply)
{
var packet = p_crypto.convert <m_packet>(data);
m_key keys = null;
if (packet.deviceid != null)
{
keys = await a.api2.s_get_key(packet.deviceid);
if (keys == null)
{
met(null, e_error.invalid_deviceid);
return;
}
try
{
packet.data = p_crypto.Decrypt(packet.data, keys);
}
catch
{
met(null, e_error.invalid_encryption);
return;
}
}
var packet_y = p_crypto.convert <m_y>(packet.data);
var type = await get(packet_y.yid);
if (type == null)
{
var dv = a.api2.s_xid;
met(null, e_error.no_implement);
return;
}
var y = JsonConvert.DeserializeObject(packet_y.data, type) as layer_0.cell.y;
e_permission p = 0;
if (packet.deviceid == null)
{
p = e_permission.non;
if (packet_y.userid != null)
{
met(null, e_error.invalid_userid);
return;
}
}
else
{
if (packet_y.userid == null)
{
p = e_permission.k;
}
else
{
switch (packet_y.userid[0])
{
case 'u': p = e_permission.u; break;
case 'x': p = e_permission.x; break;
default:
met(null, e_error.invalid_userid_prefix);
return;
}
}
}
if (y.z_permission > p)
{
met(null, e_error.invalid_permission);
return;
}
y.z_userid = packet_y.userid;
y.z_deviceid = packet.deviceid;
var error = await a.api2.s_before(y);
if (error != e_error.non)
{
met(null, error);
return;
}
y.zz_reply(met);
void met(byte[] data, e_error e)
{
if (data == null)
{
data = p_crypto.convert(new o_base()
{
z_error = e
});
}
if (keys != null)
{
data = p_crypto.Encrypt(data, keys);
}
reply(data, e);
}
}
