diff options
Diffstat (limited to 'zarb-ml/mageia-sysadm/2011-February/002827.html')
| -rw-r--r-- | zarb-ml/mageia-sysadm/2011-February/002827.html | 4158 |
1 files changed, 4158 insertions, 0 deletions
diff --git a/zarb-ml/mageia-sysadm/2011-February/002827.html b/zarb-ml/mageia-sysadm/2011-February/002827.html new file mode 100644 index 000000000..0c4b6abb0 --- /dev/null +++ b/zarb-ml/mageia-sysadm/2011-February/002827.html @@ -0,0 +1,4158 @@ +<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 3.2//EN"> +<HTML> + <HEAD> + <TITLE> [Mageia-sysadm] [450] Import cleaned tools + </TITLE> + <LINK REL="Index" HREF="index.html" > + <LINK REL="made" HREF="mailto:mageia-sysadm%40mageia.org?Subject=Re%3A%20%5BMageia-sysadm%5D%20%5B450%5D%20Import%20cleaned%20tools&In-Reply-To=%3C20110206232331.3EB2E402D0%40valstar.mageia.org%3E"> + <META NAME="robots" CONTENT="index,nofollow"> + <META http-equiv="Content-Type" content="text/html; charset=us-ascii"> + <LINK REL="Previous" HREF="002826.html"> + <LINK REL="Next" HREF="002835.html"> + </HEAD> + <BODY BGCOLOR="#ffffff"> + <H1>[Mageia-sysadm] [450] Import cleaned tools</H1> + <B>root at mageia.org</B> + <A HREF="mailto:mageia-sysadm%40mageia.org?Subject=Re%3A%20%5BMageia-sysadm%5D%20%5B450%5D%20Import%20cleaned%20tools&In-Reply-To=%3C20110206232331.3EB2E402D0%40valstar.mageia.org%3E" + TITLE="[Mageia-sysadm] [450] Import cleaned tools">root at mageia.org + </A><BR> + <I>Mon Feb 7 00:24:11 CET 2011</I> + <P><UL> + <LI>Previous message: <A HREF="002826.html">[Mageia-sysadm] [448] Add cleaned files +</A></li> + <LI>Next message: <A HREF="002835.html">[Mageia-sysadm] [451] Import stage1 +</A></li> + <LI> <B>Messages sorted by:</B> + <a href="date.html#2827">[ date ]</a> + <a href="thread.html#2827">[ thread ]</a> + <a href="subject.html#2827">[ subject ]</a> + <a href="author.html#2827">[ author ]</a> + </LI> + </UL> + <HR> +<!--beginarticle--> +<PRE>Revision: 450 +Author: dmorgan +Date: 2011-02-07 00:23:30 +0100 (Mon, 07 Feb 2011) +Log Message: +----------- +Import cleaned tools + +Added Paths: +----------- + drakx/trunk/tools/ + drakx/trunk/tools/.perl_checker + drakx/trunk/tools/Makefile + drakx/trunk/tools/checkusedmodules + drakx/trunk/tools/drakx-in-chroot + drakx/trunk/tools/extractchangelog + drakx/trunk/tools/get-needed-drakx-modules + drakx/trunk/tools/hd_grub.cgi + drakx/trunk/tools/i386/ + drakx/trunk/tools/ia64/ + drakx/trunk/tools/install-xml-file-list + drakx/trunk/tools/make_lang_png_transparent.c + drakx/trunk/tools/mdkinst_stage2_tool + drakx/trunk/tools/ntp_servers.pl + drakx/trunk/tools/ppc/ + drakx/trunk/tools/rpcinfo-flushed.c + drakx/trunk/tools/serial_probe/ + drakx/trunk/tools/serial_probe/Makefile + drakx/trunk/tools/serial_probe/device.h + drakx/trunk/tools/serial_probe/kudzu.h + drakx/trunk/tools/serial_probe/serial.c + drakx/trunk/tools/serial_probe/serial.h + drakx/trunk/tools/serial_probe/serial_probe.c + drakx/trunk/tools/shift_all.pl + drakx/trunk/tools/shift_img.c + drakx/trunk/tools/simplify-drakx-modules + drakx/trunk/tools/specific_arch + drakx/trunk/tools/x86_64/ + drakx/trunk/tools/xhost+.c + +Added: drakx/trunk/tools/.perl_checker +=================================================================== +--- drakx/trunk/tools/.perl_checker (rev 0) ++++ drakx/trunk/tools/.perl_checker 2011-02-06 23:23:30 UTC (rev 450) +@@ -0,0 +1,10 @@ ++AutoLoader ++Carp::Heavy ++constant ++Cwd ++Digest::base ++Encode ++File::Path ++Gtk2::Gdk::Keysyms ++IO::Handle ++Pod::Usage +\ No newline at end of file + +Added: drakx/trunk/tools/Makefile +=================================================================== +--- drakx/trunk/tools/Makefile (rev 0) ++++ drakx/trunk/tools/Makefile 2011-02-06 23:23:30 UTC (rev 450) +@@ -0,0 +1,27 @@ ++DIRS = serial_probe ++CFLAGS = -Wall ++ ++ARCH := $(shell arch | egrep "(x86_64|sparc64|s390x)") ++ifneq ("x$(ARCH)", "x") ++LIB_NAME = lib64 ++else ++LIB_NAME = lib ++endif ++ ++.PHONY: clean install $(DIRS) ++ ++all: $(DIRS) xhost+ rpcinfo-flushed ++ ++$(DIRS): ++ make -C $@ ++ ++install: ++ install -d $(ROOTDEST)/misc ++ install mdkinst_stage2_tool drakx-in-chroot $(ROOTDEST)/misc ++ ++xhost+: %: %.c ++ $(CC) $(CFLAGS) $< -L/usr/X11R6/$(LIB_NAME) -lX11 -o $@ ++ ++clean: ++ for i in $(DIRS); do $(MAKE) -C $$i clean; done ++ rm -rf *~ xhost+ rpcinfo-flushed */*.o + + +Property changes on: drakx/trunk/tools/Makefile +___________________________________________________________________ +Added: svn:eol-style + + native + +Added: drakx/trunk/tools/checkusedmodules +=================================================================== +--- drakx/trunk/tools/checkusedmodules (rev 0) ++++ drakx/trunk/tools/checkusedmodules 2011-02-06 23:23:30 UTC (rev 450) +@@ -0,0 +1,22 @@ ++#!/bin/sh ++ ++# This script compares the perl modules used by the .pm files in perl-install ++# against the ones listed in share/list, to detect potential missing modules ++# (and potential run-time problems during the stage 2) ++ ++cd ../perl-install || exit 1; ++ ++# list of used .pm files ++find . -name '*.pm' -not -name b_dump_strings.pm -not -path ./interactive/http.pm | \ ++ xargs perl -lne '/^\s*(use|require)\s+([\w:]+)/ && print $2' | sort -u > /tmp/gi-used-pm ++ ++# list of .pm files included in install ++perl -lne 'm{/(?:PERL_VERSION|ARCH-linux|vendor_perl/\*)/([\w/]+)\.pm$} and $_=$1, s,/,::,g, print' share/list > /tmp/gi-found-pm0 ++find . -name blib -prune -o -name '*.pm' | perl -ne 's,^\./,,; s/\.pm$// or next; s,/,::,g; print' >> /tmp/gi-found-pm0 ++ ++# compute difference ++sort -u /tmp/gi-found-pm0 > /tmp/gi-found-pm ++diff -u /tmp/gi-{used,found}-pm | perl -lne 'BEGIN{print"Unpackaged modules:"} s/^-(?!-)/ / && print' ++ ++# cleanup ++rm -f /tmp/gi-used-pm /tmp/gi-found-pm{,0} + + +Property changes on: drakx/trunk/tools/checkusedmodules +___________________________________________________________________ +Added: svn:executable + + * + +Added: drakx/trunk/tools/drakx-in-chroot +=================================================================== +--- drakx/trunk/tools/drakx-in-chroot (rev 0) ++++ drakx/trunk/tools/drakx-in-chroot 2011-02-06 23:23:30 UTC (rev 450) +@@ -0,0 +1,228 @@ ++#!/usr/bin/perl ++ ++use MDK::Common; ++ ++my $SLASH_LOCATION = '/tmp/drakx-in-chroot'; ++ ++my $verbose = 0; ++my $prefix_ROOTED = '/mnt'; ++my $IMAGE_LOCATION_ROOTED = '/tmp/image'; ++my $MEDIA_LOCATION_ROOTED = '/tmp/media'; ++my $STAGE2_LOCATION_ROOTED = '/tmp/stage2'; ++my $LOOP_MOUNT_POINT = "$SLASH_LOCATION/tmp/loop"; ++my $LIVE_LOCATION_REL = 'install/stage2/live/'; ++my $COMPRESSED_LOCATION_REL = 'install/stage2/'; ++my $COMPRESSED_FILE_REL = $COMPRESSED_LOCATION_REL . 'mdkinst.sqfs'; ++my $AUTO_INSTALL_ROOTED = '/tmp/auto_inst.cfg.pl'; ++my $DEFCFG_ROOTED = '/tmp/defcfg.pl'; ++my $RPMSRATE_ROOTED = '/tmp/rpmsrate'; ++my $resolution = '800x600'; ++my ($disk_iso_repository, $repository_uri); ++ +<A HREF="https://www.mageia.org/mailman/listinfo/mageia-sysadm">+ at ARGV</A> >= 2 or die "usage: drakx-in-chroot <root of distrib> <dir to install to> [options]\n ++\nOptions specific to drakx-in-chroot: ++ --flang XX use XX locale ++ --disk-iso path of a distro ++ --resolution=XXXxYYYY (eg: --resolution=1024x768)\n ++ --repository=<path> path of packages repository ++ --text text mode installer ++"; ++ ++(my $repository, my $dir, @ARGV) = @ARGV; ++foreach (@ARGV) { ++ if (/--resolution=(.*)/) { ++ $resolution = $1; ++ } elsif (/--disk-iso=(.*)/) { ++ $disk_iso_repository = $1; ++ } elsif (/--repository=(.*)/) { ++ $repository_uri = $1; ++ } ++} ++my ($repository_without_arch, $repository_arch) = basename($repository) eq arch() ? (dirname($repository), '/' . arch()) : ($repository, ''); ++my $STAGE2_LOCATION = $SLASH_LOCATION . $STAGE2_LOCATION_ROOTED; ++ ++my $sudo; ++if ($>) { ++ $sudo = "sudo"; ++ $ENV{PATH} = "/sbin:/usr/sbin:$ENV{PATH}"; ++} ++ ++undef $ENV{TMPDIR}; # prevent packdrake faillure on creating temporary files ++ ++if (-d $SLASH_LOCATION) { ++ umount_all() == 0 or exit(1); ++ sys("$sudo rm -rf $SLASH_LOCATION/var/lib/rpm $SLASH_LOCATION/dev/mapper"); ++ rm_rf($SLASH_LOCATION); ++} ++ ++mkdir_p("$SLASH_LOCATION$_") foreach '/dev', '/dev/usb', '/etc', '/var', '/proc', '/sys', $STAGE2_LOCATION_ROOTED, $MEDIA_LOCATION_ROOTED, $prefix_ROOTED; ++ ++sys("$sudo rm -rf $dir") if $ENV{CLEAN}; ++-e $dir or sys("$sudo mkdir -p $dir"); ++ ++copy_auto_install_files(); ++ ++my $remote_repository = $repository =~ m!^(ftp|http)://! && $1; ++if ($remote_repository) { ++ my $local_mdkinst = "$SLASH_LOCATION/tmp/mdkinst.sqfs"; ++ sys("curl --silent -o $local_mdkinst $repository/$COMPRESSED_FILE_REL"); ++ mount_mdkinst($local_mdkinst); ++} elsif (-d "$repository/$LIVE_LOCATION_REL") { ++ sys("$sudo mount -o bind $repository/$LIVE_LOCATION_REL $STAGE2_LOCATION"); ++} elsif (-e "$repository/$COMPRESSED_FILE_REL") { ++ mount_mdkinst("$repository/$COMPRESSED_FILE_REL"); ++} ++ ++sys("$sudo mount -o bind $dir $SLASH_LOCATION$prefix_ROOTED"); ++$repository_uri ||= $repository_without_arch if !$remote_repository; ++sys("$sudo mount -o bind $repository_uri $SLASH_LOCATION$MEDIA_LOCATION_ROOTED") if $repository_uri; ++ ++sys("$sudo mount -t proc none $SLASH_LOCATION/proc"); ++sys("$sudo mount -t sysfs none $SLASH_LOCATION/sys"); ++ ++if ($disk_iso_repository) { ++ my $repository_arch = $repository_arch || 'i586'; ++ mkdir_p($LOOP_MOUNT_POINT); ++ sys("$sudo mount -o loop,ro $disk_iso_repository $LOOP_MOUNT_POINT"); ++ symlinkf('loop/' . $repository_arch, "$SLASH_LOCATION$IMAGE_LOCATION_ROOTED"); # FIXME: arch() ++} ++ ++symlinkf('media' . $repository_arch, "$SLASH_LOCATION$IMAGE_LOCATION_ROOTED"); ++create_initial_symlinks(); ++create_initial_devices(); ++ ++apply_stage2_updates(); ++ ++output("$SLASH_LOCATION/etc/hosts", "127.0.0.1 localhost\n") if ! -e "$SLASH_LOCATION/etc/hosts"; ++ ++#- in the chroot, we have no way to know which device corresponds to the "/" partition. ++#- so helping it by giving the device which provide major/minor information ++mkdir_p("$dir/dev"); ++eval { cp_af($_, "$dir$_") } foreach qw(/dev/root); ++ ++#- if the DISPLAY is remote, we may need to resolve the name: ++eval { cp_af($_, "$SLASH_LOCATION$_") } foreach qw(/etc/resolv.conf); ++ ++{ ++ chomp(my $kernel_version = `uname -r`); ++ my $dir = "/modules/$kernel_version"; ++ mkdir_p("$SLASH_LOCATION$dir"); ++ output_p("$SLASH_LOCATION$dir" . $_, "\n") foreach "/lib/$dir/modules.dep", "/lib/$dir/modules.alias"; ++} ++ ++my $Xnest_pid; ++my $Xnest_bin = find { whereis_binary($_) } 'Xephyr', 'Xnest'; ++if (!-f ($SLASH_LOCATION . $AUTO_INSTALL_ROOTED) && $Xnest_bin && (join('', @ARGV) !~ /--text/)) { ++ my $DISPLAY = ':8'; ++ $Xnest_pid = fork(); ++ if (!$Xnest_pid) { ++ exec $Xnest_bin, $DISPLAY, '-ac', ($Xnest_bin eq 'Xephyr' ? '-screen' : '-geometry'), $resolution or die "Xnest failed\n"; ++ } ++ $ENV{DISPLAY} = '127.0.0.1' . $DISPLAY; ++} ++ ++if (my $pid = fork()) { ++ waitpid $pid, 0; ++ umount_all() == 0 or warn "umounting failed\n"; ++ $Xnest_pid and kill 15, $Xnest_pid; ++} else { ++ $ENV{TERM} = 'linux'; # we only have terminfo for terminal "linux" ++ $ENV{HOME} = '/'; ++ # to kept sync with gi/mdk-stage1/init.c::env: ++ $ENV{LD_LIBRARY_PATH}='/lib:/usr/lib:/mnt/lib:/mnt/usr/lib:/usr/X11R6/lib:/mnt/usr/X11R6/lib:/lib64:/usr/lib64:/usr/X11R6/lib64:/mnt/lib64:/mnt/usr/lib64:/mnt/usr/X11R6/lib64'; ++ if ($remote_repository) { ++ $ENV{URLPREFIX} = $repository; ++ } ++ my $cmd = join(' ', "/usr/bin/runinstall2 --local_install", ++ if_($disk_iso_repository, "--method disk-iso"), ++ if_($remote_repository, "--method $remote_repository"), ++ @ARGV); ++ exec "$sudo chroot $SLASH_LOCATION $cmd" or die "exec $cmd in $SLASH_LOCATION failed\n"; ++} ++ ++sub system_verbose { warn join(' ', @_), "\n" if $verbose; system(@_) } ++sub sys { &system_verbose; $? and die qq(running "@_" failed: $?\n) } ++ ++sub mount_mdkinst { ++ my ($mdkinst) = @_; ++ sys("$sudo mount -t squashfs -o loop,ro $mdkinst $STAGE2_LOCATION"); ++} ++sub create_initial_symlinks() { ++ foreach (cat_or_die("$STAGE2_LOCATION/usr/share/symlinks")) { ++ my ($from, $to_) = split; ++ my $to = $SLASH_LOCATION . ($to_ || $from); ++ $from = "$STAGE2_LOCATION_ROOTED$from" if !$to_; ++ if (! -l $to) { ++ symlink $from, $to or die "symlinking $to failed\n"; ++ } ++ } ++} ++ ++sub create_initial_devices() { ++ sys("$sudo cp -a /dev/{mem,null,random,urandom} $SLASH_LOCATION/dev"); ++} ++ ++sub umount_all() { ++ my $err; ++ clean_stage2_updates(); ++ my @procs = ('/proc/bus/usb', '/proc', '/sys'); ++ foreach ((map { "$prefix_ROOTED$_" } @procs, ''), @procs, $STAGE2_LOCATION_ROOTED, $LOOP_MOUNT_POINT, $MEDIA_LOCATION_ROOTED, $IMAGE_LOCATION_ROOTED) { ++ my $dir = "$SLASH_LOCATION$_"; ++ rmdir $dir; ++ if (-d $dir) { ++ if (m!/proc/bus/usb! || begins_with($_, $prefix_ROOTED)) { ++ system_verbose "$sudo umount $dir 2>/dev/null"; ++ next; ++ } ++ system_verbose "$sudo umount $dir"; ++ } ++ rmdir $dir; ++ if (-d $dir) { ++ warn "$dir is busy\n"; ++ $err++; ++ } ++ } ++ if (my @remaining = cat_('/proc/mounts') =~ m!($SLASH_LOCATION/mnt/\S+)!g) { ++ warn "umount those mount points first: ", join(' ', @remaining), "\n"; ++ $err++; ++ } ++ $err; ++} ++ ++sub copy_auto_install_files() { ++ my ($opt); ++ each_index { ++ if ($opt eq 'auto_install' && -f $_) { ++ cp_f($_, $SLASH_LOCATION . $AUTO_INSTALL_ROOTED); ++ $_ = $AUTO_INSTALL_ROOTED; ++ } elsif ($opt eq 'defcfg' && -f $_) { ++ cp_f($_, $SLASH_LOCATION . $DEFCFG_ROOTED); ++ $_ = $DEFCFG_ROOTED; ++ } elsif ($opt eq 'rpmsrate' && -f $_) { ++ cp_f($_, $SLASH_LOCATION . $RPMSRATE_ROOTED); ++ } ++ undef $opt; ++ /^--?(.*)/ and $opt = $1; ++ } @ARGV; ++} ++ ++my @stage2_updates; ++sub apply_stage2_updates() { ++ each_index { ++ if ($_ eq '--stage2-update') { ++ my $file = $ARGV[$::i+1]; ++ my $dest = $ARGV[$::i+2]; ++ if (-f $file && $dest) { ++ undef $_; ++ undef $ARGV[$::i+1]; ++ undef $ARGV[$::i+2]; ++ push @stage2_updates, $dest; ++ sys("$sudo mount --bind $file $STAGE2_LOCATION/$dest"); ++ } ++ } ++ } @ARGV; ++} ++ ++sub clean_stage2_updates() { ++ sys("$sudo umount $STAGE2_LOCATION/$_") foreach @stage2_updates; ++} + + +Property changes on: drakx/trunk/tools/drakx-in-chroot +___________________________________________________________________ +Added: svn:executable + + * + +Added: drakx/trunk/tools/extractchangelog +=================================================================== +--- drakx/trunk/tools/extractchangelog (rev 0) ++++ drakx/trunk/tools/extractchangelog 2011-02-06 23:23:30 UTC (rev 450) +@@ -0,0 +1,2 @@ ++#!/usr/bin/perl ++ + +Added: drakx/trunk/tools/get-needed-drakx-modules +=================================================================== +--- drakx/trunk/tools/get-needed-drakx-modules (rev 0) ++++ drakx/trunk/tools/get-needed-drakx-modules 2011-02-06 23:23:30 UTC (rev 450) +@@ -0,0 +1,19 @@ ++#!/usr/bin/perl ++ ++use MDK::Common; ++ ++my ($rel, $dest, $script) = @ARGV; ++ ++$rel =~ s!/?$!!; ++ ++foreach (`strace -efile perl -cw -I $rel $script 2>&1`) { ++ my ($f) = /^open\("(.*?)",.*\)\s*=\s*\d+$/ or next; ++ $f !~ m!/usr/lib/perl5/[^/]*/warnings.pm! or next; ++ if (begins_with($f, $rel)) { ++ print $f, "\t", $dest . substr($f, length($rel)), "\n"; ++ } elsif (begins_with($f, '/dev/')) { ++ # skip ++ } elsif (begins_with($f, '/')) { ++ print "$f\n"; ++ } ++} + + +Property changes on: drakx/trunk/tools/get-needed-drakx-modules +___________________________________________________________________ +Added: svn:executable + + * + +Added: drakx/trunk/tools/hd_grub.cgi +=================================================================== +--- drakx/trunk/tools/hd_grub.cgi (rev 0) ++++ drakx/trunk/tools/hd_grub.cgi 2011-02-06 23:23:30 UTC (rev 450) +@@ -0,0 +1,102 @@ ++#!/usr/bin/perl ++ ++use CGI ':all'; ++use CGI::Carp; ++ ++my $default_append = "ramdisk_size=128000 root=/dev/ram3"; ++my $default_acpi = "acpi=ht"; ++my $default_vga = "vga=788"; ++ ++my $cgi_name = "/" . ($0 =~ m|([^/]+)$|)[0]; ++ ++print ++ header(), ++ start_html(-TITLE => 'hd_grub configuration'); ++ ++if (param()) { ++ print_menu_lst(); ++} else { ++ print_form(); ++} ++ ++print end_html; ++ ++ ++sub menu_lst { ++ my ($hd, $hd_linux, $partition_number, $directory) = @_; ++ ++ my $grub_partition_number = $partition_number - 1; ++ ++ <<EOF; ++timeout 0 ++default 0 ++ ++title Mageia Install ++ ++root ($hd,$grub_partition_number) ++kernel $directory/isolinux/alt0/vmlinuz $default_append $default_acpi $default_vga automatic=method:disk,partition:$hd_linux$partition_number,directory:$directory ++initrd $directory/isolinux/alt0/all.rdz ++EOF ++ ++} ++ ++sub print_menu_lst { ++ my $directory = param('directory'); ++ $directory =~ s!^/!!; ++ print ++ ol(li(qq(Select the text below and save it in a file "menu.lst")), ++ li(qq(Create a floppy from $directory/images/hd_grub.img (eg: <tt>dd if=hd_grub.img of=/dev/fd0</tt>))), ++ li(qq(Copy the file "menu.lst" to the floppy, overwriting the existing one)), ++ ), ++ p(), ++ start_form(-name => 'form', -action => $cgi_name, -method => 'get'), ++ textarea(-default => menu_lst(param('hd'), param('hd_linux'), param('partition_number'), "/$directory"), ++ -rows => 15, -columns => 120, ++ ), ++ end_form(), ++} ++ ++sub print_form { ++ print ++ p(), ++ start_form(-name => 'form', -action => $cgi_name, -method => 'get'), ++ ul("Please choose the partition where %s is copied.", ++ li(popup_menu(-name => "hd", -default => 'hd0', ++ -values => [ 'hd0' .. 'hd3' ], ++ -labels => { hd0 => '1st BIOS hard drive (usually hda or sda)', ++ hd1 => '2nd BIOS hard drive', ++ hd2 => '3rd BIOS hard drive', ++ hd3 => '4th BIOS hard drive', ++ })), ++ li(popup_menu(-name => "hd_linux", -default => 'hda', ++ -values => [ 'hda' .. 'hdd', 'sda' .. 'sdc', 'hde' .. 'hdh' ], ++ -labels => { ++ hda => '1st IDE hard drive (hda)', ++ hdb => '2nd IDE hard drive (hdb)', ++ hdc => '3rd IDE hard drive (hdc)', ++ hdd => '4th IDE hard drive (hdd)', ++ hde => '5th IDE hard drive (hde)', ++ hdf => '6th IDE hard drive (hdf)', ++ hdg => '7th IDE hard drive (hdg)', ++ hdh => '8th IDE hard drive (hdh)', ++ sda => '1st SCSI hard drive (sda)', ++ sdb => '2nd SCSI hard drive (sdb)', ++ sdc => '3rd SCSI hard drive (sdc)', ++ })), ++ li(popup_menu(-name => "partition_number", -default => '0', ++ -values => [ 1 .. 15 ], ++ -labels => { 1 => '1st primary partition (hda1, sda1 or ...)', ++ 2 => '2nd primary partition', ++ 3 => '3rd primary partition', ++ 4 => '4th primary partition', ++ 5 => '5th partition (hda5, sda5 or ...) (first logical partition)', ++ map { $_ => $_ . 'th partition' } 6 .. 15 ++ })), ++ ), ++ p(), ++ ul("Please enter the directory containing the %s Distribution (relative to the partition chosen above)", ++ li(textfield(-name => 'directory', -default => '/cooker/i586', size => 40)), ++ ), ++ p(submit(-name => 'Go')), ++ end_form(); ++} + + +Property changes on: drakx/trunk/tools/hd_grub.cgi +___________________________________________________________________ +Added: svn:executable + + * + +Added: drakx/trunk/tools/install-xml-file-list +=================================================================== +--- drakx/trunk/tools/install-xml-file-list (rev 0) ++++ drakx/trunk/tools/install-xml-file-list 2011-02-06 23:23:30 UTC (rev 450) +@@ -0,0 +1,383 @@ ++#!/usr/bin/perl ++ ++use FileHandle; ++use MDK::Common; ++use XML::Parser; ++use Data::Dumper; ++use File::Glob; ++use Config; ++use Cwd 'cwd'; ++ ++my $want_sudo = $ARGV[0] eq '--sudo' && shift @ARGV; ++ +<A HREF="https://www.mageia.org/mailman/listinfo/mageia-sysadm">+ at ARGV</A> == 2 or die "usage: install-xml-file-list [--sudo] <xml file> <destination>\n"; ++my ($xml_file_list, $DEST) = @ARGV; ++ ++my $sudo = ''; ++if ($>) { ++ $sudo = "sudo" if $want_sudo; ++ $ENV{PATH} = "/sbin:/usr/sbin:$ENV{PATH}"; ++} ++ ++#$verbose = 1; ++ ++my $initial_dir = cwd(); ++my $ARCH = arch() =~ /i.86/ ? 'i386' : arch(); ++my $LIB = arch() =~ /x86_64/ ? "lib64" : "lib"; ++ ++my $base_cpio_options = '-pumd --quiet'; ++ ++my $problem; ++my $tree = XML::Parser->new(Style => 'Tree')->parsefile($xml_file_list); ++ ++my $main_node = decompose($tree); ++ ++$main_node->{tag} eq 'list' or die "bad file $xml_file_list (main tag should be <list>)\n"; ++ ++handle_nodes({}, $main_node); ++ ++$problem and exit 1; ++ ++install_needed_libraries(); ++ ++final_cleanup(); ++ ++sub error { ++ my ($err) = @_; ++ warn "FATAL: $err\n"; ++ $problem = 1; ++} ++ ++sub final_cleanup() { ++ #- cpio creates directory 700, that's not nice ++ system("find $DEST -type d -print0 | xargs -0 $sudo chmod 755"); ++} ++ ++sub handle_nodes { ++ my ($env, $e) = @_; ++ handle_node($env, decompose($_)) foreach @{$e->{l}}; ++} ++sub handle_node { ++ my ($env, $node) = @_; ++ ++ if (!$node->{tag} && $node->{text} !~ /\S/) { ++ } elsif (!$node->{tag}) { ++ install($env, $node->{text}); ++ } elsif ($node->{tag} eq 'if') { ++ my $cond = valid_cond($node->{attr}); ++ handle_nodes($env, $node) if $cond; ++ } elsif ($node->{tag} eq 'if-not') { ++ my $cond = valid_cond($node->{attr}); ++ handle_nodes($env, $node) if !$cond; ++ } elsif (member($node->{tag}, 'from', 'to', 'mode', 'filter')) { ++ handle_nodes(add_to_env($env, $node->{tag} => $node->{attr}), $node); ++ } else { ++ warn "expecting tag <from>, not <$node->{tag}>\n"; ++ } ++} ++ ++sub valid_cond { ++ my ($attr) = @_; ++ every { ++ if ($_ eq 'ARCH') { ++ $ARCH =~ /$attr->{$_}/; ++ } elsif ($_ eq 'set') { ++ $ENV{$attr->{$_}}; ++ } else { ++ die "<if>: unknown condition $_\n"; ++ } ++ } keys %$attr; ++} ++ ++sub add_to_env { ++ my ($env, $tag, $attr) = @_; ++ my %env = map_each { $::a => +{%$::b} } %$env; ++ foreach (keys %$attr) { ++ !$env{$tag}{$_} or die qq(overriding attribute <$tag $_="$env{$tag}{$_}"> with $_="$attr->{$_}"\n); ++ $env{$tag}{$_} = $attr->{$_}; ++ } ++ \%env; ++} ++ ++sub group_by_n { ++ my ($n, $l) = @_; ++ my (@r, $subl); ++ my $i = 0; ++ foreach (@$l) { ++ if ($i % $n == 0) { ++ push @r, $subl = []; ++ } ++ push @$subl, $_; ++ $i++; ++ } ++ @r; ++} ++ ++sub identify_file { ++ my ($dev, $ino) = @_; ++ "$dev:$ino"; ++} ++ ++sub all_files_rec_ { ++ my ($d) = @_; ++ ++ $d, -d $d && ! -l $d ? map { all_files_rec_("$d/$_") } all($d) : (); ++} ++ ++sub expand_macros { ++ my ($f) = @_; ++ $f =~ s!\bLIB\b!$LIB!g; ++ $f =~ s!\bARCH\b!$ARCH!ge; ++ $f =~ s!\$\((\w+)\)!$ENV{$1} || die "$1 undefined\n"!ge; ++ $f; ++} ++ ++my %needed_libraries; ++sub collect_needed_libraries { ++ my (@to_check) = @_; ++ while (@to_check) { ++ my $to_check = join(' ', @to_check); ++ my @l = `ldd $to_check 2>/dev/null` =~ m! => (/\S+)!g; ++ foreach (@l) { ++ if ($main_node->{attr}{'no-arch-libraries'}) { ++ #- replace /lib/tls or /lib/i686 with /lib ++ s!^(/lib(64)?/).*?/!$1! if arch() !~ /x86_64/; ++ } ++ } ++ @to_check = grep { !$needed_libraries{$_}++ } @l; ++ @to_check = (); ++ } ++} ++sub install_needed_libraries { ++ copy_files('', $DEST, [ keys %needed_libraries ], '', '--dereference'); ++} ++ ++sub collect_needed_perl_files { ++ my ($local_rep, $dest, @scripts) = @_; ++ ++ my (%local, %global); ++ foreach my $script (@scripts) { ++ foreach (`strace -efile perl -cw -I$local_rep $script 2>&1`) { ++ my ($f) = /^open\("(.*?)",.*\)\s*=\s*\d+$/ or next; ++ if ($f =~ m!^\Q$local_rep\E/(.*)!) { ++ $local{$1} = 1; ++ } elsif (begins_with($f, '/dev/')) { ++ # skip ++ } elsif (begins_with($f, '/')) { ++ if ($main_node->{attr}{'no-arch-libraries'}) { ++ #- replace /lib/tls or /lib/i686 with /lib ++ $f =~ s!^(/lib(64)?/).*?/!$1! if arch() !~ /x86_64/; ++ } ++ $global{$f} = 1; ++ } ++ } ++ } ++ [ keys %local ], [ keys %global ]; ++} ++ ++sub copy_files { ++ my ($working_dir, $to_dir, $files, $b_flatten, @options) = @_; ++ ++ if ($b_flatten) { ++ mkdir_p($to_dir); ++ my $options = join(' ', '-r', @options); ++ foreach (group_by_n(20, $files)) { ++ warn "cp $options to_dir $to_dir from $working_dir: @$_\n" if $verbose; ++ system("cd $working_dir ; $sudo cp $options @$_ $to_dir"); ++ } ++ } else { ++ my $options = join(' ', $base_cpio_options, @options); ++ warn "cpio $options to_dir=$to_dir from=$working_dir: @$files\n" if $verbose; ++ open(my $F, "| cd $working_dir ; $sudo cpio $options $to_dir"); ++ print $F "$_\n" foreach @$files; ++ close($F) or die "cpio $to_dir failed\n"; ++ } ++} ++ ++sub install { ++ my ($env, $text) = @_; ++ ++ my $from_dir = expand_macros($env->{from}{dir}); ++ my $to_dir = $DEST . expand_macros($env->{to}{dir} || $env->{to}{flatten} && $from_dir || ''); ++ my $copy_mode = $env->{mode}{copy} || ''; ++ my $working_dir = '.'; ++ ++ my $expand = $env->{from}{expand} || ''; ++ ++ my $disallow_from_dir = sub { ++ !$from_dir or die "from dir not allowed with $expand binary\n"; ++ }; ++ ++ my $from_file = sub { ++ my ($rel, $b_full_glob, $b_recursive_dirs) = @_; ++ my $f = expand_macros($from_dir ? "$from_dir/$rel" : $rel); ++ my @l = $f; ++ chdir $working_dir; ++ if ($f =~ /\*/ || $b_full_glob) { ++ @l = File::Glob::bsd_glob($f); #- using bsd_glob because CORE::glob() splits on whitespace and we don't want this ++ if (@l == 0) { ++ error("no match for $f"); ++ } elsif (@l == 1 || $b_full_glob) { ++ } else { ++ error("multiple match for $f"); ++ @l = (); ++ } ++ } elsif (! -e $f) { ++ error("missing file $f ($rel) in $working_dir"); ++ @l = (); ++ } ++ if (@l == 1 && -d $l[0] && $b_recursive_dirs) { ++ @l = all_files_rec_($l[0]); ++ } ++ @l = grep { !m!/(\.svn|CVS)($|/)! } @l; ++ if (my $re = $env->{from}{matching}) { ++ @l = grep { eval $re } @l; ++ } ++ ++ collect_needed_libraries(grep { -f $_ && -x $_ } @l); ++ ++ chdir $initial_dir; ++ @l; ++ }; ++ ++ my @text_l = $env->{from}{spaces_in_filename} ? $text =~ /^\s*(.*?)\s*$/ : split(' ', $text); ++ my @files; ++ if ($expand eq 'tar') { ++ foreach (@text_l) { ++ my ($tarball) = $from_file->($_) or next; ++ system('tar', 'xfj', $tarball, '-C', $to_dir); ++ } ++ # not filling @files, things are already done ++ ++ } elsif ($expand eq 'command') { ++ @files = chomp_(`$text`); ++ ++ } elsif ($expand eq 'glob') { ++ #- glob done in $from_file ++ @files = @text_l; ++ ++ } elsif ($expand eq 'binary') { ++ $disallow_from_dir->(); ++ my @PATH = qw(/sbin /bin /usr/bin /usr/sbin /usr/X11R6/bin); ++ foreach my $name (map { expand_macros($_) } @text_l) { ++ my @l = grep { -x $_ } map { "$_/$name" } @PATH; ++ @l or error("can't find binary $name"), next; ++ if (@l > 1) { ++ my @m = grep { ! -l $_ } @l; ++ if (@m == 1) { ++ my $id = identify_file($m[0]); ++ push @files, grep { -l $_ && identify_file($_) eq $id } @l; ++ } ++ @l = @m if @m; ++ } ++ if (@l > 1) { ++ warn "many matches for binary $name: " . join(' ', @l) . ", choosing $l[0]\n"; ++ } ++ my $f = $l[0]; ++ while (1) { ++ push @files, $f; ++ $copy_mode ne 'dereference' or last; ++ my $l = readlink($f) or last; ++ if ($l =~ m!/! && $l !~ m!^\.\..*/s?bin/[^/]+$!) { ++ warn "keeping symlink $f -> $l as is\n"; ++ last; ++ } ++ $f = dirname($f) . '/' . $l; ++ } ++ } ++ $copy_mode ||= 'keep-links'; ++ $env->{filter}{command} ||= 'strip'; ++ ++ } elsif ($expand eq 'rpm') { ++ $disallow_from_dir->(); ++ foreach my $rpm (@text_l) { ++ my @l = chomp_(`rpm -ql $rpm`) or error("rpm $rpm must be installed"); ++ push @files, @l; ++ } ++ ++ } elsif ($expand eq 'perl') { ++ $disallow_from_dir->(); ++ $from_dir = '/usr/lib/perl5/vendor_perl/*'; ++ @files = @text_l; ++ } elsif ($expand eq 'main-perl') { ++ $disallow_from_dir->(); ++ $from_dir = $Config{privlib}; ++ @files = @text_l; ++ } elsif ($expand =~ /collect-perl-files/) { ++ my (undef, $local, $to) = split(' ', $expand); ++ ++ @files = @text_l; ++ warn "collect-perl-files $local $to @files ($env->{filter}{command})\n"; ++ my ($local_perl_files, $global_perl_files) = collect_needed_perl_files($local, $to, @files); ++ warn "collect-perl-files gave: ", join(' ', @$local_perl_files), "\n"; ++# warn " and: ", join(' ', @$global_perl_files), "\n"; ++ copy_and_filter($local =~ m!/! ? $local : "$working_dir/$local", "$DEST$to", $local_perl_files, $env->{filter}, '', '--dereference'); ++ copy_and_filter('', $DEST, $global_perl_files, $env->{filter}, '', '--dereference'); ++ ++ } elsif ($expand) { ++ die "unknown expand method $expand\n"; ++ } else { ++ @files = @text_l; ++ ++ $env->{filter}{command} ||= 'strip' if $to_dir =~ m!/bin$!; ++ } ++ ++ if ($env->{to}{dir} && $from_dir) { ++ $working_dir = $from_dir; ++ undef $from_dir; ++ } ++ ++ my @all_files = map { $from_file->($_, $expand eq 'glob', $expand ne 'rpm') } @files; ++ ++ my @options = ( ++ if_($copy_mode ne 'keep-links', '--dereference'), ++ ); ++ if (@all_files) { ++ copy_and_filter($working_dir, $to_dir, \@all_files, $env->{filter}, $env->{to}{flatten}, @options); ++ } ++} ++ ++sub copy_and_filter { ++ my ($working_dir, $to_dir, $all_files, $filter, $flatten, @copy_options) = @_; ++ ++ copy_files($working_dir, $to_dir, $all_files, $flatten, @copy_options); ++ apply_filter($to_dir, $filter, $all_files, $flatten); ++} ++ ++sub apply_filter { ++ my ($to_dir, $filter, $all_files, $b_flatten) = @_; ++ ++ chdir $to_dir; ++ foreach (group_by_n(20, $all_files)) { ++ my @l = $b_flatten ? (map { basename($_) } @$_) : (map { "./$_" } @$_); ++ @l = grep { ! -d $_ } @l or next; ++ ++ if (my $subst = $filter->{subst}) { ++ system('perl', '-pi', '-e', $subst, @l); ++ } ++ if (my $command = $filter->{command}) { ++ $command = $initial_dir . "/$command" if $command =~ m!^..?/!; ++ if ($command =~ /simplify-drakx-modules/) { ++ @l = grep { !/\.so($|\.)/ } @l or next; ++ } ++ my @options = ( ++ if_($command eq 'gzip', '-9f'), ++ if_($command eq 'strip', '2>/dev/null'), ++ ); ++ warn "running $command @options @l\n" if $verbose; ++ system(join(' ', $command, @options, @l)); ++ } ++ } ++ chdir $initial_dir; ++} ++ ++sub decompose { ++ my ($tree) = @_; ++ my ($tag, $val) = @$tree; ++ if ($tag eq '0') { ++ { text => $val }; ++ } else { ++ my ($attr, @l) = @$val; ++ { tag => $tag, attr => $attr, l => [ group_by2(@l) ] }; ++ } ++} + + +Property changes on: drakx/trunk/tools/install-xml-file-list +___________________________________________________________________ +Added: svn:executable + + * + +Added: drakx/trunk/tools/make_lang_png_transparent.c +=================================================================== +--- drakx/trunk/tools/make_lang_png_transparent.c (rev 0) ++++ drakx/trunk/tools/make_lang_png_transparent.c 2011-02-06 23:23:30 UTC (rev 450) +@@ -0,0 +1,167 @@ ++/* ++ * Guillaume Cottenceau (gc at mandriva.com) ++ * ++ * Copyright 2002-2005 Mandriva ++ * ++ * This software may be freely redistributed under the terms of the GNU ++ * public license. ++ * ++ */ ++ ++#include <unistd.h> ++#include <stdio.h> ++#include <string.h> ++#include <stdarg.h> ++ ++#define PNG_DEBUG 3 ++#include <png.h> ++ ++void abort_(const char * s, ...) ++{ ++ va_list args; ++ va_start(args, s); ++ vfprintf(stderr, s, args); ++ fprintf(stderr, "\n"); ++ va_end(args); ++ abort(); ++} ++ ++int x, y; ++ ++int width, height; ++png_byte color_type; ++png_byte bit_depth; ++ ++png_structp png_ptr; ++png_infop info_ptr; ++int number_of_passes; ++png_bytep * row_pointers; ++ ++void read_png_file(char* file_name) ++{ ++ char header[8]; // 8 is the maximum size that can be checked ++ ++ /* open file and test for it being a png */ ++ FILE *fp = fopen(file_name, "rb"); ++ if (!fp) ++ abort_("[read_png_file] File %s could not be opened for reading", file_name); ++ fread(header, 1, 8, fp); ++ if (png_sig_cmp(header, 0, 8)) ++ abort_("[read_png_file] File %s is not recognized as a PNG file", file_name); ++ ++ ++ /* initialize stuff */ ++ png_ptr = png_create_read_struct(PNG_LIBPNG_VER_STRING, NULL, NULL, NULL); ++ ++ if (!png_ptr) ++ abort_("[read_png_file] png_create_read_struct failed"); ++ ++ info_ptr = png_create_info_struct(png_ptr); ++ if (!info_ptr) ++ abort_("[read_png_file] png_create_info_struct failed"); ++ ++ if (setjmp(png_jmpbuf(png_ptr))) ++ abort_("[read_png_file] Error during init_io"); ++ ++ png_init_io(png_ptr, fp); ++ png_set_sig_bytes(png_ptr, 8); ++ ++ png_read_info(png_ptr, info_ptr); ++ ++ width = info_ptr->width; ++ height = info_ptr->height; ++ color_type = info_ptr->color_type; ++ bit_depth = info_ptr->bit_depth; ++ ++ number_of_passes = png_set_interlace_handling(png_ptr); ++ png_read_update_info(png_ptr, info_ptr); ++ ++ ++ /* read file */ ++ if (setjmp(png_jmpbuf(png_ptr))) ++ abort_("[read_png_file] Error during read_image"); ++ ++ row_pointers = (png_bytep*) malloc(sizeof(png_bytep) * height); ++ for (y=0; y<height; y++) ++ row_pointers[y] = (png_byte*) malloc(info_ptr->rowbytes); ++ ++ png_read_image(png_ptr, row_pointers); ++} ++ ++ ++void write_png_file(char* file_name) ++{ ++ /* create file */ ++ FILE *fp = fopen(file_name, "wb"); ++ if (!fp) ++ abort_("[write_png_file] File %s could not be opened for writing", file_name); ++ ++ ++ /* initialize stuff */ ++ png_ptr = png_create_write_struct(PNG_LIBPNG_VER_STRING, NULL, NULL, NULL); ++ ++ if (!png_ptr) ++ abort_("[write_png_file] png_create_write_struct failed"); ++ ++ info_ptr = png_create_info_struct(png_ptr); ++ if (!info_ptr) ++ abort_("[write_png_file] png_create_info_struct failed"); ++ ++ if (setjmp(png_jmpbuf(png_ptr))) ++ abort_("[write_png_file] Error during init_io"); ++ ++ png_init_io(png_ptr, fp); ++ ++ ++ /* write header */ ++ if (setjmp(png_jmpbuf(png_ptr))) ++ abort_("[write_png_file] Error during writing header"); ++ ++ png_set_IHDR(png_ptr, info_ptr, width, height, ++ bit_depth, color_type, PNG_INTERLACE_NONE, ++ PNG_COMPRESSION_TYPE_BASE, PNG_FILTER_TYPE_BASE); ++ ++ png_write_info(png_ptr, info_ptr); ++ ++ ++ /* write bytes */ ++ if (setjmp(png_jmpbuf(png_ptr))) ++ abort_("[write_png_file] Error during writing bytes"); ++ ++ png_write_image(png_ptr, row_pointers); ++ ++ ++ /* end write */ ++ if (setjmp(png_jmpbuf(png_ptr))) ++ abort_("[write_png_file] Error during end of write"); ++ ++ png_write_end(png_ptr, NULL); ++ ++} ++ ++void process_file(void) ++{ ++ if (info_ptr->color_type != PNG_COLOR_TYPE_RGBA) ++ abort_("[process_file] color_type of input file must be PNG_COLOR_TYPE_RGBA (is %d)", info_ptr->color_type); ++ ++ for (y=0; y<height; y++) { ++ png_byte* row = row_pointers[y]; ++ for (x=0; x<width; x++) { ++ png_byte* ptr = &(row[x*4]); ++ ptr[3] = 255-ptr[0]; ++ ptr[0] = ptr[1] = ptr[2] = 0; ++ } ++ } ++ ++} ++ ++ ++int main(int argc, char **argv) ++{ ++ if (argc != 3) ++ abort_("Usage: program_name <file_in> <file_out>"); ++ ++ read_png_file(argv[1]); ++ process_file(); ++ write_png_file(argv[2]); ++} + + +Property changes on: drakx/trunk/tools/make_lang_png_transparent.c +___________________________________________________________________ +Added: svn:eol-style + + native + +Added: drakx/trunk/tools/mdkinst_stage2_tool +=================================================================== +--- drakx/trunk/tools/mdkinst_stage2_tool (rev 0) ++++ drakx/trunk/tools/mdkinst_stage2_tool 2011-02-06 23:23:30 UTC (rev 450) +@@ -0,0 +1,66 @@ ++#!/bin/sh ++ ++error() { ++ cat <<EOF; ++usage: mdkinst_stage2_tool [--clean] [--compress | --uncompress] <stage2 dir> [<compressed file>] ++EOF ++ exit 1 ++} ++ ++if [ "$1" = "--clean" ]; then ++ CLEAN=1 ++ shift ++fi ++ ++[ $# = 2 -o $# = 3 ] || error ++ ++if [ "$1" = "--compress" -o "$1" == "--uncompress" ]; then ++ ACTION=$1 ++ shift ++ STAGE2_DIR="$1" ++ shift ++ LIVE_DIR="$STAGE2_DIR/live" ++ if [ -n "$1" ]; then ++ COMPRESSED_IMAGE=$1 ++ shift ++ else ++ COMPRESSED_IMAGE="$STAGE2_DIR/mdkinst.sqfs" ++ fi ++else ++ error ++fi ++ ++if [ $ACTION = "--compress" ]; then ++ which mksquashfs >/dev/null 2>/dev/null || { echo "missing command mksquashfs (from squashfs-tools)"; exit 1; } ++ ++ [ -d "$LIVE_DIR" ] || error ++ echo "Creating $COMPRESSED_IMAGE from $LIVE_DIR" ++ rm -f $STAGE2_DIR/.room ++ mksquashfs $LIVE_DIR $COMPRESSED_IMAGE -all-root -noappend >/dev/null || { echo "mksquashfs failed"; exit 1; } ++ chmod 755 $COMPRESSED_IMAGE ++ echo foo > $STAGE2_DIR/.room ++ if [ -s $STAGE2_DIR/.room ]; then ++ rm -f $STAGE2_DIR/.room ++ [ -n "$CLEAN" ] && rm -rf $LIVE_DIR ++ else ++ echo "not enough space" ++ rm -f $COMPRESSED_IMAGE ++ exit 1 ++ fi ++else ++ which unsquashfs >/dev/null 2>/dev/null || { echo "missing command unsquashfs (from squashfs-tools)"; exit 1; } ++ ++ [ -f "$COMPRESSED_IMAGE" ] || error ++ echo "Creating $LIVE_DIR from $COMPRESSED_IMAGE" ++ ++ if [ $EUID != "0" ]; then ++ SUDO="sudo" ++ PATH="/sbin:/usr/sbin:$PATH" ++ fi ++ ++ unsquashfs -dest $LIVE_DIR $COMPRESSED_IMAGE || { rm -rf $LIVE_DIR; exit 1; } ++ ++ [ -n "$CLEAN" ] && rm -f $COMPRESSED_IMAGE ++fi ++ ++exit 0 + + +Property changes on: drakx/trunk/tools/mdkinst_stage2_tool +___________________________________________________________________ +Added: svn:executable + + * + +Added: drakx/trunk/tools/ntp_servers.pl +=================================================================== +--- drakx/trunk/tools/ntp_servers.pl (rev 0) ++++ drakx/trunk/tools/ntp_servers.pl 2011-02-06 23:23:30 UTC (rev 450) +@@ -0,0 +1,303 @@ ++#!/usr/bin/perl ++ ++#open F, "/usr/bin/lynx -dump <A HREF="http://www.eecis.udel.edu/~mills/ntp/clock1a.html|">http://www.eecis.udel.edu/~mills/ntp/clock1a.html|</A>"; ++open(my $G, "/usr/bin/lynx -dump <A HREF="http://www.eecis.udel.edu/~mills/ntp/clock2a.html|">http://www.eecis.udel.edu/~mills/ntp/clock2a.html|</A>"); ++ ++# Chris Kloiber <<A HREF="https://www.mageia.org/mailman/listinfo/mageia-sysadm">ckloiber at redhat.com</A>> writes: ++# > It's not considered polite to use the Stratum 1 servers for purposes that ++# > are not absolutely critical. I would use Stratum 2 servers and live with ++# > the few nanoseconds difference. ++#parse() while <F>; ++ ++parse($_) while <$G>; ++ ++my @all; ++my ($l, $nb); ++sub parse { ++ local ($_) = @_; ++ /Active Servers/ .. /Discontinued Service/ or return; ++ if (/^\s+\d+\. ([A-Z ]*[A-Z]);?\s+([.\w-]+)/) { ++ push @all, $l = { name => $2, indic => $1 }; ++ $nb = 0; ++ } else { ++ s/^\s*//; ++ s/\s*$//; ++ my ($field, $val) = /^(.*):\s*(.*)/; ++ if ($field =~ /policy/i) { ++ $field = "policy"; ++ $val = lc join(' ', split(' ', $val)); ++ $val =~ s/glad to receive a note//; ++ $val =~ s/(but )?please send (a )?message to notify//; ++ $val =~ s/an email note is appreciated//; ++ $val =~ s/please send a message with the//; ++ $val =~ s/no need to notify//; ++ $val =~ s/[(), .;]*$//; ++ $val = "open access" if $val eq "public"; ++ warn "$val ($all[-1]{name})\n" if $val ne 'open access'; ++ } elsif ($field =~ /^Contact|Synchroni[sz]ation|Location|Geographic\s+Coordinates|Service\s+Area|Note$/i) { ++ } else { ++# warn "bad line ($field) $_\n"; ++ return; ++ } ++ $l->{$field} .= ($l->{$field} && ' ') . $val; ++ } ++ $nb++; ++} ++ ++ ++use Data::Dumper; ++#warn Dumper(\@all); ++ ++foreach (grep { $_->{policy} eq 'open access' } @all) { ++ my ($country, $state) = split ' ', $_->{indic}; ++ $country = ucfirst(lc $country_codes{$country}); ++ $country .= " $state" if $state; ++ printf "\t'%s' => '%s',\n", lc($_->{name}), $country; ++} ++ ++BEGIN { ++%country_codes = ( # from <A HREF="ftp://ftp.ripe.net/iso3166-countrycodes">ftp://ftp.ripe.net/iso3166-countrycodes</A> ++"AF", "AFGHANISTAN", ++"AL", "ALBANIA", ++"DZ", "ALGERIA", ++"AS", "AMERICAN SAMOA", ++"AD", "ANDORRA", ++"AO", "ANGOLA", ++"AI", "ANGUILLA", ++"AQ", "ANTARCTICA", ++"AG", "ANTIGUA AND BARBUDA", ++"AR", "ARGENTINA", ++"AM", "ARMENIA", ++"AW", "ARUBA", ++"AU", "AUSTRALIA", ++"AT", "AUSTRIA", ++"AZ", "AZERBAIJAN", ++"BS", "BAHAMAS", ++"BH", "BAHRAIN", ++"BD", "BANGLADESH", ++"BB", "BARBADOS", ++"BY", "BELARUS", ++"BE", "BELGIUM", ++"BZ", "BELIZE", ++"BJ", "BENIN", ++"BM", "BERMUDA", ++"BT", "BHUTAN", ++"BO", "BOLIVIA", ++"BA", "BOSNIA AND HERZEGOWINA", ++"BW", "BOTSWANA", ++"BV", "BOUVET ISLAND", ++"BR", "BRAZIL", ++"IO", "BRITISH INDIAN OCEAN TERRITORY", ++"BN", "BRUNEI DARUSSALAM", ++"BG", "BULGARIA", ++"BF", "BURKINA FASO", ++"BI", "BURUNDI", ++"KH", "CAMBODIA", ++"CM", "CAMEROON", ++"CA", "CANADA", ++"CV", "CAPE VERDE", ++"KY", "CAYMAN ISLANDS", ++"CF", "CENTRAL AFRICAN REPUBLIC", ++"TD", "CHAD", ++"CL", "CHILE", ++"CN", "CHINA", ++"CX", "CHRISTMAS ISLAND", ++"CC", "COCOS (KEELING) ISLANDS", ++"CO", "COLOMBIA", ++"KM", "COMOROS", ++"CG", "CONGO", ++"CD", "CONGO, THE DEMOCRATIC REPUBLIC OF THE", ++"CK", "COOK ISLANDS", ++"CR", "COSTA RICA", ++"CI", "COTE D'IVOIRE", ++"HR", "CROATIA", ++"CU", "CUBA", ++"CY", "CYPRUS", ++"CZ", "CZECH REPUBLIC", ++"DK", "DENMARK", ++"DJ", "DJIBOUTI", ++"DM", "DOMINICA", ++"DO", "DOMINICAN REPUBLIC", ++"TP", "EAST TIMOR", ++"EC", "ECUADOR", ++"EG", "EGYPT", ++"SV", "EL SALVADOR", ++"GQ", "EQUATORIAL GUINEA", ++"ER", "ERITREA", ++"EE", "ESTONIA", ++"ET", "ETHIOPIA", ++"FK", "FALKLAND ISLANDS (MALVINAS)", ++"FO", "FAROE ISLANDS", ++"FJ", "FIJI", ++"FI", "FINLAND", ++"FR", "FRANCE", ++"FX", "FRANCE, METROPOLITAN", ++"GF", "FRENCH GUIANA", ++"PF", "FRENCH POLYNESIA", ++"TF", "FRENCH SOUTHERN TERRITORIES", ++"GA", "GABON", ++"GM", "GAMBIA", ++"GE", "GEORGIA", ++"DE", "GERMANY", ++"GH", "GHANA", ++"GI", "GIBRALTAR", ++"GR", "GREECE", ++"GL", "GREENLAND", ++"GD", "GRENADA", ++"GP", "GUADELOUPE", ++"GU", "GUAM", ++"GT", "GUATEMALA", ++"GN", "GUINEA", ++"GW", "GUINEA-BISSAU", ++"GY", "GUYANA", ++"HT", "HAITI", ++"HM", "HEARD AND MC DONALD ISLANDS", ++"VA", "HOLY SEE (VATICAN CITY STATE)", ++"HN", "HONDURAS", ++"HK", "HONG KONG", ++"HU", "HUNGARY", ++"IS", "ICELAND", ++"IN", "INDIA", ++"ID", "INDONESIA", ++"IR", "IRAN (ISLAMIC REPUBLIC OF)", ++"IQ", "IRAQ", ++"IE", "IRELAND", ++"IL", "ISRAEL", ++"IT", "ITALY", ++"JM", "JAMAICA", ++"JP", "JAPAN", ++"JO", "JORDAN", ++"KZ", "KAZAKHSTAN", ++"KE", "KENYA", ++"KI", "KIRIBATI", ++"KP", "KOREA, DEMOCRATIC PEOPLE'S REPUBLIC OF", ++"KR", "KOREA, REPUBLIC OF", ++"KW", "KUWAIT", ++"KG", "KYRGYZSTAN", ++"LA", "LAO PEOPLE'S DEMOCRATIC REPUBLIC", ++"LV", "LATVIA", ++"LB", "LEBANON", ++"LS", "LESOTHO", ++"LR", "LIBERIA", ++"LY", "LIBYAN ARAB JAMAHIRIYA", ++"LI", "LIECHTENSTEIN", ++"LT", "LITHUANIA", ++"LU", "LUXEMBOURG", ++"MO", "MACAU", ++"MK", "MACEDONIA, THE FORMER YUGOSLAV REPUBLIC OF", ++"MG", "MADAGASCAR", ++"MW", "MALAWI", ++"MY", "MALAYSIA", ++"MV", "MALDIVES", ++"ML", "MALI", ++"MT", "MALTA", ++"MH", "MARSHALL ISLANDS", ++"MQ", "MARTINIQUE", ++"MR", "MAURITANIA", ++"MU", "MAURITIUS", ++"YT", "MAYOTTE", ++"MX", "MEXICO", ++"FM", "MICRONESIA, FEDERATED STATES OF", ++"MD", "MOLDOVA, REPUBLIC OF", ++"MC", "MONACO", ++"MN", "MONGOLIA", ++"MS", "MONTSERRAT", ++"MA", "MOROCCO", ++"MZ", "MOZAMBIQUE", ++"MM", "MYANMAR", ++"NA", "NAMIBIA", ++"NR", "NAURU", ++"NP", "NEPAL", ++"NL", "NETHERLANDS", ++"AN", "NETHERLANDS ANTILLES", ++"NC", "NEW CALEDONIA", ++"NZ", "NEW ZEALAND", ++"NI", "NICARAGUA", ++"NE", "NIGER", ++"NG", "NIGERIA", ++"NU", "NIUE", ++"NF", "NORFOLK ISLAND", ++"MP", "NORTHERN MARIANA ISLANDS", ++"NO", "NORWAY", ++"OM", "OMAN", ++"PK", "PAKISTAN", ++"PW", "PALAU", ++"PA", "PANAMA", ++"PG", "PAPUA NEW GUINEA", ++"PY", "PARAGUAY", ++"PE", "PERU", ++"PH", "PHILIPPINES", ++"PN", "PITCAIRN", ++"PL", "POLAND", ++"PT", "PORTUGAL", ++"PR", "PUERTO RICO", ++"QA", "QATAR", ++"RE", "REUNION", ++"RO", "ROMANIA", ++"RU", "RUSSIA", ++"RW", "RWANDA", ++"KN", "SAINT KITTS AND NEVIS", ++"LC", "SAINT LUCIA", ++"VC", "SAINT VINCENT AND THE GRENADINES", ++"WS", "SAMOA", ++"SM", "SAN MARINO", ++"ST", "SAO TOME AND PRINCIPE", ++"SA", "SAUDI ARABIA", ++"SN", "SENEGAL", ++"SC", "SEYCHELLES", ++"SL", "SIERRA LEONE", ++"SG", "SINGAPORE", ++"SK", "SLOVAKIA (Slovak Republic)", ++"SI", "SLOVENIA", ++"SB", "SOLOMON ISLANDS", ++"SO", "SOMALIA", ++"ZA", "SOUTH AFRICA", ++"GS", "SOUTH GEORGIA AND THE SOUTH SANDWICH ISLANDS", ++"ES", "SPAIN", ++"LK", "SRI LANKA", ++"SH", "ST. HELENA", ++"PM", "ST. PIERRE AND MIQUELON", ++"SD", "SUDAN", ++"SR", "SURINAME", ++"SJ", "SVALBARD AND JAN MAYEN ISLANDS", ++"SZ", "SWAZILAND", ++"SE", "SWEDEN", ++"CH", "SWITZERLAND", ++"SY", "SYRIAN ARAB REPUBLIC", ++"TW", "TAIWAN, PROVINCE OF CHINA", ++"TJ", "TAJIKISTAN", ++"TZ", "TANZANIA, UNITED REPUBLIC OF", ++"TH", "THAILAND", ++"TG", "TOGO", ++"TK", "TOKELAU", ++"TO", "TONGA", ++"TT", "TRINIDAD AND TOBAGO", ++"TN", "TUNISIA", ++"TR", "TURKEY", ++"TM", "TURKMENISTAN", ++"TC", "TURKS AND CAICOS ISLANDS", ++"TV", "TUVALU", ++"UG", "UGANDA", ++"UA", "UKRAINE", ++"AE", "UNITED ARAB EMIRATES", ++"GB", "UNITED KINGDOM", ++"US", "UNITED STATES", ++"UM", "UNITED STATES MINOR OUTLYING ISLANDS", ++"UY", "URUGUAY", ++"UZ", "UZBEKISTAN", ++"VU", "VANUATU", ++"VE", "VENEZUELA", ++"VN", "VIET NAM", ++"VG", "VIRGIN ISLANDS (BRITISH)", ++"VI", "VIRGIN ISLANDS (U.S.)", ++"WF", "WALLIS AND FUTUNA ISLANDS", ++"EH", "WESTERN SAHARA", ++"YE", "YEMEN", ++"YU", "YUGOSLAVIA", ++"ZM", "ZAMBIA", ++"ZW", "ZIMBABWE", ++ ++#added ++"UK", "UNITED KINGDOM", ++); ++} + +Added: drakx/trunk/tools/rpcinfo-flushed.c +=================================================================== +--- drakx/trunk/tools/rpcinfo-flushed.c (rev 0) ++++ drakx/trunk/tools/rpcinfo-flushed.c 2011-02-06 23:23:30 UTC (rev 450) +@@ -0,0 +1,740 @@ ++#define _(x) x ++ ++/* @(#)rpcinfo.c 2.2 88/08/11 4.0 RPCSRC */ ++#if !defined(lint) && defined (SCCSID) ++static char sccsid[] = "@(#)rpcinfo.c 1.22 87/08/12 SMI"; ++#endif ++ ++/* ++ * Copyright (C) 1986, Sun Microsystems, Inc. ++ */ ++ ++/* ++ * rpcinfo: ping a particular rpc program ++ * or dump the portmapper ++ */ ++ ++/* ++ * Sun RPC is a product of Sun Microsystems, Inc. and is provided for ++ * unrestricted use provided that this legend is included on all tape ++ * media and as a part of the software program in whole or part. Users ++ * may copy or modify Sun RPC without charge, but are not authorized ++ * to license or distribute it to anyone else except as part of a product or ++ * program developed by the user. ++ * ++ * SUN RPC IS PROVIDED AS IS WITH NO WARRANTIES OF ANY KIND INCLUDING THE ++ * WARRANTIES OF DESIGN, MERCHANTIBILITY AND FITNESS FOR A PARTICULAR ++ * PURPOSE, OR ARISING FROM A COURSE OF DEALING, USAGE OR TRADE PRACTICE. ++ * ++ * Sun RPC is provided with no support and without any obligation on the ++ * part of Sun Microsystems, Inc. to assist in its use, correction, ++ * modification or enhancement. ++ * ++ * SUN MICROSYSTEMS, INC. SHALL HAVE NO LIABILITY WITH RESPECT TO THE ++ * INFRINGEMENT OF COPYRIGHTS, TRADE SECRETS OR ANY PATENTS BY SUN RPC ++ * OR ANY PART THEREOF. ++ * ++ * In no event will Sun Microsystems, Inc. be liable for any lost revenue ++ * or profits or other special, indirect and consequential damages, even if ++ * Sun has been advised of the possibility of such damages. ++ * ++ * Sun Microsystems, Inc. ++ * 2550 Garcia Avenue ++ * Mountain View, California 94043 ++ */ ++ ++#include <getopt.h> ++#include <string.h> ++#include <unistd.h> ++#include <rpc/rpc.h> ++#include <stdio.h> ++#include <sys/socket.h> ++#include <netinet/in.h> ++#include <arpa/inet.h> ++#include <netdb.h> ++#include <rpc/pmap_prot.h> ++#include <rpc/pmap_clnt.h> ++#include <signal.h> ++#include <ctype.h> ++#include <locale.h> ++#include <libintl.h> ++ ++#define MAXHOSTLEN 256 ++ ++#define MIN_VERS ((u_long) 0) ++#define MAX_VERS ((u_long) 4294967295UL) ++ ++static void udpping (u_short portflag, int argc, char **argv); ++static void tcpping (u_short portflag, int argc, char **argv); ++static int pstatus (CLIENT *client, u_long prognum, u_long vers); ++static void pmapdump (int argc, char **argv); ++static bool_t reply_proc (void *res, struct sockaddr_in *who); ++static void brdcst (int argc, char **argv) __attribute__ ((noreturn)); ++static void deletereg (int argc, char **argv); ++static void usage (void); ++static u_long getprognum (char *arg); ++static u_long getvers (char *arg); ++static void get_inet_address (struct sockaddr_in *addr, char *host); ++ ++/* ++ * Functions to be performed. ++ */ ++#define NONE 0 /* no function */ ++#define PMAPDUMP 1 /* dump portmapper registrations */ ++#define TCPPING 2 /* ping TCP service */ ++#define UDPPING 3 /* ping UDP service */ ++#define BRDCST 4 /* ping broadcast UDP service */ ++#define DELETES 5 /* delete registration for the service */ ++ ++int ++main (int argc, char **argv) ++{ ++ register int c; ++ int errflg; ++ int function; ++ u_short portnum; ++ ++ setlocale (LC_ALL, ""); ++ ++ function = NONE; ++ portnum = 0; ++ errflg = 0; ++ while ((c = getopt (argc, argv, "ptubdn:")) != -1) ++ { ++ switch (c) ++ { ++ ++ case 'p': ++ if (function != NONE) ++ errflg = 1; ++ else ++ function = PMAPDUMP; ++ break; ++ ++ case 't': ++ if (function != NONE) ++ errflg = 1; ++ else ++ function = TCPPING; ++ break; ++ ++ case 'u': ++ if (function != NONE) ++ errflg = 1; ++ else ++ function = UDPPING; ++ break; ++ ++ case 'b': ++ if (function != NONE) ++ errflg = 1; ++ else ++ function = BRDCST; ++ break; ++ ++ case 'n': ++ portnum = (u_short) atoi (optarg); /* hope we don't get bogus # */ ++ break; ++ ++ case 'd': ++ if (function != NONE) ++ errflg = 1; ++ else ++ function = DELETES; ++ break; ++ ++ case '?': ++ errflg = 1; ++ } ++ } ++ ++ if (errflg || function == NONE) ++ { ++ usage (); ++ return 1; ++ } ++ ++ switch (function) ++ { ++ ++ case PMAPDUMP: ++ if (portnum != 0) ++ { ++ usage (); ++ return 1; ++ } ++ pmapdump (argc - optind, argv + optind); ++ break; ++ ++ case UDPPING: ++ udpping (portnum, argc - optind, argv + optind); ++ break; ++ ++ case TCPPING: ++ tcpping (portnum, argc - optind, argv + optind); ++ break; ++ ++ case BRDCST: ++ if (portnum != 0) ++ { ++ usage (); ++ return 1; ++ } ++ brdcst (argc - optind, argv + optind); ++ break; ++ ++ case DELETES: ++ deletereg (argc - optind, argv + optind); ++ break; ++ } ++ ++ return 0; ++} ++ ++static void ++udpping (portnum, argc, argv) ++ u_short portnum; ++ int argc; ++ char **argv; ++{ ++ struct timeval to; ++ struct sockaddr_in addr; ++ enum clnt_stat rpc_stat; ++ CLIENT *client; ++ u_long prognum, vers, minvers, maxvers; ++ int sock = RPC_ANYSOCK; ++ struct rpc_err rpcerr; ++ int failure; ++ ++ if (argc < 2 || argc > 3) ++ { ++ usage (); ++ exit (1); ++ } ++ prognum = getprognum (argv[1]); ++ get_inet_address (&addr, argv[0]); ++ /* Open the socket here so it will survive calls to clnt_destroy */ ++ sock = socket (AF_INET, SOCK_DGRAM, IPPROTO_UDP); ++ if (sock < 0) ++ { ++ perror ("rpcinfo: socket"); ++ exit (1); ++ } ++ failure = 0; ++ if (argc == 2) ++ { ++ /* ++ * A call to version 0 should fail with a program/version ++ * mismatch, and give us the range of versions supported. ++ */ ++ addr.sin_port = htons (portnum); ++ to.tv_sec = 5; ++ to.tv_usec = 0; ++ if ((client = clntudp_create (&addr, prognum, (u_long) 0, ++ to, &sock)) == NULL) ++ { ++ clnt_pcreateerror ("rpcinfo"); ++ printf (_("program %lu is not available\n"), prognum); ++ exit (1); ++ } ++ to.tv_sec = 10; ++ to.tv_usec = 0; ++ rpc_stat = clnt_call (client, NULLPROC, (xdrproc_t) xdr_void, ++ (char *) NULL, (xdrproc_t) xdr_void, ++ (char *) NULL, to); ++ if (rpc_stat == RPC_PROGVERSMISMATCH) ++ { ++ clnt_geterr (client, &rpcerr); ++ minvers = rpcerr.re_vers.low; ++ maxvers = rpcerr.re_vers.high; ++ } ++ else if (rpc_stat == RPC_SUCCESS) ++ { ++ /* ++ * Oh dear, it DOES support version 0. ++ * Let's try version MAX_VERS. ++ */ ++ addr.sin_port = htons (portnum); ++ to.tv_sec = 5; ++ to.tv_usec = 0; ++ if ((client = clntudp_create (&addr, prognum, MAX_VERS, ++ to, &sock)) == NULL) ++ { ++ clnt_pcreateerror ("rpcinfo"); ++ printf (_("program %lu version %lu is not available\n"), ++ prognum, MAX_VERS); ++ exit (1); ++ } ++ to.tv_sec = 10; ++ to.tv_usec = 0; ++ rpc_stat = clnt_call (client, NULLPROC, (xdrproc_t) xdr_void, ++ NULL, (xdrproc_t) xdr_void, NULL, to); ++ if (rpc_stat == RPC_PROGVERSMISMATCH) ++ { ++ clnt_geterr (client, &rpcerr); ++ minvers = rpcerr.re_vers.low; ++ maxvers = rpcerr.re_vers.high; ++ } ++ else if (rpc_stat == RPC_SUCCESS) ++ { ++ /* ++ * It also supports version MAX_VERS. ++ * Looks like we have a wise guy. ++ * OK, we give them information on all ++ * 4 billion versions they support... ++ */ ++ minvers = 0; ++ maxvers = MAX_VERS; ++ } ++ else ++ { ++ (void) pstatus (client, prognum, MAX_VERS); ++ exit (1); ++ } ++ } ++ else ++ { ++ (void) pstatus (client, prognum, (u_long) 0); ++ exit (1); ++ } ++ clnt_destroy (client); ++ for (vers = minvers; vers <= maxvers; vers++) ++ { ++ addr.sin_port = htons (portnum); ++ to.tv_sec = 5; ++ to.tv_usec = 0; ++ if ((client = clntudp_create (&addr, prognum, vers, ++ to, &sock)) == NULL) ++ { ++ clnt_pcreateerror ("rpcinfo"); ++ printf (_("program %lu version %lu is not available\n"), ++ prognum, vers); ++ exit (1); ++ } ++ to.tv_sec = 10; ++ to.tv_usec = 0; ++ rpc_stat = clnt_call (client, NULLPROC, (xdrproc_t) xdr_void, ++ NULL, (xdrproc_t) xdr_void, NULL, to); ++ if (pstatus (client, prognum, vers) < 0) ++ failure = 1; ++ clnt_destroy (client); ++ } ++ } ++ else ++ { ++ vers = getvers (argv[2]); ++ addr.sin_port = htons (portnum); ++ to.tv_sec = 5; ++ to.tv_usec = 0; ++ if ((client = clntudp_create (&addr, prognum, vers, ++ to, &sock)) == NULL) ++ { ++ clnt_pcreateerror ("rpcinfo"); ++ printf (_("program %lu version %lu is not available\n"), ++ prognum, vers); ++ exit (1); ++ } ++ to.tv_sec = 10; ++ to.tv_usec = 0; ++ rpc_stat = clnt_call (client, 0, (xdrproc_t) xdr_void, NULL, ++ (xdrproc_t) xdr_void, NULL, to); ++ if (pstatus (client, prognum, vers) < 0) ++ failure = 1; ++ } ++ (void) close (sock); /* Close it up again */ ++ if (failure) ++ exit (1); ++} ++ ++static void ++tcpping (portnum, argc, argv) ++ u_short portnum; ++ int argc; ++ char **argv; ++{ ++ struct timeval to; ++ struct sockaddr_in addr; ++ enum clnt_stat rpc_stat; ++ CLIENT *client; ++ u_long prognum, vers, minvers, maxvers; ++ int sock = RPC_ANYSOCK; ++ struct rpc_err rpcerr; ++ int failure; ++ ++ if (argc < 2 || argc > 3) ++ { ++ usage (); ++ exit (1); ++ } ++ prognum = getprognum (argv[1]); ++ get_inet_address (&addr, argv[0]); ++ failure = 0; ++ if (argc == 2) ++ { ++ /* ++ * A call to version 0 should fail with a program/version ++ * mismatch, and give us the range of versions supported. ++ */ ++ addr.sin_port = htons (portnum); ++ if ((client = clnttcp_create (&addr, prognum, MIN_VERS, ++ &sock, 0, 0)) == NULL) ++ { ++ clnt_pcreateerror ("rpcinfo"); ++ printf (_("program %lu is not available\n"), prognum); ++ exit (1); ++ } ++ to.tv_sec = 10; ++ to.tv_usec = 0; ++ rpc_stat = clnt_call (client, NULLPROC, (xdrproc_t) xdr_void, NULL, ++ (xdrproc_t) xdr_void, NULL, to); ++ if (rpc_stat == RPC_PROGVERSMISMATCH) ++ { ++ clnt_geterr (client, &rpcerr); ++ minvers = rpcerr.re_vers.low; ++ maxvers = rpcerr.re_vers.high; ++ } ++ else if (rpc_stat == RPC_SUCCESS) ++ { ++ /* ++ * Oh dear, it DOES support version 0. ++ * Let's try version MAX_VERS. ++ */ ++ addr.sin_port = htons (portnum); ++ if ((client = clnttcp_create (&addr, prognum, MAX_VERS, ++ &sock, 0, 0)) == NULL) ++ { ++ clnt_pcreateerror ("rpcinfo"); ++ printf (_("program %lu version %lu is not available\n"), ++ prognum, MAX_VERS); ++ exit (1); ++ } ++ to.tv_sec = 10; ++ to.tv_usec = 0; ++ rpc_stat = clnt_call (client, NULLPROC, (xdrproc_t) xdr_void, ++ NULL, (xdrproc_t) xdr_void, NULL, to); ++ if (rpc_stat == RPC_PROGVERSMISMATCH) ++ { ++ clnt_geterr (client, &rpcerr); ++ minvers = rpcerr.re_vers.low; ++ maxvers = rpcerr.re_vers.high; ++ } ++ else if (rpc_stat == RPC_SUCCESS) ++ { ++ /* ++ * It also supports version MAX_VERS. ++ * Looks like we have a wise guy. ++ * OK, we give them information on all ++ * 4 billion versions they support... ++ */ ++ minvers = 0; ++ maxvers = MAX_VERS; ++ } ++ else ++ { ++ (void) pstatus (client, prognum, MAX_VERS); ++ exit (1); ++ } ++ } ++ else ++ { ++ (void) pstatus (client, prognum, MIN_VERS); ++ exit (1); ++ } ++ clnt_destroy (client); ++ (void) close (sock); ++ sock = RPC_ANYSOCK; /* Re-initialize it for later */ ++ for (vers = minvers; vers <= maxvers; vers++) ++ { ++ addr.sin_port = htons (portnum); ++ if ((client = clnttcp_create (&addr, prognum, vers, ++ &sock, 0, 0)) == NULL) ++ { ++ clnt_pcreateerror ("rpcinfo"); ++ printf (_("program %lu version %lu is not available\n"), ++ prognum, vers); ++ exit (1); ++ } ++ to.tv_usec = 0; ++ to.tv_sec = 10; ++ rpc_stat = clnt_call (client, 0, (xdrproc_t) xdr_void, NULL, ++ (xdrproc_t) xdr_void, NULL, to); ++ if (pstatus (client, prognum, vers) < 0) ++ failure = 1; ++ clnt_destroy (client); ++ (void) close (sock); ++ sock = RPC_ANYSOCK; ++ } ++ } ++ else ++ { ++ vers = getvers (argv[2]); ++ addr.sin_port = htons (portnum); ++ if ((client = clnttcp_create (&addr, prognum, vers, &sock, ++ 0, 0)) == NULL) ++ { ++ clnt_pcreateerror ("rpcinfo"); ++ printf (_("program %lu version %lu is not available\n"), ++ prognum, vers); ++ exit (1); ++ } ++ to.tv_usec = 0; ++ to.tv_sec = 10; ++ rpc_stat = clnt_call (client, 0, (xdrproc_t) xdr_void, NULL, ++ (xdrproc_t) xdr_void, NULL, to); ++ if (pstatus (client, prognum, vers) < 0) ++ failure = 1; ++ } ++ if (failure) ++ exit (1); ++} ++ ++/* ++ * This routine should take a pointer to an "rpc_err" structure, rather than ++ * a pointer to a CLIENT structure, but "clnt_perror" takes a pointer to ++ * a CLIENT structure rather than a pointer to an "rpc_err" structure. ++ * As such, we have to keep the CLIENT structure around in order to print ++ * a good error message. ++ */ ++static int ++pstatus (client, prognum, vers) ++ register CLIENT *client; ++ u_long prognum; ++ u_long vers; ++{ ++ struct rpc_err rpcerr; ++ ++ clnt_geterr (client, &rpcerr); ++ if (rpcerr.re_status != RPC_SUCCESS) ++ { ++ clnt_perror (client, "rpcinfo"); ++ printf (_("program %lu version %lu is not available\n"), prognum, vers); ++ return -1; ++ } ++ else ++ { ++ printf (_("program %lu version %lu ready and waiting\n"), prognum, vers); ++ return 0; ++ } ++} ++ ++static void ++pmapdump (argc, argv) ++ int argc; ++ char **argv; ++{ ++ struct sockaddr_in server_addr; ++ register struct hostent *hp; ++ struct pmaplist *head = NULL; ++ int socket = RPC_ANYSOCK; ++ struct timeval minutetimeout; ++ register CLIENT *client; ++ struct rpcent *rpc; ++ ++ if (argc > 1) ++ { ++ usage (); ++ exit (1); ++ } ++ if (argc == 1) ++ get_inet_address (&server_addr, argv[0]); ++ else ++ { ++ bzero ((char *) &server_addr, sizeof server_addr); ++ server_addr.sin_family = AF_INET; ++ if ((hp = gethostbyname ("localhost")) != NULL) ++ bcopy (hp->h_addr, (caddr_t) & server_addr.sin_addr, ++ hp->h_length); ++ else ++ server_addr.sin_addr.s_addr = inet_addr ("0.0.0.0"); ++ } ++ minutetimeout.tv_sec = 60; ++ minutetimeout.tv_usec = 0; ++ server_addr.sin_port = htons (PMAPPORT); ++ if ((client = clnttcp_create (&server_addr, PMAPPROG, ++ PMAPVERS, &socket, 50, 500)) == NULL) ++ { ++ clnt_pcreateerror (_("rpcinfo: can't contact portmapper")); ++ exit (1); ++ } ++ if (clnt_call (client, PMAPPROC_DUMP, (xdrproc_t) xdr_void, NULL, ++ (xdrproc_t) xdr_pmaplist, (caddr_t) &head, ++ minutetimeout) != RPC_SUCCESS) ++ { ++ fputs (_("rpcinfo: can't contact portmapper"), stderr); ++ fputs (": ", stderr); ++ clnt_perror (client, "rpcinfo"); ++ exit (1); ++ } ++ if (head == NULL) ++ { ++ fputs (_("No remote programs registered.\n"), stdout); ++ } ++ else ++ { ++ fputs (_(" program vers proto port\n"), stdout); ++ for (; head != NULL; head = head->pml_next) ++ { ++ printf ("%10ld%5ld", ++ head->pml_map.pm_prog, ++ head->pml_map.pm_vers); ++ if (head->pml_map.pm_prot == IPPROTO_UDP) ++ printf ("%6s", "udp"); ++ else if (head->pml_map.pm_prot == IPPROTO_TCP) ++ printf ("%6s", "tcp"); ++ else ++ printf ("%6ld", head->pml_map.pm_prot); ++ printf ("%7ld", head->pml_map.pm_port); ++ rpc = getrpcbynumber (head->pml_map.pm_prog); ++ if (rpc) ++ printf (" %s\n", rpc->r_name); ++ else ++ printf ("\n"); ++ } ++ } ++} ++ ++/* ++ * reply_proc collects replies from the broadcast. ++ * to get a unique list of responses the output of rpcinfo should ++ * be piped through sort(1) and then uniq(1). ++ */ ++ ++/*ARGSUSED */ ++static bool_t ++reply_proc (res, who) ++ void *res; /* Nothing comes back */ ++ struct sockaddr_in *who; /* Who sent us the reply */ ++{ ++ register struct hostent *hp; ++ ++ hp = gethostbyaddr ((char *) &who->sin_addr, sizeof who->sin_addr, ++ AF_INET); ++ printf ("%s %s\n", inet_ntoa (who->sin_addr), ++ (hp == NULL) ? _("(unknown)") : hp->h_name); ++ fflush(stdout); ++ return FALSE; ++} ++ ++static void ++brdcst (argc, argv) ++ int argc; ++ char **argv; ++{ ++ enum clnt_stat rpc_stat; ++ u_long prognum, vers; ++ ++ if (argc != 2) ++ { ++ usage (); ++ exit (1); ++ } ++ prognum = getprognum (argv[0]); ++ vers = getvers (argv[1]); ++ rpc_stat = clnt_broadcast (prognum, vers, NULLPROC, (xdrproc_t) xdr_void, ++ NULL, (xdrproc_t) xdr_void, NULL, ++ (resultproc_t) reply_proc); ++ if ((rpc_stat != RPC_SUCCESS) && (rpc_stat != RPC_TIMEDOUT)) ++ { ++ fprintf (stderr, _("rpcinfo: broadcast failed: %s\n"), ++ clnt_sperrno (rpc_stat)); ++ exit (1); ++ } ++ exit (0); ++} ++ ++static void ++deletereg (argc, argv) ++ int argc; ++ char **argv; ++{ ++ u_long prog_num, version_num; ++ ++ if (argc != 2) ++ { ++ usage (); ++ exit (1); ++ } ++ if (getuid ()) ++ { /* This command allowed only to root */ ++ fputs (_("Sorry. You are not root\n"), stderr); ++ exit (1); ++ } ++ prog_num = getprognum (argv[0]); ++ version_num = getvers (argv[1]); ++ if ((pmap_unset (prog_num, version_num)) == 0) ++ { ++ fprintf (stderr, _("rpcinfo: Could not delete registration for prog %s version %s\n"), ++ argv[0], argv[1]); ++ exit (1); ++ } ++} ++ ++static void ++usage () ++{ ++ fputs (_("Usage: rpcinfo [ -n portnum ] -u host prognum [ versnum ]\n"), ++ stderr); ++ fputs (_(" rpcinfo [ -n portnum ] -t host prognum [ versnum ]\n"), ++ stderr); ++ fputs (_(" rpcinfo -p [ host ]\n"), stderr); ++ fputs (_(" rpcinfo -b prognum versnum\n"), stderr); ++ fputs (_(" rpcinfo -d prognum versnum\n"), stderr); ++} ++ ++static u_long ++getprognum (arg) ++ char *arg; ++{ ++ register struct rpcent *rpc; ++ register u_long prognum; ++ ++ if (isalpha (*arg)) ++ { ++ rpc = getrpcbyname (arg); ++ if (rpc == NULL) ++ { ++ fprintf (stderr, _("rpcinfo: %s is unknown service\n"), arg); ++ exit (1); ++ } ++ prognum = rpc->r_number; ++ } ++ else ++ { ++ prognum = (u_long) atoi (arg); ++ } ++ ++ return prognum; ++} ++ ++static u_long ++getvers (arg) ++ char *arg; ++{ ++ register u_long vers; ++ ++ vers = (int) atoi (arg); ++ return vers; ++} ++ ++static void ++get_inet_address (addr, host) ++ struct sockaddr_in *addr; ++ char *host; ++{ ++ register struct hostent *hp; ++ ++ bzero ((char *) addr, sizeof *addr); ++ addr->sin_addr.s_addr = (u_long) inet_addr (host); ++ if (addr->sin_addr.s_addr == INADDR_NONE ++ || addr->sin_addr.s_addr == INADDR_ANY) ++ { ++ if ((hp = gethostbyname (host)) == NULL) ++ { ++ fprintf (stderr, _("rpcinfo: %s is unknown host\n"), ++ host); ++ exit (1); ++ } ++ bcopy (hp->h_addr, (char *) &addr->sin_addr, hp->h_length); ++ } ++ addr->sin_family = AF_INET; ++} + + +Property changes on: drakx/trunk/tools/rpcinfo-flushed.c +___________________________________________________________________ +Added: svn:eol-style + + native + +Added: drakx/trunk/tools/serial_probe/Makefile +=================================================================== +--- drakx/trunk/tools/serial_probe/Makefile (rev 0) ++++ drakx/trunk/tools/serial_probe/Makefile 2011-02-06 23:23:30 UTC (rev 450) +@@ -0,0 +1,13 @@ ++CFLAGS = -Wall -Os ++CFILES = $(wildcard *.c) ++OFILES = $(CFILES:%.c=%.o) ++GOAL = serial_probe ++ ++$(GOAL): $(OFILES) ++ ++serial.o: serial.c serial.h device.h kudzu.h ++serial_probe.o: serial_probe.c serial.h device.h ++serial_probe: serial_probe.o ++ ++clean: ++ rm -f $(GOAL) $(OFILES) *~ + + +Property changes on: drakx/trunk/tools/serial_probe/Makefile +___________________________________________________________________ +Added: svn:eol-style + + native + +Added: drakx/trunk/tools/serial_probe/device.h +=================================================================== +--- drakx/trunk/tools/serial_probe/device.h (rev 0) ++++ drakx/trunk/tools/serial_probe/device.h 2011-02-06 23:23:30 UTC (rev 450) +@@ -0,0 +1,104 @@ ++/* Copyright 1999-2003 Red Hat, Inc. ++ * ++ * This software may be freely redistributed under the terms of the GNU ++ * public license. ++ * ++ * You should have received a copy of the GNU General Public License ++ * along with this program; if not, write to the Free Software ++ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. ++ * ++ */ ++ ++ ++#ifndef _KUDZU_DEVICES_H_ ++#define _KUDZU_DEVICES_H_ ++ ++#include <stdio.h> ++ ++enum deviceClass { ++ /* device classes... this is somewhat ad-hoc */ ++ CLASS_UNSPEC = ~0, ++ CLASS_OTHER = (1 << 0), ++ CLASS_NETWORK = (1 << 1), ++ CLASS_SCSI = (1 << 2), ++ CLASS_MOUSE = (1 << 3), ++ CLASS_AUDIO = (1 << 4), ++ CLASS_CDROM = (1 << 5), ++ CLASS_MODEM = (1 << 6), ++ CLASS_VIDEO = (1 << 7), ++ CLASS_TAPE = (1 << 8), ++ CLASS_FLOPPY = (1 << 9), ++ CLASS_SCANNER = (1 << 10), ++ CLASS_HD = (1 << 11), ++ CLASS_RAID = (1 << 12), ++ CLASS_PRINTER = (1 << 13), ++ CLASS_CAPTURE = (1 << 14), ++ CLASS_KEYBOARD = (1 << 15), ++ CLASS_MONITOR = (1 << 16), ++ CLASS_USB = (1 << 17), ++ CLASS_SOCKET = (1 << 18), ++ CLASS_FIREWIRE = (1 << 19), ++ CLASS_IDE = (1 << 20) ++}; ++ ++/* Update this if needed */ ++#define CLASS_LAST CLASS_IDE ++ ++enum deviceBus { ++ /* 'bus' that a device is attached to... this is also ad-hoc */ ++ /* BUS_SBUS is sort of a misnomer - it's more or less Sun */ ++ /* OpenPROM probing of all various associated non-PCI buses */ ++ BUS_UNSPEC = ~0, ++ BUS_OTHER = (1 << 0), ++ BUS_PCI = (1 << 1), ++ BUS_SBUS = (1 << 2), ++ BUS_SERIAL = (1 << 3), ++ BUS_PSAUX = (1 << 4), ++ BUS_PARALLEL = (1 << 5), ++ BUS_SCSI = (1 << 6), ++ BUS_IDE = (1 << 7), ++ /* Again, misnomer */ ++ BUS_KEYBOARD = (1 << 8), ++ BUS_DDC = (1 << 9), ++ BUS_USB = (1 << 10), ++ BUS_ISAPNP = (1 << 11), ++ BUS_MISC = (1 << 12), ++ BUS_FIREWIRE = (1 << 13), ++ BUS_PCMCIA = (1 << 14), ++ BUS_ADB = (1 << 15), ++ BUS_MACIO = (1 << 16) ++}; ++ ++struct device { ++ /* This pointer is used to make lists by the library. */ ++ /* Do not expect it to remain constant (or useful) across library calls. */ ++ struct device *next; ++ /* Used for ordering, and for aliasing (modem0, modem1, etc.) */ ++ int index; ++ enum deviceClass type; /* type */ ++ enum deviceBus bus; /* bus it's attached to */ ++ char * device; /* device file associated with it */ ++ char * driver; /* driver to load, if any */ ++ char * desc; /* a description */ ++ int detached; /* should we care if it disappears? */ ++ struct device *(*newDevice) (struct device *old, struct device *new); ++ void (*freeDevice) (struct device *dev); ++ void (*writeDevice) (FILE *file, struct device *dev); ++ int (*compareDevice) (struct device *dev1, struct device *dev2); ++}; ++ ++struct device *newDevice(struct device *old, struct device *new); ++void freeDevice(struct device *dev); ++void writeDevice(FILE *file, struct device *dev); ++int compareDevice(struct device *dev1, struct device *dev2); ++struct device *readDevice(FILE *file); ++ ++/* Most of these aren't implemented yet...... */ ++/* Return everything found, even non-useful stuff */ ++#define PROBE_ALL 1 ++/* Don't do 'dangerous' probes that could do weird things (isapnp, serial) */ ++#define PROBE_SAFE (1<<1) ++/* Stop at first device found */ ++#define PROBE_ONE (1<<2) ++ ++#endif + + +Property changes on: drakx/trunk/tools/serial_probe/device.h +___________________________________________________________________ +Added: svn:eol-style + + native + +Added: drakx/trunk/tools/serial_probe/kudzu.h +=================================================================== +--- drakx/trunk/tools/serial_probe/kudzu.h (rev 0) ++++ drakx/trunk/tools/serial_probe/kudzu.h 2011-02-06 23:23:30 UTC (rev 450) +@@ -0,0 +1,26 @@ ++/* Copyright 1999-2003 Red Hat, Inc. ++ * ++ * This software may be freely redistributed under the terms of the GNU ++ * public license. ++ * ++ * You should have received a copy of the GNU General Public License ++ * along with this program; if not, write to the Free Software ++ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. ++ * ++ */ ++ ++#ifndef _KUDZU_H_ ++#define _KUDZU_H_ ++ ++/* kudzu: it grows on you */ ++ ++/* level of debugging output */ ++#undef DEBUG_LEVEL ++ ++#ifdef DEBUG_LEVEL ++#define DEBUG(s...) fprintf(stderr,s) ++#else ++#define DEBUG(s...) ; ++#endif ++ ++#endif + + +Property changes on: drakx/trunk/tools/serial_probe/kudzu.h +___________________________________________________________________ +Added: svn:eol-style + + native + +Added: drakx/trunk/tools/serial_probe/serial.c +=================================================================== +--- drakx/trunk/tools/serial_probe/serial.c (rev 0) ++++ drakx/trunk/tools/serial_probe/serial.c 2011-02-06 23:23:30 UTC (rev 450) +@@ -0,0 +1,1136 @@ ++/* Copyright 1999-2003 Red Hat, Inc. ++ * ++ * This software may be freely redistributed under the terms of the GNU ++ * public license. ++ * ++ * You should have received a copy of the GNU General Public License ++ * along with this program; if not, write to the Free Software ++ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. ++ * ++ * probe serial port for PnP/Legacy devices ++ */ ++ ++ ++#include <stdio.h> ++#include <stdlib.h> ++#include <fcntl.h> ++#include <unistd.h> ++#include <termios.h> ++#include <errno.h> ++#include <string.h> ++#include <signal.h> ++#include <time.h> ++#include <libgen.h> ++#include <sys/time.h> ++#include <sys/types.h> ++#include <sys/stat.h> ++#include <sys/ioctl.h> ++#include <sys/sysmacros.h> ++ ++#include <asm/types.h> ++#include <linux/serial.h> ++ ++#include "serial.h" ++#include "kudzu.h" ++ ++/* character strings ARE null-terminated in the following structure */ ++/* these elements are marked with a (string) in the comment */ ++/* If PnP device sent 6 bit data stream, we've xlated by a 0x20 offset */ ++/* When computing checksum, must remove this offset */ ++struct pnp_com_id { ++ unsigned char xlate_6bit; /* does this contain xlated data */ ++ unsigned char other_id[17]; /* backward compatibility with pre-PNP */ ++ unsigned char other_len; /* length of the other_id */ ++ unsigned char pnp_rev[2]; /* PnP revision bytes */ ++ unsigned char pnp_rev_str[8]; /* PnP revision (string version) */ ++ unsigned char eisa_id[4]; /* EISA Mfr identifier (string) */ ++ unsigned char product_id[5]; /* Mfr determined product ID (string) */ ++ unsigned char serial_number[9];/* Optional dev serial number (string) */ ++ unsigned char class_name[33]; /* Optional PnP Class name (string) */ ++ unsigned char driver_id[42]; /* Optional compat device IDs (string) */ ++ unsigned char user_name[42]; /* Optional verbose product descr (string)*/ ++ unsigned char checksum[2]; /* Optional checksum */ ++}; ++ ++/* there are two possible bytes to signify the start of a PnP ID string */ ++#define BeginPnP1 0x28 ++#define BeginPnP2 0x08 ++ ++/* Likewise, two possible stop bytes */ ++#define EndPnP1 0x29 ++#define EndPnP2 0x09 ++ ++/* these chars indicate extensions to the base dev id exist */ ++#define ExtendPnP1 0x5c ++#define ExtendPnP2 0x3c ++ ++#define PNP_COM_MAXLEN 256 ++ ++/* results from initiating hardware probe of a hardware device */ ++#define PNP_COM_FATAL 1 /* system error, check errno */ ++#define PNP_COM_FAIL 2 /* probe ok, but found nothing */ ++#define PNP_COM_OK 3 /* probe ok, we found it */ ++ ++/* types of devices we might find */ ++/* if PNP_COM_PNPDEV is NOT set, its a legacy device */ ++#define PNP_COM_MOUSE 1 /* its a mouse */ ++#define PNP_COM_MODEM 2 /* its a modem */ ++#define PNP_COM_OTHER 4 /* device is there, cant tell what kind */ ++#define PNP_COM_NOEXIST 8 /* no device seen */ ++#define PNP_COM_PNPDEV 512 /* its a PNP device */ ++ ++static void serialFreeDevice(struct serialDevice *dev) { ++ if (dev->pnpmfr) free(dev->pnpmfr); ++ if (dev->pnpmodel) free(dev->pnpmodel); ++ if (dev->pnpcompat) free(dev->pnpcompat); ++ if (dev->pnpdesc) free(dev->pnpdesc); ++ freeDevice((struct device *)dev); ++} ++ ++static void serialWriteDevice(FILE *file, struct serialDevice *dev) ++{ ++ writeDevice(file, (struct device *) dev); ++ if (dev->pnpmfr) ++ fprintf(file,"pnpmfr: %s\n",dev->pnpmfr); ++ if (dev->pnpmodel) ++ fprintf(file,"pnpmodel: %s\n",dev->pnpmodel); ++ if (dev->pnpcompat) ++ fprintf(file,"pnpcompat: %s\n",dev->pnpcompat); ++ if (dev->pnpdesc) ++ fprintf(file,"pnpdesc: %s\n",dev->pnpdesc); ++} ++ ++static int serialCompareDevice( struct serialDevice *dev1, struct serialDevice *dev2) ++{ ++ int x; ++ ++ x = compareDevice((struct device *)dev1, (struct device *)dev2); ++ if (x && x!=2) return x; ++ if (dev1->pnpmfr && dev2->pnpmfr && strcmp(dev1->pnpmfr,dev2->pnpmfr)) ++ return 1; ++ if ((!dev1->pnpmfr || !dev2->pnpmfr) && (dev1->pnpmfr != dev2->pnpmfr)) ++ return 1; ++ if (dev1->pnpmodel && dev2->pnpmodel && strcmp(dev1->pnpmodel,dev2->pnpmodel)) ++ return 1; ++ if ((!dev1->pnpmodel || !dev2->pnpmodel) && (dev1->pnpmodel != dev2->pnpmodel)) ++ return 1; ++ if (dev1->pnpcompat && dev2->pnpcompat && strcmp(dev1->pnpcompat,dev2->pnpcompat)) ++ return 1; ++ if ((!dev1->pnpcompat || !dev2->pnpcompat) && (dev1->pnpcompat != dev2->pnpcompat)) ++ return 1; ++ if (dev1->pnpdesc && dev2->pnpdesc && strcmp(dev1->pnpdesc,dev2->pnpdesc)) ++ return 1; ++ if ((!dev1->pnpdesc || !dev2->pnpdesc) && (dev1->pnpdesc != dev2->pnpdesc)) ++ return 1; ++ return x; ++} ++ ++ ++struct serialDevice * serialNewDevice(struct serialDevice *dev) { ++ struct serialDevice *ret; ++ ++ ret = malloc(sizeof(struct serialDevice)); ++ memset(ret,'\0',sizeof(struct serialDevice)); ++ ret=(struct serialDevice *)newDevice((struct device *)dev,(struct device *)ret); ++ ret->bus = BUS_SERIAL; ++ ret->newDevice = serialNewDevice; ++ ret->freeDevice = serialFreeDevice; ++ ret->writeDevice = serialWriteDevice; ++ ret->compareDevice = serialCompareDevice; ++ if (dev && dev->bus == BUS_SERIAL) { ++ if (dev->pnpmfr) ++ ret->pnpmfr=strdup(dev->pnpmfr); ++ if (dev->pnpmodel) ++ ret->pnpmodel=strdup(dev->pnpmodel); ++ if (dev->pnpcompat) ++ ret->pnpcompat=strdup(dev->pnpcompat); ++ if (dev->pnpdesc) ++ ret->pnpdesc=strdup(dev->pnpdesc); ++ } ++ return ret; ++} ++ ++/* ++ * wait_input - wait until there is data available on fd, ++ * for the length of time specified by *timo (indefinite ++ * if timo is NULL). ++ */ ++ ++static int wait_for_input (int fd, struct timeval *timo) { ++ fd_set ready; ++ int n; ++ ++ FD_ZERO(&ready); ++ FD_SET(fd, &ready); ++ ++ n = select(fd+1, &ready, NULL, &ready, timo); ++ return n; ++} ++ ++static int open_serial_port( char *port ) { ++ int fd; ++ ++ DEBUG("opening serial port %s...", port); ++ ++ fd = open( port, O_RDWR | O_NONBLOCK); ++ if (fd < 0) { ++ DEBUG("failed.\n"); ++ return -1; ++ } else { ++ DEBUG("successful.\n"); ++ } ++ ++ /* reset file so it is no longer in non-blocking mode */ ++ if (fcntl(fd, F_SETFL, 0) < 0) { ++ close(fd); ++ DEBUG("Failed to set port to non-blocking mode\n"); ++ return -1; ++ } ++ ++ return fd; ++} ++ ++/* <0 means ioctl error occurred */ ++static int get_serial_lines( int fd ) { ++ int modem_lines; ++ ++ ioctl(fd, TIOCMGET, &modem_lines); ++ return modem_lines; ++} ++ ++/* <0 means ioctl error occurred */ ++static int set_serial_lines( int fd, int modem_lines ) { ++ return ioctl(fd, TIOCMSET, &modem_lines); ++} ++ ++/* set serial port to 1200 baud, 'nbits' bits, 1 stop, no parity */ ++static int setup_serial_port( int fd, int nbits, struct termios *attr ) { ++ ++ DEBUG("setting up serial port\n"); ++ ++ attr->c_iflag = IGNBRK | IGNPAR; ++ attr->c_cflag = 0; ++ attr->c_cflag &= ~(CSIZE | CSTOPB | PARENB | PARODD | PARENB); ++ attr->c_cflag |= CREAD | CLOCAL; /*| CRTSCTS ; */ ++ if (nbits == 7) ++ attr->c_cflag |= CS7 | CSTOPB; ++ else ++ attr->c_cflag |= CS8; ++ attr->c_oflag = 0; ++ attr->c_lflag = 0; ++ ++ attr->c_cc[VMIN] = 1; ++ attr->c_cc[VTIME] = 5; ++ ++ if (cfsetospeed( attr, B1200)) ++ return -1; ++ if (cfsetispeed( attr, B1200)) ++ return -1; ++ return tcsetattr(fd, TCSANOW, attr); ++} ++ ++/* Initialize the serial port to a known state *before* probing. This is ++ * apparently required for some Logitech mice, who will stubbornly refuse ++ * to respond to PnP probes after they've been opened by gpm or XFree. ++ */ ++ ++static int init_port(int fd) { ++ struct termios attr; ++ ++ if (tcgetattr(fd,&attr)) ++ return 1; ++ ++ cfsetospeed(&attr, B2400); ++ cfsetispeed(&attr, B2400); ++ attr.c_iflag = IXON | ICRNL; ++ attr.c_cflag = CLOCAL | HUPCL | CREAD | B9600 | CS8; ++ attr.c_oflag = 0; ++ attr.c_lflag = 0; ++ return tcsetattr(fd, TCSANOW, &attr); ++} ++ ++ ++/* Request for PnP info from serial device */ ++/* See page 6 of the pnpcom doc from Microsoft */ ++/* Return code tells us what happened */ ++/* */ ++/* PNP_COM_FATAL - error, errno has reason */ ++/* PNP_COM_OK - probe initiated successfully */ ++static int init_pnp_com_seq1( int fd ) { ++ int modem_lines; ++ int temp; ++ int dsr_status; ++ int rc = PNP_COM_OK; ++ struct termios portattr; ++ ++ DEBUG("initializing 1st PNP sequence\n"); ++ if (init_port(fd)) ++ return PNP_COM_FATAL; ++ ++ modem_lines = get_serial_lines(fd); ++ ++ /* COM port initialization, check for device enumerate */ ++ ++ /* turn on DTR, turn off RTS */ ++ modem_lines |= TIOCM_DTR; ++ modem_lines &= ~TIOCM_RTS; ++ set_serial_lines(fd, modem_lines); ++ ++ /* wait 200ms for DSR=1 */ ++ usleep(200000); ++ ++ dsr_status = get_serial_lines(fd) & TIOCM_DSR; ++ /* see if we got DSR coming up */ ++ ++ if (!dsr_status) { ++ DEBUG("Device did not set DSR\n"); ++ } ++ ++ /* COM port Setup, 1st phase */ ++ temp = tcgetattr(fd, &portattr); ++ if (temp < 0) ++ return PNP_COM_FATAL; ++ ++ /* now we set port to be 1200 baud, 7 bits, no parity, 1 stop bit */ ++ temp = setup_serial_port( fd, 7, &portattr ); ++ if (temp < 0) ++ return PNP_COM_FATAL; ++ ++ /* we drop DTR and RTS */ ++ modem_lines &= ~( TIOCM_RTS | TIOCM_DTR); ++ set_serial_lines(fd, modem_lines); ++ usleep(200000); ++ ++ /* bring DTR back up */ ++ modem_lines |= TIOCM_DTR; ++ set_serial_lines(fd, modem_lines); ++ usleep(200000); ++ ++ /* Wait for response, 1st phase */ ++ modem_lines |= TIOCM_RTS; ++ set_serial_lines(fd, modem_lines); ++ /* usleep(200000); => AQ: not valid as we should look to receive data during this time!! */ ++ ++ return rc; ++} ++ ++ ++/* Request for PnP info from serial device */ ++/* See page 6 of the pnpcom doc from Microsoft */ ++/* Always returns PNP_COM_OK */ ++static int init_pnp_com_seq2( int fd ) { ++ int modem_lines; ++ int rc = PNP_COM_OK; ++ ++ DEBUG("initializing 2nd PNP sequence\n"); ++ ++ modem_lines = get_serial_lines(fd); ++ ++ /* COM port setup, 2nd phase */ ++ /* turn off DTR and RTS */ ++ modem_lines &= ~(TIOCM_DTR | TIOCM_RTS); ++ set_serial_lines(fd, modem_lines); ++ usleep(200000); ++ ++ /* wait for response, 2nd phase */ ++ /* turn on DTR and RTS */ ++ modem_lines |= (TIOCM_DTR | TIOCM_RTS); ++ set_serial_lines(fd, modem_lines); ++ /* usleep(200000); => AQ: not valid as we should look to receive data during this time!! */ ++ ++ return rc; ++} ++ ++ ++/* Request for PnP info from serial modem device */ ++/* Uses ATI9 code, may not do anything but return 'ERROR' */ ++/* Return code tells us what happened */ ++/* */ ++/* PNP_COM_FATAL - error, errno has reason */ ++/* PNP_COM_OK - probe initiated successfully */ ++/* PNP_COM_FAIL - DSR never came on - try alterntives */ ++/* means (ATI9?) to get PnP string */ ++static int init_pnp_com_ati9( int fd ) { ++ int modem_lines; ++ int temp; ++ int done; ++ int respindex; ++ int starttime; ++ unsigned char resp[100], buf[2]; ++ struct timeval timo; ++ struct termios portattr; ++ ++ DEBUG("Querying ATI9 info from modem\n"); ++ modem_lines = get_serial_lines(fd); ++ ++ /* turn off RTS */ ++ modem_lines &= ~TIOCM_RTS; ++ set_serial_lines(fd, modem_lines); ++ ++ /* wait 200ms for DSR=1 */ ++ usleep(200000); ++ ++ /* now we set port to be 1200 baud, 8 bits, no parity, 1 stop bit */ ++ temp = tcgetattr(fd, &portattr); ++ if (temp < 0) { ++ modem_lines |= TIOCM_DTR | TIOCM_RTS; ++ set_serial_lines(fd, modem_lines); ++ return PNP_COM_FATAL; ++ } ++ ++ /* goto 1200 baud, 8 bits */ ++ temp = setup_serial_port( fd, 8, &portattr ); ++ if (temp < 0) { ++ modem_lines |= TIOCM_DTR | TIOCM_RTS; ++ set_serial_lines(fd, modem_lines); ++ return PNP_COM_FATAL; ++ } ++ ++ /* turn on DTR and RTS */ ++ modem_lines = get_serial_lines(fd); ++ modem_lines |= TIOCM_RTS | TIOCM_DTR; ++ set_serial_lines(fd, modem_lines); ++ usleep(200000); ++ ++ /* send the 'AT' command */ ++ DEBUG("Sending ATI9 command to modem\n"); ++ ++ write(fd, "ATI9\r", 5); ++ ++ /* start reading - read the AT command back */ ++ done = 0; ++ respindex= 0; ++ starttime=time(NULL); ++ memset(resp, 0, sizeof(resp)); ++ while (!done) { ++ timo.tv_sec=0; ++ timo.tv_usec=250000; ++ if (wait_for_input(fd, &timo) > 0) { ++ temp = read( fd, buf, 1 ); ++ if (temp < 0) { ++ if (errno != EAGAIN) ++ return PNP_COM_FATAL; ++ } else { ++ resp[respindex++] = buf[0]; ++ resp[respindex] = 0; ++ } ++ } else ++ done = 1; ++ ++ /* shouldnt run more than 5 seconds */ ++ if (time(NULL)-starttime > 5 ) ++ done = 1; ++ ++ if (respindex > 6) ++ done = 1; ++ ++ if (strstr(resp, "ATI9\r")) ++ done = 1; ++ ++ DEBUG("ATI9 probe ->%d \"%s\"\n",respindex, resp); ++ } ++ ++ /* see if we saw the 'OK' response */ ++ if (strstr(resp, "(")) ++ return PNP_COM_OK; ++ else ++ return PNP_COM_FAIL; ++ ++ return PNP_COM_OK; ++} ++ ++/* See if this is a legacy mouse device */ ++/* Only called if the PnP probe above failed */ ++/* We turn off the mouse via RS232 lines, then turn it on */ ++/* If it spits out an 'M' character (at 1200 baud, 7N1) */ ++/* it could be a mouse. */ ++/* */ ++/* Return code tells us what happened */ ++/* */ ++/* PNP_COM_FATAL - error, errno has reason */ ++/* PNP_COM_OK - probe saw 'M' */ ++/* PNP_COM_FAIL - Never saw the 'M' response */ ++ ++static int find_legacy_mouse( int fd ) { ++ int modem_lines; ++ int temp; ++ int done; ++ int starttime; ++ unsigned char resp[2]; ++ struct timeval timo; ++ struct termios portattr; ++ ++ DEBUG("looking for a legacy mouse\n"); ++ ++ /* now we set port to be 1200 baud, 7 bits, no parity, 1 stop bit */ ++ temp = tcgetattr(fd, &portattr); ++ if (temp < 0) ++ return PNP_COM_FATAL; ++ ++ /* goto 1200 baud, etc etc*/ ++ temp = setup_serial_port( fd, 7, &portattr ); ++ if (temp < 0) ++ return PNP_COM_FATAL; ++ ++ /* we drop DTR and RTS */ ++ modem_lines = get_serial_lines(fd); ++ modem_lines &= ~( TIOCM_RTS | TIOCM_DTR); ++ set_serial_lines(fd, modem_lines); ++ usleep(200000); ++ ++ /* bring them DTR back up */ ++ modem_lines |= TIOCM_DTR | TIOCM_RTS; ++ set_serial_lines(fd, modem_lines); ++ ++ /* start reading - after first character we quit */ ++ done = 0; ++ starttime=time(NULL); ++ while (!done) { ++ timo.tv_sec=0; ++ timo.tv_usec=250000; ++ if (wait_for_input(fd, &timo) > 0) { ++ temp = read( fd, resp, 1 ); ++ if (temp < 0) { ++ if (errno != EAGAIN) ++ return PNP_COM_FATAL; ++ } else { ++ done = 1; ++ } ++ } else ++ done = 1; ++ ++ ++ /* shouldnt run more than 2 seconds */ ++ if (time(NULL)-starttime > 2 ) ++ done = 1; ++ } ++ if (*resp == 'M') { ++ DEBUG("Found legacy mouse\n"); ++ return PNP_COM_OK; ++ } else ++ return PNP_COM_FAIL; ++} ++ ++/* See if this is a legacy modem device */ ++/* Only called if the PnP probe above failed */ ++/* We send a '!AT' and see if we get an 'OK' back */ ++/* */ ++/* Return code tells us what happened */ ++/* */ ++/* PNP_COM_FATAL - error, errno has reason */ ++/* PNP_COM_OK - probe saw 'OK' */ ++/* PNP_COM_FAIL - Never saw the 'OK' response */ ++static int find_legacy_modem( int fd ) { ++ int modem_lines; ++ int temp; ++ int done; ++ int respindex; ++ int starttime; ++ unsigned char resp[10], buf[2]; ++ struct timeval timo; ++ struct termios portattr; ++ ++ DEBUG("looking for a legacy modem\n"); ++ ++ /* now we set port to be 1200 baud, 8 bits, no parity, 1 stop bit */ ++ temp = tcgetattr(fd, &portattr); ++ if (temp < 0) ++ return PNP_COM_FATAL; ++ ++ /* goto 1200 baud, 8 bits */ ++ temp = setup_serial_port( fd, 8, &portattr ); ++ if (temp < 0) ++ return PNP_COM_FATAL; ++ ++ /* turn on DTR and RTS */ ++ modem_lines = get_serial_lines(fd); ++ modem_lines |= TIOCM_RTS | TIOCM_DTR; ++ set_serial_lines(fd, modem_lines); ++ usleep(200000); ++ ++ /* send the 'AT' command */ ++ DEBUG("Sending AT command to modem\n"); ++ ++ write(fd, "AT\r", 3); ++ ++ /* start reading - we'll get AT command back first, then modem response */ ++ done = 0; ++ respindex= 0; ++ starttime=time(NULL); ++ memset(resp, 0, sizeof(resp)); ++ while (!done) { ++ timo.tv_sec=0; ++ timo.tv_usec=250000; ++ if (wait_for_input(fd, &timo) > 0) { ++ temp = read( fd, buf, 1 ); ++ if (temp < 0) { ++ if (errno != EAGAIN) ++ return PNP_COM_FATAL; ++ } else { ++ resp[respindex++] = buf[0]; ++ } ++ } else ++ done = 1; ++ ++ /* shouldnt run more than 5 seconds */ ++ if (time(NULL)-starttime > 5 ) ++ done = 1; ++ ++ if (respindex > 9) ++ done = 1; ++ } ++ ++ /* see if we saw the 'OK' response */ ++ if (strstr(resp, "OK")) ++ return PNP_COM_OK; ++ else ++ return PNP_COM_FAIL; ++} ++ ++/* retrieve the PnP ID string */ ++/* timeout after 3 seconds */ ++/* should probably set a 200 msec timeout per char, as spec says */ ++/* if no char received, we're done */ ++static int read_pnp_string( int fd, unsigned char *pnp_string, int *pnp_len, int pnp_stringbuf_size ) { ++ int pnp_index; ++ int temp, done, counter; ++ int seen_start; ++ time_t starttime; ++ struct timeval timo; ++ unsigned char buf[80]; ++ unsigned char end_char; ++ ++ DEBUG("Attempting to read PNP ID string\n"); ++ ++ /* see if we have any input waiting */ ++ pnp_index = 0; ++ seen_start = 0; ++ done = 0; ++ end_char = 0; ++ starttime=time(NULL); ++ while (!done) { ++ timo.tv_sec=0; ++ timo.tv_usec=250000; ++ if (wait_for_input(fd, &timo) > 0) { ++ temp = read( fd, buf, 1 ); ++ if (temp < 0) { ++ if (errno != EAGAIN) ++ return PNP_COM_FAIL; ++ } else { ++ for (counter=0; counter < temp; counter++) { ++ pnp_string[pnp_index++] = buf[counter]; ++ if (seen_start) { ++ if (buf[counter] == end_char) { ++ done=1; ++ break; ++ } ++ } else { ++ if (buf[counter] == BeginPnP1) { ++ seen_start = 1; ++ end_char = EndPnP1; ++ } else if (buf[counter] == BeginPnP2) { ++ seen_start = 1; ++ end_char = EndPnP2; ++ } ++ } ++ } ++ } ++ } else ++ done = 1; ++ ++ /* shouldnt run more than 3 seconds */ ++ if (time(NULL)-starttime > 3 ) ++ done = 1; ++ ++ if (pnp_index >= pnp_stringbuf_size) ++ done = 1; ++ } ++ pnp_string[pnp_index] = 0; ++ *pnp_len=pnp_index; ++ if(*pnp_len > 0) ++ return PNP_COM_OK; ++ else /* allows to call seq2 to be conformant */ ++ return PNP_COM_FAIL; ++} ++ ++/* parse the PnP ID string into components */ ++static int parse_pnp_string( unsigned char *pnp_id_string, int pnp_len, ++ struct pnp_com_id *pnp_id ) { ++ unsigned char *p1, *p2; ++ unsigned char *start; ++ unsigned char *end; ++ unsigned char *curpos; ++ unsigned char *endfield; ++ unsigned char *temppos; ++ unsigned char *pnp_string; ++ unsigned char end_char; ++ ++ int no_more_extensions=0; ++ int stage; ++ int len; ++ unsigned short int checksum; ++ char hex_checksum[5]; ++ ++ char extension_delims[] = {EndPnP1, EndPnP2, ExtendPnP1, ExtendPnP2, 0}; ++ char end_delims[] = {EndPnP1, EndPnP2, 0}; ++ unsigned char* p1end = NULL; ++ unsigned char* p2end = NULL; ++ ++ /* clear out pnp_id */ ++ memset(pnp_id, 0, sizeof(*pnp_id)); ++ ++ /* copy pnp_string to temp space */ ++ pnp_string = alloca(pnp_len+1); ++ memcpy(pnp_string, pnp_id_string, pnp_len+1); ++ ++ /* first find the start of the PnP part of string */ ++ p1 = memchr( pnp_string, BeginPnP1, pnp_len ); ++ p2 = memchr( pnp_string, BeginPnP2, pnp_len ); ++ ++ ++ if (p1) { ++ int p_len = pnp_len - (p1 - pnp_string); ++ p1end = memchr(p1, EndPnP1, p_len); ++ } ++ if (p2) { ++ int p_len = pnp_len - (p2 - pnp_string); ++ p2end = memchr(p2, EndPnP2, p_len); ++ } ++ ++ /* use the one which points nearest to start of the string */ ++ /* and is actually defined */ ++ if ( p1 && p1end && p2 && p2end ) { ++ start = (p1 < p2) ? p1 : p2; ++ } else if ( p1 && p1end ) ++ start = p1; ++ else if ( p2 && p2end ) ++ start = p2; ++ else ++ start = NULL; ++ ++ /* if no start then we're done */ ++ if (!start) ++ return -1; ++ ++ /* the length of the initial part cannot be more than 17 bytes */ ++ if ((start - pnp_string) > 17) ++ return -1; ++ ++ /* setup end character we are looking for based on the start character */ ++ if (start == p2) { ++ pnp_id->xlate_6bit = 1; ++ end_char = EndPnP2; ++ /* we need to xlate data in PnP fields */ ++ /* remember to skip the revision fields (bytes 1 and 2 after start) */ ++ temppos=start; ++ while (1) { ++ if (*temppos == EndPnP2) { ++ *temppos += 0x20; ++ break; ++ } else if (temppos != start+1 && temppos != start+2 ) ++ *temppos += 0x20; ++ ++ temppos++; ++ } ++ } else { ++ pnp_id->xlate_6bit = 0; ++ end_char = EndPnP1; ++ } ++ ++ /* move everything before the start of the PnP block */ ++ memcpy(pnp_id->other_id, pnp_string, start-pnp_string); ++ pnp_id->other_len = start - pnp_string; ++ ++ /* now we get the PnP fields - all were zero'd out above */ ++ curpos = start+1; ++ memcpy(pnp_id->pnp_rev,curpos,2); curpos += 2; ++ memcpy(pnp_id->eisa_id,curpos,3); curpos += 3; ++ memcpy(pnp_id->product_id,curpos,4); curpos += 4; ++ /* now we see if have extension fields */ ++ no_more_extensions = 0; ++ stage = 0; ++ while (!no_more_extensions) { ++ if (*curpos == ExtendPnP1 || *curpos == ExtendPnP2) { ++ curpos++; ++ endfield = strpbrk(curpos, extension_delims); ++ if (!endfield) ++ return -1; ++ /* if we reached the end of all PnP data, back off */ ++ /* cause there is a checksum at the end of extension data */ ++ if (*endfield == EndPnP1 || *endfield == EndPnP2) ++ endfield -= 2; ++ } else ++ break; ++ ++ len = endfield - curpos; ++ switch (stage) { ++ case 0: ++ if (len != 8 && len != 0 ) ++ return -1; ++ ++ memcpy(pnp_id->serial_number,curpos,len); ++ curpos += len; ++ break; ++ ++ case 1: ++ if (len > 33) ++ return -1; ++ memcpy(pnp_id->class_name, curpos, len); ++ curpos = endfield; ++ break; ++ ++ case 2: ++ if (len > 41) ++ return -1; ++ memcpy(pnp_id->driver_id, curpos, len); ++ curpos = endfield; ++ break; ++ ++ case 3: ++ if (len > 41) ++ return -1; ++ memcpy(pnp_id->user_name, curpos, len); ++ curpos = endfield; ++ break; ++ } ++ stage++; ++ } ++ ++ /* now find the end of all PnP data */ ++ end = strpbrk(curpos, end_delims); ++ if (!end) ++ return -1; ++ ++ /* if we had any extensions, we expect an checksum */ ++ if (stage != 0) { ++ /* copy checksum into struct */ ++ memcpy(pnp_id->checksum, curpos, 2); ++ ++ /* compute the checksum as the sum of all PnP bytes, excluding */ ++ /* the two byte checksum. */ ++ checksum = 0; ++ for (temppos=start; temppos <= end; temppos++) { ++ /* skip checksum in calculation */ ++ if (temppos == (end-2) || temppos == (end-1)) ++ continue; ++ /* dont xlate the revision at start */ ++ if (temppos != (start+1) && temppos != (start+2)) ++ checksum += *temppos - ((pnp_id->xlate_6bit) ? 0x20 : 0); ++ else ++ checksum += *temppos; ++ } ++ sprintf(hex_checksum, "%.2X", checksum & 0xff); ++ if (strncmp(hex_checksum, pnp_id->checksum, 2)) ++ return -1; ++ } ++ ++ /* checksum was ok, so we're done */ ++ return 0; ++} ++ ++static int attempt_pnp_retrieve(int fd, char *pnp_string, int *pnp_strlen, int pnp_stringbuf_size) { ++ int pnp_probe_status; ++ struct pnp_com_id pnp_id; ++ int tried_at_prodding=0, give_up=0; ++ ++ DEBUG("Attempting PNP information retrieval\n"); ++ ++ while (!give_up) { ++ pnp_probe_status = init_pnp_com_seq1(fd); ++ if (pnp_probe_status == PNP_COM_FATAL) ++ return PNP_COM_FATAL; ++ pnp_probe_status = read_pnp_string(fd, pnp_string, pnp_strlen, ++ pnp_stringbuf_size); ++ if (pnp_probe_status == PNP_COM_FAIL) { ++ init_pnp_com_seq2(fd); /* always succeeds */ ++ ++ pnp_probe_status = read_pnp_string(fd, pnp_string, pnp_strlen, ++ pnp_stringbuf_size); ++ } ++ ++ if (*pnp_strlen == 1 && pnp_string[0] == 'M') /* legacy mouse */ ++ return PNP_COM_OK; ++ /* see if we got anything useful, if not try AT command */ ++ /* to prod device into correct serial params */ ++ if (parse_pnp_string( pnp_string, *pnp_strlen, &pnp_id )<0) { ++ DEBUG("That failed.\n"); ++ if (!tried_at_prodding) { ++ DEBUG("Prod modem with AT command.\n"); ++ write(fd, "AT\r", 3); ++ tried_at_prodding=1; ++ } else ++ give_up = 1; ++ } else ++ return PNP_COM_OK; ++ } ++ ++ /* normal PNP detection has failed. */ ++ /* try sending a ATI9 code to the modem to see if we get PnP id back */ ++ init_pnp_com_ati9(fd); ++ read_pnp_string(fd, pnp_string, pnp_strlen, pnp_stringbuf_size ); ++ if (parse_pnp_string( pnp_string, *pnp_strlen, &pnp_id )<0) { ++ *pnp_strlen = 0; ++ pnp_string[0] = 0; ++ return PNP_COM_FAIL; ++ } else ++ return PNP_COM_OK; ++} ++ ++struct device *serialProbe(enum deviceClass probeClass, int probeFlags, ++ struct device *devlist) { ++ int fd; ++ int temp; ++ int pnp_strlen; ++ int devicetype=-1; ++ unsigned char pnp_string[100]; ++ char port[20]; ++ struct termios origattr; ++ struct pnp_com_id pnp_id; ++ struct serialDevice *serdev; ++ struct stat sb; ++ int maj, twelve=12; ++ int console=-1; ++ int stdin_line=-1; ++ struct serial_struct si; ++ ++ DEBUG("Probing for serial ports\n"); ++ ++ if (probeFlags & PROBE_SAFE) return devlist; ++ ++ /* Are we on a serial console? */ ++ fstat(0,&sb); ++ maj = major(sb.st_rdev); ++ if (maj != 4 && (maj < 136 || maj > 143)) { ++ if (ioctl (0, TIOCLINUX, &twelve) < 0) { ++ if (ioctl (0, TIOCGSERIAL, &si) >= 0) { ++ if (si.line > 0) { ++ stdin_line = 1 << si.line; ++ } else { ++ stdin_line = 0; ++ } ++ } else stdin_line = 0; ++ } ++ } ++ ++ fd=open("/dev/console",O_RDWR); ++ if (fd != -1) { ++ fstat(fd,&sb); ++ maj = major(sb.st_rdev); ++ if (maj != 4 && (maj < 136 || maj > 143)) { ++ if (ioctl (fd, TIOCLINUX, &twelve) < 0) { ++ #ifdef __powerpc__ ++ // we could have gotten an error for another reason - like EINVAL ++ // skipping ttyS0 on PPC - which is where most modems reside ++ if (errno == ENOTTY) { ++ #endif ++ if (ioctl (fd, TIOCGSERIAL, &si) >= 0) { ++ if (si.line > 0) { ++ console = 1 << si.line; ++ } else { ++ console = 0; ++ #ifdef __powerpc__ ++ } ++ #endif ++ } ++ } else console = 0; ++ } ++ } ++ close(fd); ++ } ++ ++ ++ if ( ++ (probeClass & CLASS_UNSPEC) || ++ (probeClass & CLASS_OTHER) || ++ (probeClass & CLASS_MOUSE) || ++ (probeClass & CLASS_MODEM) || ++ (probeClass & CLASS_PRINTER) ++ ) { ++ int x; ++ ++ for (x=0; x<=3 ; x++) { ++ struct stat sbuf; ++ char lockfile[32]; ++ if (x==console || x==stdin_line) continue; ++ snprintf(port,20,"/dev/ttyS%d",x); ++ ++ /* Make sure it's not in use */ ++ snprintf(lockfile,32,"/var/lock/LCK..ttyS%d",x); ++ if (!stat(lockfile,&sbuf)) { ++ DEBUG("Port %s in use, skipping probe.\n", ++ port); ++ continue; ++ } ++ memset(lockfile,'\0',32); ++ if (readlink("/dev/modem",lockfile,32)>0) { ++ if (!strcmp(basename(port),basename(lockfile))) { ++ snprintf(lockfile,32,"/var/lock/LCK..modem"); ++ if (!stat(lockfile,&sbuf)) { ++ DEBUG("Port %s in use, skipping probe.\n", ++ port); ++ continue; ++ } ++ } ++ } ++ ++ if ((fd=open_serial_port(port)) < 0) { ++ continue; ++ } ++ /* save the current state of the port */ ++ temp = tcgetattr(fd, &origattr); ++ if (temp < 0) { ++ DEBUG("unable to retrieve port attributes...no port present?\n"); ++ close(fd); ++ continue; ++ } ++ ++ ++ /* try twiddling RS232 control lines and see if it talks to us */ ++ devicetype=-1; ++ pnp_strlen = 0; ++ if (attempt_pnp_retrieve( fd, pnp_string, &pnp_strlen, ++ sizeof(pnp_string) - 1 ) == PNP_COM_FATAL) ++ goto endprobe; ++ ++ /* see if we found any PnP signature */ ++ if (pnp_strlen != 0 && (pnp_strlen != 1 || pnp_string[0] != 'M')) { ++ ++ /* fill in the PnP com structure */ ++ if (parse_pnp_string( pnp_string, pnp_strlen, &pnp_id )<0) { ++ DEBUG("Got PNP data back, but failed to parse. Aborting\n"); ++ goto endprobe; ++ } else { ++ char *foo; ++ int len; ++ ++ DEBUG("PNP data parsed.\n"); ++ serdev = serialNewDevice(NULL); ++ ++ if (pnp_id.user_name[0]) { ++ serdev->pnpdesc = strdup(pnp_id.user_name); ++ len = strlen(pnp_id.eisa_id) + ++ strlen(pnp_id.product_id) + ++ strlen(pnp_id.user_name) + 3; ++ foo = malloc(len); ++ snprintf(foo,len,"%s|%s %s",pnp_id.eisa_id, ++ pnp_id.product_id,pnp_id.user_name); ++ } else { ++ len = strlen(pnp_id.eisa_id) + ++ strlen(pnp_id.product_id) + 3; ++ foo = malloc(len); ++ snprintf(foo,len,"%s|%s",pnp_id.eisa_id, ++ pnp_id.product_id); ++ } ++ if (serdev->desc) free(serdev->desc); ++ serdev->desc=strdup(foo); ++ serdev->device=strdup(port+5); ++ if (serdev->driver) free(serdev->driver); ++ serdev->driver=strdup("ignore"); ++ serdev->pnpmfr = strdup(pnp_id.eisa_id); ++ serdev->pnpmodel = strdup(pnp_id.product_id); ++ ++ free(foo); ++ foo=pnp_id.product_id; ++ if (pnp_id.driver_id) { ++ if (strstr(pnp_id.driver_id,"PNP")) ++ foo = strstr(pnp_id.driver_id,"PNP")+3; ++ serdev->pnpcompat = strdup(pnp_id.driver_id); ++ } ++ ++ if (*pnp_id.other_id == 'M' || ++ !strncmp(pnp_id.class_name, "MOUSE", 5) || ++ !strncmp(foo, "0F", 2)) { ++ serdev->type = CLASS_MOUSE; ++ if (!strncmp(serdev->desc, "|", 1)) { ++ free(serdev->desc); ++ serdev->desc=strdup("Generic Serial Mouse"); ++ } ++ if (serdev->driver) free(serdev->driver); ++ serdev->driver = strdup("generic"); ++ } ++ else if (!strncmp(pnp_id.class_name, "MODEM", 5) || ++ !strncmp(foo, "C", 1)) ++ serdev->type = CLASS_MODEM; ++ else if (!strncmp(pnp_id.class_name, "PRINTER", 7)) ++ serdev->type = CLASS_PRINTER; ++ else ++ serdev->type = CLASS_OTHER; ++ if (serdev->type & probeClass) { ++ if (devlist) ++ serdev->next = devlist; ++ devlist = (struct device *)serdev; ++ if (probeFlags & PROBE_ONE) { ++ tcsetattr(fd, TCSANOW, &origattr); ++ tcflush(fd, TCIOFLUSH); ++ close(fd); ++ return devlist; ++ } ++ } else { ++ serdev->freeDevice(serdev); ++ } ++ goto endprobe; ++ } ++ } else { ++ DEBUG("No PNP data received.\n"); ++ /* try to find a legacy device */ ++ ++ temp = find_legacy_mouse(fd); ++ if (temp == PNP_COM_FATAL) { ++ goto endprobe; ++ } else if (temp == PNP_COM_OK) { ++ if (probeClass & CLASS_MOUSE) { ++ serdev=serialNewDevice(NULL); ++ serdev->type = CLASS_MOUSE; ++ serdev->device = strdup(port+5); ++ serdev->driver= strdup("generic"); ++ serdev->desc = strdup("Generic Serial Mouse"); ++ if (devlist) ++ serdev->next = devlist; ++ devlist = (struct device *)serdev; ++ if (probeFlags & PROBE_ONE) { ++ tcsetattr(fd, TCSANOW, &origattr); ++ tcflush(fd, TCIOFLUSH); ++ close(fd); ++ return devlist; ++ } ++ } ++ goto endprobe; ++ } else { ++ DEBUG("Didn't see a legacy mouse.\n"); ++ ++ temp = find_legacy_modem(fd); ++ if (temp == PNP_COM_FATAL) { ++ goto endprobe; ++ } else if (temp == PNP_COM_OK) { ++ DEBUG("Legacy modem signature seen.\n"); ++ if (probeClass & CLASS_MODEM) { ++ serdev=serialNewDevice(NULL); ++ serdev->type = CLASS_MODEM; ++ serdev->device = strdup(port+5); ++ serdev->driver= strdup("ignore"); ++ serdev->desc = strdup("Generic Serial Modem"); ++ if (devlist) ++ serdev->next = devlist; ++ devlist = (struct device *)serdev; ++ if (probeFlags & PROBE_ONE) { ++ tcsetattr(fd, TCSANOW, &origattr); ++ tcflush(fd, TCIOFLUSH); ++ close(fd); ++ return devlist; ++ } ++ } ++ goto endprobe; ++ } else { ++ DEBUG("Didnt see a legacy modem, game over.\n"); ++ } ++ } ++ } ++ endprobe: ++ DEBUG("Restoring original port attributes\n"); ++ tcsetattr(fd, TCSANOW, &origattr); ++ tcflush(fd, TCIOFLUSH); ++ close(fd); ++ } ++ } ++ return devlist; ++} + + +Property changes on: drakx/trunk/tools/serial_probe/serial.c +___________________________________________________________________ +Added: svn:eol-style + + native + +Added: drakx/trunk/tools/serial_probe/serial.h +=================================================================== +--- drakx/trunk/tools/serial_probe/serial.h (rev 0) ++++ drakx/trunk/tools/serial_probe/serial.h 2011-02-06 23:23:30 UTC (rev 450) +@@ -0,0 +1,43 @@ ++/* Copyright 1999-2003 Red Hat, Inc. ++ * ++ * This software may be freely redistributed under the terms of the GNU ++ * public license. ++ * ++ * You should have received a copy of the GNU General Public License ++ * along with this program; if not, write to the Free Software ++ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. ++ * ++ */ ++ ++#ifndef _KUDZU_SERIAL_H_ ++#define _KUDZU_SERIAL_H_ ++ ++#include "device.h" ++ ++struct serialDevice { ++ /* common fields */ ++ struct device *next; /* next device in list */ ++ int index; ++ enum deviceClass type; /* type */ ++ enum deviceBus bus; /* bus it's attached to */ ++ char * device; /* device file associated with it */ ++ char * driver; /* driver to load, if any */ ++ char * desc; /* a description */ ++ int detached; ++ /* serial-specific fields */ ++ struct serialDevice *(*newDevice) (struct serialDevice *dev); ++ void (*freeDevice) (struct serialDevice *dev); ++ void (*writeDevice) (FILE *file, struct serialDevice *dev); ++ int (*compareDevice) (struct serialDevice *dev1, struct serialDevice *dev2); ++ char * pnpmfr; ++ char * pnpmodel; ++ char * pnpcompat; ++ char * pnpdesc; ++ ++}; ++ ++struct serialDevice *serialNewDevice(struct serialDevice *dev); ++struct device *serialProbe(enum deviceClass probeClass, int probeFlags, ++ struct device *devlist); ++ ++#endif + + +Property changes on: drakx/trunk/tools/serial_probe/serial.h +___________________________________________________________________ +Added: svn:eol-style + + native + +Added: drakx/trunk/tools/serial_probe/serial_probe.c +=================================================================== +--- drakx/trunk/tools/serial_probe/serial_probe.c (rev 0) ++++ drakx/trunk/tools/serial_probe/serial_probe.c 2011-02-06 23:23:30 UTC (rev 450) +@@ -0,0 +1,114 @@ ++/* Copyright 1999 Mandrakesoft <<A HREF="https://www.mageia.org/mailman/listinfo/mageia-sysadm">fpons at mandrakesoft.com</A>> ++ * ++ * The following file used by this one are copyrighted by RedHat and ++ * are taken from kudzu : ++ * device.h ++ * serial.h ++ * serial.c ++ * This file is taken from kudzu.c copyrighted by RedHat, 1999. ++ * ++ * This software may be freely redistributed under the terms of the GNU ++ * public license. ++ * ++ * You should have received a copy of the GNU General Public License ++ * along with this program; if not, write to the Free Software ++ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. ++ * ++ */ ++ ++#include <stdio.h> ++#include <string.h> ++#include <stdlib.h> ++ ++#include "serial.h" ++#include "device.h" ++ ++typedef struct device *(newFunc)(struct device *); ++typedef int (initFunc)(); ++typedef struct device *(probeFunc)(enum deviceClass, int, struct device *); ++ ++char *classStrings[] = { ++ "UNSPEC", "OTHER", "NETWORK", "SCSI", "VIDEO", "AUDIO", ++ "MOUSE", "MODEM", "CDROM", "TAPE", "FLOPPY", "SCANNER", ++ "HD", "RAID", "PRINTER", "CAPTURE", "KEYBOARD", NULL ++}; ++ ++struct device *newDevice(struct device *old, struct device *new) { ++ if (!old) { ++ if (!new) { ++ new = malloc(sizeof(struct device)); ++ memset(new,'\0',sizeof(struct device)); ++ } ++ new->type = CLASS_UNSPEC; ++ } else { ++ new->type = old->type; ++ if (old->device) new->device = strdup(old->device); ++ if (old->driver) new->driver = strdup(old->driver); ++ if (old->desc) new->desc = strdup(old->desc); ++ } ++ new->newDevice = newDevice; ++ new->freeDevice = freeDevice; ++ new->compareDevice = compareDevice; ++ return new; ++} ++ ++void freeDevice(struct device *dev) { ++ if (!dev) { ++ printf("freeDevice(null)\n"); ++ abort(); /* return; */ ++ } ++ if (dev->device) free (dev->device); ++ if (dev->driver) free (dev->driver); ++ if (dev->desc) free (dev->desc); ++ free (dev); ++} ++ ++void writeDevice(FILE *file, struct device *dev) {} ++int compareDevice(struct device *dev1, struct device *dev2) { return 0; } ++ ++int main () { ++ struct device* devices = NULL; ++ struct serialDevice* serialDevice = NULL; ++ ++ devices = serialProbe(CLASS_UNSPEC, 0, devices); ++ while (devices) { ++ serialDevice = (struct serialDevice*)devices; ++ ++ printf("CLASS="); ++ if (serialDevice->type == CLASS_UNSPEC) puts("UNSPEC"); else ++ if (serialDevice->type == CLASS_OTHER) puts("OTHER"); else ++ if (serialDevice->type == CLASS_NETWORK) puts("NETWORK"); else ++ if (serialDevice->type == CLASS_SCSI) puts("SCSI"); else ++ if (serialDevice->type == CLASS_MOUSE) puts("MOUSE"); else ++ if (serialDevice->type == CLASS_AUDIO) puts("AUDIO"); else ++ if (serialDevice->type == CLASS_CDROM) puts("CDROM"); else ++ if (serialDevice->type == CLASS_MODEM) puts("MODEM"); else ++ if (serialDevice->type == CLASS_VIDEO) puts("VIDEO"); else ++ if (serialDevice->type == CLASS_TAPE) puts("TAPE"); else ++ if (serialDevice->type == CLASS_FLOPPY) puts("FLOPPY"); else ++ if (serialDevice->type == CLASS_SCANNER) puts("SCANNER"); else ++ if (serialDevice->type == CLASS_HD) puts("HD"); else ++ if (serialDevice->type == CLASS_RAID) puts("RAID"); else ++ if (serialDevice->type == CLASS_PRINTER) puts("PRINTER"); else ++ if (serialDevice->type == CLASS_CAPTURE) puts("CAPTURE"); else ++ if (serialDevice->type == CLASS_KEYBOARD) puts("KEYBOARD"); else ++ if (serialDevice->type == CLASS_MONITOR) puts("MONITOR"); else ++ if (serialDevice->type == CLASS_USB) puts("USB"); else ++ if (serialDevice->type == CLASS_SOCKET) puts("SOCKET"); else ++ if (serialDevice->type == CLASS_FIREWIRE) puts("FIREWIRE"); else ++ if (serialDevice->type == CLASS_IDE) puts("IDE"); ++ printf("BUS=SERIAL\n"); ++ printf("DEVICE=/dev/%s\n", serialDevice->device); ++ printf("DRIVER=%s\n", serialDevice->driver); ++ if (!serialDevice->pnpdesc) printf("DESCRIPTION=%s\n", serialDevice->desc); ++ if (serialDevice->pnpmfr) printf("MANUFACTURER=%s\n", serialDevice->pnpmfr); ++ if (serialDevice->pnpmodel) printf("MODEL=%s\n", serialDevice->pnpmodel); ++ if (serialDevice->pnpcompat) printf("COMPAT=%s\n", serialDevice->pnpcompat); ++ if (serialDevice->pnpdesc) printf("DESCRIPTION=%s\n", serialDevice->pnpdesc); ++ printf("\n"); ++ ++ devices=devices->next; ++ } ++ ++ return 0; ++} + + +Property changes on: drakx/trunk/tools/serial_probe/serial_probe.c +___________________________________________________________________ +Added: svn:eol-style + + native + +Added: drakx/trunk/tools/shift_all.pl +=================================================================== +--- drakx/trunk/tools/shift_all.pl (rev 0) ++++ drakx/trunk/tools/shift_all.pl 2011-02-06 23:23:30 UTC (rev 450) +@@ -0,0 +1,113 @@ ++use MDK::Common; ++ ++my %shifts = ( ++'af' => 1, ++'am' => 1, ++'ar' => 0, ++'az' => 1, ++'be' => 2, ++'bg' => 2, ++'bn' => 1, ++'br' => 2, ++'bs' => 2, ++'ca' => 2, ++'cs' => 2, ++'cy' => 2, ++'da' => 2, ++'de' => 2, ++'el' => 2, ++'en_GB' => 2, ++'en_US' => 2, ++'eo' => 2, ++'es' => 2, ++'et' => 2, ++'eu' => 2, ++'fa' => 0, ++'fi' => 1, ++'fo' => 2, ++'fr' => 2, ++'ga' => 2, ++'gd' => 2, ++'gl' => 2, ++'gv' => 2, ++'he' => 0, ++'hi' => 1, ++'hr' => 2, ++'hu' => 2, ++'hy' => 1, ++'ia' => 2, ++'id' => 1, ++'is' => 1, ++'it' => 1, ++'iu' => 1, ++'ja' => 3, ++'ka' => 1, ++'kn' => 1, ++'ko' => 1, ++'kw' => 0, ++'lo' => 0, ++'lt' => 0, ++'lv' => 0, ++'mi' => 0, ++'mk' => 0, ++'mn' => 0, ++'mr' => 0, ++'ms' => 0, ++'mt' => 0, ++'nb' => 0, ++'nl' => 0, ++'nn' => 0, ++'no' => 0, ++'oc' => 0, ++'pl' => 0, ++'pt_BR' => 0, ++'pt' => 0, ++'ro' => 0, ++'ru' => 0, ++'sk' => 0, ++'sl' => 0, ++'sp' => 0, ++'sq' => 0, ++'sr' => 0, ++'sv' => 0, ++'ta' => 1, ++'te' => 1, ++'tg' => 0, ++'th' => 0, ++'tr' => 0, ++'tt' => 1, ++'uk' => 0, ++'ur' => 1, ++'uz' => 0, ++'vi' => 0, ++'wa' => 0, ++'yi' => 0, ++'zh_CN' => 0, ++'zh_TW' => 0, ++); ++ ++foreach (glob("lang*.png")) { ++ /lang-(.*)\.png/; ++ exists $shifts{$1} or die "doesn't exist for $_"; ++ $shifts{$1} or next; ++ print "./a.out $_ l.png $shifts{$1}\n"; ++ system("./a.out $_ l.png $shifts{$1}"); ++ renamef('l.png', $_); ++} ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ + +Added: drakx/trunk/tools/shift_img.c +=================================================================== +--- drakx/trunk/tools/shift_img.c (rev 0) ++++ drakx/trunk/tools/shift_img.c 2011-02-06 23:23:30 UTC (rev 450) +@@ -0,0 +1,165 @@ ++/* ++ * Guillaume Cottenceau (gc at mandriva.com) ++ * ++ * Copyright 2002-2005 Mandriva ++ * ++ * This software may be freely redistributed under the terms of the GNU ++ * public license. ++ * ++ */ ++ ++#include <unistd.h> ++#include <stdio.h> ++#include <string.h> ++#include <stdarg.h> ++ ++#define PNG_DEBUG 3 ++#include <png.h> ++ ++void abort_(const char * s, ...) ++{ ++ va_list args; ++ va_start(args, s); ++ vfprintf(stderr, s, args); ++ fprintf(stderr, "\n"); ++ va_end(args); ++ abort(); ++} ++ ++int x, y; ++ ++int width, height; ++png_byte color_type; ++png_byte bit_depth; ++ ++png_structp png_ptr; ++png_infop info_ptr; ++int number_of_passes; ++png_bytep * row_pointers; ++ ++void read_png_file(char* file_name) ++{ ++ char header[8]; // 8 is the maximum size that can be checked ++ ++ /* open file and test for it being a png */ ++ FILE *fp = fopen(file_name, "rb"); ++ if (!fp) ++ abort_("[read_png_file] File %s could not be opened for reading", file_name); ++ fread(header, 1, 8, fp); ++ if (png_sig_cmp(header, 0, 8)) ++ abort_("[read_png_file] File %s is not recognized as a PNG file", file_name); ++ ++ ++ /* initialize stuff */ ++ png_ptr = png_create_read_struct(PNG_LIBPNG_VER_STRING, NULL, NULL, NULL); ++ ++ if (!png_ptr) ++ abort_("[read_png_file] png_create_read_struct failed"); ++ ++ info_ptr = png_create_info_struct(png_ptr); ++ if (!info_ptr) ++ abort_("[read_png_file] png_create_info_struct failed"); ++ ++ if (setjmp(png_jmpbuf(png_ptr))) ++ abort_("[read_png_file] Error during init_io"); ++ ++ png_init_io(png_ptr, fp); ++ png_set_sig_bytes(png_ptr, 8); ++ ++ png_read_info(png_ptr, info_ptr); ++ ++ width = info_ptr->width; ++ height = info_ptr->height; ++ color_type = info_ptr->color_type; ++ bit_depth = info_ptr->bit_depth; ++ ++ number_of_passes = png_set_interlace_handling(png_ptr); ++ png_read_update_info(png_ptr, info_ptr); ++ ++ ++ /* read file */ ++ if (setjmp(png_jmpbuf(png_ptr))) ++ abort_("[read_png_file] Error during read_image"); ++ ++ row_pointers = (png_bytep*) malloc(sizeof(png_bytep) * height); ++ for (y=0; y<height; y++) ++ row_pointers[y] = (png_byte*) malloc(info_ptr->rowbytes); ++ ++ png_read_image(png_ptr, row_pointers); ++} ++ ++ ++void write_png_file(char* file_name) ++{ ++ /* create file */ ++ FILE *fp = fopen(file_name, "wb"); ++ if (!fp) ++ abort_("[write_png_file] File %s could not be opened for writing", file_name); ++ ++ ++ /* initialize stuff */ ++ png_ptr = png_create_write_struct(PNG_LIBPNG_VER_STRING, NULL, NULL, NULL); ++ ++ if (!png_ptr) ++ abort_("[write_png_file] png_create_write_struct failed"); ++ ++ info_ptr = png_create_info_struct(png_ptr); ++ if (!info_ptr) ++ abort_("[write_png_file] png_create_info_struct failed"); ++ ++ if (setjmp(png_jmpbuf(png_ptr))) ++ abort_("[write_png_file] Error during init_io"); ++ ++ png_init_io(png_ptr, fp); ++ ++ ++ /* write header */ ++ if (setjmp(png_jmpbuf(png_ptr))) ++ abort_("[write_png_file] Error during writing header"); ++ ++ png_set_IHDR(png_ptr, info_ptr, width, height, ++ bit_depth, color_type, PNG_INTERLACE_NONE, ++ PNG_COMPRESSION_TYPE_BASE, PNG_FILTER_TYPE_BASE); ++ ++ png_write_info(png_ptr, info_ptr); ++ ++ ++ /* write bytes */ ++ if (setjmp(png_jmpbuf(png_ptr))) ++ abort_("[write_png_file] Error during writing bytes"); ++ ++ png_write_image(png_ptr, row_pointers); ++ ++ ++ /* end write */ ++ if (setjmp(png_jmpbuf(png_ptr))) ++ abort_("[write_png_file] Error during end of write"); ++ ++ png_write_end(png_ptr, NULL); ++ ++} ++ ++void process_file(char* shift) ++{ ++ int shift_ = atoi(shift); ++ ++ if (info_ptr->color_type != PNG_COLOR_TYPE_RGBA) ++ abort_("[process_file] color_type of input file must be PNG_COLOR_TYPE_RGBA (is %d)", info_ptr->color_type); ++ ++ width -= shift_; ++ for (y=0; y<height; y++) { ++ row_pointers[y] += 4 * shift_; ++ } ++ ++} ++ ++ ++int main(int argc, char **argv) ++{ ++ if (argc != 4) ++ abort_("Usage: program_name <file_in> <file_out> <shift>"); ++ ++ read_png_file(argv[1]); ++ process_file(argv[3]); ++ write_png_file(argv[2]); ++} + + +Property changes on: drakx/trunk/tools/shift_img.c +___________________________________________________________________ +Added: svn:eol-style + + native + +Added: drakx/trunk/tools/simplify-drakx-modules +=================================================================== +--- drakx/trunk/tools/simplify-drakx-modules (rev 0) ++++ drakx/trunk/tools/simplify-drakx-modules 2011-02-06 23:23:30 UTC (rev 450) +@@ -0,0 +1,5 @@ ++#!/usr/bin/perl -pi ++ ++s/^\s*use\s+(diagnostics|strict|vars|warnings).*//g; ++ ++/^__END__/ and $_ = '', close ARGV; + + +Property changes on: drakx/trunk/tools/simplify-drakx-modules +___________________________________________________________________ +Added: svn:executable + + * + +Added: drakx/trunk/tools/specific_arch +=================================================================== +--- drakx/trunk/tools/specific_arch (rev 0) ++++ drakx/trunk/tools/specific_arch 2011-02-06 23:23:30 UTC (rev 450) +@@ -0,0 +1,9 @@ ++#!/usr/bin/perl ++ ++use MDK::Common; ++ ++print join(' ', map { ++ my $arch = arch(); ++ $arch = $compat_arch{$arch} while $arch && !-e "$_.$arch"; ++ -e "$_.$arch" ? "$_.$arch" : (); ++ } @ARGV), "\n"; + + +Property changes on: drakx/trunk/tools/specific_arch +___________________________________________________________________ +Added: svn:executable + + * + +Added: drakx/trunk/tools/xhost+.c +=================================================================== +--- drakx/trunk/tools/xhost+.c (rev 0) ++++ drakx/trunk/tools/xhost+.c 2011-02-06 23:23:30 UTC (rev 450) +@@ -0,0 +1,11 @@ ++#include <stdlib.h> ++#include <X11/Xlib.h> ++ ++ ++int main(int argc, char **argv) { ++ Display *d = XOpenDisplay(getenv("DISPLAY") ? getenv("DISPLAY") : ":0"); ++ if (d == NULL) exit(1); ++ XDisableAccessControl(d); ++ XCloseDisplay(d); ++ exit(0); ++} + + +Property changes on: drakx/trunk/tools/xhost+.c +___________________________________________________________________ +Added: svn:eol-style + + native +-------------- next part -------------- +An HTML attachment was scrubbed... +URL: </pipermail/mageia-sysadm/attachments/20110206/37532f73/attachment.html> +</PRE> + + +<!--endarticle--> + <HR> + <P><UL> + <!--threads--> + <LI>Previous message: <A HREF="002826.html">[Mageia-sysadm] [448] Add cleaned files +</A></li> + <LI>Next message: <A HREF="002835.html">[Mageia-sysadm] [451] Import stage1 +</A></li> + <LI> <B>Messages sorted by:</B> + <a href="date.html#2827">[ date ]</a> + <a href="thread.html#2827">[ thread ]</a> + <a href="subject.html#2827">[ subject ]</a> + <a href="author.html#2827">[ author ]</a> + </LI> + </UL> + +<hr> +<a href="https://www.mageia.org/mailman/listinfo/mageia-sysadm">More information about the Mageia-sysadm +mailing list</a><br> +</body></html> |