Godot-sandbox/test-client-godot
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity

remove gdscript and update modules

Browse source
This commit is contained in:
AleaJactaEst 2020-02-09 16:13:30 +01:00
parent c6a8820e65
commit c677e691d6
48 changed files with 124 additions and 2811 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

4
.gitmodules vendored
View file

@ -1,4 +0,0 @@
[submodule "godot-cpp"]
path = godot-cpp
url = https://github.com/GodotNativeTools/godot-cpp
branch = 3.1

3
README.md
View file

@ -13,7 +13,8 @@ touch .gdignore
git clone https://github.com/godotengine/godot.git
cd godot
# switch on release
git checkout 3.1.2-stable
#git checkout 3.1.2-stable
git checkout 3.2
# Create link with our module (or copy file to godot/modules - as you like)
cd modules
for file in ../../../modules/*

2
assets/Scripts/Definition/msg.gd
View file

@ -64,7 +64,7 @@ func read_all_node():
_msg_data[branch]["leaf"][leaf] = ileaf
ileaf += 1
ret = _msg_xml.read()
var NetworkConnexion = preload("res://networkconnexion.gdns").new()
#var networkConnexion = NetworkConnexion.new()
if ProjectSettings.get_setting("khaganat/debug_mode"):
#print("Branch:" + str(_msg_data.size()))
var sizebranch = _msg_data.size()

1
assets/Scripts/Network/net_low_level.gd
View file

@ -46,3 +46,4 @@ func _process(delta):
func _exit_tree():
print("[net_low_level] End")
disconnect_server()
_networkconnection.terminate_network_connection()

7
bitset.gdns
View file

@ -1,7 +0,0 @@
[gd_resource type="NativeScript" load_steps=2 format=2]
[ext_resource path="res://gdnative.gdnlib" type="GDNativeLibrary" id=1]
[resource]
class_name = "BitSet"
library = ExtResource( 1 )

7
bitstream.gdns
View file

@ -1,7 +0,0 @@
[gd_resource type="NativeScript" load_steps=2 format=2]
[ext_resource path="res://gdnative.gdnlib" type="GDNativeLibrary" id=1]
[resource]
class_name = "BitStream"
library = ExtResource( 1 )

7
crypt.gdns
View file

@ -1,7 +0,0 @@
[gd_resource type="NativeScript" load_steps=2 format=2]
[ext_resource path="res://gdnative.gdnlib" type="GDNativeLibrary" id=1]
[resource]
class_name = "Crypt"
library = ExtResource( 1 )

14
gdnative.gdnlib
View file

@ -1,14 +0,0 @@
[general]
singleton=false
load_once=true
symbol_prefix="godot_"
reloadable=true
[entry]
X11.64="res://gdnative/bin/libgdnative.linux.release.64.so"
[dependencies]
X11.64=[ ]

153
gdnative/SConstruct
View file

@ -1,153 +0,0 @@
#!python
#
# On root project
# scons -C gdnative platform=linux bits=64
#
import os, subprocess, platform, sys
# Local dependency paths, adapt them to your setup
godot_headers_path = "../godot-cpp/godot_headers/"
cpp_bindings_path = "../godot-cpp/"
cpp_library = "godot-cpp"
if not os.path.exists( 'bin' ):
os.mkdir( 'bin' )
def add_sources(sources, dir, extension):
for f in os.listdir(dir):
if f.endswith('.' + extension):
sources.append(dir + '/' + f)
# Try to detect the host platform automatically
# This is used if no `platform` argument is passed
if sys.platform.startswith('linux'):
host_platform = 'linux'
elif sys.platform == 'darwin':
host_platform = 'osx'
elif sys.platform == 'win32':
host_platform = 'windows'
else:
raise ValueError('Could not detect platform automatically, please specify with platform=<platform>')
opts = Variables([], ARGUMENTS)
opts.Add(EnumVariable('platform', 'Target platform', host_platform,
allowed_values=('linux', 'osx', 'windows'),
ignorecase=2))
opts.Add(EnumVariable('bits', 'Target platform bits', 'default', ('default', '32', '64')))
opts.Add(BoolVariable('use_llvm', 'Use the LLVM compiler - only effective when targeting Linux', False))
opts.Add(BoolVariable('use_mingw', 'Use the MinGW compiler - only effective on Windows', False))
# Must be the same setting as used for cpp_bindings
opts.Add(EnumVariable('target', 'Compilation target', 'debug',
allowed_values=('debug', 'release'),
ignorecase=2))
opts.Add(PathVariable('headers_dir', 'Path to the directory containing Godot headers', godot_headers_path, PathVariable.PathIsDir))
opts.Add(PathVariable('target_path', 'The path where the lib is installed.', 'bin'))
opts.Add(PathVariable('target_name', 'The library name.', 'libgdcrypt', PathVariable.PathAccept))
unknown = opts.UnknownVariables()
if unknown:
print("Unknown variables:" + unknown.keys())
Exit(1)
env = Environment()
opts.Update(env)
Help(opts.GenerateHelpText(env))
# sys.stderr.write("**** %s\n" % (cpp_library))
# This makes sure to keep the session environment variables on Windows
# This way, you can run SCons in a Visual Studio 2017 prompt and it will find all the required tools
if env['platform'] == 'windows':
if env['bits'] == '64':
env = Environment(TARGET_ARCH='amd64')
elif env['bits'] == '32':
env = Environment(TARGET_ARCH='x86')
else:
print("Warning: bits argument not specified, target arch is=" + env['TARGET_ARCH'])
opts.Update(env)
is64 = False
if (env['platform'] == 'osx' or env['TARGET_ARCH'] == 'amd64' or env['TARGET_ARCH'] == 'emt64' or env['TARGET_ARCH'] == 'x86_64'):
is64 = True
if env['bits'] == 'default':
env['bits'] = '64' if is64 else '32'
if env['platform'] == 'linux':
if env['use_llvm']:
env['CXX'] = 'clang++'
env.Append(CCFLAGS=['-fPIC', '-g', '-std=c++14', '-Wwrite-strings'])
env.Append(LINKFLAGS=["-Wl,-R,'$$ORIGIN'"])
if env['target'] == 'debug':
env.Append(CCFLAGS=['-Og'])
elif env['target'] == 'release':
env.Append(CCFLAGS=['-O3'])
if env['bits'] == '64':
env.Append(CCFLAGS=['-m64'])
env.Append(LINKFLAGS=['-m64'])
elif env['bits'] == '32':
env.Append(CCFLAGS=['-m32'])
env.Append(LINKFLAGS=['-m32'])
elif env['platform'] == 'osx':
if env['bits'] == '32':
raise ValueError('Only 64-bit builds are supported for the macOS target.')
env.Append(CCFLAGS=['-g', '-std=c++14', '-arch', 'x86_64'])
env.Append(LINKFLAGS=['-arch', 'x86_64', '-framework', 'Cocoa', '-Wl,-undefined,dynamic_lookup'])
if env['target'] == 'debug':
env.Append(CCFLAGS=['-Og'])
elif env['target'] == 'release':
env.Append(CCFLAGS=['-O3'])
elif env['platform'] == 'windows':
if host_platform == 'windows' and not env['use_mingw']:
# MSVC
env.Append(LINKFLAGS=['/WX'])
if env['target'] == 'debug':
env.Append(CCFLAGS=['/EHsc', '/D_DEBUG', '/MDd'])
elif env['target'] == 'release':
env.Append(CCFLAGS=['/O2', '/EHsc', '/DNDEBUG', '/MD'])
else:
# MinGW
if env['bits'] == '64':
env['CXX'] = 'x86_64-w64-mingw32-g++'
elif env['bits'] == '32':
env['CXX'] = 'i686-w64-mingw32-g++'
env.Append(CCFLAGS=['-g', '-O3', '-std=c++14', '-Wwrite-strings'])
env.Append(LINKFLAGS=['--static', '-Wl,--no-undefined', '-static-libgcc', '-static-libstdc++'])
env.Append(CPPPATH=['.', env['headers_dir'], 'include', 'include/gen', 'include/core'])
# source to compile
sources = []
add_sources(sources, 'src', 'cpp')
#add_sources(sources, 'src/gen', 'cpp')
# make sure our binding library is properly includes
env.Append(CPPPATH=['.', godot_headers_path, cpp_bindings_path + 'include/', cpp_bindings_path + 'include/core/', cpp_bindings_path + 'include/gen/'])
env.Append(LIBPATH=[cpp_bindings_path + 'bin/'])
libgodot = '{}.{}.{}.{}'.format(cpp_library, env['platform'], env['target'], env['bits'])
env.Append(LIBS=[libgodot])
# static = env.Command('libstdc++.a', None, Action('ln -s `g++ -print-file-name=libstdc++.a` $TARGET'));
# tweak this if you want to use different folders, or more folders, to store your source code in.
env.Append(CPPPATH=['src/'])
srcgdnative = Glob('src/*.cpp')
libgdnative = env.SharedLibrary(target=os.path.join(env['target_path'], 'libgdnative.{}.{}.{}'.format(env['platform'], env['target'], env['bits'])), source=srcgdnative)
Default(libgdnative)
# Generates help for the -h scons option.
Help(opts.GenerateHelpText(env))

0
gdnative/src/.gdignore
View file

1
gdnative/src/.gitignore vendored
View file

@ -1 +0,0 @@
*.os

164
gdnative/src/bitset.cpp
View file

@ -1,164 +0,0 @@
/*
* Class BitSet
Copyright (C) 2019 AleaJactaEst
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
Build :
scons platform=linux bits=64
*/
#include <Godot.hpp>
#include <iostream>
#include "bitset.h"
using namespace godot;
#define BITSET_SIZE 32
void BitSet::_register_methods()
{
register_method("size", &BitSet::size);
register_method("resize", &BitSet::resize);
register_method("clear", &BitSet::clear);
register_method("clear_data", &BitSet::clear_data);
register_method("set_bit", &BitSet::set_bit);
register_method("clear_bit", &BitSet::clear_bit);
register_method("put", &BitSet::put);
register_method("get", &BitSet::get);
register_method("write_serial", &BitSet::write_serial);
register_method("read_serial", &BitSet::read_serial);
register_method("show", &BitSet::show);
}
BitSet::BitSet()
{
this->_num_bits = 8;
this->_size_byte = 1;
this->_mask_last = 0;
this->_data = new uint32_t[1];
}
BitSet::~BitSet()
{
// add your cleanup here
if ( this->_data != nullptr )
delete [] this->_data;
}
void BitSet::_init()
{
}
int BitSet::size()
{
return this->_size_byte;
}
void BitSet::resize(uint32_t num_bits)
{
uint32_t i;
uint32_t n_last_bits;
if (this->_num_bits != num_bits )
{
this->_num_bits = num_bits;
this->_size_byte = (num_bits + BITSET_SIZE - 1) / BITSET_SIZE;
delete [] this->_data;
this->_data = new uint32_t[this->_size_byte];
n_last_bits = this->_num_bits & (BITSET_SIZE - 1);
if ( n_last_bits == 0 )
this->_mask_last = ~0;
else
this->_mask_last = (1 << n_last_bits) - 1;
}
this->clear_data();
}
void BitSet::clear()
{
this->resize(1);
}
void BitSet::clear_data()
{
for(uint32_t i = 0;i < this->_size_byte; ++i)
this->_data[i] = 0;
}
void BitSet::set_bit(uint32_t bit_number)
{
if (bit_number >= this->_size_byte)
throw "Out of range";
uint32_t mask = bit_number & (BITSET_SIZE - 1);
mask = 1 << mask;
this->_data[bit_number>>5] |= mask;
}
void BitSet::clear_bit(uint32_t bit_number)
{
if (bit_number >= this->_size_byte)
throw "Out of range";
uint32_t mask = bit_number & (BITSET_SIZE - 1);
mask = 1 << mask;
this->_data[bit_number>>5] &= mask;
}
void BitSet::put(uint32_t bit_number, bool value)
{
if (bit_number >= this->_size_byte)
throw "Out of range";
if ( value )
this->set_bit(bit_number);
else
this->clear_bit(bit_number);
}
bool BitSet::get(uint32_t bit_number)
{
if (bit_number >= this->_size_byte)
throw "Out of range";
uint32_t mask = bit_number & (BITSET_SIZE - 1);
mask = 1 << mask;
return this->_data[bit_number>>5] & mask != 0;
}
void BitSet::write_serial(BitStream * msgout)
{
uint8_t current_version = 0;
msgout->put_uint8(current_version);
msgout->put_uint32(this->_num_bits);
// _size_byte est lié à _num_bits dommage que l'on envoie celui-la
msgout->put_uint32(this->_size_byte);
for(uint32_t i = 0;i < this->_size_byte; ++i)
msgout->put_uint32(this->_data[i]);
}
void BitSet::read_serial(BitStream * msgin)
{
uint8_t current_version = msgin->get_sint8();
uint8_t num_bits = msgin->get_uint32();
this->resize(num_bits);
for(uint32_t i = 0;i < this->_size_byte; ++i)
this->_data[i] = msgin->get_uint32();
}
String BitSet::show()
{
BitStream msgout;
this->write_serial(&msgout);
return msgout.show();
}

