Example #1
0
 def _on_circuit_creation_failure(self, failure, circ):
   log_ex(failure, "circuit creation failed", [TorCtl.ErrorReply])
   #make sure it is no longer in our collections of circuits:
   if circ in self.circuits:
     self.circuits.remove(circ)
   if circ in self.liveCircuits:
     self.liveCircuits.remove(circ)
Example #2
0
def copy_file(fromFile, toFile):
  """Copy file, return success, print any errors"""
  try:
    shutil.copy(fromFile, toFile)
  except Exception, error:
    log_ex(error, "copy_file failed")
    return False
Example #3
0
 def success(self, data):
   """Called when all data has finished downloading.  Validates the the length of the data is proper given any relevant headers, and calls successCB or failure appropriately
   @param data:  the data downloaded from the HTTPDownloader (None if we were saving to a file)
   @type  data:  str or None"""
   if not self.requestDone:
     self.requestDone = True
     try:
       #validate that the file length is right if there were headers:
       if not self.fileName:
         data = self.file.getvalue()
         self.file.really_close()
         dataSize = len(data)
       else:
         dataSize = os.path.getsize(self.fileName)
       if self.protocolInstance.headers.has_key('content-length'):
         headerSize = int(self.protocolInstance.headers['content-length'][0])
         if not headerSize == dataSize:
           raise DownloadSizeError("Downloaded size was %s.  Header content-length size was %s." % (dataSize, headerSize))
     except Exception, e:
       self.failure(e)
     else:
       try:
         if not self.fileName:
           self.successCB(data, self)
         else:
           self.successCB(self.fileName, self)
       except Exception, e:
         log_ex(e, "HTTPClient failed during success callback.  url=%s" % (self.url))
Example #4
0
 def launch_failed(self, reason):
   log_ex(reason, "Failed to launch application:  %s" % (self.name), [DependencyError])
   GUIController.get().show_msgbox("Failed to launch %s:  %s" % (self.name, reason), title="Error", makeSafe=True)
   if self.startupDeferred:
     tempDeferred = self.startupDeferred
     self.startupDeferred = None
     tempDeferred.callback(False)
Example #5
0
 def _on_process_done(self, result):
   """Used as both a callback and errback for when the _wait thread finishes or fails"""
   self.done = True
   if type(result) == type(True):
     return result
   log_ex(result, "Failure in PseudoProcess")
   return False
Example #6
0
def file_exists(fileName):
  """@returns: a boolean of whether the file exists"""
  try:
    ret = os.path.exists(fileName)
    return ret
  except Exception, error:
    log_ex(error, "file_exists failed")
Example #7
0
 def error(self, failure):
   #ignore shutdown errors
   if ProgramState.DONE:
     return
   log_ex(failure, "Error while submitting logs via FTP")
   if self.cb:
     self.cb(False)
Example #8
0
 def error(failure):
   if not self.is_done():
     if Basic.exception_is_a(failure, [TorCtl.TorCtlClosed, TorCtl.ErrorReply]):
       log_msg("Failed to create PAR client, closing", 1, "circuit")
     else:
       log_ex(failure, "Unexpected failure while starting circuit")
     self.on_done()
Example #9
0
 def validate_php_output(response):
   """The script should return an integer.  Anything else indicates a failure."""
   try:
     response = int(response)
     return True
   except Exception, e:
     log_ex(e, "PHP account creation failed:  %s\n%s" % (response, args))
Example #10
0
def get_pid_from_port(port):
  """Figure out the process that has launched a connection from port.  Returns
  the pid, or 0 on failure"""
  port = int(port)
  try:
    #read in netstat -pant
    p = subprocess.Popen("netstat -pant 2>/dev/null | grep %s" % (port), shell=True, stdout=subprocess.PIPE)
    p.wait()
    data = p.stdout.read()
    if not data:
      return 0
    lines = data.split("\n")
    #pop the last line (it's empty)
    lines.pop()
    #for each of the program/port bindings:
    for line in lines:
      line = line.split()
      localAddr = line[3]
      remoteAddr = line[4]
      #dont bother with remote addresses
      if localAddr.rfind(":::") != -1 or remoteAddr.rfind(":::") != -1:
        continue
      localAddr = localAddr.split(":")
      remoteAddr = remoteAddr.split(":")
      #if these are the droids we're looking for:
      if localAddr[0] in ("0.0.0.0", "127.0.0.1") and remoteAddr[0] in ("0.0.0.0", "127.0.0.1") and int(localAddr[1]) == port:
        process = line[6].split("/")
        return process[0]
  except Exception, e:
    log_ex(e, "While doing linux portmapping")
