Click above to get retro games delivered to your door ever month!

 Queue functions overview
------------------------------------------------------------------------------
 The NOVLIB queue functions make the NetWare Queue Management System (QMS)
 available to developers. QMS provides a central storage and queuing
 mechanism to enable users to create jobs which are then added to the queue.
 The jobs can be serviced remotely by a program at another node on the
 network.

 Queues and the Bindery

 A queue is a group of jobs waiting to be serviced. Queue users place jobs
 in the queue and job servers take jobs from the queue and service them. For
 the most part, jobs are processed sequentially, with those arriving first
 being serviced before those that come after.
 Queues are objects in the bindery of a file server. Defining a queue as a
 bindery object allows QMS to guarantee that only authorised users will
 access and modify the queue status or its contents. By defining users,
 operators and job servers as properties of the queue, QMS provides
 extensive control over how the queue is used and who may use it. For more
 information about the structure of the bindery, see Chapter 3, Bindery
 Functions.

 Queue Object

 As with any bindery object, a queue has a name, type, ID number and
 security status. The name and type or just the ID number of the queue
 identify it uniquely among queues in the bindery of a file server.
 Particularly on an internetwork, it is important to note that a queue
 exists in the bindery of a specific file server.
 When a queue is created, the object type must be specified. Novell has
 established certain conventions determining the object type to use for
 different types of queues. For example, it is suggested that print queues
 use type 3, archive queues use type 8, and that generic job queues use type
 10. These conventions are not enforced but are recommended and documented
 in the table of object types in the Bindery Functions section of this
 manual.
 Developers using the NOVLIB queue functions can use any object type, but
 programs are more likely to cooperate with other utilities and services if
 the conventions are followed. When creating queues that are not one of the
 normal Novell object types, an object type value greater than 32768,
 (0x8000) should be used.

 When QMS creates a queue, the queue is assigned the security levels read
 anyone and write Supervisor. The read anyone level allows users to scan the
 bindery for a list of queues of a particular type, even without being
 logged in. On the other hand, the write Supervisor level ensures that only
 the Supervisor will be able to modify the properties of the queue.

 Queue Properties

 When a queue is created with the NOVLIB FSQueueAdd() function, a bindery
 object is created with four properties: Q_DIRECTORY, Q_USERS, Q_SERVERS,
 and Q_OPERATORS. These properties let your programs control access to the
 queue through normal bindery routines.
 The first property, Q_DIRECTORY, has a security level of read Supervisor /
 write Supervisor. The other three properties are read logged / write
 Supervisor. Thus, only the Supervisor can see or modify the value of
 Q_DIRECTORY, but any logged-in user can see the value of Q_USERS,
 Q_SERVERS, and Q_OPERATORS.

 The Queue Bindery Object

 Name:          Assigned by the program
 Type:          A unique number identifying the
             bindery type of the queue
 ID Number:        Assigned by the bindery for the QMS
 Security Access Level:  Read logged / write Supervisor
 Properties:       Q_DIRECTORY
             Q_USERS
             Q_OPERATORS
             Q_SERVERS

 Q_DIRECTORY Property

 When your program creates a queue, you can specify a directory path. QMS
 will use this path to create a queue directory to hold the system files
 containing the queue itself and the job files related to the queue entries.
 If you do not specify a path, NOVLIB, like PCONSOLE, sets the directory
 path to SYS:SYSTEM by default. QMS names the queue directory with the ID
 number of the queue. The complete directory path, including the queue
 directory, is written to the Q_DIRECTORY property. Q_DIRECTORY is an item
 property; each queue has only one.

 Q_USERS Property

 QMS determines who may place jobs in a queue using the Q_USERS property.
 Q_USERS is a set property containing a list of all the object IDs of the
 users who may place a job in a queue. The list can contain both user object
 IDs and group object IDs. By default the NOVLIB FSQueueAdd() function
 automatically adds group EVERYONE to the property when it creates a queue.
 If a user is security-equivalent to any object listed in the Q_USERS
 property, that user may place jobs in the queue. Likewise, when a group
 name is added to the Q_USERS property, all users in the group may place
 jobs in the queue. Since the Q_USERS property access level is write
 Supervisor, only someone with Supervisor privileges can add or remove users
 from this property.

 Q_SERVERS Property

 QMS determines who may service a queue using the Q_SERVERS property.
 Q_SERVERS is a set property containing a list of the bindery object IDs
 (users, special servers, etc.) that can attach to a queue and service jobs.
 Typically, the object IDs of users authorised to start the queue servicing
 program are put in the Q_SERVERS property. Under certain circumstances, it
 may be desirable to have a separate login entity in the bindery for the
 queue servicing program.

 Q_OPERATORS Property

 QMS determines who has operator privileges using the Q_OPERATORS property.
 Q_OPERATORS is a set property that contains a list of the bindery object
 IDs (user, special servers, etc.) able to perform specific operations on
 the queue.
 Operators can manipulate the order of jobs in the queue and change the
 status of a queue, e.g. suspend the operation of the queue as needed.
 As with the Q_USERS property, user or group names can be added to the
 Q_OPERATORS property. In other words, queue operators must exist in the
 bindery of a file server as some kind of object, such as a user. When
 FSQueueAdd() is used to create a queue, NOVLIB automatically adds the
 Supervisor to the Q_OPERATORS property.