Linux as a Network Printer Device: Sharing USB Printers via Raw Port 9100

At revWhiteShadow, we understand the persistent need to optimize and extend the functionality of existing hardware. Many organizations and individuals possess reliable USB printers that, while perfectly functional, lack native network connectivity. The desire to transform a directly connected USB printer into a fully accessible network resource, indistinguishable from an “autonomous” network printer, is a common and achievable goal. This article delves into the comprehensive process of configuring a Linux machine, specifically emphasizing Debian-based distributions, to act as a robust network printer device, emulating the behavior of HP Jetdirect and making your USB printer available to any network client, including systems like AIX that communicate via the Raw protocol on port 9100.

Understanding the Network Printer Paradigm

Traditionally, “autonomous” network printers are self-contained devices with integrated network interfaces. They possess their own IP addresses and directly listen for print jobs on specific network ports. The most prevalent protocol for direct raw print job submission is Raw, often associated with port 9100, commonly implemented by the HP Jetdirect protocol. This method bypasses the need for host-based print spooling software on the client side, directly sending print data to the printer’s internal formatter.

The challenge, therefore, is to replicate this direct network-to-printer communication using a standard Linux computer as an intermediary. This involves setting up the Linux system to receive print jobs over the network on the designated Raw port and then transparently forward these jobs to the connected USB printer. This effectively turns your Linux box into a sophisticated print server, presenting a familiar interface to network clients accustomed to autonomous network printers.

Why Choose Linux for Network Printer Emulation?

Linux’s inherent flexibility, open-source nature, and powerful networking capabilities make it an ideal platform for creating custom network services. Unlike proprietary solutions, Linux allows for fine-grained control over every aspect of the process, ensuring compatibility and adaptability.

  • Cost-Effectiveness: Leveraging existing Linux hardware drastically reduces the cost associated with purchasing dedicated network print servers or new network-enabled printers.
  • Customization and Control: Linux provides unparalleled control over network configurations, port management, and printer driver integration.
  • Ubiquitous Compatibility: By emulating standard protocols like Raw/Jetdirect, your Linux-based print device will be compatible with a vast array of client operating systems and devices, including older or specialized systems like AIX.
  • Reliability and Stability: Linux is renowned for its stability and uptime, making it a dependable solution for continuous network printing.
  • Security: Linux offers robust security features that can be tailored to protect your network print environment.

Core Components for Linux Network Printer Emulation

To achieve the desired functionality, we will need to configure several key components within our Linux system:

  1. USB Printer Configuration: Ensuring the USB printer is correctly recognized and functional under Linux.
  2. Network Listening Service: A service that listens for incoming connections on port 9100.
  3. Print Job Redirection: A mechanism to capture the incoming raw print data and send it to the USB printer.
  4. Printer Driver: The appropriate Linux printer driver for your specific USB printer.

Step-by-Step Configuration Guide

We will now outline a comprehensive, step-by-step process to transform your Debian Linux system into a network printer device that supports Raw/port 9100.

### Setting Up the USB Printer in Linux

Before we can configure network access, we must ensure the USB printer is properly detected and usable within the Linux environment.

  1. Physical Connection: Connect your USB printer to an available USB port on your Linux machine.
  2. System Detection: Upon connection, your Linux system should ideally detect the printer automatically. You can verify this by checking the output of lsusb in the terminal. This command will list all USB devices connected to the system.
  3. Printer Driver Installation: This is a crucial step. Most modern printers are supported out-of-the-box by Linux or through the CUPS (Common Unix Printing System) framework.
    • Using CUPS: CUPS is the de facto standard for printing in Linux. If it’s not already installed, you can install it with:
      sudo apt update
sudo apt install cups
    • Adding the Printer: After installing CUPS, you can add your printer through its web interface. Open a web browser and navigate to http://localhost:631. Go to the “Administration” tab, then “Add Printer”. CUPS will scan for connected printers. Select your USB printer from the list and follow the on-screen prompts to select the appropriate printer driver. If your specific model isn’t listed, you may need to find and install a PPD (PostScript Printer Description) file for it. Websites like OpenPrinting.org are excellent resources for finding Linux printer drivers.
    • Testing the Printer: Once added, you should be able to send a test page from the CUPS web interface to confirm the printer is functioning correctly via USB. Note the device URI assigned to your printer within CUPS. It will typically look something like /dev/usb/lp0 or similar.