59
gdnative/src/bitset.h
View file

@ -1,59 +0,0 @@
/*
Header BitSet
Copyright (C) 2019 AleaJactaEst
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#ifndef BIT_SET_H
#define BIT_SET_H
#include <Godot.hpp>
#include <Reference.hpp>
#include "bitstream.h"
namespace godot {
class BitSet : public Reference {
GODOT_CLASS(BitSet, Reference)
private:
uint32_t _num_bits;
uint32_t _size_byte;
uint32_t _mask_last;
uint32_t * _data;
public:
static void _register_methods();
BitSet();
~BitSet();
void _init(); // our initializer called by Godot
int size();
void resize(uint32_t num_bits);
void clear();
void clear_data();
void set_bit(uint32_t bit_number);
void clear_bit(uint32_t bit_number);
void put(uint32_t bit_number, bool value);
bool get(uint32_t bit_number);
void write_serial(BitStream * msgout);
void read_serial(BitStream * msgin);
String show();
};
}
#endif

457
gdnative/src/bitstream.cpp
View file

@ -1,457 +0,0 @@
/*
Copyright (C) 2019 AleaJactaEst
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
Build :
scons platform=linux bits=64
*/
#include <Godot.hpp>
#include "bitstream.h"
using namespace godot;
bool little_endian = false;
void BitStream::_register_methods()
{
register_method("is_little_endian", &BitStream::is_little_endian);
register_method("size", &BitStream::size);
register_method("put_serial", &BitStream::put_serial);
register_method("put_bool", &BitStream::put_bool);
register_method("put_char", &BitStream::put_char);
register_method("put_uint8", &BitStream::put_uint8);
register_method("put_sint8", &BitStream::put_sint8);
register_method("put_sint16", &BitStream::put_sint16);
register_method("put_uint16", &BitStream::put_uint16);
register_method("put_sint32", &BitStream::put_sint32);
register_method("put_uint32", &BitStream::put_uint32);
register_method("put_sint64", &BitStream::put_sint64);
register_method("put_uint64", &BitStream::put_uint64);
register_method("put_string", &BitStream::put_string);
register_method("put_string_hexa32", &BitStream::put_string_hexa32);
register_method("put_array_uint8", &BitStream::put_array_uint8);
register_method("show", &BitStream::show);
register_method("show_detail", &BitStream::show_detail);
register_method("show_counter", &BitStream::show_counter);
register_method("get_data", &BitStream::get_data);
register_method("put_data", &BitStream::put_data);
register_method("get_serial", &BitStream::get_serial);
register_method("get_bool", &BitStream::get_bool);
register_method("get_sint8", &BitStream::get_sint8);
register_method("get_uint8", &BitStream::get_uint8);
register_method("get_sint16", &BitStream::get_sint16);
register_method("get_uint16", &BitStream::get_uint16);
register_method("get_sint32", &BitStream::get_sint32);
register_method("get_uint32", &BitStream::get_uint32);
register_method("get_sint64", &BitStream::get_sint64);
register_method("get_uint64", &BitStream::get_uint64);
register_method("get_array_uint8", &BitStream::get_array_uint8);
}
void BitStream::clear()
{
this->_pos = 0;
this->_read = 0;
}
BitStream::BitStream()
{
clear();
}
BitStream::~BitStream()
{
// add your cleanup here
}
void BitStream::_init()
{
uint32_t i=0x12345678;
if ( (*((uint8_t*)(&i))) == 0x78 )
little_endian = true;
else
little_endian = false;
}
bool BitStream::is_little_endian()
{
return little_endian;
}
int BitStream::size()
{
return (this->_pos + 7) / 8;
}
int BitStream::size_data()
{
return this->_pos;
}
void BitStream::put_serial(uint32_t value, uint32_t nbits)
{
uint32_t v;
uint32_t mask;
uint32_t freeBits;
uint32_t pos;
if ( nbits == 0 )
return;
else if ( nbits > 32 )
throw "Out of range";
if ( this->_pos % 8 == 0 ) // Increase node
this->_data.append(0);
if ( nbits != 32 )
{
mask = (1 << nbits) - 1;
v = value & mask;
}
else
{
v = value;
}
freeBits = 8 - (this->_pos % 8);
pos = this->_data.size() - 1;
if(nbits > freeBits)
{
this->_data.set(pos, this->_data[pos] | (v >> (nbits - freeBits)));
this->_pos += freeBits;
this->put_serial(v, nbits - freeBits);
}
else
{
this->_data.set(pos, this->_data[pos] | (v << (freeBits - nbits)));
this->_pos += nbits;
}
}
void BitStream::put_bool(bool value)
{
this->put_serial(value, 1);
}
void BitStream::put_sint8(int8_t value)
{
this->put_serial(value, 8);
}
void BitStream::put_uint8(uint8_t value)
{
this->put_serial(value, 8);
}
void BitStream::put_sint16(int16_t value)
{
this->put_serial(value, 16);
}
void BitStream::put_uint16(uint16_t value)
{
this->put_serial(value, 16);
}
void BitStream::put_sint32(int32_t value)
{
this->put_serial(value, 32);
}
void BitStream::put_uint32(uint32_t value)
{
this->put_serial(value, 32);
}
void BitStream::put_sint64(int64_t value)
{
if(little_endian)
{
this->put_serial(value>>32, 32);
this->put_serial(value, 32);
}
else
{
this->put_serial(value, 32);
this->put_serial(value>>32, 32);
}
}
void BitStream::put_uint64(uint64_t value)
{
if(little_endian)
{
this->put_serial(value>>32, 32);
this->put_serial(value, 32);
}
else
{
this->put_serial(value, 32);
this->put_serial(value>>32, 32);
}
}
void BitStream::put_string_hexa32(String hexa)
{
uint32_t res = 0;
CharString tmp = hexa.ascii();
for(const char * c = tmp.get_data(); *c != 0; c++)
{
res <<= 4;
if ( *c >= '0' && *c <= '9')
res += *c - '0';
else if ( *c >= 'A' && *c <= 'F')
res += *c - 'A' + 10;
}
this->put_serial(res,32);
}
void BitStream::put_char(String value)
{
if ( value.length() >= 1)
this->put_uint8( value[0] );
else
this->put_uint8( 0 );
}
void BitStream::put_string(String value)
{
uint32_t lenvalue = value.length();
this->put_uint32(lenvalue);
//CharString tmp = value.ascii();
for(uint32_t i = 0; i < lenvalue ; ++i)
{
this->put_char(value[i]);
}
}
void BitStream::put_array_uint8(PoolByteArray value)
{
uint32_t i;
for(i = 0; i < value.size() ; ++i)
this->put_serial(value[i], 8);
}
String BitStream::show()
{
String ret;
uint32_t pos = 0;
for(uint32_t i = 0; i < this->_data.size(); ++i)
{
uint8_t c = this->_data[i];
uint8_t mask = 0x80;
while(mask)
{
if ( (c & mask) != 0 )
ret += String('1');
else
ret += String('0');
mask >>= 1;
pos += 1;
if (pos >= this->_pos)
break;
}
if (pos >= this->_pos)
break;
}
return ret ;
}
String BitStream::show_detail()
{
String ret;
uint32_t pos = 0;
for(uint32_t i = 0; i < this->_data.size(); ++i)
{
uint8_t c = this->_data[i];
uint8_t mask = 0x80;
while(mask)
{
if ( (c & mask) != 0 )
ret += String('1');
else
ret += String('0');
mask >>= 1;
pos += 1;
if (pos >= this->_pos)
break;
}
if (pos >= this->_pos)
break;
}
String strsize;
uint32_t t = this->_data.size();
if ( t == 0) strsize = "0";
while ( t > 0 )
{
char c = '0' + ( t % 10 );
strsize = String(c) + strsize;
t /= 10;
}
String strpos;
t = this->_pos;
if ( t == 0) strpos = "0";
while ( t > 0 )
{
char c = '0' + ( t % 10 );
strpos = String(c) + strpos;
t /= 10;
}
return "[size:" + strsize + ", pos:" + strpos + "]" + ret ;
}
String BitStream::show_counter()
{
String ret = "[" + String::num_int64(this->_read) + " / " + String::num_int64(this->_pos) + "]";
return ret;
}
PoolByteArray BitStream::get_data()
{
return this->_data;
}
void BitStream::put_data(PoolByteArray value)
{
this->_data = value;
this->_pos = value.size() * 8;
}
uint32_t BitStream::get_serial(uint32_t nbits)
{
uint32_t value;
uint32_t pos;
uint32_t freeBits;
uint32_t v;
if ( nbits == 0 )
return 0;
else if ( nbits > 32 )
{
ERR_PRINT("Out of range (BitStream::get_serial)");
throw "Out of range";
}
if (this->_read + nbits > this->_pos)
{
ERR_PRINT("Out of range (BitStream::get_serial)");
throw "Out of range";
}
value = 0;
pos = this->_read / 8;
freeBits = 8 - (this->_read % 8);
v = this->_data[pos] & ((1 << freeBits) - 1);
if(nbits > freeBits)
{
value |= (v << (nbits-freeBits));
this->_read += freeBits;
value |= this->get_serial(nbits - freeBits);
}
else
{
value |= (v >> (freeBits-nbits));
this->_read += nbits;
}
return value;
}
bool BitStream::get_bool()
{
if(this->get_serial(1) == 0)
return false;
return true;
}
int8_t BitStream::get_sint8()
{
return this->get_serial(8);
}
uint8_t BitStream::get_uint8()
{
return this->get_serial(8);
}
int16_t BitStream::get_sint16()
{
return this->get_serial(16);
}
uint16_t BitStream::get_uint16()
{
return this->get_serial(16);
}
int32_t BitStream::get_sint32()
{
return this->get_serial(32);
}
uint32_t BitStream::get_uint32()
{
return this->get_serial(32);
}
int64_t BitStream::get_sint64()
{
int64_t v1;
int64_t v2;
if(little_endian)
{
v1 = this->get_serial(32);
v2 = this->get_serial(32);
}
else
{
v2 = this->get_serial(32);
v1 = this->get_serial(32);
}
return (v1 << 32) | v2;
}
uint64_t BitStream::get_uint64()
{
int64_t v1;
int64_t v2;
if(little_endian)
{
v1 = this->get_serial(32);
v2 = this->get_serial(32);
}
else
{
v2 = this->get_serial(32);
v1 = this->get_serial(32);
}
return (v1 << 32) | v2;
}
PoolByteArray BitStream::get_array_uint8(uint32_t length)
{
PoolByteArray ret;
while(length != 0)
{
ret.append(this->get_serial(8));
--length;
}
return ret;
}

86
gdnative/src/bitstream.h
View file

