POE/giFT/gift.pl

#!/usr/bin/perl -w

# PoCo-giFT v0.1 Jason Stillwell 2002 
# use at your own risk, no warantees implied, no guarantees provided. 
# it shouldn't \rm -rf * your hard drive but then again look what happened with Pool of Radiance

use strict;
use Gtk;
use POE;

package POE::Component::giFT;
use POE::Session;
use POE::Wheel::SocketFactory;
use POE::Wheel::ReadWrite;
use POE::Driver::SysRW;
use POE::Filter::Stream;
use Gtk;
use Data::Dumper;

my $LOG; # later, the logging method to use.

sub new { # CLASS METHOD
        my $type = shift;
        my %options = @_;

        $LOG = $options{LOG} if exists($options{LOG});

        # start up gift POE session
        my $session =  POE::Session->create(
                 package_states => [
                        $type =>
                                [ qw(
                                _start
                                gtk_start
                                connect_success
                                connect_failure
                                io_error
                                io_input
                                close
                                do_query
                                do_transfer
                                add_sources
                                event_in
                                item_in 
                                id_in 
                                end_id 
                                query_clicked 
                                download_clicked 
                                stop_download_clicked
                                stop_upload_clicked
                                get_stats
                                ) ]
                         ],
                options => { debug => 1 }
                );

        return $session;
}

sub connect_failure { # EVENT
        # called if we can't connect to the daemon
        my $kernel = $_[KERNEL];
        &log("daemon connect failed");
        $kernel->yield('close');
}

sub close { # EVENT
        # called if the connection closed or we need to close it
        my $heap = $_[HEAP];
        &log("closing connection");
        delete $heap->{factory};
        delete $heap->{io};
}

sub connect_success { # EVENT
        # called when our socket connects. does protocol initilization.
        my ($kernel,$heap,$socket) = @_[KERNEL,HEAP,ARG0];

        &log("daemon connected, sending attach");
        $heap->{io} = new POE::Wheel::ReadWrite (
                Handle => $socket,
                Driver => new POE::Driver::SysRW (),
                Filter => new POE::Filter::Stream (),
                InputEvent => 'io_input',
                ErrorEvent => 'io_error'
        );

        $heap->{io}->put(&event_to_data({event=>'attach', profile=>'dragonfax', client=>'PoCo-giFT', version=>'0.1'}));
        $kernel->yield('gtk_start');
}


# for simplicity we dont use a full fledged 'event' object. just a hash of values.
# these two function handle the converstion to and from the io stream when necessary

sub event_to_data { # SUBROUTINE
        my %event = %{shift()};
        if ( not exists($event{event}) ) {
                &log('tried to create event without a type');
                &print_event(\%event);
                return undef;
        }
        my $data = "<$event{event}";
        foreach my $param ( keys %event ) {
                next if $param eq 'event';
                $data .= qq( $param="$event{$param}");
        }
        $data .= "/>\r\n";
        return $data;
}

sub data_to_event { # SUBROUTINE
        # takes a line from the socket input and turns it into a hash ref of values
        my $data = shift;
        $data =~ s{\r\n$}{};
        $data =~ s{^<(.+)/>$}{$1} or &log("bad event structure $data");
        $data =~ s{^(\S+)\s*}{} or &log("no event type $data");

        my %params = ( event => $1 );
        while ( $data =~ s{^\s*(\S+)="([^"]+)"\s*}{} ) {
                $params{$1} = $2;
        }

        return \%params;
}

sub io_input { # EVENT 
        # called when we receive input. breaks it up into lines and hands it over to the event dispatcher
        my ($kernel,$line) = @_[KERNEL,ARG0];
        
        while ( $line =~ s{^(.+)\r\n}{} ) { # possibly multiple lines per io input packet
                my $tag = $1;
                my $event = &data_to_event($tag);
                $kernel->yield('event_in',$event);
        }
}

