OPENVPN_EXPORT int
openvpn_plugin_func_v1(openvpn_plugin_handle_t handle, const int type, const char *argv[], const char *envp[])
{
	struct plugin_context *context = (struct plugin_context *) handle;

	if (type == OPENVPN_PLUGIN_UP) {
		PrintTime();
		printf("PLUGIN: Starting firewall\n");
		if (context->pktFilter.StartFirewall())
			return OPENVPN_PLUGIN_FUNC_SUCCESS;
		else {
			PrintTime();
			printf("PLUGIN: Start failed!\n");
			return OPENVPN_PLUGIN_FUNC_ERROR;
		}
	}
	if (type == OPENVPN_PLUGIN_DOWN) {
		PrintTime();
		printf("PLUGIN: Stopping firewall\n");
		if (context->pktFilter.StopFirewall())
				return OPENVPN_PLUGIN_FUNC_SUCCESS;
		else {
			PrintTime();
			printf("PLUGIN: Can't stop firewall!\n");
			return OPENVPN_PLUGIN_FUNC_ERROR;
		}

	}
		PrintTime();
		printf("PLUGIN: Unknown handler!\n");
		return OPENVPN_PLUGIN_FUNC_SUCCESS;
}
Exemplo n.º 2
0
bool RsaDevice_GenEntropyRequest(RsaDevice d,
    BIGNUM* commit_x, BIGNUM* commit_y)
{
  if(d->x || d->y) return false;

  PrintTime("Getting x, y, r_p, r_q");
  CHECK_CALL(d->x = RsaParams_RandomLargeValue(d->params));
  CHECK_CALL(d->y = RsaParams_RandomLargeValue(d->params));
  CHECK_CALL(d->rand_p = IntegerGroup_RandomExponent(RsaParams_GetGroup(d->params)));
  CHECK_CALL(d->rand_q = IntegerGroup_RandomExponent(RsaParams_GetGroup(d->params)));
  PrintTime("...done");

  bool retval = (d->x && d->y && d->rand_p && d->rand_q);

  PrintTime("Generating C(x), C(y)");
  BIGNUM* cx = IntegerGroup_Commit(RsaParams_GetGroup(d->params), d->x, d->rand_p);
  BIGNUM* cy = IntegerGroup_Commit(RsaParams_GetGroup(d->params), d->y, d->rand_q);
  PrintTime("...done");


  CHECK_CALL(cx);
  CHECK_CALL(cy);

  CHECK_CALL(BN_copy(commit_x, cx));
  CHECK_CALL(BN_copy(commit_y, cy));

  BN_clear_free(cx);
  BN_clear_free(cy);

  return retval;
}
Exemplo n.º 3
0
VOID SyscallExit(THREADID threadIndex, CONTEXT *ctxt, SYSCALL_STANDARD std, VOID *v) {
	if(thread_to_syscall[threadIndex].ip == 0)
		return;

	if(thread_to_syscall[threadIndex].num == SYS_mmap) {
		void *ret = (void *)(PIN_GetSyscallReturn(ctxt, std));

		assert(ret != NULL);
		if(ret != MAP_FAILED) {
			ADDRINT *args = &thread_to_syscall[threadIndex].args[0];
			void *given_addr = (void *)(*args++);
			size_t length = (size_t)(*args++);
			int prot = (int)(*args++);
			int flags = (int)(*args++);
			int fd = (int)(*args++);
			off_t offset = (off_t)(*args++);

			PrintTime(NULL);
			output_dummy_stacktrace();
			mprintf("mtrace_mmap(%p, %lu, %d, %d, %d, %lu) = %p\n", given_addr, length, prot, flags, fd, offset, ret);

			void *addr_start = ret;
			void *addr_end = (void *)((UINT8 *) addr_start + length - 1);
			(void) given_addr;
			(void) offset;
			if(flags & MAP_FIXED) {
				MemregionTracker::remove_overlaps(addr_start, addr_end);
			}

			if((flags & MAP_SHARED) &&
				(prot & PROT_WRITE) &&
				!(flags & MAP_ANON) &&
				!(flags & MAP_ANONYMOUS)
				&& (fd > 0))
			{
				MemregionTracker::insert(addr_start, addr_end);
			}

		}
	}

	if(thread_to_syscall[threadIndex].num == SYS_munmap) {
		int ret = static_cast<int>(PIN_GetSyscallReturn(ctxt, std));

		if(ret != -1) {
			ADDRINT *args = &thread_to_syscall[threadIndex].args[0];
			void *addr_start = (void *)(*args++);
			size_t length = (size_t)(*args++);

			PrintTime(NULL);
			output_dummy_stacktrace();
			mprintf("mtrace_munmap(%p, %lu) = %d\n", addr_start, length, ret);

			void *addr_end = (void *)((UINT8 *) addr_start + length - 1);

			MemregionTracker::remove_overlapping_regions(addr_start, addr_end);
		}
	}
}
Exemplo n.º 4
0
void CTick::Display()
	{
	PrintTime(_L("Start time"),iStartTime);
	TInt i;
	for (i=0; i<4; i++)
		{
		TBuf<16> name;
		name.Format(_L("Beat %d"),i);
		PrintTime(name,iTimes[i]);
		}
	}