@ -1,86 +0,0 @@
/*
Header BitStream
Copyright (C) 2019 AleaJactaEst
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#ifndef BIT_STREAM_H
#define BIT_STREAM_H
#include <Godot.hpp>
#include <Reference.hpp>
namespace godot {
class BitStream : public Reference {
GODOT_CLASS(BitStream, Reference)
private:
uint32_t _pos;
uint32_t _read;
PoolByteArray _data;
public:
static void _register_methods();
void clear();
BitStream();
~BitStream();
void _init(); // our initializer called by Godot
bool is_little_endian();
int size();
int size_data();
void put_serial(uint32_t value, uint32_t nbits);
void put_bool(bool value);
void put_sint8(int8_t value);
void put_uint8(uint8_t value);
void put_sint16(int16_t value);
void put_uint16(uint16_t value);
void put_sint32(int32_t value);
void put_uint32(uint32_t value);
void put_sint64(int64_t value);
void put_uint64(uint64_t value);
void put_string_hexa32(String hexa);
void put_char(String value);
void put_string(String value);
void put_array_uint8(PoolByteArray value);
String show();
String show_detail();
String show_counter();
PoolByteArray get_data();
void put_data(PoolByteArray value);
uint32_t get_serial(uint32_t nbits);
bool get_bool();
int8_t get_sint8();
uint8_t get_uint8();
int16_t get_sint16();
uint16_t get_uint16();
int32_t get_sint32();
uint32_t get_uint32();
int64_t get_sint64();
uint64_t get_uint64();
PoolByteArray get_array_uint8(uint32_t length);
};
}
#endif

42
gdnative/src/clfecommon.h
View file

@ -1,42 +0,0 @@
/*
Header CLFECOMMON : message send by server
Copyright (C) 2019 AleaJactaEst
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#ifndef CLFECOMMON_H
#define CLFECOMMON_H
namespace godot {
enum CLFECOMMON {
SYSTEM_LOGIN_CODE = 0,
SYSTEM_SYNC_CODE = 1,
SYSTEM_ACK_SYNC_CODE = 2,
SYSTEM_PROBE_CODE = 3,
SYSTEM_ACK_PROBE_CODE = 4,
SYSTEM_DISCONNECTION_CODE = 5,
SYSTEM_STALLED_CODE = 6,
SYSTEM_SERVER_DOWN_CODE = 7,
SYSTEM_QUIT_CODE = 8,
SYSTEM_ACK_QUIT_CODE = 9,
NUMBITSINLONGACK = 512
};
}
#endif // CLFECOMMON_H

34
gdnative/src/crypt.cpp
View file

@ -1,34 +0,0 @@
/*
Build :
scons platform=linux bits=64
*/
#include "crypt.h"
#include "sha512crypt.h"
using namespace godot;
void Crypt::_register_methods() {
register_method("encrypt", &Crypt::encrypt);
}
Crypt::Crypt() {
}
Crypt::~Crypt() {
// add your cleanup here
}
void Crypt::_init() {
// initialize any variables here
}
String Crypt::encrypt(String key, String salt) {
String out = "";
char * res = sha512_crypt (key.ascii().get_data(), salt.ascii().get_data());
out = res;
return out;
}

25
gdnative/src/crypt.h
View file

@ -1,25 +0,0 @@
#ifndef CRYPT_H
#define CRYPT_H
#include <Godot.hpp>
#include <Reference.hpp>
namespace godot {
class Crypt : public Object {
GODOT_CLASS(Crypt, Object)
public:
static void _register_methods();
Crypt();
~Crypt();
void _init(); // our initializer called by Godot
String encrypt(String key, String salt);
};
}
#endif

47
gdnative/src/gdlibrary.cpp
View file

@ -1,47 +0,0 @@
/*
Header to link with Godot
Copyright (C) 2019 AleaJactaEst
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#include "bitstream.h"
#include "bitset.h"
#include "crypt.h"
#include "network_connection.h"
#include "message_description_node.h"
/** GDNative Initialize **/
extern "C" void GDN_EXPORT godot_gdnative_init(godot_gdnative_init_options *o) {
godot::Godot::gdnative_init(o);
}
/** GDNative Terminate **/
extern "C" void GDN_EXPORT godot_gdnative_terminate(godot_gdnative_terminate_options *o) {
terminate_network_connection();
godot::Godot::gdnative_terminate(o);
}
/** NativeScript Initialize **/
extern "C" void GDN_EXPORT godot_nativescript_init(void *handle) {
godot::Godot::nativescript_init(handle);
godot::register_class<godot::BitStream>();
godot::register_class<godot::BitSet>();
godot::register_class<godot::Crypt>();
godot::register_class<godot::NetworkConnection>();
godot::register_class<godot::MessageDescriptionNode>();
}

99
gdnative/src/network_connection.cpp
View file

@ -1,99 +0,0 @@
/*
Library to present all functions of NetworkConnectionCore (network)
Copyright (C) 2019 AleaJactaEst
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#include <Godot.hpp>
#include "network_connection.h"
#include "bitstream.h"
#include "network_connection_core.h"
using namespace godot;
NetworkConnectionCore *NetworkConnectionCore::singleton = NULL;
void NetworkConnection::_register_methods()
{
register_method("define_checksum_msg_xml", &NetworkConnection::define_checksum_msg_xml);
register_method("define_socket_udp", &NetworkConnection::define_socket_udp);
register_method("send_system_login", &NetworkConnection::send_system_login);
register_method("send_system_disconnect", &NetworkConnection::send_system_disconnect);
register_method("send_system_quit", &NetworkConnection::send_system_quit);
register_method("disconnect_server", &NetworkConnection::disconnect_server);
register_method("process", &NetworkConnection::process);
register_method("get_state", &NetworkConnection::get_state);
register_method("get_master_message_description_node", &NetworkConnection::get_master_message_description_node);
}
NetworkConnection::NetworkConnection()
{
}
NetworkConnection::~NetworkConnection()
{
}
int NetworkConnection::get_state()
{
return NetworkConnectionCore::get_singleton()->get_state();
}
void NetworkConnection::define_checksum_msg_xml(Array checksum_msg_xml)
{
NetworkConnectionCore::get_singleton()->define_checksum_msg_xml(checksum_msg_xml);
}
void NetworkConnection::define_socket_udp(PacketPeerUDP * socketUDP)
{
NetworkConnectionCore::get_singleton()->define_socket_udp(socketUDP);
}
void NetworkConnection::send_system_login(String host, int64_t port, String user_addr, String user_key, String user_id, String lang)
{
NetworkConnectionCore::get_singleton()->send_system_login(host, port, user_addr, user_key, user_id, lang);
}
void NetworkConnection::send_system_disconnect()
{
NetworkConnectionCore::get_singleton()->send_system_disconnect();
}
void NetworkConnection::send_system_quit()
{
NetworkConnectionCore::get_singleton()->send_system_quit();
}
void NetworkConnection::disconnect_server()
{
NetworkConnectionCore::get_singleton()->disconnect_server();
}
void NetworkConnection::process(int delta)
{
NetworkConnectionCore::get_singleton()->process(delta);
}
MessageDescriptionNode & NetworkConnection::get_master_message_description_node()
{
return NetworkConnectionCore::get_singleton()->get_master_message_description_node();
}
void terminate_network_connection()
{
NetworkConnectionCore::get_singleton()->terminate_connexion();
}

64
gdnative/src/network_connection.h
View file

@ -1,64 +0,0 @@
/*
Header NetworkConnection
Copyright (C) 2019 AleaJactaEst
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#ifndef NETWORK_CONNECTION_H
#define NETWORK_CONNECTION_H
#include <Godot.hpp>
#include <gen/PacketPeerUDP.hpp>
#include <Reference.hpp>
#include "bitstream.h"
#include "clfecommon.h"
#include "store_message.h"
#include "network_connection_core.h"
namespace godot {
class NetworkConnection : public Object {
GODOT_CLASS(NetworkConnection, Object)
private:
static void _bind_methods();
public:
NetworkConnection();
~NetworkConnection();
static void _register_methods();
/* _init must exist as it is called by Godot */
void _init() {};
void define_checksum_msg_xml(Array checksum_msg_xml);
void define_socket_udp(PacketPeerUDP * socketUDP); // Not necessary, but you can define network directly on GdScript
void send_system_login(String host, int64_t port, String user_addr, String user_key, String user_id, String lang);
void send_system_disconnect();
void send_system_quit();
void disconnect_server();
void process(int delta);
int get_state();
MessageDescriptionNode & get_master_message_description_node();
};
}
void terminate_network_connection();
#endif // NETWORK_CONNECTION_H

487
gdnative/src/network_connection_core.cpp
View file

