home *** CD-ROM | disk | FTP | other *** search
/ C!T ROM 2 / ctrom_ii_b.zip / ctrom_ii_b / PROGRAM / PASCAL / NWTP04 / NWBINDRY.PAS < prev    next >
Pascal/Delphi Source File  |  1994-01-01  |  53KB  |  1,376 lines
  1. {$X+,B-,V-}
  2.  
  3. UNIT nwBindry;
  4.  
  5. { nwBindry unit as of 931229 / NwTP 0.4 API. (c) 1994, R.Spronk }
  6.  
  7. INTERFACE
  8.  
  9. USES nwMisc;
  10.  
  11. { Primary Functions:                    Interrupt: comments:
  12.  
  13. * AddBinderyObjectToSet                 (F217/41)
  14. * ChangeBinderyObjectPassword           (F217/40) Unencrypted Passwords.
  15.   ChangeEncrBinderyObjectPassword       (F217/4B) Encrypted Passwords.
  16. * ChangeBinderyObjectSecurity           (F217/38)
  17. - ChangePassword                        (F217/01) #2
  18. * ChangePropertySecurity                (F217/3B)
  19. * CloseBindery                          (F217/44)
  20. * CreateBinderyObject                   (F217/32)
  21. * CreateProperty                        (F217/39)
  22. * DeleteBinderyObject                   (F217/33)
  23. * DeleteBinderyObjectFromSet            (F217/42)
  24. * DeleteProperty                        (F217/3A)
  25. * GetBinderyAccessLevel                 (F217/46)
  26. * GetBinderyObjectID                    (F217/35)
  27. * GetBinderyObjectName                  (F217/36)
  28. - GetMemberSetMofGroupG                 (F217/09) #6
  29. * IsBinderyObjectInSet                  (F217/43)
  30. - MapNumberToGroupName                  (F217/08) #5
  31. - MapNumberToObject                     (F217/04) #4
  32. - MapObjectToNumber                     (F217/03) #3
  33. * OpenBindery                           (F217/45)
  34. * ReadPropertyValue                     (F217/3D)
  35. * RenameBinderyObject                   (F217/34)
  36. * ScanBinderyObject                     (F217/37)
  37. * ScanProperty                          (F217/3C)
  38. * VerifyBinderyObjectPassword           (F217/3F) Unencrypted Passwords.
  39. * VerifyEncrBinderyObjectPassword       (F217/4A) Encrypted passwords
  40. * WritePropertyValue                    (F217/3E)
  41.  
  42.   Secondary Functions:
  43.  
  44. * IsShellLoaded
  45. * IsUserLoggedOn
  46. * ExistsUser
  47. * GetRealUserName
  48. * IsGroupMember
  49. * AddUserToGroup
  50. * DeleteUserFromGroup
  51.  
  52. Notes: -Names of Objects & properties are automaticly converted to uppercase
  53.         by the above functions.
  54.        -Functions marked with a '*' are tested (with 3.11) and found correct.
  55.         (See example programs in XBIND.ZIP, e.g. SCANBIND,TSTBIND,BACKBIN).
  56.        -Functions marked with # are not implemented in this API.
  57.         #2: This call has been replaced by F217/40 ChangeBinderyObjectPassword.
  58.         #3: Replaced by F217/35 GetBinderyObjectID.
  59.         #4,#5: Replaced by F217/36 GetBinderyObjectName.
  60.         #5: replaced by F217/37 ScanBinderyObject and F217/3D ReadPropertyValue.
  61.  
  62. Related Functions in other units:
  63.  
  64.   GetConnectionInformation (nwConn)
  65.   GetObjectConnectionNumbers (nwConn)
  66.   LoginToFileServer (nwConn)
  67.   ScanObjectTrusteePaths (nwDir)
  68. }
  69.  
  70. CONST
  71.  { known object types: }
  72.   OT_WILD                        = -1;
  73.   OT_UNKNOWN                     = 0;
  74.   OT_USER                        = 1;
  75.   OT_USER_GROUP                  = 2;
  76.   OT_PRINT_QUEUE                 = 3;
  77.   OT_FILE_SERVER                 = 4;
  78.   OT_JOB_SERVER                  = 5;
  79.   OT_GATEWAY                     = 6;
  80.   OT_PRINT_SERVER                = 7;
  81.   OT_ARCHIVE_QUEUE               = 8;
  82.   OT_ARCHIVE_SERVER              = 9;
  83.   OT_JOB_QUEUE                   = $0A;
  84.   OT_ADMINISTRATION              = $0B;
  85.   OT_NAS_SNA_GATEWAY             = $21;
  86.   OT_REMOTE_BRIDGE_SERVER        = $24;
  87.   OT_ASYNC_BRIDGE_SERVER         = $26;   { note: # }
  88.   OT_TCPIP_GATEWAY               = $27;
  89.   OT_X25_BRIDGE                  = $28;   { # }
  90.   OT_X25_GATEWAY                 = $29;   { # EICON X25 Gateway }
  91.   OT_TIME_SYNCHRONIZATION_SERVER = $2D;
  92.   OT_ARCHIVE_SERVER_DYNAMIC_SAP  = $2E;
  93.   OT_DI3270_GATEWAY              = $45;   { # }
  94.   OT_ADVERTISING_PRINTSERVER     = $47;
  95.   OT_BTRIEVE_VAP                 = $4B;   { # Btrieve 5.0 Server; used to be $50 }
  96.   OT_BTRIEVE_5_SERVER            = $4B;   { # }
  97.   OT_NETWARE_SQL_SERVER          = $4C;   { # SQL VAP/NLM }
  98.   OT_XTREE_NETWORK               = $4D;   { # }
  99.   OT_BTRIEVE_4_SERVER            = $50;   { # Btrieve v.4.xx Server }
  100.   OT_PRINT_QUEUE_USER            = $53;
  101.   OT_EICON_ROUTER                = $58;   { # }
  102.   OT_ARCSERVE_30                 = $66;   { # }
  103.   OT_WANCOPY_UTILITY             = $72;   { # }
  104.   OT_TES_NETWARE_FOR_VMS         = $7A;   { # }
  105.   OT_EMERALD_BACKUP              = $92;   { # }
  106.   OT_NETWARE_ACCESS_SERVER       = $98;   { # }
  107.   OT_PORTABLE_NETWARE            = $9E;   { # }
  108.   OT_POWERCHUTE                  = $A1;   { # }
  109.   OT_COMPAQ_IDA_STATUS_MONITOR   = $AC;   { # }
  110.   OT_BINDERY                     = $0102; { # }
  111.   OT_ORACLE_DATABASE_SERVER      = $0103; { # }
  112.   OT_RSPCX_SERVER                = $0107; { # Rconsole }
  113.   OT_CSA_MUX                     = $0114; { # }
  114.   OT_CSA_LSA                     = $0115; { # }
  115.   OT_CSA_CM                      = $0116; { # }
  116.   OT_CSA_SMA                     = $0117; { # }
  117.   OT_CSA_DBA                     = $0118; { # }
  118.   OT_CSA_NMA                     = $0119; { # }
  119.   OT_CSA_SSA                     = $011A; { # }
  120.   OT_CSA_STATUS                  = $011B; { # }
  121.   OT_CSA_APPC                    = $011E; { # }
  122.   OT_CSA_TEST                    = $0126; { # }
  123.   OT_CSA_TRACE                   = $012A; { # }
  124.   OT_COMMUNICATIONS_EXEC         = $0130; { # }
  125.   OT_NNS_DOMAIN                  = $0133; { # }
  126.   OT_NNS_PROFILE                 = $0135; { # }
  127.   OT_NW386_PRINT_QUEUE           = $0137; { # }
  128.   OT_LANSPOOL_SERVER             = $0141; { # }
  129.   OT_COMPAQ_SNMP_AGENT           = $0174; { # }
  130.   OT_HP_LASERJET                 = $030C; { # }
  131.   OT_PC3M                        = $037E; { # ?Tape Backup?}
  132.   OT_ARCSERVE_40                 = $03C4; { # }
  133.   OT_NETWARE_SQL                 = $03DE; { # }
  134.   OT_SITE_LOCK_VRS_FILES         = $0429; { # }
  135.   OT_SITE_LOCK_CHECKS            = $0529; { # }
  136.   OT_SITE_LOCK                   = $0B29; { # , see $2380 }
  137.   OT_SITE_LOCK_APPLICATIONS      = $0C29; { # }
  138.   OT_SITE_LOCK_2                 = $2380; { # , see $0B29 }
  139.   OT_SITE_LOCK_SERVER            = $4808; { # }
  140.   OT_SITE_LOCK_USER              = $5555; { # }
  141.   OT_TAPEWARE                    = $6312; { # }
  142.   OT_RABBIT_GATEWAY              = $6F00; { # }
  143.   OT_TAPEWARE_AGENT              = $7F82; { # }
  144.  { object types are reserved upto $8000 }
  145.   OT_LANPORT                     =Word($8002); { * }
  146.   OT_INTEL_NETPORT               =Word($8002); { * }
  147.   OT_QUICK_NETWARE_MANAGEMENT    =Word($8888); { * }
  148.   OT_WORDPEFECT_NETWARE_VERSION  =Word($8888); { * }
  149.   OT_PEGASUS_MAIL                =Word($9009); { * }
  150.   OT_QNT_ACCESS_WS               =Word($B0EF); { * }
  151. { note #: These object type numbers are probably correct,
  152.           but there are no (Novell) standard names for these object types.
  153.        *: These object type numbers may be in use for other purposes by
  154.           other applications.                                              }
  155.  
  156.  { bindery security: }
  157.   BS_ANY_READ       = $00;
  158.   BS_LOGGED_READ    = $01;
  159.   BS_OBJECT_READ    = $02;
  160.   BS_SUPER_READ     = $03;
  161.   BS_BINDERY_READ   = $04;
  162.  
  163.   BS_ANY_WRITE      = $00;
  164.   BS_LOGGED_WRITE   = $10;
  165.   BS_OBJECT_WRITE   = $20;
  166.   BS_SUPER_WRITE    = $30;
  167.   BS_BINDERY_WRITE  = $40;
  168.  
  169. {property & object objFlag/propFlags Constants:}
  170.   BF_ITEM           = $00;
  171.   BF_SET            = $02;
  172.   BF_DYN_PROP       = $10; {1}
  173.   BF_STAT_PROP      = $00; {1}
  174.   { or BF_ITEM/SET with BF_xx_PROP to obtain propFlags }
  175.   BF_STAT_OBJ       = $00; {1}
  176.   BF_DYN_OBJ        = $01; {1}
  177.  
  178. { Note 1: not available in the NW interface for C }
  179.  
  180.  
  181. Type propertyType=Array[1..128] of Byte;
  182.  
  183. Var result:word;
  184.  
  185. {F217/32 [2.15c+] }
  186. Function CreateBinderyObject(objName:string; objType:Word;
  187.                              objFlaG, objSecurity :Byte   ):boolean;
  188. { Creates an object in the bindery.
  189.   objName: name of the new object (47 chars)
  190.   objType: object type number (own type number or OT_xxx constant)
  191.   objFlag: identifies an object as static (BF_STAT_OBJ (0))
  192.            or dynamic (BF_DYN_OBJ (1))
  193.            (dynamic objects are removed from the bindery when the server goes down)
  194.   objSecurity: high nibble: write privileges needed to modify this object
  195.                low  nibble: read privileges needed to access this object
  196.                (default: $31 Supervisor write/Logged read) }
  197.  
  198. {F217/33 [2.15c+] }
  199. Function DeleteBinderyObject( objName:String; objType:Word ):boolean;
  200. { deletes a bindery object and all asociated properties. }
  201.  
  202. {F217/34 [2.15c+]}
  203. Function RenameBinderyObject( objName,NewObjName :string; objType :word ):boolean;
  204. { This function allows the (supervisor-equivalent) user to rename an object,
  205.   given its' type and old name.                                              }
  206.  
  207. {F217/35 [2.15c+] }
  208. Function GetBinderyObjectID( objName:String; objType:word;
  209.                              Var object_ID:Longint       ):boolean;
  210. { returns the object ID of an object, given its type and name.       }
  211.  
  212. {F217/36 [2.15c+] }
  213. Function GetBinderyObjectName( object_Id:LongInt;
  214.                                Var objName:String; Var objType:word ):boolean;
  215. { returns the type and name of an object, given its four BYTE-id. }
  216.  
  217. {F217/37 [2.15c+]}
  218. Function ScanBinderyObject( SearchObjName: String;
  219.                             SearchObjType: Integer;
  220.               {i/o:}    Var lastObjSeen  : Longint;
  221.               {out:}    Var RepName      : String;
  222.                         Var RepType      : Word;
  223.                         Var RepId        : LongInt;
  224.                         Var RepFlag      : Byte;
  225.                         Var RepSecurity  : Byte;
  226.                         Var RepHasProperties: Boolean
  227.                           ) :boolean;
  228. { This function scans the bindery and returns complete information about
  229.   a bindery object. It can be called iteratively.
  230.   -When called for the first time, supply -1 for lastObjSeen.
  231.   -Subsequent calls can then made (with lastObjSeen as an I/O parameter)
  232.    until error FCh: 'No Such Object' occurs.
  233.  
  234.   * as SearchObjName means all object names.
  235.   the SearchObjType is the object Type (OT_xxxxx). ( OT_WILD= -1: any type ) }
  236.  
  237. {F217/38 [2.15c+]}
  238. Function ChangeBinderyObjectSecurity(objName :String; objType :Word;
  239.                                      NewObjSecurity :Byte           ):boolean;
  240. { Changes the security of a Bindery object. This call is made successfully,
  241.   if the user is supervisor equivalent and the current security is unequal to
  242.   NetWare Read/ NetWare Write.                                              }
  243.  
  244. {F217/39 [2.15c+]}
  245. Function CreateProperty( objName:String; objType:Word;
  246.                     propertyName:String; propFlags,propSecurity:Byte ):boolean;
  247. { Creates a property to be associated with a bindery object.
  248.   Property flags tell whether a property is dynamic or static and whether
  249.   the property is defined as static or dynamic.  (see BF_xxx constants )    }
  250.  
  251. {F217/3A [2.15c+]}
  252. Function DeleteProperty( objName:String; objType:Word;
  253.                          propertyName:String          ):boolean;
  254. { Deletes a property from a bindery object.
  255.   The property field may contain wildcards.                                 }
  256.  
  257. {F217/3B [2.15c+] }
  258. Function ChangePropertySecurity( objName:String; objType:Word;
  259.                                 propName:String; newPropSecurity:Byte ):boolean;
  260. { The user must have read and write access to the property to make this call.
  261.   The call can't assign a greater security level than the security level of
  262.   the caller.                                                               }
  263.  
  264. {F217/3C [2.15c+]}
  265. Function ScanProperty( objName:String; objType:Word; searchPropName:String;
  266.             {i/o var:} Var SequenceNumber:LongInt;
  267.             { output:} Var propName:String;
  268.                        Var propFlags:Byte;
  269.                        Var propSecurity:Byte;
  270.                        Var propHasValue:Boolean;
  271.                        Var moreProperties:Boolean  ):boolean;
  272. { Sequence number should be -1 the first time this call is made.
  273.   The call can be reiterated (by supplying the returned Seq.#) until
  274.   moreProperties=FALSE or nwBindry.Result=NO_SUCH_PROPERTY.
  275.   searchPropName may contain wildcards;
  276.   If propHasValue=TRUE, the value can be read by calling ReadPropertyValue;
  277.   moreProperties=TRUE if more properties exist for this object.            }
  278.  
  279. {F217/3D [2.15c+]}
  280. Function ReadPropertyValue( objName:String; objType:Word;
  281.                             propName:String; segmentNumber:Word;
  282.                             Var propValue   : propertyType;
  283.                             Var moreSegments: Boolean;
  284.                             Var propFlags   : Byte              ):boolean;
  285. { Returns the value of a property associated with a Bindery object.     }
  286.  
  287. {F217/3E [2.15c+]}
  288. Function WritePropertyValue( objName:String; objType:Word;
  289.                    propName:String; segmentNbr: Byte; propValue:propertyType;
  290.                    moreSegments:Boolean                   ):boolean;
  291. { Changes the value of a (NON-SET) property associated with a Bindery object.
  292.   To write values to set-properties, use the AddBinderyObjectToSet call.
  293.   The user needs write access to the property to make this call.
  294.  
  295.   SegmentNBR should be set to 1 the first time this call is made. If there are
  296.   more segments, this value should be increased by EXACTLY 1.
  297.   If you know how many segments already exist, then you can set segmentNbr to
  298.   any segment in the range 1..'max_segment' and change that segment.
  299.  
  300.   The moreSegments flag should be set to TRUE if the current segment is NOT
  301.   the last segment to be written to. Setting this Flag to true will delete all
  302.   segments with a higher segmentnumber than the segment currently written to. }
  303.  
  304. {F217/3F [2.15c+]}
  305. FUNCTION VerifyBinderyObjectPassword
  306.           ( objName:string; objType:Word; password:string):boolean;
  307. { Verifies the accuracy of a password for a bindery object. }
  308. { for netware 3.xx remember to have previously (eg in the autoexec.ncf file )
  309.   set allow unencrypted passwords = on
  310.   on the console, otherwise this call always fails !
  311.   Note that intruder lockout status is affected by this call !
  312.   Netware security isn't that stupid....
  313.   Passwords need to be converted to upper case, NULL if there is no password. }
  314.  
  315. {F217/4A [2.15c+]}
  316. FUNCTION VerifyEncrBinderyObjectPassword
  317.           ( objName:string; objType:Word; password:string):boolean;
  318. { Verifies the accuracy of a password for a bindery object. }
  319. { Encrypts passwords. }
  320. { Passwords need to be converted to upper case, NULL if there is no password. }
  321.  
  322. {F217/40 [2.0/2.1/3.x] }
  323. Function ChangeBinderyObjectPassword(objName:String; objType:Word;
  324.                                      oldPassWord,newPassWord:String ):boolean;
  325. { Changes the password of a bindery object.
  326.   Allow unencrypted passwords must be ON!
  327.   Old Password can be NULL. To log into a file server, an object must have a
  328.   PASSWORD property. User must have read and write access to the bindery object. }
  329.  
  330. {F217/41 [2.15c+]}
  331. Function AddBinderyObjectToSet(objName:String; objType:Word;propName,
  332.                                memberName:String; memberType:Word ):boolean;
  333. { Adds a bindery object (member) to a property set.
  334.   user must have write access to the set property.                        }
  335.  
  336. {F217/42 [2.15c+]}
  337. Function DeleteBinderyObjectFromSet(objName:String; objType:Word;propName,
  338.                                     memberName:String; memberType:Word ):boolean;
  339. { Deletes a (member) bindery object from a property set.
  340.   user must have write access to the set property.                        }
  341.  
  342. {F217/43 [2.15c+]}
  343. Function IsBinderyObjectInSet(objName:String; objType:Word;propName,
  344.                               memberName:String; memberType:Word ):boolean;
  345. { Allows the programmer to check whether a bindery object is a member of a
  346.   set-property. memberName( of memberType) is the object to be searched for,
  347.   PropName (attached to the object with name objName (of objType))
  348.   is the property containing the set to be searched.
  349.   User must have read rights to the object and the property.
  350.   Ex: ('EVERYONE',OT_USER_GROUP,'GROUP_MEMBERS','SUPERVISOR',OT_USER)  }
  351.  
  352. {F217/44 [2.15c+]}
  353. Function CloseBindery:boolean;
  354. { Closes the bindery files so they can be backed up. (Supervisor only) }
  355.  
  356. {F217/45 [2.15c+]}
  357. Function OpenBindery:boolean;
  358. { This call must be used after the CloseBindery call. No other bindery
  359.   call will work while the bindery is closed.                          }
  360.  
  361. {F217/46 [2.15c+] }
  362. Function getBinderyAccessLevel( {out:} Var SecurityAccesslevel:byte;
  363.                                        Var ObjId:Longint          ): Boolean;
  364. { It returns the user's access level to the bindery.                      }
  365. { Often used as a quick way of determining the current users' object id   }
  366. { use the BS_xxxx constants to determine the exact rights of the user     }
  367.  
  368. {F217/17 [3.x]}
  369. FUNCTION GetEncryptionKey(VAR key : TencryptionKey): Boolean;
  370. { called by LoginToFileserver (nwConn), and VerifyBinderyObjectPassword,
  371.   ChangeBonderyObjectPassword (nwBindry) to get an encryption key for
  372.   the encryption function. }
  373.  
  374.  
  375. {************************** secondary functions: ****************************}
  376.  
  377. Function IsShellLoaded:boolean;
  378. Function IsUserLoggedOn:boolean;
  379. Function ExistsUser(userObjName:string):boolean;
  380. Function GetRealUserName(userObjname:string; Var realname:string):boolean;
  381. Function IsGroupMember(GroupName,UserObjName:String): Boolean;
  382. Function AddUserToGroup(userName,GroupName:String):boolean;
  383. Function DeleteUserFromGroup(userName,GroupName:String):boolean;
  384.  
  385. IMPLEMENTATION{=============================================================}
  386.  
  387. USES Dos;
  388.  
  389. Var UnitReqBuffer:array[1..576] of byte;
  390.     UnitReplyBuffer:array[1..576] of byte;
  391.     UnitRegs:registers;
  392.  
  393. Procedure F2SystemCall(subf:byte;req_size,rep_size:word);
  394. begin
  395. With UnitRegs
  396.  do begin
  397.     DS := Seg(UnitReqBuffer);  SI := Ofs(UnitReqBuffer);   CX := Req_size;
  398.     ES := Seg(UnitReplyBuffer);DI := Ofs(UnitReplyBuffer); DX := rep_size;
  399.     AH := $F2; AL := subf;
  400.     MSDOS(UnitRegs);
  401.     Result:=al;
  402.     end;
  403. end;
  404.  
  405.  
  406. {F217/17 [3.x]}
  407. FUNCTION GetEncryptionKey(VAR key : TencryptionKey): Boolean;
  408. Var req : RECORD
  409.           len : WORD;
  410.           func: BYTE;
  411.           END         ABSOLUTE UnitReqBuffer;
  412. BEGIN
  413. With req
  414.  do begin
  415.     len := 1;
  416.     func := $17;
  417.     end;
  418. F2Systemcall($17,sizeof(req),sizeof(key));
  419. Move(UnitReplyBuffer,key,8);
  420. GetEncryptionKey:=(Result=0);
  421. END;
  422.  
  423.  
  424. {F217/3F [2.15c+]}
  425. FUNCTION VerifyBinderyObjectPassword
  426.           ( objName:string;objType:Word; password : string):boolean;
  427. { Verifies the accuracy of a password for a bindery object. }
  428. { Passwords need to be converted to upper case, NULL if there is no password. }
  429. var  Request_buffer : record
  430.                       buffer_length : Word;
  431.                       subfunction   : byte;
  432.                       obj_type      : word; { hi-lo }
  433.                       _ObjectName   : string[48];
  434.                       _PassWord     : string[127];
  435.                       end                       ABSOLUTE UnitReqBuffer;
  436. begin
  437. With request_buffer
  438. do begin
  439.    buffer_length := SizeOf(request_buffer)-2;
  440.    subfunction :=$3F;
  441.    obj_type:=swap(objType); { force hi-lo }
  442.    UpString(objName);
  443.    UpString(password);
  444.    PStrCopy(_ObjectName,objName,48); _ObjectName[48]:=#0; UpString(_ObjectName);
  445.    PStrCopy(_PassWord,password,127); Upstring(_PassWord);
  446.   end;
  447. F2SystemCall($17,sizeof(request_buffer),0);
  448. VerifyBinderyObjectPassword:=(result=0);
  449. { possible resultcodes:
  450. $00    0      verification of object_name/password combination
  451. $96  150      Sever out of memory
  452. $C5  197      account disabled due to intrusion lockout
  453. $D6  214      unencrypted password calls not allowed on this v3+ server
  454. $F0  240      Wildcard not allowed
  455. $FB  251      no such property
  456. $FC  252      no such object_name on this server
  457. $FE  254      Server Bindery Locked
  458. $FF  255      Bindery failure (No such object or bad password)        }
  459. end;
  460.  
  461.  
  462. {F217/4A [3.x]}
  463. FUNCTION VerifyEncrBinderyObjectPassword(ObjName: String; ObjType: Word; PassWord: String): Boolean;
  464.  
  465.    FUNCTION VerifyEncrypted(ObjName : String; ObjType : Word; VAR key : TencryptionKey): Boolean;
  466.    VAR req : RECORD
  467.              BufLen  : Word;
  468.              _func   : Byte;
  469.              _key    : TencryptionKey;
  470.              _ObjType: Word;
  471.              _ObjName: String[48];
  472.              End                   ABSOLUTE UnitReqBuffer;
  473.    Begin
  474.    With req
  475.     do Begin
  476.        _func := $4A;
  477.        _key  := key;
  478.        _ObjType := Swap(objType);
  479.        PstrCopy(_ObjName,ObjName,48); UpString(_ObjName);
  480.        if ObjName[0]<#48
  481.         then _objName[0]:=objName[0]
  482.         else _objname[0]:=#48;
  483.        BufLen:=ord(_ObjName[0])+12;
  484.        End;
  485.    F2systemCall($17,sizeof(req),0);
  486.    VerifyEncrypted:=(result=0);
  487.    End;
  488.  
  489. VAR
  490.   key : TencryptionKey;
  491.   ObjId:LongInt;
  492.   _pw:string;
  493.   _lpw:Byte;
  494.  
  495. Begin
  496. UpString(password);
  497. _pw:=password;if _pw[0]>#127 Then _pw[0]:=#127;
  498. _lpw:=length(password);
  499. if _lpw=0 Then _pw:=#0;
  500.  
  501. IF GetEncryptionKey(key)
  502.  Then Begin
  503.       IF GetBinderyObjectId(objName,objType,ObjId)
  504.        Then Begin
  505.             EncryptPassword(objId,_pw,key);
  506.             VerifyEncrypted(ObjName, ObjType, key);
  507.             End;
  508.       End
  509.  Else VerifyBinderyObjectPassword(ObjName, ObjType, Password);
  510.  
  511. VerifyEncrBinderyObjectPassword := (result=0);
  512. End;
  513.  
  514.  
  515.  
  516. {F217/37 [2.15c+]}
  517. Function ScanBinderyObject( SearchObjName: String;
  518.                             SearchObjType: Integer;
  519.               {i/o:}    Var lastObjSeen  : Longint;
  520.               {out:}    Var RepName      : String;
  521.                         Var RepType      : Word;
  522.                         Var RepId        : LongInt;
  523.                         Var RepFlag      : Byte;
  524.                         Var RepSecurity  : Byte;
  525.                         Var RepHasProperties: Boolean
  526.                           ) :boolean;
  527. { This function scans the bindery and returns complete information about
  528.   a bindery object. }
  529. var TempStr:string;
  530.     req : record
  531.           length          : word;
  532.           subfunction     : byte;
  533.           last_obj_id     : longint; {hi-lo}
  534.           search_obj_type : word;    {hi-lo}
  535.           search_obj_name : string[48];
  536.           end                           ABSOLUTE UnitReqBuffer;
  537.     rep : record
  538.           object_id   : longint; {hi-lo}
  539.           object_type : word;    {hi-lo}
  540.           object_name : array [1..48] of byte;
  541.           object_flag : byte;
  542.           security    : byte;
  543.           properties  : byte;
  544.           end                           ABSOLUTE UnitReplyBuffer;
  545.    count : integer;
  546. begin
  547. with req
  548. do begin
  549.    length := SizeOf(req)-2;
  550.    subfunction := $37;
  551.    last_obj_id := Lswap(lastObjseen);  { force hi-lo }
  552.    search_obj_type:= swap(Word(SearchObjType)); { force hi-lo }
  553.    PstrCopy(Search_obj_name,SearchObjName,48); Search_obj_Name[48]:=#0; UpString(Search_obj_name);
  554.    end;
  555. F2Systemcall($17,sizeOf(req),sizeOf(rep));
  556. With rep
  557. do begin
  558.    repFlag := object_flag;
  559.    repHasProperties := (properties>0);
  560.    repSecurity := security;
  561.    repType := swap(object_type); { force lo-hi }
  562.    repId := Lswap(object_id);    { force lo-hi }
  563.    lastObjSeen := repId;
  564.    ZStrCopy(repName,Object_Name,48);
  565.    end;
  566. scanBinderyObject:=(result=0);
  567. { Possible Resultcodes:
  568.   96h server out of memory; EFh Invalid Name; FCh No Such Object;
  569.   FEh Server Bindery Locked; FFh Bindery failure                  }
  570. end;
  571.  
  572.  
  573. {F217/3D [2.15c+]}
  574. Function ReadPropertyValue( objName:String; objType:Word;
  575.                             propName:String; segmentNumber:Word;
  576.                             Var propValue   : propertyType;
  577.                             Var moreSegments: Boolean;
  578.                             Var propFlags   : Byte              ):boolean;
  579. { Returns the value of a property associated with a Bindery object.     }
  580. var req : record
  581.           len         : word;
  582.           subfunction : byte;
  583.           _objType    : word;  { hi-lo }
  584.           _ObjName    : string[48];
  585.           _segNbr     : byte;
  586.           _propName   : string[15];
  587.           end                       ABSOLUTE UnitReqBuffer;
  588.    reply : record
  589.            _propValue : propertyType; {array [1..128] of byte}
  590.            _moreSegments : byte;
  591.            _propFlags : byte;
  592.            end                      ABSOLUTE UnitReplyBuffer;
  593. BEGIN
  594.  With req
  595.  do begin
  596.     len:=SizeOf(req)-2;
  597.     subfunction  := $3d;
  598.     _objType:=swap(objType); { force hi-lo }
  599.     _segNbr:=segmentNumber;
  600.     PStrCopy(_ObjName,objName,48); _ObjName[48]:=#0; UpString(_ObjName);
  601.     PStrCopy(_PropName,propName,15); UpString(_propName);
  602.     end;
  603.  With reply
  604.  do begin
  605.     _moreSegments := 1;
  606.     _propFlags := 0;
  607.     end;
  608. F2Systemcall($17,sizeof(req),sizeof(reply));
  609. if result=0
  610.  then begin
  611.       propValue:=reply._propValue;
  612.       moreSegments:=reply._moreSegments>0;
  613.       propFlags:=reply._propFlags;
  614.       end;
  615. ReadPropertyValue:=(result=0);
  616. { 96 server out of memory; EC no such segment; F0 wilcard not allowed;
  617.   f1 invalid bindery security; f9 no property read privileges;
  618.   fb no such property; fc no such object; FE Server Bindery Locked;
  619.   FF Bindery Failure.                                                 }
  620. end;
  621.  
  622.  
  623. {F217/36 [2.15c+] }
  624. Function GetBinderyObjectName( object_Id:LongInt;
  625.                                Var objName:String; Var objType:word ):boolean;
  626. { returns the type and name of an object, given its four BYTE-id. }
  627. Var Req :record
  628.          len:word;
  629.          subF:byte;
  630.          _objId:LongInt;  { hi-lo }
  631.          end                            ABSOLUTE UnitReqBuffer;
  632.    reply:record
  633.          _objId:LongInt;  { hi-lo }
  634.          _objType:word;   { hi-lo }
  635.          _objName:array[1..48] of Byte;
  636.          end                            ABSOLUTE UnitReplyBuffer;
  637. BEGIN
  638. WITH req
  639. do begin
  640.    len :=SizeOf(Req)-2;
  641.    SubF:=$36;
  642.    _objId:=Lswap(object_Id); { force hi-lo }
  643.    end;
  644. F2SystemCall($17,sizeOf(req),sizeOf(reply));
  645. IF result=0
  646.  then begin
  647.       ZstrCopy(objName,reply._objName,48);
  648.       objType:=swap(reply._objType); { force lo-hi }
  649.       end;
  650. GetBinderyObjectName:=(result=0);
  651. end;
  652.  
  653.  
  654. {F217/35 [2.15c+] }
  655. Function GetBinderyObjectID( objName:String; objType:word;
  656.                              Var object_ID:Longint       ):boolean;
  657. { returns the object ID of an object, given its type and name.       }
  658. Var req:record
  659.          len:word;
  660.          subF:Byte;
  661.          _objType:word;   { hi-lo }
  662.          _objName:string[48];
  663.          end                       ABSOLUTE UnitReqBuffer;
  664.     Reply:record
  665.          _objId:LongInt;  { hi-lo }
  666.          _objType:word;   { hi-lo }
  667.          _objName:array[1..48] of char;
  668.          end                       ABSOLUTE UnitReplyBuffer;
  669. BEGIN
  670. WITH req
  671. do begin
  672.    len :=SizeOf(Req)-2;
  673.    SubF:=$35;
  674.    _objType:=swap(objType); { force hi-lo }
  675.    PStrCopy(_objName,objName,48); _objName[48]:=#0;
  676.    UpString(_objName);
  677.    end;
  678. F2SystemCall($17,sizeOf(req),sizeOf(reply));
  679. IF result=0 then object_ID:=Lswap(reply._objId); { force lo-hi }
  680. GetBinderyObjectID:=(result=0);
  681. end;
  682.  
  683.  
  684. {F217/46 [2.15c+]}
  685. Function getBinderyAccessLevel(Var SecurityAccessLevel:byte;
  686.                                Var objId:Longint ):boolean;
  687. { It returns the user's access level to the bindery.                      }
  688. { Often used as a quick way of determining the current users' object id   }
  689. { use the BS_xxxx constants to determine the exact rights of the user     }
  690. Var req:record
  691.         len      :word;
  692.         subF     :byte;
  693.         end                         ABSOLUTE UnitReqBuffer;
  694.     reply:record
  695.           accLeveL:byte;
  696.           _objId:longInt;
  697.           fill:array[1..20] of byte;
  698.           end                       ABSOLUTE UnitReplyBuffer;
  699. BEGIN
  700. With req
  701.  do begin
  702.     subF:=$46;
  703.     len:=sizeOf(req)-2;
  704.     end;
  705. F2SystemCall($17,sizeOf(req),sizeOf(reply));
  706. If result=0
  707.  then with reply
  708.        do begin
  709.           SecurityAccessLevel:=accLevel;
  710.           objId:=Lswap(_objId);
  711.           end;
  712. GetBinderyAccessLevel:=(result=0);
  713. end;
  714.  
  715.  
  716.  
  717. {F217/45 [2.15c+]}
  718. Function OpenBindery:boolean;
  719. { This call must be used after the CloseBindery call. No other bindery
  720.   call will work while the bindery is closed.                          }
  721. Var req  :record
  722.           len:word;
  723.           subFunc:byte;
  724.           end            ABSOLUTE UnitReqBuffer;
  725. Begin
  726. WITH req
  727. do begin
  728.    len:=1;
  729.    subFunc:=$45;
  730.    end;
  731. F2SystemCall($17,sizeOf(req),0);
  732. OpenBindery:=(result=0)
  733. end;
  734.  
  735.  
  736. {F217/44 [2.15c+]}
  737. Function CloseBindery:boolean;
  738. { Closes the bindery files so they can be backed up. (Supervisor only) }
  739. Var req  :record
  740.           len:word;
  741.           subFunc:byte;
  742.           end           ABSOLUTE UnitReqBuffer;
  743. Begin
  744. WITH req
  745. do begin
  746.    len:=SizeOf(req)-2;
  747.    subFunc:=$44;
  748.    end;
  749. F2SystemCall($17,sizeOf(req),0);
  750. CloseBindery:=(result=0)
  751. end;
  752.  
  753.  
  754. {F217/32 [2.15c+] }
  755. Function CreateBinderyObject(objName:string; objType:Word;
  756.                              objFlaG, objSecurity :Byte   ):boolean;
  757. { Creates an object in the bindery.
  758.   objName: name of the new object (47 chars)
  759.   objType: object type number (own type number or OT_xxx constant)
  760.   objFlag: identifies an object as static (0) or dynamic (1)
  761.            (dynamic objects are removed from the bindery when the server goes down)
  762.   objSecurity: high nibble: write privileges needed to modify this object
  763.                low  nibble: read privileges needed to access this object
  764.                (default: $31 Supervisor write/Logged read) }
  765. Var req  :record
  766.           len          :word;
  767.           subFunc      :byte;
  768.           _objFlag     :Byte;
  769.           _objSecurity :Byte;
  770.           _objType     :word; { hi-lo }
  771.           _objName     :string[48]
  772.           end                        ABSOLUTE UnitReqBuffer;
  773. Begin
  774. WITH req
  775. do begin
  776.    len:=SizeOf(req)-2;
  777.    subFunc:=$32;
  778.    _objFlag:=objFlag;
  779.    _objSecurity:=objSecurity;
  780.    _objType:=swap(objType); { force hi-lo }
  781.    PStrCopy(_objName,objName,48); _objName[48]:=#0; UpString(_objName);
  782.   end;
  783. F2SystemCall($17,sizeof(req),0);
  784. CreateBinderyObject:=(result=0)
  785. { 96h server out of memory; EEh Object Already Exists; EFh Invalid Name
  786.   F1h invalid Bindery security; F5h no object create privileges
  787.   FEh Server Bindery Locked; FFh Bindery Failure                        }
  788. end;
  789.  
  790.  
  791.  
  792. {F217/33 [2.15c+] }
  793. Function DeleteBinderyObject( objName:String; objType:Word ):boolean;
  794. { deletes a bindery object and all asociated properties. }
  795. Var req  :record
  796.           len      :word;
  797.           subFunc  :byte;
  798.           _objType :Word; { hi-lo }
  799.           _objName :string[48];
  800.           end                   ABSOLUTE UnitReqBuffer;
  801. Begin
  802. WITH req
  803. do begin
  804.    len:=SizeOf(req)-2;
  805.    subFunc:=$33;
  806.    _objType:=swap(objType); { force hi-lo }
  807.    PStrCopy(_objName,objName,48); _objName[48]:=#48; UpString(_objName);
  808.    end;
  809. F2SystemCall($17,sizeOf(req),0);
  810. DeleteBinderyObject:=(result=0)
  811. { 96h Server out of memory; EFh Invalid name; F0h wildcard not allowed;
  812.   F4h No object delete privileges; FCh no such object
  813.   FEh Server Bindery Locked; FFh bindery failure                        }
  814. end;
  815.  
  816.  
  817. {F217/34 [2.15c+]}
  818. Function RenameBinderyObject( objName,NewObjName :string; objType :word ):boolean;
  819. { This function allows the (supervisor-equivalent) user to rename an object,
  820.   given its' type and old name.                                              }
  821. Var req  :record
  822.           len         :word;
  823.           subFunc     :byte;
  824.           _objType    :word; { hi-lo }
  825.           _objName    :string[48];
  826.           _NewObjName :string[48];
  827.           end                       ABSOLUTE UnitReqBuffer;
  828. Begin
  829. WITH req
  830. do begin
  831.    len:=SizeOf(req)-2;
  832.    subFunc:=$34;
  833.    _objType:=swap(objType); { force hi-lo }
  834.    PstrCopy(_objName,objName,48); _objName[48]:=#0; Upstring(_objName);
  835.    PstrCopy(_NewObjName,NewObjName,48); _NewObjName[48]:=#0; UpString(_NewObjName);
  836.    end;
  837. F2SystemCall($17,sizeOf(req),0);
  838. RenameBinderyObject:=(result=0)
  839. { 96h Server out of memory; EFh Invalid name; F0h wildcard not allowed;
  840.   F3h No object rename privileges; FCh no such object
  841.   FEh Server Bindery Locked; FFh bindery failure                        }
  842. end;
  843.  
  844.  
  845.  
  846. {F217/43 [2.15c+]}
  847. Function IsBinderyObjectInSet(objName:String; objType:Word;
  848.                  propName, memberName:String; memberType:Word ):boolean;
  849. { Allows the programmer to check whether a bindery object is a member of a
  850.   set-property. Objectname( of Objecttype) is the object to be searched for,
  851.   PropName (attached to the object with name memberName (of memberType))
  852.   is the property containing the set to be searched.
  853.   User must have read rights to the object and the property.
  854.   Ex: ('SUPERVISOR',OT_USER,'GROUP_MEMBERS','EVERYONE',OT_USER_GROUP)       }
  855. Var req  :record
  856.           len         :word;
  857.           subFunc     :byte;
  858.           _objType    :Word;       { hi-lo   }
  859.           _objName    :String[48]; { [48]=#0 }
  860.           _propName   :String[15];
  861.           _memObjType :Word;       { hi-lo   }
  862.           _memName    :String[48]; { [48]=#0 }
  863.           end                      ABSOLUTE UnitReqBuffer;
  864. Begin
  865. WITH req
  866. do begin
  867.    len:=SizeOf(req)-2;
  868.    subFunc:=$43;
  869.    _objType:=swap(objType); { force hi-lo }
  870.    PstrCopy(_objName,objName,48); _objName[48]:=#0; UpString(_objName);
  871.    PstrCopy(_propName,propName,15); UpString(_propName);
  872.    _memObjType:=swap(memberType); { force hi-lo }
  873.    PStrCopy(_memName,memberName,48); _memName[48]:=#0; UpString(_memName);
  874.    end;
  875. F2SystemCall($17,sizeOf(req),0);
  876. IsBinderyObjectInSet:=(result=0)
  877. { 96h Server out of memory; EA No Such member; EB Not Group Property
  878.   F0h wildcard not allowed; F9 No Property read privileges;
  879.   FCh no such object; FEh Server Bindery Locked; FFh bindery failure        }
  880. end;
  881.  
  882.  
  883.  
  884. {F217/41 [2.15c+]}
  885. Function AddBinderyObjectToSet(objName:String; objType:Word;
  886.                   propName, memberName:String; memberType:Word ):boolean;
  887. { Adds a bindery object to a property set.
  888.   user must have write access to the set property.                        }
  889. Var req  :record
  890.           len         :word;
  891.           subFunc     :byte;
  892.           _objType    :Word;       { hi-lo   }
  893.           _objName    :String[48]; { [48]=#0 }
  894.           _propName   :String[15];
  895.           _memObjType :Word;       { hi-lo   }
  896.           _memName    :String[48]; { [48]=#0 }
  897.           end                      ABSOLUTE UnitReqBuffer;
  898. Begin
  899. WITH req
  900. do begin
  901.    len:=SizeOf(req)-2;
  902.    subFunc:=$41;
  903.    _objType:=swap(objType); { force hi-lo }
  904.    PstrCopy(_objName,objName,48); _objName[48]:=#0; UpString(_objName);
  905.    PstrCopy(_propName,propName,15); UpString(_propName);
  906.    _memObjType:=swap(memberType); { force hi-lo }
  907.    PStrCopy(_memName,memberName,48); _memName[48]:=#0; UpString(_memName);
  908.    end;
  909. F2SystemCall($17,sizeOf(req),0);
  910. AddBinderyObjectToSet:=(result=0)
  911. { 96h Server out of memory; E9 Member already Exists; EB Not Group Property
  912.   F0h wildcard not allowed; F8 No Property write privileges;
  913.   FCh no such object; FEh Server Bindery Locked; FFh bindery failure        }
  914. end;
  915.  
  916.  
  917. {F217/42 [2.0/2.1/3.x]}
  918. Function DeleteBinderyObjectFromSet(objName:String; objType:Word;
  919.                        propName, memberName:String; memberType:Word ):boolean;
  920. { Deltes a bindery object from a property set.
  921.   user must have write access to the set property.                        }
  922. Var req  :record
  923.           len         :word;
  924.           subFunc     :byte;
  925.           _objType    :Word;       { hi-lo   }
  926.           _objName    :String[48]; { [48]=#0 }
  927.           _propName   :String[15];
  928.           _memObjType :Word;       { hi-lo   }
  929.           _memName    :String[48]; { [48]=#0 }
  930.           end                       ABSOLUTE UnitReqBuffer;
  931. Begin
  932. WITH req
  933. do begin
  934.    len:=SizeOf(req)-2;
  935.    subFunc:=$42;
  936.    _objType:=swap(objType); { force hi-lo }
  937.    PstrCopy(_objName,objName,48); _objName[48]:=#0; UpString(_objName);
  938.    PstrCopy(_propName,propName,15); UpString(_propName);
  939.    _memObjType:=swap(memberType); { force hi-lo }
  940.    PStrCopy(_memName,memberName,48); _memName[48]:=#0; UpString(_memName);
  941.    end;
  942. F2SystemCall($17,sizeOf(req),0);
  943. DeleteBinderyObjectFromSet:=(result=0)
  944. { 96h Server out of memory; EA No Such Member; EB Not Group Property
  945.   F0h wildcard not allowed; F8 No Property write privileges; FB No Such property;
  946.   FCh no such object; FEh Server Bindery Locked; FFh bindery failure        }
  947. end;
  948.  
  949.  
  950. {F217/38 [2.15c+]}
  951. Function ChangeBinderyObjectSecurity(objName :String; objType :Word;
  952.                                      NewObjSecurity :Byte           ):boolean;
  953. { Changes the security of a Bindery object. This call is made successfully,
  954.   if the user is supervisor equivalent and the current security is unequal to
  955.   NetWare Read/ NetWare Write.                                              }
  956. Var req  :record
  957.           len      :word;
  958.           subFunc  :byte;
  959.           _NobjSec :Byte;
  960.           _objType :Word; { hi-lo }
  961.           _objName :String[48]; { [48]=#0 }
  962.           end                     ABSOLUTE UnitReqBuffer;
  963. Begin
  964. WITH req
  965. do begin
  966.    len:=SizeOf(req)-2;
  967.    subFunc:=$38;
  968.    _NobjSec:=NewObjSecurity;
  969.    _objType:=swap(objType); { force hi-lo }
  970.    PstrCopy(_objName,objName,48); _objName[48]:=#0; UpString(_objName);
  971.    end;
  972. F2SystemCall($17,sizeOf(req),0);
  973. ChangeBinderyObjectSecurity:=(result=0)
  974. { Completion Codes:
  975.   96 Server out of memory; F0 Wildcard Not Allowed; F1 Invalid Bindery Security;
  976.   FC No Such Object; FE Server Bindery Locked; FF Bindery Failure.           }
  977. end;
  978.  
  979.  
  980.  
  981.  
  982. {F217/40 [2.0/2.1/3.x] }
  983. Function ChangeBinderyObjectPassword(objName:String; objType:Word;
  984.                                   oldPassWord,newPassWord:String ):boolean;
  985. { Changes the password of a bindery object.
  986.   Allow unencrypted passwords must be ON!
  987.   Old Password can be NULL. To log into a file server, an object must have a
  988.   PASSWORD property. User must have read and write access to the bindery object. }
  989. Var req  :record
  990.           len      :word;
  991.           subFunc  :byte;
  992.           _objType :Word;        { hi-lo }
  993.           _objName :String[48];  { [48]=#0 }
  994.           _oldPW   :String[128]; { wow! a password of 128 chars! }
  995.           _newPW   :String[128];
  996.           end                     ABSOLUTE UnitReqBuffer;
  997. Begin
  998. WITH req
  999. do begin
  1000.    len:=SizeOf(req)-2;
  1001.    subFunc:=$40;
  1002.    _objType:=swap(objType); { force hi-lo }
  1003.    PStrCopy(_objName,objName,48); _ObjName[48]:=#0; UpString(_objName);
  1004.    PStrCopy(_oldPW,oldPassWord,128); UpString(_oldPW);
  1005.    PStrCopy(_newPW,newPassWord,128); UpString(_newPW);
  1006.    end;
  1007. F2SystemCall($17,sizeOf(req),0);
  1008. ChangeBinderyObjectPassword:=(result=0)
  1009. { Completion Codes:
  1010.   96 Server Out Of Memory; F0 Wildcard Not Allowed; FB No Such Property;
  1011.   FC No Such Object; FE Server Bindery Locked; FF No Such Object *OR*
  1012.   No Password Associated With Object *OR* Old Password Invalid.           }
  1013. end;
  1014.  
  1015.  
  1016.  
  1017.  
  1018. {F217/39 [2.15c+]}
  1019. Function CreateProperty( objName:String; objType:Word;
  1020.                     propertyName:String; propFlags,propSecurity:Byte ):boolean;
  1021. { Creates a property to be associated with a bindery object.
  1022.   property flags tell whether a property is dynamic or static and whether
  1023.   the property is defined as static or dynamic.                            }
  1024. Var req  :record
  1025.           len       :word;
  1026.           subFunc   :byte;
  1027.           _objType  :Word;       { hi-lo }
  1028.           _objName  :String[48]; { [48]=#0 }
  1029.           _propFlags:Byte;
  1030.           _propSec  :Byte;
  1031.           _propName :String[15];
  1032.           end                      ABSOLUTE UnitReqBuffer;
  1033. Begin
  1034. WITH req
  1035. do begin
  1036.    len:=SizeOf(req)-2;
  1037.    subFunc:=$39;
  1038.    _objType:=swap(objType); { force hi-lo }
  1039.    PStrCopy(_objName,objName,48); _objName[48]:=#0; UpString(_objName);
  1040.    _propFlags:=propFlags;
  1041.    _propSec:=propSecurity;
  1042.    PStrCopy(_propName,propertyName,15); UpString(_propName);
  1043.    end;
  1044. F2SystemCall($17,sizeof(req),0);
  1045. CreateProperty:=(result=0)
  1046. { Completion Codes:
  1047.   96 Server Out Of Memory; ED Property already exists; EF Invalid Name;
  1048.   F0 Wildcard Not Allowed; F1 Invalid Bindery Security; F7 No Property Create Privileges;
  1049.   FC No Such Object; FE Server Bindery Locked; FF Bindery Failure           }
  1050. end;
  1051.  
  1052.  
  1053. {F217/3A [2.15c+]}
  1054. Function DeleteProperty( objName:String; objType:Word;
  1055.                          propertyName:String          ):boolean;
  1056. { Deletes a property from a bindery object.
  1057.   The property field may contain wildcards.                                 }
  1058. Var req  :record
  1059.           len       :word;
  1060.           subFunc   :byte;
  1061.           _objType  :Word;       { hi-lo }
  1062.           _objName  :String[48]; { [48]=#0 }
  1063.           _propName :String[15];
  1064.           end                    ABSOLUTE UnitReqBuffer;
  1065. Begin
  1066. WITH req
  1067. do begin
  1068.    len:=SizeOf(req)-2;
  1069.    subFunc:=$3A;
  1070.    _objType:=swap(objType); { force hi-lo }
  1071.    PStrCopy(_objName,objName,48); _objName[48]:=#0; UpString(_objName);
  1072.    PStrCopy(_propName,propertyName,15); UpString(_propName);
  1073.    end;
  1074. F2SystemCall($17,sizeOf(req),0);
  1075. DeleteProperty:=(result=0)
  1076. { Completion Codes:
  1077.   96 Server Out Of Memory; F0 Wildcard Not Allowed; F1 Invalid Bindery Security;
  1078.   F6 No property delete privileges; FB No Such property;
  1079.   FC No Such Object; FE Server Bindery Locked; FF Bindery Failure           }
  1080. end;
  1081.  
  1082.  
  1083. {F217/3C [2.15c+]}
  1084. Function ScanProperty( objName:String; objType:Word; searchPropName:String;
  1085.             {i/o var:} Var SequenceNumber:LongInt;
  1086.             { output:} Var propName:String;
  1087.                        Var propFlags:Byte;
  1088.                        Var propSecurity:Byte;
  1089.                        Var propHasValue:Boolean;
  1090.                        Var moreProperties:Boolean  ):boolean;
  1091. { Sequence number should be -1 the first time this call is made.
  1092.   The call can be reiterated (by supplying the returned Seq.#) until
  1093.   moreProperties=FALSE or nwBindry.Result=NO_SUCH_PROPERTY.
  1094.   searchPropName may contain wildcards;
  1095.   If propHasValue=TRUE, the value can be read by calling ReadPropertyValue;
  1096.   moreProperties=TRUE if more properties exist for this object.            }
  1097. Var req  :record
  1098.           len       :word;
  1099.           subFunc   :byte;
  1100.           _objType  :Word;    {hi-lo}
  1101.           _objName  :String[48];
  1102.           _SeqNbr   :LongInt; {hi-lo}
  1103.           _propName :String[15];
  1104.           end                    ABSOLUTE UnitReqBuffer;
  1105.     reply:record
  1106.           _propName :array[1..16] of Byte;
  1107.           _propFlags:Byte;
  1108.           _propSec  :Byte;
  1109.           _SeqNbr   :Longint; {hi-lo}
  1110.           _propHasValue:Byte;
  1111.           _moreProp :Byte;
  1112.           end                   ABSOLUTE UnitReplyBuffer;
  1113. Begin
  1114. WITH req
  1115. do begin
  1116.    len:=SizeOf(req)-2;
  1117.    subFunc:=$3C;
  1118.    _objType:=swap(objType); { force hi-lo }
  1119.    PStrCopy(_objName,objName,48); _objName[48]:=#0; UpString(_objName);
  1120.    _SeqNbr:=Lswap(SequenceNumber); { force hi-lo }
  1121.    PstrCopy(_propName,searchPropName,15); UpString(_propName);
  1122.    end;
  1123. F2SystemCall($17,sizeof(req),sizeof(reply));
  1124. With reply
  1125. do begin
  1126.    SequenceNumber:=Lswap(_SeqNbr); { force lo-hi }
  1127.    ZStrCopy(propName,_propName,15);
  1128.    propFlags:=_propFlags;
  1129.    propSecurity:=_propSec;
  1130.    propHasValue:=(_propHasValue>0);
  1131.    moreProperties:=(_moreProp>0);
  1132.    end;
  1133. ScanProperty:=(result=0)
  1134. { Completion Codes:
  1135.   96 Server Out Of Memory; F1 Invalid Bindery Security; FB No Such property;
  1136.   FC No Such Object; FE Server Bindery Locked; FF Bindery Failure           }
  1137. end;
  1138.  
  1139.  
  1140. {F217/3E [2.15c+]}
  1141. Function WritePropertyValue( objName:String; objType:Word;
  1142.                    propName:String; segmentNbr: Byte; propValue:propertyType;
  1143.                    moreSegments:Boolean                   ):boolean;
  1144. { Changes the value of a (NON-SET) property associated with a Bindery object.}
  1145. Var req  :record
  1146.           len         :word;
  1147.           subFunc     :byte;
  1148.           _objType    :Word; { hi-lo }
  1149.           _objName    :String[48];
  1150.           _segNbr     :Byte;
  1151.           _EraseRemainingSeg:Byte; { FF=true 00=false }
  1152.           _propName   :String[15];
  1153.           _propValSeg :propertyType;
  1154.           end                        ABSOLUTE UnitReqBuffer;
  1155. Begin
  1156. WITH req
  1157. do begin
  1158.    len:=SizeOf(req)-2;
  1159.    subFunc:=$3E;
  1160.    _objType:=swap(objType); { force hi-lo }
  1161.    PStrCopy(_objName,objName,48); _objName[48]:=#0; UpString(_objName);
  1162.    _segNbr:=segmentNbr;
  1163.    if moreSegments
  1164.      then _EraseRemainingSeg:=$00
  1165.      else _EraseRemainingSeg:=$FF;
  1166.    PstrCopy(_propName,propName,15); UpString(_propName);
  1167.    _propValSeg:=propValue;
  1168.    end;
  1169. F2SystemCall($17,sizeOf(req),0);
  1170. WritePropertyValue:=(result=0)
  1171. { Completion Codes:
  1172.   96 Server Out Of Memory; E8 Not Item Property; EC no such segment;
  1173.   F0 Wildcard Not Allowed; F1 Invalid Bindery Security;
  1174.   F8 No property write privileges; FB No Such property;
  1175.   FC No Such Object; FE Server Bindery Locked; FF Bindery Failure           }
  1176. end;
  1177.  
  1178. {F217/3B [2.15c+] }
  1179. Function ChangePropertySecurity( objName:String; objType:Word;
  1180.                                 propName:String; newPropSecurity:Byte ):boolean;
  1181. { The user must have read and write access to the property to make this call.
  1182.   The call can't assign a greater security level than the security level of
  1183.   the caller.                                                               }
  1184. Var req  :record
  1185.           len:word;
  1186.           subFunc:byte;
  1187.           _objType:Word; { hi-lo }
  1188.           _objName:String[48];
  1189.           _NewPropSec:Byte;
  1190.           _PropName:String[15];
  1191.           end                   ABSOLUTE UnitReqBuffer;
  1192. Begin
  1193. WITH req
  1194. do begin
  1195.    len:=SizeOf(req)-2;
  1196.    subFunc:=$3B;
  1197.    _objType:=swap(objType); { force hi-lo }
  1198.    PstrCopy(_objName,objName,48); _objName[48]:=#0; Upstring(_objName);
  1199.    _NewPropSec:=NewPropSecurity;
  1200.    PstrCopy(_propName,propName,15); Upstring(_propName);
  1201.    end;
  1202. F2SystemCall($17,sizeOf(req),0);
  1203. ChangePropertySecurity:=(result=0)
  1204. { Completion Codes:
  1205.   96 Server Out Of Memory; F0 Wildcard Not Allowed; F1 Invalid Bindery Security;
  1206.   FB No Such property;  FC No Such Object; FE Server Bindery Locked;
  1207.   FF Bindery Failure                                                         }
  1208. end;
  1209.  
  1210.  
  1211.  
  1212. {=======SECONDARY FUNCTIONS===================================================}
  1213.  
  1214.  
  1215.  
  1216. Function IsShellLoaded:boolean;
  1217. Var mask:byte;
  1218.     id:LongInt;
  1219. begin
  1220. IsShellLoaded:=( nwBindry.getBinderyAccessLevel(mask,id) and (id<>0));
  1221. end;
  1222.  
  1223.  
  1224. Function IsUserLoggedOn:boolean;
  1225. Var mask:byte;
  1226.     id:LongInt;
  1227.     objName:String;
  1228.     objType:word;
  1229. begin
  1230. IsUserLoggedOn:=( nwBindry.getBinderyAccessLevel(mask,id)
  1231.                   and (id<>0)
  1232.                   and nwBindry.GetBinderyObjectName(id,objName,objType)
  1233.                 )
  1234. end;
  1235.  
  1236.  
  1237. Function GetRealUserName(userObjName:string; Var realname:string):boolean;
  1238. Var propValue:propertyType;
  1239.     moreSeg:Boolean;
  1240.     w,propFlag:Byte;
  1241. begin
  1242. If ReadPropertyValue(userObjName,OT_USER,'IDENTIFICATION',1,propValue,moreSeg,propFlag)
  1243.  then begin
  1244.       ZStrCopy(realname,propValue,128);
  1245.       w:=1;
  1246.       While ((w<=128) and (realname[w]<>#0)) do inc(w);
  1247.       realName[0]:=chr(w);
  1248.       end
  1249.  else realname:='';
  1250. end;
  1251.  
  1252. Function GetUserObjectID:LongInt;
  1253. Var mask:byte;
  1254.     id:LongInt;
  1255. begin
  1256. if getBinderyAccessLevel(mask,id)
  1257.  then GetUserObjectID:=id
  1258.  else getUserObjectID:=-1;
  1259. { -1 : look at nwBindry.result for error number }
  1260. end;
  1261.  
  1262.  
  1263. Function ExistsUser(userObjName:string):boolean;
  1264. Var nam:string;
  1265.     typ:word;
  1266.     id:LongInt;
  1267.     f,s:byte;
  1268.     hasProp:boolean;
  1269.     lastObjSeen:LongInt;
  1270. begin
  1271. lastObjSeen:=-1;
  1272. ExistsUser:=scanBinderyObject(userObjName,OT_USER,lastObjSeen,nam,typ,id,f,s,hasProp);
  1273. end;
  1274.  
  1275. Function IsGroupMember( GroupName,UserObjName:String): Boolean;
  1276. begin
  1277. IsGroupMember:=IsBinderyObjectInSet(GroupName,OT_USER_GROUP,'GROUP_MEMBERS',
  1278.                                     UserObjName,OT_USER);
  1279. end;
  1280.  
  1281.  
  1282.  
  1283.  
  1284. Function AddUserToGroup(userName,GroupName:String):boolean;
  1285. begin
  1286. { first create the necessary properties. They may already exist. }
  1287.  
  1288. CreateProperty(userName,OT_USER,'GROUPS_I''M_IN',
  1289.                BF_SET,BS_SUPER_WRITE OR BS_LOGGED_READ);
  1290. IF (result<>$00) and (result<>$ED) { property already exists }
  1291. then begin AddUserToGroup:=false;exit end; { bindery failure / bad username}
  1292.  
  1293. CreateProperty(userName,OT_USER,'SECURITY_EQUALS',
  1294.                BF_SET,BS_SUPER_WRITE OR BS_LOGGED_READ);
  1295. IF (result<>$00) and (result<>$ED) { property already exists }
  1296. then begin AddUserToGroup:=false;exit end;
  1297.  
  1298. { The following construction seems a bit overdone, but it is needed to keep
  1299.   the bindery consistent. A user is either fully added to a group OR
  1300.   nothing happens, this way we ensure that a user is not 'patially added'
  1301.   to a group.
  1302.   If the user already is a member of the group, no error is returned. }
  1303. IF AddBinderyObjectToSet(Groupname,OT_USER_GROUP,'GROUP_MEMBERS',
  1304.                          userName,OT_USER)
  1305.  then begin
  1306.       IF AddBinderyObjectToSet(userName,OT_USER,'GROUPS_I''M_IN',
  1307.                                GroupName,OT_USER_GROUP)
  1308.        then begin
  1309.             IF AddBinderyObjectToSet(userName,OT_USER,'SECURITY_EQUALS',
  1310.                                      GroupName,OT_USER_GROUP)
  1311.              then begin
  1312.                   AddUserToGroup:=true;
  1313.                   exit;
  1314.                   end
  1315.              else begin { attempt to delete partially setup member }
  1316.                   DeleteBinderyObjectFromSet(Groupname,OT_USER_GROUP,'GROUP_MEMBERS',
  1317.                                              userName,OT_USER);
  1318.                   DeleteBinderyObjectFromSet(userName,OT_USER,'GROUPS_I''M_IN',
  1319.                                              GroupName,OT_USER_GROUP)
  1320.                   end
  1321.             end
  1322.        else begin
  1323.             DeleteBinderyObjectFromSet(Groupname,OT_USER_GROUP,'GROUP_MEMBERS',
  1324.                                        userName,OT_USER);
  1325.             end;
  1326.       end;
  1327. if result=$E9 then result:=$00; { $E9: user already a member of group }
  1328. AddUserToGroup:=(result=0);
  1329. { As all these called functions are in this unit, you can check nwBindry.result
  1330.   for the errorcode. }
  1331. { resultcodes: $FC user OR group object doesn't exist. }
  1332. end;
  1333.  
  1334.  
  1335.  
  1336.  
  1337. Function DeleteUserFromGroup(userName,GroupName:String):boolean;
  1338. begin
  1339. { The following construction seems a bit overdone, but it is needed to keep
  1340.   the bindery consistent. A user is either totally deleted from a group OR
  1341.   nothing happens, this way we ensure that a user is not 'patially deleted'
  1342.   from a group.
  1343.   If the user was not a member of the group, no error is returned. }
  1344. IF DeleteBinderyObjectFromSet(Groupname,OT_USER_GROUP,'GROUP_MEMBERS',
  1345.                               userName,OT_USER)
  1346.  then begin
  1347.       IF DeleteBinderyObjectFromSet(userName,OT_USER,'GROUPS_I''M_IN',
  1348.                                     GroupName,OT_USER_GROUP)
  1349.        then begin
  1350.             IF DeleteBinderyObjectFromSet(userName,OT_USER,'SECURITY_EQUALS',
  1351.                                           GroupName,OT_USER_GROUP)
  1352.              then begin
  1353.                   DeleteUserFromGroup:=True;
  1354.                   exit;
  1355.                   end
  1356.              else begin { attempt to repair partially deleted member }
  1357.                   AddBinderyObjectToSet(Groupname,OT_USER_GROUP,'GROUP_MEMBERS',
  1358.                                         userName,OT_USER);
  1359.                   AddBinderyObjectToSet(userName,OT_USER,'GROUPS_I''M_IN',
  1360.                                         GroupName,OT_USER_GROUP)
  1361.                   end
  1362.             end
  1363.        else AddBinderyObjectToSet(Groupname,OT_USER_GROUP,'GROUP_MEMBERS',
  1364.                                   userName,OT_USER);
  1365.       end;
  1366. if result=$EA then result:=0; { $EA: user obj NOT a member of group }
  1367. DeleteUserFromGroup:=false;
  1368. { As all these called functions are in this unit, you can check nwBindry.result
  1369.   for the errorcode. }
  1370. { Resultcodes: $FC user OR group object doesn't exist.   }
  1371. end;
  1372.  
  1373.  
  1374. end. { end of unit nwBindry }
  1375.  
  1376.