[Link].

com

DebuggingPrintingProblems -
Ubuntu Wiki
26–33 minutes

Debugging This page is part of the debugging series —

Central pages with debugging details for a variety of
Ubuntu packages.

Contents

1. Reporting Bugs

2. Printer detection
1. USB printer

2. Parallel port printer

3. Network printer

4. USB -> Parallel adapter

3. CUPS web interface

4. CUPS error_log

5. Troubleshooting Wizard

6. Print Error pop-up window

7. AppArmor Protection of the printing system

8. Capturing print job data

9. Getting the data which would go to the printer

10. Sending a file to the printer unfiltered

11. PostScript (PDF) printer chokes on the PostScript (PDF) coming

from Ubuntu

12. USB printer does not print or prints garbage

13. Problems installing the CUPS package

14. Turboprint

15. Known bugs

Reporting Bugs

Bugs about printing problems should be assigned to the cups

package if you don't know which package they belong to. To
report printing bugs preferably use 'ubuntu-bug cups' from a
terminal window which will gather useful information about your
system related to printing like the version of Ubuntu you use,
configured printers and the versions of important printing
packages installed and automatically attach them to your bug
report. You can also add the information after the bug is reported
by executing 'apport-collect -p cups BUGNUMBER' where
BUGNUMBER is the bug report you want to add information to.

Printer detection

NOTE: If you have a USB -> Parallel adapter, proceed as for a

USB printer and also see the "USB -> Parallel adapter" section
below.

USB printer

1. Make sure that the printer is connected to your system and

powered on.

2. Open a terminal/console and check if the usb kernel modules are

loaded:
$ lsmod | grep usb

3. Unplug the USB printer cable from your computer and enter this
command:
$ tail ‐f /var/log/syslog

4. Reconnect the USB printer cable, you should see some

messages appearing.
 5. Press Ctrl-C to stop the logging.

6. Check whether the printer gets correctly detected by the USB

subsystem and determine its USB vendor/product IDs and the
USB bus and device addresses:
$ lsusb
Note: The USB bus and device addresses change if you turn off
or unplug the printer. Please re-run this command if needed.

7. Check whether the device files for the printer get created and the
ownerships ("root lp") and permissions (non-HP: "crw-rw-r--", HP:
"crw-rw-r--+") correctly set:
$ ls ‐l /dev/usb/lp* /dev/bus/usb/*/*

8. Determine the printer's device ID strings:

$ sudo usb_printerid /dev/usb/lp0
$ sudo usb_printerid /dev/usb/lp1
...
For HP printers also use
$ hp‐info ‐i
and choose the printer with the problem from the text menu, then
copy the "deviceid" entry from the output (can be several lines).

9. For HP printers: Check that you have the latest version of HPLIP
and whether HPLIP connects to them:
$ hp‐makeuri <Bus>:<Device>
Replace "<Bus>" and "<Device>" by the bus and device numbers
from the "lsusb" output (not vendor and product ID). The numbers
must be supplied with three digits, zero-padded from the left, like
"008:015". (More information from [Link]

10. Find out if your printer gets detected by CUPS:

$ lpinfo ‐v

11. Attach the output of the above commands to the bug report.

Note that problems cannot only caused by CUPS but also by the
kernel (package "linux"), libusb, HPLIP (package "hplip"), and
several third-party printer drivers.
 Parallel port printer

1. Make sure that the printer is connected to your system and

powered on.

2. Open a terminal/console and check if the lp, ppdev, and

parport_pc kernel modules are loaded:
$ lsmod | grep lp
$ lsmod | grep ppdev
$ lsmod | grep parport_pc

3. Check if the kernel detected the parallel port during bootup:

$ dmesg | grep par

4. Check if the device files of the parallel port(s) are created and
have the correct permissions and ownerships:
$ ls ‐l /dev/lp* /dev/parport*

5. Check if the printer auto-detection result appears in the kernel's

virtual file system:
$ ls ‐l /proc/sys/dev/parport/parport*/autoprobe*
$ sudo cat /proc/sys/dev/parport/parport*/
autoprobe*

6. Find out if your printer gets detected by CUPS:

$ lpinfo ‐v

7. Run the parallel port CUPS backend separately, once with