@ -1,487 +0,0 @@
/*
Library to manage network
Copyright (C) 2019 AleaJactaEst
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#define DEBUG_ENABLED
#include <Godot.hpp>
#include <core/Defs.hpp>
#include <gen/PacketPeerUDP.hpp>
#include "tools.h"
#include "bitset.h"
#include "bitstream.h"
#include "network_connection_core.h"
#include "state.h"
using namespace godot;
NetworkConnectionCore *NetworkConnectionCore::get_singleton()
{
if ( NetworkConnectionCore::singleton == NULL )
NetworkConnectionCore::singleton = new NetworkConnectionCore();
return NetworkConnectionCore::singleton;
}
NetworkConnectionCore::NetworkConnectionCore()
{
this->_socketUDP = NULL;
this->_state = STATE::NotInitialised ;
}
NetworkConnectionCore::~NetworkConnectionCore()
{
NetworkConnectionCore::singleton = NULL;
this->_state = STATE::NotInitialised ;
}
int NetworkConnectionCore::get_state()
{
return this->_state;
}
void NetworkConnectionCore::define_checksum_msg_xml(Array & checksum_msg_xml)
{
DEBUG_PRINT("Received msg.xml checksum");
this->_checksum_msg_xml = checksum_msg_xml;
DEBUG_PRINT("Received msg.xml checksum " + itos(checksum_msg_xml.size()));
DEBUG_PRINT("Received msg.xml checksum " + itos(this->_checksum_msg_xml.size()));
}
void NetworkConnectionCore::define_socket_udp(PacketPeerUDP * socketUDP)
{
// Use if you define PacketPeerUDP on other script
if ( this->_socketUDP == NULL)
this->_socketUDP = socketUDP;
}
void NetworkConnectionCore::autodefine_socket_udp()
{
// Create socket udp if not defined (If you don't use define_socket_udp)
if ( this->_socketUDP == NULL)
{
PacketPeerUDP::___init_method_bindings();
this->_socketUDP = PacketPeerUDP::_new();
if ( this->_socketUDP == NULL)
throw "Failed to open network";
}
}
void NetworkConnectionCore::send_system_login(String host, int64_t port, String user_addr, String user_key, String user_id, String lang)
{
// Configure socket UDP
this->autodefine_socket_udp();
if ( this->_state != STATE::NotInitialised )
{
DEBUG_PRINT("Close old network socket");
this->_socketUDP->close();
}
INFO_PRINT("Connect to " + host + ":" + itos(port));
this->_socketUDP->set_dest_address(host, port);
// Open connection and send ID
BitStream msgout;
msgout.put_sint32(_current_received_number);
msgout.put_bool(true);
msgout.put_uint8(CLFECOMMON::SYSTEM_LOGIN_CODE);
msgout.put_string_hexa32(user_addr);
msgout.put_string_hexa32(user_key);
msgout.put_string_hexa32(user_id);
msgout.put_string(lang);
godot::Error ret;
ret = this->_socketUDP->put_packet(msgout.get_data());
if ( ret != Error::OK)
{
this->_socketUDP->close();
switch(ret)
{
case Error::ERR_CANT_CONNECT:
ERR_PRINT("network connexion - Can't connect");
default:
ERR_PRINT("network connexion - Unknown error");
}
return;
}
INFO_PRINT("Connected to khganat");
this->_state = STATE::Connected;
// Initialize counter
this->_current_received_number = 0;
this->_last_received_number = 0;
this->_quit_id = 0;
this->_long_ack_bit_field.resize(NUM_BITS_IN_LONG_ACK);
this->_latest_probes.clear();
this->_ack_bit_mask = 0;
this->_last_ack_bit = 0;
this->_last_ack_in_long_ack = 0;
}
void NetworkConnectionCore::send_system_quit()
{
// TODO - check why we send quit_id
if ( this->_state != STATE::Connected && this->_state != STATE::ForceSynchronize )
return;
DEBUG_PRINT("send quit to server");
BitStream msgout;
msgout.put_sint32(this->_current_received_number);
msgout.put_bool(true);
msgout.put_uint8(CLFECOMMON::SYSTEM_QUIT_CODE);
msgout.put_sint32(this->_quit_id);
if ( this->_socketUDP->put_packet(msgout.get_data()) != Error::OK )
{
ERR_PRINT("Error to send disconnect");
}
this->_state = STATE::Quit;
}
void NetworkConnectionCore::send_system_disconnect()
{
if ( this->_state != STATE::Connected && this->_state != STATE::ForceSynchronize )
return;
DEBUG_PRINT("send disconnect to server");
BitStream msgout;
msgout.put_sint32(this->_current_received_number);
msgout.put_bool(true);
msgout.put_uint8(CLFECOMMON::SYSTEM_DISCONNECTION_CODE);
if ( this->_socketUDP->put_packet(msgout.get_data()) != Error::OK )
{
ERR_PRINT("Error to send disconnect");
}
this->_socketUDP->close();
this->_state = STATE::Disconnect;
}
void NetworkConnectionCore::send_system_ack_probe()
{
// khanat-opennel-code/code/ryzom/server/src/frontend_service/fe_receive_sub.cpp:1121 void CFeReceiveSub::handleReceivedMsg( CClientHost *clienthost )
if (this->_state != STATE::Connected && this->_state != STATE::ForceSynchronize)
return;
int max = this->_latest_probes.size();
if (max == 0 )
return;
if (this->_state == STATE::ForceSynchronize && max < 5)
return;
DEBUG_PRINT("send system ACK PROBE to server");
BitStream msgout;
msgout.put_sint32(this->_current_received_number);
msgout.put_bool(true);
msgout.put_uint8(CLFECOMMON::SYSTEM_ACK_PROBE_CODE);
msgout.put_sint32(max);
for(int i=0; i < max ; ++i )
{
//DEBUG_PRINT("i:" + itos(i));
int data = this->_latest_probes[i];
//DEBUG_PRINT("data:" + itos(data));
msgout.put_sint32(data);
//DEBUG_PRINT("updated");
}
if (this->_socketUDP->put_packet(msgout.get_data()) != Error::OK)
{
ERR_PRINT("Error to send disconnect");
return;
}
this->_latest_probes.clear();
if (this->_state == STATE::ForceSynchronize && max >= 5)
{
// We have send ACK, so now we clean all queue and received all message to synchronize
this->queue.clear();
this->_state = STATE::Connected;
}
}
void NetworkConnectionCore::disconnect_server()
{
if (this->_state != STATE::Connected && this->_state != STATE::ForceSynchronize)
return;
send_system_disconnect();
}
void NetworkConnectionCore::decode_system_message(BitStream *msgin)
{
int message = msgin->get_uint8();
switch (message)
{
case CLFECOMMON::SYSTEM_LOGIN_CODE:
DEBUG_PRINT("SYSTEM_LOGIN_CODE");
break;
case CLFECOMMON::SYSTEM_SYNC_CODE:
this->receive_system_sync(msgin);
break;
case CLFECOMMON::SYSTEM_STALLED_CODE:
DEBUG_PRINT("SYSTEM_STALLED_CODE");
break;
case CLFECOMMON::SYSTEM_SERVER_DOWN_CODE:
DEBUG_PRINT("SYSTEM_SERVER_DOWN_CODE");
break;
case CLFECOMMON::SYSTEM_PROBE_CODE:
this->receive_system_probe(msgin);
break;
default:
ERR_PRINT("Received unknown message [" + itos(message) + "]");
break;
}
}
void NetworkConnectionCore::decode_normal_message(BitStream *msgin)
{
DEBUG_PRINT("Decode normal message");
}
void NetworkConnectionCore::receive_system_sync(BitStream * msgin)
{
int i;
bool valide = true;
DEBUG_PRINT("SYSTEM_SYNC_CODE");
uint32_t synchronize = msgin->get_uint32();
int64_t stime = msgin->get_sint64();
uint32_t latestsync = msgin->get_uint32();
PoolByteArray msg_xml = msgin->get_array_uint8(16);
PoolByteArray database_xml = msgin->get_array_uint8(16);
if ( msg_xml.size() != this->_checksum_msg_xml.size() )
{
valide = false;
DEBUG_PRINT("MSG XML is incorrect (server:" + itos(msg_xml.size()) +", client:" + itos(this->_checksum_msg_xml.size()) + ")");
}
else
{
for(i=0; i<msg_xml.size(); ++i)
{
if ( (int) msg_xml[i] != (int) this->_checksum_msg_xml[i] )
{
valide = false;
DEBUG_PRINT("MSG XML is incorrect (pos:" + itos(i) +")");
}
}
}
if ( valide == true )
DEBUG_PRINT("MSG XML is correct");
else
DEBUG_PRINT("MSG.XML is wrong");
/*
self._Synchronize = msg.readUint32('Synchronize')
stime = msg.readSint64('stime')
self._LatestSync = msg.readUint32('LatestSync')
logging.getLogger(LOGGER).debug("%d %d %d" %(self._Synchronize, stime, self._LatestSync))
# khanat-opennel-code/code/ryzom/client/src/network_connection.cpp : void CNetworkConnection::receiveSystemSync(CBitMemStream &msgin)
MsgData = msg.readArrayUint8(16, 'MsgData')
DatabaseData = msg.readArrayUint8(16, 'DatabaseData')
logging.getLogger(LOGGER).debug("MsgData:" + str(MsgData))
logging.getLogger(LOGGER).debug("DatabaseData:" + str(DatabaseData))
md5Msg = bytes(MsgData)
md5Database = bytes(DatabaseData)
if md5Msg == self._MsgXmlMD5:
logging.getLogger(LOGGER).info("Check MD5 msg.xml : OK")
else:
logging.getLogger(LOGGER).error("Check MD5 msg.xml : KO")
if md5Database == self._DatabaseXmlMD5:
logging.getLogger(LOGGER).info("Check MD5 database.xml : OK")
else:
logging.getLogger(LOGGER).error("Check MD5 database.xml : KO")
logging.getLogger(LOGGER).debug("Msg Received:" + msg.showAllData())
self._MsPerTick = 100
self._CurrentServerTick = self._Synchronize + self._CurrentReceivedNumber + 2
self._CurrentClientTick = self._CurrentServerTick - ( self._LCT + self._MsPerTick ) / self._MsPerTick
self._CurrentClientTime = self._UpdateTime - (self._LCT + self._MsPerTick)
*/
}
void NetworkConnectionCore::receive_system_probe(BitStream * msgin)
{
DEBUG_PRINT("SYSTEM_PROBE_CODE size:" + itos(this->_latest_probes.size()));
this->_latest_probes.append(msgin->get_sint32());
}
void NetworkConnectionCore::wait_resynchronize(int32_t current_received_number, BitStream * msgin)
{
bool system_mode;
this->_current_received_number = current_received_number;
system_mode = msgin->get_bool();
if ( system_mode == true )
{
int message = msgin->get_uint8();
switch (message)
{
case CLFECOMMON::SYSTEM_LOGIN_CODE:
DEBUG_PRINT("SYSTEM_LOGIN_CODE");
break;
case CLFECOMMON::SYSTEM_SYNC_CODE:
DEBUG_PRINT("SYSTEM_SYNC_CODE");
break;
case CLFECOMMON::SYSTEM_STALLED_CODE:
DEBUG_PRINT("SYSTEM_STALLED_CODE");
break;
case CLFECOMMON::SYSTEM_SERVER_DOWN_CODE:
DEBUG_PRINT("SYSTEM_SERVER_DOWN_CODE");
break;
case CLFECOMMON::SYSTEM_PROBE_CODE:
this->receive_system_probe(msgin);
break;
default:
ERR_PRINT("Received unknown message [" + itos(message) + "]");
break;
}
}
this->_last_received_number = current_received_number;
}
void NetworkConnectionCore::analyze_message_receieved(int32_t current_received_number, BitStream * msgin)
{
bool system_mode;
bool ackBool = false;
int ackBit = 0;
int i;
this->_current_received_number = current_received_number;
system_mode = msgin->get_bool();
if ( system_mode == true )
{
INFO_PRINT("Received system message");
if (this->_current_received_number == this->_last_received_number + 1)
{
INFO_PRINT("Received message");
}
else if (this->_current_received_number < this->_last_received_number + 1)
{
INFO_PRINT("Received old message");
return;
}
else if (this->_current_received_number > this->_last_received_number + 1)
{
INFO_PRINT("Received message in future (lost some message)");
}
}
else
{
INFO_PRINT("Received normal message");
}
if ( system_mode != true )
{
ackBool = true;
ackBit = 1;
}
if ( current_received_number - this->_last_received_number < 32 )
{
this->_ack_bit_mask <<= current_received_number - this->_last_received_number;
this->_ack_bit_mask |= this->_last_ack_bit << (current_received_number - this->_last_received_number - 1);
}
else if (((current_received_number - this->_last_received_number) == 32) && (this->_last_ack_bit != 0))
this->_ack_bit_mask = 0x80000000;
else
this->_ack_bit_mask = 0x00000000;
this->_last_ack_bit = ackBit;
for(i=this->_last_received_number + 1 ;i < _current_received_number; ++i)
this->_long_ack_bit_field.clear_bit(i & (NUM_BITS_IN_LONG_ACK -1) );
// TODO - what's action when we have rotate onthis number (max -> 0)
if( this->_last_received_number > 0x08000000 )
{
if(this->_last_ack_in_long_ack <= (this->_last_received_number - NUM_BITS_IN_LONG_ACK))
this->_last_ack_in_long_ack = this->_last_received_number - NUM_BITS_IN_LONG_ACK + 1;
this->_last_received_number = current_received_number;
}
else
{
if(this->_last_ack_in_long_ack - 0x80000000 <= (this->_last_received_number - NUM_BITS_IN_LONG_ACK - 0x80000000))
this->_last_ack_in_long_ack = this->_last_received_number - NUM_BITS_IN_LONG_ACK + 1;
this->_last_received_number = current_received_number;
}
if ( system_mode == true )
this->decode_system_message(msgin);
else
this->decode_normal_message(msgin);
}
void NetworkConnectionCore::store_message_received(PoolByteArray & msgbytes)
{
int pos = this->queue.put_msgbytes(msgbytes);
BitStream * msgin = this->queue.get_msg(pos);
int32_t current_received_number = this->queue.get_received_number(pos);
/// TODO - check if max int execeded current_received_number < 1000 this->_last_received_number > 0x80000000
if ( this->_state == STATE::ForceSynchronize )
{
// We have detected a problem of synchro, we wait message ack probe and after server launch a re-sync
wait_resynchronize(current_received_number, msgin);
}
else if ( current_received_number - this->_last_received_number <= 0 ) // Received old message
{
INFO_PRINT("current_received_number : " + itos(current_received_number) + " / queue size : " + itos(this->queue.length()));
this->queue.erase(pos);
return;
}
else if ( this->_last_received_number + 1 == current_received_number ) // Received next message
{
INFO_PRINT("current_received_number : " + itos(current_received_number) + " / queue size : " + itos(this->queue.length()));
analyze_message_receieved(current_received_number, msgin);
this->queue.erase(pos);
}
else // Received new message (but missing some message between) -> go to queue and cross finger to received the next message (for _last_received_number)
{
INFO_PRINT("current_received_number : " + itos(current_received_number) + " / queue size : " + itos(this->queue.length()));
if (this->queue.length() >= SIZE_QUEUE_MESSAGE)
{
ERR_PRINT("Network queue is full / wait re-synchronize");
this->_state = STATE::ForceSynchronize ;
return;
}
}
}
void NetworkConnectionCore::send_message()
{
if ( this->_latest_probes.size() > 0 )
send_system_ack_probe();
}
void NetworkConnectionCore::process(int delta)
{
if (this->_state != STATE::Connected && this->_state != STATE::ForceSynchronize)
return;
//INFO_PRINT( "Process - delta : " + itos(delta));
for(int i = 0; (this->_socketUDP->get_available_packet_count() > 0) && (i < MAX_LOOP_READ_BY_STEP) ; ++i)
{
PoolByteArray msgbytes ;
msgbytes = this->_socketUDP->get_packet();
DEBUG_PRINT("Size msg received : " + itos(msgbytes.size()) );
store_message_received(msgbytes);
}
send_message();
}
void NetworkConnectionCore::terminate_connexion()
{
DEBUG_PRINT("Terminate network connexion");
if ( this->_socketUDP == NULL )
return;
delete this-> _socketUDP;
this->_socketUDP = NULL;
}
MessageDescriptionNode & NetworkConnectionCore::get_master_message_description_node()
{
return this->_message_description_node;
}

