Esempio n. 1
0
void setOperationalMode(int newmode) {
	extern void buildMyStatsCSV();
	
  if(newmode == (int)P_WAIT) {
  	// stop();  --- should we see if we can WAIT while paused in an audio file?
  	SysIntoWaitMode();
    // when leaving wait mode, next instruction is executed, so we return here
    return;
  } else {
    	// assume calling for sleep or halt
		if (newmode == (int)P_HALT)
			logString((char *)"Halting",BUFFER,LOG_NORMAL);
		else // newmode == (int)P_SLEEP
			logString((char *)"Sleeping",BUFFER,LOG_NORMAL);			
		housekeeping();
		shutdown();		
	  	if (newmode == (int)P_HALT)  {
		  	SysIntoHaltMode();
	  	}
		else { // newmode == (int)P_SLEEP
			_SystemOnOff();
		}
		while(1);	
	    // cpu reset on exiting halt/sleep mode, so nothing below here executes
     }
}
Esempio n. 2
0
// possibly stop running driver if allowed by config
void IDAStealth::StealthSession::stopDrivers()
{
	const HideDebuggerConfig& config = HideDebuggerConfig::getInstance();
	if (config.getUnloadRDTSC())
	{
		try
		{
			bool wasRunning = rdtscDriver_.isRunning();
			rdtscDriver_.stopDriver();
			if (wasRunning) logString("Successfully unloaded RDTSC emulation driver");
		}
		catch (const std::exception& e)
		{
			logString("RDTSC driver: " + std::string(e.what()));
		}
	}

	if (config.getUnloadStealth())
	{
		try
		{
			bool wasRunning = stealthDriver_.isRunning();
			stealthDriver_.stopDriver();
			if (wasRunning) logString("Successfully unloaded stealth driver");
		}
		catch (const std::exception& e)
		{
			logString("Stealth driver: " + std::string(e.what()));
		}
	}
}
Esempio n. 3
0
void rtcAlarmFired(unsigned long alarm) {
	char buffer[48], wrk[12];
	void setNextAlarm();
	void removeAlarm(unsigned long);
	APP_IRAM static unsigned long lastActivity;
	
	strcpy(buffer,"rtcAlarmFired() alarm=");
	unsignedlongToHexString((long)alarm, (char *)wrk);
	strcat(buffer, wrk);
	logString(buffer,ASAP,LOG_ALWAYS);
	
	removeAlarm(alarm);	// remove from table if present

	if((alarm & 0x00ffffffL) == 0) {
//	if(*P_Hour == 0 && *P_Minute == 0) { // bump systemcounters 
		incrementCumulativeDays();
//		loadSystemCounts();
		//TODO:Redundant with Flash system counter
//		systemCounts.poweredDays += 1;
//		systemCounts.monthday++;
//		fixBadDate(&systemCounts);
//		saveSystemCounts();
//		logRTC(); // remove
		while(*P_Second == 0) wait(100);
		strcpy(buffer,"poweredDays=");
		longToDecimalString(getCumulativeDays(), buffer+12, 4);
		logString(buffer,ASAP,LOG_ALWAYS);
		lastActivity = 0;  // if up when rollover prevent shutdown
//		resetRTC();
//		resetRTC23();  // test, really set rtc to 0,0,1sec
//		setRTCalarm(0, 0, 0);
	}
	setNextAlarm();
}
Esempio n. 4
0
BOOL
isCategoryLocked(char *cat)
{
	char buffer[READ_LENGTH+1];
	char filepath[PATH_LENGTH];
	char *line;

	int handle, locked;
		
	cpyListPath(filepath,LIST_MASTER); // gets the right path using the current system language
	strcat(filepath,(char *)LIST_MASTER);
	strcat(filepath,(char *)".txt");
	
	handle = tbOpen(filepath, O_RDONLY);
	if(handle < 0) {
		logString("isCategoryLocked: unable to open following path:",BUFFER,LOG_DETAIL);
		logString(filepath, BUFFER,LOG_DETAIL);
		return(FALSE);
	}

	getLine(-1,0);  // reset in case at end from prior use
	for(locked = 0; line = getLine(handle,buffer); locked = 0) {
		if(*line == '!') {
			line++;
			locked = 1;
		}
		if(!strcmp(line, cat))
			break;
	} 
	
	close(handle);
	
	return(locked == 1);

}
Esempio n. 5
0
void rtcAlarmFired(unsigned long alarm) {
	char buffer[48], wrk[12];
	void setNextAlarm();
	void removeAlarm(unsigned long);
	APP_IRAM static unsigned long lastActivity;
	
	strcpy(buffer,"rtcAlarmFired alarm=");
	unsignedlongToHexString((long)alarm, (char *)wrk);
	strcat(buffer, wrk);
	logString(buffer,ASAP,LOG_ALWAYS);
	
//  any rtc alarm not on hour 0 minute 0 will not reset an alarm 
	if(curAlarmSet) {
		removeAlarm(curAlarmSet);
		curAlarmSet = 0;
	}
	if((alarm & 0xffff) == 0) {
//	if(*P_Hour == 0 && *P_Minute == 0) { // bump systemcounters 
		loadSystemCounts();
		systemCounts.poweredDays += 1;
		systemCounts.monthday++;
		fixBadDate(&systemCounts);
		saveSystemCounts();
//		logRTC(); // remove
		while(*P_Second == 0) wait(100);
		strcpy(buffer,"poweredDays=");
		longToDecimalString(systemCounts.poweredDays, buffer+12, 4);
		logString(buffer,ASAP,LOG_ALWAYS);
		lastActivity = 0;  // if up when rollover prevent shutdown
//		resetRTC();
//		resetRTC23();  // test, really set rtc to 0,0,1sec
//		setRTCalarm(0, 0, 0);
	}
	setNextAlarm();
}
Esempio n. 6
0
void
setLockCat(char *cat, int newlock_value) {
	char buffer[READ_LENGTH+1];
	char filepath[PATH_LENGTH];
	char *lineStart, *lineCat, tempLine[80];
	int handle, wHandle, i, locked, bytesToWrite, ret;
	char wFilepath[PATH_LENGTH];
	ListItem *list; 
	
	cpyListPath(filepath,LIST_MASTER); // gets the right path using the current system language
	strcat(filepath,(char *)LIST_MASTER);
	strcat(filepath,(char *)".txt");
	
	handle = tbOpen(filepath, O_RDONLY);
	if(handle < 0) {
		logString("lockCat: unable to open following path:",LOG_NORMAL,LOG_DETAIL);
		logString(filepath, BUFFER,LOG_DETAIL);
		return(FALSE);
	}
	strcpy(wFilepath,"temp.txt");
	wHandle = tbOpen((LPSTR)wFilepath,O_CREAT|O_TRUNC|O_WRONLY);

	getLine(-1,0);  // reset in case at end from prior use
	for(;(lineStart = lineCat = getLine(handle,buffer));) {
		locked = 0;
		if(*lineStart == '!') {
			lineCat++;
			locked = 1;
		}
		if(!strcmp(lineCat, cat)) {	// the category we want
			if(locked == newlock_value) { // nothing to do
				close(handle);
				close(wHandle);
				unlink(wFilepath);
				return;
			}
			if(newlock_value) {
				bytesToWrite = convertDoubleToSingleChar(tempLine,"!",FALSE);
				ret = write(wHandle,(unsigned long)tempLine<<1,1);		
			} else {
				// need to unlock this category
				lineStart = lineCat; // skips the '!' 	
			}
		}
		bytesToWrite = convertDoubleToSingleChar(tempLine,lineStart,TRUE);
		ret = write(wHandle,(unsigned long)tempLine<<1,bytesToWrite);		
	}
	close(handle);
	close(wHandle);
	i = unlink((LPSTR)filepath);
	if (i != -1) {
		i = rename((LPSTR)wFilepath,(LPSTR)filepath);
	}
	
	list = &pkgSystem.lists[context.package->idxMasterList];
	if(!strcmp(list->currentString, cat)) {
		list->isLocked = newlock_value;
	}
}
Esempio n. 7
0
void DebugManager::logCommandLine(const std::vector<UString> &argv) {
	logString("Full command line:");
	for (std::vector<UString>::const_iterator arg = argv.begin(); arg != argv.end(); ++arg) {
		logString(" ");
		logString(*arg);
	}
	logString("\n");
}
Esempio n. 8
0
void setOperationalMode(int newmode) {
	extern void buildMyStatsCSV();
	extern void saveLogFile(int);
	
  if(newmode == (int)P_WAIT) {
  	// stop();  --- should we see if we can WAIT while paused in an audio file?
  	SysIntoWaitMode();
    // when leaving wait mode, next instruction is executed, so we return here
    return;
  } else {
		// give visual feedback of shutting down (aural feedback when user causes shutdown in takeAction())
 		setLED(LED_ALL,TRUE);
  		buildMyStatsCSV();
		buildExchgOstats();
 		clearDeleteQueue();
  		write_config_bin();  // build a config.bin
		writeVersionToDisk(SYSTEM_PATH);  // make sure the version file is correct
  		confirmSNonDisk(); // make sure the serial number file is correct 
 		//cleanUpOldRevs(); // cleanup any old revs 
    	// assume calling for sleep or halt
		*P_Clock_Ctrl |= 0x200;	//bit 9 KCEN enable IOB0-IOB2 key change interrupt
		if (newmode == (int)P_HALT)
			logString((char *)"Halting",BUFFER,LOG_NORMAL);
		else // newmode == (int)P_SLEEP
			logString((char *)"Sleeping",BUFFER,LOG_NORMAL);			
		
		saveLogFile(0);	
		
	  	Snd_Stop();    // no logging
		setLED(LED_ALL,FALSE);
	
		turnAmpOff();

		disk_safe_exit(0);
// try to get the sd card in a safe state - reversw what we do on startup		
		_deviceunmount(0);
		fs_uninit();
		SD_Uninitial();		

		turnSDoff();
		turnNORoff();
	  	
	  	if (newmode == (int)P_HALT)  {
/*
	  		setRTCalarmSeconds(61);		// device should come back on in 61 seconds
*/
		  	SysIntoHaltMode();
	  	}
		else { // newmode == (int)P_SLEEP
			disk_safe_exit(0);

			_SystemOnOff();
		}
	
		while(1);	
	    // cpu reset on exiting halt/sleep mode, so nothing below here executes
     }
}
Esempio n. 9
0
void logException(unsigned int errorCode, const char * pStrError, int takeAction) {
	// errorcode == 1 means memory error from BodyInit() and ucBSInit()
	int i; 
	char errorString[160];
	
	if(vCur_1 < V_MIN_SDWRITE_VOLTAGE) {
	}
	
	if (takeAction || LOG_WARNINGS) {
		strcpy(errorString,"\x0d\x0a" "*** ERROR! (cycle "); //cycle number
		longToDecimalString(systemCounts.powerUpNumber,(char *)(errorString+strlen(errorString)),4);
		strcat(errorString," - version " VERSION ")\x0d\x0a*** #");
		longToDecimalString((long)errorCode,(char *)(errorString+strlen(errorString)),3);
		if (takeAction) {
			strcat(errorString,"-fatal");
			stop();						
		}
		else 
			strcat(errorString,"-warning");

		if (LOG_FILE) {
			logString(errorString,ASAP);
			if (pStrError) {
				LBstrncpy(errorString,pStrError,80);
				logString(errorString,ASAP);
			}
		}
		else {
			appendStringToFile(ERROR_LOG_FILE,errorString);	
			if (pStrError) {
				LBstrncpy(errorString,pStrError,80);
				appendStringToFile(ERROR_LOG_FILE,errorString);
			}
		}
	}		
	//todo: put a parameter in fct to return instead of reset or USB
	//maybe a choice of the three RETURN, RESET, USB
	if (takeAction) {
// 		commenting out code to alert user of error -- just use lights and auto-reset to welcome msg
//		if (errorCode != 10 && errorCode != 14)  // can't access config or system boot 
//			insertSoundFile(ERROR_SOUND_FILE_IDX);
//		if (errorCode != 14) // LED_GREEN and LED_RED are not assigned without config file
			for (i=0; i < 5; i++) {
				setLED(LED_GREEN,FALSE);
				setLED(LED_RED,TRUE);
				wait(500);
				setLED(LED_RED,FALSE);
				setLED(LED_GREEN,TRUE);
				wait(500);
			}
		if (takeAction == USB_MODE) // can't load config
			setUSBDevice (TRUE);
		else if (takeAction == RESET)
			resetSystem();
		else if (takeAction ==  SHUT_DOWN)
			setOperationalMode((int)P_SLEEP);
	}
}
Esempio n. 10
0
// possibly start both, the RDTSC and the stealth driver
void IDAStealth::StealthSession::startDrivers()
{
	HideDebuggerConfig& config = HideDebuggerConfig::getInstance();
	
	try
	{		
		// RDTSC driver
		if (config.getUseRDTSC())
		{
			ResourceItem drvResource = getRDTSCDriverResource();
			// empty driver name means: randomize name!
			std::string driverName = config.getRandRDTSCName() ? "" : "RDTSCEMU";
			rdtscDriver_.startDriver(drvResource, driverName);
			RDTSCMode mode = config.getRDTSCMode();
			unsigned int param = mode == constant ? 0 : config.getRDTSCIncrDelta();
			DWORD ioctlCode = mode == constant ? (DWORD)IOCTL_RDTSCEMU_METHOD_ALWAYS_CONST : (DWORD)IOCTL_RDTSCEMU_METHOD_INCREASING;
			rdtscDriver_.setMode(ioctlCode, &param, sizeof(param));
			std::ostringstream oss;
			oss << "Successfully started RDTSC emulation driver from "
				<< rdtscDriver_.getDriverPath().c_str();
			logString(oss.str());
		}
	}
	catch (const std::exception& e)
	{
		logString(e.what());
	}

	try
	{
		// stealth driver
		if (config.getUseStealthDriver())
		{
			ResourceItem stealthDrvResource = getStealthDriverResource();
			stealthDriver_.startDriver(stealthDrvResource, "STEALTHDRIVER");
			std::ostringstream oss;
			oss << "Successfully started stealth driver from "
				<< stealthDriver_.getDriverPath().c_str();
			logString(oss.str());

			StealthHook mode;
			if (config.getStealthNtSetInfoThread())
			{
				mode = SH_NtSetInformationThread;
				stealthDriver_.setMode(IOCTL_STEALTHDRIVER_ENABLE_HOOKS, &mode, sizeof(StealthHook));
			}
			if (config.getStealthNtQueryInfoProcess())
			{
				mode = SH_NtQueryInformationProcess;
				stealthDriver_.setMode(IOCTL_STEALTHDRIVER_ENABLE_HOOKS, &mode, sizeof(StealthHook));
			}
		}
	}
	catch (const std::exception& e)
	{
		logString(e.what());
	}	
}
Esempio n. 11
0
static int getFileHandle (CtnrFile *newFile) {
	int ret = 0; 
	char sTemp[PATH_LENGTH];
	CtnrPackage *pkg;
		
	pkg = getPackageFromFile(newFile); // get package that applied to file, rather than context package
	// This is necessary for user packages inserting system sounds.

	switch (pkg->pkg_type) {
		case PKG_SYS:
		case SYS_MSG:
			strcpy(sTemp,LANGUAGES_PATH);
			if (pkg->transList.mode == '1')
				strcat(sTemp,TRANSLATE_TEMP_DIR);
			else
				strcat(sTemp,pkg->strHeapStack + pkg->idxName);
				
			strcat(sTemp,"/");
			if (newFile->idxFirstBlockInFile == -1) 	// check for list
				strcat(sTemp,TOPICS_SUBDIR);
			else
				strcat(sTemp,UI_SUBDIR);			
			break;		
		case PKG_APP:
			strcpy(sTemp, USER_PATH);
			strcat(sTemp,pkg->strHeapStack + pkg->idxName);
			strcat(sTemp,"/");
			//USERS CAN'T USE LISTS YET - ONLY THE SYSTEM PACKAGE
			//if (newFile->idxFirstBlockInFile == -1) 	// check for list
			//	strcat(sTemp,LISTS_SUBDIR);
			break;
		case PKG_MSG:	
			strcpy(sTemp, USER_PATH);
			break;
	}
	strcat(sTemp,pkg->strHeapStack + newFile->idxFilename);
	strcat(sTemp,AUDIO_FILE_EXT);

	ret = tbOpen((LPSTR)sTemp,O_RDONLY);
	if (DEBUG_MODE) {
		logString(sTemp,BUFFER);
		if (ret == -1) {
			strcpy(sTemp,"last file not found");
			logString(sTemp,ASAP);
		}
	}
	
	if ((ret >= 0)/* && (pkg->pkg_type > PKG_SYS)*/) {
		recordStats(sTemp, (long)ret, STAT_OPEN, pkg->pkg_type);
	}
	
//	logString(sTemp,ASAP);
	return ret;
}
Esempio n. 12
0
	bool Shader::compile()
	{
		m_program = glCreateProgram();
		glCompileShader(m_vertex);
		GLint status;
		glGetShaderiv(m_vertex, GL_COMPILE_STATUS, &status);
		if(status != GL_TRUE)
		{
			GLint length;
			glGetShaderiv(m_vertex, GL_INFO_LOG_LENGTH, &length);
			char* log = new char[length];
			glGetShaderInfoLog(m_vertex, length, 0, log);
			std::string logString(log);
			delete [] log;
			Util::LogManager::error("Error while compiling vertex shader "+ m_vertFile +": "+logString);
			return false;
		} else
			m_vertexLoaded = true;

		glCompileShader(m_fragment);
		glGetShaderiv(m_fragment, GL_COMPILE_STATUS, &status);
		if(status != GL_TRUE)
		{
			GLint length;
			glGetShaderiv(m_fragment, GL_INFO_LOG_LENGTH, &length);
			char* log = new char[length];
			glGetShaderInfoLog(m_fragment, length, 0, log);
			std::string logString(log);
			delete [] log;
			Util::LogManager::error("Error while compiling vertex shader "+ m_fragFile +": "+logString);
			return false;
		} else
			m_fragmentLoaded = true;
		glAttachShader(m_program, m_vertex);
		glAttachShader(m_program, m_fragment);
		glLinkProgram(m_program);

		glGetProgramiv(m_program, GL_LINK_STATUS, &status);
		if(status != GL_TRUE)
		{
			GLint length;
			glGetProgramiv(m_program, GL_INFO_LOG_LENGTH, &length);
			char* log = new char[length];
			glGetProgramInfoLog(m_program, length, 0, log);
			std::string logString(log);
			delete [] log;
			Util::LogManager::error("Error while linking shader: "+logString);
			return false;
		} else
			m_programLoaded = true;

		return true;
	}
