lib/Audio/MPD.pm

   1 #
   2 # This program is free software; you can redistribute it and/or modify
   3 # it under the terms of the GNU General Public License as published by
   4 # the Free Software Foundation; either version 2 of the License, or
   5 # (at your option) any later version.
   6 #
   7 # This program is distributed in the hope that it will be useful,
   8 # but WITHOUT ANY WARRANTY; without even the implied warranty of
   9 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  10 # GNU General Public License for more details.
  11 #
  12 # You should have received a copy of the GNU General Public License
  13 # along with this program; if not, write to the Free Software
  14 # Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  15 #
  16 #
  17
  18 package Audio::MPD;
  19
  20 use warnings;
  21 use strict;
  22
  23 use Audio::MPD::Collection;
  24 use Audio::MPD::Item;
  25 use Audio::MPD::Playlist;
  26 use Audio::MPD::Stats;
  27 use Audio::MPD::Status;
  28 use Encode;
  29 use IO::Socket;
  30
  31
  32 use base qw[ Class::Accessor::Fast ];
  33 __PACKAGE__->mk_accessors(
  34     qw[ _host _password _port
  35         collection playlist version ] );
  36
  37
  38 our $VERSION = '0.17.2';
  39
  40
  41 #--
  42 # Constructor
  43
  44 #
  45 # my $mpd = Audio::MPD->new( [$hostname], [$port], [$password] )
  46 #
  47 # This is the constructor for Audio::MPD. One can specify a $hostname, a
  48 # $port, and a $password.
  49 # If none is specified then defaults to environment vars MPD_HOST, MPD_PORT
  50 # and MPD_PASSWORD. If those aren't set, defaults to 'localhost', 6600 and ''.
  51 #
  52 sub new {
  53     my $class = shift;
  54     my ($host, $port, $password) = @_;
  55
  56     # use mpd defaults.
  57     $host     = $ENV{MPD_HOST}     || 'localhost' unless defined $host;
  58     $port     = $ENV{MPD_PORT}     || '6600'      unless defined $port;
  59     $password = $ENV{MPD_PASSWORD} || ''          unless defined $password;
  60
  61     # create & bless the object.
  62     my $self = {
  63         _host     => $host,
  64         _port     => $port,
  65         _password => $password,
  66     };
  67     bless $self, $class;
  68
  69     # create the helper objects and store them.
  70     $self->collection( Audio::MPD::Collection->new($self) );
  71     $self->playlist  ( Audio::MPD::Playlist->new($self) );
  72
  73     # try to issue a ping to test connection - this can die.
  74     $self->ping;
  75
  76     return $self;
  77 }
  78
  79
  80 #--
  81 # Private methods
  82
  83
  84 #
  85 # my @result = $mpd->_send_command( $command );
  86 #
  87 # This method is central to the module. It is responsible for interacting with
  88 # mpd by sending the $command and reading output - that will be returned as an
  89 # array of chomped lines (status line will not be returned).
  90 #
  91 # Note that currently, this method will connect to mpd before sending any
  92 # command, and will disconnect after the command has been issued. This scheme
  93 # is far from optimal, but allows us not to care about timeout disconnections.
  94 #
  95 # /!\ Note that we're using high-level, blocking sockets. This means that if
  96 # the mpd server is slow, or hangs for whatever reason, or even crash abruptly,
  97 # the program will be hung forever in this sub. The POE::Component::Client::MPD
  98 # module is way safer - you're advised to use it instead of Audio::MPD.
  99 #
 100 # This method can die on several conditions:
 101 #  - if the server cannot be reached,
 102 #  - if it's not an mpd server,
 103 #  - if the password is incorrect,
 104 #  - or if the command is an invalid mpd command.
 105 # In the latter case, the mpd error message will be returned.
 106 #
 107 sub _send_command {
 108     my ($self, $command) = @_;
 109
 110     # try to connect to mpd.
 111     my $socket = IO::Socket::INET->new(
 112         PeerAddr => $self->_host,
 113         PeerPort => $self->_port
 114     )
 115     or die "Could not create socket: $!\n";
 116     my $line;
 117
 118     # parse version information.
 119     $line = $socket->getline;
 120     chomp $line;
 121     die "Not a mpd server - welcome string was: [$line]\n"
 122         if $line !~ /^OK MPD (.+)$/;
 123     $self->version($1);
 124
 125     # send password.
 126     if ( $self->_password ) {
 127         $socket->print( 'password ' . encode('utf-8', $self->_password) . "\n" );
 128         $line = $socket->getline;
 129         die $line if $line =~ s/^ACK //;
 130     }
 131
 132     # ok, now we're connected - let's issue the command.
 133     $socket->print( encode('utf-8', $command) );
 134     my @output;
 135     while (defined ( $line = $socket->getline ) ) {
 136         chomp $line;
 137         die $line if $line =~ s/^ACK //; # oops - error.
 138         last if $line =~ /^OK/;          # end of output.
 139         push @output, decode('utf-8', $line);
 140     }
 141
 142     # close the socket.
 143     $socket->close;
 144
 145     return @output;
 146 }
 147
 148
 149 #
 150 # my @items = $mpd->_cooked_command_as_items( $command );
 151 #
 152 # Lots of Audio::MPD methods are using _send_command() and then parse the
 153 # output as a collection of Audio::MPD::Item. This method is meant to
 154 # factorize this code, and will parse the raw output of _send_command() in
 155 # a cooked list of items.
 156 #
 157 sub _cooked_command_as_items {
 158     my ($self, $command) = @_;
 159
 160     my @lines = $self->_send_command($command);
 161     my (@items, %param);
 162
 163     # parse lines in reverse order since "file:" or "directory:" lines
 164     # come first. therefore, let's first store every other parameter,
 165     # and the last line will trigger the object creation.
 166     # of course, since we want to preserve the playlist order, this means
 167     # that we're going to unshift the objects instead of push.
 168     foreach my $line (reverse @lines) {
 169         my ($k,$v) = split /:\s+/, $line, 2;
 170         $param{$k} = $v;
 171         next unless $k eq 'file' || $k eq 'directory'; # last param of item
 172         unshift @items, Audio::MPD::Item->new(%param);
 173         %param = ();
 174     }
 175
 176     return @items;
 177 }
 178
 179
 180 #
 181 # my %hash = $mpd->_cooked_command_as_kv( $command );
 182 #
 183 # Lots of Audio::MPD methods are using _send_command() and then parse the
 184 # output to get a list of key / value (with the colon ":" acting as separator).
 185 # This method is meant to factorize this code, and will parse the raw output
 186 # of _send_command() in a cooked hash.
 187 #
 188 sub _cooked_command_as_kv {
 189     my ($self, $command) = @_;
 190     my %hash =
 191         map { split(/:\s+/, $_, 2) }
 192         $self->_send_command($command);
 193     return %hash;
 194 }
 195
 196 #
 197 # my @list = $mpd->_cooked_command_strip_first_field( $command );
 198 #
 199 # Lots of Audio::MPD methods are using _send_command() and then parse the
 200 # output to remove the first field (with the colon ":" acting as separator).
 201 # This method is meant to factorize this code, and will parse the raw output
 202 # of _send_command() in a cooked list of strings.
 203 #
 204 sub _cooked_command_strip_first_field {
 205     my ($self, $command) = @_;
 206
 207     my @list =
 208         map { ( split(/:\s+/, $_, 2) )[1] }
 209         $self->_send_command($command);
 210     return @list;
 211 }
 212
 213
 214 #--
 215 # Public methods
 216
 217 # -- MPD interaction: general commands
 218
 219 #
 220 # $mpd->ping;
 221 #
 222 # Sends a ping command to the mpd server.
 223 #
 224 sub ping {
 225     my ($self) = @_;
 226     $self->_send_command( "ping\n" );
 227 }
 228
 229
 230 #
 231 # my $version = $mpd->version;
 232 #
 233 # Return version of MPD server's connected.
 234 #
 235 # sub version {} # implemented as an accessor.
 236 #
 237
 238
 239 #
 240 # $mpd->kill;
 241 #
 242 # Send a message to the MPD server telling it to shut down.
 243 #
 244 sub kill {
 245     my ($self) = @_;
 246     $self->_send_command("kill\n");
 247 }
 248
 249
 250 #
 251 # $mpd->password( [$password] )
 252 #
 253 # Change password used to communicate with MPD server to $password.
 254 # Empty string is assumed if $password is not supplied.
 255 #
 256 sub password {
 257     my ($self, $passwd) = @_;
 258     $passwd ||= '';
 259     $self->_password($passwd);
 260     $self->ping; # ping sends a command, and thus the password is sent
 261 }
 262
 263
 264 #
 265 # $mpd->updatedb( [$path] );
 266 #
 267 # Force mpd to recan its collection. If $path (relative to MPD's music
 268 # directory) is supplied, MPD will only scan it - otherwise, MPD will rescan
 269 # its whole collection.
 270 #
 271 sub updatedb {
 272     my ($self, $path) = @_;
 273     $path ||= '';
 274     $self->_send_command("update $path\n");
 275 }
 276
 277
 278 #
 279 # my @handlers = $mpd->urlhandlers;
 280 #
 281 # Return an array of supported URL schemes.
 282 #
 283 sub urlhandlers {
 284     my ($self) = @_;
 285     return $self->_cooked_command_strip_first_field("urlhandlers\n");
 286 }
 287
 288
 289 # -- MPD interaction: handling volume & output
 290
 291 #
 292 # $mpd->volume( [+][-]$volume );
 293 #
 294 # Sets the audio output volume percentage to absolute $volume.
 295 # If $volume is prefixed by '+' or '-' then the volume is changed relatively
 296 # by that value.
 297 #
 298 sub volume {
 299     my ($self, $volume) = @_;
 300
 301     if ($volume =~ /^(-|\+)(\d+)/ )  {
 302         my $current = $self->status->volume;
 303         $volume = $1 eq '+' ? $current + $2 : $current - $2;
 304     }
 305     $self->_send_command("setvol $volume\n");
 306 }
 307
 308
 309 #
 310 # $mpd->output_enable( $output );
 311 #
 312 # Enable the specified audio output. $output is the ID of the audio output.
 313 #
 314 sub output_enable {
 315     my ($self, $output) = @_;
 316     $self->_send_command("enableoutput $output\n");
 317 }
 318
 319
 320 #
 321 # $mpd->output_disable( $output );
 322 #
 323 # Disable the specified audio output. $output is the ID of the audio output.
 324 #
 325 sub output_disable {
 326     my ($self, $output) = @_;
 327     $self->_send_command("disableoutput $output\n");
 328 }
 329
 330
 331
 332 # -- MPD interaction: retrieving info from current state
 333
 334 #
 335 # $mpd->stats;
 336 #
 337 # Return an Audio::MPD::Stats object with the current statistics of MPD.
 338 #
 339 sub stats {
 340     my ($self) = @_;
 341     my %kv = $self->_cooked_command_as_kv( "stats\n" );
 342     return Audio::MPD::Stats->new(%kv);
 343 }
 344
 345
 346 #
 347 # my $status = $mpd->status;
 348 #
 349 # Return an Audio::MPD::Status object with various information on current
 350 # MPD server settings. Check the embedded pod for more information on the
 351 # available accessors.
 352 #
 353 sub status {
 354     my ($self) = @_;
 355     my %kv = $self->_cooked_command_as_kv( "status\n" );
 356     my $status = Audio::MPD::Status->new( %kv );
 357     return $status;
 358 }
 359
 360
 361 #
 362 # my $song = $mpd->current;
 363 #
 364 # Return an C<Audio::MPD::Item::Song> representing the song currently playing.
 365 #
 366 sub current {
 367     my ($self) = @_;
 368     my ($item) = $self->_cooked_command_as_items("currentsong\n");
 369     return $item;
 370 }
 371
 372
 373 #
 374 # my $song = $mpd->song( [$song] )
 375 #
 376 # Return an C<Audio::MPD::Item::Song> representing the song number C<$song>.
 377 # If C<$song> is not supplied, returns the current song.
 378 #
 379 sub song {
 380     my ($self, $song) = @_;
 381     return $self->current unless defined $song;
 382     my ($item) = $self->_cooked_command_as_items("playlistinfo $song\n");
 383     return $item;
 384 }
 385
 386
 387 #
 388 # my $song = $mpd->songid( [$songid] )
 389 #
 390 # Return an C<Audio::MPD::Item::Song> representing the song with id C<$songid>.
 391 # If C<$songid> is not supplied, returns the current song.
 392 #
 393 sub songid {
 394     my ($self, $songid) = @_;
 395     return $self->current unless defined $songid;
 396     my ($item) = $self->_cooked_command_as_items("playlistid $songid\n");
 397     return $item;
 398 }
 399
 400
 401 # -- MPD interaction: altering settings
 402
 403 #
 404 # $mpd->repeat( [$repeat] );
 405 #
 406 # Set the repeat mode to $repeat (1 or 0). If $repeat is not specified then
 407 # the repeat mode is toggled.
 408 #
 409 sub repeat {
 410     my ($self, $mode) = @_;
 411
 412     $mode = not $self->status->repeat
 413         unless defined $mode; # toggle if no param
 414     $mode = $mode ? 1 : 0;               # force integer
 415     $self->_send_command("repeat $mode\n");
 416 }
 417
 418
 419 #
 420 # $mpd->random( [$random] );
 421 #
 422 # Set the random mode to $random (1 or 0). If $random is not specified then
 423 # the random mode is toggled.
 424 #
 425 sub random {
 426     my ($self, $mode) = @_;
 427
 428     $mode = not $self->status->random
 429         unless defined $mode; # toggle if no param
 430     $mode = $mode ? 1 : 0;               # force integer
 431     $self->_send_command("random $mode\n");
 432 }
 433
 434
 435 #
 436 # $mpd->fade( [$seconds] );
 437 #
 438 # Enable crossfading and set the duration of crossfade between songs. If
 439 # $seconds is not specified or $seconds is 0, then crossfading is disabled.
 440 #
 441 sub fade {
 442     my ($self, $value) = @_;
 443     $value ||= 0;
 444     $self->_send_command("crossfade $value\n");
 445 }
 446
 447
 448 # -- MPD interaction: controlling playback
 449
 450 #
 451 # $mpd->play( [$song] );
 452 #
 453 # Begin playing playlist at song number $song. If no argument supplied,
 454 # resume playing.
 455 #
 456 sub play {
 457     my ($self, $number) = @_;
 458     $number = '' unless defined $number;
 459     $self->_send_command("play $number\n");
 460 }
 461
 462 #
 463 # $mpd->playid( [$songid] );
 464 #
 465 # Begin playing playlist at song ID $songid. If no argument supplied,
 466 # resume playing.
 467 #
 468 sub playid {
 469     my ($self, $number) = @_;
 470     $number ||= '';
 471     $self->_send_command("playid $number\n");
 472 }
 473
 474
 475 #
 476 # $mpd->pause( [$sate] );
 477 #
 478 # Pause playback. If $state is 0 then the current track is unpaused, if
 479 # $state is 1 then the current track is paused.
 480 #
 481 # Note that if $state is not given, pause state will be toggled.
 482 #
 483 sub pause {
 484     my ($self, $state) = @_;
 485     $state ||= ''; # default is to toggle
 486     $self->_send_command("pause $state\n");
 487 }
 488
 489
 490 #
 491 # $mpd->stop;
 492 #
 493 # Stop playback.
 494 #
 495 sub stop {
 496     my ($self) = @_;
 497     $self->_send_command("stop\n");
 498 }
 499
 500
 501 #
 502 # $mpd->next;
 503 #
 504 # Play next song in playlist.
 505 #
 506 sub next {
 507     my ($self) = @_;
 508     $self->_send_command("next\n");
 509 }
 510
 511 #
 512 # $mpd->prev;
 513 #
 514 # Play previous song in playlist.
 515 #
 516 sub prev {
 517     my($self) = shift;
 518     $self->_send_command("previous\n");
 519 }
 520
 521
 522 #
 523 # $mpd->seek( $time, [$song]);
 524 #
 525 # Seek to $time seconds in song number $song. If $song number is not specified
 526 # then the perl module will try and seek to $time in the current song.
 527 #
 528 sub seek {
 529     my ($self, $time, $song) = @_;
 530     $time ||= 0; $time = int $time;
 531     $song = $self->status->song if not defined $song; # seek in current song
 532     $self->_send_command( "seek $song $time\n" );
 533 }
 534
 535
 536 #
 537 # $mpd->seekid( $time, $songid );
 538 #
 539 # Seek to $time seconds in song ID $songid. If $song number is not specified
 540 # then the perl module will try and seek to $time in the current song.
 541 #
 542 sub seekid {
 543     my ($self, $time, $song) = @_;
 544     $time ||= 0; $time = int $time;
 545     $song = $self->status->songid if not defined $song; # seek in current song
 546     $self->_send_command( "seekid $song $time\n" );
 547 }
 548
 549
 550 1;
 551
 552
 553
 554 __END__
 555
 556 =pod
 557
 558 =head1 NAME
 559
 560 Audio::MPD - class to talk to MPD (Music Player Daemon) servers
 561
 562
 563 =head1 SYNOPSIS
 564
 565     use Audio::MPD;
 566
 567     my $mpd = Audio::MPD->new();
 568     $mpd->play();
 569     sleep 10;
 570     $mpd->next();
 571
 572
 573 =head1 DESCRIPTION
 574
 575 Audio::MPD gives a clear object-oriented interface for talking to and
 576 controlling MPD (Music Player Daemon) servers. A connection to the MPD
 577 server is established as soon as a new Audio::MPD object is created.
 578 Commands are then sent to the server as the class's methods are called.
 579
 580
 581 =head1 METHODS
 582
 583 =head2 Constructor
 584
 585 =over 4
 586
 587 =item new( [$host] [, $port] [, $password] )
 588
 589 This is the constructor for Audio::MPD. One can specify a $hostname, a
 590 $port, and a $password.
 591
 592 If none is specified then defaults to environment vars MPD_HOST, MPD_PORT
 593 and MPD_PASSWORD. If those aren't set, defaults to 'localhost', 6600 and ''.
 594
 595 =back
 596
 597
 598 =head2 Controlling the server
 599
 600 =over 4
 601
 602 =item $mpd->ping()
 603
 604 Sends a ping command to the mpd server.
 605
 606
 607 =item $mpd->version()
 608
 609 Return the version number for the server we are connected to.
 610
 611
 612 =item $mpd->kill()
 613
 614 Send a message to the MPD server telling it to shut down.
 615
 616
 617 =item $mpd->password( [$password] )
 618
 619 Change password used to communicate with MPD server to $password.
 620 Empty string is assumed if $password is not supplied.
 621
 622
 623 =item $mpd->updatedb( [$path] )
 624
 625 Force mpd to recan its collection. If $path (relative to MPD's music directory)
 626 is supplied, MPD will only scan it - otherwise, MPD will rescan its whole
 627 collection.
 628
 629
 630 =item $mpd->urlhandlers()
 631
 632 Return an array of supported URL schemes.
 633
 634
 635 =back
 636
 637
 638 =head2 Handling volume & output
 639
 640 =over 4
 641
 642 =item $mpd->volume( [+][-]$volume )
 643
 644 Sets the audio output volume percentage to absolute $volume.
 645 If $volume is prefixed by '+' or '-' then the volume is changed relatively
 646 by that value.
 647
 648
 649 =item $mpd->output_enable( $output )
 650
 651 Enable the specified audio output. $output is the ID of the audio output.
 652
 653
 654 =item $mpd->output_disable( $output )
 655
 656 Disable the specified audio output. $output is the ID of the audio output.
 657
 658 =back
 659
 660
 661 =head2 Retrieving info from current state
 662
 663 =over 4
 664
 665 =item $mpd->stats()
 666
 667 Return an C<Audio::MPD::Stats> object with the current statistics of MPD.
 668 See the associated pod for more information.
 669
 670
 671 =item $mpd->status()
 672
 673 Return an C<Audio::MPD::Status> object with various information on current
 674 MPD server settings. Check the embedded pod for more information on the
 675 available accessors.
 676
 677
 678 =item $mpd->current()
 679
 680 Return an C<Audio::MPD::Item::Song> representing the song currently playing.
 681
 682
 683 =item $mpd->song( [$song] )
 684
 685 Return an C<Audio::MPD::Item::Song> representing the song number C<$song>. If
 686 C<$song> is not supplied, returns the current song.
 687
 688
 689 =item $mpd->songid( [$songid] )
 690
 691 Return an C<Audio::MPD::Item::Song> representing the song with id C<$songid>.
 692 If C<$songid> is not supplied, returns the current song.
 693
 694 =back
 695
 696
 697 =head2 Altering MPD settings
 698
 699 =over 4
 700
 701 =item $mpd->repeat( [$repeat] )
 702
 703 Set the repeat mode to $repeat (1 or 0). If $repeat is not specified then
 704 the repeat mode is toggled.
 705
 706
 707 =item $mpd->random( [$random] )
 708
 709 Set the random mode to $random (1 or 0). If $random is not specified then
 710 the random mode is toggled.
 711
 712
 713 =item $mpd->fade( [$seconds] )
 714
 715 Enable crossfading and set the duration of crossfade between songs.
 716 If $seconds is not specified or $seconds is 0, then crossfading is disabled.
 717
 718 =back
 719
 720
 721 =head2 Controlling playback
 722
 723 =over 4
 724
 725 =item $mpd->play( [$song] )
 726
 727 Begin playing playlist at song number $song. If no argument supplied,
 728 resume playing.
 729
 730
 731 =item $mpd->playid( [$songid] )
 732
 733 Begin playing playlist at song ID $songid. If no argument supplied,
 734 resume playing.
 735
 736
 737 =item $mpd->pause( [$state] )
 738
 739 Pause playback. If C<$state> is 0 then the current track is unpaused,
 740 if $state is 1 then the current track is paused.
 741
 742 Note that if C<$state> is not given, pause state will be toggled.
 743
 744
 745 =item $mpd->stop()
 746
 747 Stop playback.
 748
 749
 750 =item $mpd->next()
 751
 752 Play next song in playlist.
 753
 754
 755 =item $mpd->prev()
 756
 757 Play previous song in playlist.
 758
 759
 760 =item $mpd->seek( $time, [$song])
 761
 762 Seek to $time seconds in song number $song. If $song number is not specified
 763 then the perl module will try and seek to $time in the current song.
 764
 765
 766 =item $mpd->seekid( $time, $songid )
 767
 768 Seek to $time seconds in song ID $songid. If $song number is not specified
 769 then the perl module will try and seek to $time in the current song.
 770
 771 =back
 772
 773
 774 =head2 Searching the collection
 775
 776 To search the collection, use the C<collection()> accessor, returning the
 777 associated C<Audio::MPD::Collection> object. You will then be able to call:
 778
 779     $mpd->collection->random_song();
 780
 781 See C<Audio::MPD::Collection> documentation for more details on available
 782 methods.
 783
 784
 785 =head2 Handling the playlist
 786
 787 To update the playlist, use the C<playlist()> accessor, returning the
 788 associated C<Audio::MPD::Playlist> object. You will then be able to call:
 789
 790     $mpd->playlist->clear;
 791
 792 See C<Audio::MPD::Playlist> documentation for more details on available
 793 methods.
 794
 795
 796 =head1 SEE ALSO
 797
 798 You can find more information on the mpd project on its homepage at
 799 L<http://www.musicpd.org>, or its wiki L<http://mpd.wikia.com>.
 800
 801 Regarding this Perl module, you can report bugs on CPAN via
 802 L<http://rt.cpan.org/Public/Bug/Report.html?Queue=Audio-MPD>.
 803
 804 Audio::MPD development takes place on <audio-mpd@googlegroups.com>: feel free
 805 to join us. (use L<http://groups.google.com/group/audio-mpd> to sign in). Our
 806 subversion repository is located at L<https://svn.musicpd.org>.
 807
 808
 809
 810 =head1 AUTHORS
 811
 812 Jerome Quelin <jquelin@cpan.org>
 813
 814 Original code by Tue Abrahamsen <tue.abrahamsen@gmail.com>, documented by
 815 Nicholas J. Humfrey <njh@aelius.com>.
 816
 817
 818
 819 =head1 COPYRIGHT AND LICENSE
 820
 821 Copyright (c) 2005 Tue Abrahamsen <tue.abrahamsen@gmail.com>
 822
 823 Copyright (c) 2006 Nicholas J. Humfrey <njh@aelius.com>
 824
 825 Copyright (c) 2007 Jerome Quelin <jquelin@cpan.org>
 826
 827
 828 This program is free software; you can redistribute it and/or modify
 829 it under the terms of the GNU General Public License as published by
 830 the Free Software Foundation; either version 2 of the License, or
 831 (at your option) any later version.
 832
 833 This program is distributed in the hope that it will be useful,
 834 but WITHOUT ANY WARRANTY; without even the implied warranty of
 835 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 836 GNU General Public License for more details.
 837
 838 =cut
 839