91
gdnative/src/network_connection_core.h
View file

@ -1,91 +0,0 @@
/*
Header NetworkConnectionCore
Copyright (C) 2019 AleaJactaEst
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#ifndef NETWORK_CONNECTION_CORE_H
#define NETWORK_CONNECTION_CORE_H
#include <Godot.hpp>
#include <gen/PacketPeerUDP.hpp>
#include "bitset.h"
#include "bitstream.h"
#include "clfecommon.h"
#include "store_message.h"
#include "state.h"
#include "message_description_node.h"
#define MAX_LOOP_READ_BY_STEP 10
#define NUM_BITS_IN_LONG_ACK 512
namespace godot {
class NetworkConnectionCore : public Object {
GODOT_CLASS(NetworkConnectionCore, Object)
private:
static NetworkConnectionCore *singleton;
bool _force_resynchronize;
STATE _state;
PacketPeerUDP * _socketUDP;
int32_t _current_received_number;
int32_t _last_received_number;
int32_t _quit_id;
BitSet _long_ack_bit_field;
Array _latest_probes;
Array _checksum_msg_xml;
uint32_t _ack_bit_mask;
int32_t _last_ack_bit;
int32_t _last_ack_in_long_ack;
StoreMessage queue;
MessageDescriptionNode _message_description_node;
public:
static NetworkConnectionCore * get_singleton();
NetworkConnectionCore();
~NetworkConnectionCore();
int get_state();
void define_checksum_msg_xml(Array & checksum_msg_xml);
void define_socket_udp(PacketPeerUDP * socketUDP);
void autodefine_socket_udp();
void send_system_login(String host, int64_t port, String user_addr, String user_key, String user_id, String lang);
void send_system_disconnect();
void send_system_quit();
void disconnect_server();
void send_system_ack_probe();
void decode_system_message(BitStream *msgin);
void decode_normal_message(BitStream *msgin);
void receive_system_sync(BitStream * msgin);
void receive_system_probe(BitStream * msgin);
void wait_resynchronize(int32_t current_received_number, BitStream * msgin);
void analyze_message_receieved(int32_t, BitStream *msgin);
void store_message_received(PoolByteArray & msgbytes);
void send_message();
void process(int delta);
bool connected();
void terminate_connexion();
MessageDescriptionNode & get_master_message_description_node();
};
}
#endif

622
gdnative/src/sha512crypt.cpp
View file

@ -1,622 +0,0 @@
/* SHA512-based Unix crypt implementation.
Released into the Public Domain by Ulrich Drepper <drepper@redhat.com>. */
#include <endian.h>
#include <errno.h>
#include <limits.h>
#include <stdbool.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/param.h>
#include <sys/types.h>
/* Structure to save state of computation between the single steps. */
struct sha512_ctx
{
uint64_t H[8];
uint64_t total[2];
uint64_t buflen;
char buffer[256]; /* NB: always correctly aligned for uint64_t. */
};
#if __BYTE_ORDER == __LITTLE_ENDIAN
# define SWAP(n) \
(((n) << 56) \
| (((n) & 0xff00) << 40) \
| (((n) & 0xff0000) << 24) \
| (((n) & 0xff000000) << 8) \
| (((n) >> 8) & 0xff000000) \
| (((n) >> 24) & 0xff0000) \
| (((n) >> 40) & 0xff00) \
| ((n) >> 56))
#else
# define SWAP(n) (n)
#endif
/* This array contains the bytes used to pad the buffer to the next
64-byte boundary. (FIPS 180-2:5.1.2) */
static const unsigned char fillbuf[128] = { 0x80, 0 /* , 0, 0, ... */ };
/* Constants for SHA512 from FIPS 180-2:4.2.3. */
static const uint64_t K[80] =
{
UINT64_C (0x428a2f98d728ae22), UINT64_C (0x7137449123ef65cd),
UINT64_C (0xb5c0fbcfec4d3b2f), UINT64_C (0xe9b5dba58189dbbc),
UINT64_C (0x3956c25bf348b538), UINT64_C (0x59f111f1b605d019),
UINT64_C (0x923f82a4af194f9b), UINT64_C (0xab1c5ed5da6d8118),
UINT64_C (0xd807aa98a3030242), UINT64_C (0x12835b0145706fbe),
UINT64_C (0x243185be4ee4b28c), UINT64_C (0x550c7dc3d5ffb4e2),
UINT64_C (0x72be5d74f27b896f), UINT64_C (0x80deb1fe3b1696b1),
UINT64_C (0x9bdc06a725c71235), UINT64_C (0xc19bf174cf692694),
UINT64_C (0xe49b69c19ef14ad2), UINT64_C (0xefbe4786384f25e3),
UINT64_C (0x0fc19dc68b8cd5b5), UINT64_C (0x240ca1cc77ac9c65),
UINT64_C (0x2de92c6f592b0275), UINT64_C (0x4a7484aa6ea6e483),
UINT64_C (0x5cb0a9dcbd41fbd4), UINT64_C (0x76f988da831153b5),
UINT64_C (0x983e5152ee66dfab), UINT64_C (0xa831c66d2db43210),
UINT64_C (0xb00327c898fb213f), UINT64_C (0xbf597fc7beef0ee4),
UINT64_C (0xc6e00bf33da88fc2), UINT64_C (0xd5a79147930aa725),
UINT64_C (0x06ca6351e003826f), UINT64_C (0x142929670a0e6e70),
UINT64_C (0x27b70a8546d22ffc), UINT64_C (0x2e1b21385c26c926),
UINT64_C (0x4d2c6dfc5ac42aed), UINT64_C (0x53380d139d95b3df),
UINT64_C (0x650a73548baf63de), UINT64_C (0x766a0abb3c77b2a8),
UINT64_C (0x81c2c92e47edaee6), UINT64_C (0x92722c851482353b),
UINT64_C (0xa2bfe8a14cf10364), UINT64_C (0xa81a664bbc423001),
UINT64_C (0xc24b8b70d0f89791), UINT64_C (0xc76c51a30654be30),
UINT64_C (0xd192e819d6ef5218), UINT64_C (0xd69906245565a910),
UINT64_C (0xf40e35855771202a), UINT64_C (0x106aa07032bbd1b8),
UINT64_C (0x19a4c116b8d2d0c8), UINT64_C (0x1e376c085141ab53),
UINT64_C (0x2748774cdf8eeb99), UINT64_C (0x34b0bcb5e19b48a8),
UINT64_C (0x391c0cb3c5c95a63), UINT64_C (0x4ed8aa4ae3418acb),
UINT64_C (0x5b9cca4f7763e373), UINT64_C (0x682e6ff3d6b2b8a3),
UINT64_C (0x748f82ee5defb2fc), UINT64_C (0x78a5636f43172f60),
UINT64_C (0x84c87814a1f0ab72), UINT64_C (0x8cc702081a6439ec),
UINT64_C (0x90befffa23631e28), UINT64_C (0xa4506cebde82bde9),
UINT64_C (0xbef9a3f7b2c67915), UINT64_C (0xc67178f2e372532b),
UINT64_C (0xca273eceea26619c), UINT64_C (0xd186b8c721c0c207),
UINT64_C (0xeada7dd6cde0eb1e), UINT64_C (0xf57d4f7fee6ed178),
UINT64_C (0x06f067aa72176fba), UINT64_C (0x0a637dc5a2c898a6),
UINT64_C (0x113f9804bef90dae), UINT64_C (0x1b710b35131c471b),
UINT64_C (0x28db77f523047d84), UINT64_C (0x32caab7b40c72493),
UINT64_C (0x3c9ebe0a15c9bebc), UINT64_C (0x431d67c49c100d4c),
UINT64_C (0x4cc5d4becb3e42b6), UINT64_C (0x597f299cfc657e2a),
UINT64_C (0x5fcb6fab3ad6faec), UINT64_C (0x6c44198c4a475817)
};
/* Process LEN bytes of BUFFER, accumulating context into CTX.
It is assumed that LEN % 128 == 0. */
static void
sha512_process_block (const void *buffer, size_t len, struct sha512_ctx *ctx)
{
const uint64_t *words = (uint64_t *)buffer;
size_t nwords = len / sizeof (uint64_t);
uint64_t a = ctx->H[0];
uint64_t b = ctx->H[1];
uint64_t c = ctx->H[2];
uint64_t d = ctx->H[3];
uint64_t e = ctx->H[4];
uint64_t f = ctx->H[5];
uint64_t g = ctx->H[6];
uint64_t h = ctx->H[7];
/* First increment the byte count. FIPS 180-2 specifies the possible
length of the file up to 2^128 bits. Here we only compute the
number of bytes. Do a double word increment. */
ctx->total[0] += len;
if (ctx->total[0] < len)
++ctx->total[1];
/* Process all bytes in the buffer with 128 bytes in each round of
the loop. */
while (nwords > 0)
{
uint64_t W[80];
uint64_t a_save = a;
uint64_t b_save = b;
uint64_t c_save = c;
uint64_t d_save = d;
uint64_t e_save = e;
uint64_t f_save = f;
uint64_t g_save = g;
uint64_t h_save = h;
/* Operators defined in FIPS 180-2:4.1.2. */
#define Ch(x, y, z) ((x & y) ^ (~x & z))
#define Maj(x, y, z) ((x & y) ^ (x & z) ^ (y & z))
#define S0(x) (CYCLIC (x, 28) ^ CYCLIC (x, 34) ^ CYCLIC (x, 39))
#define S1(x) (CYCLIC (x, 14) ^ CYCLIC (x, 18) ^ CYCLIC (x, 41))
#define R0(x) (CYCLIC (x, 1) ^ CYCLIC (x, 8) ^ (x >> 7))
#define R1(x) (CYCLIC (x, 19) ^ CYCLIC (x, 61) ^ (x >> 6))
/* It is unfortunate that C does not provide an operator for
cyclic rotation. Hope the C compiler is smart enough. */
#define CYCLIC(w, s) ((w >> s) | (w << (64 - s)))
/* Compute the message schedule according to FIPS 180-2:6.3.2 step 2. */
for (unsigned int t = 0; t < 16; ++t)
{
W[t] = SWAP (*words);
++words;
}
for (unsigned int t = 16; t < 80; ++t)
W[t] = R1 (W[t - 2]) + W[t - 7] + R0 (W[t - 15]) + W[t - 16];
/* The actual computation according to FIPS 180-2:6.3.2 step 3. */
for (unsigned int t = 0; t < 80; ++t)
{
uint64_t T1 = h + S1 (e) + Ch (e, f, g) + K[t] + W[t];
uint64_t T2 = S0 (a) + Maj (a, b, c);
h = g;
g = f;
f = e;
e = d + T1;
d = c;
c = b;
b = a;
a = T1 + T2;
}
/* Add the starting values of the context according to FIPS 180-2:6.3.2
step 4. */
a += a_save;
b += b_save;
c += c_save;
d += d_save;
e += e_save;
f += f_save;
g += g_save;
h += h_save;
/* Prepare for the next round. */
nwords -= 16;
}
/* Put checksum in context given as argument. */
ctx->H[0] = a;
ctx->H[1] = b;
ctx->H[2] = c;
ctx->H[3] = d;
ctx->H[4] = e;
ctx->H[5] = f;
ctx->H[6] = g;
ctx->H[7] = h;
}
/* Initialize structure containing state of computation.
(FIPS 180-2:5.3.3) */
static void
sha512_init_ctx (struct sha512_ctx *ctx)
{
ctx->H[0] = UINT64_C (0x6a09e667f3bcc908);
ctx->H[1] = UINT64_C (0xbb67ae8584caa73b);
ctx->H[2] = UINT64_C (0x3c6ef372fe94f82b);
ctx->H[3] = UINT64_C (0xa54ff53a5f1d36f1);
ctx->H[4] = UINT64_C (0x510e527fade682d1);
ctx->H[5] = UINT64_C (0x9b05688c2b3e6c1f);
ctx->H[6] = UINT64_C (0x1f83d9abfb41bd6b);
ctx->H[7] = UINT64_C (0x5be0cd19137e2179);
ctx->total[0] = ctx->total[1] = 0;
ctx->buflen = 0;
}
/* Process the remaining bytes in the internal buffer and the usual
prolog according to the standard and write the result to RESBUF.
IMPORTANT: On some systems it is required that RESBUF is correctly
aligned for a 32 bits value. */
static void *
sha512_finish_ctx (struct sha512_ctx *ctx, void *resbuf)
{
/* Take yet unprocessed bytes into account. */
uint64_t bytes = ctx->buflen;
size_t pad;
/* Now count remaining bytes. */
ctx->total[0] += bytes;
if (ctx->total[0] < bytes)
++ctx->total[1];
pad = bytes >= 112 ? 128 + 112 - bytes : 112 - bytes;
memcpy (&ctx->buffer[bytes], fillbuf, pad);
/* Put the 128-bit file length in *bits* at the end of the buffer. */
*(uint64_t *) &ctx->buffer[bytes + pad + 8] = SWAP (ctx->total[0] << 3);
*(uint64_t *) &ctx->buffer[bytes + pad] = SWAP ((ctx->total[1] << 3) |
(ctx->total[0] >> 61));
/* Process last bytes. */
sha512_process_block (ctx->buffer, bytes + pad + 16, ctx);
/* Put result from CTX in first 64 bytes following RESBUF. */
for (unsigned int i = 0; i < 8; ++i)
((uint64_t *) resbuf)[i] = SWAP (ctx->H[i]);
return resbuf;
}
static void
sha512_process_bytes (const void *buffer, size_t len, struct sha512_ctx *ctx)
{
/* When we already have some bits in our internal buffer concatenate
both inputs first. */
if (ctx->buflen != 0)
{
size_t left_over = ctx->buflen;
size_t add = 256 - left_over > len ? len : 256 - left_over;
memcpy (&ctx->buffer[left_over], buffer, add);
ctx->buflen += add;
if (ctx->buflen > 128)
{
sha512_process_block (ctx->buffer, ctx->buflen & ~127, ctx);
ctx->buflen &= 127;
/* The regions in the following copy operation cannot overlap. */
memcpy (ctx->buffer, &ctx->buffer[(left_over + add) & ~127],
ctx->buflen);
}
buffer = (const char *) buffer + add;
len -= add;
}
/* Process available complete blocks. */
if (len >= 128)
{
#if !_STRING_ARCH_unaligned
/* To check alignment gcc has an appropriate operator. Other
compilers don't. */
# if __GNUC__ >= 2
# define UNALIGNED_P(p) (((uintptr_t) p) % __alignof__ (uint64_t) != 0)
# else
# define UNALIGNED_P(p) (((uintptr_t) p) % sizeof (uint64_t) != 0)
# endif
if (UNALIGNED_P (buffer))
while (len > 128)
{
sha512_process_block (memcpy (ctx->buffer, buffer, 128), 128,
ctx);
buffer = (const char *) buffer + 128;
len -= 128;
}
else
#endif
{
sha512_process_block (buffer, len & ~127, ctx);
buffer = (const char *) buffer + (len & ~127);
len &= 127;
}
}
/* Move remaining bytes into internal buffer. */
if (len > 0)
{
size_t left_over = ctx->buflen;
memcpy (&ctx->buffer[left_over], buffer, len);
left_over += len;
if (left_over >= 128)
{
sha512_process_block (ctx->buffer, 128, ctx);
left_over -= 128;
memcpy (ctx->buffer, &ctx->buffer[128], left_over);
}
ctx->buflen = left_over;
}
}
/* Define our magic string to mark salt for SHA512 "encryption"
replacement. */
static const char sha512_salt_prefix[] = "$6$";
/* Prefix for optional rounds specification. */
static const char sha512_rounds_prefix[] = "rounds=";
/* Maximum salt string length. */
#define SALT_LEN_MAX 16
/* Default number of rounds if not explicitly specified. */
#define ROUNDS_DEFAULT 5000
/* Minimum number of rounds. */
#define ROUNDS_MIN 1000
/* Maximum number of rounds. */
#define ROUNDS_MAX 999999999
/* Table with characters for base64 transformation. */
static const char b64t[65] = "./0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
static char *
sha512_crypt_r (const char *key, const char *salt, char *buffer, int buflen)
{
unsigned char alt_result[64]
__attribute__ ((__aligned__ (__alignof__ (uint64_t))));
unsigned char temp_result[64]
__attribute__ ((__aligned__ (__alignof__ (uint64_t))));
struct sha512_ctx ctx;
struct sha512_ctx alt_ctx;
size_t salt_len;
size_t key_len;
size_t cnt;
char *cp;
char *copied_key = NULL;
char *copied_salt = NULL;
char *p_bytes;
char *s_bytes;
/* Default number of rounds. */
size_t rounds = ROUNDS_DEFAULT;
bool rounds_custom = false;
/* Find beginning of salt string. The prefix should normally always
be present. Just in case it is not. */
if (strncmp (sha512_salt_prefix, salt, sizeof (sha512_salt_prefix) - 1) == 0)
/* Skip salt prefix. */
salt += sizeof (sha512_salt_prefix) - 1;
if (strncmp (salt, sha512_rounds_prefix, sizeof (sha512_rounds_prefix) - 1)
== 0)
{
const char *num = salt + sizeof (sha512_rounds_prefix) - 1;
char *endp;
unsigned long int srounds = strtoul (num, &endp, 10);
if (*endp == '$')
{
salt = endp + 1;
rounds = MAX (ROUNDS_MIN, MIN (srounds, ROUNDS_MAX));
rounds_custom = true;
}
}
salt_len = MIN (strcspn (salt, "$"), SALT_LEN_MAX);
key_len = strlen (key);
if ((key - (char *) 0) % __alignof__ (uint64_t) != 0)
{
char *tmp = (char *) alloca (key_len + __alignof__ (uint64_t));
key = copied_key = (char *)
memcpy (tmp + __alignof__ (uint64_t)
- (tmp - (char *) 0) % __alignof__ (uint64_t),
key, key_len);
}
if ((salt - (char *) 0) % __alignof__ (uint64_t) != 0)
{
char *tmp = (char *) alloca (salt_len + __alignof__ (uint64_t));
salt = copied_salt = (char *)
memcpy (tmp + __alignof__ (uint64_t)
- (tmp - (char *) 0) % __alignof__ (uint64_t),
salt, salt_len);
}
/* Prepare for the real work. */
sha512_init_ctx (&ctx);
/* Add the key string. */
sha512_process_bytes (key, key_len, &ctx);
/* The last part is the salt string. This must be at most 16
characters and it ends at the first `$' character (for
compatibility with existing implementations). */
sha512_process_bytes (salt, salt_len, &ctx);
/* Compute alternate SHA512 sum with input KEY, SALT, and KEY. The
final result will be added to the first context. */
sha512_init_ctx (&alt_ctx);
/* Add key. */
sha512_process_bytes (key, key_len, &alt_ctx);
/* Add salt. */
sha512_process_bytes (salt, salt_len, &alt_ctx);
/* Add key again. */
sha512_process_bytes (key, key_len, &alt_ctx);
/* Now get result of this (64 bytes) and add it to the other
context. */
sha512_finish_ctx (&alt_ctx, alt_result);
/* Add for any character in the key one byte of the alternate sum. */
for (cnt = key_len; cnt > 64; cnt -= 64)
sha512_process_bytes (alt_result, 64, &ctx);
sha512_process_bytes (alt_result, cnt, &ctx);
/* Take the binary representation of the length of the key and for every
1 add the alternate sum, for every 0 the key. */
for (cnt = key_len; cnt > 0; cnt >>= 1)
if ((cnt & 1) != 0)
sha512_process_bytes (alt_result, 64, &ctx);
else
sha512_process_bytes (key, key_len, &ctx);
/* Create intermediate result. */
sha512_finish_ctx (&ctx, alt_result);
/* Start computation of P byte sequence. */
sha512_init_ctx (&alt_ctx);
/* For every character in the password add the entire password. */
for (cnt = 0; cnt < key_len; ++cnt)
sha512_process_bytes (key, key_len, &alt_ctx);
/* Finish the digest. */
sha512_finish_ctx (&alt_ctx, temp_result);
/* Create byte sequence P. */
cp = p_bytes = (char *)alloca (key_len);
for (cnt = key_len; cnt >= 64; cnt -= 64)
cp = (char *)mempcpy (cp, temp_result, 64);
memcpy (cp, temp_result, cnt);
/* Start computation of S byte sequence. */
sha512_init_ctx (&alt_ctx);
/* For every character in the password add the entire password. */
for (cnt = 0; cnt < 16 + alt_result[0]; ++cnt)
sha512_process_bytes (salt, salt_len, &alt_ctx);
/* Finish the digest. */
sha512_finish_ctx (&alt_ctx, temp_result);
/* Create byte sequence S. */
cp = s_bytes = (char *)alloca (salt_len);
for (cnt = salt_len; cnt >= 64; cnt -= 64)
cp = (char *)mempcpy ( cp, temp_result, 64);
memcpy (cp, temp_result, cnt);
/* Repeatedly run the collected hash value through SHA512 to burn
CPU cycles. */
for (cnt = 0; cnt < rounds; ++cnt)
{
/* New context. */
sha512_init_ctx (&ctx);
/* Add key or last result. */
if ((cnt & 1) != 0)
sha512_process_bytes (p_bytes, key_len, &ctx);
else
sha512_process_bytes (alt_result, 64, &ctx);
/* Add salt for numbers not divisible by 3. */
if (cnt % 3 != 0)
sha512_process_bytes (s_bytes, salt_len, &ctx);
/* Add key for numbers not divisible by 7. */
if (cnt % 7 != 0)
sha512_process_bytes (p_bytes, key_len, &ctx);
/* Add key or last result. */
if ((cnt & 1) != 0)
sha512_process_bytes (alt_result, 64, &ctx);
else
sha512_process_bytes (p_bytes, key_len, &ctx);
/* Create intermediate result. */
sha512_finish_ctx (&ctx, alt_result);
}
/* Now we can construct the result string. It consists of three
parts. */
cp = __stpncpy (buffer, sha512_salt_prefix, MAX (0, buflen));
buflen -= sizeof (sha512_salt_prefix) - 1;
if (rounds_custom)
{
int n = snprintf (cp, MAX (0, buflen), "%s%zu$",
sha512_rounds_prefix, rounds);
cp += n;
buflen -= n;
}
cp = __stpncpy (cp, salt, MIN ((size_t) MAX (0, buflen), salt_len));
buflen -= MIN ((size_t) MAX (0, buflen), salt_len);
if (buflen > 0)
{
*cp++ = '$';
--buflen;
}
#define b64_from_24bit(B2, B1, B0, N) \
do { \
unsigned int w = ((B2) << 16) | ((B1) << 8) | (B0); \
int n = (N); \
while (n-- > 0 && buflen > 0) \
{ \
*cp++ = b64t[w & 0x3f]; \
--buflen; \
w >>= 6; \
} \
} while (0)
b64_from_24bit (alt_result[0], alt_result[21], alt_result[42], 4);
b64_from_24bit (alt_result[22], alt_result[43], alt_result[1], 4);
b64_from_24bit (alt_result[44], alt_result[2], alt_result[23], 4);
b64_from_24bit (alt_result[3], alt_result[24], alt_result[45], 4);
b64_from_24bit (alt_result[25], alt_result[46], alt_result[4], 4);
b64_from_24bit (alt_result[47], alt_result[5], alt_result[26], 4);
b64_from_24bit (alt_result[6], alt_result[27], alt_result[48], 4);
b64_from_24bit (alt_result[28], alt_result[49], alt_result[7], 4);
b64_from_24bit (alt_result[50], alt_result[8], alt_result[29], 4);
b64_from_24bit (alt_result[9], alt_result[30], alt_result[51], 4);
b64_from_24bit (alt_result[31], alt_result[52], alt_result[10], 4);
b64_from_24bit (alt_result[53], alt_result[11], alt_result[32], 4);
b64_from_24bit (alt_result[12], alt_result[33], alt_result[54], 4);
b64_from_24bit (alt_result[34], alt_result[55], alt_result[13], 4);
b64_from_24bit (alt_result[56], alt_result[14], alt_result[35], 4);
b64_from_24bit (alt_result[15], alt_result[36], alt_result[57], 4);
b64_from_24bit (alt_result[37], alt_result[58], alt_result[16], 4);
b64_from_24bit (alt_result[59], alt_result[17], alt_result[38], 4);
b64_from_24bit (alt_result[18], alt_result[39], alt_result[60], 4);
b64_from_24bit (alt_result[40], alt_result[61], alt_result[19], 4);
b64_from_24bit (alt_result[62], alt_result[20], alt_result[41], 4);
b64_from_24bit (0, 0, alt_result[63], 2);
if (buflen <= 0)
{
errno = ERANGE;
buffer = NULL;
}
else
*cp = '\0'; /* Terminate the string. */
/* Clear the buffer for the intermediate result so that people
attaching to processes or reading core dumps cannot get any
information. We do it in this way to clear correct_words[]
inside the SHA512 implementation as well. */
sha512_init_ctx (&ctx);
sha512_finish_ctx (&ctx, alt_result);
memset (temp_result, '\0', sizeof (temp_result));
memset (p_bytes, '\0', key_len);
memset (s_bytes, '\0', salt_len);
memset (&ctx, '\0', sizeof (ctx));
memset (&alt_ctx, '\0', sizeof (alt_ctx));
if (copied_key != NULL)
memset (copied_key, '\0', key_len);
if (copied_salt != NULL)
memset (copied_salt, '\0', salt_len);
return buffer;
}
/* This entry point is equivalent to the `crypt' function in Unix
libcs. */
char *
sha512_crypt (const char *key, const char *salt)
{
/* We don't want to have an arbitrary limit in the size of the
password. We can compute an upper bound for the size of the
result in advance and so we can prepare the buffer we pass to
`sha512_crypt_r'. */
static char *buffer = NULL;
static int buflen = 0;
int needed = (sizeof (sha512_salt_prefix) - 1
+ sizeof (sha512_rounds_prefix) + 9 + 1
+ strlen (salt) + 1 + 86 + 1);
if (buflen < needed)
{
char *new_buffer = (char *) realloc (buffer, needed);
if (new_buffer == NULL)
return NULL;
buffer = new_buffer;
buflen = needed;
}
return sha512_crypt_r (key, salt, buffer, buflen);
}