sub event_in { # EVENT
        # event dispatcher, receives lines, parses them and distributes them to the write events
        my ($kernel,$heap,$event) = @_[KERNEL,HEAP,ARG0];
        #&print_event($event);

        if ( $$event{event} eq 'event' ) {
                # let ui know we've got an id now
                $kernel->yield('id_in',$event);
        }
        elsif ( $$event{event} eq 'item' ) { # query hit
                $kernel->yield('item_in',$event);
        }
        elsif ( $$event{event} eq 'search' ) { # query hit
                # let ui know this event is over
                $kernel->yield('end_id',$event);
        }
        elsif ( $$event{event} eq 'stats' ) {
                # update stats display, we only care about OpenFT for now
                return if ( not exists($$event{protocol}) ) or ( $$event{protocol} ne 'OpenFT' );
                $heap->{labels}->{users}->set_text($$event{users});
                $heap->{labels}->{files}->set_text($$event{files});
                $heap->{labels}->{shared}->set_text("$$event{size}GB");
        }
        elsif ( $$event{event} eq 'transfer' ) {
                # its either an upload, external download, or progress
                if ( exists($heap->{transfers}->{$$event{id}}) ) {
                        if ( exists($$event{addsource}) ) {
                                # just a source line, no data downloaded, add info
                                push @{$heap->{transfers}->{$$event{id}}->{sources}},$event;
                        }
                        elsif ( exists($$event{transmit}) ) {
                                # update line in CList (GUI)
                                my $id = $$event{id};
                                my $list;
                                my $number;
                                if ( exists($heap->{transfers}->{$id}->{dl_number}) ) {
                                        $number = $heap->{transfers}->{$id}->{dl_number};
                                        $list = $heap->{dl_list} 
                                }
                                else {
                                        $number = $heap->{transfers}->{$id}->{ul_number};
                                        $list = $heap->{ul_list};
                                }
                                $list->set_text($number,1,$$event{transmit});
                        }
                        else {
                                # end-transfer event

                                # remove line from clist
                                my $id = $$event{id};
                                my $hash = $heap->{transfers}->{$id}->{hash};
                                my $list = exists($heap->{transfers}->{$id}->{dl_number}) ? $heap->{dl_list} : $heap->{ul_list};
                                # find row to remove (clist.find_row_from_dat is useless)
                                my $num_rows = $list->rows();
                                for ( my $i = 0; $i < $num_rows; $i++) {
                                        if ( $list->get_text($i,3) eq $hash ) {
                                                $list->remove($i);
                                                last;
                                        }
                                }

                                # remove transfer info
                                delete($heap->{transfers}->{$id});
                        }
                }
                elsif ( exists($$event{action}) ) {
                        # upload started or downloaded started in a different session (gui)
                        $heap->{transfers}->{$$event{id}} = $event;
                        if ( $$event{action} eq 'upload' ) {
                                # upload notification
                                my $number = $heap->{ul_list}->rows();
                                $heap->{transfers}->{$$event{id}}->{ul_number} = $number;
                                $heap->{ul_list}->append($$event{save}, 0, $$event{size}, $$event{hash});
                        }
                        elsif ( $$event{action} eq 'download' ) {
                                # new transfer, create the stuff to watch it.
                                my $number = $heap->{dl_list}->rows();
                                $heap->{transfers}->{$$event{id}}->{dl_number} = $number;
                                $heap->{dl_list}->append($$event{save}, 0, $$event{size}, $$event{hash});

                        }
                }
        }
        #else {
        #}

}

sub stop_download_clicked { # EVENT
        # kill download clicked in GUI
        my ($heap) = $_[HEAP];
        my $list = $heap->{dl_list};
        &stop_transfer($heap,$list);
}

sub stop_upload_clicked { # SUBROUTINE
        # kill upload clicked in GUI
        my ($heap) = $_[HEAP];
        my $list = $heap->{ul_list};
        &stop_transfer($heap,$list);
}

sub stop_transfer { # EVENT
        # kills the transfer and removes it from our internal structs and GUI
        my ($heap,$list) = @_;
        my $row_selected = ($list->selection)[0];
        my $hash = $list->get_text($row_selected,3);

        # find that id
        my $our_id;
        foreach my $id ( keys %{$heap->{transfers}} ) {
                $our_id = $id if $heap->{transfers}->{$id}->{hash} eq $hash;
        }

        # send 'kill transfer'
        $heap->{io}->put(&event_to_data({event=>'transfer', action=>'cancel', id=>$our_id}));
        
}


sub get_stats { # EVENT
        # politely asks for stats update
        my $heap = $_[HEAP];
        $heap->{io}->put(&event_to_data({event=>'stats'}));
        $heap->{waiting} = { event => 'stats'};
}

