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); }