Package: netpbm
Version: 2:10.0-10.1jim
Severity: normal
Tags: patch
xwdtopnm is broken on 64-bit systems because it assumes "long" is 32
bits. The attached patch replaces
long -> int32n
unsigned long -> uint32n
This patch has been tested to work on both 32 and 64 bit systems.
-jim
-- System Information:
Debian Release: testing/unstable
APT prefers testing
APT policy: (990, 'testing'), (500, 'unstable')
Architecture: amd64 (x86_64)
Shell: /bin/sh linked to /bin/bash
Kernel: Linux 2.6.14-2-amd64-k8
Locale: LANG=POSIX, LC_CTYPE=en_US.UTF-8 (charmap=UTF-8)
Versions of packages netpbm depends on:
ii libc6 2.3.5-8.1 GNU C Library: Shared libraries an
ii libjpeg62 6b-10 The Independent JPEG Group's JPEG
ii libnetpbm10 2:10.0-10.1jim Shared libraries for netpbm
ii libpng12-0 1.2.8rel-5 PNG library - runtime
ii libtiff4 3.7.4-1 Tag Image File Format (TIFF) libra
ii zlib1g 1:1.2.3-8 compression library - runtime
Versions of packages netpbm recommends:
ii gs 8.15-4 Transitional package
ii gs-esp [gs] 8.15.1.dfsg.1-1 The Ghostscript PostScript interpr
ii gs-gpl [gs] 8.15-4 The GPL Ghostscript PostScript int
-- no debconf information
diff -ur netpbm-free-10.0.orig/pnm/x11wd.h netpbm-free-10.0/pnm/x11wd.h
--- netpbm-free-10.0.orig/pnm/x11wd.h 2003-08-14 15:38:51.000000000 -0400
+++ netpbm-free-10.0/pnm/x11wd.h 2006-02-10 13:55:13.000000000 -0500
@@ -58,7 +58,7 @@
} X11WDFileHeader;
typedef struct {
- unsigned long num;
+ uint32n num;
unsigned short red, green, blue;
char flags; /* do_red, do_green, do_blue */
char pad;
Only in netpbm-free-10.0/pnm: xwdtopnm
diff -ur netpbm-free-10.0.orig/pnm/xwdtopnm.c netpbm-free-10.0/pnm/xwdtopnm.c
--- netpbm-free-10.0.orig/pnm/xwdtopnm.c 2003-08-14 15:38:51.000000000 -0400
+++ netpbm-free-10.0/pnm/xwdtopnm.c 2006-02-10 14:05:35.000000000 -0500
@@ -52,7 +52,7 @@
Which of the members applies depends on the bits per item of
the input image.
*/
- long l; /* 32 bits per item */
+ int32n l; /* 32 bits per item */
short s; /* 16 bits per item */
char c; /* 8 bits per item */
} item;
@@ -65,7 +65,7 @@
/* This is the number of bits in the current item that have not yet
been returned as part of a pixel or saved as carryover bits.
*/
- unsigned long carryover_bits;
+ uint32n carryover_bits;
/* This is the odd bits left over from one item that need to be
combined with more bits from the next item to form a pixel
value (the pixel is split between two items). An item is a
@@ -79,20 +79,20 @@
};
static short bs_short ARGS(( short s ));
-static long bs_long ARGS(( long l ));
+static int32n bs_int32 ARGS(( int32n l ));
static int byte_swap;
static int
-zero_bits(const unsigned long mask) {
+zero_bits(const uint32n mask) {
/*----------------------------------------------------------------------------
Return the number of consective zero bits at the least significant end
of the binary representation of 'mask'. E.g. if mask == 0x00fff800,
we would return 11.
-----------------------------------------------------------------------------*/
int i;
- unsigned long shifted_mask;
+ uint32n shifted_mask;
for (i=0, shifted_mask = mask;
i < sizeof(mask)*8 && (shifted_mask & 0x00000001) == 0;
@@ -103,12 +103,12 @@
static int
-one_bits(const unsigned long input) {
+one_bits(const uint32n input) {
/*----------------------------------------------------------------------------
Return the number of one bits in the binary representation of 'input'.
-----------------------------------------------------------------------------*/
int one_bits;
- unsigned long mask;
+ uint32n mask;
one_bits = 0; /* initial value */
for (mask = 0x00000001; mask != 0x00000000; mask <<= 1)
@@ -124,8 +124,8 @@
int * const padrightP, xelval * const maxvalP,
enum visualclass * const visualclassP, int * const formatP,
xel ** const colorsP, int * const bits_per_pixelP,
- int * const bits_per_itemP, unsigned long * const red_maskP,
- unsigned long * const green_maskP, unsigned long * const blue_maskP,
+ int * const bits_per_itemP, uint32n * const red_maskP,
+ uint32n * const green_maskP, uint32n * const blue_maskP,
enum byteorder * const byte_orderP,
enum byteorder * const bit_orderP)
{
@@ -148,7 +148,7 @@
pm_error( "couldn't read XWD file header" );
if ( h10P->file_version == X10WD_FILE_VERSION ||
- bs_long( h10P->file_version ) == X10WD_FILE_VERSION )
+ bs_int32( h10P->file_version ) == X10WD_FILE_VERSION )
{
int i;
X10Color* x10colors;
@@ -156,13 +156,13 @@
if ( h10P->file_version != X10WD_FILE_VERSION )
{
byte_swap = 1;
- h10P->header_size = bs_long( h10P->header_size );
- h10P->file_version = bs_long( h10P->file_version );
- h10P->display_type = bs_long( h10P->display_type );
- h10P->display_planes = bs_long( h10P->display_planes );
- h10P->pixmap_format = bs_long( h10P->pixmap_format );
- h10P->pixmap_width = bs_long( h10P->pixmap_width );
- h10P->pixmap_height = bs_long( h10P->pixmap_height );
+ h10P->header_size = bs_int32( h10P->header_size );
+ h10P->file_version = bs_int32( h10P->file_version );
+ h10P->display_type = bs_int32( h10P->display_type );
+ h10P->display_planes = bs_int32( h10P->display_planes );
+ h10P->pixmap_format = bs_int32( h10P->pixmap_format );
+ h10P->pixmap_width = bs_int32( h10P->pixmap_width );
+ h10P->pixmap_height = bs_int32( h10P->pixmap_height );
h10P->window_width = bs_short( h10P->window_width );
h10P->window_height = bs_short( h10P->window_height );
h10P->window_x = bs_short( h10P->window_x );
@@ -268,7 +268,7 @@
*bit_orderP = LSBFirst;
}
else if ( h11P->file_version == X11WD_FILE_VERSION ||
- bs_long( h11P->file_version ) == X11WD_FILE_VERSION )
+ bs_int32( h11P->file_version ) == X11WD_FILE_VERSION )
{
int i;
X11XColor* x11colors;
@@ -278,31 +278,31 @@
if ( h11P->file_version != X11WD_FILE_VERSION )
{
byte_swap = 1;
- h11P->header_size = bs_long( h11P->header_size );
- h11P->file_version = bs_long( h11P->file_version );
- h11P->pixmap_format = bs_long( h11P->pixmap_format );
- h11P->pixmap_depth = bs_long( h11P->pixmap_depth );
- h11P->pixmap_width = bs_long( h11P->pixmap_width );
- h11P->pixmap_height = bs_long( h11P->pixmap_height );
- h11P->xoffset = bs_long( h11P->xoffset );
- h11P->byte_order = bs_long( h11P->byte_order );
- h11P->bitmap_unit = bs_long( h11P->bitmap_unit );
- h11P->bitmap_bit_order = bs_long( h11P->bitmap_bit_order );
- h11P->bitmap_pad = bs_long( h11P->bitmap_pad );
- h11P->bits_per_pixel = bs_long( h11P->bits_per_pixel );
- h11P->bytes_per_line = bs_long( h11P->bytes_per_line );
- h11P->visual_class = bs_long( h11P->visual_class );
- h11P->red_mask = bs_long( h11P->red_mask );
- h11P->green_mask = bs_long( h11P->green_mask );
- h11P->blue_mask = bs_long( h11P->blue_mask );
- h11P->bits_per_rgb = bs_long( h11P->bits_per_rgb );
- h11P->colormap_entries = bs_long( h11P->colormap_entries );
- h11P->ncolors = bs_long( h11P->ncolors );
- h11P->window_width = bs_long( h11P->window_width );
- h11P->window_height = bs_long( h11P->window_height );
- h11P->window_x = bs_long( h11P->window_x );
- h11P->window_y = bs_long( h11P->window_y );
- h11P->window_bdrwidth = bs_long( h11P->window_bdrwidth );
+ h11P->header_size = bs_int32( h11P->header_size );
+ h11P->file_version = bs_int32( h11P->file_version );
+ h11P->pixmap_format = bs_int32( h11P->pixmap_format );
+ h11P->pixmap_depth = bs_int32( h11P->pixmap_depth );
+ h11P->pixmap_width = bs_int32( h11P->pixmap_width );
+ h11P->pixmap_height = bs_int32( h11P->pixmap_height );
+ h11P->xoffset = bs_int32( h11P->xoffset );
+ h11P->byte_order = bs_int32( h11P->byte_order );
+ h11P->bitmap_unit = bs_int32( h11P->bitmap_unit );
+ h11P->bitmap_bit_order = bs_int32( h11P->bitmap_bit_order );
+ h11P->bitmap_pad = bs_int32( h11P->bitmap_pad );
+ h11P->bits_per_pixel = bs_int32( h11P->bits_per_pixel );
+ h11P->bytes_per_line = bs_int32( h11P->bytes_per_line );
+ h11P->visual_class = bs_int32( h11P->visual_class );
+ h11P->red_mask = bs_int32( h11P->red_mask );
+ h11P->green_mask = bs_int32( h11P->green_mask );
+ h11P->blue_mask = bs_int32( h11P->blue_mask );
+ h11P->bits_per_rgb = bs_int32( h11P->bits_per_rgb );
+ h11P->colormap_entries = bs_int32( h11P->colormap_entries );
+ h11P->ncolors = bs_int32( h11P->ncolors );
+ h11P->window_width = bs_int32( h11P->window_width );
+ h11P->window_height = bs_int32( h11P->window_height );
+ h11P->window_x = bs_int32( h11P->window_x );
+ h11P->window_y = bs_int32( h11P->window_y );
+ h11P->window_bdrwidth = bs_int32( h11P->window_bdrwidth );
}
for ( i = 0; i < h11P->header_size - sizeof(*h11P); ++i )
if ( getc( file ) == EOF )
@@ -441,7 +441,7 @@
-static unsigned long
+static uint32n
getpix(FILE *file, struct row_control * const row_controlP,
const int bits_per_pixel, const int bits_per_item,
const enum byteorder byte_order, const enum byteorder bit_order) {
@@ -479,7 +479,7 @@
*row_controlP.
-----------------------------------------------------------------------------*/
- unsigned long pixel;
+ uint32n pixel;
/* This is the pixel value we ultimately return. It is a 32 bit
bitstring, with the pixel value right-justified in it.
*/
@@ -488,6 +488,9 @@
/* This is the number of bits we need to take from the current
item to combine with carryover bits to form a pixel.
*/
+
+ long tmplong; /* For pm_read*long */
+
/*
if (pixel_count < 4)
pm_message("getting pixel %d", pixel_count);
@@ -517,18 +520,18 @@
break;
case 32:
- switch (byte_order) {
- case MSBFirst:
- if (pm_readbiglong(file, &row_controlP->item.l) == -1)
- pm_error( "error reading image" );
- break;
- case LSBFirst:
- if (pm_readlittlelong(file, &row_controlP->item.l) == -1)
- pm_error( "error reading image");
- break;
- }
- break;
-
+ switch (byte_order) {
+ case MSBFirst:
+ if (pm_readbiglong(file, &tmplong) == -1)
+ pm_error( "error reading image" );
+ break;
+ case LSBFirst:
+ if (pm_readlittlelong(file, &tmplong) == -1)
+ pm_error( "error reading image");
+ break;
+ }
+ row_controlP->item.l = tmplong;
+ break;
default:
pm_error( "can't happen" );
}
@@ -545,8 +548,8 @@
bits_to_take = bits_per_pixel - row_controlP->bits_carried_over;
{
- unsigned long bits_to_take_mask;
- static unsigned long bits_taken;
+ uint32n bits_to_take_mask;
+ static uint32n bits_taken;
/* The bits we took from the current item: 'bits_to_take' bits
right-justified in a 32 bit bitstring.
*/
@@ -604,7 +607,7 @@
/* Part, but not all, of the next pixel is in this item. Get it
into carryover_bits and then mark this item all used up.
*/
- unsigned long bits_left_mask;
+ uint32n bits_left_mask;
int bit_shift;
/* How far to shift item to get the bits that are left
right-justified
@@ -711,8 +714,8 @@
const enum byteorder byte_order, const enum byteorder bit_order,
const int padright, const int cols, const xelval maxval,
const int format,
- unsigned long red_mask, unsigned long green_mask,
- unsigned long blue_mask, const xel* const colors,
+ uint32n red_mask, uint32n green_mask,
+ uint32n blue_mask, const xel* const colors,
const enum visualclass visualclass
) {
@@ -741,7 +744,7 @@
unsigned int col;
for (col = 0; col < cols; ++col) {
- unsigned long pixel;
+ uint32n pixel;
/* This is a triplet of indices into the color map, packed
into this bit string according to red_mask, etc.
*/
@@ -779,7 +782,7 @@
blue_maxval = blue_mask >> blue_shift;
for ( col = 0, xP = xelrow; col < cols; ++col, ++xP ) {
- unsigned long pixel;
+ uint32n pixel;
pixel = getpix( ifp, &row_control,
bits_per_pixel, bits_per_item,
@@ -819,7 +822,7 @@
int rows, cols, format, padright, row;
int bits_per_pixel;
int bits_per_item;
- unsigned long red_mask, green_mask, blue_mask;
+ uint32n red_mask, green_mask, blue_mask;
xelval maxval;
enum visualclass visualclass;
enum byteorder byte_order, bit_order;
@@ -897,8 +900,8 @@
return u.s;
}
-static long
-bs_long( long l )
+static int32n
+bs_int32( int32n l )
{
union cheat u;
unsigned char t;
