Exemple #1
0
/* a c based repl */
void repl_c(interp_core_type *interp) {
    load_main(interp);

    /* while the interpreter is running */
    while(interp->running) {
    	object_type *obj=0;

    	printf(">");

    	obj=parse(interp, stdin);
	
    	if(interp->running) {
    	    obj=eval(interp, obj);
	
    	    /* if there was no error, output the result */
    	    if(has_error(interp)) {
    		printf("There was an error executing the given expression");
                output(interp, interp->exception ? interp->exception : obj);
    	    } else {
                output(interp, obj);
            }

    	}
    	printf("\n");
    }
}
Exemple #2
0
Huint _create_system_thread( hthread_t *th, hthread_attr_t *attr, hthread_start_t start, void *arg )
{
    Huint threadStatus;
    Huint threadID;

    // Create the thread id for the new thread
    if( attr->detached )    threadStatus = _create_detached();
    else                    threadStatus = _create_joinable();

    // Check if there was an error while creating the new thread. If
    // there was then it means that all of the available threads are
    // being used, so we return an error.
    if( has_error(threadStatus) )   return EAGAIN;

    // If there was no error then we need to get the new thread's id
    // out of the return status.
    threadID = extract_id( threadStatus );

    // Initialize the software structures used to keep track of the thread.
    _setup_thread( threadID, attr, start, arg );

    // Set the scheduling parameter for the thread.
    _set_schedparam( threadID, attr->sched_param );

    // Return the thread ID to the caller. At this point the thread has
    // been successfully created and added to the queue so that we know
    // a valid thread ID will be returned to the user.
    *th = threadID;

    // The thread was created and added to the ready-to-run queue
    // successfully. Return the success code.
    return SUCCESS;
}
Exemple #3
0
// Command line parsing
std::pair<bool, etix::tool::opt_parse>
parse_cmdline(int argc, char* argv[]) {
    auto opt_parse = etix::tool::opt_parse{ argc, argv };

    opt_parse.optional("-c", "Path to the configuration file (-c /path/to/conf)", true);
    opt_parse.optional("-l", "Set log level (-l 4 will only show warnings and errors)", true);
    opt_parse.optional("-d", "Launch the discovery tool on the given subnet", false);
    opt_parse.optional("-b", "Launch the bruteforce tool on all discovered devices", false);
    opt_parse.optional("-t", "Generate thumbnails from detected cameras", false);
    opt_parse.optional("-g", "Check if the stream can be opened with GStreamer", false);
    opt_parse.optional("-v", "Display Cameradar's version", false);
    opt_parse.optional("-h", "Display this help", false);
    opt_parse.execute();

    if (opt_parse.exist("-h")) {
        opt_parse.print_help();
        return std::make_pair(false, opt_parse);
    } else if (opt_parse.exist("-v")) {
        print_version();
        return std::make_pair(false, opt_parse);
    } else if (opt_parse.has_error()) {
        std::cout << "Usage: ./cameradar [option]\n\toptions:\n" << std::endl;
        opt_parse.print_help();
        return std::make_pair(false, opt_parse);
    }

    return std::make_pair(true, opt_parse);
}
void analyzer::start()
{
    if( has_error() )return ;
    automata* NFAmata = regex_reader::getInstance()->get_nfa(rules_file);
	nfa_to_dfa* converter = nfa_to_dfa::get_instance();
	DFA = converter->get_dfa(NFAmata);
    comp_f_stream.open(compile_file,ios_base::binary);
}
/** \internal
  * \brief  The system call that implements the htread_exit functionality.
  *
  * \author     Wesley Peck <*****@*****.**>
  *
  * This function is the system call routine which implements the 
  * hthread_exit functionality for hthreads. The user space function
  * hthread_exit invokes this function to terminate a thread.
  *
  * \param  retval  The return value of the thread. If the currently
  *                 running thread is in the joinable state then this
  *                 value is returned to the thread which joins with
  *                 the currently running thread, otherwise this
  *                 value is discarded.
  * \return         This function never returns to the calling thread.
  */ 