sub do_query { # EVENT
        # handles the underlying part of sending a query to the daemon
        my ($heap,$query,$realm) = @_[HEAP,ARG0,ARG1];
        if ( $realm eq 'everything' )  {
                $heap->{io}->put(&event_to_data({event=>'search', query=>$query}));
        }
        else {
                $heap->{io}->put(&event_to_data({event=>'search', realm=>$realm, query=>$query}));
        }
}

sub do_transfer { # EVENT
        # handles hte underlying protocol of sending a transfer request to the daemon
        my ($heap,$hash) = @_[HEAP,ARG0];
        my $filename = &href2filename($heap->{hashes}->{$hash}->[0]->{href});
        my $size = $heap->{hashes}->{$hash}->[0]->{size};
        $heap->{io}->put(&event_to_data({event=>'transfer', action=>'download', save=>$filename, size=>$size, hash=>$hash}));
}

sub print_event { # SUBROUTINE
        # useful for logging purposes
        my $event = shift;
        my $string = "[$$event{event}]";
        foreach my $param ( keys %{$event} ) {
                next if ($param eq 'event');
                $string .= " $param=$$event{$param}";
        }
        &log($string);
}

sub io_error { # EVENT
        # called when we fail to read from the socket. means its time to close up shop.
        my $kernel = $_[KERNEL];
        &log("io error");
        $kernel->yield('close');
}


sub _start { # EVENT
        # session initializer, like a Constructor but for POE sessions.
        my ($kernel,$heap) = @_[KERNEL,HEAP];

        $kernel->alias_set('giFT');
        $heap->{queries} = [];

        &log("connecting to daemon");
        $heap->{factory} = new POE::Wheel::SocketFactory
                (
                RemoteAddress  => '127.0.0.1',       # Sets the connect() address
                RemotePort     => 1213,          # Sets the connect() port
                SuccessEvent => 'connect_success',
                FailureEvent => 'connect_failure'
                );

}