6
gdnative/src/sha512crypt.h
View file

@ -1,6 +0,0 @@
#ifndef SHA512CRYPT_H
#define SHA512CRYPT_H
char * sha512_crypt (const char *key, const char *salt);
#endif

38
gdnative/src/state.h
View file

@ -1,38 +0,0 @@
/*
Header STATE : to know state of client
Copyright (C) 2019 AleaJactaEst
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#ifndef STATE_H
#define STATE_H
enum STATE {
NotInitialised = 0,
//NotConnected = 1, // When received a cookie - not used here
//Authenticate = 2,
//Login = 3,
// Synchronize = 4,
Connected = 5, // State when we are connecte
//Probe = 6,
//Stalled = 7,
Disconnect = 8,
Quit = 9,
ForceSynchronize = 10
};
#endif // STATE_H

127
gdnative/src/store_message.cpp
View file

@ -1,127 +0,0 @@
/*
StoreMessage : class to manage packet received by khaganat
If we received message with bad order, with this class we can manage (with limit storage)
Copyright (C) 2019 AleaJactaEst
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#include <Godot.hpp>
#include <core/Defs.hpp>
#include "bitstream.h"
#include "tools.h"
#include "store_message.h"
using namespace godot;
StoreMessage::StoreMessage()
{
this->clear();
}
StoreMessage::~StoreMessage()
{
}
void StoreMessage::clear()
{
for(int i = 0 ; i < SIZE_QUEUE_MESSAGE ; ++i )
{
//this->_empty[i] = true;
this->_received_number[i] = 0;
this->_msgin[i].clear();
}
this->_size = 0;
}
int StoreMessage::length()
{
return this->_size;
}
int StoreMessage::put_msgbytes(PoolByteArray & msgbytes)
{
int i = 0;
int ii ;
//while((this->_empty[i] != true)&&(i < SIZE_QUEUE_MESSAGE))
while((i < SIZE_QUEUE_MESSAGE)&&(this->_msgin[i].size_data() != 0))
++i;
if(i >= SIZE_QUEUE_MESSAGE) // Out of memory
{
ERR_PRINT("Network queue is full (" + itos(i) + " / " + itos(SIZE_QUEUE_MESSAGE) + ")");
throw "Out of memory";
}
//INFO_PRINT("-> i:" + itos(i) + "/" + itos(this->_size) + " State:" + itos(this->_msgin[i].size_data()) + " num:" + itos(this->_received_number[i]));
//INFO_PRINT("i:" + itos(i) + " / " + itos(SIZE_QUEUE_MESSAGE) );
this->_msgin[i].put_data(msgbytes);
int32_t current_received_number = this->_msgin[i].get_sint32();
this->_received_number[i] = current_received_number;
// Check we don't have other message with same _received_number (also remove it)
ii = i + 1;
while(ii < SIZE_QUEUE_MESSAGE)
{
if ( this->_received_number[ii] == current_received_number)
this->erase(ii);
++ii;
}
this->_size ++;
/*
for(int ii = 0 ; ii < SIZE_QUEUE_MESSAGE ; ++ii)
{
INFO_PRINT(itos(ii) + ") i:" + itos(i) + "/" + itos(this->_size) + " State:" + itos(this->_msgin[ii].size_data()) + " num:" + itos(this->_received_number[ii]));
}
*/
return i;
}
BitStream * StoreMessage::get_msg(int pos)
{
if ( pos >= SIZE_QUEUE_MESSAGE )
{
ERR_PRINT("Try to get data out of memory");
throw "Out of memory";
}
return & this->_msgin[pos];
}
int32_t StoreMessage::get_received_number(int pos)
{
if ( pos >= SIZE_QUEUE_MESSAGE )
{
ERR_PRINT("Try to get data out of memory");
throw "Out of memory";
}
return this->_received_number[pos];
}
void StoreMessage::erase(int pos)
{
if ( pos >= SIZE_QUEUE_MESSAGE )
{
ERR_PRINT("Try to erase data out of memory");
return;
}
//this->_empty[pos] = true;
this->_received_number[pos] = 0;
this->_msgin[pos].clear();
this->_size -- ;
}

