Programmer 7500/MAX_PROGRAMMERS.iso/PASCAL/ECO30603.ZIP/ECO30603.LZH/ECOLIBII/ECO_NOVL.PAS

Pascal/Delphi Source File | 1992-12-11 | 53.8 KB | 2,122 lines

unit eco_novl;

interface
uses
  dos

  ;



type
  integer = word;


const
  months : array [1..12] of string[3] = (
    'Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun',
    'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec'
  );
  hexdigits : array[0..15] of char = '0123456789ABCDEF';


var
  { as programmer first call getserverinfo. }
  serverinfo : record
    returnlength                  :              integer;
    server                        : array[1..48] of byte;
    netwarevers                   :                 byte;
    netwaresubv                   :                 byte;
    connectionmax                 :  array[1..2] of byte;
    connectionuse                 :  array[1..2] of byte;
    maxconvol                     :  array[1..2] of byte;
    os_revision                   :                 byte;
    sft_level                     :                 byte;
    tts_level                     :                 byte;
    peak_used                     :  array[1..2] of byte;
    accounting_version            :                 byte;
    vap_version                   :                 byte;
    queuing_version               :                 byte;
    print_server_version          :                 byte;
    virtual_console_version       :                 byte;
    security_restrictions_version :                 byte;
    internetwork_version_version  :                 byte;
    undefined                     : array[1..60] of byte;
    peak_connections_used         :              integer;
    connections_max               :              integer;
    connections_in_use            :              integer;
    max_connected_volumes         :              integer;
    name                          :               string;
  end;



  procedure getconnectioninfo(
    var logicalstationno : integer;
    var name, hex_id      :  string;
    var conntype         : integer;
    var datetime         :  string;
    var error            : integer
  );
  { returns username and login date/time when you supply the station number. }

  procedure clear_connection(
    connection_number : integer; var error : integer
  );
  { kicks the workstation off the server}

  procedure gethexid(var userid, hexid: string; var error: integer);
  { returns the novell hexid of an username when you supply the username. }

  procedure getserverinfo;
  { returns various info of the default server }

  procedure getuser(
    var _station: integer; var _username: string; var error:integer
  );
  { returns logged-in station username when you supply the station number. }

  procedure getnode(var hex_addr: string; var error: integer);
  { returns your physical network node in hex. }

  procedure getstation(var _station: integer; var error: integer);
  { returns the station number of your workstation }

  procedure getservername(var servername : string; var error : integer);
  { returns the name of the current server }

  procedure send_message_to_username(
    username, message: string; var error: integer
  );
  { sends a novell message to the userid's workstation }

  procedure send_message_to_station(
    station: integer; message: string; var error: integer
  );
  { sends a message to the workstation station # }

  procedure get_volume_name(
    var volume_name: string; volume_number: integer; var error: integer
  );
  { gets the volume name from novell network drive }
  { example:  sys    note: default drive must be a }
  { network drive.                                 }

  procedure get_realname(
    var userid: string; var realname: string; var error: integer
  );
  { you supply the userid, and it returns the realname as stored by syscon. }
  { example:  userid=mbramwel   realname=mark bramwell }

  procedure get_broadcast_mode(var bmode: integer);
  procedure set_broadcast_mode(bmode: integer);
  procedure get_broadcast_message(var bmessage: string; var error: integer);

  procedure get_server_datetime(
    var _year, _month, _day, _hour, _min, _sec, _dow: integer
  );
  { pulls from the server the date, time and day of week }

  procedure set_date_from_server;
  { pulls the date from the server and updates the workstation's clock }

  procedure set_time_from_server;
  { pulls the time from the server and updates the workstation's clock }

  procedure get_server_version(var _version : string);
  procedure open_message_pipe(var _connection, error: integer);
  procedure close_message_pipe(var _connection, error: integer);
  procedure check_message_pipe(var _connection, error: integer);

  procedure send_personal_message(
    var _connection : integer; var _message : string; var error : integer
  );

  procedure get_personal_message(
    var _connection : integer; var _message : string; var error : integer
  );

  procedure get_drive_connection_id(var drive_number, server_number : integer);
  { pass the drive number - it returns the server number if a network volume }

  procedure get_file_server_name(
    var server_number: integer; var server_name: string
  );

  procedure get_directory_path(
    var handle: integer; var pathname: string; var error: integer
  );

  procedure get_drive_handle_id(var drive_number, handle_number: integer);

  procedure set_preferred_connection_id(server_num: integer);
  procedure get_preferred_connection_id(var server_num: integer);
  procedure set_primary_connection_id(server_num: integer);
  procedure get_primary_connection_id(var server_num: integer);
  procedure get_default_connection_id(var server_num: integer);

  procedure get_internet_address(
    station : integer;
    var net_number, node_addr, socket_number : string;
    var error : integer
  );

  procedure login_to_file_server(
    obj_type: integer; _name, _password: string; var error: integer
  );

  procedure logout;
  procedure logout_from_file_server(var id: integer);
  procedure down_file_server(flag: integer; var error: integer);
  procedure detach_from_file_server(var id, error: integer);
  procedure disable_file_server_login(var error: integer);
  procedure enable_file_server_login(var error: integer);

  procedure alloc_permanent_directory_handle(
    var _dir_handle       : integer;
    var _drive_letter     :  string;
    var _dir_path_name    :  string;
    var _new_dir_handle   : integer;
    var _effective_rights :    byte;
    var _error            : integer
  );

  procedure map(var drive_spec: string; var _rights: byte; var _error: integer);

  procedure scan_object(
    var last_object        : longint;
    var search_object_type : integer;
    var search_object      :  string;
    var replyid            : longint;
    var replytype          : integer;
    var replyname          :  string;
    var replyflag          : integer;
    var replysecurity      :    byte;
    var replyproperties    : integer;
    var error              : integer
  );

  procedure verify_object_password(
    var object_type:integer; var object_name, password : string;
    var error : integer
  );


  { file locking routines }

  procedure log_file(
    lock_directive:integer; log_filename: string;
    log_timeout:integer; var error:integer
  );

  procedure clear_file_set;
  procedure lock_file_set(lock_timeout:integer; var error:integer);
  procedure release_file_set;
  procedure release_file(log_filename: string; var error:integer);
  procedure clear_file(log_filename: string; var error:integer);



  procedure open_semaphore(
    _name           :   string;
    _initial_value  : shortint;
    var _open_count :  integer;
    var _handle     :  longint;
    var error       :  integer
  );

  procedure close_semaphore(var _handle:longint; var error:integer);
  procedure examine_semaphore(
    var _handle:longint; var _value:shortint; var _count, error:integer
  );
  procedure signal_semaphore(var _handle:longint; var error:integer);
  procedure wait_on_semaphore(
    var _handle:longint; _timeout:integer; var error:integer
  );













implementation









const
  zero = '0';


var
  error : word; { return code for all functions }




  {
    pulls volume names from default server.  use set_preferred_connection_id
    to set the default server.
    errors:  0=ok, 1=no volume assigned  98h= # out of range
  }
  procedure get_volume_name;
  var
    pcregs        : registers;
    count, count1  : integer;

    requestbuffer : record
      len         : integer;
      func        :    byte;
      vol_num     :    byte;
    end;

    replybuffer : record
      len         : integer;
      vol_length  : byte;
      name        : array[1..16] of byte;
    end;

  begin
    with pcregs do begin
      ah := $e2;
      ds := seg(requestbuffer);
      si := ofs(requestbuffer);
      es := seg(replybuffer);
      di := ofs(replybuffer);
    end;
    with requestbuffer do begin
      len  := 2;
      func := 6;
      vol_num := volume_number;  {passed from calling program}
    end;
    with replybuffer do begin
      len :=  17;
      vol_length := 0;
      for count := 1 to 16 do name[count] := $00;
    end;
    msdos(pcregs);
    volume_name := '';
    if replybuffer.vol_length > 0 then
      for count := 1 to replybuffer.vol_length do
        volume_name := volume_name + chr(replybuffer.name[count]);
    error := pcregs.al;
  end;



  procedure verify_object_password;
  {
    for netware 3.xx remember to have previously (eg in the autoexec file )
    set allow unencrypted passwords = on
    on the console, otherwise this call always fails !
    note that intruder lockout status is affected by this call !
    netware security isn't that stupid....
    passwords appear to need to be converted to upper case

    error      apparent meaning as far as i can work out....

      0            verification of object_name/password combination
      197          account disabled due to intrusion lockout
      214          unencrypted password calls not allowed on this v3+ server
      252          no such object_name on this server
      255          failure to verify object_name/password combination
  }
  var
    regs : registers;

    request_buffer : record
      buffer_length   :               integer;
      dosfn           :                  byte;
      obj_type        :   array[1..2] of byte;
      obj_name_length :                  byte;
      obj_name        :  array[1..47] of byte;
      password_length :                  byte;
      obj_password    : array[1..127] of byte;
    end;

    reply_buffer : record
      buffer_length : integer;
    end;

    count : integer;

  begin
    with request_buffer do begin
      buffer_length := 179;
      dosfn := $3f;
      obj_type[1] := 0;
      obj_type[2] := object_type;
      obj_name_length := 47;
      for count := 1 to 47 do obj_name[count] := $00;
      for count := 1 to length(object_name) do
        obj_name[count] := ord(object_name[count]);
      password_length := length(password);
      for count := 1 to 127 do obj_password[count] := $00;
      if password_length > 0 then for count := 1 to password_length do
        obj_password[count] := ord(upcase(password[count]));
    end;
    with reply_buffer do buffer_length := 0;
    with regs do begin
      ah := $e3;
      ds := seg(request_buffer);
      si := ofs(request_buffer);
      es := seg(reply_buffer);
      di := ofs(reply_buffer);
    end;
    msdos(regs);
    error := regs.al;
  end; { verify_object_password }



  procedure scan_object;
  var
    regs : registers;

    request_buffer : record
      buffer_length :              integer;
      dosfn         :                 byte;
      last_seen     :              longint;
      search_type   :  array[1..2] of byte;
      name_length   :                 byte;
      search_name   : array[1..47] of byte;
    end;

    reply_buffer : record
      buffer_length :              integer;
      object_id     :              longint;
      object_type   :  array[1..2] of byte;
      object_name   : array[1..48] of byte;
      object_flag   :                 byte;
      security      :                 byte;
      properties    :                 byte;
    end;

    count : integer;

  begin
    with request_buffer do begin
      buffer_length := 55;
      dosfn := $37;
      last_seen := last_object;
      if search_object_type = -1 then { -1 = wildcard } begin
        search_type[1] := $ff;
        search_type[2] := $ff;
      end else begin
        search_type[1] := 0;
        search_type[2] := search_object_type;
      end;
      name_length := length(search_object);
      for count := 1 to 47 do search_name[count] := $00;
      if name_length > 0 then for count := 1 to name_length do
        search_name[count] := ord(upcase(search_object[count]));
    end;
    with reply_buffer do begin
      buffer_length := 57;
      object_id := 0;
      object_type[1] := 0;
      object_type[2] := 0;
      for count := 1 to 48 do object_name[count] := $00;
      object_flag := 0;
      security := 0;
      properties := 0;
    end;
    with regs do begin
      ah := $e3;
      ds := seg(request_buffer);
      si := ofs(request_buffer);
      es := seg(reply_buffer);
      di := ofs(reply_buffer);
    end;
    msdos(regs);
    error := regs.al;
    with reply_buffer do begin
      replyflag := object_flag;
      replyproperties := properties;
      replysecurity := security;
      replytype := object_type[2];
      replyid := object_id;
    end;
    count := 1;
    replyname := '';
    while (count <= 48)  and (reply_buffer.object_name[count] <> 0) do begin
      replyname := replyname + chr(reply_buffer.object_name[count]);
      count := count + 1;
    end { while };
  end;



  procedure alloc_permanent_directory_handle;
  var
    regs : registers;

    request_buffer : record
      buffer_length   : integer;
      dosfn           : byte;
      dir_handle      : byte;
      drive_letter    : byte;
      dir_path_length : byte;
      dir_path_name   : packed array[1..255] of byte;
    end;

    reply_buffer : record
      buffer_length    : integer;
      new_dir_handle   :    byte;
      effective_rights :    byte;
    end;

    count : integer;

  begin
    with request_buffer do begin
      buffer_length := 259;
      dosfn := $12;
      dir_handle := _dir_handle;
      drive_letter := ord(upcase(_drive_letter[1]));
      dir_path_length := length(_dir_path_name);
      for count := 1 to 255 do dir_path_name[count] := $0;
      if dir_path_length > 0 then for count := 1 to dir_path_length do
      dir_path_name[count] := ord(upcase(_dir_path_name[count]));
    end;
    with reply_buffer do begin
      buffer_length := 2;
      new_dir_handle := 0;
      effective_rights := 0;
    end;
    with regs do begin
      ah := $e2;
      ds := seg(request_buffer);
      si := ofs(request_buffer);
      es := seg(reply_buffer);
      di := ofs(reply_buffer);
    end;
    msdos(regs);
    _error := regs.al;
    _effective_rights := $0;
    _new_dir_handle := $0;
    if _error = 0 then begin
      _effective_rights := reply_buffer.effective_rights;
      _new_dir_handle := reply_buffer.new_dir_handle;
    end;
  end;




  procedure map;
  var
    dir_handle   : integer;
    path_name    :  string;
    rights       :    byte;
    drive_number : integer;
    drive_letter :  string;
    new_handle   : integer;
    error        : integer;

  begin
    {first thing is we strip leading and trailing blanks}
    while drive_spec[1]=' ' do
      drive_spec := copy(drive_spec, 2, length(drive_spec));
    while drive_spec[length(drive_spec)]=' ' do
      drive_spec := copy(drive_spec, 1, length(drive_spec)-1);
    drive_number := ord(upcase(drive_spec[1]))-65;
    drive_letter := upcase(drive_spec[1]);
    path_name := copy(drive_spec, 4, length(drive_spec));
    get_drive_handle_id(drive_number, dir_handle);
    alloc_permanent_directory_handle(
      dir_handle, drive_letter, path_name, new_handle, rights, error
    );
    _error := error;
    _rights := rights;
  end;




  procedure down_file_server;
  var
    regs : registers;

    request_buffer : record
      buffer_length : integer;
      dosfn         :    byte;
      down_flag     :    byte;
    end;

    reply_buffer : record
      buffer_length : integer;
    end;

  begin
    with request_buffer do begin
      buffer_length := 2;
      dosfn := $d3;
      down_flag := flag;
    end;
    reply_buffer.buffer_length := 0;
    with regs do begin
      ah := $e3;
      ds := seg(request_buffer);
      si := ofs(request_buffer);
      es := seg(reply_buffer);
      di := ofs(reply_buffer);
    end;
    msdos(regs);
    error := regs.al;
  end;




  procedure set_preferred_connection_id;
  var regs : registers;
  begin
    regs.ah := $f0;
    regs.al := $00;
    regs.dl := server_num;
    msdos(regs);
  end;




  procedure set_primary_connection_id;
  var regs : registers;
  begin
    regs.ah := $f0;
    regs.al := $04;
    regs.dl := server_num;
    msdos(regs);
  end;




  procedure get_primary_connection_id;
  var regs : registers;
  begin
    regs.ah := $f0;
    regs.al := $05;
    msdos(regs);
    server_num := regs.al;
  end;




  procedure get_default_connection_id;
  var regs : registers;
  begin
    regs.ah := $f0;
    regs.al := $02;
    msdos(regs);
    server_num := regs.al;
  end;




  procedure get_preferred_connection_id;
  var regs : registers;
  begin
    regs.ah := $f0;
    regs.al := $02;
    msdos(regs);
    server_num := regs.al;
  end;




  procedure get_drive_connection_id;
  var
    regs        :            registers;
    drive_table : array[1..32] of byte;
    count       :              integer;
    p           :                ^byte;

  begin
    regs.ah := $ef;
    regs.al := $02;
    msdos(regs);
    p := ptr(regs.es, regs.si);
    move(p^, drive_table, 32);
    if ((drive_number < 0) or (drive_number > 32))  then drive_number := 1;
    server_number := drive_table[drive_number];
  end;




  procedure get_drive_handle_id;
  var
    regs        :            registers;
    drive_table : array[1..32] of byte;
    count       :              integer;
    p           :                ^byte;

  begin
    regs.ah := $ef;
    regs.al := $00;
    msdos(regs);
    p := ptr(regs.es, regs.si);
    move(p^, drive_table, 32);
    if ((drive_number < 0) or (drive_number > 32))  then drive_number := 1;
    handle_number := drive_table[drive_number];
  end;




  procedure get_file_server_name;
  var
    regs       :              registers;
    name_table : array[1..8*48] of byte;
    server     :  array[1..8] of string;
    count      :                integer;
    count2     :                integer;
    p          :                  ^byte;
    no_more    :                integer;

  begin
    regs.ah := $EF; regs.al := $04; msdos(regs);
    no_more := 0; p := ptr(regs.es, regs.si);
    move(p^, name_table, 8*48);
    for count := 1 to 8 do server[count] := '';
    for count := 0 to 7 do begin
      no_more := 0;
      for count2 := (count*48)+1 to (count*48)+48 do
        if name_table[count2] <> $00 then begin
          if no_more=0 then server[count+1] := server[count+1] +
            chr(name_table[count2]);
        end else no_more := 1; {scan until 00h is found}
    end;
    if ((server_number<1) or (server_number>8)) then server_number := 1;
    server_name := server[server_number];
  end;




  procedure disable_file_server_login;
  var
    regs : registers;

    request_buffer : record
      buffer_length : integer;
      dosfn         :    byte
    end;

    reply_buffer : record
      buffer_length : integer;
    end;

  begin
    with regs do begin
      ah := $e3;
      ds := seg(request_buffer);
      si := ofs(request_buffer);
      es := seg(reply_buffer);
      di := ofs(reply_buffer);
    end;
    with request_buffer do begin
      buffer_length := 1;
      dosfn := $cb;
    end;
    reply_buffer.buffer_length := 0;
    msdos(regs);
    error := regs.al;
  end;




  procedure enable_file_server_login;
  var
    regs : registers;

    request_buffer : record
      buffer_length : integer;
      dosfn         :    byte
    end;

    reply_buffer : record
      buffer_length : integer;
    end;

  begin
    with regs do begin
      ah := $e3;
      ds := seg(request_buffer);
      si := ofs(request_buffer);
      es := seg(reply_buffer);
      di := ofs(reply_buffer);
    end;
    with request_buffer do begin
      buffer_length := 1;
      dosfn := $cc;
    end;
    reply_buffer.buffer_length := 0;
    msdos(regs);
    error := regs.al;
  end;




  procedure get_directory_path;
  var
    regs  : registers;
    count :   integer;

    request_buffer : record
      len        : integer;
      dosfn      :    byte;
      dir_handle :    byte;
    end;

    reply_buffer : record
      len       :               integer;
      path_len  :                  byte;
      path_name : array[1..255] of byte;
    end;

  begin
    with regs do begin
      ah := $e2;
      ds := seg(request_buffer);
      si := ofs(request_buffer);
      es := seg(reply_buffer);
      di := ofs(reply_buffer);
    end;
    with request_buffer do begin
      len := 2;
      dosfn := $01;
      dir_handle := handle;
    end;
    with reply_buffer do begin
      len := 256;
      path_len := 0;
      for count := 1 to 255 do path_name[count] := $00;
    end;
    msdos(regs);
    error := regs.al;
    pathname := '';
    if reply_buffer.path_len > 0 then for count := 1 to reply_buffer.path_len do
      pathname := pathname + chr(reply_buffer.path_name[count]);
  end;




  procedure detach_from_file_server;
  var regs : registers;
  begin
    regs.ah := $f1;
    regs.al := $01;
    regs.dl := id;
    msdos(regs);
    error := regs.al;
  end;




  procedure getstation;
  var
    pcregs : registers;

  begin
    pcregs.ah := $dc;
    msdos( pcregs );
    _station := pcregs.al;
    error := 0;
  end;




  procedure gethexid;
  var
    reg           : registers;
    i, x           :   integer;
    hex_id        :    string;

    requestbuffer : record
      len      :              integer;
      func     :                 byte;
      conntype :  array[1..2] of byte;
      name_len :                 byte;
      name     : array[1..47] of char;
    end;

    replybuffer : record
      len       :              integer;
      uniqueid1 :  array[1..2] of byte;
      uniqueid2 :  array[1..2] of byte;
      conntype  :                 word;
      name      : array[1..48] of byte;
    end;

  begin
    reg.ah := $e3;
    requestbuffer.func := $35;
    reg.ds := seg(requestbuffer);
    reg.si := ofs(requestbuffer);
    reg.es := seg(replybuffer);
    reg.di := ofs(replybuffer);
    requestbuffer.len := 52;
    replybuffer.len := 55;
    requestbuffer.name_len := length(userid);
    for i := 1 to length(userid) do requestbuffer.name[i] := userid[i];
    requestbuffer.conntype[2] := $1;
    requestbuffer.conntype[1] := $0;
    replybuffer.conntype := 1;
    msdos(reg);
    error := reg.al;   {
    if error = $96 then writeln('server out of memory');
    if error = $ef then writeln('invalid name');
    if error = $f0 then writeln('wildcard not allowed');
    if error = $fc then writeln('no such object *', userid, '*');
    if error = $fe then writeln('server bindery locked');
    if error = $ff then writeln('bindery failure'); }
    hex_id := '';
    if error = 0 then begin
      hex_id := hexdigits[replybuffer.uniqueid1[1] shr 4];
      hex_id := hex_id + hexdigits[replybuffer.uniqueid1[1] and $0f];
      hex_id := hex_id + hexdigits[replybuffer.uniqueid1[2] shr 4];
      hex_id := hex_id + hexdigits[replybuffer.uniqueid1[2] and $0f];
      hex_id := hex_id + hexdigits[replybuffer.uniqueid2[1] shr 4];
      hex_id := hex_id + hexdigits[replybuffer.uniqueid2[1] and $0f];
      hex_id := hex_id + hexdigits[replybuffer.uniqueid2[2] shr 4];
      hex_id := hex_id + hexdigits[replybuffer.uniqueid2[2] and $0f];
      { now we chop off leading zeros }
      while hex_id[1] = '0' do hex_id := copy(hex_id, 2, length(hex_id));
    end;
    hexid := hex_id;
  end;




  procedure getconnectioninfo;
  var
    reg            : registers;
    i, x            : integer;
    requestbuffer : record
      packetlength : integer;
      functionval  : byte;
      connectionno : byte;
    end;
    replybuffer : record
      returnlength :              integer;
      uniqueid1    :  array[1..2] of byte;
      uniqueid2    :  array[1..2] of byte;
      conntype     :  array[1..2] of byte;
      objectname   : array[1..48] of byte;
      logintime    :  array[1..8] of byte;
    end;
    month          : string[3];
    year,
    day,
    hour,
    minute         : string[2];

  begin
    with requestbuffer do begin
      packetlength := 2;
      functionval := 22;  { 22 = get station info }
      connectionno := logicalstationno;
    end;
    replybuffer.returnlength := 62;
    with reg do begin
      ah := $e3;
      ds := seg(requestbuffer);
      si := ofs(requestbuffer);
      es := seg(replybuffer);
      di := ofs(replybuffer);
    end;
    msdos(reg);
    name := '';
    hex_id := '';
    conntype := 0;
    datetime := '';
    if reg.al = 0 then begin
      with replybuffer do begin
        i := 1;
        while (i <= 48)  and (objectname[i] <> 0) do begin
          name[i] := chr(objectname[i]);
          inc(i);
        end { while };
        name[0] := chr(i - 1);
        if name<>'' then begin
          str(logintime[1]:2, year);
          month := months[logintime[2]];
          str(logintime[3]:2, day);
          str(logintime[4]:2, hour);
          str(logintime[5]:2, minute);
          if day[1] = ' ' then day[1] := '0';
          if hour[1] = ' ' then hour[1] := '0';
          if minute[1] = ' ' then minute[1] := '0';
          datetime := day + ' ' + month + ' ' + year +
            '  ' + hour + ':' + minute;
        end;
      end { with };
    end;
    error := reg.al;
    if name<>'' then begin
      hex_id := '';
      hex_id := hexdigits[replybuffer.uniqueid1[1] shr 4];
      hex_id := hex_id + hexdigits[replybuffer.uniqueid1[1] and $0f];
      hex_id := hex_id + hexdigits[replybuffer.uniqueid1[2] shr 4];
      hex_id := hex_id + hexdigits[replybuffer.uniqueid1[2] and $0f];
      hex_id := hex_id + hexdigits[replybuffer.uniqueid2[1] shr 4];
      hex_id := hex_id + hexdigits[replybuffer.uniqueid2[1] and $0f];
      hex_id := hex_id + hexdigits[replybuffer.uniqueid2[2] shr 4];
      hex_id := hex_id + hexdigits[replybuffer.uniqueid2[2] and $0f];
      conntype := replybuffer.conntype[2];
      { now we chop off leading zeros }
      while (hex_id[1]='0') and (length(hex_id) > 0) do
        hex_id := copy(hex_id, 2, length(hex_id));
    end;
  end { getconnectinfo };




  procedure login_to_file_server;
  var
    regs : registers;

    request_buffer : record
      b_length        :              integer;
      dosfn           :                 byte;
      o_type          :  array[1..2] of byte;
      name_length     :                 byte;
      obj_name        : array[1..47] of byte;
      password_length :                 byte;
      password        : array[1..27] of byte;
    end;

    reply_buffer : record
      r_length : integer;
    end;

    count : integer;

  begin
    with request_buffer do begin
      b_length := 79;
      dosfn := $14;
      o_type[1] := 0;
      o_type[2] := obj_type;
      for count := 1 to 47 do obj_name[count] := $0;
      for count := 1 to 27 do password[count] := $0;
      if length(_name) > 0 then for count := 1 to length(_name) do
        obj_name[count] := ord(upcase(_name[count]));
      if length(_password) > 0 then for count := 1 to length(_password) do
        password[count] := ord(upcase(_password[count]));
      {set to full length of field}
      name_length := 47;
      password_length := 27;
    end;
    with reply_buffer do begin
      r_length := 0;
    end;
    with regs do begin
      ah := $e3;
      ds := seg(request_buffer);
      si := ofs(request_buffer);
      es := seg(reply_buffer);
      di := ofs(reply_buffer);
    end;
    msdos(regs);
    error := regs.al
  end;




  procedure logout;
  {logout from all file servers}
  var regs : registers;
  begin
    regs.ah := $d7;
    msdos(regs);
  end;




  procedure logout_from_file_server;
  {logout from one file server}
  var regs : registers;
  begin
    regs.ah := $f1;
    regs.al := $02;
    regs.dl := id;
    msdos(regs);
  end;




  procedure send_message_to_username;
  var
    count1     :    byte;
    userid     :  string;
    stationid  : integer;
    ret_code   : integer;

  begin
    ret_code := 1;
    for count1 := 1 to length(username) do
      username[count1] := upcase(username[count1]); { convert to upper case }
    getserverinfo;
    for count1 := 1 to serverinfo.connections_max do begin
      stationid := count1;
      getuser( stationid, userid, error);
      if userid = username then begin
        ret_code := 0;
        send_message_to_station(stationid, message, error);
      end;
    end; { end of count }
    error := ret_code;
    { error = 0 if sent,  1 if userid not found }
  end; { end of procedure }




  procedure getserverinfo;
  var
    reg            : registers;
    requestbuffer : record
      packetlength : integer;
      functionval  :    byte;
    end;
    i              :   integer;

  begin
    with requestbuffer do begin
      packetlength := 1;
      functionval := 17;  { 17 = get server info }
    end;
    serverinfo.returnlength := 128;
    with reg do begin
      ah := $e3;
      ds := seg(requestbuffer);
      si := ofs(requestbuffer);
      es := seg(serverinfo);
      di := ofs(serverinfo);
    end;
    msdos(reg);
    with serverinfo do begin
      connections_max := connectionmax[1]*256 + connectionmax[2];
      connections_in_use := connectionuse[1]*256 + connectionuse[2];
      max_connected_volumes := maxconvol[1]*256 + maxconvol[2];
      peak_connections_used := peak_used[1]*256 + peak_used[2];
      name := '';
      i := 1;
      while ((server[i] <> 0) and (i<>48)) do begin
        name := name + chr(server[i]);
        inc(i);
      end;
    end;
  end;




  procedure getservername;
  { this routine returns the same as getserverinfo.  this routine   }
  { was kept to maintain compatibility with the older  novell unit. }
  begin
    getserverinfo;
    servername := serverinfo.name;
    error := 0;
  end;





  procedure send_message_to_station;
  var
    pcregs : registers;

    req_buffer : record
      buffer_len :              integer;
      dosfn      :                 byte;
      c_count    :                 byte;
      c_list     :                 byte;
      msg_length :                 byte;
      msg        : array[1..55] of byte;
    end;

    rep_buffer : record
      buffer_len : integer;
      c_count    :    byte;
      r_list     :    byte;
    end;

    count1 : integer;

  begin
    if length(message) > 55 then message := copy(message, 1, 55);
    with pcregs do begin
      ah := $e1;
      ds := seg(req_buffer);
      si := ofs(req_buffer);
      es := seg(rep_buffer);
      di := ofs(rep_buffer);
    end;
    with req_buffer do begin
      buffer_len := 59;
      dosfn := 00;
      c_count := 1;
      c_list := station;
      for count1 := 1 to 55 do msg[count1] := $00; { zero the buffer }
      msg_length := length(message); { message length }
      for count1 := 1 to length(message) do msg[count1] := ord(message[count1]);
    end;
    with rep_buffer do begin
      buffer_len := 2;
      c_count := 1;
      r_list := 0;
    end;
    msdos( pcregs );
    error := rep_buffer.r_list;
  end;






  procedure getuser;
  {this procedure provides a shorter method of obtaining just the userid.}
  var
    gu_hexid    :  string;
    gu_conntype : integer;
    gu_datetime :  string;

  begin
    getconnectioninfo(
      _station, _username, gu_hexid, gu_conntype, gu_datetime, error
    );
  end;





  procedure getnode;
  { get the physical station address }
  const
    hex_set : array[0..15] of char = '0123456789ABCDEF';

  var
    regs : registers;

  begin { getnode }
    {get the physical address from the network card}
    regs.ah := $ee;
    msdos(regs);
    hex_addr := '';
    hex_addr := hex_addr + hex_set[(regs.ch shr 4)];
    hex_addr := hex_addr + hex_set[(regs.ch and $0f)];
    hex_addr := hex_addr + hex_set[(regs.cl shr 4) ];
    hex_addr := hex_addr + hex_set[(regs.cl and $0f)];
    hex_addr := hex_addr + hex_set[(regs.bh shr 4)];
    hex_addr := hex_addr + hex_set[(regs.bh and $0f)];
    hex_addr := hex_addr + hex_set[(regs.bl shr 4)];
    hex_addr := hex_addr + hex_set[(regs.bl and $0f)];
    hex_addr := hex_addr + hex_set[(regs.ah shr 4)];
    hex_addr := hex_addr + hex_set[(regs.ah and $0f)];
    hex_addr := hex_addr + hex_set[(regs.al shr 4)];
    hex_addr := hex_addr + hex_set[(regs.al and $0f)];
    error := 0;
  end; { getnode }



  procedure get_internet_address;
  const
    hex_set : array[0..15] of char = '0123456789ABCDEF';

  var
    regs : registers;

    request_buffer : record
      length     : integer;
      dosfn      :    byte;
      connection :    byte;
    end;

    reply_buffer : record
      length  :             integer;
      network : array[1..4] of byte;
      node    : array[1..6] of byte;
      socket  : array[1..2] of byte;
    end;

    count          : integer;
    _node_addr     :  string;
    _socket_number :  string;
    _net_number    :  string;

  begin
    with regs do begin
      ah := $e3;
      ds := seg(request_buffer);
      si := ofs(request_buffer);
      es := seg(reply_buffer);
      di := ofs(reply_buffer);
    end;
    with request_buffer do begin
      length := 2;
      dosfn := $13;
      connection := station;
    end;
    with reply_buffer do begin
      length := 12;
      for count := 1 to 4 do network[count] := 0;
      for count := 1 to 6 do node[count] := 0;
      for count := 1 to 2 do socket[count] := 0;
    end;
    msdos(regs);
    error := regs.al;
    _net_number := '';
    _node_addr := '';
    _socket_number := '';
    if error = 0 then begin
      for count := 1 to 4 do begin
        _net_number := _net_number + hex_set[
          (reply_buffer.network[count] shr 4)
        ];
        _net_number := _net_number + hex_set[
          (reply_buffer.network[count] and $0f)
        ];
      end;
      for count := 1 to 6 do begin
        _node_addr := _node_addr + (hex_set[
          (reply_buffer.node[count] shr 4)
        ]);
        _node_addr := _node_addr + (hex_set[
          (reply_buffer.node[count] and $0f)
        ]);
      end;
      for count := 1 to 2 do begin
        _socket_number := _socket_number + (hex_set[
          (reply_buffer.socket[count] shr 4)
        ]);
       _socket_number := _socket_number + (hex_set[
          (reply_buffer.socket[count] and $0f)
        ]);
      end;
    end; {end of error=0}
    net_number := _net_number;
    node_addr := _node_addr;
    socket_number := _socket_number;
  end;





  procedure get_realname;
  var
    requestbuffer : record
      buffer_length : array[1..2] of byte;
      dosfn           :                 byte;
      object_type     :  array[1..2] of byte;
      object_length   :                 byte;
      object_name     : array[1..47] of byte;
      segment         :                 byte;
      property_length :                 byte;
      property_name   : array[1..14] of byte;
    end;

    replybuffer : record
      buffer_length  :   array[1..2] of byte;
      property_value : array[1..128] of byte;
      more_segments  :                  byte;
      property_flags :                  byte;
    end;

    count    :   integer;
    id       :    string;
    regs     : registers;
    fullname :    string;

  begin
    id := 'identification';
    with requestbuffer do begin
      buffer_length[2] := 0;
      buffer_length[1] := 69;
      dosfn  := $3d;
      object_type[1] := 0;
      object_type[2] := 01;
      segment := 1;
      object_length := 47;
      property_length := length(id);
      for count := 1 to 47 do object_name[count] := $0;
      for count := 1 to length(userid) do
        object_name[count] := ord(userid[count]);
      for count := 1 to 14 do property_name[count] := $0;
      for count := 1 to length(id) do property_name[count] := ord(id[count]);
    end;
    with replybuffer do begin
      buffer_length[1] := 130;
      buffer_length[2] := 0;
      for count := 1 to 128 do property_value[count] := $0;
      more_segments := 1;
      property_flags := 0;
    end;
    with regs do begin
      ah := $e3;
      ds := seg(requestbuffer);
      si := ofs(requestbuffer);
      es := seg(replybuffer);
      di := ofs(replybuffer);
    end;
    msdos(regs);
    error := regs.al;
    fullname := '';
    count := 1;
    repeat
      if replybuffer.property_value[count] <> 0 then
        fullname := fullname + chr(replybuffer.property_value[count]);
      inc(count);
    until ((count = 128) or (replybuffer.property_value[count] = 0));
    {if regs.al = $96 then writeln('server out of memory');
    if regs.al = $ec then writeln('no such segment');
    if regs.al = $f0 then writeln('wilcard not allowed');
    if regs.al = $f1 then writeln('invalid bindery security');
    if regs.al = $f9 then writeln('no property read priv');
    if regs.al = $fb then writeln('no such property');
    if regs.al = $fc then writeln('no such object');}
    if error=0 then realname := fullname else realname := '';
  end;





  procedure get_broadcast_mode;
  var regs : registers;
  begin
    regs.ah := $de;
    regs.dl := $04;
    msdos(regs);
    bmode := regs.al;
  end;



  procedure set_broadcast_mode;
  var regs : registers;
  begin
    if ((bmode > 3) or (bmode < 0)) then bmode := 0;
    regs.ah := $de;
    regs.dl := bmode;
    msdos(regs);
    bmode := regs.al;
  end;




  procedure get_broadcast_message;
  var
    regs : registers;

    requestbuffer : record
      bufferlength : array[1..2] of byte;
      dosfn        :                byte;
    end;

    replybuffer : record
      bufferlength  :  array[1..2] of byte;
      messagelength :                 byte;
      message       : array[1..58] of byte;
    end;

    count : integer;

  begin
    with requestbuffer do begin
       bufferlength[1] := 1;
       bufferlength[2] := 0;
       dosfn := 1;
    end;
    with replybuffer do begin
      bufferlength[1] := 59;
      bufferlength[2] := 0;
      messagelength := 0;
    end;
    for count := 1 to 58 do replybuffer.message[count] := $0;
    with regs do begin
      ah := $e1;
      ds := seg(requestbuffer);
      si := ofs(requestbuffer);
      es := seg(replybuffer);
      di := ofs(replybuffer);
    end;
    msdos(regs);
    error := regs.al;
    bmessage := '';
    count := 0;
    if replybuffer.messagelength > 58 then replybuffer.messagelength := 58;
    if replybuffer.messagelength > 0 then
      for count := 1 to replybuffer.messagelength do
        bmessage := bmessage + chr(replybuffer.message[count]);
        { error = 0 if no message,  1 if message was retreived }
    if length(bmessage) = 0 then error := 1 else error := 0;
  end;





  procedure get_server_datetime;
  var
    replybuffer : record
      year : byte;
      month : byte;
      day : byte;
      hour : byte;
      minute : byte;
      second : byte;
      dow : byte;
    end;
    regs : registers;

  begin
    with regs do begin
      ah := $e7;
      ds := seg(replybuffer);
      dx := ofs(replybuffer);
    end;
    msdos(regs);
    error := regs.al;
    _year := replybuffer.year;
    _month := replybuffer.month;
    _day := replybuffer.day;
    _hour := replybuffer.hour;
    _min := replybuffer.minute;
    _sec := replybuffer.second;
    _dow := replybuffer.dow;
  end;




  procedure set_date_from_server;
  var
    replybuffer : record
      year, month, day,
      hour, minute,
      second, dow  : byte;
    end;
    regs : registers;

  begin
    with regs do begin
      ah := $e7;
      ds := seg(replybuffer);
      dx := ofs(replybuffer);
    end;
    msdos(regs);
    setdate(replybuffer.year+1900, replybuffer.month, replybuffer.day);
  end;





  procedure set_time_from_server;
  var
    replybuffer : record
      year, month, day,
      hour, minute,
      second, dow  : byte;
    end;
    regs : registers;

  begin
    with regs do begin
      ah := $e7;
      ds := seg(replybuffer);
      dx := ofs(replybuffer);
    end;
    msdos(regs);
    settime(replybuffer.hour, replybuffer.minute, replybuffer.second, 0);
  end;





  procedure get_server_version;
  var
    regs : registers;
    count, x : integer;
    request_buffer : record
      buffer_length : integer;
      dosfn         :    byte;
    end;

    reply_buffer : record
      buffer_length :               integer;
      stuff         : array[1..512] of byte;
    end;

    strings : array[1..3] of string;

  begin
    with regs do begin
      ah := $e3;
      ds := seg(request_buffer);
      si := ofs(request_buffer);
      es := seg(reply_buffer);
      di := ofs(reply_buffer);
    end;
    with request_buffer do begin
      buffer_length := 1;
      dosfn := $c9;
    end;
    with reply_buffer do begin
      buffer_length := 512;
      for count := 1 to 512 do stuff[count] := $00;
    end;
    msdos(regs);
    for count := 1 to 3 do strings[count] := '';
    x := 1;
    with reply_buffer do begin
      for count := 1 to 256 do begin
        if stuff[count] <> $0 then begin
          if not(
            (stuff[count]=32) and (strings[x]='')
          ) then strings[x] := strings[x] + chr(stuff[count]);
        end;
        if stuff[count] = $0 then if x <> 3 then inc(x);
      end;
    end; { end of with }
    _version := strings[2];
  end;





  procedure open_message_pipe;
  var
    regs : registers;

    request_buffer : record
      buffer_length    : integer;
      dosfn            :    byte;
      connection_count :    byte;
      connection_list  :    byte;
    end;

    reply_buffer : record
      buffer_length    : integer;
      connection_count :    byte;
      result_list      :    byte;
    end;

  begin
    with regs do begin
      ah := $e1;
      ds := seg(request_buffer);
      si := ofs(request_buffer);
      es := seg(reply_buffer);
      di := ofs(reply_buffer);
    end;
    with request_buffer do begin
      buffer_length := 3;
      dosfn := $06;
      connection_count := $01;
      connection_list := _connection;
    end;
    with reply_buffer do begin
      buffer_length := 2;
      connection_count := 0;
      result_list := 0;
    end;
    msdos(regs);
    error := reply_buffer.result_list;
  end;




  procedure close_message_pipe;
  var
    regs : registers;

    request_buffer : record
      buffer_length    : integer;
      dosfn            :    byte;
      connection_count :    byte;
      connection_list  :    byte;
    end;

    reply_buffer : record
      buffer_length : integer;
      connection_count : byte;
      result_list : byte;
    end;

  begin
    with regs do begin
      ah := $e1;
      ds := seg(request_buffer);
      si := ofs(request_buffer);
      es := seg(reply_buffer);
      di := ofs(reply_buffer);
    end;
    with request_buffer do begin
      buffer_length := 3;
      dosfn := $07;
      connection_count := $01;
      connection_list := _connection;
    end;
    with reply_buffer do begin
      buffer_length := 2;
      connection_count := 0;
      result_list := 0;
    end;
    msdos(regs);
    error := reply_buffer.result_list;
  end;





  procedure check_message_pipe;
  var
    regs : registers;

    request_buffer : record
      buffer_length    : integer;
      dosfn            :    byte;
      connection_count :    byte;
      connection_list  :    byte;
    end;

    reply_buffer : record
      buffer_length    : integer;
      connection_count :    byte;
      result_list      :    byte;
    end;

  begin
    with regs do begin
      ah := $e1;
      ds := seg(request_buffer);
      si := ofs(request_buffer);
      es := seg(reply_buffer);
      di := ofs(reply_buffer);
    end;
    with request_buffer do begin
      buffer_length := 3;
      dosfn := $08;
      connection_count := $01;
      connection_list := _connection;
    end;
    with reply_buffer do begin
      buffer_length := 2;
      connection_count := 0;
      result_list := 0;
    end;
    msdos(regs);
    error := reply_buffer.result_list;
  end;






  procedure send_personal_message;
  var
    regs  : registers;
    count :   integer;

    request_buffer : record
      buffer_length : integer;
      dosfn,
      connection_count,
      connection_list,
      message_length   :                  byte;
      message          : array[1..126] of byte;
    end;

    reply_buffer : record
      buffer_length    : integer;
      connection_count :    byte;
      result_list      :    byte;
    end;

  begin
    with regs do begin
      ah := $e1;
      ds := seg(request_buffer);
      si := ofs(request_buffer);
      es := seg(reply_buffer);
      di := ofs(reply_buffer);
    end;
    with request_buffer do begin
      dosfn := $04;
      connection_count := $01;
      connection_list := _connection;
      message_length := length(_message);
      buffer_length := length(_message) + 4;
      for count := 1 to 126 do message[count] := $00;
      if message_length > 0 then for count := 1 to message_length do
        message[count] := ord(_message[count]);
    end;
    with reply_buffer do begin
      buffer_length := 2;
      connection_count := 0;
      result_list := 0;
    end;
    msdos(regs);
    error := reply_buffer.result_list;
  end;






  procedure get_personal_message;
  var
    regs  : registers;
    count :  integer;

    request_buffer : record
      buffer_length : integer;
      dosfn         :   byte;
    end;

    reply_buffer : record
      buffer_length     :               integer;
      source_connection :                  byte;
      message_length    :                  byte;
      message_buffer    : array[1..126] of byte;
    end;

  begin
    with regs do begin
      ah := $e1;
      ds := seg(request_buffer);
      si := ofs(request_buffer);
      es := seg(reply_buffer);
      di := ofs(reply_buffer);
    end;
    with request_buffer do begin
      buffer_length := 1;
      dosfn := $05;
    end;
    with reply_buffer do begin
      buffer_length := 128;
      source_connection := 0;
      message_length := 0;
      for count := 1 to 126 do message_buffer[count] := $0;
    end;
    msdos(regs);
    _connection := reply_buffer.source_connection;
    _message := '';
    error := reply_buffer.message_length;
    if error > 0 then for count := 1 to error do
      _message := _message + chr(reply_buffer.message_buffer[count]);
  end;





  procedure log_file;
  var regs : registers;
  begin
    with regs do begin
      ah := $eb;
      ds := seg(log_filename);
      dx := ofs(log_filename);
      bp := log_timeout;
    end;
    msdos(regs);
    error := regs.al;
  end;





  procedure release_file;
  var regs : registers;
  begin
    with regs do begin
      ah := $ec;
      ds := seg(log_filename);
      dx := ofs(log_filename);
    end;
    msdos(regs);
    error := regs.al;
  end;





  procedure clear_file;
  var regs : registers;
  begin
    with regs do begin
      ah := $ed;
      ds := seg(log_filename);
      dx := ofs(log_filename);
    end;
    msdos(regs);
    error := regs.al;
  end;





  procedure clear_file_set;
  var regs : registers;
  begin
    regs.ah := $cf;
    msdos(regs);
    error := regs.al;
  end;





  procedure lock_file_set;
  var regs : registers;
  begin
    regs.ah := $cb;
    regs.bp := lock_timeout;
    msdos(regs);
    error := regs.al;
  end;





  procedure release_file_set;
  var regs : registers;
  begin
    regs.ah := $cd;
    msdos(regs);
  end;





  procedure open_semaphore;
  var
    regs             :             registers;
    s_name           : array[1..129] of byte;
    count            :               integer;
    semaphore_handle :  array[1..2] of word;

  begin
    if (_initial_value < 0) or (_initial_value > 127) then _initial_value := 0;
    for count := 1 to 129 do s_name[count] := $00; {zero buffer}
    if length(_name) > 127 then _name := copy(_name, 1, 127); {limit name length}
    if length(_name) > 0 then for count := 1 to length(_name) do
      s_name[count+1] := ord(_name[count]);
    s_name[1] := length(_name);
    regs.ah := $c5;
    regs.al := $00;
    move(_initial_value, regs.cl, 1);
    regs.ds := seg(s_name);
    regs.dx := ofs(s_name);
    msdos(regs);
    error := regs.al;
    _open_count := regs.bl;
    semaphore_handle[1] := regs.cx;
    semaphore_handle[2] := regs.dx;
    move(semaphore_handle, _handle, 4);
  end;





  procedure close_semaphore;
  var
    regs             :           registers;
    semaphore_handle : array[1..2] of word;

  begin
    move(_handle, semaphore_handle, 4);
    regs.ah := $c5;
    regs.al := $04;
    regs.cx := semaphore_handle[1];
    regs.dx := semaphore_handle[2];
    msdos(regs);
    error := regs.al;  { 00h=successful   ffh=invalid handle}
  end;





  procedure examine_semaphore;
  var
    regs             :           registers;
    semaphore_handle : array[1..2] of word;

  begin
    move(_handle, semaphore_handle, 4);
    regs.ah := $c5;
    regs.al := $01;
    regs.cx := semaphore_handle[1];
    regs.dx := semaphore_handle[2];
    msdos(regs);
    error := regs.al; {00h=successful ffh=invalid handle}
    move(regs.cx, _value, 1);
    _count := regs.dl;
  end;





  procedure signal_semaphore;
  var
    regs             :           registers;
    semaphore_handle : array[1..2] of word;

  begin
    move(_handle, semaphore_handle, 4);
    regs.ah := $c5;
    regs.al := $03;
    regs.cx := semaphore_handle[1];
    regs.dx := semaphore_handle[2];
    msdos(regs);
    error := regs.al;
    {00h=successful   01h=overflow value > 127   ffh=invalid handle}
  end;





  procedure wait_on_semaphore;
  var
    regs             :           registers;
    semaphore_handle : array[1..2] of word;

  begin
    move(_handle, semaphore_handle, 4);
    regs.ah := $c5;
    regs.al := $02;
    regs.bp := _timeout; {units in 1/18 of second,   0 = no wait}
    regs.cx := semaphore_handle[1];
    regs.dx := semaphore_handle[2];
    msdos(regs);
    error := regs.al;
    {00h=successful   feh=timeout failure   ffh=invalid handle}
  end;





  procedure clear_connection;
  var
    con_num :      byte;
    regs    : registers;

    request_buffer : record
      length  : integer;
      dosfn   :    byte;
      con_num :    byte;
    end;

    reply_buffer : record
      length : integer;
    end;

  begin
    with request_buffer do begin
      length := 4;
      con_num := connection_number;
      dosfn := $d2;
    end;
    reply_buffer.length := 0;
    with regs do begin
      ah := $e3;
      ds := seg(request_buffer);
      si := ofs(request_buffer);
      es := seg(reply_buffer);
      di := ofs(reply_buffer);
    end;
    msdos(regs);
    error := regs.al;
  end;



end. { end of unit novell }


this unit provides a method of obtaining novell information from a user
written program.  this unit was tested on an ibm at running dos 4.0 &
using netware 2.15.  the unit compiled cleanly under turbo pascal 6.0

last update:   8 apr 91
-----------------------------------------------------------------------

any questions can be directed to:

mark bramwell
university of western ontario
london, ontario, n6a 3k7

phone:  [phone] [work]              519-473-3618 [home]

bitnet: [e-mail]     packet: ve3pzr @ ve3gyq

anonymous ftp server internet address: 129.100.22.100

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


mods february 1 1991, ross lazarus ([e-mail])
     var errors in procedure getservername, get_broadcast_message,
     verify_object_password comments, password conversion to upper case,

seems to work fine on a netware 3.00 and on 3.01 servers -

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