Example #11
0
  def lineReceived(self, line):
    """Main subthread loop: Read commands from Tor, and handle them either
       as events or as responses to other commands.
    """
    try:
      isEvent = self.parse_line(line)
    except:
      self._err(sys.exc_info())
      return
    
    if isEvent == None:
      return

    reply = self._lines
    try:
      if isEvent:
        if self._handler is not None:
          self.handle_event(time.time(), reply)
      else:
        cb = self._callbackQueue.pop(0)
        cb(reply)
    except Exception, e:
      errorMsg = "Tor control callback failed"
      if isEvent:
        errorMsg = "Tor event handler failed"
      log_ex(e, errorMsg)
Example #12
0
 def _subprocess_finished(self, result, p):
   if result == True:
     self.remove_process(p)
     if len(self.processes) <= 0:
       self._all_subprocesses_done()
   elif result != False:
     log_ex(result, "Failed while waiting for subprocess")
Example #13
0
def get_all_processes():
  processList = []
  hProcessSnap = c_void_p(0)
  hProcessSnap = CreateToolhelp32Snapshot( TH32CS_SNAPPROCESS , 0 )
  try:
    pe32 = PROCESSENTRY32()
    pe32.dwSize = sizeof( PROCESSENTRY32 )
    ret = Process32First( hProcessSnap , pointer( pe32 ) )
    while ret :
      hProcess = OpenProcess( PROCESS_ALL_ACCESS , 0 , pe32.th32ProcessID )
      try:
        dwPriorityClass = GetPriorityClass( hProcess )
        if dwPriorityClass != 0 :
          hModuleSnap = c_void_p(0)
          me32 = MODULEENTRY32()
          me32.dwSize = sizeof( MODULEENTRY32 )
          exePath = ""
          hModuleSnap = CreateToolhelp32Snapshot( TH32CS_SNAPMODULE, pe32.th32ProcessID )
          try:
            ret = Module32First( hModuleSnap, pointer(me32) )
            if ret != 0 :
              exePath = me32.szExePath
          finally:
            CloseHandle( hModuleSnap )
          processList.append((pe32.th32ProcessID, exePath, pe32.th32ParentProcessID))
      finally:
        CloseHandle( hProcess )
      ret = Process32Next( hProcessSnap, pointer(pe32) )
  except Exception, e:
    log_ex(e, "Error while getting detailed process list")
Example #14
0
 def _on_response(self, dialog, responseId):
   """Let the base class handle the response.  Then destroy the dialog unless the base class says not to."""
   #let the base class handle the response:
   try:
     result = self.on_response(responseId)
   except Exception, error:
     log_ex(error, "Failure while handling response for '%s' dialog" % (self.title))
     return
Example #15
0
 def errReceived(self, data):
   """receives output from stderr"""
   self.transport.loseConnection()
   if self.errback:
     self.deferred.errback(data)
   else:
     log_ex('No errback attached to process to handle stderr%s' % (data), 0)
     
Example #16
0
def delete_file(fileName, silent=False):
  """Delete a file with the option of failing silently.  Be careful."""
  try:
    os.remove(fileName)
  except Exception, error:
    if not silent:
      log_ex(error, "delete_file failed")
    return False
Example #17
0
 def start(self):
   """Open the forwarded port."""
   self.reachableState = "UNKNOWN"
   self.upnpState = "UNKNOWN"
   try:
     self.start_upnp()
   except Exception, e:
     log_ex(e, "Failure while checking that port %s is properly forwarded" % (self.name))
Example #18
0
 def on_new_relay(self, r):
   try:
     assert isinstance(r.desc.nickname, basestring), "nickname must be a string"
     assert type(r.desc.idhex) == types.StringType, "idhex must be a string"
     for i in range(0,3):
       self.routerCombos[i].append_text(r.desc.nickname + "~" + r.desc.idhex)
   except Exception, e:
     log_ex(e, "Problem while updating routers in circuitlist")