### Installing and Configuring the Raw Listening Service

The core of our network printer emulation lies in a service that listens for incoming connections on port 9100 and redirects the data. For this, netcat (or nc) is an incredibly versatile tool, but a more robust and persistent solution is often preferred. We will explore using socat, a powerful command-line utility that establishes bidirectional data transfers between two addresses. socat can be configured to listen on a TCP port and forward data to another destination, which in our case will be the USB printer’s communication device.

  1. Install socat:

    sudo apt update
sudo apt install socat

  2. Identify the Printer’s Device File: As mentioned in the CUPS setup, your USB printer will be represented by a device file in /dev/. Common names include /dev/usb/lp0, /dev/usb/lp1, etc. You can also find this information within CUPS under the printer’s “Properties” or “Administration” section. If you’re unsure, dmesg | grep usb after plugging in the printer can sometimes provide clues.

  3. Configuring socat for Raw Port 9100: The goal is to have socat listen on TCP port 9100 and pipe any incoming data directly to the printer’s device file. The command structure for this is:

    socat TCP-LISTEN:9100,fork,reuseaddr FILE:/dev/usb/lp0,create,mode=0660,owner=lp,group=lp

    Let’s break down this command:

    • TCP-LISTEN:9100: This tells socat to listen for incoming TCP connections on port 9100.
    • fork: This option allows socat to fork a new process for each incoming connection, ensuring that multiple clients can connect concurrently without interfering with each other.
    • reuseaddr: This option allows the socket to be reused immediately after it’s closed, preventing “Address already in use” errors.
    • FILE:/dev/usb/lp0: This specifies the output destination. Replace /dev/usb/lp0 with the actual device file for your printer.
    • create,mode=0660,owner=lp,group=lp: These are options for the FILE destination. create attempts to create the file if it doesn’t exist (though for device files, it’s usually already there). mode=0660 sets the file permissions, and owner=lp,group=lp assigns ownership to the lp user and group, which is standard for printer access in CUPS.

  4. Making socat Run as a Service (Systemd): Running socat directly from the terminal is temporary. To make this persistent and ensure it starts automatically on boot, we should create a systemd service unit.

    • Create a service file:

      sudo nano /etc/systemd/system/rawprinter.service

    • Paste the following content into the file:

      [Unit]
Description=Raw Printer Port 9100 Service
After=network.target

[Service]
ExecStart=/usr/bin/socat TCP-LISTEN:9100,fork,reuseaddr FILE:/dev/usb/lp0,create,mode=0660,owner=lp,group=lp
Restart=on-failure
RestartSec=5
User=lp
Group=lp

[Install]
WantedBy=multi-user.target

      Important: Remember to replace /dev/usb/lp0 with the correct device file for your printer. Also, ensure the User and Group match the user/group that has access to the printer device file, typically lp.

    • Save and exit the editor (Ctrl+X, Y, Enter in nano).

    • Reload systemd, enable and start the service:

      sudo systemctl daemon-reload
sudo systemctl enable rawprinter.service
sudo systemctl start rawprinter.service

    • Check the service status:

      sudo systemctl status rawprinter.service

      This should show the service as “active (running)”. If there are errors, the status output will provide clues.

### Configuring CUPS to Use the Network Port (Optional but Recommended)

While socat directly handles the raw port, it’s good practice to also inform CUPS about this setup. This can help in managing the printer within the Linux system and ensuring it’s properly recognized by the operating system’s printing subsystem. However, for strict emulation of a “dumb” network printer device, this step might be considered optional as the AIX client will directly talk to the socat process.

If you wish to integrate this more deeply with CUPS, you can create a network printer queue in CUPS that points to the socat service.

  1. Go to CUPS Web Interface: http://localhost:631.
  2. Administration -> Add Printer.
  3. Connection: Instead of selecting a direct USB connection, choose “Other network printer”.
  4. Protocol: Select “Raw TCP/IP Printing (Port 9100)”.
  5. Device URI: Enter socket://localhost:9100 or socket://your_linux_ip:9100.
  6. Follow the prompts to select the appropriate printer model and driver as you did for the USB connection.

This configuration makes the printer accessible through CUPS as well, allowing for local printing jobs to be sent over the network port.

