Net::Lyskom - Perl module used to talk to LysKOM servers.

  use Net::Lyskom;

  $a = Net::Lyskom->new();
  $conf = 6;

  $a->login(pers_no => 437, password => "God", invisible => 1)
    or die "Failed to log in: $a->err_string\n";

  $b = $a->send_message(7680, "Oook!");

  $b = $a->create_text(
	  	       subject => "Testsubject",
                       body => "A nice and tidy message body.",
		       recpt => [437],
		      );

  if ($b) {
      print "Text number $b created.\n";
  } else {
      print "Text creation failed: $a->err_string.\n";
  }

package Net::Lyskom;
use base qw{Net::Lyskom::Object};

use strict;
use IO::Socket;
use Time::Local;
use Net::Lyskom::AuxItem;
use Net::Lyskom::MiscInfo;
use Net::Lyskom::Time;
use Net::Lyskom::TextStat;
use Net::Lyskom::Conference;
use Net::Lyskom::Person;
use Net::Lyskom::Util qw(:all);
use Net::Lyskom::Membership;
use Net::Lyskom::TextMapping;
use Net::Lyskom::ConfZInfo;
use Net::Lyskom::DynamicSession;
use Net::Lyskom::StaticSession;
use Net::Lyskom::Member;
use Net::Lyskom::Info;

use Carp;

use vars qw{ @error };


our $VERSION = '1.1';

## Variables


@error = qw(no-error
	    unused
	    not-implemented
	    obsolete-call
	    invalid-password
	    string-too-long
	    login-first
	    login-disallowed
	    conference-zero
	    undefined-conference
	    undefined-person
	    access-denied
	    permission-denied
	    not-member
	    no-such-text
	    text-zero
	    no-such-local-text
	    local-text-zero
	    bad-name
	    index-out-of-range
	    conference-exists
	    person-exists
	    secret-public
	    letterbox
	    ldb-error
	    illegal-misc
	    illegal-info-type
	    already-recipient
	    already-comment
	    already-footnote
	    not-recipient
	    not-comment
	    not-footnote
	    recipient-limit
	    comment-limit
	    footnote-limit
	    mark-limit
	    not-author
	    no-connect
	    out-of-memory
	    server-is-crazy
	    client-is-crazy
	    undefined-session
	    regexp-error
	    not-marked
	    temporary-failure
	    long-array
	    anonymous-rejected
	    illegal-aux-item
	    aux-item-permission
	    unknown-async
	    internal-error
	    feature-disabled
	    message-not-sent
	    invalid-membership-type);


## Methods

sub is_error {
    my $self = shift;
    my ($code, $err_no, $err_status) = @_;

    if ($code =~ /^=/) {
	$self->{err_no} = 0;
	$self->{err_status} = 0;
	$self->{err_string} = "";
	return 0;		# Not an error
    } elsif ($code =~ /^%% /) {
	$self->{err_no} = 4711;
	$self->{err_status} = $err_status;
	$self->{err_string} = "Protocol error!";
	return 1;		# Is an error
    } elsif ($code =~ /^%/) {
	$self->{err_no} = $err_no;
	$self->{err_status} = $err_status;
	$self->{err_string} = $error[$err_no];
	return 1;		# Is an error
    } else {
	croak "An unknown error? ($code)\n";
    }
}

sub err_no {my $s = shift; return $s->{err_no}}
sub err_status {my $s = shift; return $s->{err_status}}
sub err_string {my $s = shift; return $s->{err_string}}

sub new {
    my $proto = shift;
    my $class = ref($proto) || $proto;
    my $self = {};
    my %arg = @_;

    my $host = $arg{Host} || "kom.lysator.liu.se";
    my $port = $arg{Port} || 4894;

    my $name =
      $arg{Name} ||
	$ENV{USER} ||
	  $ENV{LOGNAME} ||
	    ((getpwuid($<))[0]);

    $self->{refno} = 1;

    $self->{socket} = IO::Socket::INET->new(
					    PeerAddr => $host,
					    PeerPort => $port,
					   )
      or croak "Can't connect to remote server: $!\n";

    $self->{socket}->print("A".holl($name)."\n");

    my $tmp = $self->{socket}->getline;
    while (!$tmp || $tmp !~ /LysKOM/) {
	$tmp = $self->{socket}->getline;
    }

    bless $self, $class;
    return $self;
}

