Piper's Pit BBS/FTP: ibm 0040 - 0049/ibm0040-0049/ibm0040.tar/ibm0040/BTF521-3.ZIP/NETWARE.LZH/NETQUE.PAS

Pascal/Delphi Source File | 1991-02-08 | 26.1 KB | 941 lines

{
  Turbo Pascal Unit of Queue Services for NetWare

  by Richard S. Sadowsky

  Please address questions and comments about this unit to ALL in section 6 of
  the PCVENB forum on Compuserve.
}
{$A-,V-,F-}

Unit NetQue;

interface
uses
  Dos,
  NetWare,
  NetBind;

const
  MaxQueueJobs         = 250;
  QueueMaxConnections  = 25;

  jcfAutoStart         = $08;
  jcfRestart           = $10;
  jfcEntryOpen         = $20;
  jfcUserHold          = $40;
  jcfOperatorHold      = $80;

type
  JobFileNameStr       = String[13];
  QueuePathType        = String[118];
  QMSDateTime          = record
                           Y,M,D,H,Min,S : Byte;
                         end;
  QueueJobList         = record
                           NumJobs : Word;
                           JobList : Array[1..MaxQueueJobs] of Word;
                         end;
  JobFileHandleType    = Array[1..6] of Byte;
  QueueTimeType        = Array[1..6] of Byte;
  TextJobField         = Array[1..50] of Char;
  TextJobStr           = String[49];
  ClientRecordArea     = Array[1..152] of Byte;
  QueueServerIDList    = Array[1..QueueMaxConnections] of LongInt;
  QueueStationList     = Array[1..QueueMaxConnections] of Byte;
  JobEntryType         = record
                           ClientStation    : Byte;
                           ClientTaskNum    : Byte;
                           ClientID         : LongInt;      {hi-lo}
                           TargetServerID   : LongInt;      {hi-lo}
                           TargetExecTime   : QMSDateTime;
                           JobEntryTime     : QMSDateTime;
                           JobNumber        : Word;         {hi-lo}
                           JobType          : Word;         {hi-lo}
                           JobPosition      : Byte;
                           JobControlFlags  : Byte;
                           JobFileName      : JobFileNameStr;
                           JobFileHandle    : JobFileHandleType;
                           ServerStation    : Byte;
                           ServerTaskNum    : Byte;
                           ServerID         : LongInt;      {hi-lo}
                           TextJobDesc      : TextJobField;
                           ClientRecord     : ClientRecordArea;
                         end;
  ServerStatusRecord   = Array[1..64] of Byte;

const
  SubFAbortServicingJob= $73;
  SubFAttachQueServ    = $6F;
  SubFChangeJobPos     = $6E;
  SubFChangeJobEntry   = $6D;
  SubFChangeToClient   = $74;
  SubFCloseAndStart    = $69;
  SubFCreateQue        = $64;
  SubFCreateJobAndFile = $68;
  SubFDestroyQue       = $65;
  SubFDetachFromQue    = $70;
  SubFFinishServicing  = $72;
  SubFGetJobFileSize   = $78;

  SubFGetJobList       = $6B;
  SubFReadCurStatus    = $66;
  SubFReadJobEntry     = $6C;
  SubFReadQueServStatus= $76;
  SubFRemJobFromQue    = $6A;
  SubFChangeToServer   = $75;
  SubFServiceJob       = $71;
  SubFReadQueStatus    = $67;
  SubFSetStatusRec     = $77;

var
  FirstOpportunity     : QMSDateTime;

function AbortServicingQueueJob(QueueID : LongInt; JobNum : Word) : Byte;
  {-Abort servicing a job, close the associated file, amd remove job entry
    from Queue}

function AttachQueueServerToQueue(QueueID : LongInt) : Byte;
  {-Attaches a station to a queue as a queue (job) server}

function ChangeQueueJobEntry(QueueID : LongInt;
                             var JobEntry : JobEntryType) : Byte;
  {-Change's information in the job's record entry}

