def timer_cb (self):
self.__sock = socket.socket ( socket.AF_INET, \
socket.SOCK_STREAM)
while not self.__connected:
try:
self.__sock.connect((self.__host, self.__port))
except:
if self.__torStatus != 'Stopped':
self.__torStatus = 'Stopped'
self.notifyObservers ( \
Notification('TorStatusChanged',\
'Stopped'))
self.__resetCounters ()
return True
else:
tc.authenticate (self.__sock)
self.__connected = True
self.__torStatus = 'Started'
self.__timeStarted = datetime.now ()
self.__torVersion = tc.get_info \
(self.__sock, 'version')['version']
self.notifyObservers (Notification \
('TorStatusChanged', 'Started'))
tc.set_events(self.__sock, self.__events)
self.__iocb = io_add_watch (self.__sock, \
IO_IN, \
self.input_cb)
return False
def input_cb (self, sock, cond):
try:
_, type, body = tc.receive_message (sock)
except:
self.__connected = False
self.__resetCounters ()
self.__sock.close()
self.__sock = socket.socket (socket.AF_INET,
socket.SOCK_STREAM)
self.__poll = timeout_add (self.__pollInterval, \
self.timer_cb)
return False
else:
event = tc.unpack_event (body)
eventType = tc.EVENT_TYPE.nameOf[event[0]]
eventData = event[1]
#Handle events and forward notifications to observers
#TODO: monitor circuits and streams
#TODO: (EVENT_TYPE.{CIRCUITSTATUS,STREAMSTATUS})
if event[0] == tc.EVENT_TYPE.BANDWIDTH:
self.__bytesRecv += eventData[0]
self.__bytesSent += eventData[1]
elif event[0] > tc.EVENT_TYPE.NEWDESC:
eventType = "LOG_MESSAGE"
if event[0] == tc.EVENT_TYPE.WARN_MSG:
self.__warningsCount += 1
elif event[0] == tc.EVENT_TYPE.ERR_MSG:
self.__errorsCounts += 1
elif event[0] == tc.EVENT_TYPE.ORCONNSTATUS:
status = eventData[0]
nick = eventData[1]
if status == tc.OR_CONN_STATUS.LAUNCHED:
self.__orConnectionsCount['Launched'] += 1
self.__orConnections[nick] = 'Launched'
elif status == tc.OR_CONN_STATUS.CONNECTED:
if self.__orConnections.has_key (nick):
self.__orConnectionsCount['Launched'] -= 1
self.__orConnectionsCount['Connected'] += 1
self.__orConnections[nick] = 'Connected'
elif status == tc.OR_CONN_STATUS.FAILED:
self.__orConnectionsCount['Failures'] += 1
if self.__orConnections.has_key(nick):
status = self.__orConnections[nick]
self.__orConnectionsCount[status] -= 1
del self.__orConnections[nick]
elif status == tc.OR_CONN_STATUS.CLOSED:
if self.__orConnections.has_key(nick):
self.__orConnectionsCount['Connected'] -= 1
del self.__orConnections[nick]
self.notifyObservers (Notification (eventType, eventData))
return True
def runControl(s):
pendingEvents = [] #XXX This tric. should become standard
TorControl._event_handler = pendingEvents.append
TorControl.set_events(s,
[TorControl.EVENT_TYPE.CIRCSTATUS,
TorControl.EVENT_TYPE.STREAMSTATUS])
TorControl.set_option(s,"__LeaveStreamsUnattached 1")
while 1:
e = pendingEvents[:]
del pendingEvents[:]
for ev in e:
handleEvent(s, ev)
_, tp, body = TorControl.receive_message(s)
if tp == TorControl.MSG_TYPE.EVENT:
handleEvent(s, body)
def launchCirc(s):
htw = HOSTS_THAT_WORK[:]
random.shuffle(htw)
path = htw[:CIRC_LEN-2] + \
[random.choice(HOSTS_TO_TEST)] + \
[random.choice(EXITS_THAT_WORK)]
circid = TorControl.extend_circuit(s, 0, path)
for name in path:
lst = HOST_STATUS.setdefault(name, [0, 0])
lst[0] += 1
return circid, path
def runControl(s):
circs = {}
s1, s2 = {}, {}
_h = lambda body, circs=circs, s1=s1, s2=s2, s=s: handleEvent(
s, body, circs, s1, s2)
TorControl._event_handler = _h
TorControl.set_events(
s,
[TorControl.EVENT_TYPE.CIRCSTATUS, TorControl.EVENT_TYPE.STREAMSTATUS])
TorControl.set_option(s, "__LeaveStreamsUnattached 1")
global N_CIRCS_DONE
while N_CIRCS_DONE < N_CIRCS_TO_TRY:
while len(circs) < CIRCS_AT_A_TIME:
c, p = launchCirc(s)
print "launching circuit %s to %s" % (c, p)
circs[c] = p
_, tp, body = TorControl.receive_message(s)
if tp == TorControl.MSG_TYPE.EVENT:
handleEvent(s, body, circs, s1, s2)
i = HOST_STATUS.items()
i.sort()
for n, (all, good) in i:
print "%s in %s circuits; %s/%s ok" % (n, all, good, all)
def handleEvent(s, body, circs, streamsByNonce, streamsByIdent):
global N_CIRCS_DONE
event, args = TorControl.unpack_event(body)
if event == TorControl.EVENT_TYPE.STREAMSTATUS:
status, ident, target = args
print "Got stream event:",TorControl.STREAM_STATUS.nameOf[status],\
ident,target
if status in (TorControl.STREAM_STATUS.NEW_CONNECT,
TorControl.STREAM_STATUS.NEW_RESOLVE,
TorControl.STREAM_STATUS.DETACHED):
target, port = target.split(":")
if not target.endswith(".exnonce"):
TorControl.attach_stream(s, ident, 0)
else:
circid, (host, url) = streamsByNonce[target]
streamsByIdent[ident] = circid, (host, url)
print "Redirecting circuit", circid, "to", host
TorControl.redirect_stream(s, ident, host)
TorControl.attach_stream(s, ident, circid)
elif status in (TorControl.STREAM_STATUS.CLOSED,
TorControl.STREAM_STATUS.FAILED):
circid, (host, url) = streamsByIdent[ident]
if circs.has_key(circid):
for name in circs[circid]:
HOST_STATUS[name][1] += 1
del circs[circid]
N_CIRCS_DONE += 1
print N_CIRCS_DONE, "circuit attempts done"
del streamsByIdent[ident]
elif event == TorControl.EVENT_TYPE.CIRCSTATUS:
status, ident, path = args
print "Got circuit event",TorControl.CIRC_STATUS.nameOf[status],\
ident,path
if status in (TorControl.CIRC_STATUS.CLOSED,
TorControl.CIRC_STATUS.FAILED):
if circs.has_key(ident):
print "Circuit failed."
del circs[ident]
N_CIRCS_DONE += 1
print N_CIRCS_DONE, "circuit attempts done"
elif status == TorControl.CIRC_STATUS.BUILT:
nonce = random.randint(1, 100000000)
nonce = "%s.exnonce" % nonce
host, url = random.choice(TARGETS)
streamsByNonce[nonce] = ident, (host, url)
print "Launching socks4a connection"
t = threading.Thread(target=runSocks4A,
args=(nonce, host, 80, url))
t.setDaemon(1)
t.start()
def run():
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
s.connect(("127.0.0.1", CONTROL_PORT))
TorControl.authenticate(s)
runControl(s)
def handleEvent(s,body):
event, args = TorControl.unpack_event(body)
if event == TorControl.EVENT_TYPE.STREAMSTATUS:
status, ident, target = args
print "Got stream event:",TorControl.STREAM_STATUS.nameOf[status],\
ident,target
if status in (TorControl.STREAM_STATUS.NEW_CONNECT,
TorControl.STREAM_STATUS.NEW_RESOLVE):
target,port=target.split(":")
if not target.endswith(".path"):
TorControl.attach_stream(s, ident, 0)
else:
path,host = parsePath(target)
#XXXX Don't launch so many circuits!
streams[ident] = path,host
circid = TorControl.extend_circuit(s, 0, path)
circuits[circid] = path
elif status == TorControl.STREAM_STATUS.DETACHED:
if not streams.has_key(ident):
TorControl.attach_stream(s, ident, 0)
else:
TorControl.close_stream(s, ident, 1)
elif event == TorControl.EVENT_TYPE.CIRCSTATUS:
status, ident, path = args
print "Got circuit event",TorControl.CIRC_STATUS.nameOf[status],\
ident,path
if not circuits.has_key(ident):
return
if status in (TorControl.CIRC_STATUS.CLOSED,
TorControl.CIRC_STATUS.FAILED):
ok = 0
elif status == TorControl.CIRC_STATUS.BUILT:
ok = 1
else:
return
ids = [ streamID for (streamID, (path,host)) in streams.items()
if path == circuits[ident] ]
for streamID in ids:
if ok:
_,host = streams[streamID]
TorControl.redirect_stream(s, streamID, host)
TorControl.attach_stream(s, streamID, ident)
#XXXX Don't do this twice.
else:
TorControl.close_stream(s, streamID, 1)
if not ok:
del circuits[ident]
