示例#1
0
文件: login-user.hpp 项目: o11c/tmwa
bool network_to_native(Packet_Head<0x0063> *native, NetPacket_Head<0x0063> network)
{
    bool rv = true;
    rv &= network_to_native(&native->magic_packet_id, network.magic_packet_id);
    rv &= network_to_native(&native->magic_packet_length, network.magic_packet_length);
    return rv;
}
示例#2
0
RecvResult recv_vpacket(Session *s, Packet_Head<id>& head, std::vector<Packet_Repeat<id>>& repeat)
{
    static_assert(id == Packet_Head<id>::PACKET_ID, "Packet_Head<id>::PACKET_ID");
    static_assert(headsize == sizeof(NetPacket_Head<id>), "NetPacket_Head<id>");
    static_assert(id == Packet_Repeat<id>::PACKET_ID, "Packet_Repeat<id>::PACKET_ID");
    static_assert(repeatsize == sizeof(NetPacket_Repeat<id>), "NetPacket_Repeat<id>");

    NetPacket_Head<id> net_head;
    std::vector<NetPacket_Repeat<id>> net_repeat;
    RecvResult rv = net_recv_vpacket(s, net_head, net_repeat);
    if (rv == RecvResult::Complete)
    {
        if (!network_to_native(&head, net_head))
            return RecvResult::Error;
        assert (head.magic_packet_id == Packet_Head<id>::PACKET_ID);

        repeat.resize(net_repeat.size());
        for (size_t i = 0; i < net_repeat.size(); ++i)
        {
            if (!network_to_native(&repeat[i], net_repeat[i]))
                return RecvResult::Error;
        }
    }
    return rv;
}
示例#3
0
文件: login-user.hpp 项目: o11c/tmwa
bool network_to_native(Packet_Fixed<0x006a> *native, NetPacket_Fixed<0x006a> network)
{
    bool rv = true;
    rv &= network_to_native(&native->magic_packet_id, network.magic_packet_id);
    rv &= network_to_native(&native->error_code, network.error_code);
    rv &= network_to_native(&native->error_message, network.error_message);
    return rv;
}
示例#4
0
文件: login-user.hpp 项目: o11c/tmwa
bool network_to_native(Packet_Fixed<0x0064> *native, NetPacket_Fixed<0x0064> network)
{
    bool rv = true;
    rv &= network_to_native(&native->magic_packet_id, network.magic_packet_id);
    rv &= network_to_native(&native->unknown, network.unknown);
    rv &= network_to_native(&native->account_name, network.account_name);
    rv &= network_to_native(&native->account_pass, network.account_pass);
    rv &= network_to_native(&native->version_2_flags, network.version_2_flags);
    return rv;
}
示例#5
0
RecvResult net_recv_opacket(Session *s, NetPacket_Head<id>& head, bool *has_opt, NetPacket_Option<id>& opt)
{
    bool ok = packet_fetch(s, 0, reinterpret_cast<Byte *>(&head), sizeof(NetPacket_Head<id>));
    if (ok)
    {
        Packet_Head<id> nat;
        if (!network_to_native(&nat, head))
            return RecvResult::Error;
        if (packet_avail(s) < nat.magic_packet_length)
            return RecvResult::Incomplete;
        if (nat.magic_packet_length < sizeof(NetPacket_Head<id>))
            return RecvResult::Error;
        size_t bytes_repeat = nat.magic_packet_length - sizeof(NetPacket_Head<id>);
        if (bytes_repeat % sizeof(NetPacket_Option<id>))
            return RecvResult::Error;
        size_t has_opt_pls = bytes_repeat / sizeof(NetPacket_Option<id>);
        if (has_opt_pls > 1)
            return RecvResult::Error;
        *has_opt = has_opt_pls;
        if (!*has_opt || packet_fetch(s, sizeof(NetPacket_Head<id>), reinterpret_cast<Byte *>(&opt), sizeof(NetPacket_Option<id>)))
        {
            packet_discard(s, nat.magic_packet_length);
            return RecvResult::Complete;
        }
        return RecvResult::Incomplete;
    }
    return RecvResult::Incomplete;
}
示例#6
0
RecvResult net_recv_vpacket(Session *s, NetPacket_Head<id>& head, std::vector<NetPacket_Repeat<id>>& repeat)
{
    bool ok = packet_fetch(s, 0, reinterpret_cast<Byte *>(&head), sizeof(NetPacket_Head<id>));
    if (ok)
    {
        Packet_Head<id> nat;
        if (!network_to_native(&nat, head))
            return RecvResult::Error;
        if (packet_avail(s) < nat.magic_packet_length)
            return RecvResult::Incomplete;
        if (nat.magic_packet_length < sizeof(NetPacket_Head<id>))
            return RecvResult::Error;
        size_t bytes_repeat = nat.magic_packet_length - sizeof(NetPacket_Head<id>);
        if (bytes_repeat % sizeof(NetPacket_Repeat<id>))
            return RecvResult::Error;
        repeat.resize(bytes_repeat / sizeof(NetPacket_Repeat<id>));
        if (packet_fetch(s, sizeof(NetPacket_Head<id>), reinterpret_cast<Byte *>(repeat.data()), bytes_repeat))
        {
            packet_discard(s, nat.magic_packet_length);
            return RecvResult::Complete;
        }
        return RecvResult::Incomplete;
    }
    return RecvResult::Incomplete;
}
示例#7
0
文件: ids.hpp 项目: wushin/tmwa
 friend
 bool network_to_native(GmLevel *native, Little16 network)
 {
     uint16_t tmp;
     bool rv = network_to_native(&tmp, network);
     native->bits = tmp;
     return rv;
 }