void _syscall_exit( void *retval )
{
	Huint status;
	Huint current;
    Hbool destroy_flag = Hfalse;

    // Print out a trace message about this system call
    TRACE_PRINTF( TRACE_FINE, TRACE_SYSCALL, "SYSCALL: (OP=EXIT) (RET=0x%8.8x)\n", (Huint)retval );

    // Grab the current thread
	current = _current_thread();
    
    // Print out a trace message about this system call
    TRACE_PRINTF( TRACE_FINE, TRACE_SYSCALL, "SYSCALL: (OP=EXIT) (TID=0x%8.8x) (RET=0x%8.8x)\n", (Huint)current, (Huint)retval );
     
    if( _detached_thread(current) ) destroy_flag = Htrue;

	// The return value needs to be saved before we
	// try to exit the thread (to avoid race conditions when a parent joins
	// a thread and trys to get the return value). Note that we don't
	// need to save the return value for a detached thread.
    threads[current].retval = retval;
    
	// FIXME: We should check the error condition during the while loop
	// to ensure that the error was because the ready-to-run queue is
	// full. Any other error is fatal and since this function never returns
	// to the caller we must handle this error.
	status = _exit_thread( current );

	while( has_error(status) )
	{
        DEBUG_PRINTF( "Exit returned an error: (STA=0x%8.8x)\n", status );

		// Yield the processor to another thread.
		_syscall_yield();

		// Try to exit again after some other thread has run.
		status = _exit_thread( current );
	}
 
    // If the thread is a detached thread then it can be destroyed right
    // away. Joinable threads cannot be destroyed until they have been joined
    // by some other thread (see _syscall_join).
    if( destroy_flag ) 
    {
        _destroy_thread( current );

        TRACE_PRINTF( TRACE_FINE, TRACE_SYSCALL, "** DETACHED = 0x%8.8x **\n",destroy_flag);
    }

    // Print out a trace message about this system call
    TRACE_PRINTF( TRACE_FINE, TRACE_SYSCALL, "SYSCALL DONE: (OP=EXIT) (RET=0x%8.8x)\n", (Huint)retval );

	// We have now exited. Run the scheduler and never come back.
	_run_sched( Hfalse );
}
bootstrap::bootstrap(char* name) {
  file_name = name;
  _has_error = false;
  open_file();
  if (!has_error()) {
    //    initialize_tables(file_size > 0 ? (file_size / 32) : (10 * K));
    initialize_tables(64 * K);
    parse_file();
    close_file();
    Universe  ::cleanup_after_bootstrap();
  }
}
MemTrackWorker::MemTrackWorker(MemSnapshot* snapshot): _snapshot(snapshot) {
  // create thread uses cgc thread type for now. We should revisit
  // the option, or create new thread type.
  _has_error = !os::create_thread(this, os::cgc_thread);
  set_name("MemTrackWorker", 0);

  // initial generation circuit buffer
  if (!has_error()) {
    _head = _tail = 0;
    for(int index = 0; index < MAX_GENERATIONS; index ++) {
      ::new ((void*)&_gen[index]) GenerationData();
    }
  }
  NOT_PRODUCT(_sync_point_count = 0;)
bool ElfDecoder::decode(address addr, char *buf, int buflen, int* offset, const char* filepath) {
  assert(filepath, "null file path");
  assert(buf != NULL && buflen > 0, "Invalid buffer");
  if (has_error()) return false;
  ElfFile* file = get_elf_file(filepath);
  if (file == NULL) {
    return false;
  }

  if (!file->decode(addr, buf, buflen, offset)) {
    return false;
  }
  if (buf[0] != '\0') {
    demangle(buf, buf, buflen);
  }
  return true;
}
 bool process(int thid) {
   //std::cout << "thread::" << thid << "\n";
   sequence_parser::job job(_parser);
   if (job.is_empty()) return false;
   for (size_t i=0; i<job->nb_filled; ++i) {
       const std::string& header = job->data[i].header;
       const std::string& seq    = job->data[i].seq;
       const std::string& qual   = job->data[i].qual;
       
     if (seq.size() != qual.size()) {
       std::cerr << "Error: Insufficient quality information. Quiting...\n";
       exit(0);
     }
     if (!has_error(seq.c_str(), qual.c_str(), seq.size())) {
      // std::cout << "READ IS PERFECT" << "\n";
       _output << "@" << header << "\n" << seq << "\n";
       _output << "+" << header << "\n" << qual << "\n";
       _output << jflib::endr;
     } else {
       //std::cout << "READ IS ERRONEOUS" << "\n";
     }
   }
   return true;
 }
 bool read (int column, uint64_t &value)
 {
     bool readable = context && has_column (column) && !has_error ();
     if (readable) value = sqlite3_column_int64 (context, column);
     return readable;
 }
/** \internal
  * \brief  The system call which implements the hthread_create functionality.
  *
  * \author     Wesley Peck <*****@*****.**>
  *
  * This function is the system call routine which implements the 
  * hthread_create functionality for hthreads. The user space function
  * hthread_create invokes this function to create a new thread.
  *
  * \param  th      If the thread was created successfully then the new
  *                 thread will be stored in the location pointed to
  *                 by this argument.
  * \param  attr    The attributes to apply to the newly created thread.
  *                 See the documentation for hthread_attr_t for more on
  *                 the allowable attributes.
  * \param  start   A function pointer which is used as the beginning of
  *                 the new threads execution. If this function ever returns
  *                 then the new thread will be terminated.
  * \param  arg     An arbitrary pointer which is used as the first and
  *                 only argument to the start routine.
  * \return         The return value is one of the following:
  *                 - EAGAIN  : There was an error when attempting to create
  *                             the new thread. Trying the attempt again might
  *                             have a different result.
  *                 - ENOMEM  : Not enough memory is available to satisfy the
  *                             request. Attempting again after more memory
  *                             is free might have different results.
  *                 - EINVAL  : One of the parameters used when calling this
  *                             function is invalid.
  *                 - FAILURE : A generic failure occurred in the hardware
  *                             when attempting to setup the thread.
  *                 - SUCCESS : The thread was created successfully
  */
Hint _syscall_create(	hthread_t *th, hthread_attr_t *attr,
						hthread_start_t start, void *arg )
{
	Huint threadStatus;
	Huint threadID;
	Huint addStatus;
    Huint setupStatus;
    Huint schedStatus;
    
    // Print out a trace message about this system call
    TRACE_PRINTF( TRACE_FINE, TRACE_SYSCALL,
                  "SYSCALL: (OP=CREATE) (THR=0x%8.8x) (ATTR=0x%8.8x) (STRT=0x%8.8x) (ARG=0x%8.8x)\n",
                  (Huint)th, (Huint)attr, (Huint)start, (Huint)arg );

    // Ask the thread manager to create a new thread for us. If it
    // is successful then the thread id will be encoded into the return
    // value.
    if( attr->detached )    threadStatus = _create_detached();
	else                    threadStatus = _create_joinable();

    TRACE_PRINTF( TRACE_FINE, TRACE_SYSCALL, "SYSCALL: (OP=CREATE) (DET = 0x%8.8x)\n",(Huint)attr->detached );

    // Check if there was an error while creating the new thread. If
	// there was then it means that all of the available threads are
	// being used, so we return an error.
	if( has_error(threadStatus) )
    {
        TRACE_PRINTF( TRACE_DBG, TRACE_SYSCALL, "SYSCALL: (OP=CREATE) (STA=0x%8.8x) (ERR=CREATE)\n", threadStatus );
        return EAGAIN;
    }

	// If there was no error then we need to get the new thread's id
	// out of the return status.
	threadID = extract_id( threadStatus );
    TRACE_PRINTF( TRACE_DBG, TRACE_SYSCALL, "SYSCALL: (OP=CREATE) (TID=0x%8.8x)\n", threadID );
    
	// Initialize the software structures used to keep track of the thread.
	setupStatus = _setup_thread( threadID, attr, start, arg );
    if( setupStatus != SUCCESS )
    {
        TRACE_PRINTF( TRACE_DBG, TRACE_SYSCALL, "SYSCALL: (OP=CREATE) (STA=0x%8.8x) (ERR=SETUP)\n", setupStatus );
        return setupStatus;
    }

    // Set the scheduling parameter for the thread.
    if( attr->hardware != Htrue )
    {
        TRACE_PRINTF( TRACE_DBG, TRACE_SYSCALL, "SYSCALL: (OP=CREATE) (Software Thread Sched. Param = 0x%8.8x)\n",attr->sched_param);
        schedStatus = _set_schedparam( threadID, attr->sched_param );
    }
    else
    {
        TRACE_PRINTF( TRACE_DBG, TRACE_SYSCALL, "SYSCALL: (OP=CREATE) (Hardware Thread Sched. Param = 0x%8.8x)\n",attr->hardware_addr);
        schedStatus = _set_schedparam( threadID, attr->hardware_addr );
    }

    if( schedStatus != SUCCESS )
    {
        TRACE_PRINTF( TRACE_DBG, TRACE_SYSCALL, "SYSCALL: (OP=CREATE) (STA=0x%8.8x) (ERR=SCHED)\n", schedStatus );
        return schedStatus;
    }

    // Now that we have the new thread setup so that it can run we
    // can add the thread in the ready-to-run queue.
    addStatus = _add_thread( threadID );

	// Check if there was an error when adding the thread into the
	// ready-to-run queue. If there was then we need to clean up the
	// new thread and return an error condition.
	if( has_error(addStatus) )
	{
        TRACE_PRINTF( TRACE_DBG, TRACE_SYSCALL, "SYSCALL: (OP=CREATE) (STA=0x%8.8x) (ERR=ADD)\n", addStatus );

        addStatus = _read_sched_status(threadID);
        _decode_sched_status(addStatus);

		// Clean up the software structures used by the thread.
		_destroy_thread( threadID );

		// Remove the thread.
		_clear_thread( threadID );

		// Return an error condition.
		return EAGAIN;
	}

	// Return the thread ID to the caller. At this point the thread has
	// been successfully created and added to the queue so that we know
	// a valid thread ID will be returned to the user.
	*th = threadID;

    // Print out a trace message about this system call
    TRACE_PRINTF( TRACE_FINE, TRACE_SYSCALL, "SYSCALL DONE: (OP=CREATE) (THR=0x%8.8x) (ATTR=0x%8.8x) (STRT=0x%8.8x) (ARG=0x%8.8x)\n", (Huint)th, (Huint)attr, (Huint)start, (Huint)arg );

	// The thread was created and added to the ready-to-run queue
	// successfully. Return the success code.
	return SUCCESS;
}
Exemple #12
0
void WindowsDecoder::initialize() {
  if (!has_error() && _dbghelp_handle == NULL) {
    HMODULE handle = ::LoadLibrary("dbghelp.dll");
    if (!handle) {
      _decoder_status = helper_not_found;
      return;
    }

    _dbghelp_handle = handle;

    pfn_SymSetOptions _pfnSymSetOptions = (pfn_SymSetOptions)::GetProcAddress(handle, "SymSetOptions");
    pfn_SymInitialize _pfnSymInitialize = (pfn_SymInitialize)::GetProcAddress(handle, "SymInitialize");
    _pfnSymGetSymFromAddr64 = (pfn_SymGetSymFromAddr64)::GetProcAddress(handle, "SymGetSymFromAddr64");
    _pfnUndecorateSymbolName = (pfn_UndecorateSymbolName)::GetProcAddress(handle, "UnDecorateSymbolName");

    if (_pfnSymSetOptions == NULL || _pfnSymInitialize == NULL || _pfnSymGetSymFromAddr64 == NULL) {
      _pfnSymGetSymFromAddr64 = NULL;
      _pfnUndecorateSymbolName = NULL;
      ::FreeLibrary(handle);
      _dbghelp_handle = NULL;
      _decoder_status = helper_func_error;
      return;
    }

    HANDLE hProcess = ::GetCurrentProcess();
    _pfnSymSetOptions(SYMOPT_UNDNAME | SYMOPT_DEFERRED_LOADS | SYMOPT_EXACT_SYMBOLS);
    if (!_pfnSymInitialize(hProcess, NULL, TRUE)) {
      _pfnSymGetSymFromAddr64 = NULL;
      _pfnUndecorateSymbolName = NULL;
      ::FreeLibrary(handle);
      _dbghelp_handle = NULL;
      _decoder_status = helper_init_error;
      return;
    }

    // set pdb search paths
    pfn_SymSetSearchPath  _pfn_SymSetSearchPath =
      (pfn_SymSetSearchPath)::GetProcAddress(handle, "SymSetSearchPath");
    pfn_SymGetSearchPath  _pfn_SymGetSearchPath =
      (pfn_SymGetSearchPath)::GetProcAddress(handle, "SymGetSearchPath");
    if (_pfn_SymSetSearchPath != NULL && _pfn_SymGetSearchPath != NULL) {
      char paths[MAX_PATH];
      int  len = sizeof(paths);
      if (!_pfn_SymGetSearchPath(hProcess, paths, len)) {
        paths[0] = '\0';
      } else {
        // available spaces in path buffer
        len -= (int)strlen(paths);
      }

      char tmp_path[MAX_PATH];
      DWORD dwSize;
      HMODULE hJVM = ::GetModuleHandle("jvm.dll");
      tmp_path[0] = '\0';
      // append the path where jvm.dll is located
      if (hJVM != NULL && (dwSize = ::GetModuleFileName(hJVM, tmp_path, sizeof(tmp_path))) > 0) {
        while (dwSize > 0 && tmp_path[dwSize] != '\\') {
          dwSize --;
        }

        tmp_path[dwSize] = '\0';

        if (dwSize > 0 && len > (int)dwSize + 1) {
          strncat(paths, os::path_separator(), 1);
          strncat(paths, tmp_path, dwSize);
          len -= dwSize + 1;
        }
      }

      // append $JRE/bin. Arguments::get_java_home actually returns $JRE
      // path
      char *p = Arguments::get_java_home();
      assert(p != NULL, "empty java home");
      size_t java_home_len = strlen(p);
      if (len > (int)java_home_len + 5) {
        strncat(paths, os::path_separator(), 1);
        strncat(paths, p, java_home_len);
        strncat(paths, "\\bin", 4);
        len -= (int)(java_home_len + 5);
      }

      // append $JDK/bin path if it exists
      assert(java_home_len < MAX_PATH, "Invalid path length");
      // assume $JRE is under $JDK, construct $JDK/bin path and
      // see if it exists or not
      if (strncmp(&p[java_home_len - 3], "jre", 3) == 0) {
        strncpy(tmp_path, p, java_home_len - 3);
        tmp_path[java_home_len - 3] = '\0';
        strncat(tmp_path, "bin", 3);

        // if the directory exists
        DWORD dwAttrib = GetFileAttributes(tmp_path);
        if (dwAttrib != INVALID_FILE_ATTRIBUTES &&
            (dwAttrib & FILE_ATTRIBUTE_DIRECTORY)) {
          // tmp_path should have the same length as java_home_len, since we only
          // replaced 'jre' with 'bin'
          if (len > (int)java_home_len + 1) {
            strncat(paths, os::path_separator(), 1);
            strncat(paths, tmp_path, java_home_len);
          }
        }
      }

      _pfn_SymSetSearchPath(hProcess, paths);
    }

     // find out if jvm.dll contains private symbols, by decoding
     // current function and comparing the result
     address addr = (address)Decoder::demangle;
     char buf[MAX_PATH];
     if (decode(addr, buf, sizeof(buf), NULL)) {
       _can_decode_in_vm = !strcmp(buf, "Decoder::demangle");
     }
  }
}
/** \internal
  * \brief  The system call that implements the hthread_join functionality.
  *
  * \author     Wesley Peck <*****@*****.**>
  *
  * This function is the system call routine which implements the 
  * hthread_join functionality for hthreads. The user space function
  * hthread_join invokes this function to join to a thread.
  *
  * \param  th      The thread which the currently running thread will
  *                 join with. This thread must be a valid thread which
  *                 is in the joinable state and must not have another
  *                 thread waiting for its termination.
  * \param  retval  If this value is not NULL then the return value from
  *                 the thread th will be stored into the location pointed
  *                 to by retval.
  * \return         The return value is one of the following:
  *                 - EINVAL  : One of the parameters used to call this
  *                             function is invalid
  *                 - SUCCESS : The thread was joined successfully and is
  *                             now exited
  */
Hint _syscall_join( hthread_t th, void **retval )
{
	Huint exited;
	Huint status;
	
    // Print out a trace message about this system call
    TRACE_PRINTF( TRACE_FINE, TRACE_SYSCALL, "SYSCALL: (OP=JOIN) (THR=0x%8.8x) (RET=0x%8.8x)\n", (Huint)th, (Huint)retval );

	// Join the current thread with the given thread.
	status = _join_thread( th );

	// If there was an error trying to join the thread then we
	// will return that error to the caller.
	if( has_error(status) )
	{
		// If the thread that is being joined has already exited then we do
		// not need to wait on it so this statement will not be executed. If
		// the thread has not yet exited then we will release the proccessor
		// without adding ourself back onto the ready-to-run queue. The thread
		// we are joining will add us back to the queue once it has exited.
        exited = extract_error( status );
		if( exited != HT_ALREADY_EXITED )
        {
            DEBUG_PRINTF( "JOIN ERROR=0x%8.8x\n", exited );
            return EINVAL;
        }
	}		

    // If the thread has not already exited then block the currently
    // running thread until that thread has exited.
    exited = extract_error( status );
    if( exited != HT_ALREADY_EXITED )
    {
        _run_sched( Htrue );
    }
    
	// At this point the thread we are joining is guaranteed to have exited.
	// We should store the return value of the thread into the retval
	// variable. We then destroy and clear the thread so that some other
	// process can make used of the thread ID.
    if( retval != NULL )
    {
        // Commented out, as fast V-HWTI re-usage via smart dispatch will re-use a V-HWTI as soon as a thread is exited,
        // thus causing the return value to be overwritten.  The new HAL bootloop copies the return value to the threads.retval location
        // just as SW threads do, so hardware thread's return values can be retrieved from the same place (as they are now preserved)
        //if( threads[ th ].hardware != 0 )   *retval = (void**)_hwti_results( threads[th].hardware - HT_HWTI_COMMAND_OFFSET );

        if( threads[ th ].hardware != 0 )   *retval = threads[th].retval;
        else                                *retval = threads[th].retval;
    }

	// Deallocate the software side structures used to keep track of the
	// thread that was just joined.
    if( !_detached_thread( th ) )
    {
        _destroy_thread( th );
    }
    
    // Print out a trace message about this system call
    TRACE_PRINTF( TRACE_FINE, TRACE_SYSCALL, "SYSCALL DONE: (OP=JOIN) (THR=0x%8.8x) (RET=0x%8.8x)\n", (Huint)th, (Huint)retval );

	// Return successfully.
	return SUCCESS;
}
Exemple #14
0
bool WindowsDecoder::can_decode_C_frame_in_vm() const {
  return  (!has_error() && _can_decode_in_vm);
}
 bool read (int column, std::string &value)
 {
     bool readable = context && has_column (column) && !has_error ();
     if (readable) value = (const char *) sqlite3_column_text (context, column);
     return readable;
 }
 bool read (int column, double &value)
 {
     bool readable = context && has_column (column) && !has_error ();
     if (readable) value = sqlite3_column_double (context, column);
     return readable;
 }
Exemple #17
0
 bool operator!() const { return has_error(); }
Exemple #18
0
 explicit operator bool() const { return !has_error(); }