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();
}
KVIRC_API void printSSLCertificate(KviWindow * wnd, const char * description, KviSSLCertificate * c)
{
wnd->output(KVI_OUT_SSL, __tr2qs("[SSL]: %c%s"), KviControlCodes::Bold, description);
wnd->output(KVI_OUT_SSL, __tr2qs("[SSL]: Version: %c%d"), KviControlCodes::Bold, c->version());
wnd->output(KVI_OUT_SSL, __tr2qs("[SSL]: Serial number: %c%d"), KviControlCodes::Bold, c->serialNumber());
wnd->output(KVI_OUT_SSL, __tr2qs("[SSL]: Subject:"));
wnd->output(KVI_OUT_SSL, __tr2qs("[SSL]: Common name: %c%s"), KviControlCodes::Bold, c->subjectCommonName());
wnd->output(KVI_OUT_SSL, __tr2qs("[SSL]: Organization: %c%s"), KviControlCodes::Bold, c->subjectOrganization());
wnd->output(KVI_OUT_SSL, __tr2qs("[SSL]: Organizational unit: %c%s"), KviControlCodes::Bold, c->subjectOrganizationalUnit());
wnd->output(KVI_OUT_SSL, __tr2qs("[SSL]: Country: %c%s"), KviControlCodes::Bold, c->subjectCountry());
wnd->output(KVI_OUT_SSL, __tr2qs("[SSL]: State or province: %c%s"), KviControlCodes::Bold, c->subjectStateOrProvince());
wnd->output(KVI_OUT_SSL, __tr2qs("[SSL]: Locality: %c%s"), KviControlCodes::Bold, c->subjectLocality());
wnd->output(KVI_OUT_SSL, __tr2qs("[SSL]: Issuer:"));
wnd->output(KVI_OUT_SSL, __tr2qs("[SSL]: Common name: %c%s"), KviControlCodes::Bold, c->issuerCommonName());
wnd->output(KVI_OUT_SSL, __tr2qs("[SSL]: Organization: %c%s"), KviControlCodes::Bold, c->issuerOrganization());
wnd->output(KVI_OUT_SSL, __tr2qs("[SSL]: Organizational unit: %c%s"), KviControlCodes::Bold, c->issuerOrganizationalUnit());
wnd->output(KVI_OUT_SSL, __tr2qs("[SSL]: Country: %c%s"), KviControlCodes::Bold, c->issuerCountry());
wnd->output(KVI_OUT_SSL, __tr2qs("[SSL]: State or province: %c%s"), KviControlCodes::Bold, c->issuerStateOrProvince());
wnd->output(KVI_OUT_SSL, __tr2qs("[SSL]: Locality: %c%s"), KviControlCodes::Bold, c->issuerLocality());
wnd->output(KVI_OUT_SSL, __tr2qs("[SSL]: Public key: %c%s (%d bits)"), KviControlCodes::Bold, c->publicKeyType(), c->publicKeyBits());
wnd->output(KVI_OUT_SSL, __tr2qs("[SSL]: Signature type: %c%s"), KviControlCodes::Bold, c->signatureType());
KviCString tmp = c->signatureContents();
if(tmp.len() > 40)
{
tmp.cutRight(tmp.len() - 40);
tmp.append("...");
}
wnd->output(KVI_OUT_SSL, __tr2qs("[SSL]: Signature contents: %c%s"), KviControlCodes::Bold, tmp.ptr());
}
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());
}
}
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;
}
KviCryptEngine::EncryptResult KviMircryptionEngine::encrypt(const char * plainText, KviCString & outBuffer)
{
KviCString szPlain = plainText;
outBuffer = "";
if(m_bEncryptCBC)
{
if(!doEncryptCBC(szPlain, outBuffer))
return KviCryptEngine::EncryptError;
}
else
{
if(!doEncryptECB(szPlain, outBuffer))
return KviCryptEngine::EncryptError;
}
outBuffer.prepend("+OK ");
if(outBuffer.len() > maxEncryptLen())
{
if(maxEncryptLen() > 0)
{
setLastError(__tr2qs("Data buffer too long"));
return KviCryptEngine::EncryptError;
}
}
//outBuffer = MCPS2_STARTTAG;
//outBuffer += MCPS2_ENDTAG;
return KviCryptEngine::Encrypted;
}
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 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);
}
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);
}
void RegisteredUserEntryDialog::editAllPropertiesClicked()
{
m_pAvatarSelector->commit();
if(m_pAvatar->isNull())
{
m_pPropertyDict->remove("avatar");
} else {
KviCString szPath = m_pAvatar->path();
if(szPath.isEmpty())m_pPropertyDict->remove("avatar");
else m_pPropertyDict->replace("avatar",new QString(szPath));
}
if(m_pNotifyCheck->isChecked())
{
QString szNicks = m_pNotifyNick->text();
if(!szNicks.isEmpty())
{
m_pPropertyDict->replace("notify",new QString(szNicks));
} else {
m_pPropertyDict->remove("notify");
}
} else {
m_pPropertyDict->remove("notify");
}
RegisteredUserPropertiesDialog * dlg = new RegisteredUserPropertiesDialog(this,m_pPropertyDict);
if(dlg->exec() != QDialog::Accepted)
{
delete dlg;
return;
}
delete dlg;
QString * notify = m_pPropertyDict->find("notify");
bool bGotIt = false;
if(notify)
{
if(!notify->isEmpty())
{
bGotIt = true;
m_pNotifyNick->setText(*notify);
}
}
m_pNotifyCheck->setChecked(bGotIt);
m_pNotifyNick->setEnabled(bGotIt);
if(!bGotIt)m_pNotifyNick->setText("");
QString * avatar = m_pPropertyDict->find("avatar");
bGotIt = false;
if(avatar)
{
if(!avatar->isEmpty())
m_pAvatarSelector->setImagePath(*avatar);
}
}
bool KviFile::load(KviCString & szData)
{
kvi_u32_t iLen;
if(!load(iLen))
return false;
szData.setLen(iLen);
return (read((char *)(szData.ptr()), iLen) == iLen);
}
void blockFromBuffer(KviCString & szBuffer)
{
indent(szBuffer);
szBuffer.prepend("{\n");
szBuffer.stripRightWhiteSpace();
szBuffer.ensureLastCharIs('\n');
szBuffer.append("}\n");
}
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;
}
void indent(KviCString & szBuffer)
{
// we can format correctly up to 65536 lines (that's really enough)
int iRealLen;
KviCString ** pszArray = szBuffer.splitToArray('\n',65536,&iRealLen);
if(pszArray)
{
addLeading(pszArray,'\t');
szBuffer.joinFromArray(pszArray,"\n",true);
KviCString::freeArray(pszArray);
}
}
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;
}
KviCryptEngine::EncryptResult KviRijndaelEngine::encrypt(const char * plainText, KviCString & outBuffer)
{
if(!m_pEncryptCipher)
{
setLastError(__tr2qs("Oops! Encryption cipher not initialized"));
return KviCryptEngine::EncryptError;
}
int len = (int)kvi_strLen(plainText);
char * buf = (char *)KviMemory::allocate(len + 16); // needed for the eventual padding
unsigned char * iv = nullptr;
if(m_bEncryptMode == CBC)
{
iv = (unsigned char *)KviMemory::allocate(MAX_IV_SIZE);
InitVectorEngine::fillRandomIV(iv, MAX_IV_SIZE);
}
int retVal = m_pEncryptCipher->padEncrypt((const unsigned char *)plainText, len, (unsigned char *)buf, iv);
if(retVal < 0)
{
KviMemory::free(buf);
setLastErrorFromRijndaelErrorCode(retVal);
return KviCryptEngine::EncryptError;
}
if(m_bEncryptMode == CBC)
{
// prepend the iv to the cyphered text
buf = (char *)KviMemory::reallocate(buf, retVal + MAX_IV_SIZE);
KviMemory::move(buf + MAX_IV_SIZE, buf, retVal);
KviMemory::move(buf, iv, MAX_IV_SIZE);
KviMemory::free(iv);
retVal += MAX_IV_SIZE;
}
if(!binaryToAscii(buf, retVal, outBuffer))
{
KviMemory::free(buf);
return KviCryptEngine::EncryptError;
}
KviMemory::free(buf);
if(outBuffer.len() > maxEncryptLen())
{
if(maxEncryptLen() > 0)
{
setLastError(__tr2qs("Data buffer too long"));
return KviCryptEngine::EncryptError;
}
}
outBuffer.prepend(KviControlCodes::CryptEscape);
return KviCryptEngine::Encrypted;
}
bool fromString(const QString & szValue, QFont & buffer)
{
KviCString str = szValue;
KviCString family, pointSize, styleHint, weight, options;
str.getToken(family, ',');
str.getToken(pointSize, ',');
str.getToken(styleHint, ',');
str.getToken(weight, ',');
if(!family.isEmpty())
buffer.setFamily(family.ptr());
int i;
bool bOk;
i = pointSize.toInt(&bOk);
if(bOk && (i > 0))
buffer.setPointSize(i);
i = styleHint.toInt(&bOk);
if(bOk && (i >= 0))
buffer.setStyleHint((QFont::StyleHint)i);
i = weight.toInt(&bOk);
if(bOk && (i >= 0))
buffer.setWeight(i);
buffer.setBold(str.contains("b"));
buffer.setItalic(str.contains("i"));
buffer.setUnderline(str.contains("u"));
buffer.setStrikeOut(str.contains("s"));
buffer.setFixedPitch(str.contains("f"));
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()));
}
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;
}
void KviUIntSelector::commit()
{
KviCString tmp = m_pSpinBox->cleanText();
bool bOk;
unsigned int val = tmp.toUInt(&bOk);
if(!bOk)val = m_uDefault;
if(m_uHighBound > m_uLowBound)
{
if(val < m_uLowBound)val = m_uLowBound;
else if(val > m_uHighBound)val = m_uHighBound;
}
if(m_bIsShortInt)*((unsigned short int *)m_pOption) = (unsigned short int)val;
else *m_pOption = val;
}
bool plainMethod(KviCString & szIn, KviCString & szOut, QByteArray & baNick, QByteArray & baPass)
{
if(szIn=="+")
{
int answerLen = 2 + (2 * baNick.size()) + baPass.size();
char * answer = (char *) KviMemory::allocate(answerLen);
char * answer2 = answer;
memcpy(answer, baNick.data(), baNick.size());
answer+=baNick.size();
memset(answer, 0, 1);
answer++;
memcpy(answer, baNick.data(), baNick.size());
answer+=baNick.size();
memset(answer, 0, 1);
answer++;
memcpy(answer, baPass.data(), baPass.size());
szOut.bufferToBase64(answer2,answerLen);
KviMemory::free(answer2);
return true;
}
return false;
}
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;
}
bool KviIrcUrl::parse(const char * url, KviCString & cmdBuffer, int contextSpec)
{
// irc[6]://<server>[:<port>][/<channel>[?<pass>]]
KviIrcUrlParts urlParts;
KviIrcUrl::split(url, urlParts);
if(urlParts.iError & InvalidUrl)
return false;
cmdBuffer = "server ";
switch(contextSpec)
{
case KVI_IRCURL_CONTEXT_FIRSTFREE:
cmdBuffer.append("-u ");
break;
case KVI_IRCURL_CONTEXT_NEW:
cmdBuffer.append("-n ");
break;
}
if(urlParts.bIPv6)
cmdBuffer.append(" -i ");
if(urlParts.bSsl)
cmdBuffer.append(" -s ");
QString channels, passwords;
QStringList splitted;
if(urlParts.chanList.size())
{
for(int i = 0; i < urlParts.chanList.size(); ++i)
{
splitted = urlParts.chanList[i].split("?");
if(i)
channels.append(",");
if(!(splitted[0].startsWith("#") || splitted[0].startsWith("!") || splitted[0].startsWith("&")))
channels.append("#");
channels.append(splitted[0]);
if(splitted.size() > 1)
{
if(i)
passwords.append(",");
passwords.append(splitted[1]);
}
}
cmdBuffer.append(KviCString::Format, " -c=\"join %s %s\" ", channels.data(), passwords.data());
}
cmdBuffer.append(urlParts.szHost);
cmdBuffer.append(KviCString::Format, " %d", urlParts.iPort);
cmdBuffer.append(';');
return true;
}
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++;
}
}
void RegistrationWizard::notifyNickChanged(const QString &)
{
bool bYes = !m_pNotifyCheck->isChecked();
if(!bYes)
{
// we need at least one nickname then :)
KviCString tmp = m_pNotifyNickEdit1->text();
if(tmp.hasData())
{
bYes = true;
} else {
tmp = m_pNotifyNickEdit2->text();
if(tmp.hasData())bYes = true;
}
}
setNextEnabled(m_pPage4,bYes);
}
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++;
}
}
}
static void kvi_ipcLoadAtoms()
{
if(g_bIpcAtomsLoaded)
return;
g_bIpcAtomsLoaded = true;
g_uLocalInstanceId = (kvi_u64_t)::getpid();
kvi_sentinel_id.sprintf("pane tonno e mistero - %d", getuid());
kvi_atom_ipc_sentinel_window = XInternAtom(kvi_ipc_get_xdisplay(), "XA_KVI4_IPC_SENTINEL_WINDOW", False);
kvi_atom_ipc_remote_command = XInternAtom(kvi_ipc_get_xdisplay(), "XA_KVI4_IPC_REMOTE_COMMAND", False);
kvi_atom_ipc_remote_message = XInternAtom(kvi_ipc_get_xdisplay(), "XA_KVI4_IPC_REMOTE_MESSAGE", False);
}