standard user privileges and once as root:
$ /usr/lib/cups/backend/parallel
$ sudo /usr/lib/cups/backend/parallel

8. Attach the output of the above commands to the bug report.

Note that problems can be caused not only by CUPS, but also by
the kernel (package "linux"), HPLIP (package "hplip"), and
several third-party printer drivers.

Network printer

1. Make sure the printer is turned on and connected to your

network. In the case of a WLAN (wireless) printer the printer
 needs to be configured to use your wireless network.

2. Check the printer's configuration by printing a configuration page

via the printer's front panel menus. This gives information about
the IP address of the printer and about the protocols it supports
(JetDirect/AppSocket, LPD, IPP, SMB/Windows, ...).

3. You can also find the printer's IP address via the configuration
web interface of your router. Many routers you can configure that
the printer always gets the same IP and you can also assign a
host name.

4. To change the printer's configuration either use the printer's front

panel menus or the printer's web configuration interface. To
access this web interface, enter the IP address of the printer into
the address or URL line of a web browser.

5. If your printer is supposed to connect via WLAN and it does not

get an IP address, make sure that your WLAN is turned on and
that the correct network name (SSID) and password are set by
the front panel menus of the printer. If the printer has no front
panel menus, you have to connct it with an ethernet cable first
and configure the WLAN access through the web interface. On
some HP printers there is WLAN connection but no ethernet
connection. These you have to connect via USB and then use the
hp-wificonfig tool from the hplip-gui package to configure them.

6. Set up the printer via system-config-printer ("Add" button). Wait

around 15 seconds for the network scan (spinning icon must
disappear). Usually you should select the default connection type
as system-config-printer tries to find the best possibility. Generally
use HP printers through the HPLIP connection, other printers
preferably with DNS-SD connections (will continue to work whn
the router changes the IP of the printer) and from the protocols
use preferably AppSocket/jetDirect. The implementation of IPP in
the printer's firmware has often bugs. Make sure the desired
protocols and DNS-SD/mDNS/BonJour support are active in the
printer's hardware configuration.
 7. Open a terminal/console and run the commands:
$ ping <IP of the printer>
$ nmap <IP of the printer>
Replace "<IP of the printer>" by the printer's IP address. The first
command checks whether you can access the printer through the
network, the second shows which port numbers are used by the
printer and through this which protocols are active (80: Has web
interface, 139: SMB, 443: encrypted IPP or encrypted web
interface, 515: LPD, 631: IPP, 9100: JetDirect/AppSocket). Install
the "nmap" package if needed.

8. Run the commands:

$ /usr/lib/cups/backend/snmp
$ sudo /usr/lib/cups/backend/dnssd
The output shows whether the printers get found by CUPS or
system-config-printer and with which device URIs and protocols.

9. Run the command

$ /usr/lib/cups/backend/snmp <IP of the printer>
if a printer does not get found by the simple "/usr/lib/cups/
backend/snmp" call.

10. Find out if your printer gets detected by CUPS:

$ lpinfo ‐v

11. Run the commands:

$ avahi‐browse ‐a ‐v ‐t ‐r
$ avahi‐browse ‐a ‐v ‐c ‐r
These commands show whether your printer is visible via DNS-
SD/mDNS/BonJour.

12. Run
$ ifconfig
$ route
to check general network health.

13. Attach the output of the above commands to the bug report.

Note that problems cannot only caused by CUPS but also by the
kernel (package "linux"), HPLIP (package "hplip"), and several
 third-party printer drivers.

USB -> Parallel adapter

We highly recommend not to buy and use these adapters to get

old parallel-only printers connected to newer computers without
parallel port. Please try the following alternatives:

1. First check whether the printer is really parallel-only. If it has a

USB or Ethernet port, use one of these for connection. If you do
not have free USB ports on your computer, use a USB hub.

2. If you have already a USB -> Parallel adapter and you have an
All-in-One router (or NAS) with USB port, try to connect the
printer with the adapter there, if the router has print server
functionality, your printer should appear as a network printer.

3. You can also get an old JetDirect (or compatible) network print
box on eBay or Amazon for cheap, which also makes a network
printer out of your printer.

