KB8PMY
/
QnetGateway
mirror of https://github.com/n7tae/QnetGateway.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

no wxWidgits!

Browse Source
pull/1/head
Tom Early 10 years ago
parent 6078a5b124
commit 89756075e7
24 changed files with 1353 additions and 2002 deletions
Show Stats Download Patch File Download Diff File

42
IRCApplication.h
Unescape View File

@ -1,47 +1,24 @@
/* #pragma once
CIRCDDB - ircDDB client library in C++
Copyright (C) 2010 Michael Dirska, DL1BFF (dl1bff@mdx.de)
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 2 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/>.
*/
#if !defined(_IRCAPPLICATION_H)
#define _IRCAPPLICATION_H
#include <wx/wx.h>
#include <string>
#include "IRCMessageQueue.h" #include "IRCMessageQueue.h"
class IRCApplication class IRCApplication
{ {
public: public:
virtual void userJoin (const wxString& nick, const wxString& name, const wxString& host) = 0; virtual void userJoin(const std::string& nick, const std::string& name, const std::string& host) = 0;
virtual void userLeave (const wxString& nick) = 0; virtual void userLeave(const std::string& nick) = 0;
virtual void userChanOp (const wxString& nick, bool op) = 0; virtual void userChanOp(const std::string& nick, bool op) = 0;
virtual void userListReset(void) = 0; virtual void userListReset(void) = 0;
virtual void msgChannel(IRCMessage * m) = 0; virtual void msgChannel(IRCMessage * m) = 0;
virtual void msgQuery(IRCMessage * m) = 0; virtual void msgQuery(IRCMessage * m) = 0;
virtual void setCurrentNick(const wxString& nick) = 0; virtual void setCurrentNick(const std::string& nick) = 0;
virtual void setTopic(const wxString& topic) = 0; virtual void setTopic(const std::string& topic) = 0;
virtual void setBestServer(const wxString& ircUser) = 0; virtual void setBestServer(const std::string& ircUser) = 0;
virtual void setSendQ(IRCMessageQueue *s) = 0; virtual void setSendQ(IRCMessageQueue *s) = 0;
virtual IRCMessageQueue *getSendQ(void) = 0; virtual IRCMessageQueue *getSendQ(void) = 0;
@ -49,6 +26,3 @@ public:
virtual ~IRCApplication() {} virtual ~IRCApplication() {}
}; };
#endif

214
IRCClient.cpp
Unescape View File