sub getres {
    my $self = shift;
    my @res;

    @res = $self->getres_sub;
    while ($res[0] =~ m/^:/) {
	$self->handle_asynch(@res);
	@res = $self->getres_sub;
    }
    return @res;
}

sub getres_sub {
    my $self = shift;
    my ($f, $r);
    my @res;

    $r = $self->{socket}->getline;
    while ($r) {
	if ($r =~ m|^(\d+)H(.*)$|) { # Start of a hollerith string
	    my $tot_len = $1;
	    my $res;
	    $r = $2."\n";
	
	    $res = substr $r, 0, $tot_len,"";
	    while (length($res) < $tot_len) {
		$r = $self->{socket}->getline;
		debug($r);
		$res .= substr $r, 0, ($tot_len-length($res)),"";
	    }
	    push @res, $res;
	    if ($r eq "") {
		$r = $self->{socket}->getline;
	    }
	    $r =~ s/^ //;
	} else {
	    ($f, $r) = split " ", $r, 2;
	    push @res,$f;
	}
    }
    return @res;
}

sub send {
    my $s = shift;

    $s->{socket}->print(@_);
}

sub handle_asynch {
    my $self = shift;
    my @call = @_;

    #debug "Asynch: @call";
}

## Server calls

sub logout {
    my $self = shift;

    return $self->gen_call_boolean(1);
}

sub change_conference {
    my $self = shift;
    my $conference = shift;

    return $self->gen_call_boolean(2,$conference);
}

sub change_name {
    my $self = shift;
    my $conference = shift;
    my $new_name = shift;

    return $self->gen_call_boolean(3, $conference, holl($new_name));
}

sub change_what_i_am_doing {
    my $self = shift;
    my $what_am_i_doing = shift;

    return $self->gen_call_boolean(4, holl($what_am_i_doing));
}

sub set_priv_bits {
    my $self = shift;
    my $person = shift;
    my %priv = (
		wheel => 0,
		admin => 0,
		statistic => 0,
		create_pers => 0,
		create_conf => 0,
		change_name => 0
	       );
    my %arg = @_;

    foreach (keys %arg) {
	$priv{$_} = $arg{$_}
    }

    my $pstring = join "", map {$_?"1":"0"}
      (
       $priv{wheel},
       $priv{admin},
       $priv{statistic},
       $priv{create_pers},
       $priv{create_conf},
       $priv{change_name},
       0, 0, 0, 0, 0, 0, 0, 0, 0, 0
      );

    return $self->gen_call_boolean(7, $person, $pstring);
}

sub set_passwd {
    my $self = shift;
    my %arg = @_;

    return $self->gen_call_boolean(8,
				   $arg{person},
				   holl($arg{old_pwd}),
				   holl($arg{new_pwd})
				  );
}

sub delete_conf {
    my $self = shift;
    my $conf = shift;

    return $self->gen_call_boolean(11, $conf);
}

sub sub_member {
    my $self = shift;
    my $conf_no = shift;
    my $pers_no = shift;

    return $self->gen_call_boolean(15, $conf_no, $pers_no);
}

sub set_presentation {
    my $self = shift;
    my $conf_no = shift;
    my $text_no = shift;

    return $self->gen_call_boolean(16, $conf_no, $text_no);
}

sub set_etc_motd {
    my $self = shift;
    my $conf_no = shift;
    my $text_no = shift;

    return $self->gen_call_boolean(17, $conf_no, $text_no);
}

sub set_supervisor {
    my $self = shift;
    my $conf_no = shift;
    my $admin = shift;

    return $self->gen_call_boolean(18, $conf_no, $admin);
}

sub set_permitted_submitters {
    my $self = shift;
    my $conf_no = shift;
    my $perm_sub = shift;

    return $self->gen_call_boolean(19, $conf_no, $perm_sub);
}

sub set_super_conf {
    my $self = shift;
    my $conf_no = shift;
    my $super_conf = shift;

    return $self->gen_call_boolean(20, $conf_no, $super_conf);
}

sub set_garb_nice {
    my $self = shift;
    my $conf_no = shift;
    my $nice = shift;

    return $self->gen_call_boolean(22, $conf_no, $nice);
}

sub get_text {
    my $self = shift;
    my %arg = @_;
    my @res;

    $arg{text} = 4711 unless $arg{text};
    $arg{start_char} = 0 unless $arg{start_char};
    $arg{end_char} = 2147483647 unless $arg{end_char};

    return $self->gen_call_scalar(25, $arg{text}, $arg{start_char}, $arg{end_char});
}

