Programmer 7500/MAX_PROGRAMMERS.iso/PASCAL/ECO30603.ZIP/ECO30603.LZH/ECOLIBII/DEMOS/NOVELL/NM.PAS

Pascal/Delphi Source File | 1992-12-16 | 13.9 KB | 444 lines

{$A-,B-,D-,E-,F+,I-,L-,N-,O-,R-,S-,V-}
{$M 65520, 0, 655360}
uses
  eco_lib, crt, eco_novl

  ;



const
  func : boolean = false;


var
  really                 : boolean;
  station,
  retcode,
  volume_number,
  conntype,
  drive_num,
  server_num,
  count,
  handle_num             : integer;
  node, username,
  volume_name,
  server,
  name, datetime,
  hex_id,
  realname,
  pathname,
  version,
  network,
  socket                 :  string;

  { scan object variables }
  replysecurity          :    byte;
  object_type,
  replytype,
  replyflag,
  replyproperties        : integer;
  lastseen, replyid      : longint;
  object_name, replyname :  string;

  i                      :    word;




  function __strip1013(s: string): string;
  var
    i :   byte;
    t : string;

  begin
    t := '';
    for i := 1 to length(s) do if not(s[i] in [#10, #13]) then t := t + s[i];
    __strip1013 := t;
  end;





  procedure __loggedusers(search: string);
  var
    pservers,
    x, write_it,
    not_logged_in : integer;
    total         : integer;
    filler        :  string;


    procedure header;
    begin
      filler := '                    ';
      getservername(server, retcode);
      getnode(node, retcode);
      getstation(station, retcode);
      getconnectioninfo(station, username, hex_id, conntype, datetime, retcode);
      if search = '' then
        writeln('List of currently logged on users for server ', server) else
        writeln('List for user ', __up(search), ' on ', server, '.');
      writeln;
    end;


    procedure display_all_users;
    var count : integer;
    begin
      total := 0; not_logged_in := 0; x := 0; pservers := 0; getserverinfo;
      for count := 1 to serverinfo.connections_max do begin
        get_internet_address(count, network, node, socket, retcode);
        if retcode=0 then begin
          getuser(count, username, retcode);
          if username <> '' then begin
            total := total + 1;
            write_it := 0;
            if search = '' then write_it := 1;
            if ((search <> '') and (pos(__up(search), __up(username))>0)) then
              write_it := 1;
              getconnectioninfo(
                count, username, hex_id, conntype, datetime, retcode
              );
            if write_it = 1 then inc(x);
            if write_it = 1 then if count=station then
              write('*') else write(' ');
            {is the connection an USER or an utility connection}
            if conntype <> 1 then begin
              username := '<'+username+'>'; inc(pservers)
            end;
            if write_it = 1 then write(
              copy(__num(count)+filler, 1, 3), ' ',
              copy(username+filler, 1, 15), ' ', datetime
            );
            if write_it = 1 then if x = 1 then write('  |  ');
            if x=2 then begin; x := 0; writeln end;
          end else not_logged_in := not_logged_in + 1;
        end; { end of connection in use }
      end;
    end;


    procedure footer;
    begin
      writeln;
      if x = 1 then writeln;
      write(total, ' user');
      if total=1 then write(' is ') else write('s are ');
      writeln('logged-in on ', server, ' as of ', __curdate);
      if not_logged_in > 0 then begin
        write(not_logged_in, ' other connection');
        if not_logged_in = 1 then write(' is ') else write('s are ');
        writeln('in use, but the workstation has logged out.');
      end;
      if pservers > 0 then writeln(
        pservers, ' of the ', total, ' users were logged-in on ',
        server, ' as print servers.'
      );
    end;


    procedure change_server;    { change default server to something else }
    var
      x, y, z    : integer;
      new_server,
      servername :  string;

    begin
      z := 0;
      x := pos('/', search); new_server := __up(__nw(copy(search, 1, x-1)));
      search := __up(__nw(copy(search, x+1, 255)));
      writeln(new_server);
      func := true;

      lastseen := -1;      { -1 means start at first entry }
      object_type := 4;    {1=users 2=group 3=print server 4=file server}
      object_name := '*';  {wildcard '*' means everyone}
      retcode := 0;
      getserverinfo;
      writeln;
      writeln('List of file servers');
      writeln;
      count := 0;
      writeln('OBJNAME OBJTYP RETCODE REPLYNAME           FLAG SECURITY TYPE');
      while retcode=0 do begin
        scan_object(
          lastseen, object_type, object_name,
          replyid, replytype, replyname, replyflag, replysecurity,
          replyproperties, retcode
        );
        if retcode = 0 then begin
          if __comp(replyname, new_server) then begin
            z := 1;
            {set_preferred_connection_id();}
            writeln('     ',
              __juststr(object_name         , ' ',  5, _left_just_str), ' ',
              __juststr(__num(object_type)  , ' ',  5, _left_just_str), ' ',
              __juststr(__num(retcode)      , ' ',  5, _left_just_str), ' ',
              __juststr(replyname           , ' ', 20, _left_just_str), ' ',
              __juststr(__num(replyflag)    , ' ',  5, _left_just_str), ' ',
              __juststr(__num(replysecurity), ' ',  5, _left_just_str), ' ',
              '  ',
              __juststr(__num(replytype)    , ' ',  5, _left_just_str)
            );
          end;
          lastseen := replyid;
        end;
      end;

      if z = 0 then begin
        writeln('Server ', new_server, ' not found.');
        halt;
      end;
    end;


  begin
    if (search <> '') then change_server;
    header;
    display_all_users;
    footer;
  end;




var
  tofield,
  fromfield,
  subject     :    string;
  edctrl      : _editctrl;
  f, b        :      byte;

begin
  gotoxy(1, 11); __stdio; __setblwin(false);
  getstation(station, retcode);       { pull your station number fm network }
  getuser(station, username, retcode);{ pull your current userid fm network }
  get_realname(username, realname, retcode);
  realname := __strip1013(realname);
  getnode(node, retcode);    { pull your network physical id / never changes }
  get_internet_address(station, network, node, socket, retcode);
  getservername(server, retcode);
  getconnectioninfo(station, name, hex_id, conntype, datetime, retcode);
  gethexid(name, hex_id, retcode);

  __cls;
  __bandwin(true, 7, 4, 73, 7, 15, 1, sh_default, bt_single);
  __betwscn(
    7, 73, 5, 15, 1,
    'Station #' + __num(station) + ', under ' + server + ' as ' +
    username + ' @ ' + node + '/' + __num(__str(network))
  );
  __betwscn(
    5, 75, 6, 15, 1,
    'via socket ' + socket + ' in hex-ID: ' + hex_id + ' at ' + datetime
  );


  if (
    __inparams('/?', i) or __inparams('-?', i) or __inparams('?', i) or
    (paramcount = 0)
  ) then begin
    writeln;
    writeln('   ', __progname, ' for Novell Netware by Floor A.C. Naaijkens - Version 0.01ß');
    writeln('   ', __rep(60, '─'));
    writeln;
    writeln('   Usage');
    writeln('     NovMsg [USER] [MSGSTR]');
    writeln('     /S or /servers      info on all servers');
    writeln('     /V or /volumes      info on all volumes');
    writeln('     /D or /drives       info on all drives');
    writeln('     /U or /users        info on all users');
    writeln('     /L                  info on all logged-in users');
    writeln('     /R or /read         read msg from cmdline i.s.o. by kbd.');
    {
    writeln('     /logged X           info on all logged-in users on server X');
    writeln('     /logged *           info on all logged-in users on all servers');
    }
    writeln('     /X name             present yourself as "name"');
    writeln;
    writeln('   Note: Spaces can be represented by underscores (_)');
    halt;
  end;


  if (                                                        { ** SERVERS ** }
    __inparams('/s', i) or __inparams('/servers', i)
  ) then begin
    writeln('SERVERS'); func := true;
    for count := 1 to 8 do begin
      get_file_server_name(count, server);
      if server <> '' then begin
        set_preferred_connection_id(count);
        getserverinfo;
        get_server_version(version);
        writeln('  ', server, ' under ', version);
        with serverinfo do writeln(
          '  MAX: ', connections_max, '; USED: ', connections_in_use,
          '; PEAK: ', peak_connections_used, '.'
        );
      end;
    end;
    lastseen := -1;      { -1 means start at first entry }
    object_type := 4;    {1=users 2=group 3=print server 4=file server}
    object_name := '*';  {wildcard '*' means everyone}
    retcode := 0;
    getserverinfo;
    writeln('List of file servers');
    count := 0;
    while retcode=0 do begin
      scan_object(
        lastseen, object_type, object_name,
        replyid, replytype, replyname, replyflag, replysecurity,
        replyproperties, retcode
      );
      if retcode = 0 then begin
        if ((count mod 4) = 0) and (count <> 0) then writeln; inc(count);
        write(__juststr(replyname, ' ', 19, _left_just_str));
        lastseen := replyid;
      end;
    end;
    halt;
  end;


  {-------------------------------------------------------------------------}
  { loop through the 32 possible volumes on all novell servers and retreive }
  { the name of the volume     ie:  sys:                                    }
  {-------------------------------------------------------------------------}
  { loop through 8 connected servers }
  if (                                                        { ** VOLUMES ** }
    __inparams('/volumes', i) or __inparams('/v', i)
  ) then for count := 1 to 8 do begin
    get_file_server_name(count, server); func := true;
    if server <> '' then begin
      writeln('volumes mounted on ', server);
      set_preferred_connection_id(count);
      getserverinfo;
      for volume_number := 0 to serverinfo.max_connected_volumes do begin
        get_volume_name(volume_name, volume_number, retcode);
        if (volume_name > '') then writeln(
          '  network volume #', volume_number, ' is called ', volume_name
        );
      end;
      writeln;
      end;
    halt;
  end;



  if (                                                         { ** DRIVES ** }
    __inparams('/drives', i) or __inparams('/d', i)
  ) then begin
    writeln; writeln('network mapped drives:');  writeln; func := true;
    for count := 1 to 32 do begin { check each dos drive 1=a: 2=b: 3=c: etc.. }
      get_drive_connection_id(count, server_num);
      if server_num > 0 then begin
        get_file_server_name(server_num, server);
        set_preferred_connection_id(server_num);
        get_drive_handle_id(count, handle_num);
        get_directory_path(handle_num, pathname, retcode);
        writeln('drive ', chr(count+64), ': = ', server, '/', pathname);
      end;
    end;
    halt;
  end;




  if (                                                          { ** USERS ** }
    __inparams('/users', i) or __inparams('/u', i)
  ) then begin
    func := true;
    lastseen := -1;      { -1 means start at first entry }
    object_type := 1;    {1=users 2=group 3=print server 4=file server}
    object_name := '*';  {wildcard '*' means everyone}
    retcode := 0;
    getserverinfo;
    count := 0;
    writeln('userlist for ', serverinfo.name); writeln;
    while retcode = 0 do begin
      scan_object(
        lastseen, object_type, object_name,
        replyid, replytype, replyname, replyflag, replysecurity,
        replyproperties, retcode
      );
      if retcode = 0 then begin
        inc(count);
        write(__juststr(replyname, ' ', 19, _left_just_str));
        if (count mod 4) = 0 then writeln;
        lastseen := replyid;
      end;
      end;
    writeln;
    halt;
  end;


  if (                                                   { ** LOGGED USERS ** }
    __inparams('/logged', i) or __inparams('/l', i)
  ) then begin
    if __inparams('/logged', i) then __loggedusers(paramstr(i)) else
      __loggedusers(''); func := true;
  end;


  if not(func or __inparams('/nomsg', i)) then begin
    tofield := __up(paramstr(1));
    getuser(station, username, retcode);
    fromfield := __up(username);

    if __inparams('/X', i) then fromfield := __xlatestr(paramstr(i), '_', ' ');

    if (
      __inparams('/read', i) or __inparams('/r', i)
    ) then begin
      subject := __xlatestr(paramstr(2), '_', ' ');
    end else with edctrl do begin
      _viewx1 := 1; _viewx2 := 61; _viewy1 := 14;
      __loc(wherex, wherey, f, b);
      _vscnfore := yellow; _vscnback := brown;
      _vscncols := 60; _showflags := false;
      __betwscn(
        1, _curcolumns, 12, lightcyan, blue,
        'NovellMessage by Floor A.C. Naaijkens -- V1.01ß'
      );
      subject := '';
      really := __editline(subject, edctrl); writeln; writeln;
    end;
    if really then begin
      writeln(
        'Attempt to write following msg to ', tofield, ':', #10#13,
        subject, ' by ', fromfield
      );
      send_message_to_username(
        tofield, fromfield + ': ' + subject, retcode
      );
      if retcode <> 0 then begin
        writeln(
          'User is not logged-in on a server anywhere!!'
        );
        __loggedusers('');
      end;
    end;
  end;





end.


 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 to 129.100.22.100  pascal directory  api_tp6.zip
 (Any other novell units gladly accepted.)