@ -1,74 +1,32 @@
/*
CIRCDDB - ircDDB client library in C++
Copyright (C) 2010-2011 Michael Dirska, DL1BFF (dl1bff@mdx.de)
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 2 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/>.
*/
#if defined(WIN32)
#define WIN32_LEAN_AND_MEAN
#include <winsock2.h>
#include <ws2tcpip.h>
#else
#include <sys/types.h> #include <sys/types.h>
#include <sys/socket.h> #include <sys/socket.h>
#include <netdb.h> #include <netdb.h>
#include <unistd.h>
#endif #include <string.h>
#include "IRCClient.h" #include "IRCClient.h"
#include "IRCutils.h" #include "IRCutils.h"
#include <wx/wx.h>
#include <fcntl.h> #include <fcntl.h>
#include <errno.h> #include <errno.h>
IRCClient::IRCClient(IRCApplication *app, const std::string &update_channel, const std::string &hostName, unsigned int port, const std::string &callsign, const std::string &password,
const std::string &versionInfo, const std::string &localAddr)
IRCClient::IRCClient( IRCApplication * app, const wxString& update_channel,
const wxString& hostName, unsigned int port, const wxString& callsign, const wxString& password,
const wxString& versionInfo, const wxString& localAddr )
: wxThread(wxTHREAD_JOINABLE)
{ {
safeStringCopy(host_name, hostName.mb_str(), sizeof host_name); safeStringCopy(host_name, hostName.c_str(), sizeof host_name);
this -> callsign = callsign.Lower(); this->callsign = callsign;
ToLower(this->callsign);
this->port = port; this->port = port;
this->password = password; this->password = password;
this->app = app; this->app = app;
if (localAddr.IsEmpty()) { if (localAddr.empty())
safeStringCopy(local_addr, "0.0.0.0", sizeof local_addr); safeStringCopy(local_addr, "0.0.0.0", sizeof local_addr);
} else { else
safeStringCopy(local_addr, localAddr.mb_str(), sizeof local_addr); safeStringCopy(local_addr, localAddr.c_str(), sizeof local_addr);
}
proto = new IRCProtocol(app, this->callsign, password, update_channel, versionInfo); proto = new IRCProtocol(app, this->callsign, password, update_channel, versionInfo);
@ -86,34 +44,23 @@ IRCClient::~IRCClient()
bool IRCClient::startWork() bool IRCClient::startWork()
{ {
if (Create() != wxTHREAD_NO_ERROR) {
wxLogError(wxT("IRCClient::startWork: Could not create the worker thread!"));
return false;
}
terminateThread = false; terminateThread = false;
client_thread = std::async(std::launch::async, &IRCClient::Entry, this);
if (Run() != wxTHREAD_NO_ERROR) {
wxLogError(wxT("IRCClient::startWork: Could not run the worker thread!"));
return false;
}
return true; return true;
} }
void IRCClient::stopWork() void IRCClient::stopWork()
{ {
terminateThread = true; terminateThread = true;
client_thread.get();
Wait();
} }
wxThread::ExitCode IRCClient::Entry () #define MAXIPV4ADDR 10
void IRCClient::Entry()
{ {
unsigned int numAddr; unsigned int numAddr;
#define MAXIPV4ADDR 10
struct sockaddr_in addr[MAXIPV4ADDR]; struct sockaddr_in addr[MAXIPV4ADDR];
struct sockaddr_in myaddr; struct sockaddr_in myaddr;
@ -123,15 +70,12 @@ wxThread::ExitCode IRCClient::Entry ()
int sock = 0; int sock = 0;
unsigned int currentAddr = 0; unsigned int currentAddr = 0;
int result;
numAddr = 0; numAddr = 0;
result = getAllIPV4Addresses(local_addr, 0, &numAddr, &myaddr, 1); int result = getAllIPV4Addresses(local_addr, 0, &numAddr, &myaddr, 1);
if ((result != 0) || (numAddr != 1)) { if ((result != 0) || (numAddr != 1)) {
wxLogVerbose(wxT("IRCClient::Entry: local address not parseable, using 0.0.0.0")); traceit("IRCClient::Entry: local address not parseable, using 0.0.0.0\n");
memset(&myaddr, 0x00, sizeof(struct sockaddr_in)); memset(&myaddr, 0x00, sizeof(struct sockaddr_in));
} }
@ -144,15 +88,15 @@ wxThread::ExitCode IRCClient::Entry ()
switch (state) { switch (state) {
case 0: case 0:
if (terminateThread) { if (terminateThread) {
wxLogVerbose(wxT("IRCClient::Entry: thread terminated at state=%d"), state); traceit("IRCClient::Entry: thread terminated at state=%d\n", state);
return 0; return;
} }
if (timer == 0) { if (timer == 0) {
timer = 30; timer = 30;
if (getAllIPV4Addresses(host_name, port, &numAddr, addr, MAXIPV4ADDR) == 0) { if (getAllIPV4Addresses(host_name, port, &numAddr, addr, MAXIPV4ADDR) == 0) {
wxLogVerbose(wxT("IRCClient::Entry: number of DNS entries %d"), numAddr); //traceit("IRCClient::Entry: number of DNS entries %d\n", numAddr);
if (numAddr > 0) { if (numAddr > 0) {
currentAddr = 0; currentAddr = 0;
state = 1; state = 1;
@ -164,53 +108,36 @@ wxThread::ExitCode IRCClient::Entry ()
case 1: case 1:
if (terminateThread) { if (terminateThread) {
wxLogVerbose(wxT("IRCClient::Entry: thread terminated at state=%d"), state); traceit("IRCClient::Entry: thread terminated at state=%d\n", state);
return 0; return;
} }
if (timer == 0) { if (timer == 0) {
sock = socket(PF_INET, SOCK_STREAM, IPPROTO_TCP); sock = socket(PF_INET, SOCK_STREAM, IPPROTO_TCP);
if (sock < 0) { if (sock < 0) {
wxLogSysError(wxT("IRCClient::Entry: socket")); traceit("IRCClient::Entry: could not create socket!\n");
timer = 30; timer = 30;
state = 0; state = 0;
} else { } else {
#if defined(__WINDOWS__)
u_long nonBlock = 1UL;
if (ioctlsocket( sock, FIONBIO, &nonBlock ) != 0) {
wxLogSysError(wxT("IRCClient::Entry: ioctlsocket"));
closesocket(sock);
timer = 30;
state = 0;
}
#else
if (fcntl(sock, F_SETFL, O_NONBLOCK) < 0) { if (fcntl(sock, F_SETFL, O_NONBLOCK) < 0) {
wxLogSysError(wxT("IRCClient::Entry: fcntl")); traceit("IRCClient::Entry: fcntl error\n");
close(sock); close(sock);
timer = 30; timer = 30;
state = 0; state = 0;
} }
#endif
else { else {
unsigned char *h = (unsigned char *) &(myaddr.sin_addr); unsigned char *h = (unsigned char *) &(myaddr.sin_addr);
int res; int res;
if ((h[0] != 0) || (h[1] != 0) || (h[2] != 0) || (h[3] != 0)) { if ((h[0] != 0) || (h[1] != 0) || (h[2] != 0) || (h[3] != 0))
wxLogVerbose(wxT("IRCClient::Entry: bind: local address %d.%d.%d.%d"), traceit("IRCClient::Entry: bind: local address %d.%d.%d.%d\n", h[0], h[1], h[2], h[3]);
h[0], h[1], h[2], h[3]);
}
res = bind(sock, (struct sockaddr *) &myaddr, sizeof (struct sockaddr_in)); res = bind(sock, (struct sockaddr *) &myaddr, sizeof (struct sockaddr_in));
if (res != 0) { if (res != 0) {
traceit("IRCClient::Entry: bind error\n");
wxLogSysError(wxT("IRCClient::Entry: bind"));
#if defined(__WINDOWS__)
closesocket(sock);
#else
close(sock); close(sock);
#endif
state = 0; state = 0;
timer = 30; timer = 30;
break; break;
@ -218,31 +145,21 @@ wxThread::ExitCode IRCClient::Entry ()
h = (unsigned char *) &(addr[currentAddr].sin_addr); h = (unsigned char *) &(addr[currentAddr].sin_addr);
wxLogVerbose(wxT("IRCClient::Entry: trying to connect to %d.%d.%d.%d"), //traceit("IRCClient::Entry: trying to connect to %d.%d.%d.%d\n", h[0], h[1], h[2], h[3]);
h[0], h[1], h[2], h[3]);
res = connect(sock, (struct sockaddr *) (addr + currentAddr), sizeof (struct sockaddr_in)); res = connect(sock, (struct sockaddr *) (addr + currentAddr), sizeof (struct sockaddr_in));
if (res == 0) { if (res == 0) {
wxLogVerbose(wxT("IRCClient::Entry: connected")); traceit("IRCClient::Entry: connected to %d.%d.%d.%d\n", h[0], h[1], h[2], h[3]);
state = 4; state = 4;
} else { } else {
#if defined(__WINDOWS__) if (errno == EINPROGRESS) {
if (WSAGetLastError() == WSAEWOULDBLOCK) //traceit("IRCClient::Entry: connect in progress\n");
#else
if (errno == EINPROGRESS)
#endif
{
wxLogVerbose(wxT("IRCClient::Entry: connect in progress"));
state = 3; state = 3;
timer = 10; // 5 second timeout timer = 10; // 5 second timeout
} else { } else {
wxLogSysError(wxT("IRCClient::Entry: connect")); traceit("IRCClient::Entry: connect\n");
#if defined(__WINDOWS__)
closesocket(sock);
#else
close(sock); close(sock);
#endif
currentAddr++; currentAddr++;
if (currentAddr >= numAddr) { if (currentAddr >= numAddr) {
state = 0; state = 0;
@ -265,45 +182,28 @@ wxThread::ExitCode IRCClient::Entry ()
fd_set myset; fd_set myset;
FD_ZERO(&myset); FD_ZERO(&myset);
FD_SET(sock, &myset); FD_SET(sock, &myset);
int res; int res = select(sock+1, NULL, &myset, NULL, &tv);
res = select(sock+1, NULL, &myset, NULL, &tv);
if (res < 0) { if (res < 0) {
wxLogSysError(wxT("IRCClient::Entry: select")); traceit("IRCClient::Entry: select\n");
#if defined(__WINDOWS__)
closesocket(sock);
#else
close(sock); close(sock);
#endif
state = 0; state = 0;
timer = 30; timer = 30;
} else if (res > 0) { // connect is finished } else if (res > 0) { // connect is finished
#if defined(__WINDOWS__)
int val_len;
#else
socklen_t val_len; socklen_t val_len;
#endif
int value; int value;
val_len = sizeof value; val_len = sizeof value;
if (getsockopt(sock, SOL_SOCKET, SO_ERROR, (char *) &value, &val_len) < 0) { if (getsockopt(sock, SOL_SOCKET, SO_ERROR, (char *) &value, &val_len) < 0) {
wxLogSysError(wxT("IRCClient::Entry: getsockopt")); traceit("IRCClient::Entry: getsockopt error\n");
#if defined(__WINDOWS__)
closesocket(sock);
#else
close(sock); close(sock);
#endif
state = 0; state = 0;
timer = 30; timer = 30;
} else { } else {
if (value != 0) { if (value != 0) {
wxLogWarning(wxT("IRCClient::Entry: SO_ERROR=%d"), value); traceit("IRCClient::Entry: SO_ERROR=%d\n", value);
#if defined(__WINDOWS__)
closesocket(sock);
#else
close(sock); close(sock);
#endif
currentAddr ++; currentAddr ++;
if (currentAddr >= numAddr) { if (currentAddr >= numAddr) {
state = 0; state = 0;
@ -313,19 +213,15 @@ wxThread::ExitCode IRCClient::Entry ()
timer = 2; timer = 2;
} }
} else { } else {
wxLogVerbose(wxT("IRCClient::Entry: connected2")); traceit("IRCClient::Entry: connected2\n");
state = 4; state = 4;
} }
} }
} else if (timer == 0) { } else if (timer == 0) {
// select timeout and timer timeout // select timeout and timer timeout
wxLogVerbose(wxT("IRCClient::Entry: connect timeout")); //traceit("IRCClient::Entry: connect timeout\n");
#if defined(__WINDOWS__)
closesocket(sock);
#else
close(sock); close(sock);
#endif
currentAddr++; currentAddr++;
if (currentAddr >= numAddr) { if (currentAddr >= numAddr) {
state = 0; state = 0;
@ -370,29 +266,29 @@ wxThread::ExitCode IRCClient::Entry ()
while ((state == 5) && sendQ->messageAvailable()) { while ((state == 5) && sendQ->messageAvailable()) {
IRCMessage * m = sendQ->getMessage(); IRCMessage * m = sendQ->getMessage();
wxString out; std::string out;
m->composeMessage(out); m->composeMessage(out);
char buf[200]; char buf[200];
safeStringCopy(buf, out.mb_str(wxConvUTF8), sizeof buf); safeStringCopy(buf, out.c_str(), sizeof buf);
int len = strlen(buf); int len = strlen(buf);
if (buf[len - 1] == 10) { // is there a NL char at the end? if (buf[len - 1] == 10) { // is there a NL char at the end?
int r = send(sock, buf, len, 0); int r = send(sock, buf, len, 0);
if (r != len) { if (r != len) {
wxLogVerbose(wxT("IRCClient::Entry: short write %d < %d"), r, len); traceit("IRCClient::Entry: short write %d < %d\n", r, len);
timer = 0; timer = 0;
state = 6; state = 6;
} }
/* else /* else
{ {
wxLogVerbose(wxT("write %d bytes (") + out + wxT(")"), len ); traceit("write %d bytes (%s)\n", len, out.c_str());
} */ } */
} else { } else {
wxLogVerbose(wxT("IRCClient::Entry: no NL at end, len=%d"), len); traceit("IRCClient::Entry: no NL at end, len=%d\n", len);
timer = 0; timer = 0;
state = 6; state = 6;
@ -412,38 +308,26 @@ wxThread::ExitCode IRCClient::Entry ()
proto->setNetworkReady(false); proto->setNetworkReady(false);
recv->stopWork(); recv->stopWork();
wxThread::Sleep(2000); sleep(2);
delete recv; delete recv;
delete recvQ; delete recvQ;
delete sendQ; delete sendQ;
#if defined(__WINDOWS__)
closesocket(sock);
#else
close(sock); close(sock);
#endif
if (terminateThread) { // request to end the thread if (terminateThread) { // request to end the thread
wxLogVerbose(wxT("IRCClient::Entry: thread terminated at state=%d"), state); traceit("IRCClient::Entry: thread terminated at state=%d\n", state);
return 0; return;
} }
timer = 30; timer = 30;
state = 0; // reconnect to IRC server state = 0; // reconnect to IRC server
} }
break; break;
} // switch
usleep(500000);
} }
return;
wxThread::Sleep(500);
}
return 0;
} }

57
IRCClient.h
Unescape View File

@ -1,65 +1,31 @@
/* #pragma once
CIRCDDB - ircDDB client library in C++ #include <future>
Copyright (C) 2010-2011 Michael Dirska, DL1BFF (dl1bff@mdx.de)
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 2 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/>.
*/
#if !defined(_IRCCLIENT_H)
#define _IRCCLIENT_H
#include "IRCReceiver.h" #include "IRCReceiver.h"
#include "IRCMessageQueue.h" #include "IRCMessageQueue.h"
#include "IRCProtocol.h" #include "IRCProtocol.h"
#include "IRCApplication.h" #include "IRCApplication.h"
#include <wx/wx.h> class IRCClient
class IRCClient : public wxThread
{ {
public: public:
IRCClient(IRCApplication *app, const std::string &update_channel, const std::string &hostName, unsigned int port, const std::string &callsign, const std::string &password,
const std::string &versionInfo, const std::string &localAddr);
IRCClient( IRCApplication * app, const wxString& update_channel, virtual ~IRCClient();
const wxString& hostName, unsigned int port, const wxString& callsign, const wxString& password,
const wxString& versionInfo, const wxString& localAddr );
~IRCClient();
bool startWork(); bool startWork();
void stopWork(); void stopWork();
protected: protected:
virtual void Entry();
virtual wxThread::ExitCode Entry();
private: private:
char host_name[100]; char host_name[100];
char local_addr[100]; char local_addr[100];
unsigned int port; unsigned int port;
wxString callsign; std::string callsign;
wxString password; std::string password;
bool terminateThread; bool terminateThread;
@ -67,10 +33,7 @@ private:
IRCMessageQueue *recvQ; IRCMessageQueue *recvQ;
IRCMessageQueue *sendQ; IRCMessageQueue *sendQ;
IRCProtocol *proto; IRCProtocol *proto;
std::future<void> client_thread;
IRCApplication *app; IRCApplication *app;
}; };
#endif

268
IRCDDB.cpp
Unescape View File

@ -1,32 +1,8 @@
/*
CIRCDDB - ircDDB client library in C++
Copyright (C) 2010-2011 Michael Dirska, DL1BFF (dl1bff@mdx.de)
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 2 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 "IRCDDB.h" #include "IRCDDB.h"
#include "IRCClient.h" #include "IRCClient.h"
#include "IRCDDBApp.h" #include "IRCDDBApp.h"
#include "IRCutils.h"
#include <wx/wx.h>
struct CIRCDDBPrivate { struct CIRCDDBPrivate {
IRCClient *client; IRCClient *client;
@ -34,17 +10,15 @@ struct CIRCDDBPrivate {
}; };
CIRCDDB::CIRCDDB(const wxString& hostName, unsigned int port, CIRCDDB::CIRCDDB(const std::string &hostName, unsigned int port, const std::string &callsign, const std::string &password, const std::string &versionInfo, const std::string &localAddr)
const wxString& callsign, const wxString& password, : d(new CIRCDDBPrivate)
const wxString& versionInfo, const wxString& localAddr ) : d( new CIRCDDBPrivate )
{ {
wxString update_channel = wxT("#dstar"); std::string update_channel = "#dstar";
d->app = new IRCDDBApp(update_channel); d->app = new IRCDDBApp(update_channel);
d->client = new IRCClient( d->app, update_channel, hostName, port, callsign, d->client = new IRCClient(d->app, update_channel, hostName, port, callsign, password, versionInfo, localAddr);
password, versionInfo, localAddr );
} }
CIRCDDB::~CIRCDDB() CIRCDDB::~CIRCDDB()
@ -58,7 +32,7 @@ CIRCDDB::~CIRCDDB()
// A false return implies a network error, or unable to log in // A false return implies a network error, or unable to log in
bool CIRCDDB::open() bool CIRCDDB::open()
{ {
wxLogVerbose(wxT("start")); traceit("start");
return d->client->startWork() && d->app->startWork(); return d->client->startWork() && d->app->startWork();
} }
@ -69,229 +43,215 @@ int CIRCDDB::getConnectionState()
} }
void CIRCDDB::rptrQTH(const wxString& rptrcall, double latitude, double longitude, const wxString& desc1, const wxString& desc2, const wxString& infoURL, const wxString &swVersion) void CIRCDDB::rptrQTH(const std::string &rptrcall, double latitude, double longitude, const std::string &desc1, const std::string &desc2, const std::string &infoURL, const std::string &swVersion)
{ {
d->app->rptrQTH(rptrcall, latitude, longitude, desc1, desc2, infoURL, swVersion); d->app->rptrQTH(rptrcall, latitude, longitude, desc1, desc2, infoURL, swVersion);
} }
void CIRCDDB::rptrQRG(const wxString& rptrcall, double txFrequency, double duplexShift, double range, double agl) void CIRCDDB::rptrQRG(const std::string &rptrcall, double txFrequency, double duplexShift, double range, double agl)
{ {
d->app->rptrQRG(rptrcall, txFrequency, duplexShift, range, agl); d->app->rptrQRG(rptrcall, txFrequency, duplexShift, range, agl);
} }
void CIRCDDB::kickWatchdog ( const wxString& wdInfo ) void CIRCDDB::kickWatchdog(const std::string &wdInfo)
{ {
d->app->kickWatchdog(wdInfo); d->app->kickWatchdog(wdInfo);
} }
// Send heard data, a false return implies a network error // Send heard data, a false return implies a network error
bool CIRCDDB::sendHeard( const wxString& myCall, const wxString& myCallExt, bool CIRCDDB::sendHeard(const std::string &myCall, const std::string &myCallExt, const std::string &yourCall, const std::string &rpt1,
const wxString& yourCall, const wxString& rpt1, const std::string &rpt2, unsigned char flag1, unsigned char flag2, unsigned char flag3)
const wxString& rpt2, unsigned char flag1,
unsigned char flag2, unsigned char flag3 )
{ {
if (myCall.Len() != 8) { if (myCall.size() != 8) {
wxLogVerbose(wxT("CIRCDDB::sendHeard:myCall: len != 8")); traceit("CIRCDDB::sendHeard:myCall: len != 8");
return false; return false;
} }
if (myCallExt.Len() != 4) { if (myCallExt.size() != 4) {
wxLogVerbose(wxT("CIRCDDB::sendHeard:myCallExt: len != 4")); traceit("CIRCDDB::sendHeard:myCallExt: len != 4");
return false; return false;
} }
if (yourCall.Len() != 8) { if (yourCall.size() != 8) {
wxLogVerbose(wxT("CIRCDDB::sendHeard:yourCall: len != 8")); traceit("CIRCDDB::sendHeard:yourCall: len != 8");
return false; return false;
} }
if (rpt1.Len() != 8) { if (rpt1.size() != 8) {
wxLogVerbose(wxT("CIRCDDB::sendHeard:rpt1: len != 8")); traceit("CIRCDDB::sendHeard:rpt1: len != 8");
return false; return false;
} }
if (rpt2.Len() != 8) { if (rpt2.size() != 8) {
wxLogVerbose(wxT("CIRCDDB::sendHeard:rpt2: len != 8")); traceit("CIRCDDB::sendHeard:rpt2: len != 8");
return false; return false;
} }
return d->app->sendHeard( myCall, myCallExt, yourCall, rpt1, rpt2, flag1, flag2, flag3, return d->app->sendHeard( myCall, myCallExt, yourCall, rpt1, rpt2, flag1, flag2, flag3, " ", "", "");
wxT(" "), wxT(""), wxT(""));
} }
// Send heard data, a false return implies a network error // Send heard data, a false return implies a network error
bool CIRCDDB::sendHeardWithTXMsg( const wxString& myCall, const wxString& myCallExt, bool CIRCDDB::sendHeardWithTXMsg(const std::string &myCall, const std::string &myCallExt, const std::string &yourCall, const std::string &rpt1, const std::string &rpt2, unsigned char flag1,
const wxString& yourCall, const wxString& rpt1, unsigned char flag2, unsigned char flag3, const std::string &network_destination, const std::string &tx_message)
const wxString& rpt2, unsigned char flag1,
unsigned char flag2, unsigned char flag3,
const wxString& network_destination,
const wxString& tx_message )
{ {
if (myCall.Len() != 8) { if (myCall.size() != 8) {
wxLogVerbose(wxT("CIRCDDB::sendHeard:myCall: len != 8")); traceit("CIRCDDB::sendHeard:myCall: len != 8");
return false; return false;
} }
if (myCallExt.Len() != 4) { if (myCallExt.size() != 4) {
wxLogVerbose(wxT("CIRCDDB::sendHeard:myCallExt: len != 4")); traceit("CIRCDDB::sendHeard:myCallExt: len != 4");
return false; return false;
} }
if (yourCall.Len() != 8) { if (yourCall.size() != 8) {
wxLogVerbose(wxT("CIRCDDB::sendHeard:yourCall: len != 8")); traceit("CIRCDDB::sendHeard:yourCall: len != 8");
return false; return false;
} }
if (rpt1.Len() != 8) { if (rpt1.size() != 8) {
wxLogVerbose(wxT("CIRCDDB::sendHeard:rpt1: len != 8")); traceit("CIRCDDB::sendHeard:rpt1: len != 8");
return false; return false;
} }
if (rpt2.Len() != 8) { if (rpt2.size() != 8) {
wxLogVerbose(wxT("CIRCDDB::sendHeard:rpt2: len != 8")); traceit("CIRCDDB::sendHeard:rpt2: len != 8");
return false; return false;
} }
wxString dest = network_destination; std::string dest = network_destination;
if (dest.Len() == 0) { if (dest.size() == 0)
dest = wxT(" "); dest = " ";
}
if (dest.Len() != 8) { if (dest.size() != 8) {
wxLogVerbose(wxT("CIRCDDB::sendHeard:network_destination: len != 8")); traceit("CIRCDDB::sendHeard:network_destination: len != 8");
return false; return false;
} }
wxString msg; std::string msg;
if (tx_message.Len() == 20) { if (tx_message.length() == 20) {
unsigned int i; for (unsigned int i=0; i < tx_message.size(); i++) {
for (i=0; i < tx_message.Len(); i++) { char ch = tx_message.at(i);
wxChar ch = tx_message.GetChar(i);
if ((ch > 32) && (ch < 127)) { if (ch>32 && ch<127) {
msg.Append(ch); msg.push_back(ch);
} else { } else {
msg.Append(wxT('_')); msg.push_back('_');
} }
} }
} }
return d->app->sendHeard( myCall, myCallExt, yourCall, rpt1, rpt2, flag1, flag2, flag3, return d->app->sendHeard( myCall, myCallExt, yourCall, rpt1, rpt2, flag1, flag2, flag3, dest, msg, "");
dest, msg, wxT(""));
} }
bool CIRCDDB::sendHeardWithTXStats( const wxString& myCall, const wxString& myCallExt, bool CIRCDDB::sendHeardWithTXStats(const std::string &myCall, const std::string &myCallExt, const std::string &yourCall, const std::string &rpt1, const std::string &rpt2, unsigned char flag1,
const wxString& yourCall, const wxString& rpt1, unsigned char flag2, unsigned char flag3, int num_dv_frames, int num_dv_silent_frames, int num_bit_errors)
const wxString& rpt2, unsigned char flag1,
unsigned char flag2, unsigned char flag3,
int num_dv_frames,
int num_dv_silent_frames,
int num_bit_errors )
{ {
if ((num_dv_frames <= 0) || (num_dv_frames > 65535)) { if (num_dv_frames<= 0 || num_dv_frames>65535) {
wxLogVerbose(wxT("CIRCDDB::sendHeard:num_dv_frames not in range 1-65535")); traceit("CIRCDDB::sendHeard:num_dv_frames not in range 1-65535");
return false; return false;
} }
if (num_dv_silent_frames > num_dv_frames) { if (num_dv_silent_frames > num_dv_frames) {
wxLogVerbose(wxT("CIRCDDB::sendHeard:num_dv_silent_frames > num_dv_frames")); traceit("CIRCDDB::sendHeard:num_dv_silent_frames > num_dv_frames");
return false; return false;
} }
if (num_bit_errors > (4*num_dv_frames)) { // max 4 bit errors per frame if (num_bit_errors > 4*num_dv_frames) { // max 4 bit errors per frame
wxLogVerbose(wxT("CIRCDDB::sendHeard:num_bit_errors > (4*num_dv_frames)")); traceit("CIRCDDB::sendHeard:num_bit_errors > (4*num_dv_frames)");
return false; return false;
} }
if (myCall.Len() != 8) { if (myCall.size() != 8) {
wxLogVerbose(wxT("CIRCDDB::sendHeard:myCall: len != 8")); traceit("CIRCDDB::sendHeard:myCall: len != 8");
return false; return false;
} }
if (myCallExt.Len() != 4) { if (myCallExt.size() != 4) {
wxLogVerbose(wxT("CIRCDDB::sendHeard:myCallExt: len != 4")); traceit("CIRCDDB::sendHeard:myCallExt: len != 4");
return false; return false;
} }
if (yourCall.Len() != 8) { if (yourCall.size() != 8) {
wxLogVerbose(wxT("CIRCDDB::sendHeard:yourCall: len != 8")); traceit("CIRCDDB::sendHeard:yourCall: len != 8");
return false; return false;
} }
if (rpt1.Len() != 8) { if (rpt1.size() != 8) {
wxLogVerbose(wxT("CIRCDDB::sendHeard:rpt1: len != 8")); traceit("CIRCDDB::sendHeard:rpt1: len != 8");
return false; return false;
} }
if (rpt2.Len() != 8) { if (rpt2.size() != 8) {
wxLogVerbose(wxT("CIRCDDB::sendHeard:rpt2: len != 8")); traceit("CIRCDDB::sendHeard:rpt2: len != 8");
return false; return false;
} }
wxString stats = wxString::Format(wxT("%04x"), num_dv_frames); char buf[16];
snprintf(buf, 16, "%04x", num_dv_frames);
std::string stats = buf;
if (num_dv_silent_frames >= 0) { if (num_dv_silent_frames >= 0) {
wxString s = wxString::Format(wxT("%02x"), (num_dv_silent_frames * 100) / num_dv_frames); snprintf(buf, 16, "%02x", num_dv_silent_frames * 100 / num_dv_frames);
stats.Append(s); stats.append(buf);
if (num_bit_errors >= 0) { if (num_bit_errors >= 0) {
s = wxString::Format(wxT("%02x"), (num_bit_errors * 125) / (num_dv_frames * 3)); snprintf(buf,16, "%02x", num_bit_errors * 125 / (num_dv_frames * 3));
stats.Append(s); stats.append(buf);
} else { } else {
stats.Append(wxT("__")); stats.append("__");
} }
} else { } else {
stats.Append(wxT("____")); stats.append("____");
} }
stats.Append(wxT("____________")); // stats string should have 20 chars stats.append("____________"); // stats string should have 20 chars
return d->app->sendHeard( myCall, myCallExt, yourCall, rpt1, rpt2, flag1, flag2, flag3, return d->app->sendHeard( myCall, myCallExt, yourCall, rpt1, rpt2, flag1, flag2, flag3, " ", "", stats);
wxT(" "), wxT(""), stats);
} }
// Send query for a gateway/reflector, a false return implies a network error // Send query for a gateway/reflector, a false return implies a network error
bool CIRCDDB::findGateway(const wxString& gatewayCallsign) bool CIRCDDB::findGateway(const std::string &gatewayCallsign)
{ {
if (gatewayCallsign.Len() != 8) { if (gatewayCallsign.size() != 8) {
wxLogVerbose(wxT("CIRCDDB::findGateway: len != 8")); traceit("CIRCDDB::findGateway: len != 8");
return false; return false;
} }
std::string gcs = gatewayCallsign;
return d->app->findGateway( gatewayCallsign.Upper()); ToUpper(gcs);
return d->app->findGateway(gcs);
} }
bool CIRCDDB::findRepeater(const wxString& repeaterCallsign) bool CIRCDDB::findRepeater(const std::string &repeaterCallsign)
{ {
if (repeaterCallsign.Len() != 8) { if (repeaterCallsign.size() != 8) {
wxLogVerbose(wxT("CIRCDDB::findRepeater: len != 8")); traceit("CIRCDDB::findRepeater: len != 8");
return false; return false;
} }
std::string rcs = repeaterCallsign;
return d->app->findRepeater( repeaterCallsign.Upper()); ToUpper(rcs);
return d->app->findRepeater(rcs);
} }
// Send query for a user, a false return implies a network error // Send query for a user, a false return implies a network error
bool CIRCDDB::findUser(const wxString& userCallsign) bool CIRCDDB::findUser(const std::string &userCallsign)
{ {
if (userCallsign.Len() != 8) { if (userCallsign.size() != 8) {
wxLogVerbose(wxT("CIRCDDB::findUser: len != 8")); traceit("CIRCDDB::findUser: len != 8");
return false; return false;
} }
std::string ucs = userCallsign;
return d->app->findUser( userCallsign.Upper()); ToUpper(ucs);
return d->app->findUser(ucs);
} }
// The following functions are for processing received messages // The following functions are for processing received messages
@ -304,29 +264,29 @@ IRCDDB_RESPONSE_TYPE CIRCDDB::getMessageType()
// Get a gateway message, as a result of IDRT_REPEATER returned from getMessageType() // Get a gateway message, as a result of IDRT_REPEATER returned from getMessageType()
// A false return implies a network error // A false return implies a network error
bool CIRCDDB::receiveRepeater(wxString& repeaterCallsign, wxString& gatewayCallsign, wxString& address, DSTAR_PROTOCOL& /*protocol*/) bool CIRCDDB::receiveRepeater(std::string &repeaterCallsign, std::string &gatewayCallsign, std::string &address, DSTAR_PROTOCOL &/*protocol*/)
{ {
IRCDDB_RESPONSE_TYPE rt = d->app->getReplyMessageType(); IRCDDB_RESPONSE_TYPE rt = d->app->getReplyMessageType();
if (rt != IDRT_REPEATER) { if (rt != IDRT_REPEATER) {
wxLogError(wxT("CIRCDDB::receiveRepeater: unexpected response type")); traceit("CIRCDDB::receiveRepeater: unexpected response type");
return false; return false;
} }
IRCMessage * m = d->app->getReplyMessage(); IRCMessage * m = d->app->getReplyMessage();
if (m == NULL) { if (m == NULL) {
wxLogError(wxT("CIRCDDB::receiveRepeater: no message")); traceit("CIRCDDB::receiveRepeater: no message");
return false; return false;
} }
if (!m->getCommand().IsSameAs(wxT("IDRT_REPEATER"))) { if (m->getCommand().compare("IDRT_REPEATER")) {
wxLogError(wxT("CIRCDDB::receiveRepeater: wrong message type")); traceit("CIRCDDB::receiveRepeater: wrong message type");
return false; return false;
} }
if (m->getParamCount() != 3) { if (m->getParamCount() != 3) {
wxLogError(wxT("CIRCDDB::receiveRepeater: unexpected number of message parameters")); traceit("CIRCDDB::receiveRepeater: unexpected number of message parameters");
return false; return false;
} }
@ -341,29 +301,29 @@ bool CIRCDDB::receiveRepeater(wxString& repeaterCallsign, wxString& gatewayCalls
// Get a gateway message, as a result of IDRT_GATEWAY returned from getMessageType() // Get a gateway message, as a result of IDRT_GATEWAY returned from getMessageType()
// A false return implies a network error // A false return implies a network error
bool CIRCDDB::receiveGateway(wxString& gatewayCallsign, wxString& address, DSTAR_PROTOCOL& /*protocol*/) bool CIRCDDB::receiveGateway(std::string &gatewayCallsign, std::string &address, DSTAR_PROTOCOL& /*protocol*/)
{ {
IRCDDB_RESPONSE_TYPE rt = d->app->getReplyMessageType(); IRCDDB_RESPONSE_TYPE rt = d->app->getReplyMessageType();
if (rt != IDRT_GATEWAY) { if (rt != IDRT_GATEWAY) {
wxLogError(wxT("CIRCDDB::receiveGateway: unexpected response type")); traceit("CIRCDDB::receiveGateway: unexpected response type");
return false; return false;
} }
IRCMessage * m = d->app->getReplyMessage(); IRCMessage * m = d->app->getReplyMessage();
if (m == NULL) { if (m == NULL) {
wxLogError(wxT("CIRCDDB::receiveGateway: no message")); traceit("CIRCDDB::receiveGateway: no message");
return false; return false;
} }
if (!m->getCommand().IsSameAs(wxT("IDRT_GATEWAY"))) { if (m->getCommand().compare("IDRT_GATEWAY")) {
wxLogError(wxT("CIRCDDB::receiveGateway: wrong message type")); traceit("CIRCDDB::receiveGateway: wrong message type");
return false; return false;
} }
if (m->getParamCount() != 2) { if (m->getParamCount() != 2) {
wxLogError(wxT("CIRCDDB::receiveGateway: unexpected number of message parameters")); traceit("CIRCDDB::receiveGateway: unexpected number of message parameters");
return false; return false;
} }
@ -377,36 +337,36 @@ bool CIRCDDB::receiveGateway(wxString& gatewayCallsign, wxString& address, DSTAR
// Get a user message, as a result of IDRT_USER returned from getMessageType() // Get a user message, as a result of IDRT_USER returned from getMessageType()
// A false return implies a network error // A false return implies a network error
bool CIRCDDB::receiveUser(wxString& userCallsign, wxString& repeaterCallsign, wxString& gatewayCallsign, wxString& address) bool CIRCDDB::receiveUser(std::string &userCallsign, std::string &repeaterCallsign, std::string &gatewayCallsign, std::string &address)
{ {
wxString dummy; std::string dummy;
return receiveUser(userCallsign, repeaterCallsign, gatewayCallsign, address, dummy); return receiveUser(userCallsign, repeaterCallsign, gatewayCallsign, address, dummy);
} }
bool CIRCDDB::receiveUser(wxString& userCallsign, wxString& repeaterCallsign, wxString& gatewayCallsign, wxString& address, bool CIRCDDB::receiveUser(std::string &userCallsign, std::string &repeaterCallsign, std::string &gatewayCallsign, std::string &address,
wxString& timeStamp) std::string &timeStamp)
{ {
IRCDDB_RESPONSE_TYPE rt = d->app->getReplyMessageType(); IRCDDB_RESPONSE_TYPE rt = d->app->getReplyMessageType();
if (rt != IDRT_USER) { if (rt != IDRT_USER) {
wxLogError(wxT("CIRCDDB::receiveUser: unexpected response type")); traceit("CIRCDDB::receiveUser: unexpected response type");
return false; return false;
} }
IRCMessage * m = d->app->getReplyMessage(); IRCMessage * m = d->app->getReplyMessage();
if (m == NULL) { if (m == NULL) {
wxLogError(wxT("CIRCDDB::receiveUser: no message")); traceit("CIRCDDB::receiveUser: no message");
return false; return false;
} }
if (!m->getCommand().IsSameAs(wxT("IDRT_USER"))) { if (m->getCommand().compare("IDRT_USER")) {
wxLogError(wxT("CIRCDDB::receiveUser: wrong message type")); traceit("CIRCDDB::receiveUser: wrong message type");
return false; return false;
} }
if (m->getParamCount() != 5) { if (m->getParamCount() != 5) {
wxLogError(wxT("CIRCDDB::receiveUser: unexpected number of message parameters")); traceit("CIRCDDB::receiveUser: unexpected number of message parameters");
return false; return false;
} }

76
IRCDDB.h
Unescape View File

@ -1,29 +1,6 @@
/* #pragma once
CIRCDDB - ircDDB client library in C++ #include <string>
Copyright (C) 2010-2011 Michael Dirska, DL1BFF (dl1bff@mdx.de)
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 2 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/>.
*/
#if !defined(_IRCDDB_H)
#define _IRCDDB_H
#include <wx/wx.h>
enum IRCDDB_RESPONSE_TYPE { enum IRCDDB_RESPONSE_TYPE {
IDRT_NONE, IDRT_NONE,
@ -44,8 +21,7 @@ struct CIRCDDBPrivate;
class CIRCDDB class CIRCDDB
{ {
public: public:
CIRCDDB(const wxString& hostName, unsigned int port, const wxString& callsign, const wxString& password, CIRCDDB(const std::string &hostName, unsigned int port, const std::string &callsign, const std::string &password, const std::string &versionInfo, const std::string &localAddr = "");
const wxString& versionInfo, const wxString& localAddr = wxEmptyString );
~CIRCDDB(); ~CIRCDDB();
// A false return implies a network error, or unable to log in // A false return implies a network error, or unable to log in
@ -58,7 +34,7 @@ public:
// longitude WGS84 position of antenna in degrees, positive value -> EAST // longitude WGS84 position of antenna in degrees, positive value -> EAST
// desc1, desc2 20-character description of QTH // desc1, desc2 20-character description of QTH
void rptrQTH(const wxString& rptrcall, double latitude, double longitude, const wxString& desc1, const wxString& desc2, const wxString& infoURL, const wxString &swVersion); void rptrQTH(const std::string &rptrcall, double latitude, double longitude, const std::string &desc1, const std::string &desc2, const std::string &infoURL, const std::string &swVersion);
@ -69,7 +45,7 @@ public:
// range range of the repeater in meters (meters = miles * 1609.344) // range range of the repeater in meters (meters = miles * 1609.344)
// agl height of the antenna above ground in meters (meters = feet * 0.3048) // agl height of the antenna above ground in meters (meters = feet * 0.3048)
void rptrQRG(const wxString& rptrcall, double txFrequency, double duplexShift, double range, double agl); void rptrQRG(const std::string &rptrcall, double txFrequency, double duplexShift, double range, double agl);
// If you call this method once, watchdog messages will be sent to the // If you call this method once, watchdog messages will be sent to the
@ -80,7 +56,7 @@ public:
// version of the RF decoding software. For example, the ircDDB java software sets this // version of the RF decoding software. For example, the ircDDB java software sets this
// to "rpm_ircddbmhd-x.z-z". The string wdInfo must contain at least one non-space character. // to "rpm_ircddbmhd-x.z-z". The string wdInfo must contain at least one non-space character.
void kickWatchdog(const wxString& wdInfo); void kickWatchdog(const std::string &wdInfo);
@ -94,10 +70,7 @@ public:
// 10 = some network error occured, next state is "0" (new connection attempt) // 10 = some network error occured, next state is "0" (new connection attempt)
// Send heard data, a false return implies a network error // Send heard data, a false return implies a network error
bool sendHeard(const wxString& myCall, const wxString& myCallExt, bool sendHeard(const std::string &myCall, const std::string &myCallExt, const std::string &yourCall, const std::string &rpt1, const std::string &rpt2, unsigned char flag1, unsigned char flag2, unsigned char flag3);
const wxString& yourCall, const wxString& rpt1,
const wxString& rpt2, unsigned char flag1,
unsigned char flag2, unsigned char flag3 );
// same as sendHeard with two new fields: // same as sendHeard with two new fields:
@ -105,12 +78,8 @@ public:
// or reflector, where this transmission is relayed to. // or reflector, where this transmission is relayed to.
// tx_message: 20-char TX message or empty string, if the user did not // tx_message: 20-char TX message or empty string, if the user did not
// send a TX message // send a TX message
bool sendHeardWithTXMsg(const wxString& myCall, const wxString& myCallExt, bool sendHeardWithTXMsg(const std::string &myCall, const std::string &myCallExt, const std::string &yourCall, const std::string &rpt1, const std::string &rpt2, unsigned char flag1,
const wxString& yourCall, const wxString& rpt1, unsigned char flag2, unsigned char flag3, const std::string &network_destination, const std::string &tx_message);
const wxString& rpt2, unsigned char flag1,
unsigned char flag2, unsigned char flag3,
const wxString& network_destination,
const wxString& tx_message );
// this method should be called at the end of a transmission // this method should be called at the end of a transmission
// num_dv_frames: number of DV frames sent out (96 bit frames, 20ms) // num_dv_frames: number of DV frames sent out (96 bit frames, 20ms)
@ -122,24 +91,19 @@ public:
// So, the overall bit error rate is calculated like this: // So, the overall bit error rate is calculated like this:
// BER = num_bit_errors / (num_dv_frames * 24) // BER = num_bit_errors / (num_dv_frames * 24)
// Set num_bit_errors = -1, if the error information is not available. // Set num_bit_errors = -1, if the error information is not available.
bool sendHeardWithTXStats(const wxString& myCall, const wxString& myCallExt, bool sendHeardWithTXStats(const std::string &myCall, const std::string &myCallExt, const std::string &yourCall, const std::string &rpt1, const std::string &rpt2, unsigned char flag1,
const wxString& yourCall, const wxString& rpt1, unsigned char flag2, unsigned char flag3, int num_dv_frames, int num_dv_silent_frames, int num_bit_errors);
const wxString& rpt2, unsigned char flag1,
unsigned char flag2, unsigned char flag3,
int num_dv_frames,
int num_dv_silent_frames,
int num_bit_errors );
// The following three functions don't block waiting for a reply, they just send the data // The following three functions don't block waiting for a reply, they just send the data
// Send query for a gateway/reflector, a false return implies a network error // Send query for a gateway/reflector, a false return implies a network error
bool findGateway(const wxString& gatewayCallsign); bool findGateway(const std::string &gatewayCallsign);
// Send query for a repeater module, a false return implies a network error // Send query for a repeater module, a false return implies a network error
bool findRepeater(const wxString& repeaterCallsign); bool findRepeater(const std::string &repeaterCallsign);
// Send query for a user, a false return implies a network error // Send query for a user, a false return implies a network error
bool findUser(const wxString& userCallsign); bool findUser(const std::string &userCallsign);
// The following functions are for processing received messages // The following functions are for processing received messages
@ -148,18 +112,17 @@ public:
// Get a gateway message, as a result of IDRT_REPEATER returned from getMessageType() // Get a gateway message, as a result of IDRT_REPEATER returned from getMessageType()
// A false return implies a network error // A false return implies a network error
bool receiveRepeater(wxString& repeaterCallsign, wxString& gatewayCallsign, wxString& address, DSTAR_PROTOCOL& protocol); bool receiveRepeater(std::string &repeaterCallsign, std::string &gatewayCallsign, std::string &address, DSTAR_PROTOCOL& protocol);
// Get a gateway message, as a result of IDRT_GATEWAY returned from getMessageType() // Get a gateway message, as a result of IDRT_GATEWAY returned from getMessageType()
// A false return implies a network error // A false return implies a network error
bool receiveGateway(wxString& gatewayCallsign, wxString& address, DSTAR_PROTOCOL& protocol); bool receiveGateway(std::string &gatewayCallsign, std::string &address, DSTAR_PROTOCOL &protocol);
// Get a user message, as a result of IDRT_USER returned from getMessageType() // Get a user message, as a result of IDRT_USER returned from getMessageType()
// A false return implies a network error // A false return implies a network error
bool receiveUser(wxString& userCallsign, wxString& repeaterCallsign, wxString& gatewayCallsign, wxString& address); bool receiveUser(std::string &userCallsign, std::string &repeaterCallsign, std::string &gatewayCallsign, std::string &address);
bool receiveUser(wxString& userCallsign, wxString& repeaterCallsign, wxString& gatewayCallsign, wxString& address, bool receiveUser(std::string &userCallsign, std::string &repeaterCallsign, std::string &gatewayCallsign, std::string &address, std::string &timeStamp);
wxString& timeStamp );
void close(); // Implictely kills any threads in the IRC code void close(); // Implictely kills any threads in the IRC code
@ -168,6 +131,3 @@ private:
struct CIRCDDBPrivate * const d; struct CIRCDDBPrivate * const d;
}; };
#endif // _IRCDDB_H

882
IRCDDBApp.cpp
View File

File diff suppressed because it is too large Load Diff

77
IRCDDBApp.h
Unescape View File

@ -1,56 +1,34 @@
/* #pragma once
CIRCDDB - ircDDB client library in C++
Copyright (C) 2010-2011 Michael Dirska, DL1BFF (dl1bff@mdx.de)
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 2 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/>.
*/
#if !defined(_IRCDDBAPP_H)
#define _IRCDDBAPP_H
#include <string>
#include <future>
#include "IRCDDB.h" #include "IRCDDB.h"
#include "IRCApplication.h" #include "IRCApplication.h"
#include <wx/wx.h>
class IRCDDBAppPrivate; class IRCDDBAppPrivate;
class IRCDDBApp : public IRCApplication, wxThread class IRCDDBApp : public IRCApplication
{ {
public: public:
IRCDDBApp(const wxString& update_channel); IRCDDBApp(const std::string &update_channel);
virtual ~IRCDDBApp(); virtual ~IRCDDBApp();
virtual void userJoin (const wxString& nick, const wxString& name, const wxString& host); virtual void userJoin(const std::string &nick, const std::string &name, const std::string &host);
virtual void userLeave (const wxString& nick); virtual void userLeave(const std::string &nick);
virtual void userChanOp (const wxString& nick, bool op); virtual void userChanOp(const std::string &nick, bool op);
virtual void userListReset(); virtual void userListReset();
virtual void msgChannel(IRCMessage *m); virtual void msgChannel(IRCMessage *m);
virtual void msgQuery(IRCMessage *m); virtual void msgQuery(IRCMessage *m);
virtual void setCurrentNick(const wxString& nick); virtual void setCurrentNick(const std::string &nick);
virtual void setTopic(const wxString& topic); virtual void setTopic(const std::string &topic);
virtual void setBestServer(const wxString& ircUser); virtual void setBestServer(const std::string &ircUser);
virtual void setSendQ(IRCMessageQueue *s); virtual void setSendQ(IRCMessageQueue *s);
virtual IRCMessageQueue *getSendQ(); virtual IRCMessageQueue *getSendQ();
@ -62,35 +40,30 @@ public:
IRCMessage *getReplyMessage(); IRCMessage *getReplyMessage();
bool findUser ( const wxString& s ); bool findUser(const std::string &s);
bool findRepeater ( const wxString& s ); bool findRepeater(const std::string &s);
bool findGateway ( const wxString& s ); bool findGateway(const std::string &s);
bool sendHeard(const wxString& myCall, const wxString& myCallExt, bool sendHeard(const std::string &myCall, const std::string &myCallExt, const std::string &yourCall, const std::string &rpt1,
const wxString& yourCall, const wxString& rpt1, const std::string &rpt2, unsigned char flag1, unsigned char flag2, unsigned char flag3,
const wxString& rpt2, unsigned char flag1, const std::string &destination, const std::string &tx_msg, const std::string &tx_stats);
unsigned char flag2, unsigned char flag3,
const wxString& destination, const wxString& tx_msg,
const wxString& tx_stats);
int getConnectionState(); int getConnectionState();
void rptrQRG(const wxString& rptrcall, double txFrequency, double duplexShift, double range, double agl); void rptrQRG(const std::string &rptrcall, double txFrequency, double duplexShift, double range, double agl);
void rptrQTH(const wxString& rtprcall, double latitude, double longitude, const wxString& desc1, const wxString& desc2, const wxString& infoURL, const wxString &swVersion); void rptrQTH(const std::string &rtprcall, double latitude, double longitude, const std::string &desc1, const std::string &desc2, const std::string &infoURL, const std::string &swVersion);
void kickWatchdog( const wxString& wdInfo ); void kickWatchdog(const std::string &wdInfo);
protected: protected:
virtual wxThread::ExitCode Entry(); virtual void Entry();
private: private:
void doUpdate ( wxString& msg ); void doUpdate(std::string &msg);
void doNotFound ( wxString& msg, wxString& retval ); void doNotFound(std::string &msg, std::string &retval);
wxString getIPAddress( wxString& zonerp_cs ); std::string getIPAddress(std::string &zonerp_cs);
bool findServerUser(); bool findServerUser();
IRCDDBAppPrivate *d; IRCDDBAppPrivate *d;
std::future<void> worker_thread;
}; };
#endif

91
IRCMessage.cpp
Unescape View File

@ -1,44 +1,24 @@
/* //#include <string>
//#include <list>
CIRCDDB - ircDDB client library in C++
Copyright (C) 2010-2011 Michael Dirska, DL1BFF (dl1bff@mdx.de)
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 2 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 "IRCMessage.h" #include "IRCMessage.h"
IRCMessage::IRCMessage() IRCMessage::IRCMessage()
{ {
numParams = 0; numParams = 0;
prefixParsed = false; prefixParsed = false;
} }
IRCMessage::IRCMessage ( const wxString& toNick, const wxString& msg ) IRCMessage::IRCMessage(const std::string &toNick, const std::string &msg)
{ {
command = wxT("PRIVMSG"); command = "PRIVMSG";
numParams = 2; numParams = 2;
params.Add( toNick ); params.push_back(toNick);
params.Add( msg ); params.push_back(msg);
prefixParsed = false; prefixParsed = false;
} }
IRCMessage::IRCMessage ( const wxString& cmd ) IRCMessage::IRCMessage(const std::string &cmd)
{ {
command = cmd; command = cmd;
numParams = 0; numParams = 0;
@ -50,23 +30,23 @@ IRCMessage::~IRCMessage()
} }
void IRCMessage::addParam( const wxString& p ) void IRCMessage::addParam(const std::string &p)
{ {
params.Add( p ); params.push_back(p);
numParams = params.GetCount(); numParams = params.size();
} }
int IRCMessage::getParamCount() int IRCMessage::getParamCount()
{ {
return params.GetCount(); return params.size();
} }
wxString IRCMessage::getParam( int pos ) std::string IRCMessage::getParam(int pos)
{ {
return params[pos]; return params[pos];
} }
wxString IRCMessage::getCommand() std::string IRCMessage::getCommand()
{ {
return command; return command;
} }
@ -77,25 +57,25 @@ void IRCMessage::parsePrefix()
unsigned int i; unsigned int i;
for (i=0; i < 3; i++) { for (i=0; i < 3; i++) {
prefixComponents.Add(wxT("")); prefixComponents.push_back("");
} }
int state = 0; int state = 0;
for (i=0; i < prefix.Len(); i++) { for (i=0; i < prefix.length(); i++) {
wxChar c = prefix.GetChar(i); char c = prefix.at(i);
switch (c) { switch (c) {
case wxT('!'): case '!':
state = 1; // next is name state = 1; // next is name
break; break;
case wxT('@'): case '@':
state = 2; // next is host state = 2; // next is host
break; break;
default: default:
prefixComponents[state].Append(c); prefixComponents[state].append(1, c);
break; break;
} }
} }
@ -103,7 +83,7 @@ void IRCMessage::parsePrefix()
prefixParsed = true; prefixParsed = true;
} }
wxString& IRCMessage::getPrefixNick() std::string &IRCMessage::getPrefixNick()
{ {
if (!prefixParsed) { if (!prefixParsed) {
parsePrefix(); parsePrefix();
@ -112,7 +92,7 @@ wxString& IRCMessage::getPrefixNick()
return prefixComponents[0]; return prefixComponents[0];
} }
wxString& IRCMessage::getPrefixName() std::string &IRCMessage::getPrefixName()
{ {
if (!prefixParsed) { if (!prefixParsed) {
parsePrefix(); parsePrefix();
@ -121,7 +101,7 @@ wxString& IRCMessage::getPrefixName()
return prefixComponents[1]; return prefixComponents[1];
} }
wxString& IRCMessage::getPrefixHost() std::string &IRCMessage::getPrefixHost()
{ {
if (!prefixParsed) { if (!prefixParsed) {
parsePrefix(); parsePrefix();
@ -130,36 +110,25 @@ wxString& IRCMessage::getPrefixHost()
return prefixComponents[2]; return prefixComponents[2];
} }
void IRCMessage::composeMessage ( wxString& output ) void IRCMessage::composeMessage(std::string &output)
{ {
#if defined(DEBUG_IRC) std::string o;
wxString d = wxT("T [") + prefix + wxT("] [") + command + wxT("]");
for (int i=0; i < numParams; i++) {
d.Append(wxT(" [") + params[i] + wxT("]") );
}
d.Replace(wxT("%"), wxT("%%"), true);
d.Replace(wxT("\\"), wxT("\\\\"), true);
wxLogVerbose(d);
#endif
wxString o;
if (prefix.Len() > 0) { if (prefix.length() > 0) {
o = wxT(":") + prefix + wxT(" "); o = std::string(":") + prefix + ' ';
} }
o.Append(command); o += command;
for (int i=0; i < numParams; i++) { for (int i=0; i < numParams; i++) {
if (i == (numParams - 1)) { if (i == (numParams - 1)) {
o.Append(wxT(" :") + params[i]); o += (std::string(" :") + params[i]);
} else { } else {
o.Append(wxT(" ") + params[i]); o += (std::string(" ") + params[i]);
} }
} }
o.Append(wxT("\r\n")); o += std::string("\r\n");
output = o; output = o;
} }

65
IRCMessage.h
Unescape View File

@ -1,71 +1,38 @@
/* #pragma once
#include <string>
CIRCDDB - ircDDB client library in C++ #include <vector>
Copyright (C) 2010 Michael Dirska, DL1BFF (dl1bff@mdx.de)
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 2 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/>.
*/
#if !defined(_IRC_MESSAGE_H)
#define _IRC_MESSAGE_H
#include <wx/wx.h>
class IRCMessage class IRCMessage
{ {
public: public:
IRCMessage(); IRCMessage();
IRCMessage(const std::string& toNick, const std::string& msg);
IRCMessage( const wxString& toNick, const wxString& msg ); IRCMessage(const std::string& command);
IRCMessage( const wxString& command );
~IRCMessage(); ~IRCMessage();
std::string prefix;
std::string command;
wxString prefix; std::vector<std::string> params;
wxString command;
wxArrayString params;
int numParams; int numParams;
wxString& getPrefixNick(); std::string &getPrefixNick();
wxString& getPrefixName(); std::string &getPrefixName();
wxString& getPrefixHost(); std::string &getPrefixHost();
void composeMessage ( wxString& output ); void composeMessage (std::string& output);
void addParam( const wxString& p ); void addParam(const std::string &p);
wxString getCommand(); std::string getCommand();
wxString getParam( int pos ); std::string getParam(int pos);
int getParamCount(); int getParamCount();
private: private:
void parsePrefix(); void parsePrefix();
wxArrayString prefixComponents; std::vector<std::string> prefixComponents;
bool prefixParsed; bool prefixParsed;
}; };
#endif

46
IRCMessageQueue.cpp
Unescape View File

@ -1,24 +1,3 @@
/*
CIRCDDB - ircDDB client library in C++
Copyright (C) 2010 Michael Dirska, DL1BFF (dl1bff@mdx.de)
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 2 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 "IRCMessageQueue.h" #include "IRCMessageQueue.h"
@ -54,18 +33,24 @@ void IRCMessageQueue::signalEOF()
bool IRCMessageQueue::messageAvailable() bool IRCMessageQueue::messageAvailable()
{ {
wxMutexLocker lock(accessMutex); accessMutex.lock();
IRCMessageQueueItem *m = first;
return (first != NULL); accessMutex.unlock();
return (m != NULL);
} }
IRCMessage * IRCMessageQueue::peekFirst() IRCMessage * IRCMessageQueue::peekFirst()
{ {
wxMutexLocker lock(accessMutex); accessMutex.lock();
IRCMessageQueueItem * k = first; IRCMessageQueueItem * k = first;
accessMutex.unlock();
if ( k == NULL ) { if ( k == NULL ) {
return NULL; return NULL;
} }
@ -76,7 +61,7 @@ IRCMessage * IRCMessageQueue::peekFirst()
IRCMessage * IRCMessageQueue::getMessage() IRCMessage * IRCMessageQueue::getMessage()
{ {
wxMutexLocker lock(accessMutex); accessMutex.lock();
IRCMessageQueueItem * k; IRCMessageQueueItem * k;
@ -99,15 +84,17 @@ IRCMessage * IRCMessageQueue::getMessage()
delete k; delete k;
accessMutex.unlock();
return msg; return msg;
} }
void IRCMessageQueue::putMessage( IRCMessage * m ) void IRCMessageQueue::putMessage( IRCMessage * m )
{ {
wxMutexLocker lock(accessMutex); accessMutex.lock();
// wxLogVerbose(wxT("IRCMessageQueue::putMessage")); //traceit("IRCMessageQueue::putMessage\n");
IRCMessageQueueItem * k = new IRCMessageQueueItem(m); IRCMessageQueueItem * k = new IRCMessageQueueItem(m);
@ -121,8 +108,7 @@ void IRCMessageQueue::putMessage( IRCMessage * m )
} }
last = k; last = k;
}
accessMutex.unlock();
}

30
IRCMessageQueue.h
Unescape View File

@ -1,28 +1,6 @@
/* #pragma once
CIRCDDB - ircDDB client library in C++ #include <mutex>
Copyright (C) 2010 Michael Dirska, DL1BFF (dl1bff@mdx.de)
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 2 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/>.
*/
#if !defined(_IRCMESSAGEQUEUE_H)
#define _IRCMESSAGEQUEUE_H
#include <wx/wx.h>
#include "IRCMessage.h" #include "IRCMessage.h"
@ -70,8 +48,6 @@ private:
IRCMessageQueueItem * first; IRCMessageQueueItem * first;
IRCMessageQueueItem * last; IRCMessageQueueItem * last;
wxMutex accessMutex; std::mutex accessMutex;
}; };
#endif

206
IRCProtocol.cpp
Unescape View File

@ -1,63 +1,45 @@
/* #include <string>
#include <vector>
CIRCDDB - ircDDB client library in C++ #include <regex>
#include <mutex>
Copyright (C) 2010-2011 Michael Dirska, DL1BFF (dl1bff@mdx.de)
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 2 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 "IRCutils.h"
#include "IRCProtocol.h" #include "IRCProtocol.h"
#include <wx/regex.h> extern void traceit(const char *fmt,...);
#define CIRCDDB_VERSION "1.2.4" #define CIRCDDB_VERSION "2.0.0"
IRCProtocol::IRCProtocol ( IRCApplication * app, IRCProtocol::IRCProtocol(IRCApplication *app, const std::string &callsign, const std::string &password, const std::string &channel, const std::string &versionInfo)
const wxString& callsign, const wxString& password, const wxString& channel,
const wxString& versionInfo )
{ {
this->password = password; this->password = password;
this->channel = channel; this->channel = channel;
this->app = app; this->app = app;
this->versionInfo = wxT("CIRCDDB:"); this->versionInfo = "CIRCDDB:";
this->versionInfo.Append(wxT(CIRCDDB_VERSION)); this->versionInfo.append(CIRCDDB_VERSION);
if (versionInfo.Len() > 0) { if (versionInfo.length() > 0) {
this->versionInfo.Append(wxT(" ")); this->versionInfo.append(" ");
this->versionInfo.Append(versionInfo); this->versionInfo.append(versionInfo);
} }
int hyphenPos = callsign.find(wxT('-')); int hyphenPos = callsign.find('-');
if (hyphenPos == wxNOT_FOUND) { if (hyphenPos < 0) {
wxString n; std::string n;
n = callsign + wxT("-1"); n = callsign + "-1";
nicks.Add(n); nicks.push_back(n);
n = callsign + wxT("-2"); n = callsign + "-2";
nicks.Add(n); nicks.push_back(n);
n = callsign + wxT("-3"); n = callsign + "-3";
nicks.Add(n); nicks.push_back(n);
n = callsign + wxT("-4"); n = callsign + "-4";
nicks.Add(n); nicks.push_back(n);
} else { } else {
nicks.Add(callsign); nicks.push_back(callsign);
} }
name = callsign; name = callsign;
@ -76,7 +58,7 @@ IRCProtocol::~IRCProtocol()
void IRCProtocol::chooseNewNick() void IRCProtocol::chooseNewNick()
{ {
int r = rand() % nicks.GetCount(); int r = rand() % nicks.size();
currentNick = nicks[r]; currentNick = nicks[r];
} }
@ -84,9 +66,8 @@ void IRCProtocol::chooseNewNick()
void IRCProtocol::setNetworkReady(bool b) void IRCProtocol::setNetworkReady(bool b)
{ {
if (b == true) { if (b == true) {
if (state != 0) { if (state != 0)
wxLogError(wxT("IRCProtocol::setNetworkReady: unexpected state")); traceit("IRCProtocol::setNetworkReady: unexpected state");
}
state = 1; state = 1;
chooseNewNick(); chooseNewNick();
@ -106,39 +87,39 @@ bool IRCProtocol::processQueues ( IRCMessageQueue * recvQ, IRCMessageQueue * sen
IRCMessage *m = recvQ->getMessage(); IRCMessage *m = recvQ->getMessage();
#if defined(DEBUG_IRC) #if defined(DEBUG_IRC)
wxString d = wxT("R [") + m->prefix + wxT("] [") + m->command + wxT("]"); std::string d = std::string("R [") + m->prefix + std::string("] [") + m->command + std::string("]");
for (int i=0; i < m->numParams; i++) { for (int i=0; i < m->numParams; i++) {
d.Append(wxT(" [") + m->params[i] + wxT("]") ); d.append(std::string(" [") + m->params[i] + std::string("]") );
} }
d.Replace(wxT("%"), wxT("%%"), true); // d.Replace(std::string("%"), std::string("%%"), true);
d.Replace(wxT("\\"), wxT("\\\\"), true); // d.Replace(std::string("\\"), std::string("\\\\"), true);
wxLogVerbose(d); traceit("%s\n", d.c_str());
#endif #endif
if (m->command.IsSameAs(wxT("004"))) { if (0 == m->command.compare("004")) {
if (state == 4) { if (state == 4) {
if (m->params.GetCount() > 1) { if (m->params.size() > 1) {
wxRegEx serverNamePattern(wxT("^grp[1-9]s[1-9].ircDDB$")); std::regex serverNamePattern("^grp[1-9]s[1-9].ircDDB$");
if (serverNamePattern.Matches( m->params[1] )) { if (std::regex_match(m->params[1], serverNamePattern)) {
app->setBestServer(wxT("s-") + m->params[1].Mid(0,6)); app->setBestServer(std::string("s-") + m->params[1].substr(0,6));
} }
} }
state = 5; // next: JOIN state = 5; // next: JOIN
app->setCurrentNick(currentNick); app->setCurrentNick(currentNick);
} }
} else if (m->command.IsSameAs(wxT("PING"))) { } else if (0 == m->command.compare("PING")) {
IRCMessage *m2 = new IRCMessage(); IRCMessage *m2 = new IRCMessage();
m2->command = wxT("PONG"); m2->command = "PONG";
if (m->params.GetCount() > 0) { if (m->params.size() > 0) {
m2->numParams = 1; m2->numParams = 1;
m2->params.Add( m->params[0] ); m2->params.push_back( m->params[0] );
} }
sendQ -> putMessage(m2); sendQ -> putMessage(m2);
} else if (m->command.IsSameAs(wxT("JOIN"))) { } else if (0 == m->command.compare("JOIN")) {
if ((m->numParams >= 1) && m->params[0].IsSameAs(channel)) { if ((m->numParams >= 1) && 0==m->params[0].compare(channel)) {
if (m->getPrefixNick().IsSameAs(currentNick) && (state == 6)) { if (0==m->getPrefixNick().compare(currentNick) && (state == 6)) {
if (debugChannel.Len() > 0) { if (debugChannel.length() > 0) {
state = 7; // next: join debug_channel state = 7; // next: join debug_channel
} else { } else {
state = 10; // next: WHO * state = 10; // next: WHO *
@ -148,25 +129,25 @@ bool IRCProtocol::processQueues ( IRCMessageQueue * recvQ, IRCMessageQueue * sen
} }
} }
if ((m->numParams >= 1) && m->params[0].IsSameAs(debugChannel)) { if ((m->numParams >= 1) && 0==m->params[0].compare(debugChannel)) {
if (m->getPrefixNick().IsSameAs(currentNick) && (state == 8)) { if (0==m->getPrefixNick().compare(currentNick) && (state == 8)) {
state = 10; // next: WHO * state = 10; // next: WHO *
} }
} }
} else if (m->command.IsSameAs(wxT("PONG"))) { } else if (0 == m->command.compare("PONG")) {
if (state == 12) { if (state == 12) {
timer = pingTimer; timer = pingTimer;
state = 11; state = 11;
} }
} else if (m->command.IsSameAs(wxT("PART"))) { } else if (0 == m->command.compare("PART")) {
if ((m->numParams >= 1) && m->params[0].IsSameAs(channel)) { if ((m->numParams >= 1) && 0==m->params[0].compare(channel)) {
if (app != NULL) { if (app != NULL) {
app->userLeave( m->getPrefixNick() ); app->userLeave( m->getPrefixNick() );
} }
} }
} else if (m->command.IsSameAs(wxT("KICK"))) { } else if (0 == m->command.compare("KICK")) {
if ((m->numParams >= 2) && m->params[0].IsSameAs(channel)) { if ((m->numParams >= 2) && 0==m->params[0].compare(channel)) {
if (m->params[1].IsSameAs(currentNick)) { if (0 == m->params[1].compare(currentNick)) {
// i was kicked!! // i was kicked!!
delete m; delete m;
return false; return false;
@ -174,52 +155,49 @@ bool IRCProtocol::processQueues ( IRCMessageQueue * recvQ, IRCMessageQueue * sen
app->userLeave( m->params[1] ); app->userLeave( m->params[1] );
} }
} }
} else if (m->command.IsSameAs(wxT("QUIT"))) { } else if (0 == m->command.compare("QUIT")) {
if (app != NULL) { if (app != NULL) {
app->userLeave( m->getPrefixNick() ); app->userLeave( m->getPrefixNick() );
} }
} else if (m->command.IsSameAs(wxT("MODE"))) { } else if (0 == m->command.compare("MODE")) {
if ((m->numParams >= 3) && m->params[0].IsSameAs(channel)) { if ((m->numParams >= 3) && 0==m->params[0].compare(channel)) {
if (app != NULL) { if (app != NULL) {
size_t i; size_t i;
wxString mode = m->params[1]; std::string mode = m->params[1];
for (i = 1; (i < mode.Len()) && ((size_t) m->numParams >= (i+2)); i++) { for (i=1; i<mode.length() && (size_t)m->numParams>=(i+2); i++) {
if ( mode[i] == wxT('o') ) { if (mode[i] == 'o') {
if ( mode[0] == wxT('+') ) { if (mode[0] == '+') {
app->userChanOp(m->params[i+1], true); app->userChanOp(m->params[i+1], true);
} else if ( mode[0] == wxT('-') ) { } else if (mode[0] == '-') {
app->userChanOp(m->params[i+1], false); app->userChanOp(m->params[i+1], false);
} }
} }
} // for } // for
} }
} }
} else if (m->command.IsSameAs(wxT("PRIVMSG"))) { } else if (0 == m->command.compare("PRIVMSG")) {
if ((m->numParams == 2) && (app != NULL)) { if ((m->numParams == 2) && (app != NULL)) {
if (m->params[0].IsSameAs(channel)) { if (0 == m->params[0].compare(channel)) {
app->msgChannel(m); app->msgChannel(m);
} else if (m->params[0].IsSameAs(currentNick)) { } else if (0 == m->params[0].compare(currentNick)) {
app->msgQuery(m); app->msgQuery(m);
} }
} }
} else if (m->command.IsSameAs(wxT("352"))) { // WHO list } else if (0 == m->command.compare("352")) { // WHO list
if ((m->numParams >= 7) && m->params[0].IsSameAs(currentNick) if ((m->numParams >= 7) && 0==m->params[0].compare(currentNick) && 0==m->params[1].compare(channel)) {
&& m->params[1].IsSameAs(channel)) {
if (app != NULL) { if (app != NULL) {
app->userJoin(m->params[5], m->params[2], m->params[3]); app->userJoin(m->params[5], m->params[2], m->params[3]);
app->userChanOp ( m->params[5], m->params[6].IsSameAs(wxT("H@"))); app->userChanOp (m->params[5], 0==m->params[6].compare("H@"));
} }
} }
} else if (m->command.IsSameAs(wxT("433"))) { // nick collision } else if (0 == m->command.compare("433")) { // nick collision
if (state == 2) { if (state == 2) {
state = 3; // nick collision, choose new nick state = 3; // nick collision, choose new nick
timer = 10; // wait 5 seconds.. timer = 10; // wait 5 seconds..
} }
} else if (m->command.IsSameAs(wxT("332")) || } else if (0==m->command.compare("332") || 0==m->command.compare("TOPIC")) { // topic
m->command.IsSameAs(wxT("TOPIC"))) { // topic if ((m->numParams == 2) && (app != NULL) && 0==m->params[0].compare(channel)) {
if ((m->numParams == 2) && (app != NULL) &&
m->params[0].IsSameAs(channel) ) {
app->setTopic(m->params[1]); app->setTopic(m->params[1]);
} }
} }
@ -232,15 +210,15 @@ bool IRCProtocol::processQueues ( IRCMessageQueue * recvQ, IRCMessageQueue * sen
switch (state) { switch (state) {
case 1: case 1:
m = new IRCMessage(); m = new IRCMessage();
m->command = wxT("PASS"); m->command = "PASS";
m->numParams = 1; m->numParams = 1;
m->params.Add(password); m->params.push_back(password);
sendQ->putMessage(m); sendQ->putMessage(m);
m = new IRCMessage(); m = new IRCMessage();
m->command = wxT("NICK"); m->command = "NICK";
m->numParams = 1; m->numParams = 1;
m->params.Add(currentNick); m->params.push_back(currentNick);
sendQ->putMessage(m); sendQ->putMessage(m);
timer = 10; // wait for possible nick collision message timer = 10; // wait for possible nick collision message
@ -250,12 +228,12 @@ bool IRCProtocol::processQueues ( IRCMessageQueue * recvQ, IRCMessageQueue * sen
case 2: case 2:
if (timer == 0) { if (timer == 0) {
m = new IRCMessage(); m = new IRCMessage();
m->command = wxT("USER"); m->command = "USER";
m->numParams = 4; m->numParams = 4;
m->params.Add(name); m->params.push_back(name);
m->params.Add(wxT("0")); m->params.push_back("0");
m->params.Add(wxT("*")); m->params.push_back("*");
m->params.Add(versionInfo); m->params.push_back(versionInfo);
sendQ->putMessage(m); sendQ->putMessage(m);
timer = 30; timer = 30;
@ -267,9 +245,9 @@ bool IRCProtocol::processQueues ( IRCMessageQueue * recvQ, IRCMessageQueue * sen
if (timer == 0) { if (timer == 0) {
chooseNewNick(); chooseNewNick();
m = new IRCMessage(); m = new IRCMessage();
m->command = wxT("NICK"); m->command = "NICK";
m->numParams = 1; m->numParams = 1;
m->params.Add(currentNick); m->params.push_back(currentNick);
sendQ->putMessage(m); sendQ->putMessage(m);
timer = 10; // wait for possible nick collision message timer = 10; // wait for possible nick collision message
@ -286,9 +264,9 @@ bool IRCProtocol::processQueues ( IRCMessageQueue * recvQ, IRCMessageQueue * sen
case 5: case 5:
m = new IRCMessage(); m = new IRCMessage();
m->command = wxT("JOIN"); m->command = "JOIN";
m->numParams = 1; m->numParams = 1;
m->params.Add(channel); m->params.push_back(channel);
sendQ->putMessage(m); sendQ->putMessage(m);
timer = 30; timer = 30;
@ -303,14 +281,14 @@ bool IRCProtocol::processQueues ( IRCMessageQueue * recvQ, IRCMessageQueue * sen
break; break;
case 7: case 7:
if (debugChannel.Len() == 0) { if (debugChannel.length() == 0) {
return false; // this state cannot be processed if there is no debug_channel return false; // this state cannot be processed if there is no debug_channel
} }
m = new IRCMessage(); m = new IRCMessage();
m->command = wxT("JOIN"); m->command = "JOIN";
m->numParams = 1; m->numParams = 1;
m->params.Add(debugChannel); m->params.push_back(debugChannel);
sendQ->putMessage(m); sendQ->putMessage(m);
timer = 30; timer = 30;
@ -326,10 +304,10 @@ bool IRCProtocol::processQueues ( IRCMessageQueue * recvQ, IRCMessageQueue * sen
case 10: case 10:
m = new IRCMessage(); m = new IRCMessage();
m->command = wxT("WHO"); m->command = "WHO";
m->numParams = 2; m->numParams = 2;
m->params.Add(channel); m->params.push_back(channel);
m->params.Add(wxT("*")); m->params.push_back("*");
sendQ->putMessage(m); sendQ->putMessage(m);
timer = pingTimer; timer = pingTimer;
@ -343,9 +321,9 @@ bool IRCProtocol::processQueues ( IRCMessageQueue * recvQ, IRCMessageQueue * sen
case 11: case 11:
if (timer == 0) { if (timer == 0) {
m = new IRCMessage(); m = new IRCMessage();
m->command = wxT("PING"); m->command = "PING";
m->numParams = 1; m->numParams = 1;
m->params.Add(currentNick); m->params.push_back(currentNick);
sendQ->putMessage(m); sendQ->putMessage(m);
timer = pingTimer; timer = pingTimer;

48
IRCProtocol.h
Unescape View File

@ -1,39 +1,12 @@
/* #pragma once
CIRCDDB - ircDDB client library in C++
Copyright (C) 2010 Michael Dirska, DL1BFF (dl1bff@mdx.de)
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 2 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/>.
*/
#if !defined(_IRCPROTOCOL_H)
#define _IRCPROTOCOL_H
#include <wx/wx.h>
#include "IRCMessageQueue.h" #include "IRCMessageQueue.h"
#include "IRCApplication.h" #include "IRCApplication.h"
class IRCProtocol class IRCProtocol
{ {
public: public:
IRCProtocol ( IRCApplication * app, IRCProtocol(IRCApplication * app, const std::string &callsign, const std::string &password, const std::string &channel, const std::string &versionInfo);
const wxString& callsign, const wxString& password, const wxString& channel,
const wxString& versionInfo );
~IRCProtocol(); ~IRCProtocol();
@ -44,22 +17,19 @@ public:
private: private:
void chooseNewNick(); void chooseNewNick();
wxArrayString nicks; std::vector<std::string> nicks;
wxString password; std::string password;
wxString channel; std::string channel;
wxString name; std::string name;
wxString currentNick; std::string currentNick;
wxString versionInfo; std::string versionInfo;
int state; int state;
int timer; int timer;
int pingTimer; int pingTimer;
wxString debugChannel; std::string debugChannel;
IRCApplication *app; IRCApplication *app;
}; };
#endif

144
IRCReceiver.cpp
Unescape View File

@ -1,81 +1,11 @@
/*
CIRCDDB - ircDDB client library in C++
Copyright (C) 2010 Michael Dirska, DL1BFF (dl1bff@mdx.de)
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 2 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/>.
*/
#if defined(WIN32)
#define WIN32_LEAN_AND_MEAN
#include <winsock2.h>
#include <ws2tcpip.h>
#else
#include <sys/types.h> #include <sys/types.h>
#include <sys/socket.h> #include <sys/socket.h>
#endif #include "IRCutils.h"
#include "IRCMessage.h"
#include "IRCReceiver.h" #include "IRCReceiver.h"
#include <wx/wx.h>
IRCReceiver::IRCReceiver(int sock, IRCMessageQueue * q )
: wxThread(wxTHREAD_JOINABLE)
{
this->sock = sock;
recvQ = q;
}
IRCReceiver::~IRCReceiver()
{
}
bool IRCReceiver::startWork()
{
if (Create() != wxTHREAD_NO_ERROR) {
wxLogError(wxT("IRCReceiver::startWork: Could not create the worker thread!"));
return false;
}
terminateThread = false;
if (Run() != wxTHREAD_NO_ERROR) {
wxLogError(wxT("IRCReceiver::startWork: Could not run the worker thread!"));
return false;
}
return true;
}
void IRCReceiver::stopWork()
{
terminateThread = true;
Wait();
}
static int doRead(int sock, char * buf, int buf_size) static int doRead(int sock, char * buf, int buf_size)
{ {
struct timeval tv; struct timeval tv;
@ -94,11 +24,11 @@ static int doRead( int sock, char * buf, int buf_size )
res = select(sock+1, &rdset, NULL, &errset, &tv); res = select(sock+1, &rdset, NULL, &errset, &tv);
if ( res < 0 ) { if ( res < 0 ) {
wxLogSysError(wxT("IRCReceiver::doRead: select")); traceit("IRCReceiver::doread: select() error.\n");
return -1; return -1;
} else if ( res > 0 ) { } else if ( res > 0 ) {
if (FD_ISSET(sock, &errset)) { if (FD_ISSET(sock, &errset)) {
wxLogVerbose(wxT("IRCReceiver::doRead: select (FD_ISSET(sock, exceptfds))")); traceit("IRCReceiver::doRead: FD_ISSET error\n");
return -1; return -1;
} }
@ -106,22 +36,21 @@ static int doRead( int sock, char * buf, int buf_size )
res = recv(sock, buf, buf_size, 0); res = recv(sock, buf, buf_size, 0);
if (res < 0) { if (res < 0) {
wxLogSysError(wxT("IRCReceiver::doRead: read")); traceit("IRCReceiver::doRead: recv error\n");
return -1; return -1;
} else if (res == 0) { } else if (res == 0) {
wxLogVerbose(wxT("IRCReceiver::doRead: EOF read==0")); traceit("IRCReceiver::doRead: EOF read==0\n");
return -1; return -1;
} else { } else
return res; return res;
} }
}
} }
return 0; return 0;
} }
wxThread::ExitCode IRCReceiver::Entry () void IRCReceiver::Entry()
{ {
IRCMessage *m = new IRCMessage(); IRCMessage *m = new IRCMessage();
@ -129,9 +58,6 @@ wxThread::ExitCode IRCReceiver::Entry ()
int state = 0; int state = 0;
while (!terminateThread) { while (!terminateThread) {
// wxLogVerbose(wxT("IRCReceiver: tick"));
char buf[200]; char buf[200];
int r = doRead(sock, buf, sizeof buf); int r = doRead(sock, buf, sizeof buf);
@ -145,67 +71,87 @@ wxThread::ExitCode IRCReceiver::Entry ()
char b = buf[i]; char b = buf[i];
if (b > 0) { if (b > 0) {
if (b == 10) { if (b == '\n') {
recvQ->putMessage(m); recvQ->putMessage(m);
m = new IRCMessage(); m = new IRCMessage();
state = 0; state = 0;
} else if (b == 13) { } else if (b == '\r') {
// do nothing // do nothing
} else switch (state) { } else switch (state) {
case 0: case 0:
if (b == ':') { if (b == ':') {
state = 1; // prefix state = 1; // prefix
} else if (b == 32) { } else if (b == ' ') {
// do nothing // do nothing
} else { } else {
m -> command.Append(wxChar(b)); m->command.push_back(b);
state = 2; // command state = 2; // command
} }
break; break;
case 1: case 1:
if (b == 32) { if (b == ' ') {
state = 2; // command is next state = 2; // command is next
} else { } else {
m -> prefix.Append(wxChar(b)); m->prefix.push_back(b);
} }
break; break;
case 2: case 2:
if (b == 32) { if (b == ' ') {
state = 3; // params state = 3; // params
m->numParams = 1; m->numParams = 1;
m -> params.Add(wxT("")); m->params.push_back("");
} else { } else {
m -> command.Append(wxChar(b)); m->command.push_back(b);
} }
break; break;
case 3: case 3:
if (b == 32) { if (b == ' ') {
m->numParams++; m->numParams++;
if (m->numParams >= 15) { if (m->numParams >= 15) {
state = 5; // ignore the rest state = 5; // ignore the rest
} }
m -> params.Add(wxT("")); m->params.push_back("");
} else if ((b == ':') && (m -> params[ m -> numParams-1 ].Len() == 0)) { } else if ((b == ':') && (m->params[m->numParams - 1].length() == 0)) {
state = 4; // rest of line is this param state = 4; // rest of line is this param
} else { } else {
m -> params[ m -> numParams-1 ].Append(wxChar(b)); m->params[m->numParams - 1].push_back(b);
} }
break; break;
case 4: case 4:
m -> params[ m -> numParams-1 ].Append(wxChar(b)); m->params[m->numParams - 1].push_back(b);
break; break;
} // switch } // switch
} // if } // if
} // for } // for
} // while } // while
return 0; return;
} }
IRCReceiver::IRCReceiver(int sock, IRCMessageQueue *q)
{
this->sock = sock;
recvQ = q;
}
IRCReceiver::~IRCReceiver()
{
}
bool IRCReceiver::startWork()
{
terminateThread = false;
rec_thread = std::async(std::launch::async, &IRCReceiver::Entry, this);
return true;
}
void IRCReceiver::stopWork()
{
terminateThread = true;
rec_thread.get();
}

53
IRCReceiver.h
Unescape View File

@ -1,62 +1,21 @@
/* #pragma once
#include <future>
CIRCDDB - ircDDB client library in C++
Copyright (C) 2010 Michael Dirska, DL1BFF (dl1bff@mdx.de)
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 2 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/>.
*/
#if !defined(_IRCRECEIVER_H)
#define _IRCRECEIVER_H
#include <wx/wx.h>
#include "IRCMessageQueue.h" #include "IRCMessageQueue.h"
class IRCReceiver
class IRCReceiver : public wxThread
{ {
public: public:
IRCReceiver(int sock, IRCMessageQueue *q); IRCReceiver(int sock, IRCMessageQueue *q);
virtual ~IRCReceiver();
~IRCReceiver();
bool startWork(); bool startWork();
void stopWork(); void stopWork();
protected: protected:
virtual void Entry();
virtual wxThread::ExitCode Entry();
private: private:
bool terminateThread; bool terminateThread;
int sock; int sock;
IRCMessageQueue *recvQ; IRCMessageQueue *recvQ;
std::future<void> rec_thread;
}; };
#endif

148
IRCutils.cpp
Unescape View File

@ -1,49 +1,41 @@
/*
CIRCDDB - ircDDB client library in C++
Copyright (C) 2010-2011 Michael Dirska, DL1BFF (dl1bff@mdx.de)
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 2 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/>.
*/
#if defined(WIN32)
#define WIN32_LEAN_AND_MEAN
#include <winsock2.h>
#include <ws2tcpip.h>
#else
#include <sys/types.h> #include <sys/types.h>
#include <sys/socket.h> #include <sys/socket.h>
#include <netdb.h> #include <netdb.h>
#include <cstdio>
#endif #include <cstring>
#include <cstdlib>
#include <cstdarg>
#include <ctime>
#include <wx/wx.h> #include <string>
#include <vector>
#include <iostream>
#include <istream>
#include <ostream>
#include <iterator>
#include <sstream>
#include <algorithm>
#include "IRCutils.h" #include "IRCutils.h"
// not needed, defined in /usr/include/features.h
//#define _XOPEN_SOURCE
time_t parseTime(const std::string str)
{
struct tm stm;
strptime(str.c_str(), "%Y-%m-%d %H:%M:%S", &stm);
return mktime(&stm);
}
int getAllIPV4Addresses ( const char * name, unsigned short port, std::vector<std::string> stringTokenizer(const std::string &s)
unsigned int * num, struct sockaddr_in * addr, unsigned int max_addr ) {
std::stringstream ss(s);
std::istream_iterator<std::string> it(ss);
std::istream_iterator<std::string> end;
std::vector<std::string> result(it, end);
return result;
}
int getAllIPV4Addresses(const char * name, unsigned short port, unsigned int * num, struct sockaddr_in * addr, unsigned int max_addr)
{ {
struct addrinfo hints; struct addrinfo hints;
@ -60,23 +52,20 @@ int getAllIPV4Addresses ( const char * name, unsigned short port,
unsigned int numAddr = 0; unsigned int numAddr = 0;
for (rp = res; rp != NULL; rp = rp->ai_next) { for (rp = res; rp != NULL; rp = rp->ai_next) {
if (rp->ai_family == AF_INET) { if (rp->ai_family == AF_INET)
numAddr ++; numAddr ++;
} }
}
if (numAddr > 0) { if (numAddr > 0) {
if (numAddr > max_addr) { if (numAddr > max_addr)
numAddr = max_addr; numAddr = max_addr;
}
int * shuffle = new int[numAddr]; int * shuffle = new int[numAddr];
unsigned int i; unsigned int i;
for (i=0; i < numAddr; i++) { for (i=0; i < numAddr; i++)
shuffle[i] = i; shuffle[i] = i;
}
for (i=0; i < (numAddr - 1); i++) { for (i=0; i < (numAddr - 1); i++) {
if (rand() & 1) { if (rand() & 1) {
@ -116,9 +105,7 @@ int getAllIPV4Addresses ( const char * name, unsigned short port,
return 0; return 0;
} else { } else {
wxString e( gai_strerror(r), wxConvUTF8); traceit("getaddrinfo: %s\n", gai_strerror(r));
wxLogWarning(wxT("getaddrinfo: ") + e );
return 1; return 1;
} }
@ -126,15 +113,11 @@ int getAllIPV4Addresses ( const char * name, unsigned short port,
} }
void safeStringCopy (char *dest, const char *src, unsigned int buf_size) void safeStringCopy (char *dest, const char *src, unsigned int buf_size)
{ {
unsigned int i = 0; unsigned int i = 0;
while (i < (buf_size - 1) && (src[i] != 0)) { while (i<(buf_size - 1) && src[i] != 0) {
dest[i] = src[i]; dest[i] = src[i];
i++; i++;
} }
@ -142,24 +125,65 @@ void safeStringCopy (char * dest, const char * src, unsigned int buf_size)
dest[i] = 0; dest[i] = 0;
} }
char *getCurrentTime(void)
wxString getCurrentTime(void)
{ {
time_t now = time(NULL); time_t now = time(NULL);
struct tm* tm; struct tm* tm;
struct tm tm_buf; struct tm tm_buf;
char buffer[25]; static char buffer[25];
#if defined(__WINDOWS__)
gmtime_s(&tm_buf, &now);
tm = &tm_buf;
#else
gmtime_r(&now, &tm_buf); gmtime_r(&now, &tm_buf);
tm = &tm_buf; tm = &tm_buf;
#endif
strftime(buffer, sizeof buffer, "%Y-%m-%d %H:%M:%S", tm); strftime(buffer, sizeof buffer, "%Y-%m-%d %H:%M:%S", tm);
return wxString(buffer, wxConvLocal); return buffer;
}
void traceit(const char *fmt,...)
{
time_t ltime;
struct tm tm;
const short BFSZ = 512;
char buf[BFSZ];
time(&ltime);
localtime_r(&ltime, &tm);
snprintf(buf,BFSZ - 1,"%02d/%02d/%02d %d:%02d:%02d:",
tm.tm_mon+1,tm.tm_mday,tm.tm_year % 100,
tm.tm_hour,tm.tm_min,tm.tm_sec);
va_list args;
va_start(args,fmt);
vsnprintf(buf + strlen(buf), BFSZ - strlen(buf) -1, fmt, args);
va_end(args);
fprintf(stdout, "%s", buf);
return;
} }
void ToUpper(std::string &str)
{
for (auto it=str.begin(); it!=str.end(); it++) {
if (islower(*it))
*it = toupper(*it);
}
}
void ToLower(std::string &str)
{
for (auto it=str.begin(); it!=str.end(); it++) {
if (isupper(*it))
*it = tolower(*it);
}
}
void ReplaceChar(std::string &str, char from, char to)
{
for (auto it=str.begin(); it!=str.end(); it++) {
if (from == *it)
*it = to;
}
}

34
IRCutils.h
Unescape View File

@ -1,31 +1,23 @@
/* #pragma once
CIRCDDB - ircDDB client library in C++ #include <string>
#include <vector>
#include <ctime>
Copyright (C) 2010 Michael Dirska, DL1BFF (dl1bff@mdx.de) time_t parseTime(const std::string str);
This program is free software: you can redistribute it and/or modify std::vector<std::string> stringTokenizer(const std::string &str);
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 2 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/>.
*/
int getAllIPV4Addresses(const char *name, unsigned short port, unsigned int *num, struct sockaddr_in *addr, unsigned int max_addr);
void safeStringCopy (char * dest, const char * src, unsigned int buf_size);
int getAllIPV4Addresses ( const char * name, unsigned short port, char *getCurrentTime(void);
unsigned int * num, struct sockaddr_in * addr, unsigned int max_addr );
void traceit(const char *fmt,...);
void safeStringCopy (char * dest, const char * src, unsigned int buf_size); void ToUpper(std::string &str);
wxString getCurrentTime(void); void ToLower(std::string &str);
void ReplaceChar(std::string &str, char from, char to);

15
Makefile
Unescape View File

@ -20,8 +20,8 @@ BINDIR=/usr/local/bin
CFGDIR=/usr/local/etc CFGDIR=/usr/local/etc
LOGDIR=/var/log LOGDIR=/var/log
CPPFLAGS=-W -Wall -I/usr/include `wx-config --cppflags base` CPPFLAGS=-W -Wall -I/usr/include -std=c++11
LDFLAGS=-L/usr/lib `wx-config --libs base` -lconfig++ LDFLAGS=-L/usr/lib -lconfig++
PROGRAMS=g2_ircddb g2_link dvap_rptr dvrptr g2link_test g2link_test_audio PROGRAMS=g2_ircddb g2_link dvap_rptr dvrptr g2link_test g2link_test_audio
@ -41,19 +41,22 @@ dvap_rptr : dvap_rptr.cpp dstar_dv.o golay23.o versions.h
dvrptr : dvrptr.cpp dstar_dv.o golay23.o dvrptr : dvrptr.cpp dstar_dv.o golay23.o
g++ -W -Wall -o dvrptr dvrptr.cpp golay23.o dstar_dv.o -I/usr/include -L/usr/lib -lconfig++ -lrt g++ -W -Wall -o dvrptr dvrptr.cpp golay23.o dstar_dv.o -I/usr/include -L/usr/lib -lconfig++ -lrt
IRCDDB.o : IRCDDB.cpp IRCDDB.h IRCutils.o : IRCutils.cpp IRCutils.h
g++ $(CPPFLAGS) -c $(CPPFLAGS) IRCDDB.cpp g++ -c $(CPPFLAGS) IRCutils.cpp
IRCDDB.o : IRCDDB.cpp IRCDDB.h IRCutils.h
g++ -c $(CPPFLAGS) IRCDDB.cpp
IRCClient.o : IRCClient.cpp IRCClient.h IRCutils.h IRCClient.o : IRCClient.cpp IRCClient.h IRCutils.h
g++ -c $(CPPFLAGS) IRCClient.cpp g++ -c $(CPPFLAGS) IRCClient.cpp
IRCReceiver.o : IRCReceiver.cpp IRCReceiver.h IRCMessageQueue.h IRCReceiver.o : IRCReceiver.cpp IRCReceiver.h IRCMessageQueue.h IRCutils.h
g++ -c $(CPPFLAGS) IRCReceiver.cpp g++ -c $(CPPFLAGS) IRCReceiver.cpp
IRCMessageQueue.o : IRCMessageQueue.cpp IRCMessageQueue.h IRCMessage.h IRCMessageQueue.o : IRCMessageQueue.cpp IRCMessageQueue.h IRCMessage.h
g++ -c $(CPPFLAGS) IRCMessageQueue.cpp g++ -c $(CPPFLAGS) IRCMessageQueue.cpp
IRCProtocol.o : IRCProtocol.cpp IRCProtocol.h IRCProtocol.o : IRCProtocol.cpp IRCProtocol.h IRCutils.h
g++ -c $(CPPFLAGS) IRCProtocol.cpp g++ -c $(CPPFLAGS) IRCProtocol.cpp
IRCMessage.o : IRCMessage.cpp IRCMessage.h IRCMessage.o : IRCMessage.cpp IRCMessage.h

27
dvap_rptr.cpp
Unescape View File

@ -43,7 +43,6 @@
#include <string> #include <string>
#include <libconfig.h++> #include <libconfig.h++>
using namespace std;
using namespace libconfig; using namespace libconfig;
#define VERSION DVAP_VERSION #define VERSION DVAP_VERSION
@ -394,7 +393,7 @@ bool get_value(const Config &cfg, const char *path, bool &value, bool default_va
return true; return true;
} }
bool get_value(const Config &cfg, const char *path, string &value, int min, int max, const char *default_value) bool get_value(const Config &cfg, const char *path, std::string &value, int min, int max, const char *default_value)
{ {
if (cfg.lookupValue(path, value)) { if (cfg.lookupValue(path, value)) {
int l = value.length(); int l = value.length();
@ -428,7 +427,7 @@ static int read_config(const char *cfgFile)
return 1; return 1;
} }
string dvap_path, value; std::string dvap_path, value;
for (i=0; i<3; i++) { for (i=0; i<3; i++) {
dvap_path = "module."; dvap_path = "module.";
dvap_path += ('a' + i); dvap_path += ('a' + i);
@ -443,7 +442,7 @@ static int read_config(const char *cfgFile)
} }
RPTR_MOD = 'A' + i; RPTR_MOD = 'A' + i;
if (cfg.lookupValue(string(dvap_path+".callsign").c_str(), value) || cfg.lookupValue("ircddb.login", value)) { if (cfg.lookupValue(std::string(dvap_path+".callsign").c_str(), value) || cfg.lookupValue("ircddb.login", value)) {
int l = value.length(); int l = value.length();
if (l<3 || l>CALL_SIZE-2) { if (l<3 || l>CALL_SIZE-2) {
traceit("Call '%s' is invalid length!\n", value.c_str()); traceit("Call '%s' is invalid length!\n", value.c_str());
@ -481,7 +480,7 @@ static int read_config(const char *cfgFile)
return 1; return 1;
} }
if (get_value(cfg, string(dvap_path+".invalid_prefix").c_str(), value, 1, CALL_SIZE, "XXX")) { if (get_value(cfg, std::string(dvap_path+".invalid_prefix").c_str(), value, 1, CALL_SIZE, "XXX")) {
if (islower(value[i])) if (islower(value[i]))
value[i] = toupper(value[i]); value[i] = toupper(value[i]);
value.resize(CALL_SIZE, ' '); value.resize(CALL_SIZE, ' ');
@ -489,13 +488,13 @@ static int read_config(const char *cfgFile)
} else } else
return 1; return 1;
if (get_value(cfg, string(dvap_path+".internal_ip").c_str(), value, 7, IP_SIZE, "0.0.0.0")) if (get_value(cfg, std::string(dvap_path+".internal_ip").c_str(), value, 7, IP_SIZE, "0.0.0.0"))
strcpy(RPTR_VIRTUAL_IP, value.c_str()); strcpy(RPTR_VIRTUAL_IP, value.c_str());
else else
return 1; return 1;
i = 19998 + (RPTR_MOD - 'A'); i = 19998 + (RPTR_MOD - 'A');
get_value(cfg, string(dvap_path+".port").c_str(), RPTR_PORT, 10000, 65535, i); get_value(cfg, std::string(dvap_path+".port").c_str(), RPTR_PORT, 10000, 65535, i);
if (get_value(cfg, "gateway.ip", value, 7, IP_SIZE, "127.0.0.1")) if (get_value(cfg, "gateway.ip", value, 7, IP_SIZE, "127.0.0.1"))
strcpy(G2_INTERNAL_IP, value.c_str()); strcpy(G2_INTERNAL_IP, value.c_str());
@ -506,7 +505,7 @@ static int read_config(const char *cfgFile)
get_value(cfg, "gateway.internal.port", G2_PORT, 10000, 65535, 19000); get_value(cfg, "gateway.internal.port", G2_PORT, 10000, 65535, 19000);
if (get_value(cfg, string(dvap_path+".serial_number").c_str(), value, 8, 10, "APXXXXXX")) if (get_value(cfg, std::string(dvap_path+".serial_number").c_str(), value, 8, 10, "APXXXXXX"))
strcpy(DVP_SERIAL, value.c_str()); strcpy(DVP_SERIAL, value.c_str());
else { else {
traceit("%s.serial_number '%s' is invalid!\n", dvap_path.c_str(), value.c_str()); traceit("%s.serial_number '%s' is invalid!\n", dvap_path.c_str(), value.c_str());
@ -514,19 +513,19 @@ static int read_config(const char *cfgFile)
} }
double f; double f;
get_value(cfg, string(dvap_path+".frequency").c_str(), f, 100.0, 1400.0, 145.5); get_value(cfg, std::string(dvap_path+".frequency").c_str(), f, 100.0, 1400.0, 145.5);
DVP_FREQ = (u_int32_t)(1.0e6*f); DVP_FREQ = (u_int32_t)(1.0e6*f);
get_value(cfg, string(dvap_path+".power").c_str(), i, -12, 10, 10); get_value(cfg, std::string(dvap_path+".power").c_str(), i, -12, 10, 10);
DVP_PWR = (int16_t)i; DVP_PWR = (int16_t)i;
get_value(cfg, string(dvap_path+".squelch").c_str(), i, -128, -45, -100); get_value(cfg, std::string(dvap_path+".squelch").c_str(), i, -128, -45, -100);
DVP_SQL = (char)i; DVP_SQL = (char)i;
get_value(cfg, string(dvap_path+".offset").c_str(), i, -2000, 2000, 0.0); get_value(cfg, std::string(dvap_path+".offset").c_str(), i, -2000, 2000, 0.0);
DVP_OFF = (int16_t)i; DVP_OFF = (int16_t)i;
get_value(cfg, string(dvap_path+".packet_wait").c_str(), WAIT_FOR_PACKETS, 6, 100, 25); get_value(cfg, std::string(dvap_path+".packet_wait").c_str(), WAIT_FOR_PACKETS, 6, 100, 25);
get_value(cfg, "timing.timeout.remote_g2", REMOTE_TIMEOUT, 1, 10, 2); get_value(cfg, "timing.timeout.remote_g2", REMOTE_TIMEOUT, 1, 10, 2);
@ -534,7 +533,7 @@ static int read_config(const char *cfgFile)
get_value(cfg, "timing.play.wait", DELAY_BEFORE, 1, 10, 2); get_value(cfg, "timing.play.wait", DELAY_BEFORE, 1, 10, 2);
get_value(cfg, string(dvap_path+".acknowledge").c_str(), RPTR_ACK, false); get_value(cfg, std::string(dvap_path+".acknowledge").c_str(), RPTR_ACK, false);
inactiveMax = (REMOTE_TIMEOUT * 1000) / WAIT_FOR_PACKETS; inactiveMax = (REMOTE_TIMEOUT * 1000) / WAIT_FOR_PACKETS;
traceit("Max loops = %d\n", inactiveMax); traceit("Max loops = %d\n", inactiveMax);

35
dvrptr.cpp
Unescape View File

@ -25,7 +25,6 @@
#include <string> #include <string>
#include <libconfig.h++> #include <libconfig.h++>
using namespace std;
using namespace libconfig; using namespace libconfig;
#define VERSION DVRPTR_VERSION #define VERSION DVRPTR_VERSION
@ -1837,7 +1836,7 @@ bool get_value(const Config &cfg, const char *path, bool &value, bool default_va
return true; return true;
} }
bool get_value(const Config &cfg, const char *path, string &value, int min, int max, const char *default_value) bool get_value(const Config &cfg, const char *path, std::string &value, int min, int max, const char *default_value)
{ {
if (cfg.lookupValue(path, value)) { if (cfg.lookupValue(path, value)) {
int l = value.length(); int l = value.length();
@ -1871,7 +1870,7 @@ static int read_config(const char *cfgFile)
return 1; return 1;
} }
string path, value; std::string path, value;
for (i=0; i<3; i++) { for (i=0; i<3; i++) {
path = "module."; path = "module.";
path += ('a' + i); path += ('a' + i);
@ -1886,7 +1885,7 @@ static int read_config(const char *cfgFile)
} }
DVRPTR_MOD = 'A' + i; DVRPTR_MOD = 'A' + i;
if (cfg.lookupValue(string(path+".callsign").c_str(), value) || cfg.lookupValue("ircddb.login", value)) { if (cfg.lookupValue(std::string(path+".callsign").c_str(), value) || cfg.lookupValue("ircddb.login", value)) {
int l = value.length(); int l = value.length();
if (l<3 || l>CALL_SIZE-2) { if (l<3 || l>CALL_SIZE-2) {
logdata("Call '%s' is invalid length!\n", value.c_str()); logdata("Call '%s' is invalid length!\n", value.c_str());
@ -1924,12 +1923,12 @@ static int read_config(const char *cfgFile)
return 1; return 1;
} }
if (get_value(cfg, string(path+".rf_control.on").c_str(), value, 0, CALL_SIZE, " ")) if (get_value(cfg, std::string(path+".rf_control.on").c_str(), value, 0, CALL_SIZE, " "))
strcpy(ENABLE_RF, value.c_str()); strcpy(ENABLE_RF, value.c_str());
else else
logdata("%s.rf_control.on '%s' is invalid, rejected.\n", path.c_str(), value.c_str()); logdata("%s.rf_control.on '%s' is invalid, rejected.\n", path.c_str(), value.c_str());
if (get_value(cfg, string(path+".rf_control.off").c_str(), value, 0, CALL_SIZE, " ")) if (get_value(cfg, std::string(path+".rf_control.off").c_str(), value, 0, CALL_SIZE, " "))
strcpy(DISABLE_RF, value.c_str()); strcpy(DISABLE_RF, value.c_str());
else else
logdata("%s.rf_control.off '%s' is invalid, rejected.\n", path.c_str(), value.c_str()); logdata("%s.rf_control.off '%s' is invalid, rejected.\n", path.c_str(), value.c_str());
@ -1942,7 +1941,7 @@ static int read_config(const char *cfgFile)
REMOTE_TIMEOUT = 3; REMOTE_TIMEOUT = 3;
logdata("timing.timeout.remote_g2 = [%d]\n", REMOTE_TIMEOUT); logdata("timing.timeout.remote_g2 = [%d]\n", REMOTE_TIMEOUT);
if (get_value(cfg, string(path+".invalid_prefix").c_str(), value, 1, CALL_SIZE, "XXX")) { if (get_value(cfg, std::string(path+".invalid_prefix").c_str(), value, 1, CALL_SIZE, "XXX")) {
value.resize(CALL_SIZE, ' '); value.resize(CALL_SIZE, ' ');
for (i=0; i<CALL_SIZE; i++) { for (i=0; i<CALL_SIZE; i++) {
if (islower(value[i])) if (islower(value[i]))
@ -1954,21 +1953,21 @@ static int read_config(const char *cfgFile)
return 1; return 1;
} }
if (get_value(cfg, string(path+".serial_number").c_str(), value, 11, 11, "00.00.00.00")) if (get_value(cfg, std::string(path+".serial_number").c_str(), value, 11, 11, "00.00.00.00"))
strcpy(DVRPTR_SERIAL, value.c_str()); strcpy(DVRPTR_SERIAL, value.c_str());
else { else {
logdata("%s.serial_number '%s' is invalid!\n", path.c_str(), value.c_str()); logdata("%s.serial_number '%s' is invalid!\n", path.c_str(), value.c_str());
return 1; return 1;
} }
if (get_value(cfg, string(path+".internal_ip").c_str(), value, 7, IP_SIZE, "0.0.0.0")) if (get_value(cfg, std::string(path+".internal_ip").c_str(), value, 7, IP_SIZE, "0.0.0.0"))
strcpy(DVRPTR_INTERNAL_IP, value.c_str()); strcpy(DVRPTR_INTERNAL_IP, value.c_str());
else { else {
logdata("%s.internal_ip '%s' is invalid!\n", path.c_str(), value.c_str()); logdata("%s.internal_ip '%s' is invalid!\n", path.c_str(), value.c_str());
return 1; return 1;
} }
get_value(cfg, string(path+".port").c_str(), DVRPTR_INTERNAL_PORT, 10000, 65535, 19998 + (DVRPTR_MOD - 'A')); get_value(cfg, std::string(path+".port").c_str(), DVRPTR_INTERNAL_PORT, 10000, 65535, 19998 + (DVRPTR_MOD - 'A'));
if (get_value(cfg, "gateway.ip", value, 7, IP_SIZE, "127.0.0.1")) if (get_value(cfg, "gateway.ip", value, 7, IP_SIZE, "127.0.0.1"))
strcpy(GATEWAY_IP, value.c_str()); strcpy(GATEWAY_IP, value.c_str());
@ -1979,26 +1978,26 @@ static int read_config(const char *cfgFile)
get_value(cfg, "gateway.internal.port", GATEWAY_PORT, 10000, 65535, 19000); get_value(cfg, "gateway.internal.port", GATEWAY_PORT, 10000, 65535, 19000);
get_value(cfg, string(path+".rf_tx_level").c_str(), RF_AUDIO_Level, 1, 100, 80); get_value(cfg, std::string(path+".rf_tx_level").c_str(), RF_AUDIO_Level, 1, 100, 80);
get_value(cfg, string(path+".duplex").c_str(), DUPLEX, false); get_value(cfg, std::string(path+".duplex").c_str(), DUPLEX, false);
get_value(cfg, string(path+".acknowledge").c_str(), RPTR_ACK, false); get_value(cfg, std::string(path+".acknowledge").c_str(), RPTR_ACK, false);
get_value(cfg, string(path+".ack_delay").c_str(), i, 1, 999, 300); get_value(cfg, std::string(path+".ack_delay").c_str(), i, 1, 999, 300);
ACK_DELAY = (long)i; ACK_DELAY = (long)i;
get_value(cfg, "timing.play.delay", DELAY_BETWEEN, 10, 25, 19); get_value(cfg, "timing.play.delay", DELAY_BETWEEN, 10, 25, 19);
DELAY_BETWEEN *= 1000; DELAY_BETWEEN *= 1000;
get_value(cfg, string(path+".tx_delay").c_str(), TX_DELAY, 0, 6000, 250); get_value(cfg, std::string(path+".tx_delay").c_str(), TX_DELAY, 0, 6000, 250);
Modem_Init2[8] = TX_DELAY & 0xFF; Modem_Init2[8] = TX_DELAY & 0xFF;
Modem_Init2[9] = TX_DELAY >> 8; Modem_Init2[9] = TX_DELAY >> 8;
get_value(cfg, string(path+".rqst_count").c_str(), RQST_COUNT, 6, 20, 10); get_value(cfg, std::string(path+".rqst_count").c_str(), RQST_COUNT, 6, 20, 10);
get_value(cfg, string(path+".inverse.rx").c_str(), RX_Inverse, true); get_value(cfg, std::string(path+".inverse.rx").c_str(), RX_Inverse, true);
get_value(cfg, string(path+".inverse.tx").c_str(), TX_Inverse, true); get_value(cfg, std::string(path+".inverse.tx").c_str(), TX_Inverse, true);
inactiveMax = (REMOTE_TIMEOUT * 1000000) / 400; inactiveMax = (REMOTE_TIMEOUT * 1000000) / 400;
logdata("... computed max number of loops %d, each loop is 400 microseconds\n", inactiveMax); logdata("... computed max number of loops %d, each loop is 400 microseconds\n", inactiveMax);

2
g2.dvap.cfg
Unescape View File

@ -5,7 +5,7 @@ ircddb = {
# If you are not using rr.openquad.net, you need to specify the host and possibly the password. # If you are not using rr.openquad.net, you need to specify the host and possibly the password.
# #
# host = "some.server.host" // others include group1-irc.ircddb.net # host = "some.server.host" // others include group1-irc.ircddb.net
# password = "1111111111111" // not needed for rr.penquad.net # password = "1111111111111" // not needed for rr.openquad.net
} }
module = { module = {

146
g2_ircddb.cpp
Unescape View File

@ -53,14 +53,12 @@
#include <string> #include <string>
#include <map> #include <map>
#include <libconfig.h++> #include <libconfig.h++>
using namespace std;
using namespace libconfig; using namespace libconfig;
#include <pthread.h> #include <pthread.h>
#include <wx/hashmap.h>
#include "IRCDDB.h" #include "IRCDDB.h"
#include "IRCutils.h"
#include "versions.h" #include "versions.h"
#define IP_SIZE 15 #define IP_SIZE 15
@ -75,19 +73,19 @@ using namespace libconfig;
/* configuration data */ /* configuration data */
typedef struct portip_tag { typedef struct portip_tag {
string ip; std::string ip;
int port; int port;
} PORTIP; } PORTIP;
/* Gateway callsign */ /* Gateway callsign */
static string OWNER; static std::string OWNER;
static string owner; static std::string owner;
static string local_irc_ip; static std::string local_irc_ip;
static string status_file; static std::string status_file;
static string dtmf_dir; static std::string dtmf_dir;
static string dtmf_file; static std::string dtmf_file;
static string echotest_dir; static std::string echotest_dir;
static string irc_pass; static std::string irc_pass;
PORTIP g2_internal, g2_external, g2_link, ircddb; PORTIP g2_internal, g2_external, g2_link, ircddb;
@ -125,17 +123,17 @@ static socklen_t aprs_addr_len;
/* data needed for aprs login and aprs beacon */ /* data needed for aprs login and aprs beacon */
static struct rptr_struct{ static struct rptr_struct{
PORTIP aprs; PORTIP aprs;
string aprs_filter; std::string aprs_filter;
int aprs_hash; int aprs_hash;
int aprs_interval; int aprs_interval;
/* 0=A, 1=B, 2=C */ /* 0=A, 1=B, 2=C */
struct mod_struct { struct mod_struct {
string call; /* KJ4NHF-B */ std::string call; /* KJ4NHF-B */
bool defined; bool defined;
string band; /* 23cm ... */ std::string band; /* 23cm ... */
double frequency, offset, latitude, longitude, range, agl; double frequency, offset, latitude, longitude, range, agl;
string desc1, desc2, desc, url, package_version; std::string desc1, desc2, desc, url, package_version;
PORTIP portip; PORTIP portip;
} mod[3]; } mod[3];
} rptr; } rptr;
@ -274,14 +272,8 @@ static regex_t preg;
CACHE used to cache users, repeaters, CACHE used to cache users, repeaters,
gateways, IP numbers coming from the irc server gateways, IP numbers coming from the irc server
*/ */
WX_DECLARE_STRING_HASH_MAP(wxString, user2rptr_type);
static user2rptr_type user2rptr_map;
WX_DECLARE_STRING_HASH_MAP(wxString, rptr2gwy_type);
static rptr2gwy_type rptr2gwy_map;
WX_DECLARE_STRING_HASH_MAP(wxString, gwy2ip_type); static std::map<std::string, std::string> user2rptr_map, rptr2gwy_map, gwy2ip_map;
static gwy2ip_type gwy2ip_map;
static pthread_mutex_t irc_data_mutex = PTHREAD_MUTEX_INITIALIZER; static pthread_mutex_t irc_data_mutex = PTHREAD_MUTEX_INITIALIZER;
@ -328,7 +320,6 @@ static int get_yrcall_rptr_from_cache(char *call, char *arearp_cs, char *zonerp_
char *mod, char *ip, char RoU); char *mod, char *ip, char RoU);
static bool get_yrcall_rptr(char *call, char *arearp_cs, char *zonerp_cs, static bool get_yrcall_rptr(char *call, char *arearp_cs, char *zonerp_cs,
char *mod, char *ip, char RoU); char *mod, char *ip, char RoU);
static void traceit(const char *fmt,...);
static int read_config(char *); static int read_config(char *);
static void runit(); static void runit();
static void sigCatch(int signum); static void sigCatch(int signum);
@ -478,30 +469,6 @@ static void calcPFCS(unsigned char *packet, int len)
return; return;
} }
/* log the event */
static void traceit(const char *fmt,...)
{
time_t ltime;
struct tm tm;
const short BFSZ = 512;
char buf[BFSZ];
time(&ltime);
localtime_r(&ltime, &tm);
snprintf(buf,BFSZ - 1,"%02d/%02d/%02d %d:%02d:%02d:",
tm.tm_mon+1,tm.tm_mday,tm.tm_year % 100,
tm.tm_hour,tm.tm_min,tm.tm_sec);
va_list args;
va_start(args,fmt);
vsnprintf(buf + strlen(buf), BFSZ - strlen(buf) -1, fmt, args);
va_end(args);
fprintf(stdout, "%s", buf);
return;
}
bool get_value(const Config &cfg, const char *path, int &value, int min, int max, int default_value) bool get_value(const Config &cfg, const char *path, int &value, int min, int max, int default_value)
{ {
if (cfg.lookupValue(path, value)) { if (cfg.lookupValue(path, value)) {
@ -532,7 +499,7 @@ bool get_value(const Config &cfg, const char *path, bool &value, bool default_va
return true; return true;
} }
bool get_value(const Config &cfg, const char *path, string &value, int min, int max, const char *default_value) bool get_value(const Config &cfg, const char *path, std::string &value, int min, int max, const char *default_value)
{ {
if (cfg.lookupValue(path, value)) { if (cfg.lookupValue(path, value)) {
int l = value.length(); int l = value.length();
@ -549,7 +516,6 @@ bool get_value(const Config &cfg, const char *path, string &value, int min, int
/* process configuration file */ /* process configuration file */
static int read_config(char *cfgFile) static int read_config(char *cfgFile)
{ {
unsigned short i;
Config cfg; Config cfg;
traceit("Reading file %s\n", cfgFile); traceit("Reading file %s\n", cfgFile);
@ -569,20 +535,16 @@ static int read_config(char *cfgFile)
if (! get_value(cfg, "ircddb.login", owner, 3, CALL_SIZE-2, "UNDEFINED")) if (! get_value(cfg, "ircddb.login", owner, 3, CALL_SIZE-2, "UNDEFINED"))
return 1; return 1;
OWNER = owner; OWNER = owner;
for (i=0; i<owner.length(); i++) { ToLower(owner);
if (islower(owner[i])) ToUpper(OWNER);
OWNER[i] = toupper(OWNER[i]);
else
owner[i] = tolower(owner[i]);
}
traceit("OWNER=[%s]\n", OWNER.c_str()); traceit("OWNER=[%s]\n", OWNER.c_str());
OWNER.resize(CALL_SIZE, ' '); OWNER.resize(CALL_SIZE, ' ');
for (short int m=0; m<3; m++) { for (short int m=0; m<3; m++) {
string path = "module."; std::string path = "module.";
path += m + 'a'; path += m + 'a';
string type; std::string type;
if (cfg.lookupValue(string(path+".type").c_str(), type)) { if (cfg.lookupValue(std::string(path+".type").c_str(), type)) {
if (strcasecmp(type.c_str(), "dvap") && strcasecmp(type.c_str(), "dvrptr")) { if (strcasecmp(type.c_str(), "dvap") && strcasecmp(type.c_str(), "dvrptr")) {
traceit("%s.type '%s' is invalid\n", type.c_str()); traceit("%s.type '%s' is invalid\n", type.c_str());
return 1; return 1;
@ -592,20 +554,20 @@ static int read_config(char *cfgFile)
rptr.mod[m].package_version = DVAP_VERSION; rptr.mod[m].package_version = DVAP_VERSION;
else else
rptr.mod[m].package_version = DVRPTR_VERSION; rptr.mod[m].package_version = DVRPTR_VERSION;
if (! get_value(cfg, string(path+".ip").c_str(), rptr.mod[m].portip.ip, 7, IP_SIZE, "127.0.0.1")) if (! get_value(cfg, std::string(path+".ip").c_str(), rptr.mod[m].portip.ip, 7, IP_SIZE, "127.0.0.1"))
return 1; return 1;
get_value(cfg, string(path+".port").c_str(), rptr.mod[m].portip.port, 16000, 65535, 19998+m); get_value(cfg, std::string(path+".port").c_str(), rptr.mod[m].portip.port, 16000, 65535, 19998+m);
get_value(cfg, string(path+".frequency").c_str(), rptr.mod[m].frequency, 0.0, 1.0e12, 0.0); get_value(cfg, std::string(path+".frequency").c_str(), rptr.mod[m].frequency, 0.0, 1.0e12, 0.0);
get_value(cfg, string(path+".offset").c_str(), rptr.mod[m].offset,-1.0e12, 1.0e12, 0.0); get_value(cfg, std::string(path+".offset").c_str(), rptr.mod[m].offset,-1.0e12, 1.0e12, 0.0);
get_value(cfg, string(path+".range").c_str(), rptr.mod[m].range, 0.0, 1609344.0, 0.0); get_value(cfg, std::string(path+".range").c_str(), rptr.mod[m].range, 0.0, 1609344.0, 0.0);
get_value(cfg, string(path+".agl").c_str(), rptr.mod[m].agl, 0.0, 1000.0, 0.0); get_value(cfg, std::string(path+".agl").c_str(), rptr.mod[m].agl, 0.0, 1000.0, 0.0);
get_value(cfg, string(path+".latitude").c_str(), rptr.mod[m].latitude, -90.0, 90.0, 0.0); get_value(cfg, std::string(path+".latitude").c_str(), rptr.mod[m].latitude, -90.0, 90.0, 0.0);
get_value(cfg, string(path+".longitude").c_str(), rptr.mod[m].longitude, -180.0, 180.0, 0.0); get_value(cfg, std::string(path+".longitude").c_str(), rptr.mod[m].longitude, -180.0, 180.0, 0.0);
if (! cfg.lookupValue(path+".desc1", rptr.mod[m].desc1)) if (! cfg.lookupValue(path+".desc1", rptr.mod[m].desc1))
rptr.mod[m].desc1 = ""; rptr.mod[m].desc1 = "";
if (! cfg.lookupValue(path+".desc2", rptr.mod[m].desc2)) if (! cfg.lookupValue(path+".desc2", rptr.mod[m].desc2))
rptr.mod[m].desc2 = ""; rptr.mod[m].desc2 = "";
if (! get_value(cfg, string(path+".url").c_str(), rptr.mod[m].url, 0, 80, "github.com/ac2ie/g2_ircddb")) if (! get_value(cfg, std::string(path+".url").c_str(), rptr.mod[m].url, 0, 80, "github.com/ac2ie/g2_ircddb"))
return 1; return 1;
// truncate strings // truncate strings
if (rptr.mod[m].desc1.length() > 20) if (rptr.mod[m].desc1.length() > 20)
@ -755,10 +717,10 @@ static void *get_irc_data(void *arg)
{ {
struct timespec req; struct timespec req;
wxString user; std::string user;
wxString rptr; std::string rptr;
wxString gateway; std::string gateway;
wxString ipaddr; std::string ipaddr;
DSTAR_PROTOCOL proto; DSTAR_PROTOCOL proto;
IRCDDB_RESPONSE_TYPE type; IRCDDB_RESPONSE_TYPE type;
int rc = 0; int rc = 0;
@ -817,10 +779,10 @@ static void *get_irc_data(void *arg)
while (((type = ii->getMessageType()) != IDRT_NONE) && keep_running) { while (((type = ii->getMessageType()) != IDRT_NONE) && keep_running) {
if (type == IDRT_USER) { if (type == IDRT_USER) {
ii->receiveUser(user, rptr, gateway, ipaddr); ii->receiveUser(user, rptr, gateway, ipaddr);
if (!user.IsEmpty()) { if (!user.empty()) {
if (!rptr.IsEmpty() && !gateway.IsEmpty() && !ipaddr.IsEmpty()) { if (!rptr.empty() && !gateway.empty() && !ipaddr.empty()) {
if (bool_irc_debug) if (bool_irc_debug)
traceit("C-u:%s,%s,%s,%s\n", user.mb_str(), rptr.mb_str(), gateway.mb_str(), ipaddr.mb_str()); traceit("C-u:%s,%s,%s,%s\n", user.c_str(), rptr.c_str(), gateway.c_str(), ipaddr.c_str());
pthread_mutex_lock(&irc_data_mutex); pthread_mutex_lock(&irc_data_mutex);
@ -836,10 +798,10 @@ static void *get_irc_data(void *arg)
} }
} else if (type == IDRT_REPEATER) { } else if (type == IDRT_REPEATER) {
ii->receiveRepeater(rptr, gateway, ipaddr, proto); ii->receiveRepeater(rptr, gateway, ipaddr, proto);
if (!rptr.IsEmpty()) { if (!rptr.empty()) {
if (!gateway.IsEmpty() && !ipaddr.IsEmpty()) { if (!gateway.empty() && !ipaddr.empty()) {
if (bool_irc_debug) if (bool_irc_debug)
traceit("C-r:%s,%s,%s\n", rptr.mb_str(), gateway.mb_str(), ipaddr.mb_str()); traceit("C-r:%s,%s,%s\n", rptr.c_str(), gateway.c_str(), ipaddr.c_str());
pthread_mutex_lock(&irc_data_mutex); pthread_mutex_lock(&irc_data_mutex);
@ -854,9 +816,9 @@ static void *get_irc_data(void *arg)
} }
} else if (type == IDRT_GATEWAY) { } else if (type == IDRT_GATEWAY) {
ii->receiveGateway(gateway, ipaddr, proto); ii->receiveGateway(gateway, ipaddr, proto);
if (!gateway.IsEmpty() && !ipaddr.IsEmpty()) { if (!gateway.empty() && !ipaddr.empty()) {
if (bool_irc_debug) if (bool_irc_debug)
traceit("C-g:%s,%s\n", gateway.mb_str(),ipaddr.mb_str()); traceit("C-g:%s,%s\n", gateway.c_str(),ipaddr.c_str());
pthread_mutex_lock(&irc_data_mutex); pthread_mutex_lock(&irc_data_mutex);
@ -881,9 +843,9 @@ static void *get_irc_data(void *arg)
static int get_yrcall_rptr_from_cache(char *call, char *arearp_cs, char *zonerp_cs, static int get_yrcall_rptr_from_cache(char *call, char *arearp_cs, char *zonerp_cs,
char *mod, char *ip, char RoU) char *mod, char *ip, char RoU)
{ {
user2rptr_type::iterator user_pos = user2rptr_map.end(); std::map<std::string, std::string>::iterator user_pos = user2rptr_map.end();
rptr2gwy_type::iterator rptr_pos = rptr2gwy_map.end(); std::map<std::string, std::string>::iterator rptr_pos = rptr2gwy_map.end();
gwy2ip_type::iterator gwy_pos = gwy2ip_map.end(); std::map<std::string, std::string>::iterator gwy_pos = gwy2ip_map.end();
char temp[CALL_SIZE + 1]; char temp[CALL_SIZE + 1];
memset(arearp_cs, ' ', CALL_SIZE); memset(arearp_cs, ' ', CALL_SIZE);
@ -2033,7 +1995,10 @@ static void runit()
if ((readBuffer[16] & 0x40) != 0) { if ((readBuffer[16] & 0x40) != 0) {
if (dtmf_buf_count[i] > 0) { if (dtmf_buf_count[i] > 0) {
dtmf_file = dtmf_dir + "/" + ('A'+i) + "_mod_DTMF_NOTIFY"; dtmf_file = dtmf_dir;
dtmf_file.push_back('/');
dtmf_file.push_back('A'+i);
dtmf_file += "_mod_DTMF_NOTIFY";
if (bool_dtmf_debug) if (bool_dtmf_debug)
traceit("Saving dtmfs=[%s] into file: [%s]\n", dtmf_buf[i], dtmf_file.c_str()); traceit("Saving dtmfs=[%s] into file: [%s]\n", dtmf_buf[i], dtmf_file.c_str());
dtmf_fp = fopen(dtmf_file.c_str(), "w"); dtmf_fp = fopen(dtmf_file.c_str(), "w");
@ -3111,7 +3076,7 @@ static void *echotest(void *arg)
static void qrgs_and_maps() static void qrgs_and_maps()
{ {
for(int i=0; i<3; i++) { for(int i=0; i<3; i++) {
string rptrcall = OWNER; std::string rptrcall = OWNER;
rptrcall.resize(CALL_SIZE-1); rptrcall.resize(CALL_SIZE-1);
rptrcall += i + 'A'; rptrcall += i + 'A';
if (rptr.mod[i].latitude || rptr.mod[i].longitude || rptr.mod[i].desc1.length() || rptr.mod[i].url.length()) if (rptr.mod[i].latitude || rptr.mod[i].longitude || rptr.mod[i].desc1.length() || rptr.mod[i].url.length())
@ -3127,7 +3092,6 @@ int main(int argc, char **argv)
{ {
short int i; short int i;
struct sigaction act; struct sigaction act;
bool ok;
int rc = 0; int rc = 0;
@ -3230,17 +3194,10 @@ int main(int argc, char **argv)
aprs_init(); aprs_init();
compute_aprs_hash(); compute_aprs_hash();
ok = ::wxInitialize();
if (!ok) {
traceit("Failed to initialize wx\n");
return 1;
}
ii = new CIRCDDB(ircddb.ip, ircddb.port, owner, irc_pass, IRCDDB_VERSION, local_irc_ip); ii = new CIRCDDB(ircddb.ip, ircddb.port, owner, irc_pass, IRCDDB_VERSION, local_irc_ip);
ok = ii->open(); bool ok = ii->open();
if (!ok) { if (!ok) {
traceit("irc open failed\n"); traceit("irc open failed\n");
::wxUninitialize();
return 1; return 1;
} }
@ -3402,7 +3359,6 @@ int main(int argc, char **argv)
} }
ii->close(); ii->close();
::wxUninitialize();
traceit("g2_ircddb exiting\n"); traceit("g2_ircddb exiting\n");
return rc; return rc;
} }

49
g2_link.cpp
Unescape View File

@ -53,7 +53,6 @@
#include <utility> #include <utility>
#include <libconfig.h++> #include <libconfig.h++>
#include "versions.h" #include "versions.h"
using namespace std;
using namespace libconfig; using namespace libconfig;
/*** version number must be x.xx ***/ /*** version number must be x.xx ***/
@ -71,25 +70,25 @@ using namespace libconfig;
#define FILE_REFRESH_GWYS_CODE 'F' #define FILE_REFRESH_GWYS_CODE 'F'
/* configuration data */ /* configuration data */
static string login_call; static std::string login_call;
static bool only_admin_login; static bool only_admin_login;
static bool only_link_unlink; static bool only_link_unlink;
static string owner; static std::string owner;
static int rmt_xrf_port; static int rmt_xrf_port;
static int rmt_ref_port; static int rmt_ref_port;
static int rmt_dcs_port; static int rmt_dcs_port;
static string my_g2_link_ip; static std::string my_g2_link_ip;
static int my_g2_link_port; static int my_g2_link_port;
static string to_g2_external_ip; static std::string to_g2_external_ip;
static int to_g2_external_port; static int to_g2_external_port;
static bool qso_details; static bool qso_details;
static string gwys; static std::string gwys;
static string status_file; static std::string status_file;
static bool bool_rptr_ack; static bool bool_rptr_ack;
static int delay_between; static int delay_between;
static int delay_before; static int delay_before;
static bool announce; static bool announce;
static string announce_dir; static std::string announce_dir;
static char link_at_startup[CALL_SIZE+1]; static char link_at_startup[CALL_SIZE+1];
static unsigned int max_dongles; static unsigned int max_dongles;
static unsigned int saved_max_dongles; static unsigned int saved_max_dongles;
@ -120,17 +119,17 @@ struct inbound {
}; };
/* the Key in this inbound_list map is the unique IP address of the remote */ /* the Key in this inbound_list map is the unique IP address of the remote */
typedef map<string, inbound *> inbound_type; typedef std::map<std::string, inbound *> inbound_type;
static inbound_type inbound_list; static inbound_type inbound_list;
typedef set<string> admin_type; typedef std::set<std::string> admin_type;
static admin_type admin; static admin_type admin;
typedef set<string> link_unlink_user_type; typedef std::set<std::string> link_unlink_user_type;
static link_unlink_user_type link_unlink_user; static link_unlink_user_type link_unlink_user;
#define LH_MAX_SIZE 39 #define LH_MAX_SIZE 39
typedef map<string, string> dt_lh_type; typedef std::map<std::string, std::string> dt_lh_type;
static dt_lh_type dt_lh_list; static dt_lh_type dt_lh_list;
/* /*
@ -248,7 +247,7 @@ static unsigned short crc_tabccitt[256] = {
/* the map of remotes */ /* the map of remotes */
/* key is the callsign, data is the host */ /* key is the callsign, data is the host */
typedef map<string, string> gwy_list_type; typedef std::map<std::string, std::string> gwy_list_type;
static gwy_list_type gwy_list; static gwy_list_type gwy_list;
static unsigned char queryCommand[QUERY_SIZE]; static unsigned char queryCommand[QUERY_SIZE];
@ -270,7 +269,7 @@ static struct {
{ {0x00, 0x00} } { {0x00, 0x00} }
}; };
static bool load_gwys(const string &filename); static bool load_gwys(const std::string &filename);
static void calcPFCS(unsigned char *packet, int len); static void calcPFCS(unsigned char *packet, int len);
static void traceit(const char *fmt,...); static void traceit(const char *fmt,...);
static bool read_config(char *); static bool read_config(char *);
@ -617,7 +616,7 @@ static void print_status_file()
} }
/* Open text file of repeaters, reflectors */ /* Open text file of repeaters, reflectors */
static bool load_gwys(const string &filename) static bool load_gwys(const std::string &filename)
{ {
FILE *fp = NULL; FILE *fp = NULL;
char inbuf[1024]; char inbuf[1024];
@ -634,7 +633,7 @@ static bool load_gwys(const string &filename)
unsigned short j; unsigned short j;
gwy_list_type::iterator gwy_pos; gwy_list_type::iterator gwy_pos;
pair<gwy_list_type::iterator,bool> gwy_insert_pair; std::pair<gwy_list_type::iterator,bool> gwy_insert_pair;
traceit("Trying to open file %s\n", filename.c_str()); traceit("Trying to open file %s\n", filename.c_str());
fp = fopen(filename.c_str(), "r"); fp = fopen(filename.c_str(), "r");
@ -708,7 +707,7 @@ static bool load_gwys(const string &filename)
gwy_pos = gwy_list.find(call); gwy_pos = gwy_list.find(call);
if (gwy_pos == gwy_list.end()) { if (gwy_pos == gwy_list.end()) {
gwy_insert_pair = gwy_list.insert(pair<string,string>(call,payload)); gwy_insert_pair = gwy_list.insert(std::pair<std::string,std::string>(call,payload));
if (gwy_insert_pair.second) if (gwy_insert_pair.second)
traceit("Added Call=[%s], payload=[%s]\n",call, payload); traceit("Added Call=[%s], payload=[%s]\n",call, payload);
else else
@ -813,7 +812,7 @@ bool get_value(const Config &cfg, const char *path, bool &value, bool default_va
return true; return true;
} }
bool get_value(const Config &cfg, const char *path, string &value, int min, int max, const char *default_value) bool get_value(const Config &cfg, const char *path, std::string &value, int min, int max, const char *default_value)
{ {
if (cfg.lookupValue(path, value)) { if (cfg.lookupValue(path, value)) {
int l = value.length(); int l = value.length();
@ -849,8 +848,8 @@ static bool read_config(char *cfgFile)
return 1; return 1;
} }
string value; std::string value;
string key = "g2_link.ref_login"; std::string key = "g2_link.ref_login";
if (cfg.lookupValue(key, login_call) || cfg.lookupValue("ircddb.login", login_call)) { if (cfg.lookupValue(key, login_call) || cfg.lookupValue("ircddb.login", login_call)) {
int l = login_call.length(); int l = login_call.length();
if (l<3 || l>CALL_SIZE-2) { if (l<3 || l>CALL_SIZE-2) {
@ -986,7 +985,7 @@ static bool read_config(char *cfgFile)
get_value(cfg, "timing.play.wait", delay_before, 1, 10, 2); get_value(cfg, "timing.play.wait", delay_before, 1, 10, 2);
if (! get_value(cfg, "g2_link.link_at_start", value, 5, CALL_SIZE, "NONE")) { if (get_value(cfg, "g2_link.link_at_start", value, 5, CALL_SIZE, "NONE")) {
if (strcasecmp(value.c_str(), "none")) if (strcasecmp(value.c_str(), "none"))
strcpy(link_at_startup, value.c_str()); strcpy(link_at_startup, value.c_str());
} else } else
@ -1367,7 +1366,7 @@ static void runit()
int max_nfds = 0; int max_nfds = 0;
char tmp1[CALL_SIZE + 1]; char tmp1[CALL_SIZE + 1];
char tmp2[36]; // 8 for rpt1 + 24 for time_t in string format char tmp2[36]; // 8 for rpt1 + 24 for time_t in std::string format
dt_lh_type::iterator dt_lh_pos; dt_lh_type::iterator dt_lh_pos;
dt_lh_type::reverse_iterator r_dt_lh_pos; dt_lh_type::reverse_iterator r_dt_lh_pos;
@ -1377,9 +1376,9 @@ static void runit()
char ip[IP_SIZE + 1]; char ip[IP_SIZE + 1];
inbound *inbound_ptr; inbound *inbound_ptr;
inbound_type::iterator pos; inbound_type::iterator pos;
pair<inbound_type::iterator,bool> insert_pair; std::pair<inbound_type::iterator,bool> insert_pair;
bool found = false; bool found = false;
set<string>::iterator it; std::set<std::string>::iterator it;
char cmd_2_dcs[23]; char cmd_2_dcs[23];
unsigned char dcs_seq[3] = { 0x00, 0x00, 0x00 }; unsigned char dcs_seq[3] = { 0x00, 0x00, 0x00 };
@ -2882,7 +2881,7 @@ static void runit()
else else
inbound_ptr->client = 'D'; /* dongle */ inbound_ptr->client = 'D'; /* dongle */
insert_pair = inbound_list.insert(pair<string, inbound *>(ip, inbound_ptr)); insert_pair = inbound_list.insert(std::pair<std::string, inbound *>(ip, inbound_ptr));
if (insert_pair.second) { if (insert_pair.second) {
if (memcmp(inbound_ptr->call, "1NFO", 4) != 0) if (memcmp(inbound_ptr->call, "1NFO", 4) != 0)
traceit("new CALL=%s, DONGLE-p, ip=%s, users=%d\n", traceit("new CALL=%s, DONGLE-p, ip=%s, users=%d\n",

8
versions.h
Unescape View File

@ -1,5 +1,5 @@
// version strings must be 55 characters or less! // version strings must be 55 characters or less!
#define IRCDDB_VERSION "linux-g2_ircddb-4.1.0" #define IRCDDB_VERSION "linux-g2_ircddb-5.0.0"
#define LINK_VERSION "4.01" #define LINK_VERSION "5.00"
#define DVAP_VERSION "linux-dvap_rptr-3.0.0" #define DVAP_VERSION "linux-dvap_rptr-5.0.0"
#define DVRPTR_VERSION "linux-dvrptr-2.0.0" #define DVRPTR_VERSION "linux-dvrptr-5.0.0"

Write Preview
Loading…
Cancel
Save

Powered by TurnKey Linux.