YTalk is in essence a multi-user chat program.  It works almost exactly like
the UNIX "talk" program and even communicates with the same talk daemon(s),
but YTalk allows for multiple connections.  As you experiment with or use
this software, please bear in mind that YTalk is not completely finished.
It performs every major function it is designed to perform, and as a whole
is much preferable to UNIX "talk".  However, there are several more features
currently being added (including an X Window System interface) which are not
yet complete.

Consider this file to be some simplified documentation, for I have not yet
written any comprehensive docs.

****************************************************************************
** To compile YTalk, find the correct entry in Makefile.  If none exists  **
** or it does not work, you may have to create a new one.                 **
****************************************************************************

usage:	ytalk username...

The "username" field may be formatted in several different ways:

	name		- some user on your machine
	name@host	- some user on a different machine
	name#tty	- some user on a particular terminal
	name#tty@host	- some user on a particular tty on a different machine
	name@host#tty	- same as "name#tty@host"
	name@host tty	- same as the other two

You can specify multiple user names on the command line, ie:

	ytalk george fred@hissun.edu marc@grumpy.cc

Other options:
	-o file		- log the talk session and append to file
	-s		- log talk side by side
	-w width	- fold logged talk lines at width
	-b bar		- column separator for option -s (default: " | ")
	-i prompt	- prompt for logged talkers lines
	-u prompt	- prompt for logged responders lines


For each user on the command line, YTalk will attempt to connect to the talk
daemon on the specified user's host and determine if that user has left an
invitation for you to call.  If not, YTalk leaves an invitation for him on
your machine and tells his talk daemon to send an announcement to his screen.
There is not yet a dedicated YTalk daemon, but there will be.  Right now,
YTalk is able to communicate with BOTH existing versions of UNIX talk
daemons.  For any particular host, YTalk will attempt to communicate with
a talk daemon, if the caller's host also supports that talk daemon.  If the
two hosts have no daemon in common, then UNIX "talk" will not function at
all, but a connection is possible through (and only through) YTalk.

Once a connection has been established between two users, they can chat back
and forth to their hearts' content.  The connection is terminated when one
of them hits control-C.

YTalk is perfectly compatible with UNIX "talk", and they can even converse
with each other without any problems.  However, many of the features of YTalk
can only operate when you are connected to a user who is also using YTalk.
For the rest of this document, it will be assumed that all connected users
are using YTalk, unless otherwise stated.

If you specified more than one user on the YTalk command line, then YTalk
will process and add each user to the conversation as they respond to your
invitation.  As each new user enters the conversation, the screen is further
subdivided into smaller and smaller windows, one for each connected user.
Right now, the number of connected users is limited by the number of lines
on your terminal (or window), for each connected user needs at least four
lines.  The absolute maximum number of connections is set to 20 right now,
but this can be changed.

As each new user is added to the conversation, YTalk will transmit information
about that user to all other connected YTalk users so that their screens will
also subdivide and incorporate the new user.  If the new user is using UNIX
"talk", then information about him will NOT be transmitted, for his screen
would be unable to accept multiple connections.  I have given brief thought
to allowing at least the output of UNIX "talk" users to be transmitted to
all connected YTalk users, but I have not written any code to do so.  Note
that even though UNIX "talk" cannot handle multiple connections, it is still
possible for YTalk to handle multiple UNIX "talk" connections.  For example,
george (using YTalk) could communicate with fred and joe (both using UNIX
"talk"), but fred and joe would be unaware of each other.  The best way to
understand the limitations that UNIX "talk" places on YTalk is to test
various connections between the two and see how things work.

It can be annoying when you are busily chatting with some user, and someone
else attempts to talk to you, sending that talk daemon message to your screen
and messing everything up.  Also, in any multi-talk environment it should
be easy to add new users to the conversation, and remove any particular users
from the conversation on the fly.  Hence, the ESC menu.  Whenever you are
using YTalk, you can hit the ESCAPE key to bring up a menu which at this
moment has three options:

	a) Add a new user to session
	d) Delete a user from session
	o) Output a user to a file
	x) Encrypt toggle (asks for passphrase)
	p) Encrypt toggle (use PGP)

By choosing option "a", you are given the opportunity to type the name of any
user you wish to include into the conversation.  Again, YTalk will accept an
invitation from that user if an invitation exists, or will leave an invitation
and ring the given user.

By choosing option "d", you can type the name of any connected user, and that
connection will be terminated.

By choosing option "o", you can type the name of any connected user and the
name of a file, and all further output from that user will be dumped to the
specified file.  The file, if it exists, will be OVERWRITTEN.  Note that
this is not the same as the command line -o option.

By choosing options "x" or "p" encryption is enabled.  If encryption is
already on, it is disabled.  "x" uses a private password for authentication.
All parties must enter the same password.  "p" uses PGP for authentication.
You should have PGPPATH set for the latter to work.

If encryption is enabled and another user joins, that user will
not be using encryption.  One of the participants must type ESC-x
or ESC-p to initiate encryption with the new user.

Misc notes:
-----------

When user A attempts to ytalk to user B, but user B is already
ytalking with user C, user A's YTalk program will realize that user
B is already using YTalk, and will communicate with user B's YTalk
program directly in order to initialize the conversation.  User B
will see a nice windowed message like:

	Do you wish to talk with user A?

and he will be prompted for a yes/no answer.  This, in my opinion, is much
preferable to blitting the announcement message and messing up user B's
screen.

This, I believe, is just about everything at this point in time.  Work is
already being done on the following ideas:

	1) an X-window interface,
	2) private conversations which do not get interrupted or transmitted
		to all YTalk connections,
	3) a way to send an aside to just one or a few of the connected users,
	4) a dedicated YTalk daemon.

If you have any ideas, comments, or questions, I'd be happy to hear from you
at:

	yenne@ccwf.cc.utexas.edu

For all matters regarding encryption:

	miron@extropia.wimsey.com