Esempio n. 13
0
Status logQueryLogItem(const QueryLogItem& results,
                       const std::string& receiver) {
  if (FLAGS_disable_logging) {
    return Status(0, "Logging disabled");
  }

  std::vector<std::string> json_items;
  Status status;
  if (FLAGS_log_result_events) {
    status = serializeQueryLogItemAsEventsJSON(results, json_items);
  } else {
    std::string json;
    status = serializeQueryLogItemJSON(results, json);
    json_items.push_back(json);
  }
  if (!status.ok()) {
    return status;
  }

  for (auto& json : json_items) {
    if (!json.empty() && json.back() == '\n') {
      json.pop_back();
      status = logString(json, "event", receiver);
    }
  }
  return status;
}
int main(int argc, char *argv[]) {
  char inputSequenceFile[100], log_desc[1000] ;
  int ret ;

  if(argc != 2) {
    printf("Usage: %s <input-transaction-file-path>\n", argv[0]) ;
    return  0 ;
  }
  strcpy(inputSequenceFile, argv[1]) ;
  ret = checkFileExists(inputSequenceFile) ;
  if(ret == -1) {
   printf("main: File %s does not exist or is an empty file. Exiting\n", inputSequenceFile) ;
   return  0 ;
  }
  FILE *fp = fopen("repcrec.log", "w") ;
  if(fp == NULL) {
    printf("main: failed to open log file in write mode. Error: %s\n", (char *)strerror(errno)) ;
  }
  else {
    fclose(fp) ;
  }
  initializeTransactionManager() ;
  initializeSiteData() ;
  ret = parseInput(inputSequenceFile) ;
  if(ret == -1) {
   printf("main: parseInput could not parse file %s. Exiting\n", inputSequenceFile) ;
   return  0 ;
  }
  startTransactionManager() ;
  sprintf(log_desc, "main: Transaction Manager exiting\n") ;
  logString(log_desc) ;
  return  0 ;
}
Esempio n. 15
0
TEST_F(LoggerTests, test_log_string) {
    // So far, tests have only used the logger registry/plugin API.
    EXPECT_TRUE(logString("{\"json\": true}", "event"));
    ASSERT_EQ(LoggerTests::log_lines.size(), 1U);
    EXPECT_EQ(LoggerTests::log_lines.back(), "{\"json\": true}");

    // Expect the logString method to fail if we explicitly request a logger
    // plugin that has not been added to the registry.
    EXPECT_FALSE(logString("{\"json\": true}", "event", "does_not_exist"));

    // Expect the plugin to receive logs if status logging is disabled.
    FLAGS_disable_logging = true;
    EXPECT_TRUE(logString("test", "event"));
    EXPECT_EQ(LoggerTests::log_lines.size(), 2U);
    FLAGS_disable_logging = false;
}
Esempio n. 16
0
void IDAStealth::StealthSession::handleRtlGetNtGlobalFlags(unsigned int processID)
{
	HideDebuggerConfig& config = HideDebuggerConfig::getInstance();
	if (!config.getRtlGetNtGlobalFlags()) return;
	
	// assumes that ntdll is loaded to the IBA across processes
	// on ASLR systems, each image is randomized once and is 
	// mapped to the same IBA until reboot
	HMODULE hNtDll = LoadLibrary("ntdll.dll");
	LPVOID address = GetProcAddress(hNtDll, "RtlGetNtGlobalFlags");
	if (address)
	{
		// xor eax, eax; retn
		unsigned char opcodes[] = { 0x31, 0xC0, 0xC3 };
		try
		{
			Process process(processID);
			process.writeMemory(address, opcodes, 3);
		}
		catch (MemoryAccessException& e)
		{
			logString("Error while trying to patch RtlGetNtGlobalFlags: " + std::string(e.what()));
		}
	}
	FreeLibrary(hNtDll);
}
Esempio n. 17
0
void Logger::logBinary(uint32_t style, const void* data, size_t size) {
  static const char prefix[] = ".data ";
  static const char hex[16] = { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F' };

  const uint8_t* s = static_cast<const uint8_t*>(data);
  size_t i = size;

  char buffer[128];
  ::memcpy(buffer, prefix, ASMJIT_ARRAY_SIZE(prefix) - 1);

  while (i) {
    uint32_t n = static_cast<uint32_t>(IntUtil::iMin<size_t>(i, 16));
    char* p = buffer + ASMJIT_ARRAY_SIZE(prefix) - 1;

    i -= n;
    do {
      uint32_t c = s[0];

      p[0] = hex[c >> 4];
      p[1] = hex[c & 15];

      p += 2;
      s += 1;
    } while (--n);

    *p++ = '\n';
    logString(style, buffer, static_cast<size_t>(p - buffer));
  }
}
Esempio n. 18
0
void saveSystemCounts() {
	int handle, ret, i;

	if(vCur_1 < V_MIN_SDWRITE_VOLTAGE) {
		refuse_lowvoltage(0);
		return;
	}
		
	i = 0;
	do {
 		ret = unlink((LPSTR)(SYSTEM_VARIABLE_FILE));
 		if (ret)
	 		wait(100);
	}
	while (ret && ++i < 3);
	
	handle = tbOpen((LPSTR)(SYSTEM_VARIABLE_FILE),O_CREAT|O_RDWR);
	if (handle != -1)
		ret = write(handle, (unsigned long)&systemCounts<<1, sizeof(SystemCounts)<<1);
	else {
		if (ret)
			logString((char *)"failed unlink of system var file",BUFFER,LOG_ALWAYS);
		close(handle);
		logException(17,SYSTEM_VARIABLE_FILE,RESET); //can't save SYSTEM_VARIABLE_FILE;
	}
	close(handle);
}
Esempio n. 19
0
void resetSystem(void) {
	// set watchdog timer to reset device; 0x780A (Watchdog Reset Control Register)
	// see GPL Programmer's Manual (V1.0 Dec 20,2006), Section 3.5, page 18
	checkVoltage();  // USB may have been supplying sole power -- need to check if voltage dropping fast
	stop(); 
	if (PLEASE_WAIT_IDX && context.package) {  // prevents trying to insert this sound before config & control files are loaded.
		insertSound(&pkgSystem.files[PLEASE_WAIT_IDX],NULL,TRUE); 
	}
	checkVoltage();  // USB may have been supplying sole power -- need to check if voltage dropping fast
	saveVolumeProfile();
	logString((char *)"* RESET *",ASAP,LOG_ALWAYS);
	saveLogFile(0);	
	fs_safexit(); // should close all open files
	disk_safe_exit(0);
// try to get the sd card in a safe state - reverse what we do on startup		
	_deviceunmount(0);
	fs_uninit();
	SD_Uninitial();		
	turnSDoff();

	playBip();
	setLED(LED_ALL,FALSE);  

	*P_WatchDog_Ctrl &= ~0x4001; // clear bits 14 and 0 for resetting system and time=0.125 sec 	
	*P_WatchDog_Ctrl |= 0x8004; // set bits 2 and 15 for 0.125 sec, system reset, and enable watchdog
	while(1);	
}
Esempio n. 20
0
void setNextAlarm() {
	unsigned int i, hour, minute, second;
	unsigned long newAlarm;
	unsigned long curRTC   = getRTCinSeconds();
	
	curAlarmSet = 0;
/* for now disable all alarma except the one at 0:0:0 */
/*	for(i=0; i<N_RTC_ALARMS; i++) {
		if(rtcAlarm[i] > curRTC) {
			newAlarm = rtcAlarm[i];
			hour   = newAlarm / 3600;
			minute = (newAlarm % 3600) / 60;
			second = (newAlarm % 3600) % 60;
			setRTCalarm(hour, minute, second);
			logString("setRTCalarm(non-zero)",BUFFER,LOG_NORMAL); 
			curAlarmSet = newAlarm;
			break;	
		}
	}
*/
	if(curAlarmSet == 0 ) {
		logString("setRTCalarm(0,0,0)",BUFFER,LOG_DETAIL); 
		while(*P_Hour == 0 && *P_Minute == 0 && *P_Second == 0);
		setRTCalarm(0, 0, 0);
// test		setPlus10();	
	}
}
Esempio n. 21
0
TEST_F(TLSLoggerTests, test_database) {
  // Start a server.
  TLSServerRunner::start();
  TLSServerRunner::setClientConfig();

  auto forwarder = std::make_shared<TLSLogForwarder>();
  std::string expected = "{\"new_json\": true}";
  forwarder->logString(expected);
  StatusLogLine status;
  status.message = "{\"status\": \"bar\"}";
  forwarder->logStatus({status});

  // Stop the server.
  TLSServerRunner::unsetClientConfig();
  TLSServerRunner::stop();

  std::vector<std::string> indexes;
  scanDatabaseKeys(kLogs, indexes);
  EXPECT_EQ(2U, indexes.size());

  // Iterate using an unordered search, and search for the expected string
  // that was just logged.
  bool found_string = false;
  for (const auto& index : indexes) {
    std::string value;
    getDatabaseValue(kLogs, index, value);
    found_string = (found_string || value == expected);
    deleteDatabaseValue(kLogs, index);
  }
  EXPECT_TRUE(found_string);
}
Esempio n. 22
0
void
set_voltmaxvolume(BOOL forceLower)
{
	int wrk = V_MIN_VOL_VOLTAGE - vCur_1;
	
	if (wrk <= 0 || forceLower) {
		if (forceLower)
			wrk = MAX_VOLUME - 1;			
		else {
			wrk >>= 3;
			// for every .08 volt below V_MIN_VOL_VOLTAGE subtract 1 from MAX_VOLUME
			wrk = 16 - wrk;
		}
		if(wrk < 1) wrk = 1;
		if(wrk < MAX_VOLUME) {
			MAX_VOLUME = wrk;
			if (volume > MAX_VOLUME) {
				volume = MAX_VOLUME;
				SACM_Volume(volume);
				playBip();	
			}
			if (TRUE) { // logging voltage for all devices in the field (DEBUG_MODE) {
				char log[15] = "v---,MV--,CV--";
				longToDecimalString(vCur_1, log+1, 3);
				log[4] = ',';
				longToDecimalString((long)MAX_VOLUME,log+7,2);
				log[9] = ',';
				longToDecimalString((long)volume,log+11,2);
				logString(log,BUFFER,LOG_NORMAL);
			}		
		}
	}
}
Esempio n. 23
0
void logVoltage() {
	int i;
	unsigned int sample;
	char buffer[40];
	unsigned long time = getRTCinSeconds();
	APP_IRAM static unsigned long timeLastSample = -1;
	
//	if ((context.isStopped || context.isPaused) && (time > (timeInitialized + 2)))     // 2-3 second delay)
	if (VOLTAGE_SAMPLE_FREQ_SEC && (context.isStopped || context.isPaused) && time > (timeLastSample+VOLTAGE_SAMPLE_FREQ_SEC)) { 	
		sample = getCurVoltageSample();
		strcpy(buffer,"V:");
	 	longToHexString(((long)vThresh_1 & 0xffff),buffer+strlen(buffer),1);
	 	strcat(buffer," | ");
	 	
		if(sample == 0xffff) {
			sample = getCurVoltageSample();
			if(sample == 0xffff)
				return;
		}
		
		longToDecimalString((long)sample,buffer+strlen(buffer),3);
		i = strlen(buffer);
		buffer[i+1] = 0;
		buffer[i] = buffer[i-1];
		buffer[i-1] = buffer[i-2];
		buffer[i-2] = '.'; 
		logString(buffer,ASAP,LOG_DETAIL);				
	 	voltage = sample;			 		
		timeLastSample = time;
	}
}
Esempio n. 24
0
static void logKeystroke(int intKey) {
	int i;
	char str[20];

	if (LOG_KEYS) {
		longToDecimalString(keydown_counter,str,4);
		if(intKey & 0x8000) {   // key up
			if(intKey & 0x4000) {
				strcat(str," LONG ");
			} else {
				strcat(str,"  UP  ");
			}
		} else {
			strcat(str," DOWN ");
		}
		intKey &= 0x7fff;
		strcat(str,", ");
		i = strlen(str)-1;
		if (intKey == KEY_LEFT) str[i] = TEXT_EVENT_LEFT;
			else if (intKey == KEY_RIGHT) str[i] = TEXT_EVENT_RIGHT;
			else if (intKey == KEY_UP) str[i] = TEXT_EVENT_UP;
			else if (intKey == KEY_DOWN) str[i] = TEXT_EVENT_DOWN;
			else if (intKey == KEY_SELECT) str[i] = TEXT_EVENT_SELECT;
			else if (intKey == KEY_HOME) str[i] = TEXT_EVENT_HOME;
			else if (intKey == KEY_PLAY) str[i] = TEXT_EVENT_PLAY;
			else if (intKey == KEY_STAR) str[i] = TEXT_EVENT_STAR;
			else if (intKey == KEY_PLUS) str[i] = TEXT_EVENT_PLUS;
			else if (intKey == KEY_MINUS) str[i] = TEXT_EVENT_MINUS;
		logString(str,ASAP,LOG_ALWAYS);	
	}
}
TEST_F(FilesystemLoggerTests, test_log_string) {
  EXPECT_TRUE(logString("{\"json\": true}", "event"));

  std::string content;
  EXPECT_TRUE(readFile(results_path_, content));
  EXPECT_EQ(content, "{\"json\": true}\n");
}
Esempio n. 26
0
void Logger::logString( LogLevel::LogLevel level, const std::string& message )
{
    if ( level <= mLogLevel && !mIgnoreRank )
    {
        logString( message );
    }
}
Esempio n. 27
0
TEST_F(LoggerTests, test_multiple_loggers) {
  auto& rf = RegistryFactory::get();
  auto second = std::make_shared<SecondTestLoggerPlugin>();
  rf.registry("logger")->add("second_test", second);
  EXPECT_TRUE(rf.setActive("logger", "test,second_test").ok());

  auto test_plugin = rf.registry("logger")->plugin("test");
  auto test_logger = std::dynamic_pointer_cast<TestLoggerPlugin>(test_plugin);
  test_logger->shouldLogStatus = false;

  // With two active loggers, the string should be added twice.
  logString("this is a test", "added");
  EXPECT_EQ(2U, LoggerTests::log_lines.size());

  LOG(WARNING) << "Logger test is generating a warning status (4)";
  // Refer to the above notes about status logs not emitting until the logger
  // it initialized. We do a 0-test to check for dead locks around attempting
  // to forward Glog-based sinks recursively into our sinks.
  EXPECT_EQ(0U, LoggerTests::statuses_logged);

  // Now try to initialize multiple loggers (1) forwards, (2) does not.
  initLogger("logger_test");
  LOG(WARNING) << "Logger test is generating a warning status (5)";
  // Now that the "test" logger is initialized, the status log will be
  // forwarded.
  EXPECT_EQ(1U, LoggerTests::statuses_logged);

  // Multiple logger plugins have a 'primary' concept.
  auto flag_default = FLAGS_logger_secondary_status_only;
  FLAGS_logger_secondary_status_only = true;
  logString("this is another test", "added");
  // Only one log line will be appended since 'second_test' is secondary.
  EXPECT_EQ(3U, LoggerTests::log_lines.size());
  // Only one status line will be forwarded.
  LOG(WARNING) << "Logger test is generating another warning (6)";
  EXPECT_EQ(2U, LoggerTests::statuses_logged);
  FLAGS_logger_secondary_status_only = flag_default;
  logString("this is a third test", "added");
  EXPECT_EQ(5U, LoggerTests::log_lines.size());

  // Reconfigure the second logger to forward status logs.
  test_logger->shouldLogStatus = true;
  initLogger("logger_test");
  LOG(WARNING) << "Logger test is generating another warning (7)";
  EXPECT_EQ(4U, LoggerTests::statuses_logged);
}
Esempio n. 28
0
void setNextAlarm() {
	unsigned int i, hour, minute, second;
	unsigned long newAlarm;
	unsigned long curRTC   = getRTCinSeconds();
	char buf[64], strbuf[12];
	
	curAlarmSet = 0;

	for(i=0; i<N_RTC_ALARMS; i++) {
		if(rtcAlarm[i] > curRTC) {
			newAlarm = rtcAlarm[i];
			hour = newAlarm / 3600;
			while(hour >= 24)
				hour = hour - 24;
			minute = (newAlarm % 3600) / 60;
			while(minute >= 60)
				minute = minute - 60;
			second = (newAlarm % 3600) % 60;
			
			setRTCalarm(hour, minute, second);
			newAlarm = (long)((long)hour * 3600L) + (long)((long)minute * 60L) + (long)second;
				
			strcpy(buf,"setRTCalarm to ");
			unsignedlongToHexString((unsigned long)newAlarm, (char *)strbuf);
			strcat(buf, strbuf);
			logString(buf,BUFFER,LOG_DETAIL);
			 
			strcpy(buf,"   RTC = ");
			unsignedlongToHexString(curRTC, (char *)strbuf);
			strcat(buf, strbuf);
			logString(buf,BUFFER,LOG_DETAIL); 
		
			curAlarmSet = newAlarm;
			break;	
		}
	}

	if(curAlarmSet == 0 ) {
		logString("setRTCalarm(0,0,0)",BUFFER,LOG_DETAIL); 
		while(*P_Hour == 0 && *P_Minute == 0 && *P_Second == 0);
		setRTCalarm(0, 0, 0);
// test		setPlus10();	
	}
	
}
Esempio n. 29
0
const std::string Program::getInfoLog() const {
	GLint length;
	glGetProgramiv(m_nGLId, GL_INFO_LOG_LENGTH, &length);
	char* log = new char[length];
	glGetProgramInfoLog(m_nGLId, length, 0, log);
	std::string logString(log);
	delete [] log;
	return logString;
}
Esempio n. 30
0
void quitProgram(int returnValue)
{
#ifdef SOUND_ENABLED
  Mix_FadeOutMusic(700);
#endif
  if(unpacked)
  {
    logString("Quitting\n");
    remove("textures/CRYSTAL.BMP");
    remove("textures/FLY.BMP");
    remove("textures/JOHN.BMP");
    remove("textures/MARS1.BMP");
    remove("textures/MARS2.BMP");
    remove("textures/METAL.BMP");
    remove("textures/MOON1.BMP");
    remove("textures/MOON2.BMP");
    remove("textures/SAND.BMP");
    remove("textures/STEIN1.BMP");
    remove("textures/STEIN.BMP");
    remove("textures/STONE53.BMP");
    remove("textures/STONE54.BMP");
    remove("sounds/bg.ogg");
    remove("sounds/boom.wav");
    remove("sounds/crystal.wav");
    remove("sounds/fanfare.wav");
    remove("gfx/font.bmp");
    remove("gfx/particle.bmp");
    remove("gfx/loading.bmp");
    remove("textures");
    remove("sounds");
    remove("gfx");
  }
  
  hiScores = fopen(hsFName, "w");
  if (!hiScores)
    fprintf(stderr, "Couldn't write Hall of Fame\n");
  else
  {
    int i;
    for(i=0; i<10; i++)
    {
      fprintf(hiScores, "%s = %d %d %d\n",
        scores[i].Name, scores[i].mins, scores[i].secs, scores[i].dsec);
    }
    fclose(hiScores);
  }
  
  free(camBase);
  free(shipBase);
#ifdef SOUND_ENABLED
  while(Mix_FadingMusic() == MIX_FADING_OUT){};
#endif
  SDL_Quit();
  if(!debug && unpacked)
    fclose(logfile);
  exit(returnValue);
}