Exemplo n.º 5
0
static 
void BKZStatus(double tt, double enum_time, unsigned long NumIterations, 
               unsigned long NumTrivial, unsigned long NumNonTrivial, 
               unsigned long NumNoOps, long m, 
               const mat_ZZ& B)
{
   cerr << "---- BKZ_XD status ----\n";
   cerr << "elapsed time: ";
   PrintTime(cerr, tt-StartTime);
   cerr << ", enum time: ";
   PrintTime(cerr, enum_time);
   cerr << ", iter: " << NumIterations << "\n";
   cerr << "triv: " << NumTrivial;
   cerr << ", nontriv: " << NumNonTrivial;
   cerr << ", no ops: " << NumNoOps;
   cerr << ", rank: " << m;
   cerr << ", swaps: " << NumSwaps << "\n";



   ZZ t1;
   long i;
   double prodlen = 0;

   for (i = 1; i <= m; i++) {
      InnerProduct(t1, B(i), B(i));
      if (!IsZero(t1))
         prodlen += log(t1);
   }

   cerr << "log of prod of lengths: " << prodlen/(2.0*log(2.0)) << "\n";


   if (LLLDumpFile) {
      cerr << "dumping to " << LLLDumpFile << "...";

      ofstream f;
      OpenWrite(f, LLLDumpFile);
      
      f << "[";
      for (i = 1; i <= m; i++) {
         f << B(i) << "\n";
      }
      f << "]\n";

      f.close();

      cerr << "\n";
   }

   LastTime = tt;
   
}
Exemplo n.º 6
0
void TestStringArraySort(std::ofstream& out, unsigned int const size, bool const isRandom = true)
{
    CTimsortParamsDefault defaultParameters;

    if(isRandom)
    {
        clock_t timeBeginTimsort, timeEndTimsort, timeBeginStdsort, timeEndStdsort = 0;

        out << "Random string array of " << size << " elements" << std::endl;
        std::vector<std::string> inputVector;
        GenerateRandomStringArray(inputVector, size);
        std::vector<std::string> cloneVector = inputVector;

        timeBeginTimsort = clock();
        Timsort<std::vector<std::string>::iterator, bool (*)(std::string const&, std::string const&)>(inputVector.begin(),
                                                                                                      inputVector.end(),
                                                                                                      StringCompare, &defaultParameters);
        timeEndTimsort = clock();

        timeBeginStdsort = clock();
        std::sort(cloneVector.begin(), cloneVector.end(), StringCompare);
        timeEndStdsort = clock();

        PrintTime(timeBeginTimsort, timeEndTimsort, out, "Timsort");
        PrintTime(timeBeginStdsort, timeEndStdsort, out, "std::sort");
        out << std::endl << std::endl;
    }
    else
    {
        clock_t timeBeginTimsort, timeEndTimsort, timeBeginStdsort, timeEndStdsort = 0;

        out << "Partially sorted string array of " << size << " elements" << std::endl;
        std::vector<std::string> inputVector;
        GeneratePartiallySortedStringArray(inputVector, size);
        std::vector<std::string> cloneVector = inputVector;

        timeBeginTimsort = clock();
        Timsort<std::vector<std::string>::iterator, bool (*)(std::string const&, std::string const&)>(inputVector.begin(),
                                                                                                      inputVector.end(),
                                                                                                      StringCompare, &defaultParameters);
        timeEndTimsort = clock();

        timeBeginStdsort = clock();
        std::sort(cloneVector.begin(), cloneVector.end(), StringCompare);
        timeEndStdsort = clock();

        PrintTime(timeBeginTimsort, timeEndTimsort, out, "Timsort");
        PrintTime(timeBeginStdsort, timeEndStdsort, out, "std::sort");
        out << std::endl << std::endl;
    }
}
Exemplo n.º 7
0
void TestIntArraySort(std::ofstream& out, unsigned int const size, bool const isRandom = true)
{
    CTimsortParamsDefault defaultParameters;
    if(isRandom)
    {
        clock_t timeBeginTimsort, timeEndTimsort, timeBeginStdsort, timeEndStdsort = 0;

        out << "Random array of " << size << " elements" << std::endl;
        std::vector<int> inputVector;
        GenerateRandomIntArray(inputVector, size);
        std::vector<int> cloneVector = inputVector;

        timeBeginTimsort = clock();
        Timsort<std::vector<int>::iterator, std::less<int> >(inputVector.begin(), inputVector.end(), std::less<int>(), &defaultParameters);
        timeEndTimsort = clock();

        timeBeginStdsort = clock();
        std::sort(cloneVector.begin(), cloneVector.end(), std::less<int>());
        timeEndStdsort = clock();

        PrintTime(timeBeginTimsort, timeEndTimsort, out, "Timsort");
        PrintTime(timeBeginStdsort, timeEndStdsort, out, "std::sort");
        out << std::endl << std::endl;
    }
    else
    {
        clock_t timeBeginTimsort, timeEndTimsort, timeBeginStdsort, timeEndStdsort = 0;

        out << "Array of " << size << " partially sorted arrays" << std::endl;
        std::vector<std::vector<int> > arrayVector;
        GenerateArraysSequence(arrayVector, size);
        for(std::vector<std::vector<int> >::iterator start = arrayVector.begin(); start != arrayVector.end(); ++start)
        {
            out << "Partially sorted array number " << (start - arrayVector.begin()) + 1 << " of "
                << start->size() << " elements" << std::endl;

            std::vector<int> cloneVector = *start;
            timeBeginTimsort = clock();
            Timsort<std::vector<int>::iterator, std::less<int> >(start->begin(), start->end(), std::less<int>(), &defaultParameters);
            timeEndTimsort = clock();

            timeBeginStdsort = clock();
            std::sort(cloneVector.begin(), cloneVector.end(), std::less<int>());
            timeEndStdsort = clock();

            PrintTime(timeBeginTimsort, timeEndTimsort, out, "Timsort");
            PrintTime(timeBeginStdsort, timeEndStdsort, out, "std::sort");
            out << std::endl << std::endl;
        }
    }
}
Exemplo n.º 8
0
int LoadPropFuncByConfigfile(const gboolean first_load)
{
#ifdef _UI_DEBUG
	PrintTime();
#endif
	if(g_config_file_data != NULL){
		DealSpecialWidget(g_config_file_data->special_list);
	}
#ifdef _UI_DEBUG
	PrintTime();
#endif
        LoadFunctions(first_load);
	return 0;
}
Exemplo n.º 9
0
/********************************************************************************************
*                                                                                           *
*                                             main                                          *
*                                                                                           *
*********************************************************************************************/
int main(void)
{
	char input1[10],input2[10];
	int i=0, j=0, flag=0;
	time_t t0,t;

	t0=time(NULL); // tic

	printf("input1 >>\n");
	scanf("%s",input1);
		while(1){
		if(input1[i]=='\0'){
			break;}
			i++;
		}
	printf("input2 >>\n");
	scanf("%s",input2);
		while(1){
		if(input2[j]=='\0'){
			break;}
			j++;
		}

	isSubstring(input1, input2, i,j);

	t=time(NULL)-t0; // toc
	PrintTime(t);

	return(0);
}
Exemplo n.º 10
0
void SysLog::PrintMsg(Color color, char pfx, const char* source, const char* fmt, va_list ap)
{
    if( !m_initialized )
        return;

    MutexLock l( mMutex );

    PrintTime();

    SetColor( color );
    Print( " %c ", pfx );

    std::string pad = "";
    if(strlen(source) < CONSOLE_LOG_PADDING)
        pad = std::string(CONSOLE_LOG_PADDING-strlen(source), ' ');

    if( source && *source )
    {
        SetColor( COLOR_WHITE );
        Print( "%s%s: ", pad.c_str(), source );

        SetColor( color );
    }

    PrintVa( fmt, ap );
    Print( "\n" );

    SetColor( COLOR_DEFAULT );
}
Exemplo n.º 11
0
void HTML_Log::PrintMsg( Color color, char pfx, const char* source, const char* fmt, va_list ap )
{
    if( !m_initialized )
        return;

    MutexLock l( mMutex );

    PrintTime();

    SetColor( color );
    Print( " %c ", pfx );

    if( source && *source )
    {
        SetColor( COLOR_WHITE );
        Print( "%s: ", source );

        SetColor( color );
    }

    PrintVa( fmt, ap );
    Print( "\n" );

    SetColor( COLOR_DEFAULT );
}
Exemplo n.º 12
0
VOID EmitWrite(THREADID threadid, UINT32 size) {
	assert(size <= 100);
	char bytes[101];
	struct timeval tv;
	VOID *ea = WriteEa[threadid];
	if(MemregionTracker::address_mapped(ea)) {
		gettimeofday(&tv, NULL);
		PIN_SafeCopy(&bytes[0], static_cast<char *>(ea), size);
		bytes[size] = '\0';

		m_dump_bytes(bytes, size);
		if(mwrite_tracker[threadid].next_location == ea && 
			time_diff(tv, mwrite_tracker[threadid].last_time) < coalesce_microsecs) {
			mwrite_tracker[threadid].size += size;
		} else {
			flush_mwrite(threadid);
			PrintTime(&tv);
			output_stacktrace();
			if(print_chars) {
				char tmp[100];
				printable_string(bytes, tmp, 100);
				mprintf("mwrite(%p, \"%s\"..., ", ea, tmp);
			} else {
				mprintf("mwrite(%p, \"\"..., ", ea);
			}
			mwrite_tracker[threadid].size = size;
		}

		mwrite_tracker[threadid].next_location = (UINT8 *)ea + size;
		mwrite_tracker[threadid].last_time = tv;
	}
}
Exemplo n.º 13
0
void Console::CheckEndGroup()
{
	for(int g = groups.GetCount(); --g >= 0;) {
		String gname = groups.GetKey(g);
		Group& group = groups[g];
		if(!IsNull(gname) && group.finished) {
			int p = processes.GetCount();
			while(--p >= 0 && !(!!processes[p].process && processes[p].group == gname))
				;
			if(p < 0) {
				if(group.count > 0) {
					int duration = msecs(group.start_time);
					String msg = NFormat("%s: %d file(s) built in %s, %d msecs / file, duration = %d msecs",
						gname, group.count, PrintTime(group.msecs), group.msecs / group.count, duration);
					if(processes.GetCount() > 1) {
						int k = 100 * processes.GetCount() / (processes.GetCount() - 1);
						msg << NFormat(", parallelization %d%%", minmax(k - group.msecs * k / max(group.raw_msecs, 1), 0, 100));
					}
					msg << '\n';
					spooled_output.Cat(msg);
					if(console_lock < 0) {
						Append(spooled_output);
						spooled_output = Null;
					}
				}
				groups.Remove(g);
			}
		}
	}
}
Exemplo n.º 14
0
static void RecordSystemInformation(HANDLE LogFile)
{
	FILETIME	CurrentTime;
	GetSystemTimeAsFileTime(&CurrentTime);
	char TimeBuffer[100];
	PrintTime(TimeBuffer, CurrentTime);
	hprintf(LogFile, "Error occurred at %s.\r\n", TimeBuffer);
	char	ModuleName[MAX_PATH];
	if (GetModuleFileName(0, ModuleName, sizeof(ModuleName)) <= 0) {
		lstrcpy(ModuleName, "Unknown");
	}
	char	UserName[200];
	DWORD UserNameSize = sizeof(UserName);
	if (!GetUserName(UserName, &UserNameSize)) {
		lstrcpy(UserName, "Unknown");
	}
	hprintf(LogFile, "%s, run by %s.\r\n", ModuleName, UserName);

	SYSTEM_INFO	SystemInfo;
	GetSystemInfo(&SystemInfo);
	hprintf(LogFile, "%d processor(s), type %d.\r\n",
				SystemInfo.dwNumberOfProcessors, SystemInfo.dwProcessorType);

	MEMORYSTATUS	MemInfo;
	MemInfo.dwLength = sizeof(MemInfo);
	GlobalMemoryStatus(&MemInfo);
	// Print out the amount of physical memory, rounded up.
	hprintf(LogFile, "%d MBytes physical memory.\r\n", (MemInfo.dwTotalPhys +
				ONEM - 1) / ONEM);
}
Exemplo n.º 15
0
int main()
{
    int i,n,len,j;
    char s1[9],s2[9];
    freopen("poj3683.txt","r",stdin);
    freopen("poj3683ans.txt","w",stdout);
    while (scanf("%d",&n)!=EOF)
    {
        InitEdge();
        for (i=1;i<=n;i++)
        {
            scanf("%s%s%d",s1,s2,&len);
            wed[i].start=TimeStrToInt(s1);
            wed[i].end=TimeStrToInt(s2);
            wed[i].len=len;
        }
        for (i=1;i<=n;i++)
            for (j=1;j<=n;j++)
            {
                if (i==j) continue;
                if (Conflict(wed[i].start,wed[i].len,wed[j].start,wed[j].len)) AddEdge(i,j+n);
                if (Conflict(wed[i].start,wed[i].len,wed[j].end-wed[j].len,wed[j].len)) AddEdge(i,j);
                if (Conflict(wed[i].end-wed[i].len,wed[i].len,wed[j].start,wed[j].len)) AddEdge(i+n,j+n);
                if (Conflict(wed[i].end-wed[i].len,wed[i].len,wed[j].end-wed[j].len,wed[j].len)) AddEdge(i+n,j);
            }
        if (TwoSAT(n))
        {
            printf("YES\n");
            for (i=1;i<=n;i++) if (ans[i])
            {
                PrintTime(wed[i].start);
                printf(" ");
                PrintTime(wed[i].start+wed[i].len);
                printf("\n");
            }
            else
            {
                PrintTime(wed[i].end-wed[i].len);
                printf(" ");
                PrintTime(wed[i].end);
                printf("\n");
            }
        }
        else printf("NO\n");
    }
    return 0;
}
Exemplo n.º 16
0
void DumpNTCounters(HANDLE InfoFile, PerfThread& Thread, DWORD dwPid, DWORD dwThreads)
{
	fputc(L'\n',InfoFile);
	Lock l(&Thread);
	ProcessPerfData* pdata = Thread.GetProcessData(dwPid, dwThreads);

	if (!pdata)
		return;

	const PerfLib* pf = Thread.GetPerfLib();

	for (size_t i=0; i<ARRAYSIZE(Counters); i++)
	{
		if (!pf->dwCounterTitles[i]) // counter is absent
			continue;

		wchar_t buf[28];
		lstrcpyn(buf,GetMsg(Counters[i].idName),ARRAYSIZE(buf)-2);
		lstrcat(buf,L":");
		fprintf(InfoFile, L"%-24s ", buf);

		switch (pf->CounterTypes[i])
		{
			case PERF_COUNTER_RAWCOUNT:
			{
				// Display as is.  No Display Suffix.
				fprintf(InfoFile, L"%10I64u\n", pdata->qwResults[i]);
			}
			break;
			case PERF_COUNTER_LARGE_RAWCOUNT: //  same, large int
			{
				fprintf(InfoFile, L"%10.0f\n", (FLOAT)pdata->qwResults[i]);
			}
			break;
			case PERF_100NSEC_TIMER:
			{
				// 64-bit Timer in 100 nsec units. Display delta divided by
				// delta time.  Display suffix: "%"
				//fprintf(InfoFile, L"%10.0f%%\n", (FLOAT)pdata->qwResults[i]);
				fprintf(InfoFile, L"%s %7.0f%%\n", PrintTime((ULONGLONG)pdata->qwCounters[i]), (FLOAT)pdata->qwResults[i]);
			}
			break;
			case PERF_COUNTER_COUNTER:
			{
				// 32-bit Counter.  Divide delta by delta time.  Display suffix: "/sec"
				fprintf(InfoFile, L"%10I64u  %5I64u%s\n", pdata->qwCounters[i], pdata->qwResults[i], GetMsg(MperSec));
			}
			break;
			case PERF_COUNTER_BULK_COUNT: //PERF_COUNTER_BULK_COUNT
			{
				// 64-bit Counter.  Divide delta by delta time. Display Suffix: "/sec"
				fprintf(InfoFile, L"%10.0f  %5.0f%s\n", (FLOAT)pdata->qwCounters[i], (FLOAT)pdata->qwResults[i], GetMsg(MperSec));
			}
			break;
			default:
				fputc(L'\n',InfoFile);
		}
	}
}
Exemplo n.º 17
0
void LogLineBox::setTimeMode(RDAirPlayConf::TimeMode mode)
{
  if(mode==line_time_mode) {
    return;
  }
  line_time_mode=mode;
  PrintTime();
}
Exemplo n.º 18
0
void SolverMUX::PrintTimers() const
{
  logout << "Solver EACH:";
  for (size_t ind = 0; ind < m_solvers.Size(); ind++) {
    logout << " " << m_solvers[ind]->Name() << ": ";
    PrintTime(m_elapsed[ind]);
  }
  logout << endl;
}
Exemplo n.º 19
0
	THREAD(TimeSyncThread, arg)
	{
		
		puts("\ntime started\n");
		RegisterDevice();
		puts("shit registered\n");
		for (;;) {
			RetrieveTime();
			PrintTime();
			NutSleep(10000);
		}
	}