Example #19
0
 def error(failure):
     # this happens occasionally when the circuit is closed at approximately the same time that we send a payment
     # it can be safely ignored because the circuit is closed and we already learned about it
     if "552 Cannot find circuit with id" in str(failure):
         log_msg("A circuit that we tried to send a payment message to was closed.  Oops.", 4)
         self.close()
         return
     # otherwise, log an error because this is unexpected
     log_ex(failure, "SENDPAYMENT failed for circuit=%s" % (nextCircId), [TorCtl.ErrorReply])
Example #20
0
 def err(self, err, optional=None):
   """returns an error msg"""
   log_ex(err, "Unhandled error from %s" % (self.transport.getPeer()))
   #DEBUG:  NOTE:  this is a security vulnerability otherwise
   if optional:
     rep = "%s\nerr: %s"%(optional, err)
   else:
     rep = "Error with login!"
   self.reply(rep)
Example #21
0
 def closed_event(self, tp, ex, tb):
   """Called when Tor control connection is closed"""
   ignoreList = [ConnectionDone]
   if self.torApp.is_stopping() or not self.torApp.is_running():
     ignoreList += [ConnectionLost]
   log_ex(ex, "Tor failure", ignoreList, reasonTraceback=tb, excType=tp)
   if self.torApp.isReady:
     log_msg("Tor Control port was closed!  reason:  %s" % (ex), 0)
     self.torApp.on_done()
Example #22
0
  def on_apply(self, app, category):
    try:
      self.set_start_on_boot(self.startBitBlinderOnBoot)
      self.set_half_open_conns(app, self.halfOpenConnections)
#      #TEMP:  re-enable this
#      self.apply_anon_mode()
    except Exception, e:
      log_ex(e, "Failed to apply settings:")
      return False
Example #23
0
 def close(self):
     for file, f in self.handles.items():
         try:
             self.unlock_file(file, f)
         except Exception, e:
             log_ex(e, "Failed to unlock")
         try:
             f.close()
         except Exception, e:
             log_ex(e, "Failed to close")
Example #24
0
 def init_priority(self, new_priority):
     try:
         assert len(new_priority) == self.numfiles
         for v in new_priority:
             assert type(v) in (type(0), type(0L))
             assert v >= -1
             assert v <= 2
     except Exception, e:
         log_ex(e, "Error when setting priority")
         return False
Example #25
0
 def exit(self):
   shutdownDeferred = defer.Deferred()
   try:
     #for every process that did not yet exit, kill it
     for processObj in self.processes:
       #TODO:  change to this once kill_recursive runs on linux:
       #kill_recursive(p.pid)
       System.kill_process(processObj.pid)
   except Exception, error:
     log_ex(error, "Failed to kill Application process:")
Example #26
0
 def _port_test_failure(reason):
     # is this one of the errors that corresponds to unreachability?
     if Basic.exception_is_a(reason, [CannotListenError, TimeoutError]):
         return False
     # otherwise, we do not know the state of reachability (None signals that)
     # and log the error if necessary
     unexpectedException = not Basic.exception_is_a(reason, [ConnectError])
     if unexpectedException:
         log_ex(reason, "Unexpected failure while testing port")
     return None
Example #27
0
 def start_upnp(self):
   """Start the attempt to forward the port.  This function is idempotent."""
   if not self.startedUPNP:
     self.startedUPNP = True
     #try to set the new ports for Tor:
     try:
       #try forwarding the new port from the router:
       self._upnp_request()
     except Exception, error:
       log_ex(error, "Failed to start UPNP")
Example #28
0
 def _listener(self):
   """listens for keystrokes from the user and puts them in the Queue"""
   self.stdscr.timeout(500)
   while self.shouldListen:
     k = self.stdscr.getch()
     if k == -1:
       continue
     try:
       self.q.put(k)
     except Exception, e:
       log_ex(e, 'Couldn\'t shove in queue')
Example #29
0
 def _trigger_event(self, eventName, *args, **kwargs):
     """deal with an event--call all handlers"""
     assert eventName in self._knownEventNames, "Tried to trigger an unknown event (%s)" % (eventName)
     if eventName not in self._eventListenerMapping:
         return
     handlers = self._eventListenerMapping[eventName]
     for handler in handlers:
         try:
             handler(self, *args, **kwargs)
         except Exception, error:
             log_ex(error, "Failure while handling event %s on %s" % (eventName, self))
