c10net 0.0.2__tar.gz

c10net-0.0.2/LICENSE

@@ -0,0 +1,28 @@
+BSD 3-Clause License
+
+Copyright (c) 2026, Avionics Test and Analysis Corporation
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this
+   list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution.
+
+3. Neither the name of the copyright holder nor the names of its
+   contributors may be used to endorse or promote products derived from
+   this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

c10net-0.0.2/PKG-INFO

@@ -0,0 +1,132 @@
+Metadata-Version: 2.4
+Name: c10net
+Version: 0.0.2
+Summary: Python utility to make Chapter 10/11 file packets available to network tools or replay as UDP packets.
+Author-Email: Stephen Frees <sfrees@avtest.com>
+License-Expression: BSD-3-Clause
+License-File: LICENSE
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Topic :: Software Development :: Testing :: Traffic Generation
+Classifier: Topic :: System :: Monitoring
+Classifier: Topic :: System :: Networking
+Classifier: Development Status :: 2 - Pre-Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: OS Independent
+Project-URL: Homepage, https://github.com/atac/c10net
+Project-URL: Issues, https://github.com/atac/c10net/issues
+Project-URL: Repository, https://github.com/atac/c10net.git
+Project-URL: Documentation, https://github.com/atac/c10net/blob/main/README.md
+Requires-Python: >=3.9
+Requires-Dist: bitarray>=3.8.0
+Requires-Dist: bitstring>=4.3.1
+Requires-Dist: bitstruct>=8.11.0
+Requires-Dist: colorama>=0.4.6
+Requires-Dist: editables>=0.5
+Requires-Dist: iniconfig>=2.3.0
+Requires-Dist: packaging>=26.0
+Requires-Dist: pluggy>=1.6.0
+Requires-Dist: pychapter10>=1.1.19
+Requires-Dist: Pygments>=2.19.2
+Requires-Dist: pytimedinput>=2.0.1
+Requires-Dist: scapy>=2.7.0
+Provides-Extra: test
+Requires-Dist: pytest>=9.0.2; extra == "test"
+Provides-Extra: dev
+Requires-Dist: pdm_backend>=2.4.7; extra == "dev"
+Provides-Extra: all
+Requires-Dist: c10net[test]; extra == "all"
+Requires-Dist: c10net[dev]; extra == "all"
+Description-Content-Type: text/markdown
+
+# c10net
+
+**Python utility to make Chapter 10/11 file packets available to network tools or replay as UDP packets.**
+
+## Features
+
+- Convert Chapter 10 data into a PCAP file containing UDP packets for analysis.
+- Replay Chapter 10 data over the network, preserving original timing.
+- Filter by channel ID and channel type during conversion or replay.
+- Specify destination port and IP.
+
+## Installation
+
+### Install utility from PyPI:
+
+```bash
+pip install c10net
+```
+
+
+**Note:** `c10net` uses libpcap for pcap packet generation.  
+On Windows, install [Npcap](https://nmap.org/npcap/) and ensure it is available to your system.
+
+### Install for developers (Windows):
+
+```
+git clone https://github.com/atac/c10net
+py -m venv .venv
+.\.venv\Scripts\activate
+pip install -e .[all]
+```
+
+The `[all]` group installs the `[test]` and `[dev]` dependency groups.
+
+## Usage
+
+The package installs a console script `c10net`. Run `c10net -h` for top-level help.
+
+### `convert_pcap`
+
+Convert Chapter 10 file to a PCAP file comprised of UDP packets.
+
+```
+c10net convert_pcap "C:\path\to\myfile.ch10"
+```
+
+With default options, a PCAP file is generated at "C:\path\to\myfile.pcap"
+
+Use `ch10net convert_pcap -h` for more options.
+
+### `replay`
+
+Generate UDP packets from Chapter 10 file and send over a network interface.
+
+```bash
+c10net replay "C:\path\to\myfile.ch10"
+```
+
+With default options, UDP packets are replayed over available network interface with destination IP 127.0.0.1 and port 5006.
+
+Use `ch10net replay -h` for more options.
+
+### Network Options
+
+* Use `--port` to set the destination port number of generated UDP packets.
+* Use `--ip` to set the destination IP address of generated UDP packets.
+
+#### Examples
+
+Convert a Chapter 10 file to PCAP:
+
+```bash
+c10net convert_pcap input.ch10 --out output.pcap
+```
+
+Replay over the network (pulse setup packet every second):
+
+```bash
+c10net replay input.ch10 --pulse --ip 192.168.1.10 --port 49152
+```
+
+## Testing
+
+Run the test suite with `pytest` (after installing the optional `[test]` dependency group):
+
+```bash
+pytest -q
+```
+
+## License
+
+BSD-3-Clause

c10net-0.0.2/README.md

@@ -0,0 +1,92 @@
+# c10net
+
+**Python utility to make Chapter 10/11 file packets available to network tools or replay as UDP packets.**
+
+## Features
+
+- Convert Chapter 10 data into a PCAP file containing UDP packets for analysis.
+- Replay Chapter 10 data over the network, preserving original timing.
+- Filter by channel ID and channel type during conversion or replay.
+- Specify destination port and IP.
+
+## Installation
+
+### Install utility from PyPI:
+
+```bash
+pip install c10net
+```
+
+
+**Note:** `c10net` uses libpcap for pcap packet generation.  
+On Windows, install [Npcap](https://nmap.org/npcap/) and ensure it is available to your system.
+
+### Install for developers (Windows):
+
+```
+git clone https://github.com/atac/c10net
+py -m venv .venv
+.\.venv\Scripts\activate
+pip install -e .[all]
+```
+
+The `[all]` group installs the `[test]` and `[dev]` dependency groups.
+
+## Usage
+
+The package installs a console script `c10net`. Run `c10net -h` for top-level help.
+
+### `convert_pcap`
+
+Convert Chapter 10 file to a PCAP file comprised of UDP packets.
+
+```
+c10net convert_pcap "C:\path\to\myfile.ch10"
+```
+
+With default options, a PCAP file is generated at "C:\path\to\myfile.pcap"
+
+Use `ch10net convert_pcap -h` for more options.
+
+### `replay`
+
+Generate UDP packets from Chapter 10 file and send over a network interface.
+
+```bash
+c10net replay "C:\path\to\myfile.ch10"
+```
+
+With default options, UDP packets are replayed over available network interface with destination IP 127.0.0.1 and port 5006.
+
+Use `ch10net replay -h` for more options.
+
+### Network Options
+
+* Use `--port` to set the destination port number of generated UDP packets.
+* Use `--ip` to set the destination IP address of generated UDP packets.
+
+#### Examples
+
+Convert a Chapter 10 file to PCAP:
+
+```bash
+c10net convert_pcap input.ch10 --out output.pcap
+```
+
+Replay over the network (pulse setup packet every second):
+
+```bash
+c10net replay input.ch10 --pulse --ip 192.168.1.10 --port 49152
+```
+
+## Testing
+
+Run the test suite with `pytest` (after installing the optional `[test]` dependency group):
+
+```bash
+pytest -q
+```
+
+## License
+
+BSD-3-Clause

c10net-0.0.2/pyproject.toml

@@ -0,0 +1,69 @@
+[project]
+name = "c10net"
+version = "0.0.2"
+authors = [
+    { name = "Stephen Frees", email = "sfrees@avtest.com" },
+]
+description = "Python utility to make Chapter 10/11 file packets available to network tools or replay as UDP packets."
+classifiers = [
+    "Programming Language :: Python :: 3 :: Only",
+    "Topic :: Software Development :: Testing :: Traffic Generation",
+    "Topic :: System :: Monitoring",
+    "Topic :: System :: Networking",
+    "Development Status :: 2 - Pre-Alpha",
+    "Intended Audience :: Developers",
+    "Operating System :: OS Independent",
+]
+readme = "README.md"
+requires-python = ">=3.9"
+license = "BSD-3-Clause"
+license-files = [
+    "LICEN[CS]E*",
+]
+dependencies = [
+    "bitarray>=3.8.0",
+    "bitstring>=4.3.1",
+    "bitstruct>=8.11.0",
+    "colorama>=0.4.6",
+    "editables>=0.5",
+    "iniconfig>=2.3.0",
+    "packaging>=26.0",
+    "pluggy>=1.6.0",
+    "pychapter10>=1.1.19",
+    "Pygments>=2.19.2",
+    "pytimedinput>=2.0.1",
+    "scapy>=2.7.0",
+]
+
+[project.optional-dependencies]
+test = [
+    "pytest>=9.0.2",
+]
+dev = [
+    "pdm_backend>=2.4.7",
+]
+all = [
+    "c10net[test]",
+    "c10net[dev]",
+]
+
+[project.urls]
+Homepage = "https://github.com/atac/c10net"
+Issues = "https://github.com/atac/c10net/issues"
+Repository = "https://github.com/atac/c10net.git"
+Documentation = "https://github.com/atac/c10net/blob/main/README.md"
+
+[project.scripts]
+c10net = "c10net:__main__"
+
+[build-system]
+requires = [
+    "pdm-backend >= 2.4.0",
+]
+build-backend = "pdm.backend"
+
+[tool.pytest.ini_options]
+addopts = "--import-mode=importlib"
+testpaths = [
+    "tests",
+]

c10net-0.0.2/src/c10net/__main__.py

@@ -0,0 +1,3 @@
+from .c10net import *
+
+cli_entry()

c10net-0.0.2/src/c10net/c10net.py

@@ -0,0 +1,159 @@
+'''
+Main entry for the c10net tools.
+
+This module manages CLI arguments to coordinate module initialization.
+'''
+
+import sys
+from threading import Thread, Event
+from pathlib import Path
+
+from pytimedinput import timedKey
+
+from . import cli
+from . import chapter10_to_pcap
+from . import chapter10_to_replay
+from .tasks import parse_chapter10 as parse_ch10
+from .tasks import chapter10_to_ethernet as ch10_to_eth
+from .tasks import write_to_pcap as write_to_pcap
+
+_source_thread = None # Reference to the source thread to determine finished condition
+_threads = []  # List to keep track of threads for cleanup
+_terminate_events = []  # List to keep track of termination events for killing threads
+_finish_events = [] # List to keep track of finish events for clean shutdown of threads
+
+should_terminate = Event()
+should_finish = False
+
+
+def cli_entry():
+    args = cli.get_cli_parser().parse_args(sys.argv[1:])
+    
+    #print(args)
+
+    if (args.command == cli.command_replay):
+        stage_replay(args)
+    elif (args.command == cli.command_convert_pcap):
+        if not args.outfile:
+            args.outfile = _get_default_pcap_out_filepath_from_infile(args.in_pathname)
+        stage_capture_pcap(args)
+    else:
+        print("No command given. Use -h for help.")
+        sys.exit(1)
+
+    run()
+
+    global should_terminate
+    if (should_terminate.is_set()):
+        terminate_all_threads()
+        
+    for thread in _threads:
+        thread.join()  # Wait for all threads to finish
+
+
+def run():
+    global _threads
+
+    for thread in _threads:
+        thread.start()
+
+    wait_for_keypress_with_confirmation()
+
+def wait_for_keypress_with_confirmation(prompt_key="Esc", confirm_prompt="Are you sure? (y/n): "):
+    """Wait for a specific user keypress, then prompt for confirmation before returning."""
+    global should_terminate
+
+    print(f"Press {prompt_key} to exit...")
+
+    while not should_terminate.is_set() and not finished():
+        # Wait for the keypress
+        key_pressed, key_timeout = timedKey(prompt_key, timeout=1)
+
+        if (not key_timeout):
+            # Prompt for confirmation
+            response = input(confirm_prompt).strip().lower()
+            if response in ('y', 'yes'):
+                should_terminate.set()
+
+def finished():
+    """If source thread is done, set finish events. Returns True if finished."""
+    global _source_thread, should_finish
+
+    if (not should_finish and _source_thread and not _source_thread.is_alive()):
+        should_finish = True
+        for event in _finish_events:
+            event.set()
+
+    for thread in _threads:
+        if thread.is_alive():
+            return False
+
+    return True
+
+def terminate_all_threads():
+    """Set all termination events to signal threads to exit."""
+    for event in _terminate_events:
+        event.set()
+
+
+
+def stage_capture_pcap(cli_args):
+    #if (cli_args.parallel): # TODO: test this process again
+    if (False):
+        _threads.append(Thread(
+            target=parse_ch10.parse_file,
+            args=(
+                cli_args.channel_ids,
+                cli_args.channel_types,
+                cli_args.in_pathname,
+                ch10_to_eth.deposit_chapter10_packets
+            )))
+        _threads.append(Thread(
+            target=ch10_to_eth.build_ethernet_packets,
+            args=(cli_args, write_to_pcap.deposit_ethernet_packets)
+            ))
+        _threads.append(Thread(
+            target=write_to_pcap.write_packets_to_pcap,
+            args=(cli_args.outfile,)
+            ))
+
+        _terminate_events.append(parse_ch10.terminate)
+        _terminate_events.append(ch10_to_eth.terminate)
+        _terminate_events.append(write_to_pcap.terminate)
+
+        _finish_events.append(ch10_to_eth.finish)
+        _finish_events.append(write_to_pcap.finish)
+
+        global _source_thread
+        _source_thread = _threads[0]
+    else:
+        chapter10_to_pcap.run_task(cli_args)
+        sys.exit(0)
+    
+
+
+def stage_replay(cli_args):
+    None
+    # TODO: implement
+    #source_sink = (parse_ch10.retreive_packets, send_udp.deposit_packets)
+    # _threads.append(Thread(target=parse_ch10.parse_file, args=(args)))
+    # _threads.append(Thread(target=pipe_packets, args=source_sink))
+    # _threads.append(Thread(target=send_udp.replay_packets, args=(args)))
+
+    # _terminate_events.append(parse_ch10.terminate_event)
+    # _terminate_events.append(send_udp.terminate_event)
+
+    # _source_thread = _threads[0]
+    #if (cli_args.parallel):
+    if (False):
+        None
+    else:
+        chapter10_to_replay.run_task(cli_args)
+        sys.exit(0)
+
+
+def _get_default_pcap_out_filepath_from_infile(in_pathname):
+    inpath = Path(in_pathname)
+    result = inpath.with_suffix('.pcap')
+    return str(result)
+

c10net-0.0.2/src/c10net/chapter10_to_pcap.py

@@ -0,0 +1,53 @@
+
+import os
+
+from chapter10 import C10
+
+from .tasks import parse_chapter10 as pc10
+from .tasks import write_to_pcap as w2pcap
+
+from .functions import ethernet_packet_generator as ethernet_gen
+from .functions import progress_bar as bar
+
+
+def run_task(cli_args):
+    eth_gen = ethernet_gen.EthernetGenerator(cli_args)
+    pcap = w2pcap.PcapWriter(cli_args.outfile, append=False)
+
+    pc10._set_filter_parameters(
+        cli_args.channel_ids,
+        cli_args.channel_types
+    )
+
+    file_pos = 0.0
+    size = os.path.getsize(cli_args.in_pathname)
+    bar.set_bounds(0, size)
+
+    have_time = False
+    buf = []
+
+    for packet in C10(cli_args.in_pathname):
+        file_pos += packet.packet_length
+        bar.update_progress(file_pos)
+
+        if (not have_time):
+            if (packet.parent and packet.parent.last_time is not None):
+                have_time = True
+            else:
+                buf.append(packet)
+                continue
+
+        if (len(buf) > 0):
+            for p in buf:
+                p.parent.last_time = packet.parent.last_time
+                if (pc10._passes_filter(p.channel_id, p.data_type)):
+                    eth_packets = eth_gen.generate_from_chapter10(p)
+                    pcap.write(eth_packets)
+            buf = []
+
+        if (pc10._passes_filter(packet.channel_id, packet.data_type)):
+            eth_packets = eth_gen.generate_from_chapter10(packet)
+            pcap.write(eth_packets)
+    
+    pcap.flush()
+    pcap.close()

c10net-0.0.2/src/c10net/chapter10_to_replay.py

@@ -0,0 +1,76 @@
+
+import os
+
+from chapter10 import C10, packet
+
+from .tasks import parse_chapter10 as pc10
+from .tasks import udp_replay as replay
+
+from .functions import ethernet_packet_generator as ethernet_gen
+from .functions import progress_bar as bar
+from .functions import packet_pulser as pulser
+
+
+
+def run_task(cli_args):
+    eth_gen = ethernet_gen.EthernetGenerator(cli_args)
+
+    setup_pulser = None
+    use_pulse = False
+    pulse_interval = 1.0
+    if cli_args.pulse or cli_args.pulse_interval:
+        use_pulse = True
+        if (cli_args.pulse_interval):
+            pulse_interval = cli_args.pulse_interval
+    
+    pc10._set_filter_parameters(
+        cli_args.channel_ids,
+        cli_args.channel_types,
+        use_pulse
+    )
+
+    have_time = False
+    buf = []
+
+    file_pos = 0.0
+    size = os.path.getsize(cli_args.in_pathname)
+    bar.set_bounds(0, size)
+
+    file = C10(cli_args.in_pathname)
+
+    for packet in file:
+        file_pos += packet.packet_length
+        bar.update_progress(file_pos)
+
+        if use_pulse:
+            if not setup_pulser:
+                if packet.channel_id == 0 and packet.data_type == 0x01:
+                    setup_pulser = pulser.PacketPulser(packet)
+                    setup_pulser.set_interval(pulse_interval)
+            else:
+                setup_packet = setup_pulser.check_pulse()
+                if not setup_packet is None:
+                    buf.append(setup_packet)
+
+        if (not have_time):
+            if (packet.parent and packet.parent.last_time is not None):
+                have_time = True
+            else:
+                buf.append(packet)
+                continue
+
+        if (len(buf) > 0):
+            for p in buf:
+                p.parent.last_time = packet.parent.last_time
+                if (pc10._passes_filter(p.channel_id, p.data_type)):
+                    eth_packets = eth_gen.generate_from_chapter10(p)
+                    for eth in eth_packets:
+                        replay.replay_packet_with_timestamp(eth)
+            buf = []
+
+        if (pc10._passes_filter(packet.channel_id, packet.data_type)):
+            eth_packets = eth_gen.generate_from_chapter10(packet)
+            for eth in eth_packets:
+                replay.replay_packet_with_timestamp(eth)
+            
+