home *** CD-ROM | disk | FTP | other *** search
/ Programmer 7500 / MAX_PROGRAMMERS.iso / PASCAL / ECO30603.ZIP / ECO30603.LZH / ECOLIBII / ECO_IPX.PAS < prev    next >
Encoding:
Pascal/Delphi Source File  |  1992-12-11  |  10.7 KB  |  470 lines
  1. unit eco_ipx;
  2.  
  3. interface
  4.  
  5. const
  6.   temporary_socket =     0;
  7.   permanent_socket =   $ff;
  8.   okay             =     0;
  9.   invite_socket    = $0150;
  10.   chat_socket      = $0250;
  11.  
  12.  
  13. type
  14.   ipxnode = array[1..6] of byte;
  15.   ipxaddress = record
  16.     network : longint; { high-low}
  17.     node    : ipxnode; { high low }
  18.     socket  :    word; { high-low }
  19.   end;
  20.  
  21.   ipxpacket = record
  22.     packetchecksum         :       word;     { high-low }
  23.     packetlength           :       word;     { high-low }
  24.     packettransportcontrol :       byte;
  25.     packettype             :       byte;
  26.     destination            : ipxaddress;
  27.     source                 : ipxaddress;
  28.     data                   : array[0..546] of byte;
  29.   end;
  30.  
  31.   ecbfragment = record
  32.     address : pointer;  { offset-segment }
  33.     size       : word;  { low-high }
  34.   end;
  35.  
  36.   ecb = record
  37.     link                 : pointer;      { offset - segment }
  38.     esraddress           : pointer;      { offset - segment }
  39.     inuseflag            :    byte;
  40.     completioncode       :    byte;
  41.     ecbsocket            :    word;              { high-low }
  42.     ipxworkspace         : longint;                 { n / a }
  43.     driverworkspace      : array[1..12] of byte;    { n / a }
  44.     immediateaddress     : ipxnode;              { high low }
  45.     fragmentcount        :    word;              { low-high }
  46.     fragmentdescriptor   : array[0..1] of ecbfragment;
  47.   end;
  48.  
  49.  
  50.   
  51.   function asciiz(var x):string;
  52.  
  53.   function ipxopensocket(var socketnumber:word;sockettype:byte):integer;
  54.   function ipxclosesocket(socketnumber:word):integer;
  55.   function ipxgetlocaltarget(
  56.     var networkaddress: ipxaddress;
  57.     var immediateaddress:ipxnode;
  58.     var transporttime:word
  59.   ):integer;
  60.  
  61.   procedure ipxsendpacket(var eventcontrolblock: ecb);
  62.   function ipxlistenforpacket(var eventcontrolblock:ecb):integer;
  63.   procedure ipxscheduleipxevent(timeunits:word; var eventcontrolblock: ecb);
  64.   function ipxcancelevent(var eventcontrolblock: ecb):integer;
  65.   function ipxschedulespecialevent(
  66.     timeunits: word; var eventcontrolblock: ecb
  67.   ):integer;
  68.  
  69.   function ipxgetintervalmarker: word;
  70.   procedure ipxgetinternetworkaddress(var networkaddress: ipxaddress);
  71.   procedure ipxrelinquishcontrol;
  72.   procedure ipxdisconnectfromtarget(var networkaddress:ipxaddress);
  73.   procedure setupsendpacket( 
  74.     var ecbvar : ecb; var ipxvar : ipxpacket; network : longint;
  75.     node : ipxnode; socketin : word; var buffer; buffsize : word; esr : pointer
  76.   );
  77.  
  78.   procedure setuprcvpacket(
  79.     var ecbvar : ecb; var ipxvar : ipxpacket; socket : word; var buffer;
  80.     buffsize : word; esr : pointer
  81.   );
  82.  
  83.   function ncpserverpresent: boolean;
  84.   procedure ncpgetinternetaddr(
  85.     connection : byte; var targetnetwork : longint; var targetnode : ipxnode;
  86.   var targetsocket : word
  87.   );
  88.  
  89.   function ncpgetourstnnum:word;
  90.   function ncpgetconninfo(
  91.     connection : byte; var typex : word; var name : string
  92.   ) : integer;
  93.  
  94.   function swap(x: word): word;
  95.  
  96.  
  97.  
  98.  
  99.  
  100.  
  101.  
  102.  
  103.  
  104.  
  105.  
  106.   
  107. implementation
  108.  
  109.  
  110.  
  111.  
  112.  
  113.  
  114.  
  115.  
  116.  
  117.  
  118.  
  119.  
  120. uses
  121.   dos
  122.   
  123.   ;
  124.  
  125.  
  126.  
  127. var
  128.   regs : registers;
  129.  
  130.  
  131.  
  132.   function swap;
  133.   begin
  134.     swap := (x shl 8) or (x shr 8);
  135.   end;
  136.  
  137.  
  138.   
  139.   function ipxopensocket;
  140.   begin
  141.     regs.bx := 0;
  142.     regs.dx := socketnumber;
  143.     regs.al := sockettype;
  144.     intr($7a,regs);
  145.     ipxopensocket := regs.al;
  146.     socketnumber := regs.dx;
  147.   end;
  148.  
  149.  
  150.   
  151.   function ipxclosesocket;
  152.   begin
  153.     regs.bx := 1;
  154.     regs.dx := socketnumber;
  155.     intr($7a,regs);
  156.   end;
  157.  
  158.  
  159.   
  160.   function ipxgetlocaltarget;
  161.   begin
  162.     {let op beide segment adressen van de eerste twee var's moeten gelijk zijn }
  163.     regs.bx := 2;
  164.     regs.si := ofs(networkaddress);
  165.     regs.ds := seg(networkaddress);
  166.     regs.di := ofs(immediateaddress);
  167.     regs.es := seg(immediateaddress);
  168.     if regs.ds = regs.es then intr($7a,regs) else regs.al := $ff;
  169.     transporttime := regs.cx;
  170.     ipxgetlocaltarget := regs.al;
  171.   end;
  172.  
  173.  
  174.  
  175.   procedure ipxsendpacket;
  176.   begin
  177.     regs.bx := 3;
  178.     regs.es := seg(eventcontrolblock);
  179.     regs.si := ofs(eventcontrolblock);
  180.     intr($7a, regs);
  181.   end;
  182.  
  183.  
  184.  
  185.   function ipxlistenforpacket;
  186.   begin
  187.     regs.bx := 4;
  188.     regs.es := seg(eventcontrolblock);
  189.     regs.si := ofs(eventcontrolblock);
  190.     intr($7a, regs);
  191.     ipxlistenforpacket := regs.al;
  192.   end;
  193.  
  194.  
  195.   
  196.   procedure ipxscheduleipxevent;
  197.   begin
  198.     regs.bx := 5;
  199.     regs.es := seg(eventcontrolblock);
  200.     regs.si := ofs(eventcontrolblock);
  201.     regs.ax := timeunits;
  202.     intr($7a, regs);
  203.   end;
  204.  
  205.  
  206.   
  207.   function ipxcancelevent;
  208.   begin
  209.     regs.bx := 6;
  210.     regs.es := seg(eventcontrolblock);
  211.     regs.si := ofs(eventcontrolblock);
  212.     intr($7a, regs);
  213.     ipxcancelevent := regs.al;
  214.   end;
  215.  
  216.  
  217.  
  218.   function ipxschedulespecialevent;
  219.   begin
  220.     regs.bx := 7;
  221.     regs.ax := timeunits;
  222.     regs.es := seg(eventcontrolblock);
  223.     regs.si := ofs(eventcontrolblock);
  224.     intr($7a, regs);
  225.     ipxschedulespecialevent := regs.al;
  226.   end;
  227.  
  228.  
  229.   
  230.   function ipxgetintervalmarker: word;
  231.   begin
  232.     regs.bx := 8;
  233.     intr($7a, regs);
  234.     ipxgetintervalmarker := regs.ax;
  235.   end;
  236.  
  237.  
  238.   
  239.   procedure ipxgetinternetworkaddress;
  240.   begin
  241.     regs.bx := 9;
  242.     regs.si := ofs(networkaddress);
  243.     regs.es := seg(networkaddress);
  244.     intr($7a,regs);
  245.   end;
  246.  
  247.  
  248.   
  249.   procedure ipxrelinquishcontrol;
  250.   begin
  251.     regs.bx := $0a;
  252.     intr($7a,regs);
  253.   end;
  254.   
  255.  
  256.  
  257.   procedure ipxdisconnectfromtarget;
  258.   begin
  259.     regs.bx := $0b;
  260.     regs.si := ofs(networkaddress);
  261.     regs.es := seg(networkaddress);
  262.     intr($7a,regs);
  263.   end;
  264.  
  265.  
  266.   
  267.   procedure setupsendpacket;
  268.   var
  269.     ttime,i :       word;
  270.     ipxaddr : ipxaddress;
  271.     immnode :    ipxnode;      { zelfde segment als ipxaddr ! }
  272.  
  273.   begin
  274.     ipxaddr.network := network;
  275.     ipxaddr.node := node;
  276.     ipxaddr.socket := socketin;
  277.     
  278.     ecbvar.esraddress := esr;
  279.     
  280.     ecbvar.inuseflag := $ff;
  281.     ecbvar.ecbsocket := socketin;
  282.     ecbvar.fragmentcount := 2;
  283.     
  284.     ecbvar.fragmentdescriptor[0].address := @ipxvar;
  285.     ecbvar.fragmentdescriptor[0].size := sizeof(ipxvar);
  286.     
  287.     ecbvar.fragmentdescriptor[1].address := @buffer;
  288.     ecbvar.fragmentdescriptor[1].size := buffsize;
  289.     
  290.     ipxvar.packettype := 0;
  291.     
  292.     if ipxgetlocaltarget( ipxaddr, immnode, ttime ) = $fa then begin
  293.       writeln('no network path found');
  294.       write('network: ',network,'  socket: ', socketin,' adress: ');
  295.       for i := 1 to 6 do write(node[i]:4);
  296.       writeln;
  297.     end;
  298.     ecbvar.immediateaddress := immnode;
  299.     ipxvar.destination.network := network;
  300.     ipxvar.destination.node := node;
  301.     ipxvar.destination.socket := ecbvar.ecbsocket;
  302.   end;
  303.  
  304.  
  305.   
  306.   procedure setuprcvpacket;
  307.   begin
  308.       ecbvar.esraddress := esr;
  309.       ecbvar.inuseflag := $ff;
  310.       ecbvar.ecbsocket := socket;
  311.       ecbvar.fragmentcount := 2;
  312.     ecbvar.fragmentdescriptor[0].address := @ipxvar;
  313.     ecbvar.fragmentdescriptor[0].size := sizeof(ipxvar);
  314.     ecbvar.fragmentdescriptor[1].address := @buffer;
  315.     ecbvar.fragmentdescriptor[1].size := buffsize;
  316.   end;
  317.  
  318.  
  319.   
  320.   function asciiz(var x): string;
  321.   var
  322.     y : array[1..128] of char absolute x;
  323.     i :                          integer;
  324.     u :                           string;
  325.  
  326.   begin
  327.     i := 1; u := '';
  328.     while (i < 128) and (y[i] <> #0) do begin
  329.       u := u + y[i];
  330.       inc(i);
  331.     end;
  332.     asciiz := u;
  333.   end;
  334.  
  335.  
  336.   
  337.   function ncpgetourstnnum:word;
  338.   begin
  339.     regs.ah := $dc;        { get station number }
  340.     msdos( regs );
  341.     ncpgetourstnnum := regs.al;
  342.   end;
  343.  
  344.  
  345.   
  346.   function ncpgetconninfo;
  347.   type
  348.     connectionpacketrequest = record
  349.       packetlength          : word;
  350.       functie               : byte;
  351.       connectionnumber      : byte;
  352.     end;
  353.     connectionpacketreply = record
  354.       returnlength        :                 word;
  355.       uniqueid            :              longint;
  356.       typex               :                 word;
  357.       objectname          : array[1..48] of byte;
  358.       logtime             :  array[1..8] of byte;
  359.     end;
  360.  
  361.   var
  362.     request : connectionpacketrequest;
  363.     reply   :   connectionpacketreply;
  364.  
  365.   begin
  366.     request.packetlength := 2;
  367.     request.functie := 22;
  368.     reply.returnlength := 62;
  369.     with regs do begin
  370.       ah := $e3;
  371.         si := ofs(request);
  372.       ds := seg(request);
  373.         di := ofs(reply);
  374.       es := seg(reply);
  375.     end;
  376.     request.connectionnumber := connection;
  377.     msdos(regs);
  378.     name := asciiz(reply.objectname);
  379.       typex := reply.typex;
  380.       ncpgetconninfo := regs.al;
  381.   end;
  382.  
  383.  
  384.   
  385.   procedure ncpgetinternetaddr;
  386.   type
  387.     internetpacketrequest = record
  388.       packetlength        : word;
  389.       functie             : byte;
  390.       connectionnumber    : byte;
  391.     end;
  392.     internetpacketreply = record
  393.       returnlength        : word;
  394.       internetnetwork     : longint;
  395.       internethost        : ipxnode;
  396.       internetsocket      : word;
  397.     end;
  398.  
  399.   var
  400.     request : internetpacketrequest;
  401.     reply   :   internetpacketreply;
  402.  
  403.   begin
  404.     request.packetlength := 2;
  405.     request.functie := 19;                         { 19 := get internet address }
  406.     request.connectionnumber := connection;
  407.     reply.returnlength := 12;
  408.     with regs do begin
  409.       ah := $e3;
  410.       si := ofs(request);
  411.       ds := seg(request);
  412.       di := ofs(reply);
  413.       es := seg(reply);
  414.     end;
  415.     request.connectionnumber := connection;
  416.     msdos(regs);
  417.     targetnetwork := reply.internetnetwork;
  418.     targetnode := reply.internethost;
  419.     targetsocket := reply.internetsocket;
  420.   end;
  421.  
  422.  
  423.  
  424.   function ncpserverpresent;
  425.   type
  426.     getserverinforequest = record
  427.       packetlength : word;
  428.       functie      : byte;
  429.     end;
  430.     getserverinforeply = record
  431.       returnlength         : word;
  432.       servername           : array[0..47] of char;
  433.       netwareversion       : byte;
  434.       netwaresubversion    : byte;
  435.       connectionssupported : word;
  436.       connectionsinuse     : word;
  437.       maxconnectedvolumes  : word;
  438.       undefined            : array[1..72] of byte;
  439.     end;
  440.  
  441.   var
  442.     request : getserverinforequest;
  443.     reply   :   getserverinforeply;
  444.  
  445.   begin
  446.     request.packetlength := 1;
  447.     request.functie      := 17;      { 17 := get server info }
  448.     reply.returnlength   := sizeof( reply ) - 2;
  449.     reply.servername[0]  := #0;
  450.     with regs do begin
  451.       ah := $e3;
  452.       si := ofs(request);
  453.       ds := seg(request);
  454.       di := ofs(reply);
  455.       es := seg(reply);
  456.     end;
  457.     msdos( regs);
  458.     ncpserverpresent := reply.servername[0] <> #0;
  459.   end;
  460.  
  461.  
  462.  
  463. end.
  464.  
  465.   ------------ ipx routines voor novell -----------------------------------
  466.  
  467.   g. bokma         november  1991
  468.  
  469.   documentatie : zie hoofdstuk 14  programmers guide to netware
  470.