function ChangeQueueJobPosition(QueueID : LongInt; JobNumber : Word;
                                NewPosition : Byte) : Byte;
  {-Changes a job's position in the queue}

function ChangeToClientRights(QueueID : LongInt; JobNumber : Word) : Byte;
  {-Allows a queue (job) server to assume the login identity of the client
    that placed the job in the queue}

function CloseFileAndStartJob(QueueID : LongInt; JobNumber : Word) : Byte;
  {-Closes an associated file and releases the job for servicing}

function CreateQueue(QueType : Word; QueName : ObjNameStr;
                     DirectoryHandle : Byte; PathName : QueuePathType;
                     var QueueID : LongInt) : Byte;
  {-Creates a new queue on a file server}

function CreateQueueJobAndFile(QueueID : LongInt;
                               JobEntry : JobEntryType;
                               var ReplyEntry : JobEntryType) : Byte;
  {-Places a new job in the queue}

function DestroyQueue(QueueID : LongInt) : Byte;
  {-Removes a queue from the bindery and file system of a file server}

function DetachQueueServerFromQueue(QueueID : LongInt) : Byte;
  {-Removes the requesting station from the queue's list of active queue (job_
    servers}

function FinishServicingQueueJob(QueueID : LongInt; JobNumber : Word;
                                 Charge : LongInt) : Byte;
  {-Allows a queue (job) server to signal QMS when it has completed a job}

function GetQueueJobList(QueueID : LongInt; var Jobs : QueueJobList) : Byte;
  {-Provides a list of all jobs contained in a queue}

function GetQueueJobFileSize(QueueID : LongInt;
                             JobNumber : Word;
                             var SizeOfFile : LongInt) : Byte;
  {-Finds the size of the associated file for a job queue}

function ReadQueueCurrentStatus(QueueID : LongInt;
                                var QueueStatus : Byte;
                                var NumberOfJobs : Byte;
                                var NumberOfServers : Byte;
                                var ServerIDList : QueueServerIDList;
                                var StationList  : QueueStationList) : Byte;
  {-Reads the current status of the queue}

function ReadJobEntry(QueueID : LongInt; JobNumber : Word;
                      var JobEntry : JobEntryType) : Byte;
  {-Retrieves information about jobs in a queue}

function ReadQueueServerStatus(QueueID : LongInt; ServerID : LongInt;
                               ServerStation : Byte) : Byte;
  {-Reads the current status record of an attached queue (job) server}

function RemoveJobFromQueue(QueueID : LongInt; JobNumber : Word) : Byte;
  {-Removes a job from the queue}

function RestoreQueueServerRights : Byte;
  {-Restores a server's own identity after assuming the client's rights}

function ServiceQueueJobAndOpenFile(QueueID : LongInt;
                                    TargetJobType : Word;
                                    var JobEntry : JobEntryType) : Byte;
  {-Allows a queue server to request a new job for servicing}

function SetQueueCurrentStatus(QueueID : LongInt;
                               QueueStatus : Byte) : Byte;
  {-Controls the addition of jobs and job servers to a queue by setting and
    clearing bits in the queue status byte}

function SetQueueServerStatusRecord(QueueID : LongInt;
                                    var StatusRec : ServerStatusRecord) : Byte;
  {-Updates QMS' copy of a queue (job) servers's status record}

{high level routines}
function JobSize(QueueID : LongInt; JobNumber : Word;
                 var Size : LongInt) : Byte;
  {-Returns the size of the print data associate with queue QueueID and job
    JobNumber}

implementation

function NetWareLongSwap(L : LongInt) : LongInt;
type
  DoubleWord       = record
                       LoWord  : Word;
                       HiWord  : Word;
                     end;

var
  DW : DoubleWord absolute L;

begin
  NetWareLongSwap := (LongInt(Swap(DW.LoWord)) shl 16) or (Swap(DW.HiWord));
end;

function AbortServicingQueueJob(QueueID : LongInt; JobNum : Word) : Byte;
var
  Request    : record
                 Len    : Word;
                 SubF   : Byte;
                 QID    : LongInt;
                 JobN   : Word;
               end;
  Reply      : Word;
  NovRegs    : Registers;

begin
  with Request do begin
    Len    := SizeOf(Request) - 2;
    SubF   := SubFAbortServicingJob;
    QID    := NetWareSwapLong(QueueID);
    JobN   := Swap(JobNum);
  end;
  Reply    := 0;
  with NovRegs do begin
    AH := BinderyFunc;
    DS := Seg(Request);
    SI := Ofs(Request);
    ES := Seg(Reply);
    DI := Ofs(Reply);
    MsDos(NovRegs);
    AbortServicingQueueJob := AL;
  end;
end;

function AttachQueueServerToQueue(QueueID : LongInt) : Byte;

var
  Request    : record
                 Len    : Word;
                 SubF   : Byte;
                 QID    : LongInt;
               end;
  Reply      : Word;
  NovRegs    : Registers;

begin
  with Request do begin
    Len    := SizeOf(Request) - 2;
    SubF   := SubFAttachQueServ;
    QID    := NetWareSwapLong(QueueID);
  end;
  Reply    := 0;
  with NovRegs do begin
    AH := BinderyFunc;
    DS := Seg(Request);
    SI := Ofs(Request);
    ES := Seg(Reply);
    DI := Ofs(Reply);
    MsDos(NovRegs);
    AttachQueueServerToQueue := AL;
  end;
end;


function ChangeQueueJobEntry(QueueID : LongInt;
                             var JobEntry : JobEntryType) : Byte;


var
  Request    : record
                 Len    : Word;
                 SubF   : Byte;
                 QID    : LongInt;
                 Job    : JobEntryType;
               end;
  Reply      : Word;
  NovRegs    : Registers;

begin
  with Request do begin
    Len    := SizeOf(Request) - 2;
    SubF   := SubFChangeJobEntry;
    QID    := NetWareSwapLong(QueueID);
    Job    := JobEntry;
  end;
  Reply    := 0;
  with NovRegs do begin
    AH := BinderyFunc;
    DS := Seg(Request);
    SI := Ofs(Request);
    ES := Seg(Reply);
    DI := Ofs(Reply);
    MsDos(NovRegs);
    ChangeQueueJobEntry := AL;
  end;
end;


function ChangeQueueJobPosition(QueueID : LongInt; JobNumber : Word;
                                NewPosition : Byte) : Byte;


var
  Request    : record
                 Len    : Word;
                 SubF   : Byte;
                 QID    : LongInt;
                 JobN   : Word;
                 NewPos : Byte;
               end;
  Reply      : Word;
  NovRegs    : Registers;

begin
  with Request do begin
    Len    := SizeOf(Request) - 2;
    SubF   := SubFChangeJobPos;
    QID    := NetWareSwapLong(QueueID);
    JobN   := Swap(JobNumber);
    NewPos := NewPosition;
  end;
  Reply    := 0;
  with NovRegs do begin
    AH := BinderyFunc;
    DS := Seg(Request);
    SI := Ofs(Request);
    ES := Seg(Reply);
    DI := Ofs(Reply);
    MsDos(NovRegs);
    ChangeQueueJobPosition := AL;
  end;
end;

function ChangeToClientRights(QueueID : LongInt; JobNumber : Word) : Byte;
var
  Request    : record
                 Len    : Word;
                 SubF   : Byte;
                 QID    : LongInt;
                 JobN   : Word;
               end;
  Reply      : Word;
  NovRegs    : Registers;

begin
  with Request do begin
    Len    := SizeOf(Request) - SizeOf(Word);
    SubF   := SubFChangeToClient;
    QID    := NetWareSwapLong(QueueID);
    JobN   := Swap(JobNumber);
  end;
  Reply    := 0;
  with NovRegs do begin
    AH := BinderyFunc;
    DS := Seg(Request);
    SI := Ofs(Request);
    ES := Seg(Reply);
    DI := Ofs(Reply);
    MsDos(NovRegs);
    ChangeToClientRights := AL;
  end;
end;

function CloseFileAndStartJob(QueueID : LongInt; JobNumber : Word) : Byte;
var
  Request    : record
                 Len    : Word;
                 SubF   : Byte;
                 QID    : LongInt;
                 JobN   : Word;
               end;
  Reply      : Word;
  NovRegs    : Registers;

begin
  with Request do begin
    Len    := SizeOf(Request) - SizeOf(Word);
    SubF   := SubFCloseAndStart;
    QID    := NetWareSwapLong(QueueID);
    JobN   := Swap(JobNumber);
  end;
  Reply    := 0;
  with NovRegs do begin
    AH := BinderyFunc;
    DS := Seg(Request);
    SI := Ofs(Request);
    ES := Seg(Reply);
    DI := Ofs(Reply);
    MsDos(NovRegs);
    CloseFileAndStartJob := AL;
  end;
end;

function CreateQueue(QueType : Word; QueName : ObjNameStr;
                     DirectoryHandle : Byte; PathName : QueuePathType;
                     var QueueID : LongInt) : Byte;
var
  Request : record
              Len        : Word;
              SubF       : Byte;
              ObjT       : Word;
              Buf        : Array[1..170] of Byte;
            end;
  Reply   : record
              Len        : Word;
              QID        : LongInt;
            end;
  NovRegs       : Registers;
  Incr          : Word;
  Index         : Byte;
begin
  with Request do begin
    SubF   := SubFCreateQue;
    ObjT   := Swap(QueType);
    Index  := 1;
    Incr   := Succ(Length(QueName));
    Move(QueName,Buf[Index],Incr);
    Inc(Index,Incr);
    Buf[Index] := DirectoryHandle;
    Inc(Index);
    Incr := Succ(Length(PathName));
    Move(PathName,Buf[Index],Incr);
    Inc(Index,Incr);
    Len := Index + 2;
  end;
  Reply.Len := SizeOf(LongInt);
  with NovRegs do begin
    AH := BinderyFunc;
    DS := Seg(Request);
    SI := Ofs(Request);
    ES := Seg(Reply);
    DI := Ofs(Reply);
    MsDos(NovRegs);
    CreateQueue := AL;
  end;
  QueueID := NetWareSwapLong(Reply.QID);
end;

function CreateQueueJobAndFile(QueueID : LongInt;
                               JobEntry : JobEntryType;
                               var ReplyEntry : JobEntryType) : Byte;

{page 12-23}
var
  Request : record
              Len      : Word;
              SubF     : Byte;
              QID      : LongInt;
              Entry    : JobEntryType;
            end;
  Reply   : record
              Len      : Word;
              REntry   : JobEntryType;
            end;
  NovRegs       : Registers;
begin
  with Request do begin
    Len     := SizeOf(Request) - SizeOf(Word);
    SubF    := SubFCreateJobAndFile;
    QID     := NetWareSwapLong(QueueID);
    Entry   := JobEntry;
  end;
  Reply.Len := Ofs(Reply.Rentry.TextJobDesc) - Ofs(Reply.Rentry);
  with NovRegs do begin
    AH := BinderyFunc;
    DS := Seg(Request);
    SI := Ofs(Request);
    ES := Seg(Reply);
    DI := Ofs(Reply);
    MsDos(NovRegs);
    CreateQueueJobAndFile := AL;
  end;
end;

function DestroyQueue(QueueID : LongInt) : Byte;

var
  Request    : record
                 Len    : Word;
                 SubF   : Byte;
                 QID    : LongInt;
               end;
  Reply      : Word;
  NovRegs    : Registers;

begin
  with Request do begin
    Len    := SizeOf(Request) - SizeOf(Word);
    SubF   := SubFDestroyQue;
    QID    := NetWareSwapLong(QueueID);
  end;
  Reply    := 0;
  with NovRegs do begin
    AH := BinderyFunc;
    DS := Seg(Request);
    SI := Ofs(Request);
    ES := Seg(Reply);
    DI := Ofs(Reply);
    MsDos(NovRegs);
    DestroyQueue := AL;
  end;
end;

function DetachQueueServerFromQueue(QueueID : LongInt) : Byte;
var
  Request    : record
                 Len    : Word;
                 SubF   : Byte;
                 QID    : LongInt;
               end;
  Reply      : Word;
  NovRegs    : Registers;

begin
  with Request do begin
    Len    := SizeOf(Request) - SizeOf(Word);
    SubF   := SubFDetachFromQue;
    QID    := NetWareSwapLong(QueueID);
  end;
  Reply    := 0;
  with NovRegs do begin
    AH := BinderyFunc;
    DS := Seg(Request);
    SI := Ofs(Request);
    ES := Seg(Reply);
    DI := Ofs(Reply);
    MsDos(NovRegs);
    DetachQueueServerFromQueue := AL;
  end;
end;

function FinishServicingQueueJob(QueueID : LongInt; JobNumber : Word;
                                 Charge : LongInt) : Byte;
var
  Request    : record
                 Len    : Word;
                 SubF   : Byte;
                 QID    : LongInt;
                 JobN   : Word;
                 Chrg   : LongInt;
               end;
  Reply      : Word;
  NovRegs    : Registers;

begin
  with Request do begin
    Len    := SizeOf(Request) - SizeOf(Word);
    SubF   := SubFFinishServicing;
    QID    := NetWareSwapLong(QueueID);
    JobN   := Swap(JobNumber);
    Chrg   := Charge;
  end;
  Reply    := 0;
  with NovRegs do begin
    AH := BinderyFunc;
    DS := Seg(Request);
    SI := Ofs(Request);
    ES := Seg(Reply);
    DI := Ofs(Reply);
    MsDos(NovRegs);
    FinishServicingQueueJob := AL;
  end;
end;

function GetQueueJobList(QueueID : LongInt; var Jobs : QueueJobList) : Byte;

var
  Request     : record
                  Len    : Word;
                  SubF   : Byte;
                  ID     : LongInt;
                end;
  Reply       : record
                  Len    : Word;
                  JobL   : QueueJobList;
                  MaxJ   : Word;
                end;
  NovRegs     : Registers;
  I           : Word;
begin
  FillChar(Reply,SizeOf(Reply),Char(250));
  Reply.Len := SizeOf(Reply) - 2;
  with Request do begin
    Len     := SizeOf(Request) - 2;
    SubF    := SubFGetJobList;
    ID      := NetWareSwapLong(QueueID);
  end;
  with NovRegs do begin
    AH := BinderyFunc;
    DS := Seg(Request);
    SI := Ofs(Request);
    ES := Seg(Reply);
    DI := Ofs(Reply);
    MsDos(NovRegs);
    GetQueueJobList := AL;
    if AL = 0 then
      with Reply do begin
        Jobs.NumJobs := Swap(JobL.NumJobs);
        if Jobs.NumJobs > MaxQueueJobs then
          Jobs.NumJobs := MaxQueueJobs;
        for I := 1 to Jobs.NumJobs do
          Jobs.JobList[I] := Swap(JobL.JobList[I]);
      end;
  end;
end;
function GetQueueJobFileSize(QueueID : LongInt;
                             JobNumber : Word;
                             var SizeOfFile : LongInt) : Byte;

var
  Request     : record
                  Len    : Word;
                  SubF   : Byte;
                  ID     : LongInt;
                  JobN   : Word;
                end;
  Reply       : record
                  Len      : Word;
                  QID      : QueueJobList;
                  JN       : Word;
                  FSize    : LongInt; {h-l}
                end;

  NovRegs     : Registers;
  I           : Word;

begin
  FillChar(Reply,SizeOf(Reply),0);
  Reply.Len := SizeOf(Reply) - 2;
  with Request do begin
    Len     := SizeOf(Request) - 2;
    SubF    := SubFGetJobFileSize;
    ID      :=  NetWareSwapLong(QueueID);
    JobN    := JobNumber;
  end;
  with NovRegs do begin
    AH := BinderyFunc;
    DS := Seg(Request);
    SI := Ofs(Request);
    ES := Seg(Reply);
    DI := Ofs(Reply);
    MsDos(NovRegs);
    GetQueueJobFileSize := AL;
  end;
  SizeOfFile := NetWareLongSwap(Reply.FSize);
end;

function ReadQueueCurrentStatus(QueueID : LongInt;
                                var QueueStatus : Byte;
                                var NumberOfJobs : Byte;
                                var NumberOfServers : Byte;
                                var ServerIDList : QueueServerIDList;
                                var StationList  : QueueStationList) : Byte;

var
  Request     : record
                  Len    : Word;
                  SubF   : Byte;
                  ID     : LongInt;
                end;
  Reply       : record
                  Len       : Word;
                  ID        : LongInt;
                  Status    : Byte;
                  NumJobs   : Byte;
                  NumServ   : Byte;
                  ServerIDs : QueueServerIDList;
                  Stations  : QueueStationList;
                  MaxServs  : Byte;
                end;
  NovRegs     : Registers;
  I           : Word;
begin
  FillChar(Reply,SizeOf(Reply),Char(25));
  Reply.Len := SizeOf(Reply) - 2;
  with Request do begin
    Len     := SizeOf(Request) - 2;
    SubF    := SubFReadCurStatus;
  end;
  with NovRegs do begin
    AH := BinderyFunc;
    DS := Seg(Request);
    SI := Ofs(Request);
    ES := Seg(Reply);
    DI := Ofs(Reply);
    MsDos(NovRegs);
    ReadQueueCurrentStatus := AL;
    if AL = 0 then
      with Reply do begin
        QueueStatus      := Status;
        NumberOfJobs     := NumJobs;
        NumberOfServers  := NumServ;
        ServerIDList     := ServerIDs;
        StationList      := Stations;
      end;
  end;
end;

function ReadJobEntry(QueueID : LongInt; JobNumber : Word;
                      var JobEntry : JobEntryType) : Byte;
var
  Request     : record
                  Len    : Word;
                  SubF   : Byte;
                  ID     : LongInt;
                  Num    : Word;
                end;
  Reply       : record
                  Len       : Word;
                  Entry     : JobEntryType;
                end;
  NovRegs     : Registers;

begin
  with Request do begin
    Len    := SizeOf(Request) - 2;
    SubF   := SubFReadJobEntry;
    ID     := NetWareSwapLong(QueueID);
    Num    := Swap(JobNumber);
  end;
  Reply.Len := SizeOf(Reply) - 2;
  with NovRegs do begin
    AH := BinderyFunc;
    DS := Seg(Request);
    SI := Ofs(Request);
    ES := Seg(Reply);
    DI := Ofs(Reply);
    MsDos(NovRegs);
    ReadJobEntry := AL;
    if AL = 0 then begin
      Reply.Entry.JobNumber := Swap(Reply.Entry.JobNumber);
      Reply.Entry.JobType   := Swap(Reply.Entry.JobType);
      JobEntry := Reply.Entry;
    end;
  end;
end;

function ReadQueueServerStatus(QueueID : LongInt; ServerID : LongInt;
                               ServerStation : Byte) : Byte;

var
  Request     : record
                  Len    : Word;
                  SubF   : Byte;
                  ID     : LongInt; {h-l}
                  ServID : LongInt; {h-l}
                  ServSt : Byte;
                end;
  Reply       : record
                  Len : Word;
                  ServStatusRec : ServerStatusRecord;
                end;
  NovRegs     : Registers;

begin
  Reply.Len := SizeOf(Reply) - 2;
  with Request do begin
    Len    := SizeOf(Request) - 2;
    SubF   := SubFReadQueServStatus;
    ID     := NetWareSwapLong(QueueID);
    ServID := ServerID;
    ServSt := ServerStation;
  end;
  with NovRegs do begin
    AH := BinderyFunc;
    DS := Seg(Request);
    SI := Ofs(Request);
    ES := Seg(Reply);
    DI := Ofs(Reply);
    MsDos(NovRegs);
    ReadQueueServerStatus := AL;
  end;
end;

function RemoveJobFromQueue(QueueID : LongInt; JobNumber : Word) : Byte;
var
  Request     : record
                  Len    : Word;
                  SubF   : Byte;
                  ID     : LongInt;
                  Num    : Word;
                end;
  Reply       : Word;
  NovRegs     : Registers;

begin
  Reply := 0;
  with Request do begin
    Len    := SizeOf(Request) - 2;
    SubF   := SubFRemJobFromQue;
    ID     := NetWareSwapLong(QueueID);
    Num    := Swap(JobNumber);
  end;
  with NovRegs do begin
    AH := BinderyFunc;
    DS := Seg(Request);
    SI := Ofs(Request);
    ES := Seg(Reply);
    DI := Ofs(Reply);
    MsDos(NovRegs);
    RemoveJobFromQueue := AL;
  end;
end;

function RestoreQueueServerRights : Byte;
var
  Request : record
              Len  : Word;
              SubF : Byte;
            end;
  Reply   : Word;
  NovRegs     : Registers;

begin
  Reply := 0;
  with Request do begin
    Len    := SizeOf(Request) - 2;
    SubF   := SubFChangeToServer;
  end;
  with NovRegs do begin
    AH := BinderyFunc;
    DS := Seg(Request);
    SI := Ofs(Request);
    ES := Seg(Reply);
    DI := Ofs(Reply);
    MsDos(NovRegs);
    RestoreQueueServerRights := AL;
  end;
end;

function ServiceQueueJobAndOpenFile(QueueID : LongInt;
                                    TargetJobType : Word;
                                    var JobEntry : JobEntryType) : Byte;
var
  Request : record
              Len    : Word;
              SubF   : Byte;
              QID    : LongInt;
              JobT   : Word;
            end;
  Reply   : record
              Len    : Word;
              Entry  : JobEntryType;
            end;
  NovRegs : Registers;

begin
  FillChar(Reply,SizeOf(Reply),0);
  Reply.Len := SizeOf(Reply) - 2;
  with Request do begin
    Len    := SizeOf(Request) - 2;
    SubF   := SubFServiceJob;
    QID    := NetWareSwapLong(QueueID);
    JobT   := TargetJobType;
  end;
  with NovRegs do begin
    AH := BinderyFunc;
    DS := Seg(Request);
    SI := Ofs(Request);
    ES := Seg(Reply);
    DI := Ofs(Reply);
    MsDos(NovRegs);
    JobEntry := Reply.Entry;
    ServiceQueueJobAndOpenFile := AL;
  end;
end;

function SetQueueCurrentStatus(QueueID : LongInt;
                               QueueStatus : Byte) : Byte;

var
  Request : record
              Len    : Word;
              SubF   : Byte;
              QID    : LongInt;
              QStat  : Byte;
            end;
  Reply   : Word;
  NovRegs : Registers;

begin
  Reply := 0;
  with Request do begin
    Len    := SizeOf(Request) - 2;
    SubF   := SubFReadQueStatus;
    QID    := NetWareSwapLong(QueueID);
    QStat  := QueueStatus;
  end;
  with NovRegs do begin
    AH := BinderyFunc;
    DS := Seg(Request);
    SI := Ofs(Request);
    ES := Seg(Reply);
    DI := Ofs(Reply);
    MsDos(NovRegs);
    SetQueueCurrentStatus := AL;
  end;
end;
function SetQueueServerStatusRecord(QueueID : LongInt;
                                    var StatusRec : ServerStatusRecord) : Byte;

var
  Request : record
              Len    : Word;
              SubF   : Byte;
              QID    : LongInt;
              SRec   : ServerStatusRecord;
            end;
  Reply   : Word;
  NovRegs : Registers;

begin
  Reply := 0;
  with Request do begin
    Len    := SizeOf(Request) - 2;
    SubF   := SubFSetStatusRec;
    QID    := NetWareSwapLong(QueueID);
    SRec   := StatusRec;
  end;
  with NovRegs do begin
    AH := BinderyFunc;
    DS := Seg(Request);
    SI := Ofs(Request);
    ES := Seg(Reply);
    DI := Ofs(Reply);
    MsDos(NovRegs);
    SetQueueServerStatusRecord := AL;
  end;
end;

function JobSize(QueueID : LongInt; JobNumber : Word;
                      var Size : LongInt) : Byte;
  {-Returns the size of the data associate with queue QueueID and job
    JobNumber}
begin
  JobSize := GetQueueJobFileSize(QueueID,JobNumber,Size);
  Size := Size - SizeOf(JobEntryType);
end;

begin
  FillChar(FirstOpportunity, SizeOf(FirstOpportunity), $FF);
end.