Example #30
0
def throw_event(eventName, *args, **kwargs):
  """Custom event handling.  Inform all interested listeners about the event.
  @param eventName:  the event that just occurred
  @type  eventName:  str"""
  if GLOBAL_EVENT_LISTENERS.has_key(eventName):
    for x in GLOBAL_EVENT_LISTENERS[eventName]:
      try:
        func = getattr(x, "on_" + eventName)
        if func:
          func(*args, **kwargs)
      except Exception, e:
        log_ex(e, "%s failed while handling %s event" % (x, eventName))
Example #31
0
 def handle_twisted_err(_stuff=None, _why=None, quitFunc=quitFunc, **kw):
     excType = None
     tb = None
     #get the exception from the system if necessary
     if not _stuff or issubclass(type(_stuff), Exception):
         (excType, _stuff, tb) = sys.exc_info()
     #check if this is a shutdown signal
     if quitFunc and _stuff and issubclass(type(_stuff), KeyboardInterrupt):
         log_msg("Shutting down from keyboard interrupt...", 0)
         quitFunc()
         return
     #otherwise, log the exception
     if excType and tb:
         log_ex(_stuff,
                "Unhandled exception from Twisted:",
                reasonTraceback=tb,
                excType=excType)
     else:
         log_ex(_stuff, "Unhandled failure from Twisted:")
Example #32
0
 def read_routers(self, nslist):
     """ Given a list a NetworkStatuses in 'nslist', this function will 
     return a list of new Router instances.
 """
     bad_key = 0
     new = []
     for ns in nslist:
         try:
             r = self.get_router(ns)
             new.append(r)
         except ErrorReply:
             bad_key += 1
             if "Running" in ns.flags:
                 plog(
                     "NOTICE", "Running router " + ns.nickname + "=" +
                     ns.idhex + " has no descriptor")
         except Exception, e:
             log_ex(e, "Unexpected error while loading routers")
             continue
Example #33
0
 def update_coins(self):
     """Check that we have enough ACoins locally, but not too many, and none that are about to expire"""
     try:
         self.check_wallet_balance()
         #should we consider sending a deposit message?
         if not self.acoinDepositInProgress:
             coins = []
             curTime = time.time()
             #we must retry depositing any existing coins that are in progress:
             if len(self.depositingACoins) > 0:
                 coins += self.depositingACoins
             #are any stale?
             if curTime > self.beginDepositACoinTime:
                 if self.ACoins.has_key(
                         self.currentACoinInterval - 1) and len(
                             self.ACoins[self.currentACoinInterval - 1]):
                     newCoins = []
                     for coin in self.ACoins[self.currentACoinInterval - 1]:
                         newCoins.append(coin)
                         if len(newCoins) >= ACOIN_BATCH_SIZE:
                             break
                     for coin in newCoins:
                         self.remove_coin(coin)
                     coins += list(newCoins)
                     if len(coins) > 0:
                         #make sure we have enough coins:
                         self.check_wallet_balance()
             #do we have too many?
             numCoins = (self.get_wallet_balance() - ACOIN_HIGH_LEVEL)
             if numCoins > 0:
                 coins += self.get_acoins(ACOIN_BATCH_SIZE, False)
             #if we have coins to deposit, or we need to learn about the next interval
             if coins or curTime > self.curIntervalExpiration + self.intervalLearningDelay:
                 self.acoinDepositInProgress = True
                 self.deposit_acoins(coins)
     except Exception, e:
         log_ex(
             e,
             "Too many ACoins, but failed when trying to send to the bank")
Example #34
0
 def on_new_stream(self, event):
     #will automatically register itself with it's application
     stream = Stream.Stream(event)
     #figure out who should handle the stream next:
     if stream.isInternal and Stream.OBSERVE_INTERNAL:
         stream.app = self.torApp
         stream.app.on_new_stream(stream)
     else:
         try:
             #first check if this was launched internally, directly through Tor:
             #TODO:  this is a little weird, multiple failure conditions:
             if self.waiting_for_stream(stream):
                 self.handle_stream_creation(stream)
                 return
             port = int(event.source_addr.split(":")[1])
             #need to figure out the original application that started this:
             assert port, "port must be defined to map a Stream to an Application"
             pid = System.get_pid_from_port(port)
             assert pid != 0, "pid must be non-zero in order to map from a Stream to Application"
             originalApp = self.get_app_by_pid(pid)
             originalApp.on_new_stream(stream, None)
         except Exception, e:
             log_ex(e, "No app for stream=%d?" % (stream.id))