47
gdnative/src/store_message.h
View file

@ -1,47 +0,0 @@
/*
Header StoreMessage : message send by server
Copyright (C) 2019 AleaJactaEst
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#ifndef STORE_MESSAGE_H
#define STORE_MESSAGE_H
#define SIZE_QUEUE_MESSAGE 6
namespace godot {
class StoreMessage
{
// bool _empty[SIZE_QUEUE_MESSAGE];
int32_t _received_number[SIZE_QUEUE_MESSAGE];
BitStream _msgin[SIZE_QUEUE_MESSAGE];
int _size;
public:
StoreMessage();
~StoreMessage();
void clear();
int length();
int put_msgbytes(PoolByteArray & msgbytes);
BitStream * get_msg(int pos);
int32_t get_received_number(int pos);
void erase(int pos);
};
}
#endif // STORE_MESSAGE_H

29
gdnative/src/tools.cpp
View file

@ -1,29 +0,0 @@
/*
Copyright (C) 2019 AleaJactaEst
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#include <Godot.hpp>
#include <core/Defs.hpp>
#include "tools.h"
using namespace godot;
String godot::itos(int64_t p_val)
{
return String::num_int64(p_val);
}

44
gdnative/src/tools.h
View file

@ -1,44 +0,0 @@
/*
Header Tools
Copyright (C) 2019 AleaJactaEst
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#ifndef TOOLS_H
#define TOOLS_H
#include <Godot.hpp>
namespace godot {
String itos(int64_t p_val);
#define INFO_PRINT(msg) Godot::print( String(__FUNCTION__) + ":" + String(__FILE__) + ":" + itos( __LINE__) + " " + String(msg))
#ifdef DEBUG_ENABLED
#define DEBUG_PRINT(msg) Godot::print( String(__FUNCTION__) + ":" + String(__FILE__) + ":" + itos( __LINE__) + " " + String(msg))
#else
#define DEBUG_PRINT(msg)
#endif
}
#endif // STORE_MESSAGE_H

10
gdnative/test/bitset.gd
View file

@ -18,20 +18,20 @@ func test_resize():
print ("[bitset:test_resize]")
bitset.resize(1024)
func test_put():
func test_write():
#var bitset = preload("res://bitset.gdns").new()
var bitset = BitSet.new()
print ("[bitset:test_put]")
bitset.resize(1024)
#print ("[bitset:test_put] " + bitset.show())
assert( bitset.show() == "0000000000000000000000000000010000000000000000000000000000000000001000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000")
bitset.put(1, 1)
bitset.write(1, 1)
#print ("[bitset:test_put] " + bitset.show())
assert( bitset.show() == "0000000000000000000000000000010000000000000000000000000000000000001000000000000000000000000000000000001000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000")
bitset.put(2, 1)
bitset.write(2, 1)
#print ("[bitset:test_put] " + bitset.show())
assert( bitset.show() == "0000000000000000000000000000010000000000000000000000000000000000001000000000000000000000000000000000011000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000")
bitset.put(1, 0)
bitset.write(1, 0)
#print ("[bitset:test_put] " + bitset.show())
assert( bitset.show() == "0000000000000000000000000000010000000000000000000000000000000000001000000000000000000000000000000000001000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000")
@ -49,6 +49,6 @@ func test_alloc():
func test():
print("[bitset] Start check -> start")
test_resize()
test_put()
test_write()
test_alloc()
print("[bitset] Start check -> end")

1
godot-cpp

@ -1 +0,0 @@
Subproject commit 123d9f0e9264dcc7206888fc96419b32feef00c8

31
modules/README.md Normal file
View file

@ -0,0 +1,31 @@
# Module
To improve our class, we integrate specific module
(more easy to use and manipulate after)
## Build
### Clone repo godot
git clone https://github.com/godotengine/godot.git
cd godot
git checkout 3.1.2-stable
### Create link with our module
ln -s ../modules/crypt .
ln -s ../modules/bitstream .
ln -s ../modules/bitset .
### Build Project
scons -j$(nproc) -c
scons -j$(nproc) platform=x11
### Generate doc
./bin/godot.x11.tools.64 --doctool .
cp modules/khaganat/doc_classes/* doc/classes/.
### Re-build godot with doc
scons -j$(nproc) platform=x11
## Doc
https://docs.godotengine.org/en/3.1/development/cpp/custom_modules_in_cpp.html

13
modules/bitset/bitset.cpp
View file

@ -34,8 +34,8 @@ void BitSet::_bind_methods()
ClassDB::bind_method(D_METHOD("clear_data"), &BitSet::clear_data);
ClassDB::bind_method(D_METHOD("set_bit", "bit_number"), &BitSet::set_bit);
ClassDB::bind_method(D_METHOD("clear_bit", "bit_number"), &BitSet::clear_bit);
ClassDB::bind_method(D_METHOD("put", "bit_number", "value"), &BitSet::put);
ClassDB::bind_method(D_METHOD("get", "bit_number"), &BitSet::get);
ClassDB::bind_method(D_METHOD("write", "bit_number", "value"), &BitSet::write);
ClassDB::bind_method(D_METHOD("read", "bit_number"), &BitSet::read);
ClassDB::bind_method(D_METHOD("write_serial", "msgout"), &BitSet::write_serial);
ClassDB::bind_method(D_METHOD("read_serial", "msgin"), &BitSet::read_serial);
ClassDB::bind_method(D_METHOD("show"), &BitSet::show);
@ -53,7 +53,10 @@ BitSet::~BitSet()
{
// add your cleanup here
if ( this->_data != nullptr )
{
delete [] this->_data;
this->_data = nullptr;
}
}
int BitSet::size()
@ -122,7 +125,7 @@ void BitSet::clear_bit(uint32_t bit_number)
this->_data[bit_number>>5] &= mask;
}
void BitSet::put(uint32_t bit_number, bool value)
void BitSet::write(uint32_t bit_number, bool value)
{
if (bit_number >= this->_num_bits)
{
@ -135,11 +138,11 @@ void BitSet::put(uint32_t bit_number, bool value)
this->clear_bit(bit_number);
}
bool BitSet::get(uint32_t bit_number)
bool BitSet::read(uint32_t bit_number)
{
if (bit_number >= this->_num_bits)
{
ERR_PRINTS("[BitSet::get] Out of range (size:" + itos(this->_size_byte) + ", pos:" + itos(bit_number) + ")" );
ERR_PRINTS("[BitSet::pull] Out of range (size:" + itos(this->_size_byte) + ", pos:" + itos(bit_number) + ")" );
throw "Out of range";
}
uint32_t mask = bit_number & (BITSET_SIZE - 1);

4
modules/bitset/bitset.h
View file

@ -42,8 +42,8 @@ public:
void clear_data();
void set_bit(uint32_t bit_number);
void clear_bit(uint32_t bit_number);
void put(uint32_t bit_number, bool value);
bool get(uint32_t bit_number);
void write(uint32_t bit_number, bool value);
bool read(uint32_t bit_number);
void write_serial(Ref<BitStream> msgout);
void read_serial(Ref<BitStream> msgin);
String show();

12
modules/bitset/doc_classes/BitSet.xml
View file

@ -1,5 +1,5 @@
<?xml version="1.0" encoding="UTF-8" ?>
<class name="BitSet" inherits="Reference" category="Core" version="3.1.2">
<class name="BitSet" inherits="Reference" version="3.2">
<brief_description>
</brief_description>
<description>
@ -27,7 +27,15 @@
<description>
</description>
</method>
<method name="put">
<method name="pull">
<return type="bool">
</return>
<argument index="0" name="bit_number" type="int">
</argument>
<description>
</description>
</method>
<method name="push">
<return type="void">
</return>
<argument index="0" name="bit_number" type="int">

2
modules/bitstream/doc_classes/BitStream.xml
View file

@ -1,5 +1,5 @@
<?xml version="1.0" encoding="UTF-8" ?>
<class name="BitStream" inherits="Reference" category="Core" version="3.1.2">
<class name="BitStream" inherits="Reference" version="3.2">
<brief_description>
</brief_description>
<description>

19
modules/bitstreamqueue/bitstreamqueue.cpp
View file

@ -38,24 +38,28 @@ BitStreamQueue::BitStreamQueue()
OS::get_singleton()->print("[%s:%d] new BitStreamQueue\n", __FILE__, __LINE__);
for(int i = 0 ; i < SIZE_QUEUE_MESSAGE ; ++i )
this->_msgin[i].instance();
//this->_msgin.resize(SIZE_QUEUE_MESSAGE);
this->clear();
}
BitStreamQueue::~BitStreamQueue()
{
OS::get_singleton()->print("[%s:%d] delete BitStreamQueue\n", __FILE__, __LINE__);
for(int i = 0 ; i < SIZE_QUEUE_MESSAGE ; ++i )
this->_msgin[i].unref();
this->clear();
//for(int i = 0 ; i < SIZE_QUEUE_MESSAGE ; ++i ) this->_msgin[i].unref();
for(int i = 0 ; i < SIZE_QUEUE_MESSAGE ; ++i )
{
if (this->_msgin[i].unref())
/*
OS::get_singleton()->print("[%s:%d] delete BitStreamQueue %d ?\n", __FILE__, __LINE__, i);
this->_msgin[i].unref();
if (this->_msgin[i] != nullptr)
{
OS::get_singleton()->print("[%s:%d] delete BitStreamQueue %d\n", __FILE__, __LINE__, i);
memdelete(this->_msgin[i]);
this->_msgin[i] = nullptr;
//memdelete(this->_msgin[i]);
//this->_msgin[i] = nullptr;
}
*/
}
}
@ -64,6 +68,7 @@ void BitStreamQueue::clear()
for(int i = 0 ; i < SIZE_QUEUE_MESSAGE ; ++i )
{
this->_received_number[i] = 0;
//this->_msgin[i].nref();
this->_msgin[i]->clear();
}
this->_size = 0;