示例#8
0
文件: login-user.hpp 项目: o11c/tmwa
bool network_to_native(Packet_Head<0x0069> *native, NetPacket_Head<0x0069> network)
{
    bool rv = true;
    rv &= network_to_native(&native->magic_packet_id, network.magic_packet_id);
    rv &= network_to_native(&native->magic_packet_length, network.magic_packet_length);
    rv &= network_to_native(&native->login_id1, network.login_id1);
    rv &= network_to_native(&native->account_id, network.account_id);
    rv &= network_to_native(&native->login_id2, network.login_id2);
    rv &= network_to_native(&native->unused, network.unused);
    rv &= network_to_native(&native->last_login_string, network.last_login_string);
    rv &= network_to_native(&native->unused2, network.unused2);
    rv &= network_to_native(&native->sex, network.sex);
    return rv;
}
示例#9
0
RecvResult recv_opacket(Session *s, Packet_Head<id>& head, bool *has_opt, Packet_Option<id>& opt)
{
    static_assert(id == Packet_Head<id>::PACKET_ID, "Packet_Head<id>::PACKET_ID");
    static_assert(headsize == sizeof(NetPacket_Head<id>), "NetPacket_Head<id>");
    static_assert(id == Packet_Option<id>::PACKET_ID, "Packet_Option<id>::PACKET_ID");
    static_assert(optsize == sizeof(NetPacket_Option<id>), "NetPacket_Option<id>");

    NetPacket_Head<id> net_head;
    NetPacket_Option<id> net_opt;
    RecvResult rv = net_recv_opacket(s, net_head, has_opt, net_opt);
    if (rv == RecvResult::Complete)
    {
        if (!network_to_native(&head, net_head))
            return RecvResult::Error;
        assert (head.magic_packet_id == Packet_Head<id>::PACKET_ID);

        if (*has_opt)
        {
            if (!network_to_native(&opt, net_opt))
                return RecvResult::Error;
        }
    }
    return rv;
}
示例#10
0
RecvResult recv_fpacket(Session *s, Packet_Fixed<id>& fixed)
{
    static_assert(id == Packet_Fixed<id>::PACKET_ID, "Packet_Fixed<id>::PACKET_ID");
    static_assert(size == sizeof(NetPacket_Fixed<id>), "NetPacket_Fixed<id>");

    NetPacket_Fixed<id> net_fixed;
    RecvResult rv = net_recv_fpacket(s, net_fixed);
    if (rv == RecvResult::Complete)
    {
        if (!network_to_native(&fixed, net_fixed))
            return RecvResult::Error;
        assert (fixed.magic_packet_id == Packet_Fixed<id>::PACKET_ID);
    }
    return rv;
}
示例#11
0
文件: login-user.hpp 项目: o11c/tmwa
bool network_to_native(Packet_Repeat<0x0069> *native, NetPacket_Repeat<0x0069> network)
{
    bool rv = true;
    rv &= network_to_native(&native->ip, network.ip);
    rv &= network_to_native(&native->port, network.port);
    rv &= network_to_native(&native->server_name, network.server_name);
    rv &= network_to_native(&native->users, network.users);
    rv &= network_to_native(&native->maintenance, network.maintenance);
    rv &= network_to_native(&native->is_new, network.is_new);
    return rv;
}
示例#12
0
RecvResult recv_vpacket(Session *s, Packet_Head<id>& head, AString& repeat)
{
    static_assert(id == Packet_Head<id>::PACKET_ID, "Packet_Head<id>::PACKET_ID");
    static_assert(headsize == sizeof(NetPacket_Head<id>), "NetPacket_Head<id>");
    static_assert(id == Packet_Repeat<id>::PACKET_ID, "Packet_Repeat<id>::PACKET_ID");
    static_assert(repeatsize == sizeof(NetPacket_Repeat<id>), "NetPacket_Repeat<id>");
    static_assert(repeatsize == 1, "repeatsize");

    NetPacket_Head<id> net_head;
    std::vector<NetPacket_Repeat<id>> net_repeat;
    RecvResult rv = net_recv_vpacket(s, net_head, net_repeat);
    assert (head.magic_packet_id == Packet_Head<id>::PACKET_ID);
    if (rv == RecvResult::Complete)
    {
        if (!network_to_native(&head, net_head))
            return RecvResult::Error;
        // reinterpret_cast is needed to correctly handle an empty vector
        const char *begin = sign_cast<const char *>(net_repeat.data());
        const char *end = begin + net_repeat.size();
        end = std::find(begin, end, '\0');
        repeat = XString(begin, end, nullptr);
    }
    return rv;
}
示例#13
0
RecvResult recv_ppacket(Session *s, Packet_Payload<id>& payload)
{
    static_assert(id == Packet_Payload<id>::PACKET_ID, "Packet_Payload<id>::PACKET_ID");

    NetPacket_Payload<id> net_payload;
    RecvResult rv = net_recv_ppacket(s, net_payload);
    if (rv == RecvResult::Complete)
    {
        if (!network_to_native(&payload, net_payload))
            return RecvResult::Error;
        assert (payload.magic_packet_id == Packet_Payload<id>::PACKET_ID);
        if (id == 0x8000)
        {
            // 0x8000 is special
            if (packet_avail(s) < payload.magic_packet_length)
                return RecvResult::Incomplete;
            payload.magic_packet_length = 4;
            return RecvResult::Complete;
        }
        if (payload.magic_packet_length != sizeof(net_payload))
            return RecvResult::Error;
    }
    return rv;
}
示例#14
0
文件: ids.hpp 项目: wushin/tmwa
 friend
 bool network_to_native(GmLevel *native, Little32 network)
 {
     return network_to_native(&native->bits, network);
 }
示例#15
0
文件: login-user.hpp 项目: o11c/tmwa
bool network_to_native(Packet_Repeat<0x0063> *native, NetPacket_Repeat<0x0063> network)
{
    bool rv = true;
    rv &= network_to_native(&native->c, network.c);
    return rv;
}