Example #35
0
 def _start_connection_from_queue(self):
     try:
         if not self.paused:
             numOpened = 0
             #connect to peers that we have never connected to before
             while len(self.never_connected) > 0:
                 if self._should_connect_to_new_peer(numOpened):
                     peer = self.never_connected.pop(0)
                     dns, id, encrypted = peer
                     self.start_connection(dns, id, encrypted)
                     self.prev_connected.append(peer)
                     numOpened += 1
                 else:
                     break
             #connect to peers that have had succesful connections previously
             while len(self.to_connect) > 0:
                 if self._should_connect_to_new_peer(numOpened):
                     dns, id, encrypted = self.to_connect.pop(0)
                     self.start_connection(dns, id, encrypted)
                     numOpened += 1
                 else:
                     break
         #reduce the prev_connected array to 300 in the event it gets larger
         if len(self.prev_connected) >= 300:
             del self.prev_connected[:len(self.prev_connected) - 300]
         #TODO:  kinda stupid that we just keep cycling through the last list of peers, but we need some list of them so that we can retry when circuits go down
         #Better ideas include a global cache of peers obtained from PX, DHT, etc, or even a cache incorporating time last seen for peers from trackers
         if len(self.to_connect) <= 0:
             #dont repeatedly try the same peers more than once every RETRY_INTERVAL
             curTime = time.time()
             if curTime > self.lastPeerCycleTime + self.PEER_RETRY_INTERVAL:
                 self.lastPeerCycleTime = curTime
                 log_msg("Cycling through the list of peers again...", 2,
                         "btconn")
                 self.to_connect = copy.copy(self.prev_connected)
     except Exception, e:
         log_ex(e, "Failed while starting BT connections")
Example #36
0
def test_network_state():
    try:
        #test network basics--are we firewalled, is dns working, are the test servers reachable?
        testServerDeferred = test_test_servers()
        test_dns()

        #then do the tests that require the test servers:

        #test outgoing ports
        d = test_outgoing_port(80)

        def is_port_80_reachable(isReachable):
            global _isPort80Reachable
            _isPort80Reachable = isReachable
            return isReachable

        d.addCallback(is_port_80_reachable)

        d = test_outgoing_port(443)

        def is_port_443_reachable(isReachable):
            global _isPort443Reachable
            _isPort443Reachable = isReachable
            return isReachable

        d.addCallback(is_port_443_reachable)

        test_random_outgoing_port()

        #test incoming connections
        test_udp()

        #what kind of speeds have we seen over this network?  upload vs download?
        #what interface should we be binding?
    except Exception, e:
        log_ex(e, "Error while testing network state")
Example #37
0
 def failure(self, failure):
     """Called when a download fails for any reason
 @param failure:  the reason that the download failed
 @type  failure:  Exception, Failure, or str"""
     if not self.requestDone:
         try:
             self.requestDone = True
             #ensure that the network connection is closed (so it doesnt keep writing to our buffer)
             if self.protocolInstance and self.protocolInstance.transport:
                 self.protocolInstance.transport.loseConnection()
             #and close our buffer:
             if not self.fileName:
                 self.file.really_close()
             #call the registered failure handler
             if self.failureCB:
                 self.failureCB(failure, self)
             #and if there is not one, log the error by default
             else:
                 log_ex(failure, "HTTPClient failed.  url=%s" % (self.url))
         except Exception, e:
             log_ex(
                 e, "HTTPClient failed during failure callback.  url=%s" %
                 (self.url))
         finally:
Example #38
0
    def _remove_upnp(self):
        """Actually call the outside program to remove the UPNP binding.  Returns a
    deferred that will be triggered when the port binding has finished (either
    successfully or unsuccessfully)"""

        #failures just get printed out, because we cant really do anything about them
        def handle_failure(failure):
            log_msg(
                "Failed to remove UPNP mapping on shutdown:  %s" % (failure),
                1)

        try:
            #figure out our local IP address
            localIP = Twisted.get_lan_ip()
            #launch the program
            output = self._start_upnp_exe(
                ("-m", localIP, "-d", str(self.port), self.trafficType))
            #handle results
            output.addCallback(self._upnp_removed)
            output.addErrback(handle_failure)
            return output
        except Exception, error:
            log_ex(error, "Failed send request to remove UPNP")
            handle_failure("Never even sent the request  :(")