### Testing the Network Printer from AIX

Now comes the moment of truth: testing the setup from your AIX system. The netcat command you provided is the perfect tool for this.

  1. Identify the Linux Machine’s IP Address: On your Debian Linux server, find its IP address using ip addr show or hostname -I. Let’s assume your Linux machine’s IP address is 192.168.1.100.

  2. From your AIX system, use netcat:

    nc 192.168.1.100 9100

    You should see a blank prompt, indicating that netcat has successfully connected to the socat service listening on port 9100 on your Linux machine.

  3. Send Print Data: Now, you can type any text directly, or even better, send a file’s content. For example, to print a simple text file named my_report.txt on AIX:

    cat my_report.txt | nc 192.168.1.100 9100

    Alternatively, if you want to send a PostScript file (e.g., document.ps):

    cat document.ps | nc 192.168.1.100 9100

    The crucial part is that the data sent via netcat on AIX is treated as raw print data and is directly piped by socat to the USB printer. The printer’s internal controller interprets this data and prints it.

  4. Observe the Printer: Your USB printer connected to the Linux machine should now start printing the content you sent from AIX.

Advanced Considerations and Troubleshooting

While the above steps provide a solid foundation, several advanced points and common issues might arise:

  • Printer Compatibility with Raw Data: Not all printers are capable of processing raw data effectively without a specific page description language (like PostScript or PCL) being sent. If you’re sending plain text and it’s not printing, ensure your printer has a robust text mode or try sending a simple PostScript or PCL file. The CUPS driver you selected earlier is what translates the job into the printer’s native language when sent through CUPS. When using socat directly, you are sending the raw interpretation of what the driver would have sent. If you are sending plain text, it’s likely the printer expects ASCII commands.
  • Firewall Rules: Ensure that your Linux machine’s firewall (e.g., ufw or iptables) is configured to allow incoming traffic on TCP port 9100.
    • Using ufw:
      sudo ufw allow 9100/tcp
sudo ufw reload
  • Permissions: Double-check that the user and group specified in the socat service file (User=lp, Group=lp) have read/write permissions to the printer device file (/dev/usb/lp0). You can check permissions with ls -l /dev/usb/lp0. If necessary, you can adjust ownership or group membership, but ensure you understand the security implications.
  • CUPS Backend for Raw Printing: CUPS itself has a backend specifically for raw printing. If you configure the CUPS queue as described in the optional step, you can also use lpadmin or modify the queue configuration to use the raw backend directly, which might offer more structured management.
  • Multiple Printers: If you need to share multiple USB printers, you would need to run multiple socat instances, each listening on a different port (e.g., 9100, 9101, 9102), and each associated with its respective USB printer device file. Each socat service would need its own systemd unit file.
  • AIX Printer Configuration: On the AIX side, you will configure your printer queue to use the IP address of your Linux machine and port 9100. The specific method for this will depend on the AIX version and its printer configuration tools. The netcat command is a direct test, but for regular printing, you’ll configure AIX’s print spooler.
  • Printer Driver on AIX: When configuring the printer on AIX, you will need to select a printer driver that is compatible with the type of data your Linux system is sending. If you are relying on socat to send raw data, AIX may need a driver that sends generic raw data. If you integrate with CUPS on Linux and configure AIX to use that, AIX might expect a specific protocol that CUPS can then translate. However, for true emulation of an “autonomous” device talking Raw/9100, AIX will be sending raw job data.

Conclusion: Embracing Linux for Network Printing Excellence

By meticulously following these steps, you can effectively transform a standard Linux machine into a highly capable network printer device, seamlessly sharing your USB printer with any client on the network, including legacy systems like AIX that communicate via the Raw protocol on port 9100. This approach not only revitalizes existing hardware but also demonstrates the remarkable versatility and power of Linux in creating custom network solutions.

At revWhiteShadow, we champion such practical implementations that leverage technology to its fullest potential. This method offers a cost-effective, reliable, and highly customizable way to expand your printing infrastructure, proving that with the right configuration, even the simplest peripherals can become sophisticated network resources. The ability to emulate HP Jetdirect compatibility ensures broad interoperability, making this a robust solution for diverse computing environments. We are confident that this detailed guide will empower you to successfully establish your Linux-based network printer device, enhancing your network’s printing capabilities significantly.