sub delete_text {
    my $self = shift;
    my $text = shift;

    return $self->gen_call_boolean(29, $text);
}

sub add_recipient {
    my $self = shift;
    my %arg = @_;

    if ($arg{type} eq "bcc") {
	$arg{type} = 15
    } elsif ($arg{type} eq "cc") {
	$arg{type} = 1
    } else {
	$arg{type} = 0
    }
    return $self->gen_call_boolean(30,$arg{text_no},$arg{conf_no},$arg{type});
}

sub sub_recipient {
    my $self = shift;
    my $textno = shift;
    my $confno = shift;

    return $self->gen_call_boolean(31, $textno, $confno);
}

sub add_comment {
    my $self = shift;
    my $textno = shift;
    my $commentto = shift;

    return $self->gen_call_boolean(32, $textno, $commentto);
}

sub get_time {
    my $self = shift;
    my @res;

    @res = $self->server_call(35);
    if ($self->is_error(@res)) {
	return undef;
    } else {
	shift @res;    # Remove return code
	return Net::Lyskom::Time->new_from_stream(\@res);
    }
}

sub set_unread {
    my $self = shift;
    my $conf_no = shift;
    my $no_of_unread = shift;

    return $self->gen_call_boolean(40, $conf_no, $no_of_unread);
}

sub set_motd_of_lyskom {
    my $self = shift;
    my $text_no = shift;

    return $self->gen_call_boolean(41, $text_no);
}

sub enable {
    my $self = shift;
    my $level = shift;

    return $self->gen_call_boolean(42, $level);
}

sub sync_kom {
    my $self = shift;

    return $self->gen_call_boolean(43);
}

sub shutdown_kom {
    my $self = shift;
    my $exit_val = shift;

    return $self->gen_call_boolean(44, $exit_val);
}

sub get_person_stat {
    my $self = shift;
    my $persno = shift;
    my @res;

    @res = $self->server_call(49, $persno);
    if ($self->is_error(@res)) {
	return 0;
    } else {
	shift @res;		# Remove return code
	return Net::Lyskom::Person->new_from_stream(\@res);
    }
}

sub get_unread_confs {
    my $self = shift;
    my $pers_no = shift;
    my @res;

    @res = $self->server_call(52, $pers_no);
    if ($self->is_error(@res)) {
	return ();
    } else {
	shift @res;    # Remove return code
	return parse_array_stream(sub{shift @{$_[0]}},\@res);
    }

}

sub send_message {
    my $self = shift;
    my $recipient = shift;
    my $message = shift;

    return $self->gen_call_boolean(53, $recipient, holl($message));
}

sub who_am_i {
    my $self = shift;

    return $self->gen_call_scalar(56);
}

sub get_last_text {
    my $self = shift;
    my $time = shift;

    my ($sec,$min,$hour,$mday,$mon,$year,$wday,$yday,$isdst) =
                                                localtime($time);
    return $self->gen_call_scalar(58,$sec,$min,$hour,$mday,$mon,$year,$wday,
				  $yday,($isdst?1:0));
}

sub find_next_text_no {
    my $self = shift;
    my $start = shift;

    return $self->gen_call_scalar(60, $start);
}

sub find_previous_text_no {
    my $self = shift;
    my $start = shift;

    return $self->gen_call_scalar(61, $start);
}

sub login {
    my $self = shift;
    my %arg = @_;

    return $self->gen_call_boolean(62,
				   $arg{pers_no},
				   holl($arg{password}),
				   ($arg{invisible})?1:0);
}

sub set_client_version {
    my $self = shift;
    my $client_name = shift;
    my $client_version = shift;

    return $self->gen_call_boolean(69, holl($client_name), holl($client_version));
}

sub get_client_name {
    my $self = shift;
    my $session = shift;

    return $self->gen_call_scalar(70, $session);
}

sub get_client_version {
    my $self = shift;
    my $session = shift;

    return $self->gen_call_scalar(71, $session);
}

sub get_version_info {
    my $self = shift;
    my @res;

    @res = $self->server_call(75);
    if ($self->is_error(@res)) {
	return ();
    } else {
	shift @res;    # Remove return code
	return @res[0..2];
    }
}