Example #39
0
 def handle_exception(excType, value, tb):
     log_ex(value,
            "Unhandled exception in main loop:",
            reasonTraceback=tb,
            excType=excType)
Example #40
0
 def request_failed(self, error, httpDownloadInstance=None):
   self.downloadingUpdate = False
   log_ex(error, "Error while downloading update", [DownloadSizeError])
   #lets try the full installer instead then
   Scheduler.schedule_once(30 * 60, self.check_for_updates)
Example #41
0
 def error_handler(failure):
     """Log an error if the script did not finish cleanly."""
     log_ex(failure, "PHP script had an error:")
Example #42
0
 def failure(reason):
     log_ex(reason, "Failed while checking Tor bootstrap progress",
            [TorCtl.TorCtlClosed])
Example #43
0
 def failure(error):
     log_ex(
         error, "Stream (%s) failed to attach to Circuit (%s)" %
         (stream.id, self.id), [TorCtl.ErrorReply])
     stream.ignoreCircuits.add(self)
Example #44
0
 def failure_cb(reason):
     log_ex(reason,
            "External connection failed to connect to SOCKS proxy")
Example #45
0
 def generic_error_handler(self, error):
     log_ex(error, "Something bad happened", [InsufficientACoins])
Example #46
0
 def error(failure):
     log_ex(failure, "Failed to add tokens for circuit=%s" % (circId),
            [TorCtl.ErrorReply])
Example #47
0
 def failure(error):
     if self.app.is_ready() or self.app.is_starting():
         log_ex(error, "Stream (%d) failed to close" % (self.id),
                [TorCtl.ErrorReply])
Example #48
0
 def hash_failed(self, error):
   self.downloadingUpdate = False
   log_ex(error, "Error while verifying update")
   #lets just try again in half an hour or something
   Scheduler.schedule_once(30 * 60, self.check_for_updates)
Example #49
0
 def update():
     if ProgramState.DO_UPDATES:
         try:
             obj.on_update()
         except Exception, error:
             log_ex(error, "During update for %s" % (obj))
Example #50
0
 def _startup_failure(self, reason):
     self.startupDeferred = None
     log_ex(reason, "BitBlinder failed to start up!")
     return reason
Example #51
0
 def error(failure):
     log_ex(failure, "Circuit (%d) failed to close" % (self.id),
            [TorCtl.ErrorReply])
Example #52
0
 def uac_done(result):
     self.startOnBootDeferred = None
     if result != True:
         log_ex(
             result,
             "Bad result while running BitBlinderSettingsUpdate.exe")
Example #53
0
 def _handle_error(self, reason):
     """Log the error, and reply with UKNOWN_ERROR.
 Note that this is obviously only for unexpected errors.  Other errors should have their own error codes."""
     log_ex(reason, "Unhandled error during account creation")
     self._reply(RESPONSE_CODES["UNKNOWN_ERROR"])
