home *** CD-ROM | disk | FTP | other *** search
/ Magazyn Internet 2000 May / MICD_2000_05.iso / CBuilder5 / INSTALL / DATA1.CAB / Program_Built_Files / Include / smsapi.h < prev    next >
C/C++ Source or Header  |  2000-02-01  |  75KB  |  1,774 lines
  1. // **************************************************************************
  2. //
  3. //  File: SMSAPI.H
  4. //
  5. //  Copyright (c) 1994, 1995 Microsoft Corp.
  6. //
  7. //  This is the header file for the SMS API.
  8. //
  9. //  This file contains all data definitions, manifests, return codes and
  10. //  API declarations that constitute the API set.
  11. //
  12. //
  13. // **************************************************************************
  14.  
  15.  
  16.  
  17. // **************************************************************************
  18. //
  19. //  The SMS API set provides a set of interfaces to enable querying and,
  20. //  in some cases creation and deletion, of data from an SMS database.
  21. //
  22. //  SMS contains numerous objects to which an ISV needs access. These objects
  23. //  are (not in any particular order): packages, jobs, workstation command
  24. //  lines, program items, sites, domains, machines, machine groups.
  25. //
  26. //  The SMS API is built using a technology known as the objectity technique.
  27. //  This technique expresses all objects in terms of containers, folders,
  28. //  and scalars. All SMS objects are thus expressed in these terms.
  29. //  The advantage of this is that we have a standard interface to all
  30. //  objects. That is, the API does not distinguish between, say, a job and
  31. //  a machine.
  32. //
  33. //  The starting point is the container. There are certain types of container
  34. //  defined (container types below). A container is opened and then
  35. //  populated. The act of populating a container causes it to be filled with
  36. //  folders of defned types. A folder can contain sub-folders and scalars.
  37. //  Scalars are akin to leaf nodes in a hierarchy graph. The contain a
  38. //  name, type, and value.
  39. //
  40. //  Much of the power to the objectity technique is provided by filters.
  41. //  These are objects which specify selection criteria. Filters are applied
  42. //  by the user at the container level, at which point the implementation of
  43. //  the API will assume ownership of the filter. It is guaranteed that only
  44. //  folders matching the filters will be included in the container hierarchy.
  45. //
  46. //  Every folder can contain a set of scalars. Not all folders do, for
  47. //  example a machine folder does not. In some cases a folder contains a
  48. //  defined set of scalars, in other cases the scalar set can only be
  49. //  determined at run time. In cases where the scalar set is predetermined
  50. //  it will be documented in supporting documentation.
  51. //
  52. //  The APIs behave in a uniform manner.
  53. //  1. They all return a status code (SMS_STATUS).
  54. //  2. Where a value needs to be returned, it is done via a reference
  55. //     parameter.
  56. //
  57. //  An API is provided to determine the API version. Any problems involving
  58. //  the SMS API should include the information provided by this API.
  59. //
  60. //  The first step in using the APIs to to establish a connection to a
  61. //  datasource. Currently the only datasource supported in SQL, but the
  62. //  API is designed in such a way that additional datasources can be
  63. //  added. Two APIs are provided for dealing with datasources:
  64. //  DataSourceConnect and DataSourceDisonnect. The connect API returns a
  65. //  connection handle, this is used in subsequent calls to open containers.
  66. //
  67. //  Apart from these APIs, the rest of the API set is divided into four
  68. //  groups:
  69. //  1. Container APIs.
  70. //  2. Folder APIs.
  71. //  3. Scalar APIs.
  72. //  4. Filter APIs.
  73. //
  74. //  1. Container APIs.
  75. //  These allow a container to be opened, a filter to be applied to a
  76. //  container, a container to be populated with folders, a folder to be
  77. //  retrieved, and the container to be closed. An API also exists to
  78. //  return the number of folders currently contained in a container.
  79. //
  80. //  2. Folder APIs.
  81. //  These allow a for retrieval of various types of information about a
  82. //  folder (its ID or name, its type, the number of sub-folders, the number
  83. //  of scalars). Retrieval of sub-folders within a folder in both a
  84. //  sequential fashion and by name. Retrieval of scalars (sequential and by
  85. //  name. And closure of the folder.
  86. //  An API exists to allow folder creation. However, this is implementation
  87. //  dependant. That is, most folders do not permit creation, some (eg
  88. //  ceratin types of jobs) do.
  89. //
  90. //  3. Scalar APIs.
  91. //  There is a bit of overlap between this and the previous group. Although
  92. //  scalar retrieval is included in the Folder API group, it can also be
  93. //  considered a scalar API.
  94. //  An API is provided to set/update the value of a scalar. This can
  95. //  currently only be done in a folder that is being newly created.
  96. //
  97. //  4. Filter APIs.
  98. //  APIs for opening and closing a filter, and adding tokens into a filter.
  99. //  Filters are composed of one or more tokens of the same type. Some filters
  100. //  permit grouping of tokens within the filter (ie machine filter). This
  101. //  allows for complex boolean expressions.
  102. //  Tokens differ between different filters, but have a common interface.
  103. //  Tokens are contructed via the SmsAddToken API.
  104. //
  105. //  5. Filter container APIs
  106. //  Certain filters can be persistent, that is they are saved in the database
  107. //  and can be reloaded by separate processes. These filters can be created
  108. //  either the APIs, or via the SMS Admin.
  109. //   These APIs enable the retrieval of these filters from the datasource
  110. //  and the commital of new filters into the datasource.
  111. //  Currently machine filters are the only filters capable of exhibiting
  112. //  persistence.
  113. //
  114. // **************************************************************************
  115.  
  116.  
  117. #ifndef _SMSAPI_H_
  118. #pragma option push -b -a8 -pc -A- /*P_O_Push*/
  119. #define _SMSAPI_H_
  120.  
  121.  
  122.  
  123. // ====================================================================
  124. //
  125. //  Includes
  126. //
  127. // ====================================================================
  128.  
  129. #include <qrycodes.h>           // The query codes for Machine queries.
  130.  
  131. #include <smsinfo.h>            // Manifests related to scalar settings.
  132.  
  133. #include <objectty.h>           // Objectity engine.
  134.  
  135.  
  136. #ifdef __cplusplus
  137. extern "C" {
  138. #endif
  139.  
  140.  
  141.  
  142. // ====================================================================
  143. //
  144. //  Datasource definition information.
  145. //
  146. // ====================================================================
  147.  
  148. //
  149. // Supported datasources.
  150. // (NOTE: only sql supported currently).
  151. //
  152. typedef enum { DB_SQL, DB_SQL_CONNECTED, DB_OTHER } DATASOURCE_TYPE;
  153.  
  154.  
  155. //
  156. // Prototype for a decryption function. This is the last parameter
  157. // to the SQL_CONNECT_PARAMS structure.
  158. // When a user calls the DataSourceConnect API he can pass in the
  159. // user name and password in encrypted form. If the decryption function
  160. // pointer is non-null the the API will attempt to call this function
  161. // both for the user name and password.
  162. // The decryption function is user-supplied, it is expected to return
  163. // the decrypted data in the first parameter.
  164. //
  165.  
  166. typedef void (*PDECRYPTFUNC)(char *pszBuffer, char *pszDecryptMe, char *pszKey);
  167.  
  168.  
  169. //
  170. //  The information block needed for the DataSourceConnect API.
  171. //  1. SQL datasource.
  172. //
  173.  
  174. typedef struct _SQL_CONNECT_PARAMS {
  175.     DATASOURCE_TYPE ds;
  176.     char *pszServer;                    // SQL Server name.
  177.     char *pszUserName;                  // User name (possibly encrypted).
  178.     char *pszPasswd;                    // Password (possibly encrypted).
  179.     char *pszDbName;                    // Database name.
  180.     char *pszKey;                       // Decryption key.
  181.     PDECRYPTFUNC pFunc;                 // Pointer to a decryption function.
  182. } SQL_CONNECT_PARAMS;
  183.  
  184.  
  185. //
  186. //  2. RESERVED DO NOT USE
  187. //
  188.  
  189. typedef struct _SQL_CONNECT_CONNECTED_PARAMS {
  190.     DATASOURCE_TYPE ds;
  191.     HANDLE hDataSource;
  192.     const char *pszAccessType;
  193. } SQL_CONNECT_CONNECTED_PARAMS;
  194.  
  195.  
  196.  
  197. //
  198. // This only has the type field. It is used for extracting the type
  199. // in such a fashion that user code doesn't have to imply any
  200. // particular data source. It has no use other than that.
  201. //
  202.  
  203. typedef struct _GENERIC {
  204.     DATASOURCE_TYPE ds;
  205. } GENERIC;
  206.  
  207.  
  208.  
  209. // We can now define the DATASOURCE. It is a union of the structs above.
  210. typedef union {
  211.     GENERIC             type;
  212.     SQL_CONNECT_PARAMS  sqlParams;
  213.     SQL_CONNECT_CONNECTED_PARAMS sqlConnectedParams;
  214. } DATASOURCE;
  215.  
  216.  
  217.  
  218.  
  219.  
  220. // ====================================================================
  221. //
  222. //  Return codes. See also objectty.h.
  223. //
  224. // ====================================================================
  225. typedef DWORD SMS_STATUS;           // All APIs return an SMS_STATUS.
  226.  
  227. #define SMS_OK                          OTT_OK
  228. #define SMS_MORE_DATA                   OTT_MORE_DATA
  229. #define SMS_NO_MORE_DATA                OTT_NO_MORE_DATA
  230. #define SMS_FOLDER_NO_UPDATE            OTT_FOLDER_NO_UPDATE
  231.  
  232. // Error codes when registering (and accessing) containers and filters
  233. #define SMS_DUPLICATE_CONTAINER_ID      OTT_DUPLICATE_CONTAINER_ID
  234. #define SMS_DUPLICATE_FOLDER_ID         OTT_DUPLICATE_FOLDER_ID
  235. #define SMS_DUPLICATE_FILTER_ID         OTT_DUPLICATE_FILTER_ID
  236.  
  237. #define SMS_DUPLICATE_FILTER            OTT_DUPLICATE_FILTER
  238.  
  239. #define SMS_SCALAR_NO_UPDATE            OTT_SCALAR_NO_UPDATE
  240. #define SMS_SCALAR_WRONG_TYPE           OTT_SCALAR_WRONG_TYPE
  241. #define SMS_INVALID_CONTAINER_ID        OTT_INVALID_CONTAINER_ID
  242. #define SMS_INVALID_FOLDER_ID           OTT_INVALID_FOLDER_ID
  243. #define SMS_INVALID_FILTER_ID           OTT_INVALID_FILTER_ID
  244.  
  245. #define SMS_CONTAINER_NO_UPDATE         OTT_CONTAINER_NO_UPDATE
  246.  
  247. #define SMS_PARAMETER_ERROR             OTT_PARAMETER_ERROR
  248. #define SMS_UNSUPPORTED                 OTT_UNSUPPORTED
  249.  
  250. // This is returned when a specific object
  251. // (folder or scalar) is requested and not
  252. // found. APIs returning this are GetFolderByID
  253. // and GetScalarByName.
  254. #define SMS_NOT_FOUND                   OTT_NOT_FOUND
  255.  
  256. #define SMS_PARENT_NOT_FOUND            OTT_PARENT_NOT_FOUND
  257.  
  258. #define SMS_CANT_DELETE                 OTT_CANT_DELETE
  259.  
  260. #define SMS_NEW_FOLDER                  OTT_NEW_FOLDER
  261.  
  262. // Error when attempting to multiply
  263. // link a folder.
  264. #define SMS_FOLDER_LINKED               OTT_FOLDER_LINKED
  265.  
  266. // Filter operations.
  267. #define SMS_RANGE_ERROR                 OTT_RANGE_ERROR
  268.  
  269. // These are returned when a container
  270. // operation is tried when it shouldn't be.
  271. #define SMS_CONTAINER_NOT_POPULATED     OTT_CONTAINER_NOT_POPULATED
  272. #define SMS_CONTAINER_POPULATED         OTT_CONTAINER_POPULATED
  273.  
  274.  
  275. // Attempt to perform persistent operation
  276. // on a non-persistent filter.
  277. #define SMS_FILTER_NOT_PERSISTENT       OTT_FILTER_NOT_PERSISTENT
  278.  
  279. // Error return if the connection handle
  280. // of a filter doesn't match that of a
  281. // container to which the filter is being
  282. // applied.
  283. #define SMS_INVALID_CONNECTION_HANDLE   OTT_INVALID_CONNECTION_HANDLE
  284. #define SMS_INVALID_FILTER_TYPE         OTT_INVALID_FILTER_TYPE
  285.  
  286. // Folder's can't be unlinked if there are multiple handles
  287. // to the same object.
  288. #define SMS_IN_USE_BY_OTHER             OTT_IN_USE_BY_OTHER
  289.  
  290. // User (ie non-engine) codes begin here.
  291. #define SMS_ERROR                       (OTT_END + 1)
  292. #define SMS_SQL_ERROR                   (OTT_END + 2)
  293. #define SMS_INVALID_DATASOURCE          (OTT_END + 3)
  294. #define SMS_INVALID_HANDLE              (OTT_END + 4)
  295. #define SMS_INVALID_FOLDER_TYPE         (OTT_END + 6)
  296.  
  297. #define SMS_CONNECT_FAILED              (OTT_END + 7)
  298. #define SMS_NO_CREATE                   (OTT_END + 8)
  299. #define SMS_FOLDER_NOT_MODIFIED         (OTT_END + 9)
  300. #define SMS_INCORRECT_FOLDER_TYPE       (OTT_END + 10)  // Unused.
  301. #define SMS_INVALID_PARAMETER           (OTT_END + 11)
  302. #define SMS_EMPTY                       (OTT_END + 12)
  303.  
  304. // Return when commiting a child folder
  305. // and the parent folder must be committed.
  306. #define SMS_PARENT_NEEDS_COMMIT         (OTT_END + 13)
  307. #define SMS_PARENT_ALREADY_COMMITTED    (OTT_END+ 14)
  308.  
  309. // Used in asynchronous folder retrieval.
  310. // Indicates that there might be more
  311. // data but it isn't available yet.
  312. #define SMS_NOT_READY                   (OTT_END + 15)
  313.  
  314. #define SMS_FILTER_NO_MODIFY            (OTT_END + 16)
  315. #define SMS_FOLDER_ALREADY_DELETED      (OTT_END + 17)
  316.  
  317. // Only allow one active connection.
  318. // This is an SMS restriction.
  319. #define SMS_ALREADY_CONNECTED           (OTT_END + 18)
  320.  
  321. // Some failure in committing a folder
  322. #define SMS_COMMIT_FAILED               (OTT_END + 19)
  323.  
  324.  
  325. // Specific failure in linking a folder
  326. #define SMS_DUPLICATE_FOLDER            (OTT_END + 20)
  327.  
  328.  
  329. // ====================================================================
  330. //
  331. //  Various manifests.
  332. //
  333. // ====================================================================
  334.  
  335. // The location of the SMS registry root.
  336. #define SMS_REG_ROOT "SOFTWARE\\Microsoft\\SMS\\"
  337.  
  338. // The max size of character (string) data that we return.
  339. #define SMS_DATA_BUFF_SIZE  255
  340.  
  341.  
  342. // 'SMSBUFF' and 'OBJDESCRIPTOR' used in object type enumeration APIs.
  343. // ===================================================================
  344.  
  345. // A character buffer.
  346. // -------------------
  347. typedef char SMSBUFF[SMS_DATA_BUFF_SIZE+1];
  348.  
  349. // Describes an object returned from SmsEnumObjects.
  350. // -------------------------------------------------
  351. typedef struct _OBJDESCRIPTOR {
  352.     DWORD objType;                  // Type of this object.
  353.     SMSBUFF szName;                 // Object name (eg 'Personal Computer')
  354.     SMSBUFF szFriendlyName;         // Friendly name. Only used in groups
  355.                                     // where szName would be, eg,
  356.                                     // 'MICROSOFT|IDENTIFICATION|1.0', the
  357.                                     // friendly name would be 'Identification'.
  358.     BOOL bGotFriendlyName;          // TRUE if we have a friendly name.
  359.  
  360.     DWORD dwRelopMin;               // For attributes, indicates range of
  361.     DWORD dwRelopMax;               // relational operators that can be used
  362.                                     // for this attribute.
  363.     BOOL bGotRelops;                // TRUE if we have the relops fields set.
  364.  
  365. } OBJDESCRIPTOR;
  366.  
  367.  
  368. // Object types.
  369. // =============
  370. // This is the value that is inserted by the object
  371. // enumeration APIs into the OBJDESCRIPTOR structure.
  372. // --------------------------------------------------
  373. #define OT_ARCHLIST         1
  374. #define OT_ARCH             2
  375. #define OT_GROUP            3
  376. #define OT_ATTRIBUTE        4
  377.  
  378. #define OT_PLATFORMS        5
  379. #define OT_PLATFORM_PDF     6
  380. #define OT_PLATFORM_WINST   7
  381. #define OT_PLATFORM_NAD     8
  382.  
  383. #define OT_UNKNOWN          100
  384.  
  385.  
  386.  
  387.  
  388. // --------------------------------------------------------------------
  389. // Flags for Populate options.
  390. // --------------------------------------------------------------------
  391. #define POP_SYNC            0x00000000
  392. #define POP_ASYNC           0x00000001
  393. #define POP_EVENT           0x00000010
  394. #define POP_WINDOW          0x00000020
  395.  
  396.  
  397. // --------------------------------------------------------------------
  398. // Folder types supported by smsapi (MUST NOT BEGIN AT ZERO).
  399. // --------------------------------------------------------------------
  400. #define F_SITE              1               // Site folder.
  401. #define F_MACHINE           2               // Machine folder.
  402. #define F_GROUP             3               // Subfolder of machine
  403. #define F_DOMAIN            4               // Domain folder, subfolder
  404.                                             // of a site.
  405. // Jobs
  406. #define F_SYSTEMJOB         5               // System (NAD/Site) job folder.
  407. //#define F_MINIJOB           6               // Mini-job folder.
  408. #define F_INSTALLJOB        7               // Job folder (wksta install).
  409. #define F_SRVINSTALLJOB     8               // Job folder (server install).
  410. #define F_REMPKGJOB         9               // Remove package Job folder.
  411.  
  412. #define F_PACKAGE           10              // Packages.
  413. #define F_WCL               11              // Workstation command lines.
  414. #define F_PROGITEM          12              // Program items.
  415. #define F_INVENTORY         13              // Inventory rules.
  416.  
  417. #define F_MACHINEGROUP      14              // Machine group
  418. #define F_SITEGROUP         15              // Site group folder
  419.  
  420. // --------------------------------------------------------------------
  421. // Container types supported by smsapi (MUST NOT BEGIN AT ZERO).
  422. // --------------------------------------------------------------------
  423. #define C_SITE              1               // Site container.
  424. #define C_JOB               2               // Job container.
  425. #define C_MACHINE           3               // Machine container.
  426. #define C_PACKAGE           4               // Package container.
  427. #define C_MACHINEGROUP      5               // Machine group
  428. #define C_SITEGROUP         6               // Site group
  429.  
  430.  
  431. // ====================================================================
  432. //
  433. //      Filter information.
  434. //
  435. // ====================================================================
  436.  
  437.  
  438. // --------------------------------------------------------------------
  439. //  Filter types
  440. // --------------------------------------------------------------------
  441. #define SITE_FILTER         1
  442. #define MACHINE_FILTER      2
  443. #define GROUP_FILTER        3
  444. #define JOB_FILTER          4
  445. #define ARCHITECTURE_FILTER 5
  446. #define PACKAGE_FILTER      6
  447. #define ATTRIBUTE_FILTER    7
  448. #define SITELIMIT_FILTER    8
  449.  
  450.  
  451. // --------------------------------------------------------------------
  452. // Token types.
  453. // --------------------------------------------------------------------
  454. #define TOKEN_USER          0x8    // 1000 bit 3 always set for user-token
  455. #define TOKEN_OR            0x2    // 0010 bit 1 always set for AND/OR
  456. #define TOKEN_AND           0x3    // 0011 bit 1 always set for AND/OR
  457. #define TOKEN_OPENPAREN     0x4    // 0100 bit 2 always set for PAREN
  458. #define TOKEN_CLOSEPAREN    0x5    // 0101 bit 2 always set for PAREN
  459. #define TOKEN_NOTIN         0x20   //10100 bit 2 set for a PAREN plus bit 4 for an extra indicator.
  460. #define TOKEN_OPERATOR      0x2    // Detects both AND or OR
  461. #define TOKEN_PAREN         0x4    // Detects either open or close paren
  462.  
  463.  
  464. // --------------------------------------------------------------------
  465. // Manifests used in filter token APIs.
  466. // --------------------------------------------------------------------
  467. #define AT_START        OTT_AT_START    // Token will be inserted at start of
  468.                                         // expression.
  469. #define AT_END          OTT_AT_END      // Token will be appended to end of
  470.                                         // expression.
  471.  
  472. //
  473. // Flags field in SmsManipulateTokens.
  474. //
  475. #define TOK_GROUP           1
  476. #define TOK_UNGROUP         2
  477. #define TOK_DELETE          3
  478. #define TOK_GROUP_NOT       4
  479.  
  480.  
  481. /////////////////////////////////////////////////////////////////////////////
  482. /////////////////////////////////////////////////////////////////////////////
  483. /////////////////////////////////////////////////////////////////////////////
  484. ///////////     The APIs     ////////////////////////////////////////////////
  485. /////////////////////////////////////////////////////////////////////////////
  486. /////////////////////////////////////////////////////////////////////////////
  487. /////////////////////////////////////////////////////////////////////////////
  488.  
  489.  
  490. // **************************************************************************
  491. //
  492. //  This DLL provides a "C" interface for accessing SMS objects.
  493. //
  494. //===========================================================================
  495. //
  496. //  SmsAPIVer
  497. //
  498. //  This API returns a version string to identify the SMS API version.
  499. //
  500. //  Parameters:
  501. //      char **ppVersion                The version string is returned
  502. //                                      in this pointer.
  503. //                                      The user must not free this memory,
  504. //                                      it is a static buffer inside the API
  505. //                                      dll.
  506. //
  507. //  Returns:
  508. //      SMS_STATUS                      Always SMS_OK.
  509. //
  510. //===========================================================================
  511. //
  512. //===========================================================================
  513. //  1.  Connection APIs.
  514. //===========================================================================
  515. //
  516. //  SmsDataSourceConnect
  517. //
  518. //  This API connects to the datasource as specified in the DATASOURCE
  519. //  parameter. The API returns a connection handle in the second
  520. //  parameter.
  521. //  This handle is passed to OpenContainer.
  522. //
  523. //  Parameters:
  524. //      DATASOURCE *pd                  Pointer to DATASOURCE structure.
  525. //                                      The user must have already set up
  526. //                                      the appropriate parameters in this
  527. //                                      structure. For SQL this contains
  528. //                                      the server name, user name, password,
  529. //                                      database, public encryption key, and
  530. //                                      a pointer to a decryption function.
  531. //                                      See the description above.
  532. //      HANDLE *phConn                  Handle to a connection. This is
  533. //                                      filled in by the API.
  534. //
  535. //  Returns:
  536. //      SMS_STATUS                      Status. Either SMS_OK or one of the
  537. //                                      error codes listed above.
  538. //
  539. //===========================================================================
  540. //
  541. //  SmsDataSourceDisconnect
  542. //
  543. //  This API releases a datasource connection that was established by
  544. //  DataSourceConnect.
  545. //
  546. //  Parameters:
  547. //      HANDLE hConn                    Handle to the connection to be closed.
  548. //
  549. //  Returns:
  550. //      SMS_STATUS                      Status. Either SMS_OK or one of the
  551. //                                      error codes listed above.
  552. //
  553. //===========================================================================
  554. //
  555. //  2.  Engine APIs.
  556. //
  557. //  These are straight "pass-through" APIs that just call the engine APIs
  558. //  (in objectty.dll) directly. Here for name conformance and so to ensure
  559. //  that smsapi.dll will get loaded before the engine.
  560. //
  561. //===========================================================================
  562.  
  563. //
  564. //  SmsEnumContainers
  565. //
  566. //  This returns an array of pointers to FOLDER_INFO structures.
  567. //  If the pData parameter is NULL the API sets pCount to the number of
  568. //  containers registered. Thus, a user can call this API with a NULL
  569. //  buffer to get the count, which enables the application to allocate
  570. //  sufficient memory. If pData is non-NULL the API will copy up to
  571. //  pCount FOLDER_INFO pointers into the data buffer. If that number
  572. //  is less than the number of containers the count will be set as
  573. //  previously described.
  574. //  The data buffer is an array of pointers to FOLDER_INFO structures.
  575. //  These point to memory in the engine's address space, it should
  576. //  not be deallocated or modified.
  577. //LATER: make this pointer to const.
  578. //
  579. //
  580. //  Parameters:
  581. //      FOLDER_INFO **pData         Pointer to array of FOLDER_INFO structures.
  582. //      DWORD *pCount               Pointer to count of containers.
  583. //
  584. //  Returns:
  585. //      SMS_STATUS                  OTT_OK: success.
  586. //                                  OTT_MORE_DATA: passed buffer not
  587. //                                      big enough. *pCount says how
  588. //                                      many containers registered.
  589. //
  590. // ====================================================================
  591. //
  592. //  SmsEnumFilters
  593. //
  594. //  This API returns a list of all filters currently registered
  595. //  in the filter registry. This list is actually an array of
  596. //  FILTER_INFO structs.
  597. //
  598. //  The memory for this array must be allocated by the caller.
  599. //  To determine the size of the array call this API with NULL as
  600. //  the first parameter. This will result in the number of filters
  601. //  being returned in pCount.
  602. //
  603. //
  604. //  Parameters:
  605. //      FILTER_INFO *paFI           Pointer to an array of FILTER_INFO
  606. //                                  structures.
  607. //                                  The user is responsible for allocating
  608. //                                  (and deallocating) this memory.
  609. //      DWORD *pCount               Pointer to count of filters.
  610. //
  611. //  Returns:
  612. //      SMS_STATUS                  OTT_OK: success.
  613. //                                  OTT_MORE_DATA: passed buffer not
  614. //                                      big enough. *pCount says how
  615. //                                      many containers registered.
  616. //
  617. // ==========================================================================
  618. //
  619. //  SmsEnumFolders
  620. //
  621. //  This API returns a list of all folders currently registered
  622. //  in the folder registry. This list is actually an array of
  623. //  FOLDER_INFO structs.
  624. //
  625. //  The memory for this array must be allocated by the caller.
  626. //  To determine the size of the array call this API with NULL as
  627. //  the first parameter. This will result in the number of filters
  628. //  being returned in pCount.
  629. //
  630. //
  631. //  Parameters:
  632. //      FOLDER_INFO **pData         Pointer to an array of FOLDER_INFO structures.
  633. //      DWORD *pCount               Pointer to count of folders.
  634. //
  635. //  Returns:
  636. //      SMS_STATUS                  OTT_OK: success.
  637. //                                  OTT_MORE_DATA: passed buffer not
  638. //                                      big enough. *pCount says how
  639. //                                      many containers registered.
  640. //
  641. // ==========================================================================
  642. //
  643. //  SmsDescribeFolder
  644. //
  645. //  This API retrieves information about a container/folder and returns
  646. //  it in the FOLDER_INFO parameter (see description of FOLDER_INFO).
  647. //  Because containers and folders share the same id space for their
  648. //  tags, it is necessary for the caller to specify which one they are
  649. //  interested in.
  650. //  Note that the Enum... APIs return a set of objects, this API returns
  651. //  only a single one.
  652. //
  653. //
  654. //
  655. //  Parameters:
  656. //      BASETYPE tObjectity         T_CONTAINER or T_FOLDER
  657. //                                  (do we want a container or folder).
  658. //      DWORD dwTag                 Container/folder type.
  659. //      FOLDER_INFO **ppFInfo       Store the retrieved FOLDER_INFO here.
  660. //
  661. //  Returns:
  662. //      SMS_STATUS                  OTT_OK: success.
  663. //                                  OTT_INVALID_CONTAINER_ID:
  664. //                                  OTT_INVALID_FOLDER_ID:
  665. //                                      The container/folder cannot be
  666. //                                      located in the registry.
  667. //
  668. //===========================================================================
  669. //  3.  Container APIs.
  670. //===========================================================================
  671. //
  672. //  SmsOpenContainer
  673. //
  674. //  Opens a container of the specified type (cType). The container is opened
  675. //  but is currently empty. The only operations that can be performed on it
  676. //  in this state is SetFilter, Populate, and CloseContainer.
  677. //  It is permissible to have multiple containers of the same type opened
  678. //  simultaneously.
  679. //  Only when a container has been populated does it have information that
  680. //  can resonably be examined.
  681. //  The container type is one of the C_xxx manifests in the list above.
  682. //
  683. //  Parameters:
  684. //      DWORD cType                     Type of the container to open.
  685. //                                      This should be one of thr C_xxx
  686. //                                      manifests above.
  687. //      HANDLE hConnect                 Handle to a connection that has been
  688. //                                      established via SmsDataSourceConnect.
  689. //      HANDLE *phContainer             Handle to the container, filled in by
  690. //                                      the API.
  691. //
  692. //  Returns:
  693. //      SMS_STATUS                      Status. Either SMS_OK or one of the
  694. //                                      error codes listed above.
  695. //
  696. //===========================================================================
  697. //
  698. //  SmsSetFilter
  699. //
  700. //  This API submitts a filter to the container. The filter consists
  701. //  of tokens (possibly grouped) which express conditions for folder
  702. //  inclusion within a container.
  703. //  Note: when applying multiple filters an implicit AND is performed between
  704. //  filters.
  705. //
  706. //  Parameters:
  707. //      HANDLE hContainer               Identifies the container.
  708. //      HANDLE hFilter                  Handle to the filter to assign to
  709. //                                      the container.
  710. //
  711. //  Returns:
  712. //      SMS_STATUS                      Status. Either SMS_OK or one of the
  713. //                                      error codes listed above.
  714. //
  715. //===========================================================================
  716. //
  717. //  SmsPopulate
  718. //
  719. //  This causes the container to be populated with folders according to the
  720. //  filters applied to the container.
  721. //  It should be noted that not all filters that are applied to a container
  722. //  will be activated at this stage. For instance, applying an attribute
  723. //  filter to a site container has no effect at this stage. However, the
  724. //  filter is held internally within the system and will be applied to the
  725. //  appropriate folder. For an attribute filter, its activation in a site
  726. //  container would come at the level of a child domain folder. This
  727. //  technique is known as percolating filters.
  728. //  Containers are the only level at which filters can be applied at the
  729. //  API level.
  730. //  The dwOpts parameter allows the caller to specify whether the population
  731. //  (and the folder retrieval) should be asynchronous or synchronous.
  732. //  Synchronous is the default. These options are described earlier (see
  733. //  "Populate options").
  734. //  This parameter also specifies how the event handle should be set. The
  735. //  event handle can be set by the API whenever a folder has been retrieved,
  736. //  when all folders have been retrieved, or it can not be used at all (the
  737. //  default).
  738. //
  739. //  A third parameter is an event handle. According
  740. //
  741. //  Parameters:
  742. //      HANDLE hContainer               Identifies the container.
  743. //      DWORD dwOptions                 Synchronous/asynch, event handle usage.
  744. //      NOTIFY *pNotify                 Contains information about asynchronous
  745. //                                      notification. NULL if synchronous.
  746. //                                      parameter.
  747. //  Returns:
  748. //      SMS_STATUS                      Status. Either SMS_OK or one of the
  749. //                                      error codes listed above.
  750. //
  751. //===========================================================================
  752. //
  753. //  SmsGetNextFolder
  754. //
  755. //  This API retrieves the next folder in a parent container or folder.
  756. //
  757. //  Parameters:
  758. //      HANDLE hParent                  Identifies the parent (container or
  759. //                                      folder).
  760. //      DWORD fType                     Which type of sub-folder we want to
  761. //                                      retrieve.
  762. //      HANDLE *phFolder                Receives a handle to the next
  763. //                                      folder in the parent.
  764. //
  765. //  Returns:
  766. //      SMS_STATUS                      Status. Either SMS_OK or one of the
  767. //                                      error codes listed above.
  768. //
  769. //===========================================================================
  770. //
  771. //  SmsCloseContainer
  772. //
  773. //  Closes a currently open container, and frees resources held be the
  774. //  container.
  775. //  It is possible to open a container's child folders and then close the
  776. //  container. This has no adverse effects on either the folders or on any
  777. //  filters that have been applied to the container.
  778. //
  779. //  Parameters:
  780. //      HANDLE hContainer               Identifies the container.
  781. //
  782. //  Returns:
  783. //      SMS_STATUS                      Status. Either SMS_OK or one of the
  784. //                                      error codes listed above.
  785. //
  786. //===========================================================================
  787. //  4.  Folder APIs.
  788. //===========================================================================
  789. //
  790. //  SmsCreateFolder
  791. //
  792. //  This API attempts to create a folder (initally empty) of the specified
  793. //  type. Folder creation is done in the context of a parent (folder or
  794. //  container). Not all containers/folder support folder creation.
  795. //  Once created, a folder must have its scalars set by the application.
  796. //  Failure to do so will result in the system not accepting the newly
  797. //  created folder. See DescribeFolder for information on retrieving details
  798. //  about a folder's scalars.
  799. //
  800. //  Parameters:
  801. //      HANDLE hParent                  Identifies the parent (can be either
  802. //                                      container or folder).
  803. //      DWORD fType                     The type of folder to create. See
  804. //                                      the list of folders above).
  805. //      char *pszFolderID               A name to give the folder. Not all
  806. //                                      creatable folders can be named by the
  807. //                                      user. In many cases SMS itself will
  808. //                                      assign the name.
  809. //      HANDLE *phFolder                Receives a handle to the newly-created
  810. //                                      folder (if successful).
  811. //
  812. //  Returns:
  813. //      SMS_STATUS                      Status. Either SMS_OK or one of the
  814. //                                      error codes listed above.
  815. //
  816. //===========================================================================
  817. //
  818. //  SmsGetFolderID
  819. //
  820. //  This API retrives the ID/name of the folder referenced by the folder handle.
  821. //
  822. //  Parameters:
  823. //      HANDLE hFolder                  Which folder object we're talking about.
  824. //      char *pszFolderID               Pointer to buffer to receive the
  825. //                                      folder's ID. It is the caller's
  826. //                                      responsibility to ensure that this
  827. //                                      buffer is large enough. If in doubt
  828. //                                      use of buffer of size SMS_DATA_BUFF_SIZE.
  829. //                                      This is guaranteed to be sufficient.
  830. //
  831. //  Returns:
  832. //      SMS_STATUS                      Status. Either SMS_OK or one of the
  833. //                                      error codes listed above.
  834. //
  835. //===========================================================================
  836. //
  837. //  SmsGetFolderType
  838. //
  839. //  This API retrieves the folder's type as both an integer value and as
  840. //  a character string. For instance invoking this API on a domain folder
  841. //  will result in a type string of "Domain folder" and an integer type of
  842. //  F_DOMAIN being returned. The caller is responsible for ensuring that
  843. //  the character buffer is of sufficient size.
  844. //
  845. //  Parameters:
  846. //      HANDLE hFolder                  The folder to query.
  847. //      DWORD *pfType                   Receive's the folder's type (integer).
  848. //      char *pszfType                  Receives folder's type (as a string).
  849. //
  850. //  Returns:
  851. //      SMS_STATUS                      Status. Either SMS_OK or one of the
  852. //                                      error codes listed above.
  853. //
  854. //===========================================================================
  855. //
  856. //  SmsEnumFolderTypes
  857. //
  858. //  This API returns an array of DWORDs which indicate what folder types
  859. //  CAN be contained within this folder. It is the caller's responsibility
  860. //  to ensure that the DWORD array (*pfTypes) is of sufficient size.
  861. //  Calling this API with pfTypes of NULL or with *pctFolderTypes of 0,
  862. //  will result in the correct count being returned to the caller in
  863. //  pctFolderTypes.
  864. //  If the *pctFolderTypes is less than the number of folders, then up to
  865. //  *pctFolderTypes are returned in the DWORD array, and a status of
  866. //  SMS_MORE_DATA is returned.
  867. //  If *pctFolderTypes is greater than the number of folders then the maximum
  868. //  number of folder types will be stored in the array, and a value of
  869. //  PARAMETER_ERROR returned. *pctFolderTypes will be updated to indicate
  870. //  the number of folder types.
  871. //
  872. //  Note the difference between this API and GetFolderCount. This returns
  873. //  a list of sub-folder types that can be contained in the folder,
  874. //  GetFolderCount returns a count of how many sub-folders of a specified
  875. //  type actually are contained in the folder.
  876. //
  877. //  Parameters:
  878. //      HANDLE hFolder                  The folder to query.
  879. //      DWORD *pfTypes                  Points to an array of DWORD.
  880. //                                      Filled in with the types of sub-
  881. //                                      folders that this folder can contain.
  882. //      DWORD *pctFolderTypes           How many types of sub-folders this
  883. //                                      folder can contain.
  884. //
  885. //  Returns:
  886. //      SMS_STATUS                      Status. Either SMS_OK or one of the
  887. //                                      error codes listed above.
  888. //
  889. //===========================================================================
  890. //
  891. //  SmsGetFolderCount
  892. //
  893. //  This API returns (in the DWORD parameter) how many sub-folders of the
  894. //  specified folder-type are contained in this folder.
  895. //  Note that a DWORD of F_ANY means return the total count of sub-folders.
  896. //
  897. //  Parameters:
  898. //      HANDLE hFolder                  The folder (or container) to query.
  899. //      DWORD fType                     Which type of sub-folder we're
  900. //                                      interested in. F_ANY means all types.
  901. //      DWORD *pctFolders               Receives the count.
  902. //
  903. //  Returns:
  904. //      SMS_STATUS                      Status. Either SMS_OK or one of the
  905. //                                      error codes listed above.
  906. //
  907. //===========================================================================
  908. //
  909. //  SmsGetFolderByID
  910. //
  911. //  This API the retrieves from the folder a sub-folder of the specified
  912. //  type and with a specified ID.
  913. //  This method of folder retrieval is non-sequential. Once a sub-folder has
  914. //  been retrieved it can be re-retrieved. It is always legal to open a
  915. //  folder multiple times. Doing this will create multiple instances of a
  916. //  folder. Thus, it is possible to retrieve a folder twice, close once
  917. //  instance, and still have an instance of the folder available.
  918. //  Note that a folder type of F_ANY is not accepted here, it will result
  919. //  in a return code of SMS_INVALID_FOLDER_TYPE.
  920. //  Note that a type of F_ANY is not allowed.
  921. //
  922. //
  923. //  Parameters:
  924. //      HANDLE hFolder                  The folder to query.
  925. //      DWORD fType                     Which type of sub-folder we want to
  926. //                                      retrieve (see GetFolderCount).
  927. //      char *pszFolderID               The sub-folder's ID (name).
  928. //      HANDLE *phSubFolder             Receives a handle to the sub-folder.
  929. //
  930. //  Returns:
  931. //      SMS_STATUS                      Status. Either SMS_OK or one of the
  932. //                                      error codes listed above.
  933. //
  934. //===========================================================================
  935. //
  936. //  SmsRewind
  937. //
  938. //  This API resets the internal counts of either a container, a folder, or
  939. //  a filter so that contained sub-folders and/or scalars can be re-
  940. //  enumerated.
  941. //  Because GetNextFolder and GetNextScalar are sequential, once thay have
  942. //  been retrieved once they cannot be re-retrieved with these APIs.
  943. //  The Rewind API enbles the retrieval to be restarted.
  944. //  The options parameter allows the user to specify that either the folder
  945. //  list or the scalar list or both be rewound.
  946. //
  947. //
  948. //  Parameters:
  949. //      HANDLE hObject                  The container, folder, or filter
  950. //                                      to be rewound.
  951. //      DWORD  dwOptions                Rewind options:-
  952. //                                      RW_FOLDER: rewind folder lists.
  953. //                                      RW_SCALAR: rewind scalar lists.
  954. //                                      RW_ALL:    both.
  955. //
  956. //                                      If the object is a container or
  957. //                                      folder, a particular type of sub-
  958. //                                      folder list may be rewound by passing
  959. //                                      the child folder type in the
  960. //                                      dwOptions parameter.
  961. //
  962. //                                      If the object is a filter container,
  963. //                                      then a particular type of filter list
  964. //                                      may be rewound by passing the filter
  965. //                                      type in the dwOptions parameter.
  966. //
  967. //                                      If the object is a filter then only
  968. //                                      RW_SCALAR is valid.
  969. //
  970. //  Returns:
  971. //      SMS_STATUS                      Status. Either SMS_OK or one of the
  972. //                                      error codes listed above.
  973. //
  974.  
  975. //===========================================================================
  976. //
  977. //  SmsCloseFolder
  978. //
  979. //  This API closes the specified folder.
  980. //  Closing a folder causes sub-folders to be closed and deallocated UNLESS
  981. //  they have already been retrieved by a GetSubFolder/GetFolderByID call
  982. //  in which case they remain open.
  983. //  A folder's scalars are always closed and their memory deallocated.
  984. //
  985. //  Parameters:
  986. //      HANDLE hFolder                  The folder to close.
  987. //
  988. //  Returns:
  989. //      SMS_STATUS                      Status. Either SMS_OK or one of the
  990. //                                      error codes listed above.
  991. //
  992. //===========================================================================
  993. //
  994. //  SmsLinkFolder
  995. //
  996. //  This API inserts the specified folder into the in-memory list of folders
  997. //  and causes it to be linked to its parent (must still be open).
  998. //  The folder is not written back to the datasource until CommitFolder is
  999. //  called.
  1000. //
  1001. //  Parameters:
  1002. //      HANDLE hFolder                  The folder to insert.
  1003. //
  1004. //  Returns:
  1005. //      SMS_STATUS                      Status. Either SMS_OK or one of the
  1006. //                                      error codes listed above.
  1007. //
  1008. //===========================================================================
  1009. //
  1010. //  SmsUnlinkFolder
  1011. //
  1012. //  This API deletes the specified folder from the in-memory list of folders.
  1013. //  All memory associated with the folder is deallocated. However, the
  1014. //  folder is not deleted from the datasource until CommitFolder is called.
  1015. //
  1016. //  Parameters:
  1017. //      HANDLE hFolder                  The folder to delete.
  1018. //
  1019. //  Returns:
  1020. //      SMS_STATUS                      Status. Either SMS_OK or one of the
  1021. //                                      error codes listed above.
  1022. //
  1023. //===========================================================================
  1024. //
  1025. //  SmsCommitFolder
  1026. //
  1027. //  This API causes any changes in the specified folder to be written back to
  1028. //  the datasource.
  1029. //  This should be called after LinkFolder and UnlinkFolder in order to make
  1030. //  the changes permanent.
  1031. //  Note that a Commit following an Unlink will render the specified folder
  1032. //  unavailable to all operations (other that SmsCloseFolder).
  1033. //
  1034. //  Parameters:
  1035. //      HANDLE hFolder                  The folder to update (insert or delete).
  1036. //
  1037. //  Returns:
  1038. //      SMS_STATUS                      Status. Either SMS_OK or one of the
  1039. //                                      error codes listed above.
  1040. //
  1041. //===========================================================================
  1042. //
  1043. //  SmsDupFolder
  1044. //
  1045. //  This API causes the folder (hFolder) to be copied (into hNewFolder)
  1046. //  in the context of the specified parent (hParent - container or folder).
  1047. //
  1048. //  Parameters:
  1049. //      HANDLE hParent                  The parent folder in whose context
  1050. //                                      the new folder will be inserted.
  1051. //      HANDLE hFolder                  The folder to be duplicated
  1052. //      HANDLE *phNewFolder             The handle to the new folder
  1053. //                                      is returned here.
  1054. //
  1055. //  Returns:
  1056. //      SMS_STATUS                      Status. Either SMS_OK or one of the
  1057. //                                      error codes listed above.
  1058. //
  1059. //===========================================================================
  1060. //  5.  Scalar APIs.
  1061. //===========================================================================
  1062. //
  1063. //  SmsGetScalarCount
  1064. //
  1065. //  This API returns the count of scalars in this folder.
  1066. //
  1067. //  Parameters:
  1068. //      HANDLE hFolder                  The folder to query.
  1069. //      DWORD *pctScalars               Receives the count of scalars.
  1070. //
  1071. //  Returns:
  1072. //      SMS_STATUS                      Status. Either SMS_OK or one of the
  1073. //                                      error codes listed above.
  1074. //
  1075. //===========================================================================
  1076. //
  1077. //  SmsGetNextScalar
  1078. //
  1079. //  This API retrieves the next scalar from the folder.
  1080. //  Scalars can either be retrieved in a sequential fashion (this API)
  1081. //  or by name (GetScalarByName). The RewindFolder API enables the sequential
  1082. //  enumeration of scalars to be restarted.
  1083. //
  1084. //  Parameters:
  1085. //      HANDLE hFolder                  The folder to query.
  1086. //      SCALAR *pScalar                 Pointer to a SCALAR that has been
  1087. //                                      allocated by the caller.
  1088. //                                      See notes on SCALAR for a full
  1089. //                                      description of this structure and
  1090. //                                      its use.
  1091. //  Returns:
  1092. //      SMS_STATUS                      Status. Either SMS_OK or one of the
  1093. //                                      error codes listed above.
  1094. //
  1095. //===========================================================================
  1096. //
  1097. //  SmsGetScalarByName
  1098. //
  1099. //  This API retrieves the scalar specified by its name.
  1100. //
  1101. //  Parameters:
  1102. //      HANDLE hFolder                  The folder to query.
  1103. //      const char *pszName             Name of the scalar.
  1104. //      SCALAR *pScalar                 Pointer to a SCALAR that has been
  1105. //                                      allocated by the caller.
  1106. //                                      See notes on SCALAR for a full
  1107. //                                      description of this structure and
  1108. //                                      its use.
  1109. //  Returns:
  1110. //      SMS_STATUS                      Status. Either SMS_OK or one of the
  1111. //                                      error codes listed above.
  1112. //
  1113. //===========================================================================
  1114. //
  1115. //  SmsSetScalar
  1116. //
  1117. //  This API is used to set the value of a scalar. It is used when creating a
  1118. //  folder. In the future it will also be used to modify the value of a
  1119. //  scalar in an existing folder.
  1120. //  The set of scalars supported by a folder is always known at the time a
  1121. //  folder is opened, this is true even when a folder is being created.
  1122. //  Scalars have a name, a type, and a value. This API allows the value to
  1123. //  be set. Only values of the correct type are allowed. Attempting to set,
  1124. //  for instance, an integer value in a string scalar will result in a
  1125. //  SMS_SCALAR_WRONG_TYPE error return.
  1126. //  The API set supports the notion of access rights on folders and scalars,
  1127. //  in order for this API to succeed the caller must have the correct
  1128. //  access to both. Failure results in an error return of SMS_SCALAR_NO_UPDATE
  1129. //  or SMS_FOLDER_NO_UPDATE.
  1130. //
  1131. //  Parameters:
  1132. //      HANDLE hFolder                  The folder containing the scalar.
  1133. //      SCALAR *pScalar                 Pointer to a SCALAR that has been
  1134. //                                      allocated and filled in by the caller.
  1135. //                                      See notes on SCALAR for a full
  1136. //                                      description of this structure and
  1137. //                                      its use.
  1138. //  Returns:
  1139. //      SMS_STATUS                      Status. Either SMS_OK or one of the
  1140. //                                      error codes listed above.
  1141. //
  1142. //===========================================================================
  1143. //  6.  Filter container APIs.
  1144. //===========================================================================
  1145. //
  1146. //  SmsOpenFilterContainer
  1147. //
  1148. //  The filter container is a storage mechanism for persistent filters,
  1149. //  currently only Machine Filters (SMS Queries) fall into this category.
  1150. //
  1151. //  Calling this API causes the filter container to be automatically populated
  1152. //  with all persistent filters in the system.
  1153. //
  1154. //  Parameters:
  1155. //      HANDLE hConnection              Which connection to use.
  1156. //      HANDLE *phFContainer            Receives the handle to the opened
  1157. //                                      filter container.
  1158. //
  1159. //  Returns:
  1160. //      SMS_STATUS                      Status. Either SMS_OK or an error code.
  1161. //                                      LIST POSSIBLE ERROR CODES HERE.
  1162. //
  1163. //===========================================================================
  1164. //
  1165. //  SmsCloseFilterContainer
  1166. //
  1167. //  Closes the filter container. All filters container herein that have
  1168. //  not been explicitly opened are closed and the memory associated with
  1169. //  them is freed.
  1170. //
  1171. //  Parameters:
  1172. //      HANDLE hFContainer              The handle to the filter container.
  1173. //
  1174. //  Returns:
  1175. //      SMS_STATUS                      Status. Either SMS_OK or an error code.
  1176. //                                      LIST POSSIBLE ERROR CODES HERE.
  1177. //
  1178. //===========================================================================
  1179. //
  1180. //  SmsGetNextFilter
  1181. //
  1182. //  This returns (in *phFilter) a handle to the next sequential filter of
  1183. //  the specified type from the filter container (specified by hFContainer).
  1184. //  A filter type of F_ANY is not acceptable.
  1185. //
  1186. //  Parameters:
  1187. //      HANDLE hFContainer              Handle to the filter container.
  1188. //      DWORD frType                    Filter type.
  1189. //      HANDLE *phFilter                Handle to the filter returned here.
  1190. //
  1191. //  Returns:
  1192. //      SMS_STATUS                      Status. Either SMS_OK or an error code.
  1193. //                                      LIST POSSIBLE ERROR CODES HERE.
  1194. //
  1195. //===========================================================================
  1196. //
  1197. //  SmsGetFilterByID
  1198. //
  1199. //  The API will return (in *phFilter) a handle to the filter of the specified
  1200. //  type which has the specified ID.
  1201. //  As above, the handle to the filter container is also passed into the API.
  1202. //  A filter type of F_ANY is not acceptable.
  1203. //
  1204. //  Parameters:
  1205. //      HANDLE hFContainer              Handle to the filter container.
  1206. //      DWORD frType                    Filter type.
  1207. //      const char *pszID               ID of the filter to retrieve.
  1208. //      HANDLE *phFilter                Handle to the filter returned here.
  1209. //
  1210. //  Returns:
  1211. //      SMS_STATUS                      Status. Either SMS_OK or an error code.
  1212. //                                      LIST POSSIBLE ERROR CODES HERE.
  1213. //
  1214. //===========================================================================
  1215. //
  1216. //  SmsGetFilterID
  1217. //
  1218. //  This returns, in pszID, the ID of the filter specified by the handle.
  1219. //
  1220. //  Parameters:
  1221. //      HANDLE hFilter
  1222. //      char *pszID
  1223. //
  1224. //  Returns:
  1225. //      SMS_STATUS                      Status. Either SMS_OK or an error code.
  1226. //                                      LIST POSSIBLE ERROR CODES HERE.
  1227. //
  1228. //===========================================================================
  1229. //
  1230. //  SmsCommitFilter
  1231. //
  1232. //  This API will attempt to make the specified filter persistent. The filter
  1233. //  must be of a type that supports persistence, and all manadatory scalars
  1234. //  for the filter must have been set.
  1235. //
  1236. //  Parameters:
  1237. //      HANDLE hFilter
  1238. //      HANDLE hFContainer
  1239. //
  1240. //  Returns:
  1241. //      SMS_STATUS                      Status. Either SMS_OK or an error code.
  1242. //                                      LIST POSSIBLE ERROR CODES HERE.
  1243. //
  1244. //===========================================================================
  1245. //
  1246. //===========================================================================
  1247. //  7.  Filter APIs.
  1248. //===========================================================================
  1249. //
  1250. //  SmsCreateFilter
  1251. //
  1252. //  This API creates a filter of the specified type, initially empty. The
  1253. //  caller must then set tokens in this filter.
  1254. //  Filter types are listed above.
  1255. //
  1256. //  Parameters:
  1257. //      DWORD fType                     Type of filter to create.
  1258. //      HANDLE hConnection              Filters are associated with a
  1259. //                                      connection.
  1260. //      HANDLE *phFilter                Receives a handle to the filter.
  1261. //  Returns:
  1262. //      SMS_STATUS                      Status. Either SMS_OK or one of the
  1263. //                                      error codes listed above.
  1264. //
  1265. //============================================================================
  1266. //
  1267. //  SmsCloseFilter
  1268. //
  1269. //  Close the specified filter and deallocate any memory asociated with it.
  1270. //  Once a filter has been applied to a container (SetFilter), the user is
  1271. //  free to close it. The API system has made it own copy which will be freed
  1272. //  when no longer necessary.
  1273. //
  1274. //  Parameters:
  1275. //      HANDLE hFilter                  The filter to close.
  1276. //
  1277. //  Returns:
  1278. //      SMS_STATUS                      Status. Either SMS_OK or one of the
  1279. //                                      error codes listed above.
  1280. //
  1281. //============================================================================
  1282. //
  1283. //  SmsGetFilterType
  1284. //
  1285. //  This API gets the type for a particular filter. Using this type it is
  1286. //  possible to get the filter template.
  1287. //  Parameters:
  1288. //      HANDLE hFilter                  The filter to retrieve the type for.
  1289. //      DWORD *pfilterType              The filter type is returned here.
  1290. //      char *pszTag                    The filter tag is returned here.
  1291. //
  1292. //  Returns:
  1293. //      SMS_STATUS                      Status. Either SMS_OK or one of the
  1294. //                                      error codes listed above.
  1295. //
  1296. //===========================================================================
  1297. //
  1298. //  SmsGetToken
  1299. //
  1300. //  This API retrieves a token from the specified filter or folder. The token
  1301. //  to retrieve is given by the index parameter. See also SmsGetTokenCount.
  1302. //  The TOKEN structure is detailed in the file objectty.h.
  1303. //
  1304. //  Parameters:
  1305. //      HANDLE hObject                  Handle to filter or folder.
  1306. //      INT iIndex
  1307. //      TOKEN *pTokenInfo
  1308. //
  1309. //  Returns:
  1310. //      SMS_STATUS                      Status. Either SMS_OK or one of the
  1311. //                                      error codes listed above.
  1312. //
  1313. //===========================================================================
  1314. //
  1315. //  SmsAddToken
  1316. //
  1317. //  This API allows the caller to add a token into a filter (or folder). The
  1318. //  ANDOR parameter specifies if the token is to be ANDed or ORed with the
  1319. //  preceeding token. The index specifies whereabout in the filter expression
  1320. //  the token is to be inserted. The rules are as follows:
  1321. //  1. index is AT_START (-1), the token will be inserted at the start of the
  1322. //     expression and the ANDOR operator will be postfixed.
  1323. //  2. index is AT_END (-2), the token will be appended to the end of the
  1324. //     expression, the ANDOR operator will prefix the token.
  1325. //  3. if index is anything else, if the expression is currently empty then
  1326. //     the token will be inserted at the start of the expression, and the
  1327. //     ANDOR operator is ignored. If the expression is not empty then the
  1328. //     token will be inserted at the given index and the operator prefixed.
  1329. //     The exception here is if the index is out of range, in this case the
  1330. //     token will be appended with the ANDOR being prefixed.
  1331. //     In all cases, if inserting the token would cause the resulting
  1332. //     expression to be illegal a status of SMS_RANGE_ERROR will be returned.
  1333. //
  1334. //  Parameters:
  1335. //      HANDLE hObject                  Handle to filter or folder.
  1336. //      ANDOR opAndOr
  1337. //      TOKEN *pTokenInfo
  1338. //      INT iIndex
  1339. //
  1340. //  Returns:
  1341. //      SMS_STATUS                      Status. Either SMS_OK or one of the
  1342. //                                      error codes listed above.
  1343. //
  1344. //===========================================================================
  1345. //
  1346. //  SmsGetTokenCount
  1347. //
  1348. //  This API will return (in *pctTokens) the number of tokens currently in
  1349. //  the filter or folder expression.
  1350. //
  1351. //  Parameters:
  1352. //      HANDLE hObject                  Handle to either filter or folder.
  1353. //      DWORD *pctTokens
  1354. //
  1355. //  Returns:
  1356. //      SMS_STATUS                      SMS_OK, or SMS_INVALID_HANDLE.
  1357. //
  1358. //===========================================================================
  1359. //
  1360. //  SmsManipulateTokens
  1361. //
  1362. //  This APIs allows for the manipulation of tokens within a filter or folder
  1363. //  expression in various ways, according to the flags parameter.
  1364. //  TOK_GROUP       The tokens between the specified indicies are grouped
  1365. //                  together to form a sub-expression, ie they are backeted by
  1366. //                  parentheses.
  1367. //  TOK_UNGROUP     The tokens between the specified indicies have their
  1368. //                  parenthesis removed. This undoes the action of TOK_GROUP.
  1369. //  TOK_DELETE      The tokens within the specified indecies are deleted.
  1370. //                  In this case the tokens must not form a legal sub-
  1371. //                  expression.
  1372. //  TOK_GROUP_NOT   This is applicable only to persistent filters. At the
  1373. //                  moment that means only machine filters.
  1374. //                  This flag is applied to a range of one or more tokens that
  1375. //                  form a legal sub-expression. That is, a range of tokens
  1376. //                  that can ge grouped. The action performed by this is to
  1377. //                  group these tokens and preceed them with a 'NOT IN'
  1378. //                  token. This has the effect of specifying exclusion.
  1379. //
  1380. //  The user may use the manifests AT_START and AT_END to indicate
  1381. //  the full range of tokens within the filter or folder object.
  1382. //  The iStart and iEnd may be one of the following:
  1383. //  1. AT_START (-1), the index will be at the start of the expression.
  1384. //  2. AT_END (-2), the index will be at the end of the expression.
  1385. //  3. For any other valid indexes, the tokens will be manipulated within the given indexes
  1386. //
  1387. //  Parameters:
  1388. //      HANDLE hObject                  Handle to either filter or folder.
  1389. //      DWORD dwFlags
  1390. //      INT iStart
  1391. //      INT iEnd
  1392. //
  1393. //  Returns:
  1394. //      SMS_STATUS                      Status. Either SMS_OK or one of the
  1395. //                                      error codes listed above.
  1396. //
  1397. //===========================================================================
  1398. //
  1399. //  SmsGetAllFilters
  1400. //
  1401. //  This API retrieves from the specified container a list of filter handles
  1402. //  that have been applied to that container.
  1403. //  It is important to note that once this has been called, the API
  1404. //  SmsCloseFilter must be called for each of the filters in the array.
  1405. //
  1406. //  Calling this with NULL for the array of filters will cause the *pctFilters
  1407. //  parameter to be set with the number of filters, in this case the API
  1408. //  will return a status of SMS_MORE_DATA.
  1409. //  The user should then allocate sufficient memory and call the API again.
  1410. //
  1411. //  Note that the container specified here is a normal (ie folder) container
  1412. //  and not a filter container.
  1413. //
  1414. //  Parameters:
  1415. //      HANDLE hContainer
  1416. //      HANDLE *pahFilters
  1417. //      DWORD *pctFilters
  1418. //
  1419. //  Returns:
  1420. //      SMS_STATUS                      Status. Either SMS_OK or one of the
  1421. //                                      error codes listed above.
  1422. //
  1423. //===========================================================================
  1424. //
  1425. //===========================================================================
  1426. //  8.  Object enumeration APIs.
  1427. //===========================================================================
  1428. //
  1429. //  SmsEnumObjectTypes
  1430. //
  1431. //  This API returns a list of first-class objects that are known to the
  1432. //  API.
  1433. //  These objects do not have a direct existence in the container hierarchy,
  1434. //  but play an important part in the API. The objects of major concern are
  1435. //  architectures and their descendents, but Platforms are also supported.
  1436. //
  1437. //  A first-class object is one that is known directly to the APIs and which
  1438. //  does not require any additional informaion. Thus the system knows
  1439. //  directly about architectures and platforms, while it cannot know about,
  1440. //  for instance, attributes, without first knowing about an architecture
  1441. //  and a groupclass.
  1442. //
  1443. //  The 'pObjects' parameter is an array of SMSBUFF objects. On successful
  1444. //  completion of the API this array will be filled with the names of
  1445. //  each first-class object known to the system.
  1446. //
  1447. //  On entry the 'pCtObjects' parameter tells the API the size of the
  1448. //  pObjects array. On exit it contains the actual number of objects
  1449. //  known to the system.
  1450. //  If this parameter is less than the number of objects known to the system
  1451. //  then it is still set to the total, but no information will have been
  1452. //  copied to the pObjects array, and a status of SMS_MORE_DATA will be
  1453. //  returned.
  1454. //
  1455. //  Parameters:
  1456. //      HANDLE hConnection              Handle to a connection that has been
  1457. //                                      established via SmsDataSourceConnect.
  1458. //      SMSBUFF *pObjects
  1459. //      DWORD *pCtObjects
  1460. //
  1461. //  Returns:
  1462. //      SMS_STATUS                      Status. Either SMS_OK or one of the
  1463. //                                      error codes listed above.
  1464. //
  1465. //===========================================================================
  1466. //
  1467. //  SmsEnumObjects
  1468. //
  1469. //  This object actually does the work of enumerating objects. For first-
  1470. //  class objects (see above) the 'pPredecessor' parameter is not used,
  1471. //  in this case it may be set to NULL. For non first-class objects this
  1472. //  list states the predecessor objects that must be given to the system
  1473. //  in order for it to locate the requested object.
  1474. //
  1475. //  The 'ctPredecessors' parameter tells the API the number of entries in the
  1476. //  predecessor list.
  1477. //
  1478. //  'pszObjectType' tells the API what object type the user is interested in.
  1479. //
  1480. //  'pObjects' is an array of OBJDESCRIPTORS, this array will be filled in
  1481. //  with details of the requested object type.
  1482. //
  1483. //  'pCtObjects' is a pointer to a DWORD. On entry it tells the API the number
  1484. //  of entries in 'pObjects'. On exit it is always set to then count of
  1485. //  objects of the specified type. If the entry value is less than the actual
  1486. //  number of objects then no data is copied and a status of SMS_NMO_MORE_DATA
  1487. //  is returned.
  1488. //
  1489. //  Consider an example.
  1490. //  If we want to enumerate the attributes in the 'MICROSOFT|IDENTIFICATION|1.0'
  1491. //  groupclass for 'Personal Computer' objects then we would set the parameters
  1492. //  as follows:
  1493. //      pszObjectType    = "MICROSOFT|IDENTIFICATION|1.0"
  1494. //      pPredecessors[0] = "Architectures"
  1495. //      pPredecessors[1] = "Personal Computer"
  1496. //      ctPredecessors   = 2
  1497. //      pObjects - you can declare it as 'OBJDESCRIPTOR pObjects[SOME_SIZE]'
  1498. //      *pCtObjects      = SOME_SIZE
  1499. //
  1500. //  On exit the pObjects array would have 9 entries (as currently defined,
  1501. //  this can change). The first entry would look like this:
  1502. //      pObjects[0].objType          = OT_ATTRIBUTE
  1503. //      pObjects[0].szName           = 'Name"
  1504. //      pObjects[0].szFriendlyName - unused
  1505. //      pObjects[0].bGotFriendlyName = FALSE
  1506. //      pObjects[0].dwRelopMin       = QOP_STR_EQ
  1507. //      pObjects[0].dwRelopMax       = QOP_UPCASE_NOTLIKE
  1508. //      pObjects[0].bGotRelops       = TRUE
  1509.  
  1510. //  Parameters:
  1511. //      HANDLE hConn
  1512. //      char *pszObjectType
  1513. //      SMSBUFF *pPredecessors
  1514. //      DWORD ctPredecessors
  1515. //      OBJDESCRIPTOR *pObjects
  1516. //      DWORD *pCtObjects
  1517. //
  1518. //  Returns:
  1519. //      SMS_STATUS                      Status. Either SMS_OK or one of the
  1520. //                                      error codes listed above.
  1521. //
  1522. //===========================================================================
  1523.  
  1524.  
  1525.  
  1526. // ====================================================================
  1527. //      Version number API.
  1528. // ====================================================================
  1529. __declspec (dllexport) SMS_STATUS SmsAPIVer( char **ppVersion );
  1530.  
  1531.  
  1532. // ====================================================================
  1533. //      Engine APIs.
  1534. // ====================================================================
  1535.  
  1536. __declspec (dllexport) SMS_STATUS SmsEnumContainers(
  1537.                 FOLDER_INFO **pData,
  1538.                 DWORD *pCount );
  1539.  
  1540. __declspec (dllexport) SMS_STATUS SmsEnumFilters(
  1541.                 FILTER_INFO *paFI,
  1542.                 DWORD *pCount );
  1543.  
  1544. __declspec (dllexport) SMS_STATUS SmsEnumFolders(
  1545.                 FOLDER_INFO **pData,
  1546.                 DWORD *pCount );
  1547.  
  1548. __declspec (dllexport) SMS_STATUS SmsDescribeFolder(
  1549.                 BASETYPE tObjectity,        // T_CONTAINER or T_FOLDER.
  1550.                 DWORD dwTag,                // folder type (or F_ANY)
  1551.                 FOLDER_INFO **ppFInfo );    // We store the FOLDER_INFO here.
  1552.  
  1553.  
  1554. // ====================================================================
  1555. //      Connection APIs.
  1556. // ====================================================================
  1557. __declspec (dllexport) SMS_STATUS SmsDataSourceConnect(
  1558.                                 DATASOURCE *pd,
  1559.                                 HANDLE *phConn );
  1560.  
  1561. __declspec (dllexport) SMS_STATUS SmsDataSourceDisconnect(
  1562.                                 HANDLE hConn );
  1563.  
  1564.  
  1565. // ====================================================================
  1566. //      Container APIS.
  1567. // ====================================================================
  1568. __declspec (dllexport) SMS_STATUS SmsOpenContainer(
  1569.                                 DWORD cType,
  1570.                                 HANDLE hConnection,
  1571.                                 HANDLE *phContainer );
  1572.  
  1573. __declspec (dllexport) SMS_STATUS SmsSetFilter(
  1574.                                 HANDLE hContainer,
  1575.                                 HANDLE hFilter );
  1576.  
  1577. __declspec (dllexport) SMS_STATUS SmsPopulate(
  1578.                                 HANDLE hContainer,
  1579.                                 DWORD dwOptions,
  1580.                                 NOTIFY *pNotify );
  1581.  
  1582. __declspec (dllexport) SMS_STATUS SmsGetNextFolder(
  1583.                                 HANDLE hParent,
  1584.                                 DWORD fType,
  1585.                                 HANDLE *phFolder );
  1586.  
  1587. __declspec (dllexport) SMS_STATUS SmsCloseContainer(
  1588.                                 HANDLE hContainer );
  1589.  
  1590. // ====================================================================
  1591. //  Folder (collection) APIs.
  1592. //  A collection contains other things, that is it can have embedded
  1593. //  collections and it can also have properties (scalars).
  1594. // ====================================================================
  1595.  
  1596. __declspec (dllexport) SMS_STATUS SmsCreateFolder(
  1597.                                 HANDLE hParent,
  1598.                                 DWORD fType,
  1599.                                 const char *pszFolderID,
  1600.                                 HANDLE *phFolder );
  1601.  
  1602. __declspec (dllexport) SMS_STATUS SmsGetFolderID(
  1603.                                 HANDLE hFolder,
  1604.                                 char *pszFolderID );
  1605.  
  1606. __declspec (dllexport) SMS_STATUS SmsGetFolderType(
  1607.                                 HANDLE hFolder,
  1608.                                 DWORD *pfType,
  1609.                                 char *pszfType );
  1610.  
  1611. __declspec (dllexport) SMS_STATUS SmsEnumFolderTypes(
  1612.                                 HANDLE hFolder,
  1613.                                 DWORD *pfTypes,
  1614.                                 DWORD *pctFolderTypes );
  1615.  
  1616. __declspec (dllexport) SMS_STATUS SmsGetFolderCount(
  1617.                                 HANDLE hFolder,
  1618.                                 DWORD fType,
  1619.                                 DWORD *pctFolders );
  1620.  
  1621. __declspec (dllexport) SMS_STATUS SmsGetFolderByID(
  1622.                                 HANDLE hFolder,
  1623.                                 DWORD fType,
  1624.                                 char *pszFolderID,
  1625.                                 HANDLE *phSubFolder );
  1626.  
  1627. __declspec (dllexport) SMS_STATUS SmsRewind(
  1628.                                 HANDLE hObject,
  1629.                                 DWORD dwOptions );
  1630.  
  1631. __declspec (dllexport) SMS_STATUS SmsCloseFolder(
  1632.                                 HANDLE hFolder );
  1633.  
  1634. __declspec (dllexport) SMS_STATUS SmsLinkFolder(
  1635.                                 HANDLE hFolder );
  1636.  
  1637. __declspec (dllexport) SMS_STATUS SmsUnlinkFolder(
  1638.                                 HANDLE hFolder );
  1639.  
  1640. __declspec (dllexport) SMS_STATUS SmsCommitFolder(
  1641.                                 HANDLE hFolder );
  1642.  
  1643. __declspec (dllexport) SMS_STATUS SmsDupFolder(
  1644.                                 HANDLE hParent,
  1645.                                 HANDLE hFolder,
  1646.                                 HANDLE *phNewFolder );
  1647.  
  1648. // ====================================================================
  1649. //  Scalar APIs.
  1650. // ====================================================================
  1651.  
  1652. __declspec (dllexport) SMS_STATUS SmsGetScalarCount(
  1653.                                 HANDLE hFolder,
  1654.                                 DWORD *pctScalars );
  1655.  
  1656. __declspec (dllexport) SMS_STATUS SmsGetNextScalar(
  1657.                                 HANDLE hFolder,
  1658.                                 SCALAR *pScalarStruct );
  1659.  
  1660. __declspec (dllexport) SMS_STATUS SmsGetScalarByName(
  1661.                                 HANDLE hFolder,
  1662.                                 const char *pszName,
  1663.                                 SCALAR *pScalarStruct );
  1664.  
  1665. __declspec (dllexport) SMS_STATUS SmsSetScalar(
  1666.                                 HANDLE hFolder,
  1667.                                 SCALAR *pScalarStruct );
  1668.  
  1669.  
  1670.  
  1671. // ====================================================================
  1672. //
  1673. //  FilterContainer APIs
  1674. //
  1675. // ====================================================================
  1676.  
  1677. __declspec (dllexport) SMS_STATUS SmsOpenFilterContainer(
  1678.                                 HANDLE hConnection,
  1679.                                 HANDLE *phFContainer );
  1680.  
  1681. __declspec (dllexport) SMS_STATUS SmsCloseFilterContainer(
  1682.                                 HANDLE hFContainer );
  1683.  
  1684. __declspec (dllexport) SMS_STATUS SmsGetNextFilter(
  1685.                                 HANDLE hFContainer,
  1686.                                 DWORD frType,
  1687.                                 HANDLE *phFilter );
  1688.  
  1689. __declspec (dllexport) SMS_STATUS SmsGetFilterByID(
  1690.                                 HANDLE hFContainer,
  1691.                                 DWORD frType,
  1692.                                 const char *pszID,
  1693.                                 HANDLE *phFilter );
  1694.  
  1695. __declspec (dllexport) SMS_STATUS SmsGetFilterID(
  1696.                                 HANDLE hFilter,
  1697.                                 char *pszID );
  1698.  
  1699. __declspec (dllexport) SMS_STATUS SmsCommitFilter(
  1700.                                 HANDLE hFilter,
  1701.                                 HANDLE hFContainer );
  1702.  
  1703.  
  1704.  
  1705. // ====================================================================
  1706. //
  1707. //  Filter APIs
  1708. //
  1709. // ====================================================================
  1710.  
  1711. __declspec (dllexport) SMS_STATUS SmsCreateFilter(
  1712.                                 DWORD frType,
  1713.                                 HANDLE hConnection,
  1714.                                 HANDLE *phFilter );
  1715.  
  1716. __declspec (dllexport) SMS_STATUS SmsCloseFilter(
  1717.                                 HANDLE hFilter );
  1718.  
  1719. __declspec (dllexport) SMS_STATUS SmsGetFilterType(
  1720.                                 HANDLE hFilter,
  1721.                                 DWORD *pfilterType,
  1722.                                 char *pszTag );
  1723.  
  1724. __declspec (dllexport) SMS_STATUS SmsGetToken(
  1725.                                 HANDLE hObject,
  1726.                                 INT iIndex,
  1727.                                 TOKEN *pTokenInfo);
  1728.  
  1729. __declspec (dllexport) SMS_STATUS SmsAddToken(
  1730.                                 HANDLE hObject,
  1731.                                 ANDOR opAndOr,
  1732.                                 TOKEN *pTokenInfo,
  1733.                                 INT iIndex );
  1734.  
  1735. __declspec (dllexport) SMS_STATUS SmsGetTokenCount(
  1736.                                 HANDLE hObject,
  1737.                                 DWORD *pctTokens );
  1738.  
  1739. __declspec (dllexport) SMS_STATUS SmsManipulateTokens(
  1740.                                 HANDLE hObject,
  1741.                                 DWORD dwFlags,
  1742.                                 INT iStart,
  1743.                                 INT iEnd );
  1744.  
  1745. __declspec (dllexport) SMS_STATUS SmsGetAllFilters(
  1746.                                 HANDLE hContainer,
  1747.                                 HANDLE *pahFilters,
  1748.                                 DWORD *pctFilters );
  1749.  
  1750.  
  1751. __declspec (dllexport) SMS_STATUS SmsEnumObjectTypes(
  1752.                                 HANDLE hConnection,
  1753.                                 SMSBUFF *pObjects,
  1754.                                 DWORD *pCtObjects );
  1755.  
  1756. __declspec (dllexport) SMS_STATUS SmsEnumObjects(
  1757.                                 HANDLE hConn,
  1758.                                 char *pszObjectType,
  1759.                                 SMSBUFF *pPredecessors,
  1760.                                 DWORD ctPredecessors,
  1761.                                 OBJDESCRIPTOR *pObjects,
  1762.                                 DWORD *pCtObjects );
  1763.  
  1764.  
  1765. #ifdef __cplusplus
  1766. }
  1767. #endif
  1768.  
  1769. #pragma option pop /*P_O_Pop*/
  1770. #endif  // _SMSAPI_H_
  1771.  
  1772. /* EOF: smsapi.h */
  1773.  
  1774.