void tarch::logging::CommandLineLogger::warning(const long int& timestampMS, const std::string& timestampHumanReadable, const std::string& machineName, const std::string& trace, const std::string& message) {
if (writeWarning(trace)) {
std::string outputMessage = constructMessageString(
"warning",
timestampMS,
timestampHumanReadable,
machineName,
trace,
message
);
tarch::multicore::Lock lockCout( _semaphore );
out().flush();
#ifdef CompilerCLX
if(out()!=std::cout) {
std::cout << outputMessage;
std::cout.flush();
}
#else
std::cerr << outputMessage;
std::cerr.flush();
#endif
}
}
void WriteManager::offerOutgoingUpdate(NetworkTableEntry* entry) {
{
Synchronized sync(transactionsLock);
((std::queue<NetworkTableEntry*>*)incomingUpdateQueue)->push(entry);
if(((std::queue<NetworkTableEntry*>*)incomingUpdateQueue)->size()>=queueSize){
run();
writeWarning("update queue overflowed. decrease the rate at which you update entries or increase the write buffer size");
}
}
}
void moveFile(char* from, char* destination) // TODO: try to reduce the amount of dynamic memory allocation
{
char* filename = strrfind(from, '/') + 1;
size_t name_len = strlen(destination) + strlen(filename) + 1;
char* end_name;
if (!strend(destination, "/"))
{
++name_len;
end_name = malloc(name_len);
snprintf(end_name, name_len, "%s/%s", destination, filename);
}
else
{
end_name = malloc(name_len);
snprintf(end_name, name_len, "%s%s", destination, filename);
}
// add (some number) to the end of the filename to avoid overwriting data
char* safe_name = malloc(name_len);
strcpy(safe_name, end_name);
size_t safe_len;
for (int m = 1; access(safe_name, F_OK) != -1; ++m)
{
free(safe_name);
safe_len = name_len + getDigitCount(m) + 3;
safe_name = malloc(safe_len);
snprintf(safe_name, safe_len, "%s (%d)", end_name, m);
}
free(end_name);
end_name = safe_name;
name_len = safe_len; // shouldn't be necessary, but it keeps a safe state
// write to status log
writeDebug("Rename \"%s\" to \"%s\"", from, end_name);
if (rename(from, end_name) < 0)
{
writeWarning("Unable to move file to destination");
}
else
{
// send notification
char notify_message[FILE_NAME_MAX];
snprintf(notify_message, FILE_NAME_MAX, "Rename \"%s\" to \"%s\"", from , end_name);
if (isPaused())
{
sendPausedNotification(from, end_name);
}
else
{
sendMovingNotification(from, end_name);
}
}
free(end_name);
}
void withoutDefaultBad(Message mess){
switch(mess){
case Message::information:
writeMessage();
break;
case Message::warning:
writeWarning();
break;
}
}
void withoutDefaultGood(Message mess){
switch(mess){
case Message::information:
writeMessage();
break;
case Message:: warning:
writeWarning();
break;
default:
// nothing can be done
break;
}
}
void withDefault(Message mess){
switch(mess){
case Message::information:
writeMessage();
break;
case Message:: warning:
writeWarning();
break;
default:
writeUnexpected();
break;
}
}
void ConsoleText::onLogMessage(Core::LoggerMessage const& message)
{
switch(message.channel)
{
case Core::LoggerChannels::Warning:
writeWarning(message.message);
break;
case Core::LoggerChannels::Error: // Intentional fall through
case Core::LoggerChannels::Fatal:
writeError(message.message);
break;
default:
write(message.message);
break;
}
}
void SslServer::processCommandXML(QSslSocket *socket, const QByteArray &data)
{
qint32 argc;
QString cmd;
QByteArray arg1, arg2, arg3, arg4, arg5,
arg6, arg7, arg8, arg9, arg10;
if (!XMLReader(data, &argc, &cmd,
&arg1, &arg2, &arg3, &arg4, &arg5,
&arg6, &arg7, &arg8, &arg9, &arg10))
{
writeWarning(socket, "Invalid XML", true);
return;
}
if (cmd == "LOGIN")
{
if (arg1.isEmpty() || arg2.isEmpty()
|| arg3.isEmpty() || arg4.isEmpty()
|| arg5.isEmpty())
{
writeWarning(socket, "Invalid XML", true);
return;
}
QByteArray peer_negotiation_string = arg1;
QByteArray peer_id = arg2;
QByteArray password = arg3;
bool user_unavailable = getValue<bool>(arg4);
bool new_user = getValue<bool>(arg5);
QString code = QLatin1String(arg6);
if (peer_negotiation_string != NEGOTIATION_STRING)
{
DEBUG_FUNCTION("IP:" << qPrintable(socket->peerAddress().toString()) << "User origin:" << qPrintable(peer_id)
<< "Invalid NEGOTIATION STRING!");
writeWarning(socket, "Invalid NEGOTIATION STRING!", true);
return;
}
if (m_id_list.contains(peer_id))
{
DEBUG_FUNCTION("IP:" << qPrintable(socket->peerAddress().toString()) << "User origin:" << qPrintable(peer_id)
<< "This user is already connected!");
writeWarning(socket, "This user is already connected!", true);
return;
}
if (new_user)
{
if (m_sql.userExists("root"))
{
if (!m_code_list.contains(code))
{
DEBUG_FUNCTION("IP:" << qPrintable(socket->peerAddress().toString()) << "User origin:" << qPrintable(peer_id)
<< "Invalid code!");
writeWarning(socket, "Invalid code!", true);
return;
}
else
{
m_code_list.removeAll(code);
}
}
else if (cleanString(QLatin1String(peer_id)) != "root")
{
DEBUG_FUNCTION("IP:" << qPrintable(socket->peerAddress().toString()) << "User origin:" << qPrintable(peer_id)
<< "Need to create root account first!");
writeWarning(socket, "Need to create root account first!", true);
return;
}
if (m_sql.userExists(cleanString(QLatin1String(peer_id))))
{
DEBUG_FUNCTION("IP:" << qPrintable(socket->peerAddress().toString()) << "User origin:" << qPrintable(peer_id)
<< "User already exists!");
writeWarning(socket, "User already exists!", true);
return;
}
else if (!m_sql.createUser(cleanString(QLatin1String(peer_id)), cleanString(QLatin1String(password))))
{
DEBUG_FUNCTION("IP:" << qPrintable(socket->peerAddress().toString()) << "User origin:" << qPrintable(peer_id)
<< "Can't create new user!");
writeWarning(socket, "Can't create new user!", true);
return;
}
}
if (!m_sql.loginUser(cleanString(QLatin1String(peer_id)), cleanString(QLatin1String(password))))
{
DEBUG_FUNCTION("IP:" << qPrintable(socket->peerAddress().toString()) << "User origin:" << qPrintable(peer_id)
<< "Can't login with this user and password!");
writeWarning(socket, "Can't login with this user and password!", true);
return;
}
DEBUG_FUNCTION("IP:" << qPrintable(socket->peerAddress().toString()) << "User origin:" << qPrintable(peer_id)
<< "User logged in!");
m_id_list.append(peer_id);
m_id_hash.insert(socket, peer_id);
if (user_unavailable)
m_unavailable_list.append(peer_id);
QByteArray data;
data.append(getBytes<quint8>(ServerCommand::LoggedIn));
socket->write(getBytes<qint32>(data.size()));
socket->write(data);
}
else if (cmd == "REQUEST_SETTINGS")
{
QString ui_path;
QString js_path;
QString id = QLatin1String(m_id_hash[socket]);
if (id != "root")
{
ui_path = "../data/settings.ui";
js_path = "../data/settings.js";
}
else
{
ui_path = "../data/settings_root.ui";
js_path = "../data/settings_root.js";
}
QFile ui_file(ui_path);
QFile js_file(js_path);
if (!ui_file.open(QFile::ReadOnly) || !js_file.open(QFile::ReadOnly))
{
DEBUG_FUNCTION("Can't send settings file");
writeWarning(socket, "Can't send settings file", true);
return;
}
QByteArray ui_data = ui_file.readAll();
QByteArray js_data = js_file.readAll();
QByteArray xml_data = XMLWriter("SETTINGS", ui_data, js_data);
writeCommandXML(socket, xml_data);
}
else if (cmd == "DELETE_ACCOUNT")
{
QString id = QLatin1String(m_id_hash[socket]);
if (id == "root")
{
DEBUG_FUNCTION("IP:" << qPrintable(socket->peerAddress().toString()) << "User origin:" << qPrintable(m_id_hash.value(socket))
<< "Invalid operation!");
writeWarning(socket, "Invalid operation!", true);
return;
}
if (m_sql.deleteUser(id))
{
DEBUG_FUNCTION("IP:" << qPrintable(socket->peerAddress().toString()) << "User origin:" << qPrintable(m_id_hash.value(socket))
<< "User deleted sucessfully!");
writeWarning(socket, "User deleted sucessfully!", true);
}
else
{
DEBUG_FUNCTION("IP:" << qPrintable(socket->peerAddress().toString()) << "User origin:" << qPrintable(m_id_hash.value(socket))
<< "Error deleting user!");
writeWarning(socket, "Error deleting user!", true);
}
}
else if (cmd == "CHANGE_ACCOUNT_PASSWORD")
{
if (arg1.isEmpty())
{
writeWarning(socket, "Invalid XML", true);
return;
}
QByteArray password = arg1;
if (m_sql.changePassword(m_id_hash[socket], cleanString(QLatin1String(password))))
{
DEBUG_FUNCTION("IP:" << qPrintable(socket->peerAddress().toString()) << "User origin:" << qPrintable(m_id_hash.value(socket))
<< "User password changed sucessfully!");
writeWarning(socket, "User password changed sucessfully!", true);
}
else
{
DEBUG_FUNCTION("IP:" << qPrintable(socket->peerAddress().toString()) << "User origin:" << qPrintable(m_id_hash.value(socket))
<< "Error changing user password!");
writeWarning(socket, "Error changing user password!", true);
}
}
else if (cmd == "REQUEST_CODE")
{
QByteArray id = m_id_hash[socket];
if (QLatin1String(id) != "root")
{
DEBUG_FUNCTION("IP:" << qPrintable(socket->peerAddress().toString()) << "User origin:" << qPrintable(m_id_hash.value(socket))
<< "Invalid operation!");
writeWarning(socket, "Invalid operation!", true);
return;
}
QString code;
do
{
code = QString(OpenSslLib::RANDbytes(4).toHex());
code.prepend("#");
}
while (m_code_list.contains(code));
m_code_list.append(code);
QTimer::singleShot(60 * 60 * 1000, [=]{
m_code_list.removeAll(code);
});
DEBUG_FUNCTION("IP:" << qPrintable(socket->peerAddress().toString()) << "User origin:" << qPrintable(m_id_hash.value(socket))
<< "Sending code!");
QByteArray xml_data = XMLWriter("CODE", "edit_code", code.toLatin1());
writeCommandXML(socket, xml_data);
}
else
{
DEBUG_FUNCTION("IP:" << qPrintable(socket->peerAddress().toString()) << "User origin:" << qPrintable(m_id_hash.value(socket))
<< "Invalid operation!");
writeWarning(socket, "Invalid operation!", true);
}
}
void SslServer::process(const PeerData &pd)
{
QByteArray data = pd.data;
if (data.isEmpty())
return;
quint8 command = getValue<quint8>(data.mid(0, 1));
data.remove(0, 1);
QSslSocket *socket = m_socket_hash[pd.descriptor];
if (!socket)
return;
switch (command)
{
case ServerCommand::PeerTryConnect:
{
if (data.size() != 20)
{
removeSocket(socket);
return;
}
QByteArray peer_id = data;
peer_id = cleanString(QLatin1String(peer_id)).toLatin1().leftJustified(peer_id.length(), char(0), true);
if (m_unavailable_list.contains(peer_id))
{
DEBUG_FUNCTION("IP:" << qPrintable(socket->peerAddress().toString()) << "User origin:" << qPrintable(m_id_hash.value(socket))
<< "User target:" << qPrintable(peer_id) << "Attempt to connect to unavailable user!");
writeWarning(socket, "You're trying to connect to a unavailable user!");
return;
}
if (peer_id == m_id_hash[socket])
{
DEBUG_FUNCTION("IP:" << qPrintable(socket->peerAddress().toString()) << "User origin:" << qPrintable(m_id_hash.value(socket))
<< "User target:" << qPrintable(peer_id) << "Attempt to connect to itself!");
writeWarning(socket, "You're trying to connect to itself!");
return;
}
if (!m_id_list.contains(peer_id))
{
DEBUG_FUNCTION("IP:" << qPrintable(socket->peerAddress().toString()) << "User origin:" << qPrintable(m_id_hash.value(socket))
<< "User target:" << qPrintable(peer_id) << "Attempt to connect to non connected user!");
writeWarning(socket, "You're trying to connect to a non connected user!");
return;
}
QSslSocket *target_socket = m_id_hash.key(peer_id);
if (m_connecting_connected_list.contains(target_socket))
{
DEBUG_FUNCTION("IP:" << qPrintable(socket->peerAddress().toString()) << "User origin:" << qPrintable(m_id_hash.value(socket))
<< "User target:" << qPrintable(peer_id) << "Attempt to connect to already connected user!");
writeWarning(socket, "User already connected!");
return;
}
m_connecting_connected_list.append(socket);
m_connecting_connected_list.append(target_socket);
QByteArray data;
data.append(getBytes<quint8>(ServerCommand::ConnectionRequested));
data.append(getBytes<quint32>(socket->localAddress().toIPv4Address()));
data.append(m_id_hash[socket]);
m_accept_hash.insert(target_socket, socket);
DEBUG_FUNCTION("IP:" << qPrintable(socket->peerAddress().toString()) << "User origin:" << qPrintable(m_id_hash.value(socket))
<< "User target:" << qPrintable(peer_id) << "Trying to connect to peer!");
target_socket->write(getBytes<qint32>(data.size()));
target_socket->write(data);
break;
}
case ServerCommand::ConnectionAnswer:
{
if (data.size() != 1)
{
removeSocket(socket);
return;
}
QSslSocket *socket_starter = m_accept_hash[socket];
bool accepted = getValue<bool>(data.mid(0, 1));
if (!socket_starter)
{
m_connecting_connected_list.removeAll(socket_starter);
m_connecting_connected_list.removeAll(socket);
if (accepted)
{
DEBUG_FUNCTION("IP:" << qPrintable(socket->peerAddress().toString()) << "User origin:" << qPrintable(m_id_hash.value(socket))
<< "User disconnected or canceled operation!");
writeWarning(socket, "Can't connect to user because it's disconnected or canceled operation!");
}
return;
}
if (!accepted)
{
QSslSocket *socket1 = socket_starter;
QSslSocket *socket2 = socket;
m_accept_hash.remove(socket1);
m_accept_hash.remove(socket2);
m_connecting_connected_list.removeAll(socket1);
m_connecting_connected_list.removeAll(socket2);
DEBUG_FUNCTION("IP:" << qPrintable(socket->peerAddress().toString()) << "User origin:" << qPrintable(m_id_hash.value(socket))
<< "User target:" << qPrintable(m_id_hash.value(socket_starter)) << "User refused connection!");
writeWarning(socket_starter, "User refused connection!");
return;
}
QSslSocket *socket1 = socket;
QSslSocket *socket2 = socket_starter;
m_connected_1.insert(socket1, socket2);
m_connected_2.insert(socket2, socket1);
QByteArray data1;
QByteArray data2;
data1.append(getBytes<quint8>(ServerCommand::ConnectedToPeer));
data2.append(getBytes<quint8>(ServerCommand::ConnectedToPeer));
QByteArray password = OpenSslLib::RANDbytes(32);
data1.append(m_id_hash[socket1]);
data1.append(password);
data2.append(m_id_hash[socket2]);
data2.append(password);
socket1->write(getBytes<qint32>(data2.size()));
socket1->write(data2);
socket2->write(getBytes<qint32>(data1.size()));
socket2->write(data1);
DEBUG_FUNCTION("IP:" << qPrintable(socket->peerAddress().toString()) << "User origin:" << qPrintable(m_id_hash.value(socket_starter))
<< "User target:" << qPrintable(m_id_hash.value(socket)) << "Connected!");
break;
}
case ServerCommand::DisconnectedFromPeer:
{
QSslSocket *target_socket = m_connected_1.value(socket);
if (!target_socket)
target_socket = m_connected_2.value(socket);
DEBUG_FUNCTION("IP:" << qPrintable(socket->peerAddress().toString()) << "User origin:" << qPrintable(m_id_hash.value(socket))
<< "User target:" << qPrintable(m_id_hash.value(target_socket)) << "Disconnected from peer!");
disconnectedFromPeer(socket);
break;
}
case ServerCommand::P2PData:
{
QSslSocket *target_socket = m_connected_1.value(socket);
if (!target_socket)
target_socket = m_connected_2.value(socket);
if (!target_socket)
break;
data.prepend(getBytes<quint8>(ServerCommand::P2PData));
target_socket->write(getBytes<qint32>(data.size()));
target_socket->write(data);
m_alive_hash[socket].restart();
m_alive_hash[target_socket].restart();
break;
}
case ServerCommand::Alive:
{
m_alive_hash[socket].restart();
break;
}
case ServerCommand::XML:
{
processCommandXML(socket, data);
break;
}
default:
{
removeSocket(socket);
return;
}
}
}
int process(int fd, char* watch_dir)
{
struct inotify_event* event;
int length = 0;
char buffer[BUF_SIZE];
length = read(fd, buffer, BUF_SIZE);
for (int i = 0; i < length;)
{
event = (struct inotify_event*)(buffer + i);
printf("\n");
printEvent(event);
char* extension;
if (event->mask & IN_DELETE_SELF)
{
writeWarning("Watch directory was deleted");
return 1;
}
else if ((extension = strstr(event->name, ".")) != NULL)
{
size_t name_len = strlen(watch_dir) + strlen(event->name) + 1;
char* fullname = malloc(name_len);
snprintf(fullname, name_len, "%s%s", watch_dir, event->name);
int file_size = getFileSize(fullname);
printf("File size: %d\n", file_size);
if (file_size > 0) // firefox likes to create empty files for the temp files to be renamed to
{
printf("Extension: %s\n", extension);
if (strend(extension, ".txt") || strend(extension, ".pdf"))
{
moveFile(fullname, "/home/calcifer/Documents");
}
else if (strend(extension, ".tar.gz") || strend(extension, ".tar") || strend(extension, ".tar.bz2") ||
strend(extension, ".zip") || strend(extension, ".7z") || strend(extension, ".ar") ||
strend(extension, ".ace"))
{
moveFile(fullname, "/home/calcifer/Documents/archives");
}
else if (strend(extension, ".deb") || strend(extension, ".rpm") ||
strend(extension, ".msi") ||
strend(extension, ".apk") ||
strend(extension, ".app"))
{
moveFile(fullname, "/home/calcifer/Documents/installers");
}
else if (strend(extension, ".torrent"))
{
moveFile(fullname, "/home/calcifer/Downloads/torrents");
}
else if (strend(extension, ".mp4") || strend(extension, ".video") || strend(extension, ".mkv") || strend(extension, ".avi"))
{
moveFile(fullname, "/home/calcifer/Videos");
}
else if (strend(extension, ".odt") || strend(extension, ".ods") || strend(extension, ".odp") ||
strend(extension, ".doc") || strend(extension, ".xls") || strend(extension, ".ppt") ||
strend(extension, ".docx") || strend(extension, ".xlsx") || strend(extension, ".pptx"))
{
moveFile(fullname, "/home/calcifer/Documents/office");
}
else if (strend(extension, ".ovpn"))
{
moveFile(fullname, "/home/calcifer/Web");
}
else if (strend(extension, ".mp3"))
{
moveFile(fullname, "/home/calcifer/Music");
}
else if (strend(extension, ".gif"))
{
moveFile(fullname, "/home/calcifer/Pictures/gifs");
}
else if (strend(extension, ".jpg") || strend(extension, ".jpeg") ||
strend(extension, ".png") || strend(extension, ".bmp") ||
strend(extension, ".svg") ||
strend(extension, ".tif") || strend(extension, ".tiff"))
{
moveFile(fullname, "/home/calcifer/Pictures");
}
else if (strend(extension, ".c") || strend(extension, ".h") ||
strend(extension, ".cpp") || strend(extension, ".hpp") ||
strend(extension, ".py") || strend(extension, ".py3") ||
strend(extension, ".rb") ||
strend(extension, ".cs") ||
strend(extension, ".php") || strend(extension, ".js") || strend(extension, ".html") ||
strend(extension, ".java"))
{
moveFile(fullname, "/home/calcifer/Documents/code/unorganized");
}
else if (strend(extension, ".iso") || strend(extension, ".vbox") || strend(extension, ".vdi"))
{
moveFile(fullname, "/home/calcifer/Documents/disc-images");
}
else if (strend(extension, ".desktop"))
{
moveFile(fullname, "/home/calcifer/Desktop");
}
}
free(fullname);
}
i += sizeof(struct inotify_event) + event->len;
}
return 0; // shouldn't ever be possible, infinite loop
}
void FragmentShaderCode::connectLog(LogWidget &log)
{
TextEditable::connectLog(log);
connect(&m_shader,SIGNAL(error(QString)),&log,SLOT(writeError(QString)));
connect(&m_shader,SIGNAL(warning(QString)),&log,SLOT(writeWarning(QString)));
}