Example #54
0
def read_args():
    #Create the options parser, this will be used throughout the program's execution
    Globals.PARSER = optparse.OptionParser()
    #Some options that are initially important:
    Globals.PARSER.add_option("--WAIT_FOR_PROCESS",
                              type="int",
                              dest="WAIT_FOR_PROCESS",
                              help="Dont use this",
                              metavar="FILE")
    Globals.PARSER.add_option("--FINISHED_UPDATE",
                              action="store_true",
                              dest="FINISHED_UPDATE",
                              default=False)
    Globals.PARSER.add_option("--use-existing-tor",
                              action="store_true",
                              dest="USE_EXISTING_TOR",
                              default=False)
    Globals.PARSER.add_option("-m",
                              "--minimize",
                              action="store_true",
                              dest="minimize",
                              default=False)
    Globals.PARSER.add_option("--curses",
                              action="store_true",
                              dest="useCurses",
                              default=False)
    Globals.PARSER.add_option("--no-gui",
                              action="store_true",
                              dest="no_gui",
                              default=False)
    Globals.PARSER.add_option("--allow-multiple",
                              action="store_true",
                              dest="allow_multiple",
                              default=False)
    Globals.PARSER.add_option("--dev-network",
                              action="store_true",
                              dest="dev_network",
                              default=False)
    Globals.PARSER.add_option("--debug",
                              action="store_true",
                              dest="debug",
                              default=False)
    #BitTorrent:
    Globals.PARSER.add_option("-t",
                              "--torrent",
                              dest="torrent",
                              help="Download a torrent file",
                              metavar="FILE")
    #for telling us which program to launch:
    Globals.PARSER.add_option("--launch-bt",
                              action="store_true",
                              dest="launch_bt",
                              default=False)
    Globals.PARSER.add_option("--launch-bb",
                              action="store_true",
                              dest="launch_bb",
                              default=False)
    Globals.PARSER.add_option("--launch-ff",
                              action="store_true",
                              dest="launch_ff",
                              default=False)
    #actually parse the options:
    (options, args) = Globals.PARSER.parse_args()

    #make sure that SOMETHING is supposed to start up:
    if not options.launch_bb and not options.launch_bt and not options.launch_ff:
        sys.argv.append('--launch-bb')
        options.launch_bb = True

    #NOTE:  weirdness:  the WAIT_FOR_PROCESS option is ONLY here for convenience.
    #It takes a process id as an argument.  All it does is wait for the process
    #with that pid and then exit.  This is called by the updater batch file,
    #because we need to wait for the previous InnomiNet instance to exit before
    #updating.  Because we use py2exe, I didnt want to make a separate script for that
    if options.WAIT_FOR_PROCESS:
        try:
            pid = options.WAIT_FOR_PROCESS
            log_msg(
                "Waiting on previous program (%s) to finish shutting down..." %
                (pid), 2)
            System.wait_for_pid(pid)
            log_msg("Finished waiting", 2)
        except Exception, error:
            log_ex(error, "WAIT_FOR_PROCESS failed")
        finally:
Example #55
0
def cleanup_previous_update(options):
    #This option is defined to indicate that we just ran the updater script.  We set
    #the appropriate global, and just try to delete the update exe
    ignoreUpdater = False
    if os.path.exists(Globals.UPDATE_FILE_NAME):
        #kill any leftover updater processes
        try:
            startTime = time.time()
            while True:
                updaterProcs = System.get_process_ids_by_exe_path(
                    re.compile(
                        "^%s$" %
                        (Globals.UPDATE_FILE_NAME.replace("\\", "\\\\")),
                        re.IGNORECASE))
                if len(updaterProcs) <= 0:
                    break
                for pid in updaterProcs:
                    log_msg("Waiting for updater (%s) to shut down..." % (pid),
                            1)
                    System.kill_process(pid)
                if time.time() > startTime + 10.0:
                    raise Exception(
                        "Waited 15 seconds and updater still had not shut down"
                    )
                else:
                    time.sleep(1.0)
        except Exception, error:
            log_ex(error, "Failed while waiting for updater to finish")
            message = "The BitBlinderUpdate.exe is still running.  You must wait for it to finish or forcefully close it before you can run BitBlinder again.  Maybe try running BitBlinder as Administrator just once?"
            die(message, "Error", EXIT_CODES.BITBLINDER_ALREADY_RUNNING)
        #if this is the first run after an update:
        if options.FINISHED_UPDATE:
            #ok, NOW try moving the updater file
            startTime = time.time()
            while True:
                try:
                    if os.path.exists(Globals.UPDATE_FILE_NAME):
                        shutil.move(Globals.UPDATE_FILE_NAME,
                                    Globals.UPDATE_FILE_NAME + ".prev")
                    break
                except Exception, error:
                    time.sleep(0.5)
                    if time.time() > startTime + 5.0:
                        log_ex(
                            error,
                            "Failed to remove update .exe from the previous update"
                        )
                        ignoreUpdater = True
                        #ok, lets try making a file, just so I can see why this is failing for people:
                        if issubclass(type(error), WindowsError):
                            try:
                                testFile = open(
                                    Globals.UPDATE_FILE_NAME + ".test", "wb")
                                testFile.write("hello?")
                                testFile.close()
                            except Exception, error:
                                log_ex(error, "And we could NOT write a file")
                            else:
                                log_msg(
                                    "But we successfully wrote to a file (%s)  Weird."
                                    % (Globals.UPDATE_FILE_NAME + ".test"))
                        break