sub gtk_start { # EVENT
        # we've connected to the daemon so its OK to start the GUI.
        # this sets up almost the entire GUI and displays it. 
        my ($kernel,$heap,$session) = @_[KERNEL,HEAP,SESSION];

        set_locale Gtk;
        init Gtk;
        my $window = new Gtk::Window("toplevel");
        $window->set_title('PoCo-giFT');
        $window->signal_connect( "delete_event", sub {Gtk->main_quit} );
        $window->border_width( 5 );

        my $notebook = new Gtk::Notebook();
        $notebook->set_tab_pos('top'); 
        $window->add($notebook);

        ###
        # Search Tab
        ###

        my $search_table = new Gtk::Table( 5, 3, 0 ); 
        $heap->{search_table} = $search_table;
        $search_table->set_row_spacings(10);
        $search_table->set_col_spacings(10);
        $notebook->append_page($search_table, Gtk::Label->new("Search"));

        my $search_label = new Gtk::Label('Keywords:');
        my $entry = new Gtk::Entry(); 
        $search_table->attach($search_label,0,1,0,1, [], [], 0, 0);

        $heap->{entry} = $entry;
        $entry->signal_connect("activate", $session->postback('query_clicked'));
        $search_table->attach($entry,1,2,0,1, [], [], 0, 0);

        my $realm_select = new Gtk::OptionMenu();
        my $realm_menu = new Gtk::Menu();
        $heap->{realm_menu} = $realm_menu;

        my $everything_item = new Gtk::MenuItem("Everything");
        $realm_menu->append($everything_item);
        $everything_item->show();
        $heap->{realms}->{$everything_item} = 'everything';

        my $audio_item = new Gtk::MenuItem("Audio");
        $realm_menu->append($audio_item);
        $audio_item->show();
        $heap->{realms}->{$audio_item} = 'audio';

        my $video_item = new Gtk::MenuItem("Video");
        $realm_menu->append($video_item);
        $video_item->show();
        $heap->{realms}->{$video_item} = 'video';

        my $images_item = new Gtk::MenuItem("Images");
        $realm_menu->append($images_item);
        $images_item->show();
        $heap->{realms}->{$images_item} = 'images';

        my $texts_item = new Gtk::MenuItem("Text Documents");
        $realm_menu->append($texts_item);
        $texts_item->show();
        $heap->{realms}->{$texts_item} = 'text documents';

        my $software_item = new Gtk::MenuItem("Software");
        $realm_menu->append($software_item);
        $software_item->show();
        $heap->{realms}->{$software_item} = 'software';

        my $hash_item = new Gtk::MenuItem("Hash");
        $realm_menu->append($hash_item);
        $hash_item->show();
        $heap->{realms}->{$hash_item} = 'hash';

        my $user_item = new Gtk::MenuItem("User");
        $realm_menu->append($user_item);
        $user_item->show();
        $heap->{realms}->{$user_item} = 'user';

        $realm_select->set_menu( $realm_menu);
        $realm_select->set_history( 0 ); 
        $search_table->attach($realm_select,0,2,1,2, [], [], 0, 0);


        my $search_button = new Gtk::Button("Search");
        $search_button->signal_connect("clicked", $session->postback('query_clicked'));
        $search_table->attach($search_button,0,1,2,3, [], [], 0, 0);

        my $close_query_button = new Gtk::Label("Close Query");
        $search_table->attach($close_query_button,1,2,2,3, [], [], 0, 0);


        ## Stats Table
        my $stats_table = new Gtk::Table( 3, 2, 1 ); 
        $stats_table->attach_defaults(Gtk::Label->new("Users:"),0,1,0,1);
        $stats_table->attach_defaults(Gtk::Label->new("Files:"),0,1,1,2);
        $stats_table->attach_defaults(Gtk::Label->new("Shared:"),0,1,2,3);
        $search_table->attach($stats_table,2,3,0,3, [], [],  0,  0);

        my $users_label = Gtk::Label->new(0);
        $stats_table->attach_defaults($users_label,1,2,0,1);
        $heap->{labels}->{users} = $users_label;

        my $files_label = Gtk::Label->new(0);
        $stats_table->attach_defaults($files_label,1,2,1,2);
        $heap->{labels}->{files} = $files_label;

        my $shared_label = Gtk::Label->new(0);
        $stats_table->attach_defaults($shared_label,1,2,2,3);
        $heap->{labels}->{shared} = $shared_label;


        my $scrolled_window = new Gtk::ScrolledWindow( undef, undef );
        $heap->{query_scrolls}->[0] = $scrolled_window;
        $scrolled_window->set_usize( 400, 300 );
        $search_table->attach($scrolled_window,0,3,3,4,[qw(fill expand)], [qw(fill expand)],  0,  0 );

        my $gtklist = Gtk::CList->new_with_titles(qw(name size hash));
        $gtklist->set_selection_mode('single');
        $gtklist->set_column_width(0,200);
        $gtklist->set_column_width(1,100);
        $heap->{lists}->[0] = $gtklist;
        $scrolled_window->add_with_viewport( $gtklist );

        my $download_button = new Gtk::Button("Download");
        $download_button->signal_connect("clicked", $session->postback('download_clicked'));
        $search_table->attach($download_button,1,2,4,5, [], [], 0, 0);

        my $quit_button = new Gtk::Button("Quit");
        $quit_button->signal_connect("clicked", sub {Gtk->main_quit});
        $search_table->attach($quit_button,2,3,4,5, [], [], 0, 0);

        ###
        # Transfers Tab
        ###
        my $paned = new Gtk::VPaned();
        $notebook->append_page($paned, Gtk::Label->new("Transfers"));

        ## Downloads

        my $downloads_box = new Gtk::VBox( 0, 5);
        $paned->add1($downloads_box);

        my $downloads_window = new Gtk::ScrolledWindow( undef, undef );
        $downloads_box->pack_start($downloads_window, 1, 1, 0);

        my $dl_list = Gtk::CList->new_with_titles(qw(name dl total hash));
        $dl_list->set_selection_mode('single');
        $dl_list->set_column_width(0,200);
        $dl_list->set_column_width(1,100);
        $dl_list->set_column_width(2,100);
        $heap->{dl_list} = $dl_list;
        $downloads_window->add_with_viewport( $dl_list );

        my $stop_download = new Gtk::Button("Kill Download");
        $downloads_box->pack_start($stop_download, 0, 0, 0);
        $stop_download->signal_connect("clicked", $session->postback('stop_download_clicked'));


        ## Uploads
        my $uploads_box = new Gtk::VBox( 0, 5);
        $paned->add2($uploads_box);

        my $uploads_window = new Gtk::ScrolledWindow( undef, undef );
        $uploads_box->pack_start($uploads_window, 1, 1, 0);

        my $ul_list = Gtk::CList->new_with_titles(qw(name ul total hash));
        $ul_list->set_selection_mode('single');
        $ul_list->set_column_width(0,200);
        $ul_list->set_column_width(1,100);
        $ul_list->set_column_width(2,100);
        $heap->{ul_list} = $ul_list;
        $uploads_window->add_with_viewport( $ul_list );

        my $stop_upload = new Gtk::Button("Kill Upload");
        $uploads_box->pack_start($stop_upload, 0, 0, 0);
        $stop_upload->signal_connect("clicked", $session->postback('stop_upload_clicked'));

        $paned->set_position(300);


        ###
        # End Widgets
        ###

        $window->show_all;

        $kernel->yield('get_stats');

}

