def check_capture_stdin(self, cmd=None):
# Similar to suite_io.check_io_4_packets.
if cmd == config.cmd_wireshark and not config.canDisplay():
self.skipTest('Test requires a display.')
self.assertIsNotNone(cmd)
capture_file = os.path.join(config.capture_dir, 'dhcp.pcap')
testout_file = self.filename_from_id(testout_pcap)
slow_dhcp_cmd = subprocesstest.cat_dhcp_command('slow')
capture_cmd = subprocesstest.capture_command(
cmd,
'-i',
'-',
'-w',
testout_file,
'-a',
'duration:{}'.format(capture_duration),
shell=True)
if cmd == config.cmd_wireshark:
capture_cmd += ' -o console.log.level:127'
pipe_proc = self.runProcess(slow_dhcp_cmd + ' | ' + capture_cmd,
shell=True)
pipe_returncode = pipe_proc.returncode
self.assertEqual(pipe_returncode, 0)
if cmd == config.cmd_wireshark:
self.assertTrue(self.grepOutput('Wireshark is up and ready to go'),
'No startup message.')
self.assertTrue(self.grepOutput('Capture started'),
'No capture start message.')
self.assertTrue(self.grepOutput('Capture stopped'),
'No capture stop message.')
self.assertTrue(os.path.isfile(testout_file))
if (pipe_returncode == 0):
self.checkPacketCount(8)
def check_dumpcap_autostop_stdin_real(self, packets=None, filesize=None):
# Similar to check_capture_stdin.
testout_file = self.filename_from_id(testout_pcap)
cat100_dhcp_cmd = subprocesstest.cat_dhcp_command('cat100')
condition = 'oops:invalid'
self.assertTrue(packets is not None or filesize is not None,
'Need one of packets or filesize')
self.assertFalse(packets is not None and filesize is not None,
'Need one of packets or filesize')
if packets is not None:
condition = 'packets:{}'.format(packets)
elif filesize is not None:
condition = 'filesize:{}'.format(filesize)
capture_cmd = ' '.join((
cmd_dumpcap,
'-i',
'-',
'-w',
testout_file,
'-a',
condition,
))
pipe_proc = self.assertRun(cat100_dhcp_cmd + ' | ' + capture_cmd,
shell=True)
self.assertTrue(os.path.isfile(testout_file))
if packets is not None:
self.checkPacketCount(packets)
elif filesize is not None:
capturekb = os.path.getsize(testout_file) / 1000
self.assertGreaterEqual(capturekb, filesize)
def check_capture_fifo_real(self, cmd=None):
self.assertIsNotNone(cmd)
testout_file = self.filename_from_id(testout_pcap)
fifo_file = self.filename_from_id('testout.fifo')
try:
# If a previous test left its fifo laying around, e.g. from a failure, remove it.
os.unlink(fifo_file)
except:
pass
os.mkfifo(fifo_file)
slow_dhcp_cmd = subprocesstest.cat_dhcp_command('slow')
fifo_proc = self.startProcess(
('{0} > {1}'.format(slow_dhcp_cmd, fifo_file)),
shell=True)
capture_proc = self.runProcess(capture_command(cmd,
'-i', fifo_file,
'-p',
'-w', testout_file,
'-a', 'duration:{}'.format(capture_duration),
))
fifo_proc.kill()
self.assertTrue(os.path.isfile(testout_file))
capture_returncode = capture_proc.returncode
self.assertEqual(capture_returncode, 0)
if (capture_returncode == 0):
self.checkPacketCount(8)
def check_capture_stdin_real(self, cmd=None):
# Similar to suite_io.check_io_4_packets.
self.assertIsNotNone(cmd)
testout_file = self.filename_from_id(testout_pcap)
slow_dhcp_cmd = subprocesstest.cat_dhcp_command('slow')
capture_cmd = capture_command(cmd,
'-i',
'-',
'-w',
testout_file,
'-a',
'duration:{}'.format(capture_duration),
shell=True)
is_gui = type(cmd) != str and '-k' in cmd[0]
if is_gui:
capture_cmd += ' -o console.log.level:127'
pipe_proc = self.assertRun(slow_dhcp_cmd + ' | ' + capture_cmd,
shell=True)
if is_gui:
self.assertTrue(self.grepOutput('Wireshark is up and ready to go'),
'No startup message.')
self.assertTrue(self.grepOutput('Capture started'),
'No capture start message.')
self.assertTrue(self.grepOutput('Capture stopped'),
'No capture stop message.')
self.assertTrue(os.path.isfile(testout_file))
self.checkPacketCount(8)
def check_dumpcap_autostop_stdin_real(self, packets=None, filesize=None):
# Similar to check_capture_stdin.
testout_file = self.filename_from_id(testout_pcap)
cat100_dhcp_cmd = subprocesstest.cat_dhcp_command('cat100')
condition='oops:invalid'
self.assertTrue(packets is not None or filesize is not None, 'Need one of packets or filesize')
self.assertFalse(packets is not None and filesize is not None, 'Need one of packets or filesize')
if packets is not None:
condition = 'packets:{}'.format(packets)
elif filesize is not None:
condition = 'filesize:{}'.format(filesize)
capture_cmd = ' '.join((cmd_dumpcap,
'-i', '-',
'-w', testout_file,
'-a', condition,
))
pipe_proc = self.runProcess(cat100_dhcp_cmd + ' | ' + capture_cmd, shell=True)
pipe_returncode = pipe_proc.returncode
self.assertEqual(pipe_returncode, 0)
self.assertTrue(os.path.isfile(testout_file))
if (pipe_returncode != 0):
return
if packets is not None:
self.checkPacketCount(packets)
elif filesize is not None:
capturekb = os.path.getsize(testout_file) / 1000
self.assertGreaterEqual(capturekb, filesize)
def check_capture_fifo(self, cmd=None):
if not config.canMkfifo():
self.skipTest('Test requires OS fifo support.')
if cmd == config.cmd_wireshark and not config.canDisplay():
self.skipTest('Test requires a display.')
self.assertIsNotNone(cmd)
capture_file = os.path.join(config.capture_dir, 'dhcp.pcap')
testout_file = self.filename_from_id(testout_pcap)
fifo_file = self.filename_from_id('testout.fifo')
try:
# If a previous test left its fifo laying around, e.g. from a failure, remove it.
os.unlink(fifo_file)
except:
pass
os.mkfifo(fifo_file)
slow_dhcp_cmd = subprocesstest.cat_dhcp_command('slow')
fifo_proc = self.startProcess(
('{0} > {1}'.format(slow_dhcp_cmd, fifo_file)), shell=True)
capture_proc = self.runProcess(
subprocesstest.capture_command(
cmd,
'-i',
fifo_file,
'-p',
'-w',
testout_file,
'-a',
'duration:{}'.format(capture_duration),
))
fifo_proc.kill()
self.assertTrue(os.path.isfile(testout_file))
capture_returncode = capture_proc.returncode
self.assertEqual(capture_returncode, 0)
if (capture_returncode == 0):
self.checkPacketCount(8)
def check_io_4_packets(self, cmd=None, from_stdin=False, to_stdout=False):
# Test direct->direct, stdin->direct, and direct->stdout file I/O.
# Similar to suite_capture.check_capture_10_packets and
# suite_capture.check_capture_stdin.
if cmd == config.cmd_wireshark and not config.canDisplay():
self.skipTest('Test requires a display.')
self.assertIsNotNone(cmd)
capture_file = os.path.join(config.capture_dir, 'dhcp.pcap')
testout_file = self.filename_from_id(testout_pcap)
if from_stdin and to_stdout:
# XXX If we support this, should we bother with separate stdin->direct
# and direct->stdout tests?
self.fail('Stdin and stdout not supported in the same test.')
elif from_stdin:
# cat -B "${CAPTURE_DIR}dhcp.pcap" | $DUT -r - -w ./testout.pcap 2>./testout.txt
cat_dhcp_cmd = subprocesstest.cat_dhcp_command('cat')
stdin_cmd = '{0} | "{1}" -r - -w "{2}"'.format(cat_dhcp_cmd, cmd, testout_file)
io_proc = self.runProcess(stdin_cmd, shell=True)
elif to_stdout:
# $DUT -r "${CAPTURE_DIR}dhcp.pcap" -w - > ./testout.pcap 2>./testout.txt
stdout_cmd = '"{0}" -r "{1}" -w - > "{2}"'.format(cmd, capture_file, testout_file)
io_proc = self.runProcess(stdout_cmd, shell=True)
else: # direct->direct
# $DUT -r "${CAPTURE_DIR}dhcp.pcap" -w ./testout.pcap > ./testout.txt 2>&1
capture_file = os.path.join(config.capture_dir, 'dhcp.pcap')
io_proc = self.runProcess(subprocesstest.capture_command(cmd,
'-r', capture_file,
'-w', testout_file,
))
io_returncode = io_proc.returncode
self.assertEqual(io_returncode, 0)
self.assertTrue(os.path.isfile(testout_file))
if (io_returncode == 0):
self.checkPacketCount(4)
def check_io_4_packets(self, capture_file, cmd=None, from_stdin=False, to_stdout=False):
# Test direct->direct, stdin->direct, and direct->stdout file I/O.
# Similar to suite_capture.check_capture_10_packets and
# suite_capture.check_capture_stdin.
self.assertIsNotNone(cmd)
testout_file = self.filename_from_id(testout_pcap)
if from_stdin and to_stdout:
# XXX If we support this, should we bother with separate stdin->direct
# and direct->stdout tests?
self.fail('Stdin and stdout not supported in the same test.')
elif from_stdin:
# cat -B "${CAPTURE_DIR}dhcp.pcap" | $DUT -r - -w ./testout.pcap 2>./testout.txt
cat_dhcp_cmd = subprocesstest.cat_dhcp_command('cat')
stdin_cmd = '{0} | "{1}" -r - -w "{2}"'.format(cat_dhcp_cmd, cmd, testout_file)
io_proc = self.assertRun(stdin_cmd, shell=True)
elif to_stdout:
# $DUT -r "${CAPTURE_DIR}dhcp.pcap" -w - > ./testout.pcap 2>./testout.txt
stdout_cmd = '"{0}" -r "{1}" -w - > "{2}"'.format(cmd, capture_file('dhcp.pcap'), testout_file)
io_proc = self.assertRun(stdout_cmd, shell=True)
else: # direct->direct
# $DUT -r "${CAPTURE_DIR}dhcp.pcap" -w ./testout.pcap > ./testout.txt 2>&1
io_proc = self.assertRun((cmd,
'-r', capture_file('dhcp.pcap'),
'-w', testout_file,
))
self.assertTrue(os.path.isfile(testout_file))
self.checkPacketCount(4)
def check_capture_fifo(self, cmd=None):
if not config.canMkfifo():
self.skipTest('Test requires OS fifo support.')
if cmd == config.cmd_wireshark and not config.canDisplay():
self.skipTest('Test requires a display.')
self.assertIsNotNone(cmd)
capture_file = os.path.join(config.capture_dir, 'dhcp.pcap')
testout_file = self.filename_from_id(testout_pcap)
fifo_file = self.filename_from_id('testout.fifo')
try:
# If a previous test left its fifo laying around, e.g. from a failure, remove it.
os.unlink(fifo_file)
except:
pass
os.mkfifo(fifo_file)
slow_dhcp_cmd = subprocesstest.cat_dhcp_command('slow')
fifo_proc = self.startProcess(
('{0} > {1}'.format(slow_dhcp_cmd, fifo_file)),
shell=True)
capture_proc = self.runProcess(subprocesstest.capture_command(cmd,
'-i', fifo_file,
'-p',
'-w', testout_file,
'-a', 'duration:{}'.format(capture_duration),
),
env=capture_env
)
fifo_proc.kill()
self.assertTrue(os.path.isfile(testout_file))
capture_returncode = capture_proc.returncode
self.assertEqual(capture_returncode, 0)
if (capture_returncode == 0):
self.checkPacketCount(8)
def check_capture_stdin(self, cmd=None):
# Similar to suite_io.check_io_4_packets.
if cmd == config.cmd_wireshark and not config.canDisplay():
self.skipTest('Test requires a display.')
self.assertIsNotNone(cmd)
capture_file = os.path.join(config.capture_dir, 'dhcp.pcap')
testout_file = self.filename_from_id(testout_pcap)
slow_dhcp_cmd = subprocesstest.cat_dhcp_command('slow')
capture_cmd = subprocesstest.capture_command(cmd,
'-i', '-',
'-w', testout_file,
'-a', 'duration:{}'.format(capture_duration),
shell=True
)
if cmd == config.cmd_wireshark:
capture_cmd += ' -o console.log.level:127'
pipe_proc = self.runProcess(slow_dhcp_cmd + ' | ' + capture_cmd, env=capture_env, shell=True)
pipe_returncode = pipe_proc.returncode
self.assertEqual(pipe_returncode, 0)
if cmd == config.cmd_wireshark:
self.assertTrue(self.grepOutput('Wireshark is up and ready to go'), 'No startup message.')
self.assertTrue(self.grepOutput('Capture started'), 'No capture start message.')
self.assertTrue(self.grepOutput('Capture stopped'), 'No capture stop message.')
self.assertTrue(os.path.isfile(testout_file))
if (pipe_returncode == 0):
self.checkPacketCount(8)
def check_capture_fifo_real(self, cmd=None):
self.assertIsNotNone(cmd)
testout_file = self.filename_from_id(testout_pcap)
fifo_file = self.filename_from_id('testout.fifo')
try:
# If a previous test left its fifo laying around, e.g. from a failure, remove it.
os.unlink(fifo_file)
except Exception:
pass
os.mkfifo(fifo_file)
slow_dhcp_cmd = subprocesstest.cat_dhcp_command('slow')
fifo_proc = self.startProcess(
('{0} > {1}'.format(slow_dhcp_cmd, fifo_file)), shell=True)
capture_proc = self.assertRun(
capture_command(
cmd,
'-i',
fifo_file,
'-p',
'-w',
testout_file,
'-a',
'duration:{}'.format(capture_duration),
))
fifo_proc.kill()
self.assertTrue(os.path.isfile(testout_file))
self.checkPacketCount(8)
def test_rawshark_io_stdin(self, cmd_rawshark, capture_file, io_baseline_str):
'''Read from stdin using Rawshark'''
# tail -c +25 "${CAPTURE_DIR}dhcp.pcap" | $RAWSHARK -dencap:1 -R "udp.port==68" -nr - > $IO_RAWSHARK_DHCP_PCAP_TESTOUT 2> /dev/null
# diff -u --strip-trailing-cr $IO_RAWSHARK_DHCP_PCAP_BASELINE $IO_RAWSHARK_DHCP_PCAP_TESTOUT > $DIFF_OUT 2>&1
capture_file = capture_file('dhcp.pcap')
testout_file = self.filename_from_id(testout_pcap)
raw_dhcp_cmd = subprocesstest.cat_dhcp_command('raw')
rawshark_cmd = '{0} | "{1}" -r - -n -dencap:1 -R "udp.port==68"'.format(raw_dhcp_cmd, cmd_rawshark)
rawshark_proc = self.assertRun(rawshark_cmd, shell=True)
self.assertTrue(self.diffOutput(rawshark_proc.stdout_str, io_baseline_str, 'rawshark', baseline_file))
def test_rawshark_io_stdin(self):
'''Read from stdin using Rawshark'''
# tail -c +25 "${CAPTURE_DIR}dhcp.pcap" | $RAWSHARK -dencap:1 -R "udp.port==68" -nr - > $IO_RAWSHARK_DHCP_PCAP_TESTOUT 2> /dev/null
# diff -u --strip-trailing-cr $IO_RAWSHARK_DHCP_PCAP_BASELINE $IO_RAWSHARK_DHCP_PCAP_TESTOUT > $DIFF_OUT 2>&1
capture_file = os.path.join(config.capture_dir, 'dhcp.pcap')
testout_file = self.filename_from_id(testout_pcap)
raw_dhcp_cmd = subprocesstest.cat_dhcp_command('raw')
rawshark_cmd = '{0} | "{1}" -r - -n -dencap:1 -R "udp.port==68"'.format(raw_dhcp_cmd, config.cmd_rawshark)
rawshark_proc = self.runProcess(rawshark_cmd, shell=True)
rawshark_returncode = rawshark_proc.returncode
self.assertEqual(rawshark_returncode, 0)
if (rawshark_returncode == 0):
self.assertTrue(self.diffOutput(rawshark_proc.stdout_str, baseline_str, 'rawshark', baseline_file))
def check_dumpcap_ringbuffer_stdin(self, packets=None, filesize=None):
# Similar to check_capture_stdin.
cmd = config.cmd_dumpcap
capture_file = os.path.join(config.capture_dir, 'dhcp.pcap')
rb_unique = 'dhcp_rb_' + uuid.uuid4().hex[:6] # Random ID
testout_file = '{}.{}.pcapng'.format(self.id(), rb_unique)
testout_glob = '{}.{}_*.pcapng'.format(self.id(), rb_unique)
cat100_dhcp_cmd = subprocesstest.cat_dhcp_command('cat100')
condition = 'oops:invalid'
self.assertTrue(packets is not None or filesize is not None,
'Need one of packets or filesize')
self.assertFalse(packets is not None and filesize is not None,
'Need one of packets or filesize')
if packets is not None:
condition = 'packets:{}'.format(packets)
elif filesize is not None:
condition = 'filesize:{}'.format(filesize)
capture_cmd = subprocesstest.capture_command(cmd,
'-i',
'-',
'-w',
testout_file,
'-a',
'files:2',
'-b',
condition,
shell=True)
pipe_proc = self.runProcess(cat100_dhcp_cmd + ' | ' + capture_cmd,
shell=True)
pipe_returncode = pipe_proc.returncode
self.assertEqual(pipe_returncode, 0)
if (pipe_returncode != 0):
return
rb_files = glob.glob(testout_glob)
for rbf in rb_files:
self.cleanup_files.append(rbf)
self.assertEqual(len(rb_files), 2)
for rbf in rb_files:
self.assertTrue(os.path.isfile(rbf))
if packets is not None:
self.checkPacketCount(packets, cap_file=rbf)
elif filesize is not None:
capturekb = os.path.getsize(rbf) / 1000
self.assertGreaterEqual(capturekb, filesize)
def test_rawshark_io_stdin(self, cmd_rawshark, capture_file,
io_baseline_str):
'''Read from stdin using Rawshark'''
# tail -c +25 "${CAPTURE_DIR}dhcp.pcap" | $RAWSHARK -dencap:1 -R "udp.port==68" -nr - > $IO_RAWSHARK_DHCP_PCAP_TESTOUT 2> /dev/null
# diff -u --strip-trailing-cr $IO_RAWSHARK_DHCP_PCAP_BASELINE $IO_RAWSHARK_DHCP_PCAP_TESTOUT > $DIFF_OUT 2>&1
capture_file = capture_file('dhcp.pcap')
testout_file = self.filename_from_id(testout_pcap)
raw_dhcp_cmd = subprocesstest.cat_dhcp_command('raw')
rawshark_cmd = '{0} | "{1}" -r - -n -dencap:1 -R "udp.port==68"'.format(
raw_dhcp_cmd, cmd_rawshark)
rawshark_proc = self.assertRun(rawshark_cmd, shell=True)
self.assertTrue(
self.diffOutput(rawshark_proc.stdout_str, io_baseline_str,
'rawshark', baseline_file))
def test_rawshark_io_stdin(self):
'''Read from stdin using Rawshark'''
# tail -c +25 "${CAPTURE_DIR}dhcp.pcap" | $RAWSHARK -dencap:1 -R "udp.port==68" -nr - > $IO_RAWSHARK_DHCP_PCAP_TESTOUT 2> /dev/null
# diff -u --strip-trailing-cr $IO_RAWSHARK_DHCP_PCAP_BASELINE $IO_RAWSHARK_DHCP_PCAP_TESTOUT > $DIFF_OUT 2>&1
capture_file = os.path.join(config.capture_dir, 'dhcp.pcap')
testout_file = self.filename_from_id(testout_pcap)
raw_dhcp_cmd = subprocesstest.cat_dhcp_command('raw')
rawshark_cmd = '{0} | "{1}" -r - -n -dencap:1 -R "udp.port==68"'.format(
raw_dhcp_cmd, config.cmd_rawshark)
rawshark_proc = self.runProcess(rawshark_cmd, shell=True)
rawshark_returncode = rawshark_proc.returncode
self.assertEqual(rawshark_returncode, 0)
if (rawshark_returncode == 0):
self.assertTrue(
self.diffOutput(rawshark_proc.stdout_str, baseline_str,
'rawshark', baseline_file))
def check_dumpcap_ringbuffer_stdin_real(self, packets=None, filesize=None):
# Similar to check_capture_stdin.
rb_unique = 'dhcp_rb_' + uuid.uuid4().hex[:6] # Random ID
testout_file = '{}.{}.pcapng'.format(self.id(), rb_unique)
testout_glob = '{}.{}_*.pcapng'.format(self.id(), rb_unique)
cat100_dhcp_cmd = subprocesstest.cat_dhcp_command('cat100')
condition='oops:invalid'
self.assertTrue(packets is not None or filesize is not None, 'Need one of packets or filesize')
self.assertFalse(packets is not None and filesize is not None, 'Need one of packets or filesize')
if packets is not None:
condition = 'packets:{}'.format(packets)
elif filesize is not None:
condition = 'filesize:{}'.format(filesize)
capture_cmd = ' '.join((cmd_dumpcap,
'-i', '-',
'-w', testout_file,
'-a', 'files:2',
'-b', condition,
))
pipe_proc = self.runProcess(cat100_dhcp_cmd + ' | ' + capture_cmd, shell=True)
pipe_returncode = pipe_proc.returncode
self.assertEqual(pipe_returncode, 0)
if (pipe_returncode != 0):
return
rb_files = glob.glob(testout_glob)
for rbf in rb_files:
self.cleanup_files.append(rbf)
self.assertEqual(len(rb_files), 2)
for rbf in rb_files:
self.assertTrue(os.path.isfile(rbf))
if packets is not None:
self.checkPacketCount(packets, cap_file=rbf)
elif filesize is not None:
capturekb = os.path.getsize(rbf) / 1000
self.assertGreaterEqual(capturekb, filesize)
def check_capture_stdin_real(self, cmd=None):
# Similar to suite_io.check_io_4_packets.
self.assertIsNotNone(cmd)
testout_file = self.filename_from_id(testout_pcap)
slow_dhcp_cmd = subprocesstest.cat_dhcp_command('slow')
capture_cmd = capture_command(cmd,
'-i', '-',
'-w', testout_file,
'-a', 'duration:{}'.format(capture_duration),
shell=True
)
is_gui = type(cmd) != str and '-k' in cmd[0]
if is_gui:
capture_cmd += ' -o console.log.level:127'
pipe_proc = self.assertRun(slow_dhcp_cmd + ' | ' + capture_cmd, shell=True)
if is_gui:
self.assertTrue(self.grepOutput('Wireshark is up and ready to go'), 'No startup message.')
self.assertTrue(self.grepOutput('Capture started'), 'No capture start message.')
self.assertTrue(self.grepOutput('Capture stopped'), 'No capture stop message.')
self.assertTrue(os.path.isfile(testout_file))
self.checkPacketCount(8)
def check_io_4_packets(self,
capture_file,
cmd=None,
from_stdin=False,
to_stdout=False):
# Test direct->direct, stdin->direct, and direct->stdout file I/O.
# Similar to suite_capture.check_capture_10_packets and
# suite_capture.check_capture_stdin.
self.assertIsNotNone(cmd)
testout_file = self.filename_from_id(testout_pcap)
if from_stdin and to_stdout:
# XXX If we support this, should we bother with separate stdin->direct
# and direct->stdout tests?
self.fail('Stdin and stdout not supported in the same test.')
elif from_stdin:
# cat -B "${CAPTURE_DIR}dhcp.pcap" | $DUT -r - -w ./testout.pcap 2>./testout.txt
cat_dhcp_cmd = subprocesstest.cat_dhcp_command('cat')
stdin_cmd = '{0} | "{1}" -r - -w "{2}"'.format(cat_dhcp_cmd, cmd,
testout_file)
io_proc = self.runProcess(stdin_cmd, shell=True)
elif to_stdout:
# $DUT -r "${CAPTURE_DIR}dhcp.pcap" -w - > ./testout.pcap 2>./testout.txt
stdout_cmd = '"{0}" -r "{1}" -w - > "{2}"'.format(
cmd, capture_file('dhcp.pcap'), testout_file)
io_proc = self.runProcess(stdout_cmd, shell=True)
else: # direct->direct
# $DUT -r "${CAPTURE_DIR}dhcp.pcap" -w ./testout.pcap > ./testout.txt 2>&1
io_proc = self.runProcess(
subprocesstest.capture_command(
cmd,
'-r',
capture_file('dhcp.pcap'),
'-w',
testout_file,
))
io_returncode = io_proc.returncode
self.assertEqual(io_returncode, 0)
self.assertTrue(os.path.isfile(testout_file))
if (io_returncode == 0):
self.checkPacketCount(4)
def check_dumpcap_autostop_stdin(self, packets=None, filesize=None):
# Similar to check_capture_stdin.
cmd = config.cmd_dumpcap
capture_file = os.path.join(config.capture_dir, 'dhcp.pcap')
testout_file = self.filename_from_id(testout_pcap)
cat100_dhcp_cmd = subprocesstest.cat_dhcp_command('cat100')
condition = 'oops:invalid'
self.assertTrue(packets is not None or filesize is not None,
'Need one of packets or filesize')
self.assertFalse(packets is not None and filesize is not None,
'Need one of packets or filesize')
if packets is not None:
condition = 'packets:{}'.format(packets)
elif filesize is not None:
condition = 'filesize:{}'.format(filesize)
capture_cmd = subprocesstest.capture_command(cmd,
'-i',
'-',
'-w',
testout_file,
'-a',
condition,
shell=True)
pipe_proc = self.runProcess(cat100_dhcp_cmd + ' | ' + capture_cmd,
shell=True)
pipe_returncode = pipe_proc.returncode
self.assertEqual(pipe_returncode, 0)
self.assertTrue(os.path.isfile(testout_file))
if (pipe_returncode != 0):
return
if packets is not None:
self.checkPacketCount(packets)
elif filesize is not None:
capturekb = os.path.getsize(testout_file) / 1000
self.assertGreaterEqual(capturekb, filesize)