4. At least with USB -> Parallel adapters you can use with a Ubuntu
machine proceeding as follows: Make sure that there is no other
native USB printer or printer with USB -> Parallel adapter
connected. This works only with one single printer on USB. Set
up the printer with the device URI "parallel:/dev/usb/lp0", either by
selecting "Enter URI" on the first page of the add-printer wizard of
system-config-printer, or by right-clicking the icon of an existing
(non-working) print queue, choosing "Properties" in the pop-up
menu, and editing the "Device URI" field in the properties dialog.
Note that you have to select printer manufacturer and model
manually when adding a new printer.

Note that if the alternative you choose makes a network printer

out of your printer that system-config-printer should find it as a
network printer (wait for the scan to finish when the spinning icon
disappears, then open the "Network printer" section). Perhaps
you will need to choose make and model of the printer manually
to finish the setup.
 CUPS web interface

The CUPS web interface at [Link] provides some

useful messages and diagnostic capabilities.

CUPS error_log

This is a file where CUPS writes information about what it is

doing. Almost all printing problems can be diagnosed from the
error log, so it is the first place to look to start solving problems. To
be useful, you must change the logging level:

1. In Oneiric or newer with Unity desktop click the gear icon at the
upper right (the one also used to log out) and in the menu
showing up then, click "Printer" (or, in some versions, "Printers").
Or go to "System Settings" in the launcher and click on "Printing".
The printer setup tool system-config-printer will open. Select
"Server Settings" in the list on the left or in newer versions with the
printers showing as icons choose "Server" in the main menu and
then "Settings". Note that the main menu will be in the bar at the
top of the screen if Oneiric (or newer) with Unity is used. There it
only appears if you move the mouse into the top bar. Then check
the checkbox "Save debugging information for troubleshooting"
and click "Apply".

2. In all Ubuntu flavors (also Kubuntu and server editions) you can
run
$ cupsctl LogLevel=debug
to activate debug logging.

3. In Karmic and later (CUPS 1.4.x) there is an automatic debug

logging only for failed print jobs. So if you problem was a failed
print job, the error_log can already contain the desired
information. Unfortunately, only 200 debug message lines get
logged per failed job. Run the command
$ cupsctl LogDebugHistory=999999
for practically unlimited logging of failed jobs.

4. Clear the queue from any stuck jobs by deleting the jobs in the job
 viewer or running the "cancel ‐a" command.

5. Try to print something. Wait until the job disappears from the
queue or turns into "Stopped" state, independent whether
something gets out of the printer. If the job never reaches
"Stopped" state after the printer not showing any reaction for a
longer time you also can go on to the next step.

6. Scan or photograph the printout if it is not correct and attach the

images to the bug report.

7. Add /var/log/cups/error_log as an attachment to the bug

report. Note that the file is not accessible for normal users. From
Jaunty on you can access it from the account of the first user set
up (in general users in the "adm" group). Otherwise you need to
access it as root. To view the file run
$ sudo less /var/log/cups/error_log
and to copy it for attaching to a bug report run
$ sudo cp /var/log/cups/error_log ~
$ sudo chmod 777 ~/error_log

Troubleshooting Wizard

There is a troubleshooting wizard in system-config-printer

(System -> Administration -> Printing in GNOME classic, Gear
icon at the upper right of the screen -> Printers in Unity). You find
it in the "Help" menu of system-config-printer. It produces a text
file with a lot of useful information to attach to bug reports. Follow
the instructions of the wizard. If you reach the test page step, you
can either click the button to print the test page or you can print a
job to the selected printer from any application or from the
command line. The job will be shown in the integrated job viewer.
Wait until it completes or goes into "Stopped" state. ONLY THEN
AND NOT BEFORE mark the checkbox at the job, answer
whether the job got printed correctly, and click "Forward". After
that the file will get generated. Save it and attach it to your bug
report.
 Print Error pop-up window

If a print job fails, a job viewer with the failed job ("Stopped" state)
and pop-up window telling that the job has problems will appear. If
you click the "Diagnose" button, the troubleshooting wizard will
open. Do not delete the job before having completed the wizard.
Take care to choose the printer with which the problem occured.
In the "Test Page" step you do not need to print anything, nor to
wait. Mark the stopped job in the integrated job viewer, click "No"
at the question and then "Forward". After that save the file and
attach it to the bug report.

AppArmor Protection of the printing system

From Gutsy on the security of the CUPS printing system is

