void decode(KviCString & szText, unsigned char ** buf, int *len)
{
// make sure its length is multiple of 12 (eventually pad with zeroes)
if(szText.len() % 12)
{
int oldL = szText.len();
szText.setLen(szText.len() + (12 - (szText.len() % 12)));
char * padB = szText.ptr() + oldL;
char * padE = szText.ptr() + szText.len();
while(padB < padE)*padB++ = 0;
}
*len = (int)(szText.len() * 2) / 3;
*buf = (unsigned char *)KviMemory::allocate(*len);
unsigned char * p = (unsigned char *)szText.ptr();
unsigned char * e = p + szText.len();
int i;
unsigned char * bufp = *buf;
while(p < e)
{
quint32 * dw1 = (quint32 *)bufp;
bufp += 4;
quint32 * dw2 = (quint32 *)bufp;
bufp += 4;
*dw2 = 0;
for(i=0;i < 6;i++)*dw2 |= (fake_base64dec(*p++)) << (i * 6);
*dw1 = 0;
for(i=0;i < 6;i++)*dw1 |= (fake_base64dec(*p++)) << (i * 6);
}
// FIXME: this is probably needed only on LittleEndian machines!
byteswap_buffer(*buf,*len);
}
bool KviMircryptionEngine::doEncryptCBC(KviCString & plain, KviCString & encoded)
{
// make sure it is a multiple of 8 bytes (eventually pad with zeroes)
if(plain.len() % 8)
{
int oldL = plain.len();
plain.setLen(plain.len() + (8 - (plain.len() % 8)));
char * padB = plain.ptr() + oldL;
char * padE = plain.ptr() + plain.len();
while(padB < padE)
*padB++ = 0;
}
int ll = plain.len() + 8;
unsigned char * in = (unsigned char *)KviMemory::allocate(ll);
InitVectorEngine::fillRandomIV(in, 8);
KviMemory::copy(in + 8, plain.ptr(), plain.len());
// encrypt
unsigned char * out = (unsigned char *)KviMemory::allocate(ll);
BlowFish bf((unsigned char *)m_szEncryptKey.ptr(), m_szEncryptKey.len());
bf.ResetChain();
bf.Encrypt(in, out, ll, BlowFish::CBC);
KviMemory::free(in);
encoded.bufferToBase64((const char *)out, ll);
KviMemory::free(out);
encoded.prepend('*'); // prepend the signature
return true;
}
static bool dcc_module_normalize_target_data(KviDccRequest * dcc, KviCString & ipaddr, KviCString & port)
{
if(!port.isUnsignedNum())
{
if(!dcc->ctcpMsg->msg->haltOutput())
{
QString szError = QString(__tr2qs_ctx("Invalid port number %1", "dcc")).arg(port.ptr());
dcc_module_request_error(dcc, szError);
}
return false;
}
struct in_addr addr;
if(ipaddr.isUnsignedNum())
{
addr.s_addr = htonl((unsigned long)ipaddr.toULong());
QString tmp;
if(!KviNetUtils::binaryIpToStringIp(addr, tmp))
{
if(!dcc->ctcpMsg->msg->haltOutput())
{
QString szError = QString(__tr2qs_ctx("Invalid IP address in old format %1", "dcc")).arg(ipaddr.ptr());
dcc_module_request_error(dcc, szError);
}
return false;
}
ipaddr = tmp;
}
else
{
//FIXME: KviCString -> QString
if(!KviNetUtils::stringIpToBinaryIp(QString(ipaddr), &addr))
{
#ifdef COMPILE_IPV6_SUPPORT
struct in6_addr addr6;
if(KviNetUtils::stringIpToBinaryIp_V6(QString(ipaddr), &addr6))
{
dcc->bIPv6 = true;
return true; // IPV6 address.
}
#endif
if(!dcc->ctcpMsg->msg->haltOutput())
{
QString szError = QString(__tr2qs_ctx("Invalid IP address %1", "dcc")).arg(ipaddr.ptr());
dcc_module_request_error(dcc, szError);
}
return false;
}
}
return true;
}
bool KviLocale::findCatalogue(QString & szBuffer, const QString & szName, const QString & szLocaleDir)
{
KviCString szLocale = g_szLang;
QString szLocDir = szLocaleDir;
KviQString::ensureLastCharIs(szLocDir, KVI_PATH_SEPARATOR_CHAR);
szBuffer = QString("%1%2_%3.mo").arg(szLocDir, szName).arg(szLocale.ptr());
if(KviFileUtils::fileExists(szBuffer))
return true;
if(szLocale.findFirstIdx('.') != -1)
{
// things like en_GB.utf8
// kill them
szLocale.cutFromFirst('.');
szBuffer = QString("%1%2_%3.mo").arg(szLocDir, szName).arg(szLocale.ptr());
if(KviFileUtils::fileExists(szBuffer))
return true;
}
if(szLocale.findFirstIdx('@') != -1)
{
// things like @euro ?
// kill them
szLocale.cutFromFirst('@');
szBuffer = QString("%1%2_%3.mo").arg(szLocDir, szName).arg(szLocale.ptr());
if(KviFileUtils::fileExists(szBuffer))
return true;
}
if(szLocale.findFirstIdx('_') != -1)
{
// things like en_GB
// kill them
szLocale.cutFromFirst('_');
szBuffer = QString("%1%2_%3.mo").arg(szLocDir, szName).arg(szLocale.ptr());
if(KviFileUtils::fileExists(szBuffer))
return true;
}
// try the lower case version too
szLocale.toLower();
szBuffer = QString("%1%2_%3.mo").arg(szLocDir, szName).arg(szLocale.ptr());
if(KviFileUtils::fileExists(szBuffer))
return true;
return false;
}
KviIpcSentinel::KviIpcSentinel()
: QWidget(0)
{
setObjectName("kvirc4_ipc_sentinel");
#if defined(COMPILE_ON_WINDOWS) || defined(COMPILE_ON_MINGW)
setWindowTitle("kvirc4_ipc_sentinel");
setWindowFlags(Qt::FramelessWindowHint);
#else
#if defined(COMPILE_X11_SUPPORT) && defined(COMPILE_QX11INFO_SUPPORT)
kvi_ipcLoadAtoms();
XChangeProperty(kvi_ipc_get_xdisplay(),winId(),kvi_atom_ipc_sentinel_window,XA_STRING,8,
PropModeReplace,(const unsigned char *)kvi_sentinel_id.ptr(),kvi_sentinel_id.len());
kvi_ipcSetRemoteCommand(winId(),"");
#endif //!COMPILE_NO_X
#endif
move(-50,-50);
resize(1,1);
#if defined(COMPILE_ON_WINDOWS) || defined(COMPILE_ON_MINGW)
// we need to show the window once otherwise it will never get "realized"
// and we will not be able to find it via FindWindow()
show();
#endif
hide();
}
bool KviIpcSentinel::x11GetRemoteMessage()
{
Atom type;
int format;
unsigned long nItems, after;
unsigned char * data = nullptr;
KviCString szData;
if(XGetWindowProperty(kvi_ipc_get_xdisplay(), winId(), kvi_atom_ipc_remote_command,
0, 1024, false, XA_STRING, &type, &format, &nItems, &after, &data) == Success)
{
if((type == XA_STRING) && (format == 8) && (nItems > 8) && data)
{
kvi_u32_t uSenderId = *((kvi_u32_t *)(data));
if(uSenderId != g_uLocalInstanceId)
szData = (char *)(data + 8);
XFree((char *)data);
}
}
if(szData.isEmpty())
return false; // no command, or our own command
kvi_ipcSetRemoteCommand(winId(), "");
if(g_pApp)
g_pApp->ipcMessage(szData.ptr());
return true;
}
void KviModuleExtensionManager::unregisterExtensionsByModule(KviModule * m)
{
KviPointerHashTableIterator<const char *,KviModuleExtensionDescriptorList> it(*m_pExtensionDict);
KviPointerList<KviCString> dying;
dying.setAutoDelete(true);
while(KviModuleExtensionDescriptorList * l = it.current())
{
KviPointerList<KviModuleExtensionDescriptor> dying2;
dying2.setAutoDelete(true);
for(KviModuleExtensionDescriptor * d = l->first();d;d = l->next())
{
if(d->module() == m)dying2.append(d);
}
for(KviModuleExtensionDescriptor * de = dying2.first();de;de = dying2.next())
{
l->removeRef(de);
}
if(l->isEmpty())dying.append(new KviCString(it.currentKey()));
++it;
}
for(KviCString * li = dying.first();li;li = dying.next())
{
m_pExtensionDict->remove(li->ptr());
}
}
void DccVoiceWindow::connectionInProgress()
{
if(m_pDescriptor->bActive)
{
output(KVI_OUT_DCCMSG,__tr2qs_ctx("Contacting host %Q on port %Q","dcc"),&(m_pDescriptor->szIp),&(m_pDescriptor->szPort));
} else {
output(KVI_OUT_DCCMSG,__tr2qs_ctx("Listening on interface %Q port %Q","dcc"),
&(m_pMarshal->localIp()),&(m_pMarshal->localPort()));
if(m_pDescriptor->bSendRequest)
{
QString ip = !m_pDescriptor->szFakeIp.isEmpty() ? m_pDescriptor->szFakeIp : m_pDescriptor->szListenIp;
KviCString port = !m_pDescriptor->szFakePort.isEmpty() ? m_pDescriptor->szFakePort : m_pMarshal->localPort();
//#warning "OPTION FOR SENDING 127.0.0.1 and so on (not an unsigned nuumber)"
struct in_addr a;
if(KviNetUtils::stringIpToBinaryIp(ip,&a)) {
ip.setNum(htonl(a.s_addr));
}
m_pDescriptor->console()->connection()->sendFmtData("PRIVMSG %s :%cDCC VOICE %s %Q %s %d%c",
m_pDescriptor->console()->connection()->encodeText(m_pDescriptor->szNick).data(),
0x01,m_pDescriptor->szCodec.ptr(),
&ip,port.ptr(),m_pDescriptor->iSampleRate,0x01);
output(KVI_OUT_DCCMSG,__tr2qs_ctx("Sent DCC VOICE (%s) request to %Q, waiting for the remote client to connect...","dcc"),
m_pDescriptor->szCodec.ptr(),&(m_pDescriptor->szNick));
} else output(KVI_OUT_DCCMSG,__tr2qs_ctx("DCC VOICE request not sent: awaiting manual connections","dcc"));
}
}
void KviProxyDataBase::load(const QString &filename)
{
clear();
KviConfigurationFile cfg(filename,KviConfigurationFile::Read);
unsigned int nEntries = cfg.readUIntEntry("Entries",0);
for(unsigned int i=0;i<nEntries;i++)
{
KviProxy * p = new KviProxy();
KviCString tmp(KviCString::Format,"%u_Hostname",i);
p->m_szHostname = cfg.readEntry(tmp.ptr(),"proxy.example.net");
tmp.sprintf("%u_Port",i);
p->m_uPort = cfg.readUIntEntry(tmp.ptr(),7000);
tmp.sprintf("%u_Ip",i);
p->m_szIp = cfg.readEntry(tmp.ptr(),"");
tmp.sprintf("%u_User",i);
p->m_szUser = cfg.readEntry(tmp.ptr(),"");
tmp.sprintf("%u_Pass",i);
p->m_szPass = cfg.readEntry(tmp.ptr(),"");
tmp.sprintf("%u_Protocol",i);
KviCString type = cfg.readEntry(tmp.ptr(),"SOCKSv4");
p->setNamedProtocol(type.ptr());
tmp.sprintf("%u_IsIPv6",i);
p->m_bIsIPv6 = cfg.readBoolEntry(tmp.ptr(),false);
tmp.sprintf("%u_Current",i);
if(cfg.readBoolEntry(tmp.ptr(),false))m_pCurrentProxy = p;
m_pProxyList->append(p);
}
if(!m_pCurrentProxy)m_pCurrentProxy = m_pProxyList->first();
}
void RegisteredUserMaskDialog::okClicked()
{
KviCString szTmp = m_pNickEdit->text();
if(szTmp.isEmpty())szTmp = "*";
m_pMask->setNick(szTmp.ptr());
szTmp = m_pUserEdit->text();
if(szTmp.isEmpty())szTmp = "*";
m_pMask->setUsername(szTmp.ptr());
szTmp = m_pHostEdit->text();
if(szTmp.isEmpty())szTmp = "*";
m_pMask->setHost(szTmp.ptr());
accept();
}
KviCryptEngine::EncryptResult KviLamerizerEngine::encrypt(const char * plainText,KviCString &outBuffer)
{
outBuffer = plainText;
unsigned char * aux = (unsigned char *)outBuffer.ptr();
if(m_bLight)
{
while(*aux)
{
if(subst_table_light[*aux])
{
*aux = subst_table_light[*aux];
}
aux++;
}
} else {
while(*aux)
{
if(subst_table[*aux])
{
*aux = subst_table[*aux];
}
aux++;
}
}
if(!m_bLight)
{
outBuffer.replaceAll("F","Ph");
outBuffer.replaceAll("V","\\/");
}
return KviCryptEngine::Encoded;
}
bool DccVoiceWindow::event(QEvent *e)
{
if(e->type() == KVI_THREAD_EVENT)
{
switch(((KviThreadEvent *)e)->id())
{
case KVI_DCC_THREAD_EVENT_ERROR:
{
KviError::Code * pError = ((KviThreadDataEvent<KviError::Code> *)e)->getData();
QString ssss = KviError::getDescription(*pError);
output(KVI_OUT_DCCERROR,__tr2qs_ctx("ERROR: %Q","dcc"),&(ssss));
delete pError;
m_pUpdateTimer->stop();
updateInfo();
m_pTalkButton->setEnabled(false);
m_pRecordingLabel->setEnabled(false);
m_pPlayingLabel->setEnabled(false);
return true;
}
break;
case KVI_DCC_THREAD_EVENT_MESSAGE:
{
KviCString * str = ((KviThreadDataEvent<KviCString> *)e)->getData();
outputNoFmt(KVI_OUT_DCCMSG,__tr_no_xgettext_ctx(str->ptr(),"dcc"));
delete str;
return true;
}
break;
case KVI_DCC_THREAD_EVENT_ACTION:
{
int * act = ((KviThreadDataEvent<int> *)e)->getData();
switch(*act)
{
case KVI_DCC_VOICE_THREAD_ACTION_START_RECORDING:
m_pRecordingLabel->setEnabled(true);
break;
case KVI_DCC_VOICE_THREAD_ACTION_STOP_RECORDING:
m_pRecordingLabel->setEnabled(false);
break;
case KVI_DCC_VOICE_THREAD_ACTION_START_PLAYING:
m_pPlayingLabel->setEnabled(true);
break;
case KVI_DCC_VOICE_THREAD_ACTION_STOP_PLAYING:
m_pPlayingLabel->setEnabled(false);
break;
}
delete act;
return true;
}
break;
default:
qDebug("Invalid event type %d received",((KviThreadEvent *)e)->id());
break;
}
}
return KviWindow::event(e);
}
bool KviFile::load(KviCString & szData)
{
kvi_u32_t iLen;
if(!load(iLen))
return false;
szData.setLen(iLen);
return (read((char *)(szData.ptr()), iLen) == iLen);
}
bool KviStupidNotifyListManager::handleIsOn(KviIrcMessage * msg)
{
if(m_pConnection->lagMeter())
m_pConnection->lagMeter()->lagCheckComplete("@notify_naive");
KviCString nk;
const char * aux = msg->trailing();
while(*aux)
{
nk = "";
aux = kvi_extractToken(nk, aux, ' ');
if(nk.hasData())
{
QString nkd = m_pConnection->decodeText(nk.ptr());
QString nksp = " " + nkd;
m_szLastIsOnMsg.replace(nksp, "", Qt::CaseInsensitive);
if(!(m_pConsole->notifyListView()->findEntry(nkd)))
{
// not yet notified
notifyOnLine(nkd);
}
}
}
// ok...check the users that have left irc now...
QStringList sl = m_szLastIsOnMsg.isEmpty() ? QStringList() : m_szLastIsOnMsg.split(' ', QString::SkipEmptyParts);
for(auto & it : sl)
{
if(m_pConsole->notifyListView()->findEntry(it))
{
// has just left irc
notifyOffLine(it);
} // else has never been here...
}
if(((unsigned int)m_iNextNickToCheck) >= m_pNickList->count())
{
// have to restart
unsigned int iTimeout = KVI_OPTION_UINT(KviOption_uintNotifyListCheckTimeInSecs);
if(iTimeout < 5)
{
// life first of all.
// don't allow the user to suicide
if(_OUTPUT_VERBOSE)
m_pConsole->output(KVI_OUT_SYSTEMWARNING,
__tr2qs("Notify list: Timeout (%d sec) is too short, resetting to something more reasonable (5 sec)"),
iTimeout);
iTimeout = 5;
KVI_OPTION_UINT(KviOption_uintNotifyListCheckTimeInSecs) = 5;
}
m_iRestartTimer = startTimer(iTimeout * 1000);
}
else
sendIsOn();
return true;
}
bool KviFile::skipFirst(const KviCString & szT, unsigned int uMaxDist)
{
char * pcPtr = szT.ptr();
while(uMaxDist > 0)
{
char c;
if(!getChar(&c))
return false;
if(c == *pcPtr)
{
pcPtr++;
if(!*pcPtr)
return true;
}
else
{
pcPtr = szT.ptr();
}
uMaxDist--;
}
return false;
}
bool KviMircryptionEngine::doEncryptECB(KviCString & plain, KviCString & encoded)
{
// make sure it is a multiple of 8 bytes (eventually pad with zeroes)
if(plain.len() % 8)
{
int oldL = plain.len();
plain.setLen(plain.len() + (8 - (plain.len() % 8)));
char * padB = plain.ptr() + oldL;
char * padE = plain.ptr() + plain.len();
while(padB < padE)
*padB++ = 0;
}
unsigned char * out = (unsigned char *)KviMemory::allocate(plain.len()); // we use this to avoid endiannes problems
BlowFish bf((unsigned char *)m_szEncryptKey.ptr(), m_szEncryptKey.len());
bf.ResetChain();
bf.Encrypt((unsigned char *)plain.ptr(), out, plain.len(), BlowFish::ECB);
UglyBase64::encode(out, plain.len(), encoded);
KviMemory::free(out);
return true;
}
void KviConfigurationFile::writeEntry(const QString & szKey,const QList<int> &list)
{
m_bDirty = true;
KviConfigurationFileGroup * p_group = getCurrentGroup();
KviCString szData;
for(QList<int>::ConstIterator it = list.begin();it != list.end();++it)
{
if(szData.hasData())szData.append(',');
szData.append(KviCString::Format,"%d",*it);
}
//qDebug("Writing option list for group %s and key %s: %s",m_szGroup.latin1(),szKey.latin1(),szData.ptr());
p_group->replace(szKey,new QString(szData.ptr()));
}
QTextCodec * KviLocale::codecForName(const char * pcName)
{
KviCString szTmp = pcName;
bool bSendUtf8;
int iIdx = szTmp.findFirstIdx('[');
if(iIdx != -1)
{
// Might be a composite codec: either UTF-8 [child codec] or child codec [UTF-8]
KviSmartTextCodec * pCodec = g_pSmartCodecDict->find(pcName);
if(pCodec)
return pCodec; // got cached copy
if(kvi_strEqualCIN("UTF-8 [", pcName, 7))
{
// Likely a smart codec that sends UTF-8
szTmp.replaceAll("UTF-8 [", "");
szTmp.replaceAll("]", "");
bSendUtf8 = true;
}
else
{
// Likely a smart codec that sends child encoding ?
szTmp.cutFromFirst(' ');
bSendUtf8 = false;
}
QTextCodec * pChildCodec = QTextCodec::codecForName(szTmp.ptr());
if(pChildCodec)
{
pCodec = new KviSmartTextCodec(pcName, pChildCodec, bSendUtf8);
if(pCodec->ok())
{
g_pSmartCodecDict->replace(pcName, pCodec);
return pCodec;
}
delete pCodec;
}
else
{
// The name of the child codec was invalid: can't create such a smart codec.
// We probably screwed up the guess above related to the [ char.
// This code path is also triggered by the yircfuzzer by specifying completely invalid codec names.
}
}
return QTextCodec::codecForName(pcName);
}
void OptionsWidget_messageColors::save()
{
QString szName;
QString szInit;
g_pApp->getLocalKvircDirectory(szInit,KviApplication::MsgColors);
if(KviFileDialog::askForSaveFileName(szName,__tr2qs_ctx("Choose a Filename - KVIrc","options"),szInit))
{
if(m_pLastItem)saveLastItem();
KviConfigurationFile cfg(szName,KviConfigurationFile::Write);
cfg.setGroup("Messages");
KviCString tmp;
int count = m_pListView->count();
for(int i=0; i<count;i++)
{
MessageListWidgetItem* it = (MessageListWidgetItem *)m_pListView->item(i);
tmp.sprintf("Fore%d",it->optionId());
cfg.writeEntry(tmp.ptr(),it->msgType()->fore());
tmp.sprintf("Back%d",it->optionId());
cfg.writeEntry(tmp.ptr(),it->msgType()->back());
tmp.sprintf("Icon%d",it->optionId());
cfg.writeEntry(tmp.ptr(),it->msgType()->pixId());
tmp.sprintf("Log%d",it->optionId());
cfg.writeEntry(tmp.ptr(),it->msgType()->logEnabled());
tmp.sprintf("Level%d",it->optionId());
cfg.writeEntry(tmp.ptr(),it->msgType()->level());
}
}
}
bool KviMircryptionEngine::doDecryptCBC(KviCString & encoded, KviCString & plain)
{
if(*(encoded.ptr()) != '*')
{
qDebug("WARNING: specified a CBC key but the incoming message doesn't seem to be a CBC one");
return doDecryptECB(encoded, plain);
}
encoded.cutLeft(1);
char * tmpBuf;
int len = encoded.base64ToBuffer(&tmpBuf, false);
if(len < 0)
{
setLastError(__tr2qs("The message is not a base64 string: this is not my stuff"));
return false;
}
if((len < 8) || (len % 8))
{
setLastError(__tr2qs("The message doesn't seem to be encoded with CBC Mircryption"));
if(len > 0)
KviCString::freeBuffer(tmpBuf);
return false;
}
plain.setLen(len);
BlowFish bf((unsigned char *)m_szDecryptKey.ptr(), m_szDecryptKey.len());
bf.ResetChain();
bf.Decrypt((unsigned char *)tmpBuf, (unsigned char *)plain.ptr(), len, BlowFish::CBC);
// kill the first 8 bytes (random IV)
plain.cutLeft(8);
KviCString::freeBuffer(tmpBuf);
return true;
}
void bufferFromBlock(KviCString & szBuffer)
{
szBuffer.trim();
if((*(szBuffer.ptr()) == '{') && szBuffer.lastCharIs('}'))
{
// leading and trailing { must be stripped
szBuffer.cutLeft(1);
szBuffer.cutRight(1);
}
unindent(szBuffer);
szBuffer.trim();
}
bool KviMircryptionEngine::doDecryptECB(KviCString & encoded, KviCString & plain)
{
unsigned char * buf = nullptr;
int len;
UglyBase64::decode(encoded, &buf, &len);
plain.setLen(len);
BlowFish bf((unsigned char *)m_szDecryptKey.ptr(), m_szDecryptKey.len());
bf.ResetChain();
bf.Decrypt(buf, (unsigned char *)plain.ptr(), len, BlowFish::ECB);
KviMemory::free(buf);
return true;
}
bool KviWinampInterface::playMrl(const QString & mrl)
{
HWND hWinamp = find_winamp(this);
if(hWinamp)
{
QTextCodec * c = mediaplayer_get_codec();
KviCString szMrl = c ? c->fromUnicode(mrl) : mrl.toUtf8();
COPYDATASTRUCT cds;
cds.dwData = IPC_PLAYFILE;
cds.lpData = (void *)szMrl.ptr();
cds.cbData = szMrl.len() + 1; // include space for null char
SendMessage(hWinamp, WM_COPYDATA, (WPARAM)NULL, (LPARAM)&cds);
return true;
}
return false;
}
void KviProxyDataBase::save(const QString & filename)
{
KviConfigurationFile cfg(filename, KviConfigurationFile::Write);
cfg.clear();
cfg.writeEntry("Entries", static_cast<unsigned>(m_pProxyList.size()));
int i = 0;
for(auto & p : m_pProxyList)
{
KviCString tmp(KviCString::Format, "%u_Hostname", i);
cfg.writeEntry(tmp.ptr(), p->m_szHostname);
tmp.sprintf("%u_Port", i);
cfg.writeEntry(tmp.ptr(), p->m_uPort);
tmp.sprintf("%u_Ip", i);
cfg.writeEntry(tmp.ptr(), p->m_szIp);
tmp.sprintf("%u_User", i);
cfg.writeEntry(tmp.ptr(), p->m_szUser);
tmp.sprintf("%u_Pass", i);
cfg.writeEntry(tmp.ptr(), p->m_szPass);
tmp.sprintf("%u_Protocol", i);
KviCString type;
switch(p->m_protocol)
{
case KviProxy::Socks5:
type = "SOCKSv5";
break;
case KviProxy::Http:
type = "HTTP";
break;
default:
type = "SOCKSv4";
break;
}
cfg.writeEntry(tmp.ptr(), type.ptr());
tmp.sprintf("%u_IsIPv6", i);
cfg.writeEntry(tmp.ptr(), p->m_bIsIPv6);
tmp.sprintf("%u_Current", i);
if(m_pCurrentProxy == p.get())
cfg.writeEntry(tmp.ptr(), true);
i++;
}
}
KviCryptEngine::EncryptResult KviRot13Engine::encrypt(const char * plainText,KviCString &outBuffer)
{
outBuffer = plainText;
unsigned char * aux = (unsigned char *)outBuffer.ptr();
while(*aux)
{
if(isalpha(*aux))
{
char l = toupper(*aux);
if (l >= 'N' && l <= 'Z')
*aux = *aux - 13;
else if (l >= 'A' && l <= 'M')
*aux = *aux + 13;
}
aux++;
}
return KviCryptEngine::Encoded;
}
void KviInputHistory::load(const QString & szFileName)
{
KviConfigurationFile c(szFileName, KviConfigurationFile::Read);
int iCount = c.readIntEntry("Count", 0);
if(iCount > KVI_INPUT_MAX_GLOBAL_HISTORY_ENTRIES)
iCount = KVI_INPUT_MAX_GLOBAL_HISTORY_ENTRIES;
KviCString szTmp;
for(int i = 0; i < iCount; i++)
{
szTmp.sprintf("S%d", i);
QString szEntry = c.readEntry(szTmp.ptr(), "");
if(!szEntry.isEmpty())
add(szEntry);
}
}
static Window kvi_x11_findIpcSentinel(Window win)
{
Atom type;
int format;
unsigned long nItems, after;
unsigned char * data = nullptr;
if(XGetWindowProperty(kvi_ipc_get_xdisplay(), win, kvi_atom_ipc_sentinel_window,
0, 32, false, XA_STRING, &type, &format, &nItems, &after, &data) == Success)
{
if((type == XA_STRING) && (format == 8))
{
if((nItems == ((unsigned long)(kvi_sentinel_id.len()))) && data)
{
if(kvi_strEqualCSN((const char *)data, kvi_sentinel_id.ptr(), kvi_sentinel_id.len()))
{
XFree((char *)data);
return win;
}
}
}
}
Window root, parent;
Window * children;
unsigned int nChildren;
if(!XQueryTree(kvi_ipc_get_xdisplay(), win, &root, &parent, &children, &nChildren))
{
if(children)
XFree((char *)children);
return 0;
}
Window found = 0;
for(size_t i = 0; !found && i < nChildren; ++i)
found = kvi_x11_findIpcSentinel(children[i]);
if(children)
XFree((char *)children);
return found;
}
void KviInputHistory::save(const QString & szFileName)
{
KviConfigurationFile c(szFileName, KviConfigurationFile::Write);
c.clear();
c.writeEntry("Count", static_cast<unsigned>(m_StringList.size()));
KviCString szTmp;
int iIdx = 0;
for(auto & szString : m_StringList)
{
if(!szString.isEmpty())
{
szTmp.sprintf("S%d", iIdx);
c.writeEntry(szTmp.ptr(), szString);
iIdx++;
}
}
}
void KviVariantTableItem::setContentFromEditor(QWidget * w)
{
switch(m_property.type())
{
case QVariant::String:
m_property = QVariant(((QLineEdit *)w)->text());
break;
case QVariant::Int:
m_property = QVariant(((QLineEdit *)w)->text().toInt());
break;
case QVariant::UInt:
m_property = QVariant(((QLineEdit *)w)->text().toUInt());
break;
case QVariant::Bool:
m_property = QVariant(((QComboBox *)w)->currentItem(),1);
break;
case QVariant::Color:
m_property.asColor().setNamedColor(((QLineEdit *)w)->text());
break;
case QVariant::Font:
{
KviCString txt = ((QComboBox *)w)->currentText();
if(txt.hasData())
{
KviCString fam = txt;
fam.cutFromFirst(',',true);
fam.trimmed();
KviCString psz = txt;
psz.cutToFirst(',',true);
psz.trimmed();
bool bOk;
unsigned int uSize = psz.toUInt(&bOk);
if(!bOk)uSize = 12;
m_property = QVariant(QFont(fam.ptr(),uSize));
}
}
break;
default:
break;
}
}
bool KviIsOnNotifyListManager::handleUserhost(KviIrcMessage * msg)
{
if(!m_bExpectingUserhost)
return false;
// first check for consistency: all the replies must be on the USERHOST list
KviPointerList<KviIrcMask> tmplist;
tmplist.setAutoDelete(true);
KviCString nk;
const char * aux = msg->trailing();
while(*aux)
{
nk = "";
aux = kvi_extractToken(nk, aux, ' ');
if(nk.hasData())
{
// split it in a mask
KviCString nick;
KviCString user;
KviCString host;
int idx = nk.findFirstIdx('=');
if(idx != -1)
{
nick = nk.left(idx);
if(nick.lastCharIs('*'))
nick.cutRight(1);
nk.cutLeft(idx + 1);
if(nk.firstCharIs('+') || nk.firstCharIs('-'))
nk.cutLeft(1);
idx = nk.findFirstIdx('@');
if(idx != -1)
{
user = nk.left(idx);
nk.cutLeft(idx + 1);
host = nk;
}
else
{
user = "******";
host = nk;
}
bool bGotIt = false;
QString szNick = m_pConnection->decodeText(nick.ptr());
QString szUser = m_pConnection->decodeText(user.ptr());
QString szHost = m_pConnection->decodeText(host.ptr());
for(QString * s = m_pUserhostList->first(); s && (!bGotIt); s = m_pUserhostList->next())
{
if(KviQString::equalCI(*s, szNick))
{
KviIrcMask * mk = new KviIrcMask(szNick, szUser, szHost);
tmplist.append(mk);
bGotIt = true;
m_pUserhostList->removeRef(s);
}
}
if(!bGotIt)
{
// ops...not my userhost!
if(_OUTPUT_VERBOSE)
m_pConsole->output(KVI_OUT_SYSTEMWARNING, __tr2qs("Notify list: Hey! You've used USERHOST behind my back? (I might be confused now...)"));
return false;
}
}
else
{
if(_OUTPUT_VERBOSE)
m_pConsole->output(KVI_OUT_SYSTEMWARNING, __tr2qs("Notify list: Broken USERHOST reply from the server? (%s)"), nk.ptr());
}
}
}
// Ok...looks to be my usershot (still not sure at 100%, but can't do better)
if(m_pConnection->lagMeter())
m_pConnection->lagMeter()->lagCheckComplete("@notify_userhost");
m_bExpectingUserhost = false;
for(KviIrcMask * mk = tmplist.first(); mk; mk = tmplist.next())
{
if(!doMatchUser(mk->nick(), *mk))
return true; // have to restart!!!
}
if(!(m_pUserhostList->isEmpty()))
{
// ops...someone is no longer online ?
while(QString * s = m_pUserhostList->first())
{
if(_OUTPUT_VERBOSE)
m_pConsole->output(KVI_OUT_SYSTEMMESSAGE, __tr2qs("Notify list: \r!n\r%Q\r appears to have gone offline before USERHOST reply was received, will recheck in the next loop"), s);
m_pUserhostList->removeFirst();
}
}
if(m_pOnlineList->isEmpty())
{
if(m_pNotifyList->isEmpty())
delayedNotifySession();
else
delayedIsOnSession();
}
else
delayedUserhostSession();
return true;
}
