def run(self):
self.neh = NEH.NetworkEventHandler(self.transport)
#if not self.userInteraction("case301: proceed when ready to send REGISTER"):
# neh.closeSock()
# return
print " !!!! PLEASE REGISTER WITH USERNAME='******' and PASSWORD='******' WITHIN 5 MINUTES !!!!"
self.challenged = 0
req = self.readMessageFromNetwork(self.neh, 300, RequestMethod="REGISTER")
if req is None:
self.addResult(TestCase.TC_ERROR, "missing REGISTER request")
self.neh.closeSock()
return
reg = self.readMessageFromNetwork(self.neh, 60, RequestMethod="REGISTER")
if reg is None:
self.addResult(TestCase.TC_ERROR, "missing REGISTER after challenge")
else:
if reg.hasParsedHeaderField("Authorization"):
auth_p = reg.getParsedHeaderValue("Authorization")
ret = auth_p.verify(reg.getHeaderValue("Authorization"))
if ret:
Log.logDebug("case301: warnings or errors about the Authorization header, see test results", 1)
Log.logTest("case301: warnings or erros about the Authorization header, see test results")
self.results.extend(ret)
if reg.hasParsedHeaderField("CSeq") and req.hasParsedHeaderField("CSeq"):
if (reg.getParsedHeaderValue("CSeq").number <= req.getParsedHeaderValue("CSeq").number) and (reg.getParsedHeaderValue("CallID") == req.getParsedHeaderValue("CallID")):
self.addResult(TestCase.TC_WARN, "CSeq number was not increased for authorization")
else:
if reg.hasHeaderField("Authorization"):
Log.logDebug("case301: failed to parse the given Authorization header", 1)
Log.logTest("case301: unable to parse the Authorization header")
self.addResult(TestCase.TC_ERROR, "failed to parse Authorization header")
else:
Log.logDebug("case301: missing Authorization header in request", 1)
Log.logTest("case301: missing Authorization header in request")
self.addResult(TestCase.TC_FAILED, "missing Authorization header in request")
if reg.hasParsedHeaderField("From"):
fm = reg.getParsedHeaderValue("From")
if (not NEH.compareHostNames(fm.uri.host, Config.LOCAL_IP)) and (not NEH.compareHostNames(fm.uri.host, Config.LOCAL_HOSTNAME)):
self.addResult(TestCase.TC_FAILED, "host part of From URI does not contain the SFTF host")
else:
self.addResult(TestCase.TC_ERROR, "missing parsed From in REGSITER")
if self.checkAuthResponse(reg):
Log.logDebug("case301: authenticaton reply is valid", 2)
Log.logTest("case301: authenticaton reply is valid")
self.addResult(TestCase.TC_PASSED, "authentication reply is valid")
else:
Log.logDebug("case301: authentication reply is NOT valid", 1)
Log.logTest("case301: authentication reply is NOT valid")
self.addResult(TestCase.TC_FAILED, "wrong authentication reply")
self.neh.closeSock()
def run(self):
self.neh = NEH.NetworkEventHandler(self.transport)
#if not self.userInteraction("case211s: proceed when ready to send INVITE"):
# neh.closeSock()
# return
self.end = 0
print " !!!! PLEASE CALL ANY NUMBER/USER !!!!"
while self.end == 0:
req = self.readRequestFromNetwork(self.neh, TimeoutError=False)
self.neh.closeSock()
res = True
for hf in ("From", "To", "CSeq", "Call-ID"):
if not self.req.hasHeaderField(hf):
res = False
Log.logDebug(
"case211s: request misses \'" + hf + "\' header field", 1)
Log.logTest("case211s: request misses \'" + hf +
"\' header field")
if res:
Log.logDebug("case211s: all mandatory header fields found", 2)
Log.logTest("case211s: all mandatory header fields present")
self.addResult(TestCase.TC_PASSED,
"all mandatory header fields present")
else:
Log.logDebug("case211s: request misses a mandatory header field",
1)
Log.logTest("case211s: request misses a mandatory header field")
self.addResult(TestCase.TC_FAILED,
"request misses mandatory header field")
def run(self):
self.neh = NEH.NetworkEventHandler(self.transport)
#if not self.userInteraction("case903: proceed when ready to send INVITE"):
# neh.closeSock()
# return
print " !!!! PLEASE CALL ANY NUMBER/USER WITHIN 1 MINUTE !!!!"
req = self.readMessageFromNetwork(self.neh, 60)
if req is None:
self.addResult(TestCase.TC_ERROR, "missing INVITE request")
else:
if req.hasHeaderField("Content-Length"):
if req.hasParsedHeaderField("Content-Length"):
rcl_h = req.getParsedHeaderValue("Content-Length").length
rcl_c = Helper.calculateBodyLength(req.body)
if rcl_h == rcl_c:
self.addResult(TestCase.TC_PASSED, "Content-Lenght is present")
else:
self.addResult(TestCase.TC_WARN, "Content-Lenght is present, but incorrect")
else:
self.addResult(TestCase.TC_ERROR, "missing parsed Content-Length header")
else:
self.addResult(TestCase.TC_WARN, "missing Content-Lenght header in request")
self.neh.closeSock()
def run(self):
self.redirect_user_name = "redirect"
self.neh = NEH.NetworkEventHandler(self.transport)
#if not self.userInteraction("case227: proceed when ready to send INVITE"):
# neh.closeSock()
# return
print " !!!! PLEASE CALL ANY NUMBER/USER WITHIN 1 MINUTE !!!!"
self.redirected = 0
req = self.readRequestFromNetwork(self.neh, 60)
if req is None:
self.addResult(TestCase.TC_ERROR, "missing INVITE request")
self.neh.closeSock()
return
red = self.readRequestFromNetwork(self.neh)
if red is None:
self.addResult(TestCase.TC_FAILED,
"missing INVITE to redirected user")
else:
if self.redinv.rUri == self.co.uri:
self.addResult(TestCase.TC_PASSED, "successfull redirected")
else:
self.addResult(
TestCase.TC_FAILED,
"request URI in redirected request differ from Contact URI"
)
self.neh.closeSock()
def run(self):
self.neh = NEH.NetworkEventHandler(self.transport)
inv = self.createRequest("INVITE")
ct = inv.getParsedHeaderValue("Content-Type")
ct.subtype = "unsupportedformat"
inv.setHeaderValue("Content-Type", ct.create())
cd = self.getParsedHeaderInstance("Content-Disposition")
cd.type = "session"
inv.setParsedHeaderValue("Content-Disposition", cd)
inv.setHeaderValue("Content-Disposition", cd.create())
self.setBody("<audio>\r\n<pcmu port=\"443\"/>\r\n</audio>\r\n", inv)
self.writeMessageToNetwork(self.neh, inv)
self.code = 0
while (self.code <= 200):
repl = self.readReplyFromNetwork(self.neh)
if (repl is not None) and (repl.code > self.code):
self.code = repl.code
elif repl is None:
self.code = 999
if repl is None:
self.addResult(TestCase.TC_FAILED, "missing reply on request")
self.neh.closeSock()
def run(self):
self.neh = NEH.NetworkEventHandler(self.transport)
inv = self.createRequest("INVITE")
inv.rUri.username = "******"
via = inv.getParsedHeaderValue("Via")
via.branch = "z9hG4bK-.!%66*_+`'~"
inv.setHeaderValue("Via", via.create())
to = inv.getParsedHeaderValue("To")
to.displayname = "BEL:\\\x07 NUL:\\\x00 DEL:\\\x7F"
to.uri.username = "******"
inv.setHeaderValue("To", to.create())
inv.transaction.dialog.remoteUri = to
self.writeMessageToNetwork(self.neh, inv)
self.code = 0
while (self.code <= 200):
repl = self.readReplyFromNetwork(self.neh)
if (repl is not None) and (repl.code > self.code):
self.code = repl.code
elif repl is None:
self.code = 999
if repl is None:
self.addResult(TestCase.TC_FAILED, "missing reply on request")
self.neh.closeSock()
def __init__(self, tc, addr, port):
self.tc = tc
self.neh = NEH.NetworkEventHandler('tcp',
addr,
port,
eventType=_MyHttpRequest)
self.neh.openSock()
def run(self):
self.neh = NEH.NetworkEventHandler(self.transport)
inv = self.createRequest("INVITE")
via = inv.getParsedHeaderValue("Via")
via.params.append("unknownParameter=unknownValue")
via.params.append(
" unknownParameterWithLeadingLWS= unknownValuewithLeadingLWS")
via.params.append("unknownParameterWithoutAValue")
via.params.append(" unknownParameterWithoutAValueAndWithLeadingLWS")
self.reqvia = via
self.writeMessageToNetwork(self.neh, inv)
self.repvia = None
self.code = 0
while (self.code <= 200):
repl = self.readReplyFromNetwork(self.neh)
if (repl is not None) and (repl.code > self.code):
self.code = repl.code
elif repl is None:
self.code = 999
if repl is None:
self.addResult(TestCase.TC_FAILED, "missing reply on request")
if self.repvia is not None:
if self.reqvia == self.repvia:
self.addResult(
TestCase.TC_PASSED,
"Via in first reply is equal to Via in first request")
else:
self.addResult(
TestCase.TC_FAILED,
"Via in first reply is NOT equal to Via in first request")
self.neh.closeSock()
def run(self):
# creating a network socket is always required
self.neh = NEH.NetworkEventHandler(self.transport)
self.inv = self.createRequest("INVITE")
ct = self.getParsedHeaderInstance("Content-Type")
ct.type = "multipart"
ct.subtype = "mixed"
ct.params.append("boundary=verybasicboundary")
self.inv.setParsedHeaderValue("Content-Type", ct)
self.inv.setHeaderValue("Content-Type", ct.create())
dummy = self.inv.body
bd = ['--verybasicboundary\r\n', 'Content-Type: text/plain\r\n', '\r\n', 'This is just a text to test the multipart capabilities of the UA.\r\n', '\r\n', '--verybasicboundary\r\n', 'Content-Type: application/sdp\r\n', '\r\n']
bd.extend(dummy)
bd.append("--verybasicboundary--\r\n")
self.setBody(bd, self.inv)
self.writeMessageToNetwork(self.neh, self.inv)
self.end = 0
while self.end == 0:
repl = self.readReplyFromNetwork(self.neh)
if repl is None:
self.end = 1
self.addResult(TestCase.TC_ERROR, "missing reply on request")
# at the end please close the socket again
self.neh.closeSock()
def run(self):
self.neh = NEH.NetworkEventHandler(self.transport)
#if not self.userInteraction("case902: proceed when ready to send INVITE"):
# neh.closeSock()
# return
print " !!!! PLEASE CALL ANY NUMBER/USER WITHIN 1 MINUTE !!!!"
req = self.readMessageFromNetwork(self.neh, 60)
if req is None:
self.addResult(TestCase.TC_ERROR, "missing INVITE request")
else:
if req.hasHeaderField("From"):
if req.hasParsedHeaderField("From"):
frm = req.getParsedHeaderValue("From")
if frm.tag is None:
self.addResult(TestCase.TC_WARN, "missing tag in From")
else:
self.addResult(TestCase.TC_PASSED, "From contains tag")
else:
self.addResult(TestCase.TC_ERROR,
"missing parsed From header")
else:
self.addResult(TestCase.TC_ERROR,
"missing From header in request")
self.neh.closeSock()
def run(self):
self.neh = NEH.NetworkEventHandler(self.transport)
self.connected = 0
self.byed = 0
while self.byed == 0:
if self.connected == 0:
print " !!!! PLEASE CALL ANY NUMBER/USER !!!!"
else:
print " !!!! PLEASE TERMINATE/HANGUP THE CALL !!!!"
req = self.readRequestFromNetwork(self.neh)
if (req is None):
if (self.byed == 0):
self.addResult(TestCase.TC_FAILED, "missing reply on request")
if self.byed == 1:
if req.isRequest and req.method == "BYE":
if req.hasParsedHeaderField("Route"):
passed = True
r = req.getParsedHeaderValue("Route")
c = self.replok.getParsedHeaderValue("Contact")
ro = self.getParsedHeaderInstance("Record-Route")
ro.uri.protocol = "sip"
ro.uri.host = Config.LOCAL_IP
ro.uri.port = Config.LOCAL_PORT
ro.uri.params.append("lr")
ro.looseRouter = True
cur = ro
pr = range(1, 5)
pr.reverse()
for i in pr:
cur.next = self.getParsedHeaderInstance("Record-Route")
cur.next.uri.protocol = "sip"
cur.next.uri.host = "proxy0" + str(i) + ".example.com"
cur.next.uri.params.append("lr")
cur.next.looseRouter = True
cur = cur.next
if req.rUri != c.uri:
self.addResult(
TestCase.TC_FAILED,
"BYE does not contain Contact URI from INVITE in request URI"
)
passed = False
if not r.cmp(ro):
self.addResult(
TestCase.TC_FAILED,
"Route header is not equal with the Record-Route header from INVITE"
)
passed = False
if passed:
self.addResult(
TestCase.TC_PASSED,
"Loose routing is correct (request URI and Route header)"
)
else:
self.addResult(TestCase.TC_FAILED,
"received BYE misses Route header")
self.neh.closeSock()
def run(self):
# creating a network socket is always required
self.neh = NEH.NetworkEventHandler(self.transport)
self.fst_inv = self.createRequest("INVITE")
self.mediaSockPair = self.setMediaBody(self.fst_inv)
self.writeMessageToNetwork(self.neh, self.fst_inv)
self.invited = self.onhold = self.byed = 0
while self.byed == 0:
repl = self.readMessageFromNetwork(self.neh)
if repl is None:
if self.invited == 1:
bye = self.createRequest(
"BYE", dia=self.fst_inv.transaction.dialog)
Log.logTest("sending BYE for original INVITE")
self.writeMessageToNetwork(self.neh, bye)
rep = self.readReplyFromNetwork(self.neh)
if rep is None:
self.addResult(TestCase.TC_ERROR,
"missing reply on BYE")
self.addResult(TestCase.TC_ERROR, "missing reply on request")
self.byed = 1
# at the end please close the socket again
self.neh.closeSock()
def run(self):
self.branchvalue = "z9hG4bK-SFTF-dummy-branch-value"
self.neh = NEH.NetworkEventHandler(self.transport)
inv = self.createRequest("INVITE")
inv.removeParsedHeaderField("From")
inv.removeHeaderField("From")
via = inv.getParsedHeaderValue("Via")
via.branch = self.branchvalue
inv.setHeaderValue("Via", via.create())
inv.createEvent()
self.writeMessageToNetwork(self.neh, inv)
self.code = 0
while (self.code <= 200):
repl = self.readReplyFromNetwork(self.neh)
if (repl is not None) and (repl.code > self.code):
self.code = repl.code
elif repl is None:
self.code = 999
if repl is None:
self.addResult(TestCase.TC_FAILED, "missing reply on request")
self.neh.closeSock()
def run(self):
self.neh = NEH.NetworkEventHandler(self.transport)
self.end = False
self.invited = False
self.connected = False
while not self.end:
if self.invited:
print " !!!! PLEASE CALL ANY NUMBER/NAME WITHIN 60 SECONDS OVER TCP !!!!"
elif self.connected:
print " !!!! PLEASE TERMINATE/HANGUP THE CALL !!!!"
repl = self.readMessageFromNetwork(self.neh,
60,
TimeoutError=False)
if repl is None:
if not self.invited:
self.addResult(TestCase.TC_ERROR,
"did not received INVITE over TCP")
elif self.neh.state != NEH.NetworkEventHandler.NEH_CONNECTED:
self.addResult(
TestCase.TC_FAILED,
"TCP connection was not reopened by UA after closing")
else:
self.addResult(
TestCase.TC_ERROR,
"did not received BYE on the reopened TCP connection")
self.end = True
self.neh.closeSock()
def run(self):
# creating a network socket is always required
self.neh = NEH.NetworkEventHandler(self.transport)
self.inv = self.createRequest("INVITE")
to = self.inv.getParsedHeaderValue("To")
# the To displayname does not contain special characters
# feel free to add some
to.displayname = u"SC@SIP-Forum".encode('utf8')
self.inv.setHeaderValue("To", to.create())
fr = self.inv.getParsedHeaderValue("From")
# german umlaute rulez (tribute to the german author of all this :-)
fr.displayname = unicode("\xC4\xD6\xDC\xE4\xF6\xFC\xDF", "unicode_escape").encode('utf8')
self.inv.setHeaderValue("From", fr.create())
self.writeMessageToNetwork(self.neh, self.inv)
self.end = 0
while self.end == 0:
repl = self.readReplyFromNetwork(self.neh)
if repl == None:
self.addResult(TestCase.TC_FAILED, "missing reply on INVITE")
self.end = 1
# at the end please close the socket again
self.neh.closeSock()
def onACK(self, message):
Log.logTest("received ACK")
self.connected = True
Log.logTest("closing TCP connection")
self.neh.close()
self.neh = NEH.NetworkEventHandler(self.transport)
Log.logTest("sleeping for 3 seconds...")
time.sleep(3)
def run(self):
self.neh = NEH.NetworkEventHandler(self.transport)
self.rrrepl = None
inv = self.createRequest("INVITE")
via = inv.getParsedHeaderValue("Via")
rr = self.getParsedHeaderInstance("Record-Route")
rr.uri.protocol = "sip"
rr.uri.host = via.host
rr.uri.port = via.port
rr.uri.params.append("lr")
rr.looseRouter = True
rr.uri.params.append("unknownParameter=unknownValue")
rr.uri.params.append(
" unknownParameterWithLeadingLWS= unknowValueWithLeadingLWS")
rr.uri.params.append("unknownParameterWithoutAValue")
rr.uri.params.append(
" unknownParameterWithoutAValueAndWithLeadingLWS")
inv.setParsedHeaderValue("Record-Route", rr)
inv.setHeaderValue("Record-Route", rr.create())
inv.transaction.dialog.ignoreRoute = True
self.writeMessageToNetwork(self.neh, inv)
self.code = 0
self.byed = 0
while (self.code <= 200) and (self.byed == 0):
repl = self.readReplyFromNetwork(self.neh)
if (repl is not None) and (repl.code > self.code):
self.code = repl.code
elif repl is None:
self.code = 999
if repl is None:
self.addResult(TestCase.TC_FAILED, "missing reply on request")
elif self.rrrepl is not None:
if self.rrrepl.hasParsedHeaderField("Record-Route"):
reprr = self.rrrepl.getParsedHeaderValue("Record-Route")
if reprr == rr:
self.addResult(
TestCase.TC_PASSED,
"Record-Route header contains all parameters from request"
)
else:
self.addResult(
TestCase.TC_FAILED,
"Record-Route header is not equal to Record-Route from request"
)
else:
self.addResult(TestCase.TC_ERROR,
"missing Record-Route in reply")
else:
self.addResult(TestCase.TC_ERROR,
"valid reply (1xx|2xx) with Record-Route missing")
self.neh.closeSock()
def run(self):
self.neh = NEH.NetworkEventHandler(self.transport)
#if not self.userInteraction("case302bye: proceed when ready to send a INVITE"):
# neh.closeSock()
# return
inv = self.createRequest("INVITE")
self.challenged = 0
self.writeMessageToNetwork(self.neh, inv)
self.end = 0
while self.end == 0:
req = self.readMessageFromNetwork(self.neh, 10)
if req is None:
self.end = 1
if req is None:
if self.challenged == 1:
self.addResult(TestCase.TC_FAILED, "missing BYE after sending challenge (401)")
else:
self.addResult(TestCase.TC_ERROR, "missing reply on INVITE")
else:
if self.challenged == 1:
if req.hasParsedHeaderField("Authorization"):
auth_p = req.getParsedHeaderValue("Authorization")
ret = auth_p.verify(req.getHeaderValue("Authorization"))
if ret:
Log.logDebug("case302bye: warnings or errors about the Authorization header, see test log", 1)
Log.logTest("case302bye: warnings or errors about the Authorization header, see WARNINGS above")
self.results.extend(ret)
if self.first_bye.hasParsedHeaderField("CSeq") and self.bye.hasParsedHeaderField("CSeq"):
if (self.bye.getParsedHeaderValue("CSeq").number <= self.first_bye.getParsedHeaderValue("CSeq").number) and (self.bye.getParsedHeaderValue("CallID") == self.first_bye.getParsedHeaderValue("CallID")):
self.addResult(TestCase.TC_WARN, "CSeq number was not increased for authorization")
else:
if req.hasHeaderField("Authorization"):
Log.logDebug("case302bye: failed to parse the given Authorization header", 1)
Log.logTest("case302bye: unable to parse the Authorization header")
self.addResult(TestCase.TC_ERROR, "failed to parse Authorization header")
else:
Log.logDebug("case302bye: missing Authorization header in request", 1)
Log.logTest("case302bye: missing Authorization header in request")
self.addResult(TestCase.TC_FAILED, "missing Authorization header in request")
if self.checkAuthResponse(req):
Log.logDebug("case302bye: authenticaton reply is valid", 2)
Log.logTest("case302bye: authenticaton reply is valid")
self.addResult(TestCase.TC_PASSED, "authentication reply is valid")
else:
Log.logDebug("case302bye: authentication reply is NOT valid", 1)
Log.logTest("case302bye: authentication reply is NOT valid")
self.addResult(TestCase.TC_FAILED, "wrong authentication reply")
self.neh.closeSock()
def run(self):
self.testtag = "SC-test-tag"
self.neh = NEH.NetworkEventHandler(self.transport)
#if not self.userInteraction("case512: proceed when ready to send INVITE"):
# neh.closeSock()
# return
self.invited = 0
self.canceled = 0
while self.canceled == 0:
if self.invited == 0:
print " !!!! PLEASE CALL ANY NUMBER/USER !!!!"
else:
print " !!!! PLEASE CANCEL/HANGUP THE CALL !!!!"
req = self.readMessageFromNetwork(self.neh)
self.neh.closeSock()
if self.canceled == 1:
if self.first_to.tag == self.new_to.tag:
Log.logDebug("case512: To-tag in CANCEL matches tag in INVITE",
2)
Log.logTest("case512: To-tag in CANCEL matches tag in INVITE")
self.addResult(TestCase.TC_PASSED,
"To-tag is equal in CANCEL and INVITE")
elif self.new_to.tag is not None:
if self.new_to.tag == self.testtag:
Log.logDebug(
"case512: To-tag in CANCEL is from provisional response",
1)
Log.logTest(
"case512: To-tag in CANCEL is from provisional response"
)
self.addResult(TestCase.TC_FAILED,
"CANCEL To-tag from provisional response")
else:
Log.logDebug(
"case512: To-tag in CANCEL is not equal to the INVITE tag",
2)
Log.logTest(
"case512: To-tag in CANCEL is not equal to the INVITE tag"
)
self.addResult(TestCase.TC_WARN,
"CANCEL and INVITE To-tags are not equal")
else:
Log.logDebug(
"case512: To-tag in CANCEL is not equal to the INVITE tag",
2)
Log.logTest(
"case512: To-tag in CANCEL is not equal to the INVITE tag")
self.addResult(TestCase.TC_WARN,
"CANCEL and INVITE To-tags are not equal")
def run(self):
self.reregister_time = float(30)
self.neh = NEH.NetworkEventHandler(self.transport)
#if not self.userInteraction("case401: proceed when ready to send REGISTER"):
# neh.closeSock()
# return
print " !!!! PLEASE REGISTER WITHIN 5 MINUTES !!!!"
self.redriven = 0
old_req = self.readRequestFromNetwork(self.neh, 300)
if old_req is None:
self.addResult(TestCase.TC_ERROR, "missing REGISTER request")
self.neh.closeSock()
return
try:
new_req = self.readRequestFromNetwork(self.neh, 1.2*self.reregister_time, False)
except SCException:
Log.logDebug("case401: timeout after " + str(1.2*self.reregister_time) + "sec, allthough Contact expired after " + str(self.reregister_time) + "sec", 1)
Log.logTest("case401: did not receive REGISTER before timeout")
self.addResult(TestCase.TC_FAILED, "did not reregistered before Contact expired")
self.neh.closeSock()
return
if new_req.method != "REGISTER":
Log.logDebug("case401: request method != REGISTER", 1)
Log.logTest("case401: error: expected REGISTER, received " + str(new_req.method))
self.addResult(TestCase.TC_ERROR, "request method != REGISTER")
self.neh.closeSock()
return
delay = Helper.eventTimeDiff(new_req.event, old_req.event)
if (delay > (self.reregister_time*0.25)) and (delay < (self.reregister_time*0.75)):
Log.logDebug("case401: delay between REGISTER is between 0.25 * expires and 0.75 * expires => additional load", 2)
Log.logTest("case401: received REGISTER far before expires value")
self.addResult(TestCase.TC_CAUT, "received REGISTER far before (75%) expires value")
elif (delay >= (self.reregister_time*0.75) and delay <= self.reregister_time):
Log.logDebug("case401: delay between REGISTER is between 0.75 * expires and expires", 2)
Log.logTest("case401: received REGISTER shortly before expires")
self.addResult(TestCase.TC_PASSED, "received REGISTER shortly before expires")
elif delay > self.reregister_time:
Log.logDebug("case401: delay between re-REGISTER was " + str(delay) + " sec, which is above the expires value", 1)
Log.logTest("case401: received re-REGISTER very too late")
self.addResult(TestCase.TC_FAILED, "received the re-REGISTER too late")
else:
Log.logDebug("case401: delay between re-REGISTER was " + str(delay) + " sec, which is below 1/4 of the expires value", 1)
Log.logTest("case401: received re-REGISTER very much too early")
self.addResult(TestCase.TC_FAILED, "received the re-REGISTER very much too early")
self.neh.closeSock()
def run(self):
self.neh = NEH.NetworkEventHandler(self.transport)
#if not self.userInteraction("case303reg: proceed when ready to send REGISTER"):
# neh.closeSock()
# return
print " !!!! PLEASE REGISTER WITH USERNAME='******' and PASSWORD='******' WITHIN 5 MINUTES !!!!"
self.challenged = 0
req = self.readMessageFromNetwork(self.neh, 300, RequestMethod="REGISTER")
if req is None:
self.addResult(TestCase.TC_ERROR, "missing REGISTER request")
self.neh.closeSock()
return
reg = self.readMessageFromNetwork(self.neh, RequestMethod="REGISTER")
if reg is None:
self.addResult(TestCase.TC_ERROR, "missing REGISTER after challenge")
else:
if reg.hasParsedHeaderField("Authorization"):
auth_p = reg.getParsedHeaderValue("Authorization")
ret = auth_p.verify(reg.getHeaderValue("Authorization"))
if ret:
Log.logDebug("case303reg: warnings or errors about the Authorization header, see test results", 1)
Log.logTest("case303reg: warnings or erros about the Authorization header, see test results")
self.results.extend(ret)
if self.first_reg.hasParsedHeaderField("CSeq") and self.reg.hasParsedHeaderField("CSeq"):
if (self.reg.getParsedHeaderValue("CSeq").number <= self.first_reg.getParsedHeaderValue("CSeq").number) and (self.reg.getParsedHeaderValue("CallID") == self.first_reg.getParsedHeaderValue("CallID")):
self.addResult(TestCase.TC_WARN, "CSeq number was not increased for authorization")
else:
if reg.hasHeaderField("Authorization"):
Log.logDebug("case303reg: failed to parse the given Authorization header", 1)
Log.logTest("case303reg: unable to parse the Authorization header")
self.addResult(TestCase.TC_ERROR, "failed to parse Authorization header")
else:
Log.logDebug("case303reg: missing Authorization header in request", 1)
Log.logTest("case303reg: missing Authorization header in request")
self.addResult(TestCase.TC_FAILED, "missing Authorization header in request")
if self.checkAuthResponse(reg):
Log.logDebug("case303reg: authenticaton reply is valid", 2)
Log.logTest("case303reg: authenticaton reply is valid")
self.addResult(TestCase.TC_PASSED, "authentication reply is valid")
else:
Log.logDebug("case303reg: authentication reply is NOT valid", 1)
Log.logTest("case303reg: authentication reply is NOT valid")
self.addResult(TestCase.TC_FAILED, "wrong authentication reply")
self.neh.closeSock()
def run(self):
self.required_min_delay = 3.0
self.neh = NEH.NetworkEventHandler(self.transport)
#if not self.userInteraction("case304: proceed when ready to send REGISTER"):
# neh.closeSock()
# return
self.challenged = 0
print " !!!! PLEASE REGISTER WITHIN 5 MINUTES !!!!"
self.old_req = self.readMessageFromNetwork(self.neh, 300)
if self.old_req is None:
self.addResult(TestCase.TC_ERROR, "missing REGISTER request")
self.neh.closeSock()
return
self.last_delay = self.smallest_delay = 0
for i in range(0, 3):
try:
self.new_req = self.readMessageFromNetwork(self.neh, 2*self.required_min_delay, False, RequestMethod="REGISTER")
except SCException:
Log.logDebug("case304: smallest delay between retries was: " + str(self.smallest_delay) + "sec", 2)
Log.logTest("case304: smallest delay between retries was: " + str(self.smallest_delay) + "sec")
if i == 0:
Log.logDebug("case304: timeout after first 401, failed to answer the challenge", 1)
Log.logTest("case304: timeout after sending first 401")
self.addResult(TestCase.TC_WARN, "timeout after sending first 401")
elif i == 1:
if self.smallest_delay < self.required_min_delay:
Log.logDebug("case304: timeout after sending second 401", 2)
Log.logTest("case304: tried authentication only one time")
self.addResult(TestCase.TC_PASSED, "tried authentication only one time")
else:
Log.logDebug("case304: timeout after sending second 401, but delay was big enough to retype password", 2)
Log.logTest("case304: tried authentication only one time")
self.addResult(TestCase.TC_PASSED, "tried authentication only one time")
else:
Log.logDebug("case304: timeout after third 401, but tried to authenticate two times", 1)
Log.logTest("case304: timeout after sending third 401")
self.addResult(TestCase.TC_WARN, "timeout after sending third 401")
self.neh.closeSock()
return
Log.logDebug("case304: retired registration three times with same credentials", 1)
Log.logTest("case304: retired registration three times with same credentials")
self.addResult(TestCase.TC_FAILED, "retired registration three times with same credentials")
self.neh.closeSock()
def run(self):
self.testtag1 = "SC-test-tag-1"
self.testtag2 = "SC-test-tag-2"
self.testtag3 = "SC-test-tag-3"
self.ack = None
self.neh = NEH.NetworkEventHandler(self.transport)
#if not self.userInteraction("case509: proceed when ready to send INVITE"):
# neh.closeSock()
# return
self.rejected = 0
while self.rejected == 0:
print " !!!! PLEASE CALL ANY NUMBER/USER !!!!"
req = self.readMessageFromNetwork(self.neh)
self.neh.closeSock()
if (req is not None) and (self.ack is not None):
if self.ack.hasParsedHeaderField("To"):
ack_to = self.ack.getParsedHeaderValue("To")
else:
Log.logDebug("case509: missing To in ACK", 1)
Log.logTest("case509: missing To in ACK")
self.addResult(TestCase.TC_ERROR, "missing To in ACK")
if ack_to.tag == self.testtag2:
Log.logDebug(
"case509: To-tag in ACK matches tag from correct 180", 2)
Log.logTest(
"case509: To-tag in ACK matches tag from correct 180")
self.addResult(TestCase.TC_PASSED,
"To-tag in ACK matches correct 180 tag")
else:
Log.logDebug(
"case509: To-tag in ACK (\'" + str(ack_to.tag) +
"\') differes from tag in 603 (\'" + str(self.testtag2) +
"\')", 1)
Log.logTest("case509: To-tag in ACK differes from tag in 603")
if ack_to.tag == self.testtag1:
Log.logTest("case509: wrong To-tag from first 180 is used")
elif ack_to.tag == self.testtag3:
Log.logTest("case509: wrong To-tag from third 180 is used")
self.addResult(TestCase.TC_FAILED,
"To-tag in ACK differes from tag in 603")
elif (self.ack is None):
self.addResult(
TestCase.TC_ERROR,
"missing ACK on 603 to check the correct use of the To-tag")
def run(self):
self.neh = NEH.NetworkEventHandler(self.transport)
self.fst_inv = self.createRequest("INVITE")
via = self.fst_inv.getParsedHeaderValue("Via")
rr = self.getParsedHeaderInstance("Record-Route")
rr.uri.protocol = "sip"
rr.uri.host = via.host
rr.uri.port = via.port
rr.uri.params.append("lr")
rr.looseRouter= True
rr.next = self.getParsedHeaderInstance("Record-Route")
rr.next.uri.protocol = "sip"
rr.next.uri.host = "good.example.com"
rr.next.uri.params.append("lr")
rr.next.looseRouter = True
self.fst_inv.setParsedHeaderValue("Record-Route", rr)
self.fst_inv.setHeaderValue("Record-Route", rr.create())
self.fst_inv.transaction.dialog.ignoreRoute = True
self.reinvited = 0
self.byed = 0
self.writeMessageToNetwork(self.neh, self.fst_inv)
self.code = 0
while (self.code <= 200) and (self.byed == 0):
repl = self.readMessageFromNetwork(self.neh)
if (repl is not None) and (not repl.isRequest) and (repl.code > self.code):
self.code = repl.code
elif repl is None:
self.code = 999
if (repl is None):
if (self.byed == 0):
self.addResult(TestCase.TC_FAILED, "missing reply on request")
if self.byed == 1:
if repl.isRequest and repl.method == "BYE":
if repl.hasParsedHeaderField("Route"):
r = repl.getParsedHeaderValue("Route")
if r.next.uri.host == "good.example.com":
self.addResult(TestCase.TC_PASSED, "Record-Routing overwritting in re-INVITE ignored")
elif r.next.uri.host == "bad.example.com":
self.addResult(TestCase.TC_FAILED, "Record-Routing in re-INVITE overwrote Route")
else:
self.addResult(TestCase.TC_ERROR, "unknown host in Route header")
else:
self.addResult(TestCase.TC_ERROR, "received BYE misses Route header")
self.neh.closeSock()
def run(self):
self.neh = NEH.NetworkEventHandler(self.transport)
self.fst_inv = self.createRequest("INVITE")
co = self.fst_inv.getParsedHeaderValue("Contact")
co.uri.username = "******"
co.uri.params.append("%6C%72")
self.fst_inv.setHeaderValue("Contact", co.create())
self.invited = 0
self.byed = 0
self.writeMessageToNetwork(self.neh, self.fst_inv)
self.code = 0
while (self.code <= 200) and (self.byed == 0):
if self.invited == 0:
print " !!!! PLEASE ANSWER/PICKUP THE CALL !!!!"
else:
print " !!!! PLEASE TERMINATE/HANGUP THE CALL !!!!"
repl = self.readMessageFromNetwork(self.neh)
if (repl is not None) and (not repl.isRequest) and (repl.code >
self.code):
self.code = repl.code
elif repl is None:
self.code = 999
self.neh.closeSock()
if (repl is None) and (self.byed == 0):
self.addResult(TestCase.TC_FAILED,
"missing BYE request for evaluation")
if self.byed == 1:
if self.bye.rUri.username == "sc":
self.addResult(
TestCase.TC_FAILED,
"request URI contained un-escaped @ in username")
elif self.bye.rUri.username == "sc@sipcert":
self.addResult(TestCase.TC_PASSED,
"escaped username in request URI used")
elif self.bye.rUri.username == "sc%40sipcert":
self.addResult(
TestCase.TC_WARN,
"illegal charaters in request URI still escaped, but other escapings removed"
)
else:
self.addResult(
TestCase.TC_FAILED,
"request URI of the BYE did not contained the given escaped Contact value from the INVITE"
)
def run(self):
self.neh = NEH.NetworkEventHandler(self.transport)
inv = self.createRequest("OPTIONS")
self.writeMessageToNetwork(self.neh, inv)
self.code = 0
while (self.code < 200):
repl = self.readReplyFromNetwork(self.neh)
if (repl is not None) and (repl.code > self.code):
self.code = repl.code
elif repl is None:
self.code = 999
if repl is None:
self.addResult(TestCase.TC_FAILED, "missing reply on request")
self.neh.closeSock()
def run(self):
self.neh = NEH.NetworkEventHandler(self.transport)
inv = self.createRequest("INVITE")
req = self.getParsedHeaderInstance("Require")
req.tags.append("FooBarExtension")
inv.setParsedHeaderValue("Require", req)
inv.setHeaderValue("Require", req.create())
via = inv.getParsedHeaderValue("Via")
rr = self.getParsedHeaderInstance("Record-Route")
rr.uri.protocol = "sip"
rr.uri.host = via.host
rr.uri.port = via.port
inv.setParsedHeaderValue("Record-Route", rr)
inv.setHeaderValue("Record-Route", rr.create())
inv.transaction.dialog.ignoreRoute = True
self.writeMessageToNetwork(self.neh, inv)
self.reply = None
self.code = 0
while (self.code <= 200):
repl = self.readReplyFromNetwork(self.neh)
if (repl is not None) and (repl.code > self.code):
self.code = repl.code
elif repl is None:
self.code = 999
self.neh.closeSock()
if repl is None:
self.addResult(TestCase.TC_ERROR, "missing reply on request")
if self.reply is None:
self.addResult(
TestCase.TC_FAILED,
"missing negative reply, because 'Require: FooBarExtension' was not rejected"
)
else:
if self.reply.hasParsedHeaderField("Record-Route"):
self.addResult(TestCase.TC_FAILED,
"negative reply contains Record-Route header")
else:
self.addResult(
TestCase.TC_PASSED,
"negative reply does not contain Record-Route header")
def run(self):
self.neh = NEH.NetworkEventHandler(self.transport)
#if not self.userInteraction("case206: proceed when ready to send INVITE"):
# neh.closeSock()
# return
self.challenged = 0
print " !!!! PLEASE CALL ANY NUMBER/USER WITHIN 1 MINUITE !!!!"
req = self.readMessageFromNetwork(self.neh, 60)
if req is None:
self.addResult(TestCase.TC_ERROR, "missing INVITE request")
else:
if self.dialog[0].transaction[0].lastACK is not None:
self.addResult(TestCase.TC_PASSED,
"received ACK for 404 without reason phrase")
self.neh.closeSock()
def run(self):
self.neh = NEH.NetworkEventHandler(self.transport)
inv = self.createRequest("INVITE")
mf = inv.getParsedHeaderValue("Max-Forwards")
mf.forwards = 0
inv.setHeaderValue("Max-Forwards", mf.create())
self.writeMessageToNetwork(self.neh, inv)
self.code = 0
while (self.code <= 200):
repl = self.readReplyFromNetwork(self.neh)
if (repl is not None) and (repl.code > self.code):
self.code = repl.code
elif repl is None:
self.code = 999
if repl is None:
self.addResult(TestCase.TC_FAILED, "missing reply on request")
self.neh.closeSock()
def run(self):
self.neh = NEH.NetworkEventHandler(self.transport)
#if not self.userInteraction("case801s: proceed when ready to send INVITE"):
# neh.closeSock()
# return
print " !!!! PLEASE CALL ANY NUMBER/USER WITHIN 1 MINUTE !!!!"
req = self.readRequestFromNetwork(self.neh, 60)
self.neh.closeSock()
if req is None:
self.addResult(TestCase.TC_ERROR, "missing INVITE request")
else:
if req.hasHeaderField("Via"):
if req.hasParsedHeaderField("Via"):
via = req.getParsedHeaderValue("Via")
if via.rport is None:
Log.logDebug(
"case801s: parsed Via does not contain rport", 1)
Log.logTest("case801s: Via does not contain rport")
self.addResult(TestCase.TC_WARN,
"missing rport in Via")
else:
Log.logDebug("case801s: Via contains rport", 2)
Log.logTest("case801s: Via contains rport")
self.addResult(TestCase.TC_PASSED,
"Via contains rport")
else:
Log.logDebug("case801s: unable to find parsed Via header",
1)
Log.logTest("case801s: unable to find parsed Via header")
self.addResult(TestCase.TC_ERROR,
"missing parsed Via header")
else:
Log.logDebug("case801s: unable to find Via header in request",
1)
Log.logTest("case801s: unable to find Via header in request")
self.addResult(TestCase.TC_ERROR,
"missing Via header in request")
def run(self):
self.neh = NEH.NetworkEventHandler(self.transport)
inv = self.createRequest("INVITE")
req = self.getParsedHeaderInstance("Require")
req.tags.append("FooBarExtension")
inv.setParsedHeaderValue("Require", req)
inv.setHeaderValue("Require", req.create())
self.writeMessageToNetwork(self.neh, inv)
self.code = 0
while (self.code <= 200):
repl = self.readReplyFromNetwork(self.neh)
if (repl is not None) and (repl.code > self.code):
self.code = repl.code
elif repl is None:
self.code = 999
if repl is None:
self.addResult(TestCase.TC_FAILED, "missing reply on request")
self.neh.closeSock()
