LRESULT EncryptionPage::onBrowseCertificate(WORD /*wNotifyCode*/, WORD /*wID*/, HWND /*hWndCtl*/, BOOL& /*bHandled*/) {
tstring target = Text::toT(SETTING(TLS_CERTIFICATE_FILE));
CEdit edt(GetDlgItem(IDC_TLS_CERTIFICATE_FILE));
BrowseDlg dlg(m_hWnd, BrowseDlg::TYPE_NOSAVE, BrowseDlg::DIALOG_SELECT_FILE);
dlg.setPath(target, true);
if (dlg.show(target)) {
edt.SetWindowText(&target[0]);
}
return 0;
}
void Client::reloadSettings(bool updateNick) {
FavoriteHubEntry* hub = FavoriteManager::getInstance()->getFavoriteHubEntry(getHubUrl());
if(hub) {
if(updateNick) {
setCurrentNick(checkNick(hub->getNick(true)));
}
if(!hub->getUserDescription().empty()) {
setCurrentDescription(hub->getUserDescription());
} else {
setCurrentDescription(SETTING(DESCRIPTION));
}
if(!hub->getPassword().empty())
setPassword(hub->getPassword());
} else {
if(updateNick) {
setCurrentNick(checkNick(SETTING(NICK)));
}
setCurrentDescription(SETTING(DESCRIPTION));
}
}
void SpeedPage::write() {
PropPage::write((HWND)(*this), items);
if (!SETTING(DL_AUTODETECT)) {
PropPage::write((HWND)(*this), downloadItems);
}
if (!SETTING(UL_AUTODETECT)) {
PropPage::write((HWND)(*this), uploadItems);
if(SETTING(SLOTS) < 1)
settings->set(SettingsManager::SLOTS, 1);
if(SETTING(EXTRA_SLOTS) < 1)
settings->set(SettingsManager::EXTRA_SLOTS, 1);
if(SETTING(SET_MINISLOT_SIZE) < 64)
settings->set(SettingsManager::SET_MINISLOT_SIZE, 64);
}
if (!SETTING(MCN_AUTODETECT)) {
validateMCNLimits(0);
PropPage::write((HWND)(*this), mcnItems);
/*if(SETTING(MAX_MCN_DOWNLOADS) < 1)
settings->set(SettingsManager::MAX_MCN_DOWNLOADS, AirUtil::getSlotsPerUser(true, Util::toDouble(SETTING(DOWNLOAD_SPEED))));
if(SETTING(MAX_MCN_UPLOADS) < 1)
settings->set(SettingsManager::MAX_MCN_UPLOADS, AirUtil::getSlotsPerUser(false, Util::toDouble(SETTING(UPLOAD_SPEED))));*/
}
}
// [++]NSL
LRESULT PropPageTextStyles::onSelectColor(WORD /*wNotifyCode*/, WORD wID, HWND /*hWndCtl*/, BOOL& /*bHandled*/)
{
int color;
SettingsManager::IntSetting key;
switch (wID)
{
case IDC_DUPE_COLOR:
color = SETTING(DUPE_COLOR);
key = SettingsManager::DUPE_COLOR;
break;
case IDC_DUPE_EX1:
color = SETTING(DUPE_EX1_COLOR);
key = SettingsManager::DUPE_EX1_COLOR;
break;
case IDC_DUPE_EX2:
color = SETTING(DUPE_EX2_COLOR);
key = SettingsManager::DUPE_EX2_COLOR;
break;
case IDC_DUPE_EX3:
color = SETTING(DUPE_EX3_COLOR);
key = SettingsManager::DUPE_EX3_COLOR;
break;
case IDC_BAN_COLOR:
color = SETTING(BAN_COLOR);
key = SettingsManager::BAN_COLOR;
break;
default:
color = SETTING(ERROR_COLOR);
key = SettingsManager::ERROR_COLOR;
}
CColorDialog dlg(color, CC_FULLOPEN);
if (dlg.DoModal() == IDOK)
SettingsManager::set(key, (int)dlg.GetColor());
return 0;
}
void BufferedSocket::connect(const string& aAddress, uint16_t aPort, bool secure, bool allowUntrusted, bool proxy) throw(SocketException, ThreadException) {
dcassert(!sock);
try {
dcdebug("BufferedSocket::connect() %p\n", (void*)this);
sock = secure ? CryptoManager::getInstance()->getClientSocket(allowUntrusted) : new Socket;
sock->create();
sock->bind(0, SETTING(BIND_ADDRESS));
if(SETTING(SOCKET_IN_BUFFER) >= 1024)
sock->setSocketOpt(SO_RCVBUF, SETTING(SOCKET_IN_BUFFER));
if(SETTING(SOCKET_OUT_BUFFER) >= 1024)
sock->setSocketOpt(SO_SNDBUF, SETTING(SOCKET_OUT_BUFFER));
sock->setBlocking(false);
inbuf.resize(sock->getSocketOptInt(SO_RCVBUF));
Lock l(cs);
start();
addTask(CONNECT, new ConnectInfo(aAddress, aPort, proxy && (SETTING(OUTGOING_CONNECTIONS) == SettingsManager::OUTGOING_SOCKS5)));
} catch(...) {
delete sock;
sock = 0;
throw;
}
}
void ConnectivityManager::setup_connections(bool settingsChanged)
{
try
{
if (BOOLSETTING(AUTO_DETECT_CONNECTION))
{
if (!autoDetected)
detectConnection();
}
else
{
if (autoDetected || settingsChanged)
{
if (settingsChanged || SETTING(INCOMING_CONNECTIONS) != SettingsManager::INCOMING_FIREWALL_UPNP)
{
MappingManager::getInstance()->close();
}
startSocket();
}
else if (SETTING(INCOMING_CONNECTIONS) == SettingsManager::INCOMING_FIREWALL_UPNP && !MappingManager::getInstance()->getOpened())
{
// previous mappings had failed; try again
MappingManager::getInstance()->open();
}
}
}
catch (const Exception& e)
{
dcassert(0);
const string l_error = "ConnectivityManager::setup error = " + e.getError();
CFlyServerJSON::pushError(56, l_error);
}
if (settingsChanged)
{
if (SETTING(INCOMING_CONNECTIONS) != SettingsManager::INCOMING_FIREWALL_UPNP)
{
test_all_ports();
}
}
}
int SearchManager::run() {
boost::scoped_array<uint8_t> buf(new uint8_t[BUFSIZE]);
int len;
string remoteAddr;
while(!stop) {
try {
while( true ) {
// Patch from FlylinkDC++, see:
// http://code.google.com/p/flylinkdc/source/detail?r=6132
// http://bazaar.launchpad.net/~dcplusplus-team/dcplusplus/trunk/revision/2414
// .
// @todo: remove this workaround for http://bugs.winehq.org/show_bug.cgi?id=22291
// if that's fixed by reverting to simpler while (read(...) > 0) {...} code.
while (socket->wait(400, Socket::WAIT_READ) != Socket::WAIT_READ);
if (stop || (len = socket->read(&buf[0], BUFSIZE, remoteAddr)) <= 0)
break;
onData(&buf[0], len, remoteAddr);
}
} catch(const SocketException& e) {
dcdebug("SearchManager::run Error: %s\n", e.getError().c_str());
}
bool failed = false;
while(!stop) {
try {
socket->disconnect();
socket->create(Socket::TYPE_UDP);
socket->setBlocking(true);
socket->bind(port, SETTING(BIND_ADDRESS));
if(failed) {
LogManager::getInstance()->message(_("Search enabled again"));
failed = false;
}
break;
} catch(const SocketException& e) {
dcdebug("SearchManager::run Stopped listening: %s\n", e.getError().c_str());
if(!failed) {
LogManager::getInstance()->message(str(F_("Search disabled: %1%") % e.getError()));
failed = true;
}
// Spin for 60 seconds
for(int i = 0; i < 60 && !stop; ++i) {
Thread::sleep(1000);
}
}
}
}
return 0;
}
LRESULT ProtocolPage::onInitDialog(UINT /*uMsg*/, WPARAM /*wParam*/, LPARAM /*lParam*/, BOOL& /*bHandled*/)
{
SettingTab::translate((HWND)(*this), texts);
cAutoDetect.Attach(GetDlgItem(IDC_CONNECTION_DETECTION));
SetDlgItemText(IDC_PROTOCOL_ENABLED, CTSTRING_F(ENABLE_CONNECTIVITY, (v6 ? "IPv6" : "IPv4")));
auto mode = v6 ? SETTING(INCOMING_CONNECTIONS6) : SETTING(INCOMING_CONNECTIONS);
if (mode == SettingsManager::INCOMING_DISABLED) {
CheckDlgButton(IDC_PROTOCOL_ENABLED, BST_UNCHECKED);
CheckDlgButton(IDC_ACTIVE, BST_CHECKED);
} else {
CheckDlgButton(IDC_PROTOCOL_ENABLED, BST_CHECKED);
switch(mode) {
case SettingsManager::INCOMING_ACTIVE:
CheckDlgButton(IDC_ACTIVE, BST_CHECKED);
break;
case SettingsManager::INCOMING_ACTIVE_UPNP:
CheckDlgButton(IDC_ACTIVE_UPNP, BST_CHECKED);
break;
case SettingsManager::INCOMING_PASSIVE:
CheckDlgButton(IDC_PASSIVE, BST_CHECKED);
break;
default:
CheckDlgButton(IDC_ACTIVE, BST_CHECKED);
break;
}
}
SettingTab::read((HWND)(*this), v6 ? items6 : items4);
fixControls();
// Bind address
BindCombo.Attach(GetDlgItem(IDC_BIND_ADDRESS));
getAddresses();
return TRUE;
}
LRESULT AdvancedPage::onInitDialog(UINT /*uMsg*/, WPARAM /*wParam*/, LPARAM /*lParam*/, BOOL& /*bHandled*/)
{
PropPage::translate(texts);
PropPage::read(items);
PropPage::readCheckBoxList(listItems, GetDlgItem(IDC_ADVANCED_BOOLEANS));
CurSel = SETTING(MEDIA_PLAYER);
WMPlayerStr = Text::toT(SETTING(WMP_FORMAT));
WinampStr = Text::toT(SETTING(WINAMP_FORMAT));
iTunesStr = Text::toT(SETTING(ITUNES_FORMAT));
MPCStr = Text::toT(SETTING(MPLAYERC_FORMAT));
ctrlPlayer.Attach(GetDlgItem(IDC_PLAYER_COMBO));
ctrlPlayer.AddString(_T("Winamp"));
ctrlPlayer.AddString(_T("Windows Media Player"));
ctrlPlayer.AddString(_T("iTunes"));
ctrlPlayer.AddString(_T("Media Player Classic"));
ctrlPlayer.SetCurSel(CurSel);
loadFormat();
return TRUE;
}
void HttpConnection::on(BufferedSocketListener::Failed, const string& aLine) throw() {
socket->removeListener(this);
BufferedSocket::putSocket(socket);
socket = NULL;
if(SETTING(CORAL) && coralizeState == CST_DEFAULT) {
coralizeState = CST_NOCORALIZE;
dcdebug("Coralized address failed, retrying : %s\n",currentUrl.c_str());
downloadFile(currentUrl);
return;
}
coralizeState = CST_DEFAULT;
fire(HttpConnectionListener::Failed(), this, aLine + " (" + currentUrl + ")");
}
void ClientManager::on(HubUserCommand, Client* client, int aType, int ctx, const string& name, const string& command) noexcept {
if(SETTING(HUB_USER_COMMANDS)) {
if(aType == UserCommand::TYPE_REMOVE) {
int cmd = FavoriteManager::getInstance()->findUserCommand(name, client->getHubUrl());
if(cmd != -1)
FavoriteManager::getInstance()->removeUserCommand(cmd);
} else if(aType == UserCommand::TYPE_CLEAR) {
FavoriteManager::getInstance()->removeHubUserCommands(ctx, client->getHubUrl());
} else {
FavoriteManager::getInstance()->addUserCommand(aType, ctx, UserCommand::FLAG_NOSAVE, name, command, "", client->getHubUrl());
}
}
}
void FinishedManager::on(QueueManagerListener::Finished, const QueueItemPtr& qi, const string&, const HintedUser& aUser, int64_t aSpeed) noexcept {
if(!qi->isSet(QueueItem::FLAG_USER_LIST) || SETTING(LOG_FILELIST_TRANSFERS)) {
FinishedItemPtr item = new FinishedItem(qi->getTarget(), aUser, qi->getSize(), static_cast<int64_t>(aSpeed), GET_TIME(), qi->getTTH().toBase32());
{
Lock l(cs);
downloads.push_back(item);
}
fire(FinishedManagerListener::AddedDl(), item);
if(SETTING(SYSTEM_SHOW_DOWNLOADS)) {
size_t BUF_SIZE = STRING(FINISHED_DOWNLOAD).size() + UNC_MAX_PATH + 128;
char* buf = new char[BUF_SIZE];
snprintf(buf, BUF_SIZE, CSTRING(FINISHED_DOWNLOAD), Util::getFileName(qi->getTarget()).c_str(),
Util::toString(ClientManager::getInstance()->getNicks(aUser)).c_str());
LogManager::getInstance()->message(buf, LogManager::LOG_INFO);
delete[] buf;
}
}
}
LRESULT LocationsPage::onClickedBrowseTempDir(WORD /*wNotifyCode*/, WORD /*wID*/, HWND /*hWndCtl*/, BOOL& /*bHandled*/)
{
tstring dir = Text::toT(SETTING(TEMP_DOWNLOAD_DIRECTORY));
if(WinUtil::browseDirectory(dir, m_hWnd))
{
// Adjust path string
if(dir.size() > 0 && dir[dir.size() - 1] != '\\')
dir += '\\';
SetDlgItemText(IDC_TEMP_DOWNLOAD_DIRECTORY, dir.c_str());
}
return 0;
}
LRESULT UsersFrame::onOpenUserLog(WORD /*wNotifyCode*/, WORD /*wID*/, HWND /*hWndCtl*/, BOOL& /*bHandled*/) {
if(ctrlUsers.GetSelectedCount() == 1) {
int i = ctrlUsers.GetNextItem(-1, LVNI_SELECTED);
const UserInfo* ui = ctrlUsers.getItemData(i);
dcassert(i != -1);
StringMap params;
params["hubNI"] = Util::toString(ClientManager::getInstance()->getHubNames(ui->getUser()->getCID(), Util::emptyString));
params["hubURL"] = Util::toString(ClientManager::getInstance()->getHubs(ui->getUser()->getCID(), Util::emptyString));
params["userCID"] = ui->getUser()->getCID().toBase32();
params["userNI"] = Util::toString(ClientManager::getInstance()->getNicks(ui->getUser()->getCID(), Util::emptyString))[0];
params["myCID"] = ClientManager::getInstance()->getMe()->getCID().toBase32();
string file = Util::validateFileName(SETTING(LOG_DIRECTORY) + Util::formatParams(SETTING(LOG_FILE_PRIVATE_CHAT), params, false));
if(Util::fileExists(file)) {
ShellExecute(NULL, NULL, Text::toT(file).c_str(), NULL, NULL, SW_SHOWNORMAL);
} else {
MessageBox(CTSTRING(NO_LOG_FOR_USER), CTSTRING(NO_LOG_FOR_USER), MB_OK );
}
}
return 0;
}
bool ShareManager::checkInvalidFileSize(uint64_t size) const
{
uint64_t minimumSize = SETTING(SHARING_SKIPLIST_MINSIZE);
if(minimumSize != 0)
{
if( size < minimumSize )
{
return false;
}
}
uint64_t maximumSize = SETTING(SHARING_SKIPLIST_MAXSIZE);
if(maximumSize != 0)
{
if( size > maximumSize )
{
return false;
}
}
return true;
}
void EmoticonsManager::Load() {
setUseEmoticons(false);
if((SETTING(EMOTICONS_FILE) == "Disabled") || !Util::fileExists(Util::getPath(Util::PATH_EMOPACKS) + SETTING(EMOTICONS_FILE) + ".xml" )) {
return;
}
try {
SimpleXML xml;
xml.fromXML(File(Util::getPath(Util::PATH_EMOPACKS) + SETTING(EMOTICONS_FILE) + ".xml", File::READ, File::OPEN).read());
if(xml.findChild("Emoticons")) {
xml.stepIn();
while(xml.findChild("Emoticon")) {
tstring strEmotionText = Text::toT(xml.getChildAttrib("PasteText"));
if (strEmotionText.empty()) {
strEmotionText = Text::toT(xml.getChildAttrib("Expression"));
}
boost::algorithm::replace_all(strEmotionText, " ", "");
string strEmotionBmpPath = xml.getChildAttrib("Bitmap");
if (!strEmotionBmpPath.empty()) {
strEmotionBmpPath = Util::getPath(Util::PATH_EMOPACKS) + strEmotionBmpPath;
}
emoticons.push_back(new Emoticon(strEmotionText, strEmotionBmpPath));
}
xml.stepOut();
}
} catch(const Exception& e) {
dcdebug("EmoticonsManager::Create: %s\n", e.getError().c_str());
return;
}
setUseEmoticons(true);
}
void ConnectivityManager::startSocket() {
autoDetected = false;
disconnect();
if(ClientManager::getInstance()->isActive()) {
listen();
// must be done after listen calls; otherwise ports won't be set
if(SETTING(INCOMING_CONNECTIONS) == SettingsManager::INCOMING_FIREWALL_UPNP && !running)
startMapping();
}
}
/**
* Downloads a file and returns it as a string
* @todo Report exceptions
* @todo Abort download
* @param aUrl Full URL of file
* @return A string with the content, or empty if download failed
*/
void HttpConnection::downloadFile(const string& aUrl) {
dcassert(Util::findSubString(aUrl, "http://") == 0);
currentUrl = aUrl;
// Trim spaces
while(currentUrl[0] == ' ')
currentUrl.erase(0, 1);
while(currentUrl[currentUrl.length() - 1] == ' ') {
currentUrl.erase(currentUrl.length()-1);
}
// reset all settings (as in constructor), moved here from onLine(302) because ok was not reset properly
moved302 = false;
ok = false;
size = -1;
// set download type
if(Util::stricmp(currentUrl.substr(currentUrl.size() - 4), ".bz2") == 0) {
fire(HttpConnectionListener::TypeBZ2(), this);
} else {
fire(HttpConnectionListener::TypeNormal(), this);
}
if(SETTING(HTTP_PROXY).empty()) {
Util::decodeUrl(currentUrl, server, port, file);
if(file.empty())
file = "/";
} else {
Util::decodeUrl(SETTING(HTTP_PROXY), server, port, file);
file = currentUrl;
}
if(port == 0)
port = 80;
if(!socket) {
socket = BufferedSocket::getSocket(0x0a);
}
socket->setNoproxy(true);
socket->addListener(this);
socket->connect(server, port);
}
void NmdcHub::search(int aSizeType, int64_t aSize, int aFileType, const string& aString){
checkstate();
char* buf;
char c1 = (aSizeType == SearchManager::SIZE_DONTCARE) ? 'F' : 'T';
char c2 = (aSizeType == SearchManager::SIZE_ATLEAST) ? 'F' : 'T';
string tmp = toNmdc(aString);
string::size_type i;
while((i = tmp.find(' ')) != string::npos) {
tmp[i] = '$';
}
int chars = 0;
if(SETTING(CONNECTION_TYPE) == SettingsManager::CONNECTION_ACTIVE) {
string x = getLocalIp();
buf = new char[x.length() + aString.length() + 64];
chars = sprintf(buf, "$Search %s:%d %c?%c?%s?%d?%s|", x.c_str(), SETTING(IN_PORT), c1, c2, Util::toString(aSize).c_str(), aFileType+1, tmp.c_str());
} else {
buf = new char[getNick().length() + aString.length() + 64];
chars = sprintf(buf, "$Search Hub:%s %c?%c?%s?%d?%s|", getNick().c_str(), c1, c2, Util::toString(aSize).c_str(), aFileType+1, tmp.c_str());
}
send(buf, chars);
delete[] buf;
}
LRESULT UploadQueueFrame::onSpeaker(UINT /*uMsg*/, WPARAM wParam, LPARAM lParam, BOOL& /*bHandled*/) {
ctrlList.SetRedraw(FALSE);
switch(wParam) {
case REMOVE_ITEM:
{
UploadQueueItem* i = (UploadQueueItem*)lParam;
ctrlList.deleteItem(i);
updateStatus();
i->dec();
if(SETTING(BOLD_WAITING_USERS))
setDirty();
break;
}
case REMOVE:
{
std::unique_ptr<UserItem> item((UserItem*)lParam);
RemoveUser(item->getUser());
updateStatus();
if(SETTING(BOLD_WAITING_USERS))
setDirty();
break;
}
case ADD_ITEM:
AddFile((UploadQueueItem*)lParam);
updateStatus();
ctrlList.resort();
if(SETTING(BOLD_WAITING_USERS))
setDirty();
break;
case UPDATE_ITEMS:
for(int i = 0; i < ctrlList.GetItemCount(); i++) {
ctrlList.updateItem(i, UploadQueueItem::COLUMN_TRANSFERRED);
ctrlList.updateItem(i, UploadQueueItem::COLUMN_WAITING);
}
break;
}
ctrlList.SetRedraw(TRUE);
return 0;
}
void ADLSearchManager::MatchesFile(DestDirList& destDirVector, DirectoryListing::File *currentFile, string& fullPath) {
// Add to any substructure being stored
for(DestDirList::iterator id = destDirVector.begin(); id != destDirVector.end(); ++id) {
if(id->subdir != NULL) {
DirectoryListing::File *copyFile = new DirectoryListing::File(*currentFile, true);
dcassert(id->subdir->getAdls());
id->subdir->files.push_back(copyFile);
}
id->fileAdded = false; // Prepare for next stage
}
// Prepare to match searches
if(currentFile->getName().size() < 1) {
return;
}
string filePath = fullPath + "\\" + currentFile->getName();
// Match searches
for(SearchCollection::iterator is = collection.begin(); is != collection.end(); ++is) {
if(destDirVector[is->ddIndex].fileAdded) {
continue;
}
if(is->MatchesFile(currentFile->getName(), filePath, currentFile->getSize(), /*RSX++*/currentFile->getTTH()/*END*/)) {
DirectoryListing::File *copyFile = new DirectoryListing::File(*currentFile, true);
if(is->isForbidden) {
copyFile->setPoints(is->adlsPoints);
copyFile->setAdlsComment(is->adlsComment);
copyFile->setOverRidePoints(is->overRidePoints);
copyFile->setAdlsRaw(is->adlsRaw);
copyFile->setKickString(is->kickString);
copyFile->setFromFavs(is->fromFavs);
}
destDirVector[is->ddIndex].dir->files.push_back(copyFile);
destDirVector[is->ddIndex].fileAdded = true;
if(is->isAutoQueue) {
try {
QueueManager::getInstance()->add(SETTING(DOWNLOAD_DIRECTORY) + currentFile->getName(),
currentFile->getSize(), currentFile->getTTH(), getUser());
} catch(const Exception&) { }
}
if(breakOnFirst) {
// Found a match, search no more
break;
}
}
}
}
LRESULT SystemFrame::onContextMenu(UINT /*uMsg*/, WPARAM /*wParam*/, LPARAM lParam, BOOL& /*bHandled*/) {
POINT pt = { GET_X_LPARAM(lParam), GET_Y_LPARAM(lParam) }; // location of mouse click
if(pt.x == -1 && pt.y == -1) {
CRect erc;
ctrlPad.GetRect(&erc);
pt.x = erc.Width() / 2;
pt.y = erc.Height() / 2;
ClientToScreen(&pt);
}
POINT ptCl = pt;
ScreenToClient(&ptCl);
OnRButtonDown(ptCl);
OMenu menu;
menu.CreatePopupMenu();
menu.AppendMenu(MF_STRING, ID_EDIT_COPY, CTSTRING(COPY));
menu.AppendMenu(MF_SEPARATOR);
if(SETTING(LOG_SYSTEM)) {
menu.AppendMenu(MF_STRING, IDC_OPEN_SYSTEM_LOG, CTSTRING(OPEN_SYSTEM_LOG));
menu.AppendMenu(MF_SEPARATOR);
}
menu.AppendMenu(MF_STRING, ID_EDIT_SELECT_ALL, CTSTRING(SELECT_ALL));
menu.AppendMenu(MF_STRING, ID_EDIT_CLEAR_ALL, CTSTRING(CLEAR_MESSAGES));
if (!selWord.empty()) {
menu.AppendMenu(MF_STRING, IDC_COPY_DIR, CTSTRING(COPY_DIRECTORY));
menu.AppendMenu(MF_SEPARATOR);
menu.AppendMenu(MF_STRING, IDC_SEARCHDIR, CTSTRING(SEARCH_DIRECTORY));
menu.AppendMenu(MF_STRING, IDC_ADD_AUTO_SEARCH_DIR, CTSTRING(ADD_AUTO_SEARCH_DIR));
if (selWord[selWord.length() - 1] != PATH_SEPARATOR) {
menu.AppendMenu(MF_STRING, IDC_SEARCH, CTSTRING(SEARCH_FILENAME));
auto path = Text::fromT(selWord);
if (Util::fileExists(path)) {
menu.AppendMenu(MF_STRING, IDC_DELETE_FILE, CTSTRING(DELETE_FILE));
} else {
menu.AppendMenu(MF_STRING, IDC_ADD_AUTO_SEARCH_FILE, CTSTRING(ADD_AUTO_SEARCH_FILE));
menu.AppendMenu(MF_SEPARATOR);
}
}
menu.AppendMenu(MF_STRING, IDC_OPEN_FOLDER, CTSTRING(OPEN_FOLDER));
}
menu.open(m_hWnd, TPM_LEFTALIGN | TPM_RIGHTBUTTON, pt);
return 0;
}
void SDCPage::write()
{
PropPage::write((HWND)*this, items);
SettingsManager::getInstance()->set(SettingsManager::SHUTDOWN_ACTION, ctrlShutdownAction.GetCurSel());
userlistaction.Attach(GetDlgItem(IDC_USERLIST_DBLCLICK));
transferlistaction.Attach(GetDlgItem(IDC_TRANSFERLIST_DBLCLICK));
chataction.Attach(GetDlgItem(IDC_CHAT_DBLCLICK));
settings->set(SettingsManager::USERLIST_DBLCLICK, userlistaction.GetCurSel());
settings->set(SettingsManager::TRANSFERLIST_DBLCLICK, transferlistaction.GetCurSel());
settings->set(SettingsManager::CHAT_DBLCLICK, chataction.GetCurSel());
settings->set(SettingsManager::BLOOM_MODE, ctrlBloom.GetCurSel());
userlistaction.Detach();
transferlistaction.Detach();
chataction.Detach();
if(SETTING(DOWNCONN_PER_SEC) > 5)
settings->set(SettingsManager::DOWNCONN_PER_SEC, 5);
if(SETTING(AUTO_SEARCH_LIMIT) < 1)
settings->set(SettingsManager::AUTO_SEARCH_LIMIT, 1);
}
LRESULT AdviceFrame::onCreate(UINT /*uMsg*/, WPARAM /*wParam*/, LPARAM /*lParam*/, BOOL& bHandled) {
if (i_banner.Create(m_hWnd, rcDefault, NULL, WS_CHILD | WS_VISIBLE | WS_CLIPCHILDREN | WS_CLIPSIBLINGS | BS_OWNERDRAW | SS_ICON | SS_NOTIFY)) {
USES_CONVERSION;
i_banner.LoadAdRiverXMLBanner(SETTING(ADRIVER_SID), BANNER_SZ, BANNER1_BN, BANNER_BT, BANNER_PZ);
}
if (m_browser.Create(m_hWnd, rcDefault, NULL, WS_CHILD | WS_VISIBLE | WS_CLIPSIBLINGS | WS_CLIPCHILDREN)) {
if (m_browser.isBrowserOK()) {
m_browser.navigate(ADVICE_CONTENT);
}
}
bHandled = FALSE;
return TRUE;
}
void ConnectivityManager::startSocket() {
autoDetected = false;
disconnect();
// active check mustn't be there to hub-dependent setting works correctly
//if(ClientManager::getInstance()->isActive()) {
listen();
// must be done after listen calls; otherwise ports won't be set
if(SETTING(INCOMING_CONNECTIONS) == SettingsManager::INCOMING_FIREWALL_UPNP)
MappingManager::getInstance()->open();
//}
}
SearchResultInfo::SearchResultInfo(const SearchResultPtr& aSR, RelevancyInfo&& aRelevancy) :
token(Util::rand()), sr(aSR), relevancyInfo(move(aRelevancy)) {
// check the dupe
if (SETTING(DUPE_SEARCH)) {
if (sr->getType() == SearchResult::TYPE_DIRECTORY)
dupe = AirUtil::checkDirDupe(sr->getPath(), sr->getSize());
else
dupe = AirUtil::checkFileDupe(sr->getTTH());
}
//get the ip info
country = GeoManager::getInstance()->getCountry(sr->getIP());
}
void LogPage::write()
{
PropPage::write((HWND)*this, items, listItems, GetDlgItem(IDC_LOG_OPTIONS));
const string& s = SETTING(LOG_DIRECTORY);
if(s.length() > 0 && s[s.length() - 1] != '\\') {
SettingsManager::getInstance()->set(SettingsManager::LOG_DIRECTORY, s + '\\');
}
File::ensureDirectory(SETTING(LOG_DIRECTORY));
//make sure we save the last edit too, the user
//might not have changed the selection
getValues();
for(int i = 0; i < LogManager::LAST; ++i) {
string tmp = Text::fromT(options[i].first);
if(Util::stricmp(Util::getFileExt(tmp), ".log") != 0)
tmp += ".log";
LogManager::getInstance()->saveSetting(i, LogManager::FILE, tmp);
LogManager::getInstance()->saveSetting(i, LogManager::FORMAT, Text::fromT(options[i].second));
}
}
void FinishedManager::on(UploadManagerListener::Complete, const Upload* u) throw()
{
if(u->getType() == Transfer::TYPE_FILE || (u->getType() == Transfer::TYPE_FULL_LIST && BOOLSETTING(LOG_FILELIST_TRANSFERS))) {
if ((!SETTING(UPLOADFILE).empty() && (!BOOLSETTING(SOUNDS_DISABLED))))
PlaySound(Text::toT(SETTING(UPLOADFILE)).c_str(), NULL, SND_FILENAME | SND_ASYNC);
FinishedItemPtr item = new FinishedItem(u->getPath(), u->getHintedUser(), u->getFileSize(), static_cast<int64_t>(u->getAverageSpeed()), GET_TIME());
{
Lock l(cs);
uploads.push_back(item);
}
fire(FinishedManagerListener::AddedUl(), item);
size_t BUF_SIZE = STRING(FINISHED_UPLOAD).size() + MAX_PATH + 128;
char* buf = new char[BUF_SIZE];
snprintf(buf, BUF_SIZE, CSTRING(FINISHED_UPLOAD), (Util::getFileName(u->getPath())).c_str(),
Util::toString(ClientManager::getInstance()->getNicks(u->getHintedUser())).c_str());
LogManager::getInstance()->message(buf);
delete[] buf;
}
}
void Client::onRedirect(const string& aRedirectUrl) noexcept {
if (ClientManager::getInstance()->hasClient(aRedirectUrl)) {
statusMessage(STRING(REDIRECT_ALREADY_CONNECTED), LogMessage::SEV_INFO);
return;
}
redirectUrl = aRedirectUrl;
if (SETTING(AUTO_FOLLOW)) {
doRedirect();
} else {
fire(ClientListener::Redirect(), this, redirectUrl);
}
}
void LogManager::message(const string& msg, LogMessage::Severity severity) noexcept {
auto messageData = std::make_shared<LogMessage>(msg, severity);
if (severity != LogMessage::SEV_NOTIFY) {
if (SETTING(LOG_SYSTEM)) {
ParamMap params;
params["message"] = msg;
log(SYSTEM, params);
}
cache.addMessage(messageData);
}
fire(LogManagerListener::Message(), messageData);
}