sub lookup_z_name {
    my $self = shift;
    my @res;
    my %arg = @_;

    @res = $self->server_call(76,
			      holl($arg{name}),
			      ($arg{want_pers}?1:0),
			      ($arg{want_conf}?1:0));
    if ($self->is_error(@res)) {
	return 0;
    } else {
	shift @res;		# Remove return code
	return parse_array_stream(sub{Net::Lyskom::ConfZInfo->new_from_stream(@_)},\@res)
    }
}

sub re_z_lookup {
    my $self = shift;
    my @res;
    my %arg = @_;

    @res = $self->server_call(74,
			      holl($arg{name}),
			      ($arg{want_pers}?1:0),
			      ($arg{want_conf}?1:0));
    if ($self->is_error(@res)) {
	return 0;
    } else {
	shift @res;		# Remove return code
	return parse_array_stream(sub{Net::Lyskom::ConfZInfo->new_from_stream(@_)},\@res)
    }
}

sub user_active {
    my $self = shift;

    return $self->gen_call_boolean(82);
}

sub who_is_on_dynamic {
  my $self = shift;
  my %arg = @_;
  my @res;

  $arg{want_visible} = 1 unless $arg{want_visible};
  $arg{want_invisible} = 0 unless $arg{want_invisible};
  $arg{active_last} = 0 unless $arg{active_last};

  @res = $self->server_call(83,
			    ($arg{want_visible}?1:0),
			    ($arg{want_invisible}?1:0),
			    $arg{active_last});
  if ($self->is_error(@res)) {
    return 0;
  } else {
    shift @res;		# Remove return code
    return parse_array_stream(sub{Net::Lyskom::DynamicSession->new_from_stream(@_)},\@res)
  }
}

sub get_static_session_info {
    my $self = shift;
    my $session = shift;
    my @res;

    @res = $self->server_call(84, $session);
    if ($self->is_error(@res)) {
	return undef;
    } else {
	shift @res;
	return Net::Lyskom::StaticSession->new_from_stream(\@res);
    }
}

sub create_text {
    my $self = shift;
    my %arg = @_;
    my @misc;
    my $misc_count = 0;
    my @aux;
    my $aux_count = 0;
    my @call;

    push @call, holl($arg{subject}."\n".$arg{body});
    if ($arg{recpt}) {
	foreach (@{$arg{recpt}}) {
	    push @misc, 0, $_;
	    $misc_count++;
	}
    }
    if ($arg{cc_recpt}) {
	foreach (@{$arg{cc_recpt}}) {
	    push @misc, 1, $_;
	    $misc_count++;
	}
    }
    if ($arg{bcc_recpt}) {
	foreach (@{$arg{bcc_recpt}}) {
	    push @misc, 15, $_;
	    $misc_count++;
	}
    }
    if ($arg{comm_to}) {
	foreach (@{$arg{comm_to}}) {
	    push @misc, 2, $_;
	    $misc_count++;
	}
    }
    if ($arg{footn_to}) {
	foreach (@{$arg{footn_to}}) {
	    push @misc, 4, $_;
	    $misc_count++;
	}
    }
    push @call, $misc_count, '{', @misc, '}';

    if ($arg{aux}) {
	foreach (@{$arg{aux}}) {
	    push @aux, $_->to_server;
	    $aux_count++;
	}
    }
    push @call, $aux_count, '{', @aux, '}';

    return $self->gen_call_scalar(86, @call);
}

sub get_text_stat {
    my $self = shift;
    my $textno = shift;
    my @res;

    @res = $self->server_call(90, $textno);
    if ($self->is_error(@res)) {
	return 0;
    } else {
	shift @res;		# Remove return code
	return Net::Lyskom::TextStat->new_from_stream($self, $textno, \@res);
    }
}

sub get_conf_stat {
    my $self = shift;
    my @confno = @_;
    my @res;
    my @tmp;

    @tmp = $self->server_call([map {[91,$_]} @confno]);
    foreach (@tmp) {
	if ($self->is_error(@{$_})) {
	    push @res,undef;
	} else {
	    shift @{$_};		# Remove return code
	    push @res, Net::Lyskom::Conference->new_from_stream($_);
	}
    }

    if (wantarray) {
	return @res;
    } else {
	return $res[0];
    }
}