sub download_clicked { # EVENT
        # download button clicked in GUI
        my ($kernel, $heap, $widget) = @_[KERNEL,HEAP,ARG0];

        return if defined($heap->{waiting}); # only one ID at once

        my $list;
        if ( scalar(@{$heap->{queries}}) > 1 ) {
                my $page = $heap->{search_book}->get_current_page();
                # get list from that page
                $list = $heap->{lists}->[$page];
        }
        else {
                $list = $heap->{lists}->[0];
        }

        my $row_selected = ($list->selection)[0];
        my $hash = $list->get_text($row_selected,2);

        #&log("starting transfer for ",&href2filename($heap->{hashes}->{$hash}->[0]->{href})," $hash\n");
        $kernel->yield('do_transfer',$hash);
        $heap->{waiting} = { event => 'transfer', hash => $hash };
}

sub new_page { # SUBROUTINE
        # a new page in the search notebook is created for every search after the first one.
        my $heap = shift;
        my $query_number = scalar(@{$heap->{queries}}) - 1;

        my $query_scroll = new Gtk::ScrolledWindow( undef, undef );
        my $tab_string = substr($heap->{queries}->[$query_number]->{query},0,10);
        $heap->{search_book}->append_page($query_scroll, Gtk::Label->new($tab_string)); #use query string

        my $gtklist = Gtk::CList->new_with_titles(qw(name size hash));
        $gtklist->set_selection_mode('single');
        $gtklist->set_column_width(0,200);
        $gtklist->set_column_width(1,100);
        $heap->{lists}->[$query_number] = $gtklist;
        $query_scroll->add_with_viewport( $gtklist );
        $heap->{query_scrolls}->[$query_number] = $query_scroll;
        $query_scroll->show_all();

}


sub query_clicked { # EVENT
        # the search button was clicked or enter hit in the keywords field in the GUI
        my ($kernel, $heap, $widget) = @_[KERNEL,HEAP,ARG0];

        return if defined($heap->{waiting}); # only one ID at once

        my $query_number = scalar(@{$heap->{queries}}); # next available query slot

        if ( $query_number == 1) {
                # this is our second query, add notebook for more than one query

                # new notebook
                my $notebook = new Gtk::Notebook();
                $heap->{search_book} = $notebook;
                $notebook->set_tab_pos('top'); 

                # move the original scrolled window to this notebook page
                my $query_scroll_1 = $heap->{query_scrolls}->[0];
                my $search_table = $heap->{search_table};
                $search_table->remove($query_scroll_1);
                my $tab_string = substr($heap->{queries}->[0]->{query},0,10);
                $notebook->append_page($query_scroll_1, Gtk::Label->new($tab_string)); #use query string

                # add the notebook to the search table
                $search_table->attach($notebook,0,3,3,4,[qw(fill expand)], [qw(fill expand)],  0,  0 );
                $search_table->show_all();
        }


        my $realm = $heap->{realms}->{ $heap->{realm_menu}->get_active };
        my $query = $heap->{entry}->get_text;
        $kernel->yield('do_query',$query,$realm);

        #need to add special cases for user and hash realms
        my %event = ( query => $query, finished => 0, hash => undef, id => undef, realm => $realm );
        push @{$heap->{queries}},\%event;

        # set up to receive next ID
        $heap->{waiting} = { event => 'query', number => $query_number };

        if ( $query_number ) { # for any additional queries
                &new_page($heap);
                $heap->{search_book}->set_page($query_number);
        }
}