improved by using AppArmor. Unfortunately, the configuration is
not perfect yet, especially if third-party printer drivers are used.
First make sure the apparmor-utils package is installed. If you
have any problems with printing, try deactivating the AppArmor
protection with sudo aa‐complain cupsd. If this helps, look for
messages containing audit in the /var/log/syslog file. These
show which components are accessed by the printing system for
which there is no explicit permission given in /etc/apparmor.d/
[Link]. You can re-activate AppArmor via sudo aa‐
enforce cupsd. Report a bug to the package cups, so that we
can correct the default configuration of AppArmor.

Capturing print job data

Often it is needed to find out what actually got sent to the printer in
order to determine whether the problem is caused by the
application or by the printing subsystem. It is easiest to capture
the job data from the application so that it can be analyzed to see
whether it is already broken or not. To do so, follow these steps:

1. Clear the print queues of old jobs. Either use the job viewer or run
the command
 $ cancel ‐a
in a terminal window.

2. Disable the print queue with which you have the problem. Use
system-config-printer (System -> Administration -> Printing in
GNOME classic, Gear icon at the upper right of the screen ->
Printers in Unity), right-click the appropriate printer icon, and click
"Enabled" in the pop-up menu, so that the check mark
disappears; or run the command
$ cupsdisable <PRINTER>
in a terminal window (Replace "<PRINTER>" by the name of the
print queue). This makes jobs stay in the queue so that you can
capture them.

3. Now print the job from your application. When the application has
finished sending the job, check via the job viewer or the
command
$ lpstat ‐o
whether it is in the queue.

4. Display the content of CUPS' spool directory using the command

$ sudo ls ‐1 /var/spool/cups
(Enter your password when asked).

5. There should be exactly one file beginning with a "d". Copy this
file to your home directory:
$ sudo cp /var/spool/cups/d... ~/appout
$ sudo chmod 777 ~/appout

6. Re-enable the print queue:

$ cupsenable <PRINTER>

7. If the file gets printed correctly now, try the above procedure with
another file, we need a file where the problem occurs.

8. Check via the command

$ file ~/appout
what format the file is. It is usually PDF or PostScript. Display the
file on the screen to see whether the problem already occurs
(error message, missing characters, wrong colors, ...). If you see
 the problem already, the application is the culprit, assign your bug
report to the application's package, otherwise assign it to the
"cups" package.

9. Attach the original file of your application and the ~/appout file to
your bug report.

Getting the data which would go to the printer

Another important piece of data for debugging printing problems

is the data which is supposed to be sent to the printer. In the
previous section we captured what the application has sent to
CUPS. CUPS applies several filters to this data to convert it into
the printer's native language. Here we capture the result of these
filters:

1. Activate printing into a file by adding a line containing "FileDevice

yes" to /etc/cups/[Link] and restarting CUPS by the
command
$ sudo restart cups

2. Clone the queue of the printer with problems. The clone should
print into a file and not to the actual printer, but should use the
same driver, so that the same filters get applied. Use the
command:
$ lpadmin ‐p test ‐E ‐v file:/tmp/printout ‐P /etc/
cups/ppd/<queue name>.ppd
Replace "<queue name>" by the name of the queue with the
problem. The clone has also exactly the same default settings as
the original queue.

3. Print the job which failed to the new print queue "test". If you have
selected options in the print dialog, use the same options as you
used when you encountered the problem. Wait until the job
finishes (disappears in the job viewer). You will have a non-empty
file named /tmp/printout then. Copy this file to your home
directory:
$ sudo cp /tmp/printout ~
$ sudo chmod 777 ~/printout
4. Attach this file to your bug report and/or examine it.

Sending a file to the printer unfiltered

If you print a file from an application or via the "lp" or "lpr"

commands, the data usually goes through several filters to
convert it into a format which the printer understands and to apply
page management options, like 2 pages per sheet, only page 1,
3, and 9, ... to it. For debugging it can be useful to bypass all these
filters and let the data go directly to the printer, without any
changes or conversions.

Do not send arbitrary files unfiltered to the printer now hoping that
will solve any problems. Please use this mainly if you are asked
for doing so in bug reports or after asking a support question.

In most cases you will have to print the data obtained from the
section "Getting the data which would go to the printer" this way,
often after editing it.