sub modify_text_info {
    my $self = shift;
    my %arg = @_;
    my @aux;
    my $aux_count = 0;
    my @del;
    my $del_count = 0;
    my @call;

    push @call, 92;
    push @call, $arg{text};

    if ($arg{delete}) {
	foreach (@{$arg{delete}}) {
	    push @del, $_;
	    $del_count++;
	}
    }
    push @call, $del_count, '{', @del, '}';

    if ($arg{add}) {
	foreach (@{$arg{add}}) {
	    push @aux, $_->to_server;
	    $aux_count++;
	}
    }
    push @call, $aux_count, '{', @aux, '}';

    return $self->gen_call_boolean(@call);
}

sub butt_ugly_fast_reply {	# Less ugly re-implementation
    my $self = shift;
    my ($text, $data) = @_;

    $self->modify_text_info(
			    text => $text,
			    add => [
				    Net::Lyskom::AuxItem->new(
							      tag => "fast_reply",
							      data => $data
							     )
				   ]
			   );
}

sub query_predefined_aux_items {
    my $self = shift;
    my @res;

    @res = $self->server_call(96);
    if ($self->is_error(@res)) {
	return ();
    } else {
	shift @res;
	return parse_array_stream(sub{shift @{$_[0]}},\@res);
    }
}

sub get_membership {
    my $self = shift;
    my %arg = @_;
    my @res;

    $arg{first} = 0 unless $arg{first};
    $arg{no_of_confs} = 10 unless $arg{no_of_confs};
    $arg{want_read_texts} = 1 unless $arg{want_read_texts};

    @res = $self->server_call(99,
			      $arg{person},
			      $arg{first},
			      $arg{no_of_confs},
			      ($arg{want_read_texts})?1:0);
    if ($self->is_error(@res)) {
	return ();
    } else {
	shift @res;    # Remove return code
	return parse_array_stream(sub{Net::Lyskom::Membership->new_from_stream(@_)},\@res);
    }
}

sub local_to_global {
    my $self = shift;
    my %arg = @_;
    my @res;

    @res = $self->server_call(103, $arg{conf}, $arg{first}, $arg{number});
    if ($self->is_error(@res)) {
	return ();
    } else {
	shift @res;		# Remove return code
	return Net::Lyskom::TextMapping->new_from_stream(\@res);
    }
}

sub map_created_texts {
    my $self = shift;
    my %arg = @_;
    my @res;

    @res = $self->server_call(104, $arg{pers_no}, $arg{first}, $arg{number});
    if ($self->is_error(@res)) {
	return ();
    } else {
	shift @res;		# Remove return code
	return Net::Lyskom::TextMapping->new_from_stream(\@res);
    }
}

sub set_membership_type {
    my $self = shift;
    my %arg = @_;
    my $str = sprintf "%s%s%s00000",
      ($arg{invitation}?"1":"0"),
	($arg{passive}?"1":"0"),
	  ($arg{secret}?"1":"0");

    return $self->gen_call_boolean(102, $arg{pers}, $arg{conf}, $str);
}

sub get_members {
    my $self = shift;
    my %arg = @_;
    my @res;

    @res = $self->server_call(101, $arg{conf}, $arg{first}, $arg{count});
    if ($self->is_error(@res)) {
	return undef
    } else {
	shift @res;
	return parse_array_stream(sub{Net::Lyskom::Member->new_from_stream(@_)}, \@res)
    }
}

sub add_member {
    my $self = shift;
    my %arg = @_;

    my $type = sprintf "%s%s%s00000",
      ($arg{invitation}?"1":"0"),
	($arg{passive}?"1":"0"),
	  ($arg{secret}?"1":"0");
    return $self->gen_call_boolean(100, $arg{conf}, $arg{pers},
				   $arg{priority}, $arg{where}, $type);
}

sub query_read_texts {
    my $self = shift;
    my ($pers, $conf) = @_;

    my @res = $self->server_call(98,$pers,$conf);
    if ($self->is_error(@res)) {
	return undef
    } else {
	shift @res;
	return Net::Lyskom::Membership->new_from_stream(\@res)
    }
}

sub set_expire {
    my $self = shift;
    my ($conf, $expire) = @_;

    return $self->gen_call_boolean(97, $conf, $expire);
}

sub mark_text {
    my $self = shift;
    my ($text, $mark) = @_;

    return $self->gen_call_boolean(72, $text, $mark);
}

sub get_marks {
    my $self = shift;

    my @res = $self->server_call(23);
    if ($self->is_error(@res)) {
	return undef;
    } else {
	shift @res;
	return parse_array_stream(sub{[splice @{$_[0]},0,2]},\@res);
    }
}