sub id_in { # EVENT
        # we got an 'event' event which means we've been given and 'id' for some action.
        # give this id to the waiting search or transfer and start it up
        my ($heap,$event) = @_[HEAP,ARG0];

        if ( defined($heap->{waiting}) ) {
                my $w_event = $heap->{waiting}->{event};
                if ( $w_event eq 'query' ) {
                        my $number = $heap->{waiting}->{number};
                        $heap->{queries}->[$number]->{id} = $$event{id};
                        $heap->{ids}->{$$event{id}} = $number;
                }
                elsif ( $w_event eq 'transfer' ) {
                        # ready to add sources now
                        my $id = $$event{id};
                        my $hash = $heap->{waiting}->{hash};
                        $heap->{transfers}->{$id}->{hash} = $hash;
                        &add_sources($heap,$id,$hash);

                        # add this download to the dl list in the GUI
                        my $number = $heap->{dl_list}->rows();
                        $heap->{transfers}->{$id}->{dl_number} = $number;
                        my $save = &href2filename($heap->{hashes}->{$hash}->[0]->{href});
                        $heap->{transfers}->{$id}->{save} = $save;
                        my $size = $heap->{hashes}->{$hash}->[0]->{size};
                        $heap->{transfers}->{$id}->{size} = $size;
                        $heap->{dl_list}->append($save, 0, $size, $hash);
                }
                elsif ( $w_event eq 'stats' ) {
                        $heap->{stats}->{id} = $$event{id};
                }
                else {
                        &log("unknown event type waiting for id");
                }
                $heap->{waiting} = undef;
        }
        else {
                &log("error: id but no event waiting");
        }
}


sub add_sources { # SUBROUTINE
        # assumes we've already searched for more sources.
        my ($heap,$id,$hash) = @_;
        foreach my $source ( @{$heap->{hashes}->{$hash}} ) { # add sources one by one
                my $user = $$source{user};
                next if exists($heap->{transfer}->{$id}->{users}->{$user});
                my $href = $$source{href};

                $heap->{io}->put(&event_to_data({event=>'transfer', id=>$id, user=>$user, hash=>$hash, addsource=>$href}));
                $heap->{transfer}->{$id}->{users}->{$user} = 1;
        }
}

sub end_id { # EVENT
        # we got something signaling the end of a search or transfer
        my ($heap,$event) = @_[HEAP,ARG0];
        $heap->{queries}->[$heap->{ids}->{$$event{id}}]->{finished} = 1;
}

sub item_in { # EVENT
        # we received a search result. 
        my ($heap,$event) = @_[HEAP,ARG0];

        if ( not exists($heap->{ids}->{$$event{id}}) ) {
                &log('item with unknown id');
                return;
        }

        if ( not exists($heap->{queries}->[$heap->{ids}->{$$event{id}}]->{hashes}->{$$event{hash}}) ) {
                # first time we've seen this hash, add to the GUI's list for this search id (notebook page).
                $heap->{queries}->[$heap->{ids}->{$$event{id}}]->{hashes}->{$$event{hash}} = 1;
                &print_item($heap,$event);
        }
        #not yet weeding out duplicates anywhere
        push @{$heap->{hashes}->{$$event{hash}}},$event; 
}

sub print_item { # SUBROUTINE
        # not used for logging, rather prints the search result to the GUI (bad sub naming)
        my ($heap,$item) = @_;
        my $filename = &href2filename($$item{href});
        #&log("file: $filename\tsize: $$item{size}");
        my $query_number = $heap->{ids}->{$$item{id}};
        $heap->{lists}->[$query_number]->append($filename,$$item{size},$$item{hash});
}

sub href2filename { # SUBROUTINE
        # used for getting a quick filename to use in conjuction with transfers
        my $href = shift;
        $href =~ m{/([^/]+)$};
        my $filename = $1;
        $filename =~ s{\%20}{ }g;
        return $filename;
}

sub dump { # SUBROUTINE
        # useful for logging
        my $string = Dumper(@_);
        #my @strings = split(/\n/,$string);
        &log($string);
}

sub log { # SUBROUTINE
        # logging
        print @_,"\n";
}


package main;

# all we do is create one instance of our monster object/session/package
POE::Component::giFT->new();


$poe_kernel->run();

MailToCvsAdmin">MailToCvsAdmin	ViewVC Help
Powered by ViewVC 1.1.26