void P2PConnectionsWindow::refreshConnectionInfo(shared_ptr<IConnection> connection, ConnectionEvent e)
{
OS_LOCK(m_cs);
shared_ptr<P2PConnection> p2pConnection = boost::dynamic_pointer_cast<P2PConnection>(connection);
if(p2pConnection == nullptr)
{
OS_ASSERTFALSE();
return;
}
uint32 connectionID = connection->getID();
shared_ptr<ConnectionInfo> connectionInfo = m_connections.get(connectionID);
switch(e)
{
case connectionAdded: OS_ASSERT(connectionInfo == nullptr);
// Salva la nuova connessione
connectionInfo.reset(OS_NEW ConnectionInfo(connectionID, DateTime::now(), p2pConnection->getOrigin()));
m_connections.push_back(connectionID, connectionInfo);
// Inizializza lo stato della connessione
connectionInfo->setConnectionStatus(p2pConnection->takeStatusSnapshot());
// Inizializza il callback degli eventi sulla connessione
p2pConnection->addListener(boost::bind(&P2PConnectionsWindow::connectionStateChangedCallback, _1));
break;
case connectionUpdated: if(connectionInfo != nullptr)
{
// Aggiorna la data dell'ultimo aggiornamento sulla connessione
connectionInfo->setLastAction(DateTime::now());
// Aggiorna lo stato della connessione
connectionInfo->setConnectionStatus(p2pConnection->takeStatusSnapshot());
}
break;
case connectionRemoved: if(connectionInfo != nullptr)
connectionInfo->setRemoved(true);
break;
default: OS_ASSERTFALSE();
break;
}
}
bool MemFile::seek(uint64 offset, SeekPosition from) const
{
if(m_buffer == nullptr)
return false;
// Il buffer opera su un uint32 pertanto la conversione non causa problemi
uint32 roundedOffsed = static_cast<uint32>(offset);
uint32 pos = 0;
switch(from)
{
case seekBegin: pos = std::min<uint32>(roundedOffsed, m_buffer->getSize());
break;
case seekCurrent: pos = std::min<uint32>(m_buffer->getOffset() + roundedOffsed, m_buffer->getSize());
break;
case seekEnd: if(roundedOffsed < m_buffer->getSize())
pos = m_buffer->getSize() - roundedOffsed;
else
pos = 0;
break;
default: OS_ASSERTFALSE();
return false;
}
return m_buffer->seekAt(pos);
}
shared_ptr<IRCConnection> IRCSession::openConnection(shared_ptr<TCPSocket> socket)
{
if(socket == nullptr)
{
OS_ASSERTFALSE();
return nullptr;
}
OS_LOCK(m_dataCS);
shared_ptr<IRCConnection> connection = m_connection.lock();
if(connection != nullptr)
return connection;
shared_ptr<ConnectionsManager> connectionsManager = m_connectionsManager.lock();
if(connectionsManager == nullptr)
return nullptr;
clear();
initLoginRequest();
connection.reset(OS_NEW IRCConnection(get_this_ptr(), socket, connectionsManager));
connectionsManager->addConnection(connection, true);
m_connection = connection;
return connection;
}
void IdeMailBox::onPreRender()
{
ControlBase::onPreRender();
getStylesheet()->setBoolParam(PARAM_SECURE, getSecure());
if(m_message.empty())
{
shared_ptr<XMLNode> folder_node = getDocument()->create(_S("folder"));
switch(m_folder)
{
case messageFolderInbox: renderFolder(messageFolderInbox, folder_node);
break;
case messageFolderTrash: renderFolder(messageFolderTrash, folder_node);
break;
case messageFolderSentItems: renderFolder(messageFolderSentItems, folder_node);
break;
default: OS_ASSERTFALSE();
break;
}
}
else
{
renderMessage(m_message, getDocument()->create(_S("message")));
}
}
void IdeMailBox::onDeleteAllMessages(IEvent *e)
{
HtmlEvent *htmlEvent = dynamic_cast<HtmlEvent *>(e);
if(htmlEvent == nullptr)
return;
MessageFolder folder = conversions::from_utf16<MessageFolder>(htmlEvent->get(0));
if(folder != messageFolderNone)
{
switch(folder)
{
case messageFolderInbox:
case messageFolderSentItems:
// Sposta tutti i messaggi dalla posta in arrivo al cestino
getPortal()->getMessenger()->moveFolderMessages(getPage()->getDatabase(), getSessionAccount(), messageFolderInbox, messageFolderTrash);
break;
case messageFolderTrash: // Elimina tutti i messaggi nel cestino
getPortal()->getMessenger()->deleteFolderMessages(getPage()->getDatabase(), getSessionAccount(), messageFolderTrash);
break;
default: OS_ASSERTFALSE();
break;
}
// Effettua il render del folder
_renderFolder(folder);
}
}
shared_ptr<IRCRoom::UserDetails> IRCRoom::ensureUser(shared_ptr<IRCUser> user)
{
if(user == nullptr)
{
OS_ASSERTFALSE();
return nullptr;
}
OS_LOCK(*m_cs);
shared_ptr<IRCRoom::UserDetails> userDetails;
Users::iterator i = m_users.find(user->getID());
if(i != m_users.end())
{
userDetails = i->second.second;
}
else
{
userDetails.reset(OS_NEW UserDetails(get_this_ptr(), m_cs));
m_users[user->getID()] = std::make_pair(user, userDetails);
m_modified = true;
}
OS_ASSERT(userDetails != nullptr);
return userDetails;
}
shared_ptr<IRCRoom> IRCSession::ensureRoom(shared_ptr<IIRCTarget> target, bool update)
{
if(target == nullptr)
{
OS_ASSERTFALSE();
return nullptr;
}
OS_LOCK(m_dataCS);
const std::string &name = target->getName();
bool needUpdate = false;
shared_ptr<IRCRoom> room;
Rooms::const_iterator i = m_rooms.find(name);
if(i != m_rooms.end())
{
room = i->second;
}
else
{
room.reset(OS_NEW IRCRoom(target));
m_rooms[name] = room;
needUpdate = true;
}
OS_ASSERT(room != nullptr);
if(needUpdate && update)
updateRoom(room, false);
return room;
}
void IRCSession::processCommandNames(shared_ptr<IRCCommandNames> command)
{
OS_ASSERT(command != nullptr);
OS_LOCK(m_dataCS);
Rooms::const_iterator r = m_rooms.find(command->getChannel());
if(r == m_rooms.end())
{
OS_ASSERTFALSE();
return;
}
shared_ptr<IRCRoom> room = r->second;
OS_ASSERT(room != nullptr);
const IRCCommandNames::Users &users = command->getUsers();
for(IRCCommandNames::Users::const_iterator i = users.begin(); i != users.end(); ++i)
{
std::string nickname;
IRCUserType userType = ircUserTypeNormal;
if(IRCParser::parseNickname(*i, nickname, userType))
{
shared_ptr<IRCRoom::UserDetails> userDetails = room->ensureUser(ensureUser(nickname));
OS_ASSERT(userDetails != nullptr);
if(userDetails != nullptr)
userDetails->setType(userType);
}
}
}
shared_ptr<NTPResponse> NTPClient::query(shared_ptr<boost::asio::io_service> service, shared_ptr<UDPSocket> socket, const String &server, uint32 port)
{
try
{
if(socket == nullptr)
{
OS_ASSERTFALSE();
return nullptr;
}
shared_ptr<NTPClient> client(OS_NEW NTPClient(service, socket));
client->query(boost::asio::ip::udp::resolver::query(boost::asio::ip::udp::v4(), server.to_ascii(), conversions::to_string(port)));
// VERYURGENT: fixme (sul servizio potrebbero essere accodate altre operazione che non sono da processare...)
// O si fa una versione sincrona o si gestisce dall'esterno in versione asincrona
service->run();
return client->m_response;
}
catch(std::exception &e)
{
OS_LOG_ERROR(_S("Ntp error: ") + e.what());
}
return nullptr;
}
void PortalsSystem::addPortalsListener(shared_ptr<IPortalsListener> listener)
{
if(listener == nullptr)
{
OS_ASSERTFALSE();
return;
}
if(utils::exists(m_listeners, listener))
{
OS_ASSERTFALSE();
}
else
{
m_listeners.push_back(listener);
}
}
bool PortalsDirectory::handle(shared_ptr<HttpSession> session, const HttpPath &path)
{
// Controlla se non stata specificata alcuna pagina
if(path.getTokens().size() == 0)
{
// Redirige il client alla pagina predefinita
session->redirect(PortalsSystem::instance()->getMainLink(OS_IDE_PAGE_OSIRIS));
return true;
}
else
{
ide::portal::PortalPage page_type = PortalsSystem::instance()->getPortalPage(path.getDirectory());
// Controlla se la pagina non una pagina standard
if(page_type != ide::portal::ppUnknown)
{
shared_ptr<IPage> page;
switch(page_type)
{
case ide::portal::ppAccount: page.reset(OS_NEW ide::portal::Account(session));
break;
case ide::portal::ppEdit: page.reset(OS_NEW ide::portal::Edit(session));
break;
case ide::portal::ppUser: page.reset(OS_NEW ide::portal::User(session));
break;
case ide::portal::ppUsers: page.reset(OS_NEW ide::portal::Users(session));
break;
case ide::portal::ppView: page.reset(OS_NEW ide::portal::View(session));
break;
case ide::portal::ppObjectDetail: page.reset(OS_NEW ide::portal::ObjectDetail(session));
break;
case ide::portal::ppAssistant: page.reset(OS_NEW ide::portal::Assistant(session));
break;
case ide::portal::ppSearch: page.reset(OS_NEW ide::portal::Search(session));
break;
case ide::portal::ppMessenger: page.reset(OS_NEW ide::portal::Messenger(session));
break;
default: OS_ASSERTFALSE();
break;
}
return page != nullptr ? page->transmit() : false;
}
}
if(DirectoryBase::handle(session, path))
return true;
return false;
}
bool IApplication::postPrimaryProcessCommand(uint32 primaryProcessID, std::string command)
{
if(command.empty())
{
OS_ASSERTFALSE();
return false;
}
try
{
String syncFilePath = ProcessData::getSyncFilePath();
boost::interprocess::file_mapping shared_file(syncFilePath.to_ascii().c_str(), boost::interprocess::read_write);
boost::interprocess::mapped_region shared_region(shared_file, boost::interprocess::read_write);
if(shared_region.get_size() != sizeof(ProcessData))
{
OS_LOG_ERROR("Process exception: corrupted file '" + syncFilePath + "'");
return false;
}
ProcessData *processData = static_cast<ProcessData *>(shared_region.get_address());
boost::interprocess::scoped_lock<boost::interprocess::interprocess_mutex> lock(processData->mutex, boost::posix_time::microsec_clock::universal_time() + boost::posix_time::millisec(OS_PROCESS_SHARED_MEMORY_LOCK_TIMEOUT));
if(!lock)
{
OS_LOG_ERROR(_S("Process exception: lock timeout"));
return false;
}
String dataFilePath = processData->getDataFilePath();
shared_ptr<File> dataFile(OS_NEW File());
if(dataFile->open(dataFilePath, File::ofWrite | File::ofNoTruncate) == false)
{
OS_LOG_ERROR("Error opening or creating file '" + dataFilePath + "'");
return false;
}
if(dataFile->size() > 0)
{
dataFile->seekToEnd();
command.insert(0, OS_IAPPLICATION_COMMANDS_SEPARATOR);
}
if(dataFile->write(command.data(), static_cast<uint32>(command.size())) != static_cast<uint32>(command.size()))
{
OS_LOG_ERROR("Error writing file '" + dataFilePath + "'");
return false;
}
}
catch(std::exception &e)
{
OS_LOG_DEBUG(_S("Process exception: ") + e.what());
return false;
}
return true;
}
String CommentableObjectViewer::getEditObjectLink(shared_ptr<ObjectsIRevisionable> object) const
{
if(object == nullptr)
{
OS_ASSERTFALSE();
return String::EMPTY;
}
return portal::Edit::getUrl(getPortal(), object->getEntityID(), portal::Edit::acAddRevision);
}
uint64 PortalsPeer::makeID(shared_ptr<IPAddress> address)
{
if(address == nullptr)
{
OS_ASSERTFALSE();
return 0;
}
return makeID(address->toString(), address->getPort());
}
void setAttribute(shared_ptr<XMLNode> node, shared_ptr<HtmlTextBox> &child)
{
if(child == nullptr || child->hasID() == false)
{
OS_ASSERTFALSE();
return;
}
node->setAttributeString(child->getID(), child->getValue());
}
void setAttribute(shared_ptr<XMLNode> node, shared_ptr<IdePickerBool> &child)
{
if(child == nullptr || child->hasID() == false)
{
OS_ASSERTFALSE();
return;
}
node->setAttributeBool(child->getID(), child->getCheck());
}
bool IHttpDirectory::removeDirectory(shared_ptr<IHttpDirectory> directory)
{
if(directory == nullptr)
{
OS_ASSERTFALSE();
return false;
}
return removeDirectory(directory->getName());
}
bool LanguageVocabolary::load(shared_ptr<XMLDocument> document)
{
shared_ptr<XMLNode> root = document->getRoot();
if(root == nullptr)
{
OS_ASSERTFALSE();
return false;
}
shared_ptr<XMLNodes> childs = root->getNodes();
if(childs == nullptr)
{
OS_ASSERTFALSE();
return false;
}
for(XMLNodes::const_iterator i = childs->begin(); i != childs->end(); parse(*i), ++i);
return true;
}
shared_ptr<DataIStatistics> EntitiesStatisticsCache::load(const ObjectID &id, IdeSession *session)
{
// URGENT
/*
OS_ASSERT(logged_user != nullptr);
return logged_user->getDatabase()->getStatistics(logged_user->getAccount()->getID(), id, portalObjectTypeUnknown);
*/
OS_ASSERTFALSE();
return nullptr;
}
void HttpVirtualDirectory::addHandler(shared_ptr<IHttpDirectoryHandler> handler)
{
if(handler == nullptr)
{
OS_ASSERTFALSE();
return;
}
OS_ASSERT(utils::exists(m_handlers, handler) == false);
m_handlers.push_back(handler);
}
String Connection::_getPath() const
{
shared_ptr<Driver> driver = boost::dynamic_pointer_cast<Driver>(getDriver());
if(driver == nullptr)
{
OS_ASSERTFALSE();
return String::EMPTY;
}
return driver->getDatabasePath(getDatabase());
}
void IRCSession::processCommandNick(shared_ptr<IRCCommandNick> command)
{
OS_ASSERT(command != nullptr);
if(renameUser(command->getOldNick(), command->getNewNick()) == false)
{
OS_ASSERTFALSE();
return;
}
updateAllRooms(true);
}
void Mirror::setRenderMode(shared_ptr<XMLNode> root, uint32 renderMode)
{
if(root == nullptr)
{
OS_ASSERTFALSE();
return;
}
switch(renderMode)
{
case OS_MODULES_MIRROR_RENDER_MODE_DEFAULT:
case OS_MODULES_MIRROR_RENDER_MODE_CONTENT:
break;
default: OS_ASSERTFALSE();
renderMode = OS_MODULES_MIRROR_RENDER_MODE_DEFAULT;
break;
}
root->setAttributeUint32(OS_MODULES_MIRROR_RENDER_MODE, renderMode);
}
bool PluginModule::initialize()
{
shared_ptr<Plugin> plugin = getPlugin();
if(plugin == nullptr)
{
OS_ASSERTFALSE();
return false;
}
OS_ASSERT(m_interface != nullptr);
return (m_interface != nullptr && m_interface->initialize != nullptr) ? m_interface->initialize(*plugin) : false;
}
void P2PConnectionsWindow::handleConnectionStateChanged(shared_ptr<IConnection> connection)
{
// N.B.: il callback può essere chiamato da threads diversi pertanto ogni notifica deve essere fatta via post
if(connection == nullptr)
{
OS_ASSERTFALSE();
return;
}
refreshConnectionInfo(connection, connectionUpdated);
}
void IRCChannelPage::toggleUserMode(shared_ptr<IRCUser> user, IRCModeType mode)
{
if(user == nullptr)
{
OS_ASSERTFALSE();
return;
}
shared_ptr<IRCRoom> room = getRoom();
if(room == nullptr)
return;
shared_ptr<IRCRoom::UserDetails> userDetails = room->getUserDetails(user->getID());
if(userDetails == nullptr)
{
OS_ASSERTFALSE();
return;
}
bool enabled = true;
switch(mode)
{
case ircModeTypeOperator: enabled = !(userDetails->getType() == ircUserTypeOperator);
break;
case ircModeTypeHalfOperator: enabled = !(userDetails->getType() == ircUserTypeHalfOperator);
break;
case ircModeTypeVoice: enabled = !(userDetails->getVoice());
break;
case ircModeTypeBan: enabled = true;
break;
default: OS_ASSERTFALSE();
return;
}
room->changeUserMode(user->getID(), mode, enabled);
}
uint64 PortalsPeer::makeID(const String &ip, uint32 port)
{
try
{
return makeID(boost::asio::ip::tcp::endpoint(boost::asio::ip::address::from_string(ip.to_ascii()), port));
}
catch(std::exception &)
{
OS_ASSERTFALSE();
}
return 0;
}
void LanguageManager::addListener(shared_ptr<LanguageFolderListener> listener)
{
if(listener == nullptr)
{
OS_ASSERTFALSE();
return;
}
boost::mutex::scoped_lock lock(m_cs);
OS_ASSERT(m_listeners.find(listener) == m_listeners.end());
m_listeners.insert(listener);
}
void LanguageManager::removeListener(shared_ptr<LanguageFolderListener> listener)
{
boost::mutex::scoped_lock lock(m_cs);
Listeners::iterator i = m_listeners.find(listener);
if(i == m_listeners.end())
{
OS_ASSERTFALSE();
return;
}
m_listeners.erase(i);
}
bool IApplication::init(int argc, wchar_t *argv[])
{
if(argc == 0)
{
OS_ASSERTFALSE();
OS_LOG_ERROR("Invalid args");
return false;
}
FileSystem::instance()->initExecutableName(argv[0]);
return init(FileSystem::instance()->getExecutablePath());
}
