Packet* UdpServer::DataToPacket(size_t bytes_transferred)
{
size_t current_length = 0;
Packet* packet;
do{
char type[HEADER_LENGTH+1];
memcpy((void*)type, received_data+current_length, 4);
unsigned int type2 = decode(received_data+current_length+4, 4);
int length = decode(received_data+current_length+8, 4);
unsigned char* data = new unsigned char[length-12];
memcpy(data, received_data+current_length+12, length-12);
//Create the package and add it to the end of the queue
packet = new Packet(type, type2, length, (char*)data);
string packetData = packet->toString();
debug->notification(3, this->type, "<<[%s] %s 0x%08x {%s}", getRemoteIp().c_str(), packet->GetType(), packet->GetType2(), packetData.c_str());
current_length += length;
delete[] data;
if(current_length != bytes_transferred)
debug->warning(2, this->type, "UDP - We received a group of packets! Keep the log to investigate the packet, need to change implementation for this");
}while(current_length != bytes_transferred);
return packet;
}
ConnectionData* UserConnection::getPluginObject() noexcept {
resetEntity();
pod.ip = pluginString(getRemoteIp());
pod.object = this;
pod.port = Util::toInt(port);
pod.protocol = isSet(UserConnection::FLAG_NMDC) ? PROTOCOL_NMDC : PROTOCOL_ADC; // TODO: isSet(...) not practical if more than two protocols
pod.isOp = isSet(UserConnection::FLAG_OP) ? True : False;
pod.isSecure = isSecure() ? True : False;
return &pod;
}
string UdpServer::PacketToData(Packet* packet)
{
string buffer = packet->GetType();
buffer.append(7, '\0'); // upd packets have zero filled header
int len = 12 + packet->GetData().size() + 1; //header + data + final null char
buffer.append(1, (char)len);
buffer.append(packet->GetData());
buffer.push_back('\0');
string packetData = packet->toString();
debug->notification(3, type, ">>[%s] %s 0x%08x {%s}", getRemoteIp().c_str(), packet->GetType(), packet->GetType2(), packetData.c_str());
delete packet;
return buffer;
}
void AtDrv::getRemoteData(uint8_t sock, uint8_t *ip, uint16_t *port)
{
if(!isAtMode()) {
if(!switchToAtMode()) {
INFO1("Can't switch to at mode");
memset(ip, 0, 4);
*port = 0;
goto end;
}
}
getRemoteIp(sock, ip);
getRemotePort(sock, port);
end:
return;
}
void UdpServer::ProcessData(Packet* packet)
{
Packet* sendPacket = NULL;
if(packet != NULL)
{
//debug->notification(2, type, "local port: %i, remote port: %i", getLocalPort(), getRemotePort());
string port = lexical_cast<string>(getRemotePort());
sendPacket = new Packet("ECHO", 0x00000000);
sendPacket->SetVar("TXN", "ECHO");
sendPacket->SetVar("IP", getRemoteIp());
sendPacket->SetVar("PORT", port);
sendPacket->SetVar("ERR", "0");
sendPacket->SetVar("TYPE", "1");
sendPacket->SetVar("TID", packet->GetVar("TID"));
delete packet;
}
else
debug->warning(2, type, "UDP - Packet is NULL");
send_data = PacketToData(sendPacket);
}
void UserConnection::on(BufferedSocketListener::Line, const string& aLine) throw () {
COMMAND_DEBUG(aLine, DebugManager::TYPE_CLIENT, DebugManager::INCOMING, getRemoteIp());
if(aLine.length() < 2) {
fire(UserConnectionListener::ProtocolError(), this, "Invalid data"); // TODO: translate
return;
}
if(aLine[0] == 'C' && !isSet(FLAG_NMDC)) {
if(!Text::validateUtf8(aLine)) {
fire(UserConnectionListener::ProtocolError(), this, "Non-UTF-8 data in an ADC connection"); // TODO: translate
return;
}
dispatch(aLine);
return;
} else if(aLine[0] == '$') {
setFlag(FLAG_NMDC);
} else {
// We shouldn't be here?
fire(UserConnectionListener::ProtocolError(), this, "Invalid data"); // TODO: translate
return;
}
string cmd;
string param;
string::size_type x;
if( (x = aLine.find(' ')) == string::npos) {
cmd = aLine.substr(1);
} else {
cmd = aLine.substr(1, x - 1);
param = aLine.substr(x+1);
}
if(cmd == "MyNick") {
if(!param.empty())
fire(UserConnectionListener::MyNick(), this, param);
} else if(cmd == "Direction") {
x = param.find(" ");
if(x != string::npos) {
fire(UserConnectionListener::Direction(), this, param.substr(0, x), param.substr(x+1));
}
} else if(cmd == "Error") {
if(Util::stricmp(param.c_str(), FILE_NOT_AVAILABLE) == 0 ||
param.rfind(/*path/file*/" no more exists") != string::npos) {
fire(UserConnectionListener::FileNotAvailable(), this);
} else {
fire(UserConnectionListener::ProtocolError(), this, param);
}
} else if(cmd == "GetListLen") {
fire(UserConnectionListener::GetListLength(), this);
} else if(cmd == "Get") {
x = param.find('$');
if(x != string::npos) {
fire(UserConnectionListener::Get(), this, Text::toUtf8(param.substr(0, x), encoding), Util::toInt64(param.substr(x+1)) - (int64_t)1);
}
} else if(cmd == "Key") {
if(!param.empty())
fire(UserConnectionListener::Key(), this, param);
} else if(cmd == "Lock") {
if(!param.empty()) {
x = param.find(" Pk=");
if(x != string::npos) {
fire(UserConnectionListener::CLock(), this, param.substr(0, x));
} else {
// Workaround for faulty linux clients...
x = param.find(' ');
if(x != string::npos) {
fire(UserConnectionListener::CLock(), this, param.substr(0, x));
} else {
fire(UserConnectionListener::CLock(), this, param);
}
}
}
} else if(cmd == "Send") {
fire(UserConnectionListener::Send(), this);
} else if(cmd == "MaxedOut") {
fire(UserConnectionListener::MaxedOut(), this, param);
} else if(cmd == "Supports") {
if(!param.empty()) {
fire(UserConnectionListener::Supports(), this, StringTokenizer<string>(param, ' ').getTokens());
}
} else if(cmd.compare(0, 3, "ADC") == 0) {
dispatch(aLine, true);
} else if (cmd == "ListLen") {
if(!param.empty()) {
fire(UserConnectionListener::ListLength(), this, param);
}
} else {
fire(UserConnectionListener::ProtocolError(), this, "Invalid data"); // TODO: translate
}
}
void UserConnection::send(const string& aString) {
lastActivity = GET_TICK();
COMMAND_DEBUG(aString, DebugManager::TYPE_CLIENT, DebugManager::OUTGOING, getRemoteIp());
socket->write(aString);
}
Server::Client::Client(Socket &socket)
: Socket(socket.get(), socket.getRemoteIp()), _verified(false)
{
std::cout << "Nouveau client n°" << get() << " connecté depuis " << getRemoteIp() << std::endl;
}
void UserConnection::on(BufferedSocketListener::Line, const string& aLine) throw () {
if(aLine.length() < 2) {
fire(UserConnectionListener::ProtocolError(), this, _("Invalid data"));
return;
}
if(aLine[0] == 'C' && !isSet(FLAG_NMDC)) {
if(!Text::validateUtf8(aLine)) {
fire(UserConnectionListener::ProtocolError(), this, _("Non-UTF-8 data in an ADC connection"));
return;
}
dispatch(aLine);
return;
} else if(aLine[0] == '$') {
setFlag(FLAG_NMDC);
} else {
fire(UserConnectionListener::ProtocolError(), this, _("Invalid data"));
return;
}
COMMAND_DEBUG(aLine, DebugManager::CLIENT_IN, getRemoteIp());
string cmd;
string param;
string::size_type x;
#ifdef LUA_SCRIPT
if(onUserConnectionMessageIn(this, aLine)) {
disconnect(true);
return;
}
#endif
if( (x = aLine.find(' ')) == string::npos) {
cmd = aLine;
} else {
cmd = aLine.substr(0, x);
param = aLine.substr(x+1);
}
if(cmd == "$MyNick") {
if(!param.empty())
fire(UserConnectionListener::MyNick(), this, param);
} else if(cmd == "$Direction") {
x = param.find(" ");
if(x != string::npos) {
fire(UserConnectionListener::Direction(), this, param.substr(0, x), param.substr(x+1));
}
} else if(cmd == "$Error") {
if(Util::stricmp(param.c_str(), FILE_NOT_AVAILABLE) == 0 ||
param.rfind(/*path/file*/" no more exists") != string::npos) {
fire(UserConnectionListener::FileNotAvailable(), this);
} else {
fire(UserConnectionListener::ProtocolError(), this, param);
}
} else if(cmd == "$GetListLen") {
fire(UserConnectionListener::GetListLength(), this);
} else if(cmd == "$Get") {
x = param.find('$');
if(x != string::npos) {
fire(UserConnectionListener::Get(), this, Text::toUtf8(param.substr(0, x), encoding), Util::toInt64(param.substr(x+1)) - (int64_t)1);
}
} else if(cmd == "$Key") {
if(!param.empty())
fire(UserConnectionListener::Key(), this, param);
} else if(cmd == "$Lock") {
if(!param.empty()) {
x = param.find(" Pk=");
if(x != string::npos) {
fire(UserConnectionListener::CLock(), this, param.substr(0, x), param.substr(x + 4));
} else {
// Workaround for faulty linux clients...
x = param.find(' ');
if(x != string::npos) {
setFlag(FLAG_INVALIDKEY);
fire(UserConnectionListener::CLock(), this, param.substr(0, x), Util::emptyString);
} else {
fire(UserConnectionListener::CLock(), this, param, Util::emptyString);
}
}
}
} else if(cmd == "$Send") {
fire(UserConnectionListener::Send(), this);
} else if(cmd == "$MaxedOut") {
fire(UserConnectionListener::MaxedOut(), this);
} else if(cmd == "$Supports") {
if(!param.empty()) {
fire(UserConnectionListener::Supports(), this, StringTokenizer<string>(param, ' ').getTokens());
}
} else if(cmd.compare(0, 4, "$ADC") == 0) {
dispatch(aLine, true);
} else {
fire(UserConnectionListener::ProtocolError(), this, _("Invalid data"));
}
}
void UserConnection::send(const string &aString) {
lastActivity = GET_TICK();
COMMAND_DEBUG((Util::stricmp(getEncoding(), Text::utf8) != 0 ? Text::toUtf8(aString, getEncoding()) : aString), DebugManager::CLIENT_OUT, getRemoteIp());
#ifdef LUA_SCRIPT
if(onUserConnectionMessageOut(this, aString)) {
disconnect(true);
return;
}
#endif
socket->write(aString);
}
void AtDrv::startClient(uint8_t sock, uint32_t ipAddress, uint16_t port, uint8_t protMode)
{
// if we enable CHECK_TCP_STATE feature, always call reConnect(), or we won't get right
// tcp port status, since we disable tcp auto reconnect.
#ifndef CHECK_TCP_STATE
bool needReConn = false;
#else
bool needReConn = true;
#endif
int curMode;
uint32_t curIp;
uint8_t curProtocol;
uint16_t curPort;
uint16_t curLocalPort;
uint32_t curTimeout;
bool curTcpAuto;
// clear uart buffer first
stopClient(sock);
if(!isAtMode()) {
if(!switchToAtMode()) {
INFO1("Can't switch to at mode");
goto end;
}
}
if(!getMode(sock, &curMode) || curMode != MODE_CLIENT) {
needReConn = true;
INFO1("curMode != MODE_CLIENT");
if(!setMode(sock, MODE_CLIENT)) {
INFO1("Can't set mode");
goto end;
}
}
if(!getRemoteIp(sock, (uint8_t *)&curIp) || curIp != ipAddress) {
needReConn = true;
INFO1("curIp != ipAddress");
if(!setRemoteIp(sock, ipAddress)) {
INFO1("Can't set ip");
goto end;
}
}
if(!getProtocol(sock, &curProtocol) || curProtocol != protMode) {
needReConn = true;
INFO1("curProtocol != protMode");
if(!setProtocol(sock, protMode)) {
INFO1("Can't set protocol");
goto end;
}
}
if(!getRemotePort(sock, &curPort) || curPort != port) {
needReConn = true;
INFO1("curPort != port");
if(!setPort(sock, port)) {
INFO1("Can't set port");
goto end;
}
}
if(!getTcpAuto(sock, &curTcpAuto) || curTcpAuto != false) {
needReConn = true;
INFO1("curTcpAuto != false");
if(!setTcpAuto(sock, false)) {
INFO1("Can't set tcp auto");
goto end;
}
}
if(!getLocalPort(sock, &curLocalPort) || curLocalPort != localSockPort[sock]) {
needReConn = true;
INFO1("curLocalPort != port");
if(!setLocalPort(sock, localSockPort[sock])) {
INFO1("Can't set port");
goto end;
}
}
if(needReConn) {
if(!reConnect()) {
INFO1("Can't reconnect");
goto end;
}
}
sockPort[sock] = localSockPort[sock];
sockConnected[sock] = true;
end:
return;
}
void UserConnection::on(BufferedSocketListener::Line, const string& aLine) throw () {
if(aLine.length() < 2)
return;
if(aLine[0] == 'C' && !isSet(FLAG_NMDC)) {
dispatch(aLine);
return;
} else if(aLine[0] == '$') {
setFlag(FLAG_NMDC);
} else {
// We shouldn't be here?
dcdebug("Unknown UserConnection command: %.50s\n", aLine.c_str());
return;
}
string cmd;
string param;
string::size_type x;
if( (x = aLine.find(' ')) == string::npos) {
cmd = aLine;
} else {
cmd = aLine.substr(0, x);
param = aLine.substr(x+1);
}
if(cmd == "$MyNick") {
if(!param.empty())
fire(UserConnectionListener::MyNick(), this, Text::acpToUtf8(param));
} else if(cmd == "$Direction") {
x = param.find(" ");
if(x != string::npos) {
fire(UserConnectionListener::Direction(), this, param.substr(0, x), param.substr(x+1));
}
} else if(cmd == "$Error") {
if(Util::stricmp(param.c_str(), FILE_NOT_AVAILABLE) == 0 ||
param.rfind(/*path/file*/" no more exists") != string::npos) {
fire(UserConnectionListener::FileNotAvailable(), this);
} else {
fire(UserConnectionListener::Failed(), this, param);
}
} else if(cmd == "$FileLength") {
if(!param.empty())
fire(UserConnectionListener::FileLength(), this, Util::toInt64(param));
} else if(cmd == "$GetListLen") {
fire(UserConnectionListener::GetListLength(), this);
} else if(cmd == "$Get") {
notSupported();
disconnect();
StringMap params;
params["user"] = getUser()->getNick();
params["hub"] = getUser()->getClientUrl();
params["ip"] = getRemoteIp();
string tmp = Util::formatParams(STRING(OLD_CLIENT), params, false);
LogManager::getInstance()->message(tmp);
} else if(cmd == "$GetZBlock" || cmd == "$UGetZBlock" || cmd == "$UGetBlock") {
notSupported();
disconnect();
StringMap params;
params["user"] = getUser()->getNick();
params["hub"] = getUser()->getClientUrl();
params["ip"] = getRemoteIp();
string tmp = Util::formatParams(STRING(OLD_CLIENT), params, false);
LogManager::getInstance()->message(tmp);
} else if(cmd == "$Key") {
if(!param.empty())
fire(UserConnectionListener::Key(), this, param);
} else if(cmd == "$Lock") {
if(!param.empty()) {
x = param.find(" Pk=");
if(x != string::npos) {
fire(UserConnectionListener::CLock(), this, param.substr(0, x), param.substr(x + 4));
} else {
// Workaround for faulty linux clients...
x = param.find(' ');
if(x != string::npos) {
setFlag(FLAG_INVALIDKEY);
fire(UserConnectionListener::CLock(), this, param.substr(0, x), Util::emptyString);
} else {
fire(UserConnectionListener::CLock(), this, param, Util::emptyString);
}
}
}
} else if(cmd == "$Send") {
fire(UserConnectionListener::Send(), this);
} else if(cmd == "$Sending") {
int64_t bytes = -1;
if(!param.empty())
bytes = Util::toInt64(param);
fire(UserConnectionListener::Sending(), this, bytes);
} else if(cmd == "$MaxedOut") {
fire(UserConnectionListener::MaxedOut(), this);
} else if(cmd == "$Supports") {
if(!param.empty()) {
fire(UserConnectionListener::Supports(), this, StringTokenizer<string>(param, ' ').getTokens());
}
} else if(cmd.compare(0, 4, "$ADC") == 0) {
dispatch(aLine, true);
} else {
dcdebug("Unknown NMDC command: %.50s\n", aLine.c_str());
}
}