Use one of the following methods for unfiltered printing:

1. Independent how your printer is connected, you can print

unfiltered by using the "lp" or "lpr" commands with the "-oraw"
argument:
$ lp ‐d <printer> ‐oraw <file>
$ lpr ‐P <printer> ‐oraw <file>
Replace <printer> by the name of your print queue and <file> by
the name of the file you want to print. This does not work around
bugs in CUPS backends (the modules which CUPS uses to
communicate with printer hardware), see the next steps for such
cases.

2. If the printer is connected via USB or parallel port, you can send
the job directly to the printer's device file:
$ sudo ‐s
# cat file > /dev/lp0
# cat file > /dev/usb/lp0
# cat file > /dev/usb/lp1
 # exit
The numbers in the device file names can vary (sse also sections
"USB Printer" and "Parallel port printer" above).

3. If the printer is connected via the network (both ethernet or

WLAN), you can use "nc" ("netcat", part of the netcat-openbsd
and netcat-traditional packages, install one of them if needed) to
send unfiltered data:
$ nc ‐w1 <printer> 9100 < <file>
Replace <printer> by the host name or IP address of your printer
and <file> by the name of the file you want to send. If the printer
refuses the job, check in the printer's web configuration interface
whether JetDirect/AppSocket/9100 printing is enabled (see also
the section "Network printer" above).

PostScript (PDF) printer chokes on the

PostScript (PDF) coming from Ubuntu

Unfortunately, the PostScript (or PDF) interpreters in many

printers have bugs, letting them print garbage or nothing at all, or
even crash/get stuck when receiving a valid PostScript (or PDF)
file.

If you have a PostScript or PDF printer and it does not print

correctly from Ubuntu, please report a bug and proceed as
follows, telling all your results in your bug report and staying tuned
for further instructions of the developers:

1. Tell us the exact Ubuntu version which you are using.

2. Tell us the exact printer model.

3. Attach the error_log, as described in the section "CUPS

error_log" on this page.

4. Attach the input file which you tried to print and tell us with which
application you tried to print it.

5. Attach the data which CUPS receives from the application