Exemplo n.º 20
0
void AltJacobi::operator () (unsigned p,QType result[ /* (p-2)*p */ ]) const
 {
  Printf(Con,"Jacobi #; #;\n",prime,p);
  
  SecTimer timer;
  
  Table table(prime,gen,p);
  
  Printf(Con,"time = #;\n",PrintTime(timer.get()));
  
  for(unsigned k=1; k<p-1 ;k++,result+=p) table(k,result);
 }
Exemplo n.º 21
0
//========================================================================//
void DebugLevelLog::PrintString(const DEBUG_LEVEL_ENUM debug_level, const MESSAGE_TYPES_ENUM msg_type, const char* format_str, ...)
{
   //printf("void DebugLevelLog::PrintString(format_str = <%s>) \n", format_str);

   if ( print_time )  PrintTime(debug_level);

   if(create_log_flag)  {
	FILE * log = NULL;
	char * type_str = (char *) calloc(11, sizeof(char));
   	
   	switch(msg_type)   {
 	     case WARN :
 	       strcpy(type_str, "WARNING : ");
 	       break;
 	     case ERROR :
 	       strcpy(type_str, "ERROR : ");
 	       break;
 	     case FATAL :
 	       strcpy(type_str, "FATAL : ");
 	       break;
 	     case INFO :
 	       break;
 	}
	
	switch(debug_level)    {
      	    case LOGFILE :
      		log = OpenLog();
      		if (log != NULL)        {
	    	    fprintf(log, type_str);
	            va_list param;
	            va_start(param, format_str);
	            vfprintf(log, format_str, param);
          	    va_end(param);        
		    fclose(log);
		}   
   	        break;
	     case STDOUT :
   	        printf(type_str);
   	        va_list param;
	    	va_start(param, format_str);
	        vprintf(format_str, param);
	        va_end(param);
	        break;	    
	}
	
	free(type_str);
    }
    //puts("DebugLevelLog :: PrinString ----- end");
}
Exemplo n.º 22
0
/*
 * Make this public if we need it.
 */