sub unmark_text {
    my $self = shift;
    my $text = shift;

    return $self->gen_call_boolean(73, $text);
}

sub set_last_read {
    my $self = shift;
    my ($conf, $local_no) = @_;

    return $self->gen_call_boolean(77, $conf, $local_no)
}

sub set_conf_type {
    my $self = shift;
    my %arg = @_;

    die unless exists($arg{conf});
    $arg{rd_prot}         = 0 unless $arg{rd_prot};
    $arg{original}        = 0 unless $arg{original};
    $arg{secret}          = 0 unless $arg{secret};
    $arg{letterbox}       = 0 unless $arg{letterbox};
    $arg{allow_anonymous} = 0 unless $arg{allow_anonymous};
    $arg{forbid_secret}   = 0 unless $arg{forbid_secret};

    my $type = sprintf "%s%s%s%s%s%s000",
      ($arg{rd_prot}?"1":"0"),
	($arg{original}?"1":"0"),
	  ($arg{secret}?"1":"0"),
	    ($arg{letterbox}?"1":"0"),
	      ($arg{allow_anonymous}?"1":"0"),
		($arg{forbid_secret}?"1":"0");
    return $self->gen_call_boolean(21, $arg{conf}, $type);

}

sub mark_as_read {
    my $self = shift;
    my $conf = shift;
    my @texts = @_;

    return $self->gen_call_boolean(27, $conf, scalar @texts, '{', @texts, '}');
}

sub sub_comment {
    my $self = shift;
    my ($text, $comment) = @_;

    return $self->gen_call_boolean(33, $text, $comment);
}

sub add_footnote {
    my $self = shift;
    my ($text, $footnote_to) = @_;

    return $self->gen_call_boolean(37, $text, $footnote_to);
}

sub sub_footnote {
    my $self = shift;
    my ($text, $footnote_to) = @_;

    return $self->gen_call_boolean(38, $text, $footnote_to);
}

sub disconnect {
    my $self = shift;
    my $session = shift;

    return $self->gen_call_boolean(55, $session);
}

sub set_user_area {
    my $self = shift;
    my ($pers, $text) = @_;

    return $self->gen_call_boolean(57, $pers, $text);
}

sub get_uconf_stat {
    my $self = shift;
    my @confno = @_;
    my @res;
    my @tmp;

    @tmp = $self->server_call([map {[78,$_]} @confno]);
    foreach (@tmp) {
	if ($self->is_error(@{$_})) {
	    push @res,undef;
	} else {
	    shift @{$_};		# Remove return code
	    push @res, Net::Lyskom::Conference->new_from_ustream($_);
	}
    }

    if (wantarray) {
	return @res;
    } else {
	return $res[0];
    }
}

sub set_info {
    my $self = shift;
    my %arg = @_;

    $arg{conf_pres_conf} = 0 unless $arg{conf_pres_conf};
    $arg{pers_pres_conf} = 0 unless $arg{pers_pres_conf};
    $arg{motd_conf} = 0 unless $arg{motd_conf};
    $arg{kom_news_conf} = 0 unless $arg{kom_news_conf};
    $arg{motd_of_lyskom} = 0 unless $arg{motd_of_lyskom};

    return $self->gen_call_boolean(79, 0, # The zero must be there, see prot-a
				   $arg{conf_pres_conf},
				   $arg{pers_pres_conf},
				   $arg{motd_conf},
				   $arg{kom_news_conf},
				   $arg{motd_of_lyskom}
				  );
}

sub accept_async {
    my $self = shift;

    return $self->gen_call_boolean(80, scalar @_, '{', @_, '}');
}

sub query_async {
    my $self = shift;

    my @res = $self->server_call(81);
    if ($self->is_error(@res)) {
	return undef
    } else {
	return parse_array_stream(sub{shift @{$_[0]}},\@res);
    }
}

sub get_collate_table {
    my $self = shift;

    return $self->gen_call_scalar(85);
}