Example #56
0
    def handle_payment(self, msg):
        """Unpack, process, and respond to a payment message.
    @param msg:  the payment message from the origin.
    @type  msg:  str"""
        #if there are any failures, log them, and close the circuit:
        try:
            #read the PAR protocol version:
            version, msg = Basic.read_byte(msg)
            assert version == 1, "currently only accept PAR version 1"
            readTokens, msg = Basic.read_int(msg)
            writeTokens, msg = Basic.read_int(msg)
            #read their request ID too
            theirId, msg = Basic.read_long(msg)
            #read the number of coins:
            numCoins, msg = Basic.read_byte(msg)
            #read each coin:
            creditsEarned = 0
            requests = []
            for i in range(0, numCoins):
                #what type of coin is this?
                coinType, msg = Basic.read_byte(msg)
                #we only accept acoins for now:
                assert coinType == PaymentStream.COIN_TYPES[
                    'A'], "bad coin type"
                #get the matching request:
                requestId, msg = Basic.read_long(msg)
                requests.append(requestId)
            assert len(msg) % numCoins == 0, "bad payment message length"
            coinLen = len(msg) / numCoins
            for requestId in requests:
                #if this is not true, there wont even be another part to the response
                assert Basic.read_byte(msg)[0] == ord(
                    '0'), "bad leading byte in payment message"
                blob, msg = msg[:coinLen], msg[coinLen:]
                request = self.requests[requestId]
                del self.requests[requestId]
                code, sig = Basic.read_byte(blob)
                #validate the ACoin
                coin = BankMessages.parse_acoin_response(
                    self.bank, sig, request)
                if not coin:
                    raise Exception("Invalid ACoin sent for payment!")
                #success!
                creditsEarned += coin.get_expected_value()
                coin.originCircuit = self
                self.bank.on_earned_coin(coin)
            receiptMessageDeferred = self.send_receipt_message(
                theirId, numCoins)
            if not receiptMessageDeferred:
                return
            #check that they paid enough:
            requestedTokens = readTokens + writeTokens
            paidTokens = creditsEarned * Globals.CELLS_PER_PAYMENT
            if paidTokens < requestedTokens:
                raise Exception("Relays asked for %s, but only paid for %s" %
                                (requestedTokens, paidTokens))
            #inform Tor that we got a payment message:
            addTokensDeferred = self.add_tokens(readTokens, writeTokens)
            if not addTokensDeferred:
                return

            def response(result):
                if result:
                    read, write = result
                    log_msg(
                        "%s paid us %s for exit stream, now %d / %d" %
                        (Basic.clean(self.baseCircuit.prevHexId[:4]),
                         creditsEarned, read, write), 3, "par")

            addTokensDeferred.addCallback(response)
        except Exception, error:
            log_ex(error, "Got bad PAR message")
            self.close()
Example #57
0
                self.btApp.force_stop()
            System.SHUTDOWN = True
            shutdownDeferred = BitBlinder.stop()
            shutdownDeferred.addCallback(self._shutdown)
            shutdownDeferred.addErrback(self._shutdown)

    def _shutdown(self, result):
        """Stop the main loop and cause the program to exit.
    This should ONLY be called after all Applications are shut down cleanly."""
        Basic.validate_result(result, "MainLoop::_shutdown")
        #close the server that listens for new versions of the app to start up:
        StartupServer.stop()
        #remove scheduled events:
        if self.updateEvent and self.updateEvent.active():
            self.updateEvent.cancel()
        ProgramState.DO_UPDATES = False
        self.updateEvent = None
        GlobalEvents.throw_event("shutdown")
        log_msg("Done with shutdown deferreds", 4)
        #close the main loop
        if ProgramState.USE_GTK:
            try:
                gtk.main_quit()
            except Exception, error:
                log_ex(error, "Couldn't kill the gtk main loop")
        else:
            try:
                Globals.reactor.stop()
            except Exception, error:
                log_ex(error, "Couldn't stop the reactor")
Example #58
0
 def on_upnp_done(self):
   try:
     self.start_test()
   except Exception, e:
     log_ex(e, "Error while starting test for port %s" % (self.name))
Example #59
0
 def stop_failure(self, reason):
     log_ex(reason, "%s failed to stop cleanly" % (self.name))
     self.stop_done()
Example #60
0
 def on_failure(failure, instance, failure_cb=failure_cb):
   log_ex(failure, "Failed while downloading current version document", [ConnectionDone])
   if failure_cb:
     failure_cb(failure, instance)