2
modules/bitstreamqueue/bitstreamqueue.h
View file

@ -34,7 +34,7 @@ private:
int _size;
uint32_t _received_number[SIZE_QUEUE_MESSAGE];
Ref<BitStream> _msgin[SIZE_QUEUE_MESSAGE];
//Vector<BitStream> _msgin[SIZE_QUEUE_MESSAGE];
//Vector<BitStream> _msgin;
public:
BitStreamQueue();
~BitStreamQueue();

2
modules/bitstreamqueue/doc_classes/BitStreamQueue.xml
View file

@ -1,5 +1,5 @@
<?xml version="1.0" encoding="UTF-8" ?>
<class name="BitStreamQueue" inherits="Reference" category="Core" version="3.1.2">
<class name="BitStreamQueue" inherits="Reference" version="3.2">
<brief_description>
</brief_description>
<description>

2
modules/crypt/doc_classes/Crypt.xml
View file

@ -1,5 +1,5 @@
<?xml version="1.0" encoding="UTF-8" ?>
<class name="Crypt" inherits="Reference" category="Core" version="3.1.2">
<class name="Crypt" inherits="Reference" version="3.2">
<brief_description>
</brief_description>
<description>

2
modules/networkconnection/doc_classes/NetworkConnection.xml
View file

@ -1,5 +1,5 @@
<?xml version="1.0" encoding="UTF-8" ?>
<class name="NetworkConnection" inherits="Reference" category="Core" version="3.1.2">
<class name="NetworkConnection" inherits="Reference" version="3.2">
<brief_description>
</brief_description>
<description>

2
modules/networkconnection/doc_classes/NetworkConnectionCore.xml
View file

@ -1,5 +1,5 @@
<?xml version="1.0" encoding="UTF-8" ?>
<class name="NetworkConnectionCore" inherits="Reference" category="Core" version="3.1.2">
<class name="NetworkConnectionCore" inherits="Reference" version="3.2">
<brief_description>
</brief_description>
<description>

6
modules/networkconnection/network_connection.cpp
View file

@ -33,6 +33,7 @@ void NetworkConnection::_bind_methods()
ClassDB::bind_method(D_METHOD("disconnect_server"), &NetworkConnection::disconnect_server);
ClassDB::bind_method(D_METHOD("process", "delta"), &NetworkConnection::process);
ClassDB::bind_method(D_METHOD("get_state"), &NetworkConnection::get_state);
ClassDB::bind_method(D_METHOD("terminate_network_connection"), &NetworkConnection::terminate_network_connection);
//ClassDB::bind_method(D_METHOD("get_master_message_description_node"), &NetworkConnection::get_master_message_description_node);
}
@ -99,7 +100,8 @@ MessageDescriptionNode & NetworkConnection::get_master_message_description_node(
return NetworkConnectionCore::get_singleton()->get_master_message_description_node();
}
*/
void terminate_network_connection()
void NetworkConnection::terminate_network_connection()
{
NetworkConnectionCore::get_singleton()->terminate_connexion();
if ( NetworkConnectionCore::is_active() )
NetworkConnectionCore::get_singleton()->terminate_connexion();
}

3
modules/networkconnection/network_connection.h
View file

@ -46,10 +46,9 @@ public:
void disconnect_server();
void process(int delta);
int get_state();
void terminate_network_connection();
//MessageDescriptionNode & get_master_message_description_node();
};
void terminate_network_connection();
#endif // NETWORK_CONNECTION_H

46
modules/networkconnection/network_connection_core.cpp
View file

@ -29,6 +29,15 @@ NetworkConnectionCore *NetworkConnectionCore::get_singleton()
return NetworkConnectionCore::singleton;
}
void NetworkConnectionCore::make_default()
{
OS::get_singleton()->print("NetworkConnectionCore::make_default\n");
}
void NetworkConnectionCore::cleanup()
{
OS::get_singleton()->print("NetworkConnectionCore::cleanup\n");
}
NetworkConnectionCore::NetworkConnectionCore()
{
this->_socketUDP = nullptr;
@ -37,6 +46,17 @@ NetworkConnectionCore::NetworkConnectionCore()
NetworkConnectionCore::~NetworkConnectionCore()
{
OS::get_singleton()->print("[%s:%d] NetworkConnectionCore::destructor\n", __FILE__, __LINE__);
if ( NetworkConnectionCore::singleton->_socketUDP != nullptr)
{
OS::get_singleton()->print("[%s:%d] NetworkConnectionCore::destructor\n", __FILE__, __LINE__);
delete NetworkConnectionCore::singleton->_socketUDP;
if ( NetworkConnectionCore::singleton->_socketUDP != nullptr )
OS::get_singleton()->print("[%s:%d] NetworkConnectionCore::destructor ?\n", __FILE__, __LINE__);
//NetworkConnectionCore::singleton->_socketUDP = nullptr;
}
NetworkConnectionCore::singleton = nullptr;
this->_state = STATE::NotInitialised;
}
@ -460,7 +480,7 @@ void NetworkConnectionCore::analyze_message_received(uint32_t current_received_n
this->_long_ack_bit_field.clear_bit(i & (NUM_BITS_IN_LONG_ACK -1) );
OS::get_singleton()->print("long_ack_bit_field.put : %u\n", current_received_number & (NUM_BITS_IN_LONG_ACK-1));
this->_long_ack_bit_field.put(current_received_number & (NUM_BITS_IN_LONG_ACK-1), ackBool);
this->_long_ack_bit_field.write(current_received_number & (NUM_BITS_IN_LONG_ACK-1), ackBool);
// TODO - what's action when we have rotate onthis number (max -> 0)
if( this->_last_received_number > 0x08000000 )
@ -542,18 +562,26 @@ void NetworkConnectionCore::process(int delta)
send_message();
}
bool NetworkConnectionCore::is_active()
{
OS::get_singleton()->print("[%s:%d] is_active ..\n", __FILE__, __LINE__);
if ( NetworkConnectionCore::singleton == nullptr )
return false;
return true;
}
void NetworkConnectionCore::terminate_connexion()
{
if ( this->_socketUDP == nullptr )
OS::get_singleton()->print("[%s:%d] Terminate network connexion .\n", __FILE__, __LINE__);
if ( NetworkConnectionCore::singleton == nullptr )
return;
OS::get_singleton()->print("[%s:%d] Terminate network connexion\n", __FILE__, __LINE__);
delete this->_socketUDP;
this->_socketUDP = nullptr;
OS::get_singleton()->print("[%s:%d] Terminate network connexion ..\n", __FILE__, __LINE__);
OS::get_singleton()->print("[%s:%d] Terminate network connexion ...\n", __FILE__, __LINE__);
delete NetworkConnectionCore::singleton;
if ( NetworkConnectionCore::singleton != nullptr )
{
delete NetworkConnectionCore::singleton;
NetworkConnectionCore::singleton = nullptr;
}
OS::get_singleton()->print("[%s:%d] Terminate network connexion ?\n", __FILE__, __LINE__);
OS::get_singleton()->print("[%s:%d] Terminate network connexion ....\n", __FILE__, __LINE__);
}
/*

4
modules/networkconnection/network_connection_core.h
View file

@ -98,6 +98,9 @@ public:
NetworkConnectionCore();
~NetworkConnectionCore();
static void make_default();
static void cleanup();
int get_state();
void autodefine_socket_udp();
@ -127,6 +130,7 @@ public:
void send_message();
void process(int delta);
bool connected();
static bool is_active();
void terminate_connexion();
//MessageDescriptionNode & get_master_message_description_node();
};

7
networkconnexion.gdns
View file

@ -1,7 +0,0 @@
[gd_resource type="NativeScript" load_steps=2 format=2]
[ext_resource path="res://gdnative.gdnlib" type="GDNativeLibrary" id=1]
[resource]
class_name = "NetworkConnection"
library = ExtResource( 1 )