(section "Capturing print job data" on this page).
 6. Attach the data which the printer receives (section "Getting the
data which would go to the printer" on this page)

7. Examine the file obtained in the previous step by running the

command
$ file printout

8. If the file is PostScript or PDF, subscribe "cliddell" (Chris Liddell,

Ghostscript upstream developer) to the bug report and also try to
display the file on the screen with "evince" and "gs".

9. Send the file unfiltered to the printer (as described in the section
"Sending a file to the printer unfiltered". You should get the same
problem, if you get a different (correct or incorrect) result, there is
a problem with the CUPS backend (program which CUPS uses
to communicate with the printer hardware).

10. If the file is PostScript, try to send uncompressed PostScript. To

do so print the file obtained in step (5) with one of the commands
$ lpr ‐P <printer> ‐o psdebug <file>
$ lp ‐d <printer> ‐o psdebug <file>
Repeat the steps (6) - (9) printing this way. See also the file /usr/
share/doc/cups-filters/[Link], section "POSTSCRIPT
PRINTING DEBUG MODE".

11. As a workaround for the time being you can switch to an

alternative program for generating the PostScript which is sent to
the printer. Run
$ lpadmin ‐p <printer> ‐o pdftops‐renderer‐
default=pdftops
to switch over and
$ lpadmin ‐p <printer> ‐R pdftops‐renderer‐default
to switch back. Make sure that you switch back if you follow
further instructions from the developers in your bug report, or
create a separate print queue for the workaround. See also the
file /usr/share/doc/cups-filters/[Link], section
"POSTSCRIPT PRINTING RENDERER AND RESOLUTION
SELECTION".
 USB printer does not print or prints garbage

There are some USB printers who do not work when the
standard communication through the USB is applied. For these
exception rules need to get implemented in the USB backend of
CUPS.

If your printer is connected via USB try the following steps to find
out whether such exception rules could solve your problem:

1. Does your printer also allow to be connected via network? Or

does your router have a USB port which can be used to make a
network printer out of a USB printer? Try out these connection
methods. If your printer works with them, continue with the
following steps. Continue also with the following steps if you do
not have possibilities to use your printer as a network printer.
Otherwise, your printer has a problem which does not fall into this
class.

2. Make sure your printer is connected via USB again. Run the
following command in a terminal window
$ cancel ‐a
$ lpadmin ‐p <queue> ‐o usb‐unidir‐default=true
with <queue> being the print queue name of the printer with
problems. Now your computer does purely uni-directional USB
communication with your printer. Does printing work correctly
now? Run
$ lpadmin ‐p <queue> ‐R usb‐unidir‐default
to remove this change.

3. Run
$ cancel ‐a
$ lpadmin ‐p <queue> ‐o usb‐no‐reattach‐
default=true
to make the USB backend not re-attach the usblp kernel module
after the communication with the printer. Does printing work
correctly for you now? Undo this change via
$ lpadmin ‐p <queue> ‐R usb‐no‐reattach‐default
Please report a bug on the package "cups", preferably by running
the command
$ ubuntu‐bug cups
Report your results of the tests above and paste in the output of
the
$ lsusb
command.

Problems installing the CUPS package

Most problems of installing the CUPS package are due to the

CUPS daemon not starting after the installation or update of the
package and this often happens when something is not OK with
the configuration settings in /etc/cups/[Link].

To find out what is happening during startup of CUPS run the

following commands
$ wget [Link]
[Link]
$ sudo cp /etc/init/[Link]{,.orig}
$ sudo cp [Link] /etc/init/[Link]
$ sudo stop cups
$ sudo start cups
This should fail. Please attach /tmp/log to your bug report. After
that, please restore the original script again with
$ sudo mv /etc/init/[Link]{.orig,}

If the CUPS daemon did not start ("lpstat -r" says "scheduler is
not running") follow the instructions under "CUPS error_log" on
this page and instead of sending a job try to start CUPS:
$ sudo /usr/sbin/cupsd
If it fails, attach your error_log to your bug report.

If you look into your /tmp/log and error_log, you can probably also
already find by yourself what went wrong, for example a broken
entry in /etc/cups/[Link].

To restore the default configuration file /etc/cups/[Link], run

the commands:
$ sudo mv /etc/cups/[Link] ~
$ apt‐get download cups
$ sudo dpkg ‐i ‐‐force‐confmiss cups_*.deb
You can also restore other configuration files, as [Link] for
example. Simply do the same steps but instead of [Link]
move away the offending configuration file.

Turboprint

Turboprint is a comercially distributed manufacturer-independent

printer driver package. It is for photo inkjet printers, supporting
several models which are not or not well supported by the drivers
which come with Ubuntu (Gutenprint, HPLIP) or from the
manufacturers and also adds color management with calibration
service to all supported printers. You have to pay for the software
and for the calibration service. You can download the software for
free but after a 30-day trial period a Turboprint logo gets printed
on every page.

We cannot fix bugs in Turboprint, as it is a third-party closed-

source software package, like many manufacturer-supplied
drivers, but the developers of Turboprint are responsive, so we
can forward bug reports to them.

One known problem is that Turboprint currently ships with a

Ghostscript clone based on a very old Ghostscript version, after
which we have worked a lot with the original developers of
Ghostscript to remove very many crash bugs. So if you have
problems that certain (especially more complex) files do not print
(and perhaps you find segmentation fault messages of "gszedo"
in /var/log/syslog), proceed as follows:

Run the command:

$ turboprint
A window, "Turboprint Control Center" will open. Click
"Preferences" at the bottom of the window. In the dialog popping
up now uncheck "Use Ghostscript with extensions for
Turboprint". Click "OK" in the dialog window and "Exit" in the main
window.

This makes Turboprint using the current version of Ghostscript as

shipped with Ubuntu, containing all the latest bug fixes.

Known bugs

Description of known issues, how to recognise them and stock

responses/actions.

evince: First try to remove (or move away) the ~/.config/

evince/print‐settings especially if you did changes on print
queues, printers, drivers, ... Old settings can prevent printing (See
bug 1652791). Also note that evince (and other GTK/GNOME-
based applications) often generates very awkward, large PDF
files which can make PostScript and PDF printers receive very
large and complex files which they cannot cope with. This got
improved in newer versions, but old applications, especially ones
using GTK 2.x still often cause problems.

Discuss this page

CategoryBugSquad CategoryDebugging