def main(self):
brokenClient = False
self.handleConnect()
self.gettingdata = False
self.client_connected = True
self.breakConnection = False
while (not self.gettingdata) and (not self.breakConnection):
yield WaitComplete(self.getline(), tag="_getline1")
try:
command = self.line.split()
except AttributeError:
brokenClient = True
break
self.handleCommand(command)
if not brokenClient:
if (not self.breakConnection):
EndOfMessage = False
self.netPrint('354 Enter message, ending with "." on a line by itself')
while not EndOfMessage:
yield WaitComplete(self.getline(), tag="getline2")
if self.lastline():
EndOfMessage = True
self.netPrint("250 OK id-deferred")
self.send(producerFinished(),"signal")
if not brokenClient:
yield WaitComplete(self.handleDisconnect(),tag="_handleDisconnect")
self.logResult()
def handleCommand(self, command):
if command[0] == "STAT":
self.sendCommand("STAT")
yield WaitComplete(self.getline(), tag="_getline4")
# print "SERVER RESPONSE", self.line
ok, emails, boxsize = self.line.split()
emails = int(emails)
boxsize = int(boxsize)
self.send((emails, boxsize), "client_outbox")
if command[0] == "DELE":
net_command = "DELE %d" % (command[1], )
self.sendCommand(net_command)
yield WaitComplete(self.getline(), tag="_getline4")
# print "SERVER RESPONSE", self.line
self.send(self.line, "client_outbox")
if command[0] == "TOP":
net_command = "TOP %d %d" % (command[1], command[2])
self.sendCommand(net_command)
end_of_headers = False
lines = []
while not end_of_headers:
yield WaitComplete(self.getline(), tag="_getline4")
# print "SERVER RESPONSE", repr(self.line), "--EOL--"
self.line = self.line.lower()
lines.append(self.line)
if "".join(lines)[-5:] == "\r\n.\r\n":
end_of_headers = True
lines = ("".join(lines)).split("\r\n")
headers = self.headerlinesToDict(lines[:][1:])
self.send(headers, "client_outbox")
def main(self):
requestobject = self.initialiseRequestObject()
yield WaitComplete(self.getInitialLine())
self.handleInitialLine(requestobject)
if requestobject["bad"]: # Initial line may be dud
self.debug("HTTPParser::main - request line bad\n")
self.closeConnection()
return
if self.mode == "response" or requestobject["method"] == "PUT" or requestobject["method"] == "POST":
self.bodiedrequest = True
else:
self.bodiedrequest = False
yield WaitComplete(self.getHeaders(requestobject))
self.setServer(requestobject)
self.setConnectionMode(requestobject)
requestobject["peer"] = self.peer
requestobject["peerport"] = self.peerport
requestobject["localip"] = self.localip
requestobject["localport"] = self.localport
self.send(ParsedHTTPHeader(requestobject), "outbox") # Pass on completed header
if self.bodiedrequest:
yield WaitComplete(self.getBody(requestobject))
#state 4 - request complete, send it on
self.debug("HTTPParser::main - request sent on\n")
# print requestobject
#print 'closing connection!'
self.closeConnection()
yield 1
def main(self):
self.control_message = None
self.connectionSuccess = False
self.loggedIn = False
yield WaitComplete(self.waitForBanner())
if self.connectionSuccess:
yield WaitComplete(self.doLogin(self.username, self.password))
if self.loggedIn:
run = True
while run:
while not self.anyReady():
self.pause()
yield 1
while self.dataReady("client_inbox"):
command = self.recv("client_inbox")
yield WaitComplete(self.handleCommand(command))
if command[0] == "QUIT":
run = False
self.sendCommand("QUIT")
yield WaitComplete(self.getline(), tag="_getline5")
# print "SERVER RESPONSE", self.line
if self.shutdown() or self.control_message:
self.send(self.control_message, "signal") # Pass on
else:
self.send(shutdownMicroprocess(), "signal")
yield 1
def main(self):
loggedin = False
try:
self.netPrint("")
while not loggedin:
self.send("login: "******"outbox")
yield WaitComplete(self.waitMsg())
username = self.getMsg()[:-2] # strip \r\n
self.send("password: "******"outbox")
yield WaitComplete(self.waitMsg())
password = self.getMsg()[:-2] # strip \r\n
self.netPrint("")
if users.get(username.lower(), None) == password:
self.netPrint("Login Successful")
loggedin = True
else:
self.netPrint("Login Failed!")
except GotShutdownMessage:
self.send(self.recv("control"), "signal")
if loggedin:
self.State["remoteuser"] = username
def main(self):
print "Reindeer", self.Name, "is up and about!"
self.send("holiday", "feet")
for i in xrange(4):
yield 1 # Nasty hack - we need to here from our feet when we've arrived(!)
yield WaitComplete(self.onHoliday())
while 1:
yield WaitComplete(self.doSantasWorkshop())
def doLogin(self, username, password):
self.sendCommand("USER " + username)
yield WaitComplete(self.getline(), tag="_getline2")
# print "SERVER RESPONSE", self.line
if self.line[:3] == "+OK":
self.sendCommand("PASS " + password)
yield WaitComplete(self.getline(), tag="_getline3")
# print "SERVER RESPONSE", self.line
if self.line[:3] == "+OK":
self.loggedIn = True
def main(self):
"""\
Requests a surface from PygameDisplay and registers to listen for events.
Then enters the main loop, which checks for Pygame events and updates
them to the screen.
"""
yield WaitComplete(self.initPygame(DISPLAYREQUEST = True,
size = (self.screen_width, self.screen_height),
callback = (self, '_surface'),
position = self.position,
events = (self, "_events")))
self.send({'ADDLISTENEVENT' : pygame.KEYDOWN,
'surface' : self.screen
}
, '_pygame')
while not self.shutdown():
yield 1
string_buffer = self.string_buffer
while self.dataReady('_events'):
for event in self.recv('_events'):
char = event.unicode
if char == '\n' or char == '\r':
self.send(string_buffer)
string_buffer = ''
elif event.key == K_BACKSPACE:
string_buffer = string_buffer[:len(string_buffer)-1]
elif event.key == K_ESCAPE:
self.done = True
else:
string_buffer += char
self.setText(string_buffer + '|')
self.string_buffer = string_buffer
def main(self):
while not self.dataReady("control"):
self.send("login: "******"outbox")
yield WaitComplete(self.waitMsg())
username = self.getMsg()
self.send("password: "******"outbox")
yield WaitComplete(self.waitMsg())
password = self.getMsg()
print
print repr(username), repr(password)
self.pause()
yield 1
self.send(self.recv("control"), "signal")
def main(self):
ID = randint(0,20000)
print "PRE-WAIT"
yield WaitComplete(self.tick(ID))
print "POST-WAIT"
while 1:
yield 1
try:
data = self.recv("inbox")
print data,
except:
print "NO DATA READY, LETS WAIT A BIT"
ID = randint(0,20000)
print "PRE-WAIT"
yield WaitComplete(self.tick(ID))
print "POST-WAIT"
def main(self):
print "Santa's up and about!"
self.send("santasworkshop", "feet")
for i in xrange(4):
yield 1 # Nasty hack - we need to here from our feet when we've arrived(!)
self.send("Ho Ho Ho!", "voicebox")
yield WaitComplete(self.doSleeping())
def main(self):
"""Main loop"""
yield WaitComplete(
self.requestDisplay(
DISPLAYREQUEST=True,
callback=(self, "fromDisplay"),
events=(self, "eventsIn"),
size=self.size,
position=self.position,
))
self.surface.fill((255, 255, 255))
self.send({"REDRAW": True, "surface": self.surface}, "toDisplay")
self.send(
{
"ADDLISTENEVENT": pygame.MOUSEBUTTONDOWN,
"surface": self.surface
}, "toDisplay")
self.send(
{
"ADDLISTENEVENT": pygame.MOUSEMOTION,
"surface": self.surface
}, "toDisplay")
self.send(
{
"ADDLISTENEVENT": pygame.MOUSEBUTTONUP,
"surface": self.surface
}, "toDisplay")
while not self.finished():
while self.dataReady("inbox"):
msgs = self.recv("inbox")
# \
#print repr(msgs)
self.redrawNeeded = False
for msg in msgs:
cmd = msg[0]
args = msg[1:]
# parse commands here
self.handleCommand(cmd, *args)
if self.redrawNeeded:
self.send({
"REDRAW": True,
"surface": self.surface
}, "toDisplay")
if not self.clean:
if not self.dirty_sent:
self.send("dirty", "surfacechanged")
self.dirty_sent = True
# pass on events received from pygame display
while self.dataReady("eventsIn"):
self.send(self.recv("eventsIn"), "eventsOut")
self.pause()
yield 1
def doRequestDisplay(self, size):
return WaitComplete(
self.requestDisplay(DISPLAYREQUEST=True,
callback=(self, "display_control"),
events=(self, "events"),
size=size,
transparency=self.transparency,
position=(0, 0)))
def waitMsg(self):
def _waitMsg(self):
while (not self.dataReady("inbox")) and (
not self.dataReady("control")):
self.pause()
yield 1
return WaitComplete(_waitMsg(self))
def deleteMessage(self, messageid):
def local():
self.send(["DELE",messageid], "outbox")
while not self.dataReady("inbox"):
self.pause()
yield 1
self.result = self.recv("inbox")
return WaitComplete(local())
def main(self):
try:
while 1:
self.send("login: "******"outbox")
yield WaitComplete( self.waitMsg() )
username = self.getMsg()
self.send("password: "******"outbox")
yield WaitComplete( self.waitMsg() )
password= self.getMsg()
print
print repr(username), repr(password)
self.pause()
yield 1
except GotShutdownMessage:
self.send(self.recv("control"), "signal")
self.send( Axon.Ipc.producerFinished(), "signal")
def getMailStats(self):
def local():
self.send(["STAT"], "outbox")
while not self.dataReady("inbox"):
self.pause()
yield 1
self.stat = self.recv("inbox")
self.stat_mails, self.stat_size = self.stat
return WaitComplete(local())
def main(self):
yield WaitComplete(self.connect())
for md5key in self.getMD5key():
yield 1
for reply in self.getBOSandAuthCookie(md5key):
yield 1
goal = self.extractBOSandCookie(reply)
self.send(goal, "_cookie")
assert self.debugger.note("AuthCookieGetter.main", 1, str(goal))
def getMessageHeaders(self, messageID):
def local():
self.send(["TOP",messageID,0], "outbox")
while not self.dataReady("inbox"):
self.pause()
yield 1
self.headers = self.recv("inbox")
return WaitComplete(local())
def waitForBanner(self):
yield WaitComplete(self.getline(), tag="_getline1")
# print "SERVER RESPONSE", self.line
self.banner = self.line.strip()
# print repr(self.banner)
if self.banner[:3] == "+OK":
self.connectionSuccess = True
else:
self.connectionSuccess = False
def doRequestDisplay(self):
return WaitComplete(
self.requestDisplay(DISPLAYREQUEST=True,
callback = (self,"display_control"),
events = (self, "events"),
size = self.surfacesize,
transparency = self.transparency,
position = self.surfaceposition,
onlymouseinside = self.onlymouseinside, ### Tempted to do events depth instead
)
)
def getBody(self, requestobject):
self.debug("HTTPParser::main - stage 3 start - Get Post Body")
#state 3 - the headers are complete - awaiting the message
if requestobject["headers"].get("transfer-encoding","").lower() == "chunked":
yield WaitComplete(self.getBody_ChunkTransferEncoding(requestobject))
elif requestobject["headers"].has_key("content-length"):
yield WaitComplete(self.getBody_KnownContentLength(requestobject))
else: #we'll assume it's a connection: close jobby
yield WaitComplete(self.getBodyDependingOnHalfClose())
#else:
# #no way of knowing how long the body is
# requestobject["bad"] = 411 #length required
# print "HTTPParser::main - stage 3.bad"
self.debug("HTTPParser::main - stage 3 end - Got Post Body")
def deleteMessage(self, messageid):
def local():
print "WARNING, you missed this!"
return # just in case we accidentally missed something
self.send(["DELE", messageid], "outbox")
while not self.dataReady("inbox"):
self.pause()
yield 1
self.result = self.recv("inbox")
return WaitComplete(local())
def main(self):
"""Main loop"""
yield WaitComplete(self.initPygame(DISPLAYREQUEST = True,
size = (self.screen_width, self.screen_height),
callback = (self, '_surface'),
position = self.position))
while not self.shutdown():
yield 1
if self.dataReady('inbox'):
line = str(self.recv('inbox'))
self.update(line)
def main(self):
done = False
while not done:
yield WaitComplete(self.waitForData())
while self.dataReady("inbox"):
data = self.recv("inbox")
sys.stdout.write(str(data) + "\n")
sys.stdout.flush()
done = data == 0
yield 1
def main(self):
while 1:
yield WaitComplete(self.sleep())
for d in self.Inbox("inbox"):
try:
command = self.commands.get(d[0])
except KeyError:
pass
if command:
command(d[1:])
else:
(self.contextactions[-1])(d)
def main(self):
"""\
Requests a surface from PygameDisplay and registers to listen for events
Then enters the main loop, which checks for Pygame events and updates
them to the screen.
"""
yield 1
yield 1
yield 1
yield WaitComplete(self.initPygame(DISPLAYREQUEST = True,
size = (self.screen_width, self.screen_height),
callback = (self, '_surface'),
position = self.position,
events = (self, "_events")))
self.send({'ADDLISTENEVENT' : pygame.KEYDOWN,
'surface' : self.screen},
'_pygame')
string_buffer = self.initial_string_buffer
while not self.needShutdown(): # FIXME: Inconsistent - see method definition
yield 1
while self.dataReady('_events'):
for event in self.recv('_events'):
char = event.unicode
if char == '\n' or char == '\r':
self.send(string_buffer)
string_buffer = ''
elif event.key == K_BACKSPACE:
string_buffer = string_buffer[:-1]
elif event.key == K_ESCAPE:
self.done = True
else:
string_buffer += char
# Add a '|' character as a text cursor
self.setText(string_buffer + '|')
while self.dataReady("inbox"):
char = self.recv("inbox")
if char == "\n" or char == "\r":
self.send(string_buffer)
string_buffer = ''
elif char == "\x08":
string_buffer = string_buffer[:-1]
else:
string_buffer += char
self.setText(string_buffer + '|')
while not self.anyReady() and not self.needShutdown(): # changed to while - can be woken by messages leaving as well as arriving
self.pause() # Looping here is safe, since we only update based on information on inboxes
yield 1
self.send(Axon.Ipc.producerFinished(message=self.screen), "_pygame")
def main(self):
yield WaitComplete(self.getDisplay())
while self.shutdown():
if self.dataReady("inbox"):
data = self.recv("inbox")
if isinstance(data, list):
self.display.blit(data[0], data[1])
else:
self.display.blit(data, (0, 0))
self.pygame_display_flip()
self.pause()
yield 1
def handleDisconnect(self):
if not self.acceptingMail: return
self.connectToRealSMTPServer()
yield 1
sentDataLine = False
for line in self.inbox_log:
if not sentDataLine: # wait for a response from the server before sending next line
yield WaitComplete(self.getline_fromsmtpserver(),tag="getline_smtp")
self.send(line, "tcp_outbox")
yield 1
if not sentDataLine:
sentDataLine = (line == "DATA\r\n")
yield 1
self.send(producerFinished(), "tcp_signal")
def grabStoreHam(self, messageid):
def local():
self.send(["RETR", messageid], "outbox")
while not self.dataReady("inbox"):
self.pause()
yield 1
self.result = self.recv("inbox")
filename = str(self.hamcount)
full_filename = os.path.join(self.possible_ham_store, filename)
F = open(full_filename, "wb")
F.write(self.result)
F.close()
# print "STORED SPAM IN", full_filename
return WaitComplete(local())
