int main() {
startDaemon();
Fan fan("/sys/devices/platform/applesmc.768", "fan1");
Sensor coreOne(
"/sys/devices/platform/applesmc.768/subsystem/devices/coretemp.0",
"temp2");
Sensor coreTwo(
"/sys/devices/platform/applesmc.768/subsystem/devices/coretemp.0",
"temp3");
Load load("/proc", "stat");
fan.writeContent(fan.getPath() + "/" + fan.getName() + "_manual", "1");
#if FANMINSPEED
fan.setFanMinSpeed(FANMINSPEED);
#endif
#if FANMAXSPEED
fan.setFanMaxSpeed(FANMAXSPEED);
#endif
int loadFactor = (fan.getFanMaxSpeed() - fan.getFanMinSpeed())
/ (LOADSCALETO - LOACSCALEFROM);
int sensorFacotor = (fan.getFanMaxSpeed() - fan.getFanMinSpeed())
/ (SENSORSCALETO - SENSORSCALEFROM);
while (1) {
double loadAverage = 0;
double sensorAverage = 0;
for (int i = 0; i < AVERAGECOUNT; i++) {
loadAverage += load.getAverage();
sensorAverage += (coreOne.getTemp() + coreTwo.getTemp());
sleep(SLEEPTIME);
}
loadAverage = loadAverage / AVERAGECOUNT;
sensorAverage = sensorAverage / ((2 * AVERAGECOUNT) * 100000);
logToFile(DAEMON_LOG, dtos(loadAverage).c_str());
logToFile(DAEMON_LOG, dtos(sensorAverage).c_str());
if (loadAverage > LOACSCALEFROM) {
fan.setSpeed(
fan.getFanMinSpeed()
+ loadFactor * (loadAverage - LOACSCALEFROM));
} else {
fan.setSpeed(
fan.getFanMinSpeed()
+ sensorFacotor
* (sensorAverage - SENSORSCALEFROM));
}
}
return (0);
}
void Logger::log(const std::string& pText, const Type pType, const Output pOutput)
{
bool outputText(true);
Type logType(type_);
Output logOutput(output_);
// Check for non-defaults.
if (pType != LOG_TYPE_DEFAULT)
logType = pType;
if (pOutput != LOG_OUTPUT_DEFAULT)
logOutput = pOutput;
if (LOG_OUTPUT_SILENT == logOutput) // if we're not going to output this, might as well leave now.
return;
// Check if we are actually going to output this.
switch (logType) {
case LOG_TYPE_DEBUG:
#if !defined(DEBUG)
outputText = false;
#endif
break;
case LOG_TYPE_INFO:
case LOG_TYPE_ERROR:
outputText = true;
break;
default:
log("Logger: Unknown log type! Tried to Log - " + pText, LOG_TYPE_ERROR);
}
if (false == outputText)// if we're not going to output this, might as well leave now.
return;
// See where we're going to output this.
switch (logOutput) {
case LOG_OUTPUT_FILE:
logToFile(pText, logType);
break;
case LOG_OUTPUT_FILE_AND_TERMINAL:
logToFile(pText, logType);
logToTerm(pText, logType);
break;
case LOG_OUTPUT_TERMINAL:
logToTerm(pText, logType);
break;
default:
log("Logger: Unknown log output! Tried to Log - " + pText, LOG_TYPE_ERROR, LOG_OUTPUT_FILE_AND_TERMINAL);
}
}
CVisComplexObj::~CVisComplexObj()
{
logToFile((f, "VisComplexObj is to be deleted\n"));
int i;
for (i = 0; i < aiTopIndex; ++i)
{
logToFile((f, "arrays[%d]: 0x%p\n", i, arrays[i]));
FreeDoubleArray(arrays[i]);
}
logToFile((f, "scrVertices: 0x%p\n", scrVertices));
FreeDoubleArray(scrVertices);
Show=0;
update(ACTION_DELETE, (double *)NULL, 0);
logToFile((f, "VisComplexObj has been deleted\n"));
}
void Connection::doRead(EventBase *evt)
{
Event* event = static_cast<Event*>( evt );
while(true)
{
memset(buffer,0,EventBase::MAX_BUFFER_LEN);
int leftLen = ::recv(socket,buffer,EventBase::MAX_BUFFER_LEN,0);
logToFile(buffer,leftLen);
if (leftLen == -1)
{
//printf("---接受数据到头了--\n");
return;
}
if (leftLen == 0)
{
event->eventType = ERROR_EVT;
return;
}
Record *record = new Record(buffer,leftLen);
recvs.write(record);
doReadBack();
if (leftLen < EventBase::MAX_BUFFER_LEN)
{
// break;
}
}
event->startRead();
}
/*
* Set up logging.
*/
void initializeLogging(char* level) {
stringstream ss;
ss << level;
string levelStr = ss.str();
stoupper(levelStr); // convert to all caps
// set logging mode
if (strcmp(levelStr.c_str(), "OFF") == 0) {
logMode = OFF;
} else if ( strcmp(levelStr.c_str(), "ON") == 0 ) {
logMode = ON;
} else { //this should never happen
printf("Error: received an invalid log mode choice: %d\n", level);
exit(EXIT_FAILURE);
}
if (logMode == ON) {
// get current timestamp for filename
time_t rawtime;
struct tm * timeinfo;
char buffer [80];
time ( &rawtime );
timeinfo = localtime ( &rawtime );
strftime (buffer,80,"output/output-%Y%m%d_%X.txt",timeinfo);
puts (buffer);
outFilename = buffer;
outFile.open(outFilename);
logToFile("Program Trail Start:\n\n");
}
}
void Log::info(char * _file, int _line, std::string _message){
if(LOG_LEVEL <= kINFO){
SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), INFO_COLOUR_FG | INFO_COLOUR_BG);
std::cout << "[INFO] FILE:" << _file << " LINE:" << _line << " " << _message << std::endl;
if(WRITE_INFO_TO_FILE) {
logToFile(getDate() + "[INFO] FILE:" + _file + " LINE:" + std::to_string(_line) + _message + "\n");
}
}
}
void FreeDoubleArray(double *data)
{
if (data != NULL)
{
data = data - GetOffset(GetDim(data));
logToFile((f, "DoubleArrayFreed: 0x%p\n", data));
delete[] data;
}
}
//This function uses listTree to build a "full" tree starting from the root element
//The level is used to define the indentation of the printed output
HRESULT buildFullTree(IUIAutomationElement* rootNode)
{
//Get a TreeWalker object, to parse the UI nodes
IUIAutomationTreeWalker* walker = nullptr;
auto hr = g_pAutomation->get_ControlViewWalker(&walker);
if (FAILED(hr) || walker == nullptr)
{
logToFile("Failed walker");
logToFile("Error code: " + std::to_string(hr));
return hr;
}
//Now build the tree starting with level 1 indentation
hr = listTree(1, rootNode, walker);
SAFE_RELEASE(walker);
return hr;
}
void Log::info(std::string _message){
if(LOG_LEVEL <= kINFO){
SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), INFO_COLOUR_FG | INFO_COLOUR_BG);
std::cout << "[INFO] " << _message << std::endl;
if(WRITE_INFO_TO_FILE) {
logToFile(getDate() + "[INFO] " + _message + "\n");
}
}
}
void OutputPaneDockWidget::contextMenuEvent ( QContextMenuEvent* event )
{
QMenu menu;
QAction clear("Clear",0);
QAction logToFile("Log to file",0);
QAction* chosen;
menu.addAction(&clear);
menu.addAction(&logToFile);
chosen = menu.exec(event->globalPos());
if ( chosen == &clear )
{
switch ( ui->outputStackedWidget->currentIndex() )
{
case Output_General:
ui->generalOutputTextEdit->clear();
break;
case Output_Build:
ui->compilerOutputTextEdit->clear();
break;
case Output_Debug:
ui->debuggerOutputTextEdit->clear();
break;
case Output_Search:
ui->searchOutputTextEdit->clear();
break;
}
}
if ( chosen == &logToFile )
{
QString fileName = QFileDialog::getSaveFileName(this, "Log Output", QDir::currentPath(), "Text Document (*.txt)");
if (fileName.isEmpty())
{
return;
}
switch ( ui->outputStackedWidget->currentIndex() )
{
case Output_General:
ui->generalOutputTextEdit->clear();
break;
case Output_Build:
ui->compilerOutputTextEdit->clear();
break;
case Output_Debug:
ui->debuggerOutputTextEdit->clear();
break;
case Output_Search:
ui->searchOutputTextEdit->clear();
break;
}
}
}
void Log::error(const char* format, ...)
{
va_list args;
va_start(args, format);
SDL_LogMessageV(SDL_LOG_CATEGORY_APPLICATION, SDL_LOG_PRIORITY_ERROR, format, args);
logToFile("ERROR", format, args);
va_end(args);
}
void Log::warning(const char* format, ...)
{
va_list args;
va_start(args, format);
SDL_LogMessageV(SDL_LOG_CATEGORY_APPLICATION, SDL_LOG_PRIORITY_WARN, format, args);
logToFile("WARN", format, args);
va_end(args);
}
void Log::info(const char* format, ...)
{
va_list args;
va_start(args, format);
SDL_LogMessageV(SDL_LOG_CATEGORY_APPLICATION, SDL_LOG_PRIORITY_INFO, format, args);
logToFile("INFO", format, args);
va_end(args);
}
void Log::fatal(const char* format, ...)
{
va_list args;
va_start(args, format);
SDL_LogMessageV(SDL_LOG_CATEGORY_APPLICATION, SDL_LOG_PRIORITY_CRITICAL, format, args);
logToFile("FATAL", format, args);
va_end(args);
}
void Log::debug(const char* format, ...)
{
va_list args;
va_start(args, format);
SDL_LogMessageV(SDL_LOG_CATEGORY_APPLICATION, SDL_LOG_PRIORITY_DEBUG, format, args);
logToFile("DEBUG", format, args);
va_end(args);
}
void Log::verbose(const char* format, ...)
{
va_list args;
va_start(args, format);
SDL_LogMessageV(SDL_LOG_CATEGORY_APPLICATION, SDL_LOG_PRIORITY_VERBOSE, format, args);
logToFile("VERBOSE", format, args);
va_end(args);
}
int VariantToDoubleArray(double **data, VARIANT *var)
{
long uBnd,lBnd;
int dim, dimlen[MAXDIM];
int err=0;
// Check for ARRAY of the right type
logToFile((f, "VaraintToDoubleArray: var = 0x%p\n", var));
if( var==NULL ) return COMUTIL_ERR_NULL;
logToFile((f, "VaraintToDoubleArray: var.type = %d\n", var->vt));
if (var->vt == VT_ERROR){
*data = NULL;
return 0;
}
if( !( (var->vt) & VT_ARRAY ) ) err += COMUTIL_ERR_ARRAY;
if( !( (var->vt) & VT_R8 ) ) err += COMUTIL_ERR_TYPE;
if(err) return err;
// Get Overall Length (number of elements, ignore shape of Safearray)
dim = SafeArrayGetDim(var->parray);
for(int d=1; d<=dim; d++){
SafeArrayGetLBound(var->parray, d, &lBnd);
SafeArrayGetUBound(var->parray, d, &uBnd);
dimlen[d-1] = uBnd-lBnd+1;
}
logToFile((f, "VaraintToDoubleArray: %d, (%d, %d)\n", dim, dimlen[0], dimlen[1]));
*data = CreateDoubleArray(dim, dimlen);
if (*data != NULL)
{
// Get reference pointer for accessing the SafeArray
void *sap;
if( FAILED( SafeArrayAccessData(var->parray, (void**)&sap) )) return COMUTIL_ERR_SAFEARRAY;
memcpy(*data, sap, sizeof(double) * GetLength(*data));
// Release reference pointer
SafeArrayUnaccessData (var->parray);
}
// Return Success
return 0;
}
void Console::log(const LogMessage& message) {
if (message.string().empty())
return;
logToDebug(message);
logToFile(message);
if (m_textCtrl != NULL)
logToConsole(message);
else
m_buffer.push_back(message);
}
double *CopyDoubleArrayStruct(double *data)
{
if (data == NULL) return NULL;
int dim = GetDim(data), len = GetLength(data);
int offset = GetOffset(dim);
double *result = new double[offset+len];
logToFile((f, "DoubleArrayCreated: 0x%p\n", result));
result = result + offset;
memcpy(result-offset, data-offset, sizeof(double)*offset);
return result;
}
/**
* Funcao que trata de ler de um pipe uma mensagem e registar num ficheiro
*/
int spawnRegWriter(){
char *regBuffer=(char*)malloc(256);
int tamRegMsg=0;
int pid_filhoRegisto = fork();
if(pid_filhoRegisto==0){
while((tamRegMsg=read(pipeReg[0],regBuffer,256))>0)
logToFile(regBuffer,tamRegMsg);
}
return pid_filhoRegisto;
}
void Log::warn(std::string _message){
if(LOG_LEVEL <= kWARN){
SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), WARN_COLOUR_FG | WARN_COLOUR_BG);
std::cout << "[WARN] "<< _message << std::endl;
if(WRITE_WARN_TO_FILE) {
logToFile(getDate() + "[WARN] " + _message + "\n");
}
}
if(THROW_ON_WARN){
throw;
}
}
void Log::error(char * _file, int _line, std::string _message){
if(LOG_LEVEL <= kERROR){
SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), ERROR_COLOUR_FG | ERROR_COLOUR_BG);
std::cout << "[ERROR] FILE:" << _file << " LINE:" << _line << " " << _message << std::endl;
if(WRITE_ERROR_TO_FILE) {
logToFile(getDate() + "[ERROR] FILE:" + _file + " LINE:" + std::to_string(_line) + _message + "\n");
}
}
if(THROW_ON_ERROR){
throw;
}
}
void Log::error(std::string _message){
if(LOG_LEVEL <= kERROR){
SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), ERROR_COLOUR_FG | ERROR_COLOUR_BG);
std::cout << "[ERROR]" << _message << std::endl;
if(WRITE_ERROR_TO_FILE) {
logToFile(getDate() + "[ERROR] " + _message + "\n");
}
}
if(THROW_ON_ERROR){
throw;
}
}
double *CreateDoubleArray(int dim, int *dimlen)
{
int i, len = 1, offset = GetOffset(dim);
for (i=0; i < dim; ++i) len = len * dimlen[i];
if (len == 0) return NULL;
double *result = new double[offset+len];
logToFile((f, "DoubleArrayCreated: 0x%p\n", result));
result = result + offset;
((int *)result)[-1] = len;
((int *)result)[-2] = dim;
for (i=0; i < dim; ++i)
((int *)result)[-3-i] = dimlen[i];
return result;
}
int printf(const char *fmt, ...) {
va_list ap;
va_start(ap, fmt);
vsprintf(big_string, fmt, ap);
va_end(ap);
logToFile(big_string);
if (consoleView) {
consoleView->addString(big_string);
}
return 0;
}
void dbgMsg(DEBUG_LEVEL dbg_level, const char *fmt, ...) {
va_list ap;
if (dbg_level > current_debug_level) {
return;
}
va_start(ap, fmt);
vsprintf(big_string, fmt, ap);
va_end(ap);
if (consoleView) {
consoleView->addText(big_string);
}
logToFile(big_string);
}
STDMETHODIMP CVisComplexObj::put_vertices(VARIANT newVal)
{
double *data;
HRESULT result = VariantToDoubleArray(&data, &newVal);
logToFile((f, "putVertices: %d\n", result));
if (result) return E_INVALIDARG;
if (data != NULL)
{
if (GetDim(data) != 2) return E_INVALIDARG;
if (GetLength(data, 0) != 2 && GetLength(data, 0) != 3) return E_INVALIDARG;
}
setVertices(data);
FreeDoubleArray(scrVertices);
scrVertices = CopyDoubleArrayStruct(getVertices());
updateScrVertices();
return S_OK;
}
//生成log字符串
void Log::logData(LogLevel level, const char * buf)
{
static char s_log_level[Level_count][10]=
{
"Error",
"Warning",
"Info",
"Trace",
"Debug"
};
char format_log[MAX_LOG_SIZE];
std::string current_time=StrTimeStamp();
sprintf_s(format_log, sizeof(format_log), "[%s] [threadID:%d][%s] %s\n", s_log_level[level],GetCurrentThreadId(),current_time.c_str(), buf);
//如果是错误信息，则高亮显示
if(level==Error)
{
setColor(GREEN);
logToConsole(format_log);
resetColor();
logToErrFile(format_log);
}
else if(level==Warn)
{
setColor(CYAN);
logToConsole(format_log);
resetColor();
logToErrFile(format_log);
}
else
logToConsole(format_log);
logToFile(format_log);
m_log_line++;
if(m_log_line>=MAX_LOG_LINE)
m_log_line=0;
}
void server(session_t* session)
{
gchar **lines, **tokens, **chunks;
char verb[VERB_SIZE], resource[RESOURCE_SIZE], protocol[PROTOCOL_SIZE];
char buffer[BUFFER_SIZE];
int selectStatus, currentReadFd, readBytes;
session->q = g_queue_new();
struct timeval timer;
timer.tv_sec = 30;
timer.tv_usec = 0;
// Setup read file descriptor set and timer for select()
fd_set reader;
FD_ZERO(&reader);
session->read_fds = newFdSet();
// Keep track of largest file descriptor
session->listener = createSocket(session->server);
session->maxFd = session->listener;
session->connections = g_hash_table_new (g_direct_hash, g_direct_equal);
FD_SET(session->listener, &session->read_fds);
// Main Loop
for (;;)
{
reader = session->read_fds;
selectStatus = select(session->maxFd + 1, &reader, NULL, NULL, &timer);
if (selectStatus == -1)
{
fprintf(stderr, "Select failed\n");
exit(1);
}
// Handle timeouts
else if (selectStatus == 0)
{
if (g_queue_get_length(session->q) > 0)
{
session->maxFd = closeSocket(GPOINTER_TO_INT(g_queue_pop_tail(session->q)), session);
continue;
}
}
// There's something to read
for(currentReadFd = 0; currentReadFd <= session->maxFd; currentReadFd++)
{
if (!FD_ISSET(currentReadFd, &reader))
{
continue;
}
if (currentReadFd == session->listener)
{
newConnection(session);
}
else
{
memset(buffer, '\0', BUFFER_SIZE);
memset(verb, '\0', VERB_SIZE);
memset(resource, '\0', RESOURCE_SIZE);
memset(protocol, '\0', PROTOCOL_SIZE);
readBytes = recv(currentReadFd, buffer, BUFFER_SIZE - 1, 0);;
if (readBytes <= 0)
{
closeSocket(currentReadFd, session);
continue;
}
chunks = g_strsplit(buffer, "\r\n\r\n", 2);
lines = g_strsplit(chunks[0], "\r\n", 20);
tokens = g_strsplit(lines[0], " ", 3);
strncpy(verb, tokens[0], strlen(tokens[0]));
strncpy(resource, tokens[1], strlen(tokens[1]));
strncpy(protocol, tokens[2], strlen(tokens[2]));
setSessionHeaders(session, lines);
setSessionVerb(session, verb);
if (session->verb == VERB_HEAD || session->verb == VERB_GET)
{
logToFile(session, currentReadFd, resource, verb, 200);
handleRequest(session, currentReadFd, resource, NULL);
}
else if (session->verb == VERB_POST)
{
logToFile(session, currentReadFd, resource, verb, 200);
handleRequest(session, currentReadFd, resource, chunks[1]);
}
else
{
logToFile(session, currentReadFd, resource, verb, 200);
}
gchar* connection = (gchar *) g_hash_table_lookup(session->headers, "Connection");
g_queue_remove(session->q, GINT_TO_POINTER(currentReadFd));
g_queue_push_head(session->q, GINT_TO_POINTER(currentReadFd));
if ((g_strcmp0(protocol, "HTTP/1.0") == 0 && g_strcmp0(connection, "keep-alive") != 0) || (g_strcmp0(connection, "close") == 0))
{
closeSocket(currentReadFd, session);
}
}
}
}
g_hash_table_destroy(session->connections);
FD_ZERO(&session->read_fds);
close(session->listener);
}
void destroyTorrentInfo( ) {
int i;
struct torrentInfo * t = globalTorrentInfo;
logToFile( t, "SIGINT Received - Shutting down ... \n");
printf("\n\nSIGINT Received - Shutting down ... \n");
// Tell the tracker we're shutting down.
doTrackerCommunication( t, TRACKER_STOPPED );
logToFile( t, "SHUTDOWN Notified tracker we're stopping\n");
printf("Notified tracker we're stopping\n");
free( t->announceURL );
free( t->trackerDomain );
free( t->trackerIP );
for ( i = 0; i < t->numChunks; i ++ ) {
if (! t->chunks[i].have ) {
free( t->chunks[i].data );
free( t->chunks[i].subChunks );
}
}
for ( i = 0; i < t->peerListLen; i ++ ) {
if ( t->peerList[i].defined ) {
destroyPeer( &t->peerList[i], t );
}
}
printf("Freed data chunks and peer metadata structures\n");
logToFile( t, "SHUTDOWN Freed data chunks and peer metadata structures\n");
free( t->chunks );
free( t->chunkOrdering );
free( t->name );
free( t->comment );
free( t->infoHash );
free( t->peerID );
free( t->peerList );
Bitfield_Destroy( t->ourBitfield );
if ( timer_delete( t->timerTimeoutID ) ) {
perror("timer_delete");
logToFile( t, "SHUTDOWN Error deleting timer.\n");
}
if ( timer_delete( t->timerChokeID ) ) {
perror("timer_delete");
logToFile( t, "SHUTDOWN Error deleting timer.\n");
}
munmap( t->fileData, t->totalSize );
printf("Unmapped file.\nClosing logfile.\n");
logToFile( t, "SHUTDOWN Unmapped file.\n");
logToFile( t, "SHUTDOWN Closing logfile.\n");
if ( t->logFile ) {
fclose( t->logFile );
}
free( t );
printf("Have a nice day!\n");
exit(1);
return;
}