sub create_anonymous_text {
    my $self = shift;
    my %arg = @_;
    my @misc;
    my $misc_count = 0;
    my @aux;
    my $aux_count = 0;
    my @call;

    push @call, holl($arg{subject}."\n".$arg{body});
    if ($arg{recpt}) {
	foreach (@{$arg{recpt}}) {
	    push @misc, 0, $_;
	    $misc_count++;
	}
    }
    if ($arg{cc_recpt}) {
	foreach (@{$arg{cc_recpt}}) {
	    push @misc, 1, $_;
	    $misc_count++;
	}
    }
    if ($arg{bcc_recpt}) {
	foreach (@{$arg{bcc_recpt}}) {
	    push @misc, 15, $_;
	    $misc_count++;
	}
    }
    if ($arg{comm_to}) {
	foreach (@{$arg{comm_to}}) {
	    push @misc, 2, $_;
	    $misc_count++;
	}
    }
    if ($arg{footn_to}) {
	foreach (@{$arg{footn_to}}) {
	    push @misc, 4, $_;
	    $misc_count++;
	}
    }
    push @call, $misc_count, '{', @misc, '}';

    if ($arg{aux}) {
	foreach (@{$arg{aux}}) {
	    push @aux, $_->to_server;
	    $aux_count++;
	}
    }
    push @call, $aux_count, '{', @aux, '}';

    return $self->gen_call_scalar(87, @call);
}

sub create_conf {
    my $self = shift;
    my %arg = @_;

    croak "Tried to create conference with no name" unless $arg{name};
    $arg{rd_prot}         = 0 unless $arg{rd_prot};
    $arg{original}        = 0 unless $arg{original};
    $arg{secret}          = 0 unless $arg{secret};
    $arg{letterbox}       = 0 unless $arg{letterbox};
    $arg{allow_anonymous} = 0 unless $arg{allow_anonymous};
    $arg{forbid_secret}   = 0 unless $arg{forbid_secret};
    $arg{aux} = [] unless $arg{aux};

    my $type = sprintf "%s%s%s%s%s%s000",
      ($arg{rd_prot}?"1":"0"),
	($arg{original}?"1":"0"),
	  ($arg{secret}?"1":"0"),
	    ($arg{letterbox}?"1":"0"),
	      ($arg{allow_anonymous}?"1":"0"),
		($arg{forbid_secret}?"1":"0");

    return $self->gen_call_scalar(88,
				  $arg{name},
				  $type,
				  scalar @{$arg{aux}},
				  '{',
				  map {$_->to_server} @{$arg{aux}},
				  '}'
				 );
}

sub create_person {
    my $self = shift;
    my %arg = @_;

    croak "Tried to create person without name" unless $arg{name};
    croak "Tried to create person without password" unless $arg{password};
    $arg{unread_is_secret} = 0 unless $arg{unread_is_secret};
    my $type = sprintf "%s0000000", ($arg{unread_is_secret}?"1":"0");

    return $self->gen_call_scalar(89, $arg{name}, $arg{password}, $type,
				  scalar @{$arg{aux}},
				  '{',
				  map {$_->to_server} @{$arg{aux}},
				  '}'
				 );
}

sub modify_conf_info {
    my $self = shift;
    my %arg = @_;

    $arg{delete} = [] unless $arg{delete};
    $arg{add} = [] unless $arg{add};

    return undef unless $arg{conf};
    return $self->gen_call_boolean(93, $arg{conf},
				   scalar @{$arg{delete}},
				   '{',@{$arg{delete}},'}',
				   scalar @{$arg{add}},
				   '{', map {$_->to_server} @{$arg{add}},'}'
				   );
}

sub modify_system_info {
    my $self = shift;
    my %arg = @_;

    $arg{delete} = [] unless $arg{delete};
    $arg{add} = [] unless $arg{add};

    return $self->gen_call_boolean(95,
				   scalar @{$arg{delete}},
				   '{',@{$arg{delete}},'}',
				   scalar @{$arg{add}},
				   '{', map {$_->to_server} @{$arg{add}},'}'
				   );

}

sub set_keep_commented {
    my $self = shift;
    my ($conf, $keep) = @_;

    return $self->gen_call_boolean(105, $conf, $keep);
}

sub set_pers_flags {
    my $self = shift;
    my %arg = @_;
    my $type = sprintf "%s0000000", ($arg{unread_is_secret}?"1":"0");

    return $self->gen_call_boolean(106, $arg{person}, $type);
}

sub get_info {
    my $self = shift;

    my @res = $self->server_call(94);
    if ($self->is_error(@res)) {
	return undef;
    } else {
	return Net::Lyskom::Info->new_from_stream(\@res);
    }
}

# Return something true
1;

__END__