                                ==Phrack Inc.==

                      Volume Two, Issue 24, File 7 of 13

               ()()()()()()()()()()()()()()()()()()()()()()()()
               ()                                            ()
               ()         Advanced Bitnet Procedures         ()
               ()                                            ()
               ()                     by                     ()
               ()                                            ()
               ()          VAXBusters International          ()
               ()                                            ()
               ()()()()()()()()()()()()()()()()()()()()()()()()


Greetings!  I have taken the time to write up a file about some of the more
complex operations on Bitnet.  I hope you enjoy it!                         :-)

- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

You can send multiple messages to one user@node under VAX/VMS & JNET by just
typing;

          $ SEND/REMOTE <host> <user>

This will collect messages from the terminal until an empty line or CTRL-Z is
entered.

Under Unix, the UREP package is popular to connect Unix boxes to Bitnet.  The
important user commands are as follows:


Messages
~~~~~~~~
netwrite user@host

Send one or more messages to the specified Bitnet user.  Netwrite reads
messages from it's standard input until an EOF is reached.  If called from a
terminal, netwrite will terminate on an empty line as well.

When you receive Bitnet messages on a Unix host, UREP looks for an executable
file named .exwrite in your home directory.  If it doesn't find such a file,
the message is simply spit on your terminal.  If .exwrite is present, UREP
executes this program (which can be a shell script) with five parameters:

        <To System> <To User> <From System> <From User> <Tty>

The <Tty> parameter tells the terminal to which UREP wanted to send the
message.  UREP then feeds the messages to .exwrite as standard input.  The
format of standard input is as follows:

        <count (1 byte)><message (<count> bytes)>

To display these messages you need to have a "C" program, since a shell script
is not capable of handling single bytes painlessly.  I included my exwrite.c at
the end of this file for a start.

Typically, .exwrite is used to log all incoming Bitnet messages.  You can of
course blow it up to send messages back to the sender when you're out to lunch,
etc. BTW, .exwrite is called with the user ID of the receiving user, so it's no
real security hole.


File Transfer
~~~~~~~~~~~~~
netcopy user@host [ options ]

Copy a file to the specified Bitnet user.  The most important option is
"name=<fname>.<ftype>", with which you can specify the file name to be used
at the recipient's machine.  More details are in the manual page.

When you receive Bitnet files on a Unix machine running UREP, they will
be placed in your home directory under the name ":<fname>.<ftype>".  These
files are in NETDATA format, and they have to be converted to ASCII text files
when you want to use them under Unix.  This can be done with the command;

netdata [ <input_file> [ <output_file> ] ]

When <input_file> is unspecified, standard input is used.  If <output_file> is
unspecified, standard output is used.


Bitnet Commands
~~~~~~~~~~~~~~~
Though Bitnet has no remote login capability, you can execute a (restricted)
set of commands on remote hosts.  These commands can be used to query node
status, lists of logged-on users, time and some other things.

This works as follows:

        JNET:   $ SEND/COMMAND <host> [ <command> ]
        UREP:   % netexec <host> [ <command> ]
        CMS:    SMSG <server> CMD <host> <command>

The <server> under CMS is the Bitnet control process.  In Europe, it is
normally called "EARN."  In the USA, it could be "BITNET" or maybe "RSCS."
You're on your own here.

The <host> is the Bitnet host name which you want to execute the <command>.
With JNET and UREP, you will be asked for multiple commands when you leave the
<command> field empty.  Again, input is terminated with EOF or an empty line.

I have found the following commands useful in daily life:

        CPQ N           Get a list of the users currently logged in at the
                        <host>.  This command is supposed to exist on every
                        Bitnet host, but some system managers like to restrict
                        it for security reasons.  On JNET and UREP hosts,
                        FINGER performs a similar, but more elaborate function.

        CPQ T           Make <host> tell you the current time at it's location.

        Q <otherhost>   Make <host> tell you what the next hop to <otherhost>
                        is.  This is useful when you're interested in the
                        network topology.

        Q <ohost> A     This makes <host> tell you what file is currently
                        active (being transmitted) for <ohost>.  This only
                        works for machines which are directly connected to
                        <host>.

        Q <ohost> Q     This makes <host> show you the queue of files currently
                        waiting for transmission to <ohost>.  This is useful
                        when you want to trace some file which you sent to the
                        network.

        Q SYS           This makes <host> tell you about the RSCS links it has.

Unfortunately, MVS-Hosts don't understand any of these commands, but simply
give an error message.  You can recognize these things by the string "HASP"
somewhere in the error message.

        Enjoy !

exwrite.c For Unix Hosts Running UREP
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

<-- cut here -->
/* exwrite.c - formatter for UREP rscs messages                         */

include <stdio.h>
include <sysexits.h>
include <pwd.h>
include <ctype.h>

main(argc, argv)

        int             argc;
        char            *argv[];
       struct  passwd  *pw;
        char            fname[255];
        FILE            *term;
        FILE            *log;
        int             count;
        char            buf[1024];
        char            *from_user;
        char            *from_host;
        char            *to_user;
        char            *to_host;
        char            *to_tty;
        char            *home_dir = "/tmp";

        if (argc != 6)
                fprintf(stderr, "%s: Invalid arguments\n", argv[0]);
                exit(EX_USAGE);


        /* initialise variables                                         */
        to_host = argv[1];
        to_user = argv[2];
        from_host = argv[3];
        from_user = argv[4];
        to_tty = argv[5];

        /* convert the receiving user to lowercase.  Under Unix, all    *
         * user names normally are lower case, and we need a valid      *
         * user name to determine the home directory                    */
        for (; *to_user; to_user++)
                *to_user = tolower(*to_user);
        to_user = argv[2];

        /* get the home directory of the receiving user                 */
        if (pw = getpwnam(to_user))
                home_dir = pw->pw_dir;

        /* open the terminal, exit if the open fails                    */
        sprintf(fname, "/dev/%s", to_tty);
        if (!(term = fopen(fname, "w")))
                exit(EX_OSERR);

        /* open the rscs log file                                       */
        sprintf(fname, "%s/.rscslog", home_dir);
        log = fopen(fname, "a");

        /* if the message is not coming from the relay, write the       *
         * sending user and host name to the specified terminal         */
        if (strcmp(from_user, "RELAY"))
                fprintf(term, "From %s@%s:\r\n", from_user, from_host);

        /* read in the RSCS messages and send them to the terminal      *
         * and to the logfile if it has been opened.                    *
         * In the log file, all lines are preceded by the sending user  *
         * and host name.                                               */
        while ((count = getchar()) != EOF)
                if ((count = fread(buf, 1, count, stdin)) > 0)
                        fwrite(buf, 1, count, term);
                        fprintf(term, "\r\n");
                        if (log)
                                fprintf(log, "%s@%s: ", from_user, from_host);
                                fwrite(buf, 1, count, log);
                                fprintf(log, "\n");




        exit(EX_OK);
_______________________________________________________________________________