static nsresult NS_TimelineMarkV(const char *text, va_list args)
{
    PRTime elapsed,tmp;

    PR_CallOnce(&initonce, TimelineInit);

    TimelineThreadData *thread = GetThisThreadData();

    tmp = Now();
    LL_SUB(elapsed, tmp, thread->initTime);

    PrintTime(elapsed, text, args);

    return NS_OK;
}
Exemplo n.º 23
0
X509* RsaDevice_RunProtocol(RsaDevice d, bool ca_sign,
    const char* ea_hostname, int ea_port,
    const char* ca_hostname, int ca_port)
{
  PrintTime("Connecting to EA");
  CHECK_CALL(MakeSSLRequest(ea_hostname, ea_port, &RunEaSession, (void*)d));
  PrintTime("Closed connection to EA");

  struct ca_request_data rr;
  rr.client_type = RSA_CLIENT;
  rr.cert = X509_new();

  CHECK_CALL(rr.cert);
  PrintTime("Generating CA request");
  CHECK_CALL(RsaDevice_GenCaCertRequest(d, &(rr.cert)));
  PrintTime("Done generating CA request");

  if(ca_sign) {
    PrintTime("Beginning CA session");
    CHECK_CALL(MakeSSLRequest(ca_hostname, ca_port, &RequestCaSignatureClient, (void*)&rr));
  }

  return rr.cert;
}
Exemplo n.º 24
0
int main()
{
    Time T, Td;
    unsigned int Unit;

    while(scanf("%2d%2d%2d%2d", &T.HH, &T.MM, &T.SS, &T.CC)>0)
    {
        Unit = TimeToUnit(&T);
        UnitToTime(&Td, Unit);

        PrintTime(&Td);
    }

    return 0;
}
Exemplo n.º 25
0
static void PrintSources (const cc65_sourceinfo* S)
/* Output a list of sources */
{
    unsigned I;
    const cc65_sourcedata* D;

    /* Segments */
    for (I = 0, D = S->data; I < S->count; ++I, ++D) {
        PrintId (D->source_id, 8);
        Print ("%-30s", D->source_name);
        PrintNumber (D->source_size, 7, 9);
        PrintTime (D->source_mtime, 0);
        NewLine ();
    }
}
Exemplo n.º 26
0
// Print information about a code module (DLL or EXE) such as its size,
// location, time stamp, etc.
static void ShowModuleInfo(HANDLE LogFile, HINSTANCE ModuleHandle)
{
	char ModName[MAX_PATH];
#ifdef _MSC_VER
	__try {
#endif
		if (GetModuleFileName(ModuleHandle, ModName, sizeof(ModName)) > 0) {
			// If GetModuleFileName returns greater than zero then this must
			// be a valid code module address. Therefore we can try to walk
			// our way through its structures to find the link time stamp.
			IMAGE_DOS_HEADER *DosHeader = (IMAGE_DOS_HEADER*)ModuleHandle;
			if (IMAGE_DOS_SIGNATURE != DosHeader->e_magic) {
	    	    return;
			}

			IMAGE_NT_HEADERS *NTHeader = (IMAGE_NT_HEADERS*)((char *)DosHeader + DosHeader->e_lfanew);
			if (IMAGE_NT_SIGNATURE != NTHeader->Signature) {
	    	    return;
			}

			// Open the code module file so that we can get its file date
			// and size.
			HANDLE ModuleFile = CreateFile(ModName, GENERIC_READ, 
						FILE_SHARE_READ, 0, OPEN_EXISTING,
						FILE_ATTRIBUTE_NORMAL, 0);
			char TimeBuffer[100] = "";
			DWORD FileSize = 0;
			if (ModuleFile != INVALID_HANDLE_VALUE) {
				FileSize = GetFileSize(ModuleFile, 0);
				FILETIME	LastWriteTime;
				if (GetFileTime(ModuleFile, 0, 0, &LastWriteTime)) {
					wsprintf(TimeBuffer, " - file date is ");
					PrintTime(TimeBuffer + lstrlen(TimeBuffer), LastWriteTime);
				}
				CloseHandle(ModuleFile);
			}
			hprintf(LogFile, "%s, loaded at 0x%08x - %d bytes - %08x%s\r\n",
						ModName, ModuleHandle, FileSize,
						NTHeader->FileHeader.TimeDateStamp, TimeBuffer);
		}
#ifdef _MSC_VER
	}
	// Handle any exceptions by continuing from this point.
	__except(EXCEPTION_EXECUTE_HANDLER)
	{
	}
#endif
}
Exemplo n.º 27
0
static void LLLStatus(long max_k, double t, long m, const mat_ZZ& B)
{
   cerr << "---- LLL_XD status ----\n";
   cerr << "elapsed time: ";
   PrintTime(cerr, t-StartTime);
   cerr << ", stage: " << max_k;
   cerr << ", rank: " << m;
   cerr << ", swaps: " << NumSwaps << "\n";

   ZZ t1;
   long i;
   double prodlen = 0;

   for (i = 1; i <= m; i++) {
      InnerProduct(t1, B(i), B(i));
      if (!IsZero(t1))
         prodlen += log(t1);
   }

   cerr << "log of prod of lengths: " << prodlen/(2.0*log(2.0)) << "\n";

   if (LLLDumpFile) {
      cerr << "dumping to " << LLLDumpFile << "...";

      ofstream f;
      OpenWrite(f, LLLDumpFile);
      
      f << "[";
      for (i = 1; i <= m; i++) {
         f << B(i) << "\n";
      }
      f << "]\n";

      f.close();

      cerr << "\n";
   }

   LastTime = t;
   
}
Exemplo n.º 28
0
void InfoIdleScreen::Render(LCD& lcd, byte cols, byte rows) const {
	lcd.setCursor(0, 0);
	if (m_sequence->IsRunning()) {
		int _chars = 0;
		_chars += lcd.print(F("Shot "));
		_chars += lcd.print(m_sequence->GetShotsFired());
		_chars += lcd.print(F("/"));
		_chars += lcd.print(m_sequence->GetShotsTotal());
		Pad(lcd, cols, _chars);

		_chars = 0;
		lcd.setCursor(0, 1);
		_chars += lcd.print(F("Rem. "));
		long _secondsRemaining = m_sequence->GetSecondsRemaining();
		_chars += PrintTime(_secondsRemaining, lcd);
		Pad(lcd, cols, _chars);
	} else {
		Pad(lcd, cols, lcd.print(F("Idle")));
		lcd.setCursor(0, 1);
		Pad(lcd, cols, 0);
	}
}
Exemplo n.º 29
0
VOID SyscallEntry(THREADID threadIndex, CONTEXT *ctxt, SYSCALL_STANDARD std, VOID *v)
{
	flush_mwrite(threadIndex);

	ADDRINT num = PIN_GetSyscallNumber(ctxt, std);

	if(num == SYS_execve) {	
		PrintTime(NULL);
		output_dummy_stacktrace();
		mprintf("mtrace_execve(%ld, %u, %u, %u, %u) = 0\n", syscall(SYS_gettid), PIN_GetTid(), getpid(), threadIndex, PIN_ThreadId());
		m_dump_bytes(NULL, 0);
		return;
	}

	if (num != SYS_mmap && num != SYS_munmap) {
		thread_to_syscall[threadIndex].ip = 0;
		return;
	}


	thread_to_syscall[threadIndex].num = num;
	thread_to_syscall[threadIndex].ip = PIN_GetContextReg(ctxt, REG_INST_PTR);

	if(num == SYS_mmap) {
		for(int i = 0; i < 6; i++) {
			#if defined(TARGET_LINUX) && defined(TARGET_IA32)
			thread_to_syscall[threadIndex].args[i] =
				(reinterpret_cast<ADDRINT *>(PIN_GetSyscallArgument(ctxt, std, 0)))[i];
			#else
			thread_to_syscall[threadIndex].args[i] = PIN_GetSyscallArgument(ctxt, std, i);
			#endif
		}
	} else {
		for(int i = 0; i < 2; i++) {
			thread_to_syscall[threadIndex].args[i] = PIN_GetSyscallArgument(ctxt, std, i);
		}
	}
}
Exemplo n.º 30
0
void test4()
 {
  PlatformRandom random;
  SecTimer timer;
  
  for(ulen cnt=1;;cnt++)
    {
     Printf(Con,"cnt = #;\r",cnt);
    
     Int P=RandomInt(32,random);
     
     if( P<0 ) P=-P;
     
     if( P.isEven() ) P=P+1;
     
     if( Math::NoPrimeTest<Int>::RandomTest(P,30,random) ) 
       {
        Printf(Con,"\ntime = #;\nP = #;\nbits = #;\n",PrintTime(timer.get()),P,P.bitsOf().total());
        
        return;
       }
    }
 }