← Back to branch summary

~ubuntu-branches/debian/sid/openchange/sid

« back to all changes in this revision

Viewing changes to exchange.idl

  • Committer: Package Import Robot
  • Author(s): Jelmer Vernooij
  • Date: 2012-04-12 20:07:57 UTC
  • mfrom: (11 sid)
  • mto: This revision was merged to the branch mainline in revision 12.
  • Revision ID: package-import@ubuntu.com-20120412200757-k933d9trljmxj1l4
Tags: 1:1.0-4
* openchangeserver: Add dependency on openchangeproxy.
* Rebuild against newer version of Samba 4.
* Use dpkg-buildflags.
* Migrate to Git, update Vcs-Git header.
* Switch to debhelper 9.

Show diffs side-by-side

added added

removed removed

Lines of Context:
exchange.idl
229
229
                SortTypeDisplayName_W           = 0x000003E9
230
230
        } TableSortOrders;
231
231
 
 
232
        typedef [v1_enum] enum {
 
233
                MID_BEGINNING_OF_TABLE  = 0x0,
 
234
                MID_END_OF_TABLE        = 0x2,
 
235
                MID_CURRENT             = 0x1
 
236
        } NSPI_MID;
 
237
 
232
238
        typedef [flag(NDR_NOALIGN)] struct {
233
239
                TableSortOrders SortType;
234
240
                uint32          ContainerID;
235
 
                uint32          CurrentRec;
236
 
                uint32          Delta;
 
241
                NSPI_MID        CurrentRec;
 
242
                int32           Delta;
237
243
                uint32          NumPos;
238
244
                uint32          TotalRecs;
239
245
                uint32          CodePage;
275
281
        typedef struct {
276
282
                [range(0,100000)] uint32                        cValues;
277
283
                [string,size_is(cValues),charset(UTF16)] uint16 **lppszW;
278
 
        } WStringArray_r;
 
284
        } StringArrayW_r;
279
285
 
280
286
        typedef struct {
281
287
                [range(0,100000)] uint32                        Count;
282
288
                [string,size_is(Count),charset(UTF16)] uint16   *Strings[];
283
 
        } WStringsArray_r;
 
289
        } StringsArrayW_r;
284
290
 
285
291
        typedef struct {
286
292
                [range(0,100001)] uint32                                cValues;
287
293
                [size_is(cValues+1),length_is(cValues)] MAPITAGS        aulPropTag[];
288
294
        } SPropTagArray;
289
295
 
290
 
        typedef [public] struct {
 
296
        typedef [public,noprint] struct {
291
297
                [range(0,2097152)] uint32       cb;
292
298
                [size_is(cb)] uint8             *lpb;
293
299
        } Binary_r;
309
315
 
310
316
        typedef struct {
311
317
                [range(0,100000)] uint32        cValues;
 
318
                [size_is(cValues)] dlong        *lpi8; 
 
319
        } I8Array_r;
 
320
 
 
321
        typedef struct {
 
322
                [range(0,100000)] uint32        cValues;
312
323
                [size_is(cValues)] Binary_r     *lpbin;
313
324
        } BinaryArray_r;
314
325
 
337
348
                [case(PT_ERROR)]                MAPISTATUS              err;
338
349
                [case(PT_MV_I2)]                ShortArray_r            MVi;
339
350
                [case(PT_MV_LONG)]              LongArray_r             MVl;
 
351
                [case(PT_MV_I8)]                I8Array_r               MVi8;
340
352
                [case(PT_MV_STRING8)]           StringArray_r           MVszA;
341
353
                [case(PT_MV_BINARY)]            BinaryArray_r           MVbin;
342
354
                [case(PT_MV_CLSID)]             FlatUIDArray_r          MVguid;
343
 
                [case(PT_MV_UNICODE)]           WStringArray_r          MVszW;
 
355
                [case(PT_MV_UNICODE)]           StringArrayW_r          MVszW;
344
356
                [case(PT_MV_SYSTIME)]           DateTimeArray_r         MVft;
345
357
                [case(PT_NULL)]                 uint32                  null;
346
358
                [case(PT_OBJECT)]               uint32                  object;
626
638
        MAPISTATUS NspiModLinkAtt(
627
639
                [in] policy_handle                      *handle,
628
640
                [in] uint32                             dwFlags,
629
 
                [in] uint32                             ulPropTag,
 
641
                [in] MAPITAGS                           ulPropTag,
630
642
                [in] uint32                             MId,
631
643
                [in] BinaryArray_r                      *lpEntryIds
632
644
                );
694
706
                [in] uint32                     Reserved,
695
707
                [in] STAT                       *pStat,
696
708
                [in,unique] SPropTagArray       *pPropTags,
697
 
                [in] WStringsArray_r            *paWStr,
 
709
                [in] StringsArrayW_r            *paWStr,
698
710
                [out] PropertyTagArray_r        **ppMIds,
699
711
                [out] SRowSet                   **ppRows
700
712
                );
920
932
                        op_MAPI_HardDeleteMessages              = 0x91,
921
933
                        op_MAPI_HardDeleteMessagesAndSubfolders = 0x92,
922
934
                        op_MAPI_SetLocalReplicaMidsetDeleted    = 0x93,
 
935
                        op_MAPI_Backoff                         = 0xf9,
923
936
                        op_MAPI_Logon                           = 0xfe,
 
937
                        op_MAPI_BufferTooSmall                  = 0xff,
924
938
                        /****** custom MAPI opnum for mapiproxy ******/
925
939
                        op_MAPI_proxypack                       = 0xa5
926
940
                } MAPI_OPNUM;
936
950
                uint32 lpl[cValues]; 
937
951
        } mapi_MV_LONG_STRUCT;
938
952
 
939
 
        typedef [public] struct {
 
953
        typedef struct {
940
954
                raw8string lppszA;
941
955
        } mapi_LPSTR;
942
956
 
945
959
                mapi_LPSTR strings[cValues]; 
946
960
        } mapi_SLPSTRArray;
947
961
 
948
 
        typedef struct {
 
962
        typedef [public] struct {
949
963
                [flag(STR_NULLTERM)] string lppszW;
950
964
        } mapi_LPWSTR;
951
965
 
952
 
        typedef struct {
 
966
        typedef [public] struct {
953
967
                uint32 cValues;
954
968
                mapi_LPWSTR strings[cValues];
955
 
        } mapi_SPLSTRArrayW;
 
969
        } mapi_SLPSTRArrayW;
956
970
        
957
971
        typedef [public] struct {
958
972
                uint32          cValues;
959
973
                SBinary_short   bin[cValues];
960
974
        } mapi_SBinaryArray;
961
975
 
962
 
        typedef struct {
 
976
        typedef [public] struct {
963
977
                uint32          cValues;
964
978
                GUID            lpguid[cValues];
965
979
        } mapi_SGuidArray;
1025
1039
                [case(ActionType_OP_COPY)]              MoveCopy_Action                 CopyAction;
1026
1040
                [case(ActionType_OP_REPLY)]             ReplyOOF_Action                 ReplyAction;
1027
1041
                [case(ActionType_OP_OOF_REPLY)]         ReplyOOF_Action                 ReplyOOFAction;
1028
 
                [case(ActionType_OP_DEFER_ACTION)][flag(NDR_REMAINING)] DATA_BLOB       DeferAction;
 
1042
                [case(ActionType_OP_DEFER_ACTION)][flag(NDR_REMAINING|NDR_NOALIGN)] DATA_BLOB   DeferAction;
1029
1043
                [case(ActionType_OP_BOUNCE)]            BounceCode                      BounceCode;
1030
1044
                [case(ActionType_OP_TAG)]               mapi_SPropValue_wrap            PropValue;
1031
1045
                [case(ActionType_OP_FORWARD)]           ForwardDelegate_Action          ForwardAction;
1043
1057
 
1044
1058
        typedef [flag(NDR_NOALIGN)] struct {
1045
1059
                uint16                                  ActionLength;
1046
 
                [subcontext(0),subcontext_size(ActionLength),flag(NDR_REMAINING)] ActionBlockData ActionBlockData;
 
1060
                [subcontext(0),subcontext_size(ActionLength),flag(NDR_REMAINING|NDR_NOALIGN)] ActionBlockData ActionBlockData;
1047
1061
        } ActionBlock;
1048
1062
 
1049
1063
        typedef [flag(NDR_NOALIGN)] struct {
1052
1066
        } RuleAction;
1053
1067
 
1054
1068
        typedef [public,nodiscriminant,flag(NDR_NOALIGN)] union {
 
1069
                [case(PT_NULL)];
1055
1070
                [case(PT_I2)]           uint16                  i;
1056
1071
                [case(PT_LONG)]         uint32                  l;
1057
1072
                [case(PT_DOUBLE)]       double                  dbl;
1068
1083
                [case(PT_SVREID)]       SBinary_short           bin;
1069
1084
                [case(PT_MV_LONG)]      mapi_MV_LONG_STRUCT     MVl;    
1070
1085
                [case(PT_MV_STRING8)]   mapi_SLPSTRArray        MVszA;
1071
 
                [case(PT_MV_UNICODE)]   mapi_SPLSTRArrayW       MVszW;
 
1086
                [case(PT_MV_UNICODE)]   mapi_SLPSTRArrayW       MVszW;
1072
1087
                [case(PT_MV_CLSID)]     mapi_SGuidArray         MVguid;
1073
1088
                [case(PT_MV_BINARY)]    mapi_SBinaryArray       MVbin;
1074
1089
        } mapi_SPropValue_CTR;
1080
1095
 
1081
1096
        typedef [public,flag(NDR_NOALIGN)] struct {
1082
1097
                uint16                                  cValues;
1083
 
                [flag(NDR_REMAINING)]mapi_SPropValue    lpProps[cValues];
 
1098
                [flag(NDR_REMAINING|NDR_NOALIGN)]mapi_SPropValue        lpProps[cValues];
1084
1099
        } mapi_SPropValue_array;
1085
1100
 
1086
1101
        typedef [flag(NDR_NOALIGN)] struct {
1158
1173
        typedef [enum8bit] enum {
1159
1174
                ReadOnly        = 0x0,
1160
1175
                ReadWrite       = 0x1,
1161
 
                Create          = 0x3,
 
1176
                BestAccess      = 0x3,
1162
1177
                OpenSoftDelete  = 0x4
1163
1178
        } OpenMessage_OpenModeFlags;
1164
1179
 
1266
1281
// TODO: figure out if "layout" can go
1267
1282
                uint8                                                                   layout;
1268
1283
// TODO: convert this to a proper structure - see if we already have one.
1269
 
                [flag(NDR_REMAINING)] DATA_BLOB                                         prop_values;
 
1284
                [flag(NDR_REMAINING|NDR_NOALIGN)] DATA_BLOB                                             prop_values;
1270
1285
        } RecipientRow;
1271
1286
 
1272
1287
        typedef [flag(NDR_NOALIGN)] struct {
1273
 
                ulRecipClass    RecipClass;
1274
 
                CODEPAGEID      codepage;
1275
 
                uint16          Reserved;
1276
 
                [subcontext(2)] RecipientRow    RecipientRow;
1277
 
        } OpenMessage_recipients;
1278
 
 
1279
 
        typedef [flag(NDR_NOALIGN)] struct {
1280
1288
                boolean8                HasNamedProperties;
1281
1289
                TypedString             SubjectPrefix;
1282
1290
                TypedString             NormalizedSubject;
1283
1291
                uint16                  RecipientCount;
1284
1292
                mapi_SPropTagArray      RecipientColumns;
1285
1293
                uint8                   RowCount;
1286
 
                OpenMessage_recipients  recipients[RowCount];
 
1294
                OpenRecipientRow        RecipientRows[RowCount];
1287
1295
        } OpenMessage_repl;
1288
1296
 
1289
1297
        /**************************/
1348
1356
 
1349
1357
        typedef [flag(NDR_NOALIGN)] struct {
1350
1358
                uint8           layout;
1351
 
                [flag(NDR_REMAINING)] DATA_BLOB prop_data;
 
1359
                [flag(NDR_REMAINING|NDR_NOALIGN)] DATA_BLOB prop_data;
1352
1360
        } GetProps_repl;
1353
1361
 
1354
1362
        /*************************/
1447
1455
        typedef [flag(NDR_NOALIGN)]struct {
1448
1456
                uint32          idx;
1449
1457
                ulRecipClass    RecipClass;             
1450
 
                [subcontext(2),flag(NDR_REMAINING)] RecipientRow RecipientRow;
 
1458
                [subcontext(2),flag(NDR_REMAINING|NDR_NOALIGN)] RecipientRow RecipientRow;
1451
1459
        } ModifyRecipientRow;
1452
1460
 
1453
1461
        typedef [flag(NDR_NOALIGN)] struct {
1470
1478
 
1471
1479
        typedef [flag(NDR_NOALIGN)] struct {
1472
1480
                uint32                          RowId;
1473
 
                ulRecipClass                    RecipientType;
1474
 
                uint16                          CodePageId;
 
1481
                ulRecipClass                    RecipClass;
 
1482
                CODEPAGEID                      CodePageId;
1475
1483
                uint16                          ulReserved;
1476
1484
                [subcontext(2)] RecipientRow    RecipientRow;
1477
1485
        } ReadRecipientRow;
1483
1491
 
1484
1492
        /*************************/
1485
1493
        /* EcDoRpc Function 0x10 */
1486
 
        typedef [flag(NDR_NOALIGN)] struct {
 
1494
        typedef [public,flag(NDR_NOALIGN)] struct {
1487
1495
                ulRecipClass            RecipientType;
1488
 
                uint16                  CodePageId;
 
1496
                CODEPAGEID              CodePageId;
1489
1497
                uint16                  Reserved;
1490
 
                uint16                  RecipientRowSize;
1491
 
                [subcontext(0),subcontext_size(RecipientRowSize),flag(NDR_REMAINING)]RecipientRow       RecipientRow;
 
1498
                [subcontext(2)]RecipientRow             RecipientRow;
1492
1499
        } OpenRecipientRow;
1493
1500
 
1494
1501
        typedef [flag(NDR_NOALIGN)] struct {
1524
1531
        typedef [flag(NDR_NOALIGN)] struct {
1525
1532
                uint8                           handle_idx;
1526
1533
                MSGFLAG_READ                    flags;
1527
 
                [flag(NDR_REMAINING)] DATA_BLOB clientdata;
 
1534
                /* TEMP HACK for editing notes without crashing Outlook:
 
1535
                   [flag(NDR_REMAINING|NDR_NOALIGN)] DATA_BLOB  clientdata; */
1528
1536
        } SetMessageReadFlag_req;
1529
1537
 
1530
1538
        typedef [nodiscriminant, flag(NDR_NOALIGN)] union {
1540
1548
        typedef [flag(NDR_NOALIGN)] struct {
1541
1549
                boolean8                                                        ReadStatusChanged;
1542
1550
                [switch_is(ReadStatusChanged)] SetMessageReadFlag_LogonId       LogonId;
1543
 
                [switch_is(ReadStatusChanged)] SetMessageReadFlag_ClientData    ClientData;
 
1551
                /* TEMP HACK for editing notes without crashing Outlook:
 
1552
                   [switch_is(ReadStatusChanged)]
 
1553
                   SetMessageReadFlag_ClientData        ClientData; */
1544
1554
        } SetMessageReadFlag_repl;
1545
1555
 
1546
1556
        /*************************/
1579
1589
        
1580
1590
        typedef [enum8bit, flag(NDR_PAHEX)] enum {
1581
1591
                TABLE_SORT_ASCEND = 0x0,
 
1592
                TABLE_SORT_DESCEND = 0x1,
 
1593
                TABLE_SORT_MAXIMUM_CATEGORY = 0x4
 
1594
                /* old values :
1582
1595
                TABLE_SORT_COMBINE = 0x1,
1583
1596
                TABLE_SORT_DESCEND = 0x2
 
1597
                */
1584
1598
        } TABLE_SORT;
1585
1599
 
1586
1600
        typedef [public, flag(NDR_NOALIGN)] struct _SSortOrder{
1746
1760
 
1747
1761
        /**************************/
1748
1762
        /* EcDoRpc Function 0x15  */
 
1763
        typedef [v1_enum] enum {
 
1764
                TBL_LEAF_ROW            = 0x1,
 
1765
                TBL_EMPTY_CATEGORY      = 0x2,
 
1766
                TBL_EXPANDED_CATEGORY   = 0x3,
 
1767
                TBL_COLLAPSED_CATEGORY  = 0x4
 
1768
        } RowType;
 
1769
 
1749
1770
        typedef [enum8bit] enum {
1750
1771
                TBL_ADVANCE             = 0x0,
1751
1772
                TBL_NOADVANCE           = 0x1,
1761
1782
        typedef [nopush,nopull,flag(NDR_NOALIGN)] struct {
1762
1783
                uint8           Origin;
1763
1784
                uint16          RowCount;
1764
 
                [flag(NDR_REMAINING)]DATA_BLOB  RowData;
 
1785
                [flag(NDR_REMAINING|NDR_NOALIGN)]DATA_BLOB      RowData;
1765
1786
        } QueryRows_repl;
1766
1787
 
1767
1788
        /**************************/
1800
1821
 
1801
1822
        typedef [flag(NDR_NOALIGN)] struct {
1802
1823
                boolean8        HasSoughtLess;
1803
 
                uint32          RowsSought;
 
1824
                int32           RowsSought;
1804
1825
        } SeekRow_repl;
1805
1826
 
1806
1827
        /**************************/
2076
2097
                [case(0x1)][flag(STR_NULLTERM)] string  lpszW;
2077
2098
        } MessageClass;
2078
2099
 
2079
 
        typedef [flag(NDR_NOALIGN)] struct {
2080
 
                GUID            DatabaseGUID;
2081
 
                uint8           GlobalCounter[6];
 
2100
        typedef [public,nodiscriminant, flag(NDR_NOALIGN)] union {
 
2101
                [case(0x1)] uint8       bytes[6];
 
2102
                [default] dlong         value;
 
2103
        } GLOBCNT;
 
2104
 
 
2105
        typedef [public,flag(NDR_NOALIGN)] struct {
 
2106
                GUID                    GUID;
 
2107
                [switch_is(1)] GLOBCNT  GLOBCNT;
2082
2108
        } GID;
2083
2109
 
 
2110
        typedef [public,flag(NDR_NOALIGN)] struct {
 
2111
                uint16                  ReplID;
 
2112
                [switch_is(1)] GLOBCNT  GLOBCNT;
 
2113
        } ShortTermID; /* MID, FID, CN */
 
2114
 
 
2115
        typedef [public,flag(NDR_NOALIGN)] struct {
 
2116
                GUID                    GUID;
 
2117
                uint8                   Size;
 
2118
                uint8                   Data[Size];
 
2119
        } XID;
 
2120
 
2084
2121
        typedef [enum16bit] enum {
2085
2122
                TABLE_CHANGED           =       0x1,
2086
2123
                TABLE_ROW_ADDED         =       0x3,
2089
2126
                TABLE_RESTRICT_DONE     =       0x7
2090
2127
        } RichTableNotificationType;
2091
2128
 
 
2129
        typedef [nodiscriminant, flag(NDR_NOALIGN)] union {
 
2130
                [case(0x0)];
 
2131
                [case(0xffff)];
 
2132
                [default] MAPITAGS              Tags[level];
 
2133
        } NotificationTags;
 
2134
 
2092
2135
        /* NewMailNotification: case 0x2 and 0x8002 */
2093
2136
        typedef [flag(NDR_NOALIGN)] struct {
2094
2137
                hyper                                   FID;
2103
2146
                hyper                                   FID;
2104
2147
                hyper                                   ParentFID;
2105
2148
                uint16                                  TagCount;
2106
 
                MAPITAGS                                Tags[TagCount];
 
2149
                [switch_is(TagCount)] NotificationTags  NotificationTags;
2107
2150
        } FolderCreatedNotification;
2108
2151
 
2109
2152
        /* FolderDeletedNotification: case 0x8 */
2116
2159
        typedef [flag(NDR_NOALIGN)] struct {
2117
2160
                hyper                   FID;
2118
2161
                uint16                  TagCount;
2119
 
                MAPITAGS                Tags[TagCount];
 
2162
                [switch_is(TagCount)] NotificationTags  NotificationTags;
2120
2163
        } FolderModifiedNotification_10;
2121
2164
 
2122
2165
        /* FolderMoveCopyNotification: case 0x20 and 0x40 */
2172
2215
        typedef [flag(NDR_NOALIGN)] struct {
2173
2216
                hyper                   FID;
2174
2217
                uint16                  TagCount;
2175
 
                MAPITAGS                Tags[TagCount];
 
2218
                [switch_is(TagCount)] NotificationTags  NotificationTags;
2176
2219
                uint32                  TotalMessageCount;
2177
2220
        } FolderModifiedNotification_1010;
2178
2221
 
2180
2223
        typedef [flag(NDR_NOALIGN)] struct {
2181
2224
                hyper                   FID;
2182
2225
                uint16                  TagCount;
2183
 
                MAPITAGS                Tags[TagCount];
 
2226
                [switch_is(TagCount)] NotificationTags  NotificationTags;
2184
2227
                uint32                  UnreadMessageCount;
2185
2228
        } FolderModifiedNotification_2010;
2186
2229
 
2188
2231
        typedef [flag(NDR_NOALIGN)] struct {
2189
2232
                hyper                   FID;
2190
2233
                uint16                  TagCount;
2191
 
                MAPITAGS                Tags[TagCount];
 
2234
                [switch_is(TagCount)] NotificationTags  NotificationTags;
2192
2235
                uint32                  TotalMessageCount;
2193
2236
                uint32                  UnreadMessageCount;
2194
2237
        } FolderModifiedNotification_3010;
2198
2241
                hyper                                   FID;
2199
2242
                hyper                                   MID;
2200
2243
                uint16                                  TagCount;
2201
 
                MAPITAGS                                Tags[TagCount];
 
2244
                [switch_is(TagCount)] NotificationTags  NotificationTags;
2202
2245
        } MessageCreatedNotification;
2203
2246
 
2204
2247
        /* MessageDeletedNotification: case 0x8008 */
2212
2255
                hyper                                   FID;
2213
2256
                hyper                                   MID;
2214
2257
                uint16                                  TagCount;
2215
 
                MAPITAGS                                Tags[TagCount];
 
2258
                [switch_is(TagCount)] NotificationTags  NotificationTags;
2216
2259
        } MessageModifiedNotification;
2217
2260
 
2218
2261
        /* MessageMoveCopyNotification: case 0x8020 and 0x8040 */
2268
2311
                hyper                                   MID;
2269
2312
                hyper                                   SearchFID;
2270
2313
                uint16                                  TagCount;
2271
 
                MAPITAGS                                Tags[TagCount];
 
2314
                [switch_is(TagCount)] NotificationTags  NotificationTags;
2272
2315
        } SearchMessageCreatedNotification;
2273
2316
 
2274
2317
        /* SearchMessageRemovedNotification: case 0xc008 */
2283
2326
                hyper                                   FID;
2284
2327
                hyper                                   MID;
2285
2328
                uint16                                  TagCount;
2286
 
                MAPITAGS                                Tags[TagCount];
 
2329
                [switch_is(TagCount)] NotificationTags  NotificationTags;
2287
2330
        } SearchMessageModifiedNotification;
2288
2331
 
2289
2332
        typedef [nodiscriminant] union {
2350
2393
                [switch_is(ByteCount)]  MaximumByteCount        MaximumByteCount;
2351
2394
        } ReadStream_req;
2352
2395
 
2353
 
        typedef [flag(NDR_ALIGN2)] struct {
2354
 
                [subcontext(2), flag(NDR_REMAINING)] DATA_BLOB data;
 
2396
        typedef [flag(NDR_NOALIGN)] struct {
 
2397
                [subcontext(2), flag(NDR_REMAINING|NDR_NOALIGN)] DATA_BLOB data;
2355
2398
        } ReadStream_repl;
2356
2399
 
2357
2400
        /*************************/
2358
2401
        /* EcDoRpc Function 0x2d */
2359
2402
        typedef [flag(NDR_NOALIGN)] struct {
2360
 
                [subcontext(2), flag(NDR_REMAINING)] DATA_BLOB  data;
 
2403
                [subcontext(2), flag(NDR_REMAINING|NDR_NOALIGN)] DATA_BLOB      data;
2361
2404
        } WriteStream_req;
2362
2405
 
2363
2406
 
2702
2745
                TypedString             SubjectPrefix;
2703
2746
                TypedString             NormalizedSubject;
2704
2747
                uint16                  RecipientCount;
2705
 
                uint16                  ColumnCount;
2706
 
                MAPITAGS                RecipientColumns[ColumnCount];
 
2748
                mapi_SPropTagArray      RecipientColumns;
2707
2749
                uint8                   RowCount;
2708
2750
                OpenRecipientRow        RecipientRows[RowCount];
2709
2751
        } OpenEmbeddedMessage_repl;
2858
2900
                uint16          TotalStepCount;
2859
2901
                uint8           Reserved;
2860
2902
                uint16          TransferBufferSize;
2861
 
                [subcontext(0),subcontext_size(TransferBufferSize),flag(NDR_REMAINING)] DATA_BLOB TransferBuffer;
 
2903
                [subcontext(0),subcontext_size(TransferBufferSize),flag(NDR_REMAINING|NDR_NOALIGN)] DATA_BLOB TransferBuffer;
2862
2904
        } FastTransferSourceGetBuffer_repl;
2863
2905
 
2864
2906
        /**************************/
2940
2982
        /* EcDoRpc Function 0x54  */
2941
2983
        typedef [flag(NDR_NOALIGN)] struct {
2942
2984
                uint16          TransferBufferSize;
2943
 
                [subcontext(0),subcontext_size(TransferBufferSize),flag(NDR_REMAINING)] DATA_BLOB TransferBuffer;
 
2985
                [subcontext(0),subcontext_size(TransferBufferSize),flag(NDR_REMAINING|NDR_NOALIGN)] DATA_BLOB TransferBuffer;
2944
2986
        } FastTransferDestinationPutBuffer_req;
2945
2987
 
2946
2988
        typedef [flag(NDR_NOALIGN)] struct {
2986
3028
 
2987
3029
        /*************************/
2988
3030
        /* EcDoRpc Function 0x56 */
 
3031
        typedef [enum8bit, flag(NDR_PAHEX)] enum {
 
3032
                GetIDsFromNames_GetOnly         = 0x00,
 
3033
                GetIDsFromNames_GetOrCreate     = 0x02
 
3034
        } GetIDsFromNamesFlags;
 
3035
 
2989
3036
        typedef [flag(NDR_NOALIGN)] struct {
2990
 
                uint8           ulFlags;
2991
 
                uint16          count;
2992
 
                MAPINAMEID      nameid[count];
 
3037
                GetIDsFromNamesFlags    ulFlags;
 
3038
                uint16                  count;
 
3039
                MAPINAMEID              nameid[count];
2993
3040
        } GetIDsFromNames_req;
2994
3041
 
2995
3042
        typedef [flag(NDR_NOALIGN)] struct {
3028
3075
        typedef [flag(NDR_NOALIGN)] struct {
3029
3076
                uint32          ExpandedRowCount;
3030
3077
                uint16          RowCount;
3031
 
                [flag(NDR_REMAINING)]DATA_BLOB  RowData;
 
3078
                [flag(NDR_REMAINING|NDR_NOALIGN)]DATA_BLOB  RowData;
3032
3079
        } ExpandRow_repl;
3033
3080
 
3034
3081
        /*************************/
3137
3184
        typedef [flag(NDR_NOALIGN)] struct {
3138
3185
                boolean8        HasFinished;
3139
3186
                uint16          DataSize;
3140
 
                [subcontext(0), subcontext_size(DataSize), flag(NDR_REMAINING)] DATA_BLOB Data;
 
3187
                [subcontext(0), subcontext_size(DataSize), flag(NDR_REMAINING|NDR_NOALIGN)] DATA_BLOB Data;
3141
3188
        } ReadPerUserInformation_repl;
3142
3189
 
3143
3190
        /*************************/
3147
3194
                boolean8        HasFinished;
3148
3195
                uint32          DataOffset;
3149
3196
                uint16          DataSize;
3150
 
                [subcontext(0), subcontext_size(DataSize), flag(NDR_REMAINING)] DATA_BLOB Data;
 
3197
                [subcontext(0), subcontext_size(DataSize), flag(NDR_REMAINING|NDR_NOALIGN)] DATA_BLOB Data;
3151
3198
                GUID            ReplGuid;       /* Note: ReplGuid gets only included under specific circumstances */
3152
3199
        } WritePerUserInformation_req;
3153
3200
 
3277
3324
        /*************************/
3278
3325
        /* EcDoRpc Function 0x70 */
3279
3326
        typedef [enum8bit] enum {
3280
 
                SynchronizationType_Contents    = 0x1,
3281
 
                SynchronizationType_Hierarchy   = 0x2
 
3327
                Contents        = 0x1,
 
3328
                Hierarchy       = 0x2
3282
3329
        } SynchronizationType;
3283
3330
 
 
3331
        typedef [bitmap8bit] bitmap {
 
3332
                SendOptions_Unicode             = 0x1,
 
3333
                SendOptions_ForUpload           = 0x3,
 
3334
                SendOptions_RecoverMode         = 0x4,
 
3335
                SendOptions_ForceUnicode        = 0x8,
 
3336
                SendOptions_Partial             = 0x10
 
3337
        } SendOptions;
 
3338
 
3284
3339
        typedef [bitmap16bit] bitmap {
3285
 
                SynchronizationFlag_Unicode                     = 0x0001,
3286
 
                SynchronizationFlag_NoDeletions                 = 0x0002,
3287
 
                SynchronizationFlag_IgnoreNoLongerInScope       = 0x0004,
3288
 
                SynchronizationFlag_ReadState                   = 0x0008,
3289
 
                SynchronizationFlag_FAI                         = 0x0010,
3290
 
                SynchronizationFlag_Normal                      = 0x0020,
3291
 
                SynchronizationFlag_OnlySpecifiedProperties     = 0x0080,
3292
 
                SynchronizationFlag_NoForeignIdentifiers        = 0x0100,
 
3340
                SynchronizationFlag_Unicode                     = 0x1,
 
3341
                SynchronizationFlag_NoDeletions                 = 0x2,
 
3342
                SynchronizationFlag_NoSoftDeletions             = 0x4,
 
3343
                SynchronizationFlag_ReadState                   = 0x8,
 
3344
                SynchronizationFlag_FAI                         = 0x10,
 
3345
                SynchronizationFlag_Normal                      = 0x20,
 
3346
                SynchronizationFlag_OnlySpecifiedProperties     = 0x80,
 
3347
                SynchronizationFlag_NoForeignIdentifiers        = 0x100,
3293
3348
                SynchronizationFlag_Reserved                    = 0x1000,
3294
3349
                SynchronizationFlag_BestBody                    = 0x2000,
3295
3350
                SynchronizationFlag_IgnoreSpecifiedOnFAI        = 0x4000,
3297
3352
        } SynchronizationFlag;
3298
3353
 
3299
3354
        typedef [bitmap32bit] bitmap {
3300
 
                SynchronizationExtraFlag_Eid                    = 0x00000001,
3301
 
                SynchronizationExtraFlag_MessageSize            = 0x00000002,
3302
 
                SynchronizationExtraFlag_Cn                     = 0x00000004,
3303
 
                SynchronizationExtraFlag_OrderByDeliveryTime    = 0x00000008
 
3355
                Eid                     = 0x00000001,
 
3356
                MessageSize             = 0x00000002,
 
3357
                Cn                      = 0x00000004,
 
3358
                OrderByDeliveryTime     = 0x00000008
3304
3359
        } SynchronizationExtraFlags;
3305
3360
 
3306
3361
        typedef [flag(NDR_NOALIGN)] struct {
3307
3362
                uint8                                   handle_idx;
3308
3363
                SynchronizationType                     SynchronizationType;
3309
 
                FastCopySendOptions                     SendOptions;
3310
 
                SynchronizationFlag                     SynchronizationFlags;
 
3364
                SendOptions                             SendOptions;
 
3365
                SynchronizationFlag                     SynchronizationFlag;
3311
3366
                uint16                                  RestrictionSize;
3312
 
                [subcontext(0),subcontext_size(RestrictionSize),flag(NDR_REMAINING)] DATA_BLOB  RestrictionData;
 
3367
                [subcontext(0),subcontext_size(RestrictionSize),flag(NDR_REMAINING|NDR_NOALIGN)] DATA_BLOB      RestrictionData;
3313
3368
                SynchronizationExtraFlags               SynchronizationExtraFlags;
3314
3369
                mapi_SPropTagArray                      PropertyTags;
3315
3370
        } SyncConfigure_req;
3347
3402
 
3348
3403
        /*************************/
3349
3404
        /* EcDoRpc Function 0x74 */
 
3405
        typedef [bitmap8bit] bitmap {
 
3406
                SyncImportDeletes_Hierarchy     = 0x01,
 
3407
                SyncImportDeletes_HardDelete    = 0x02
 
3408
        } SyncImportDeletesFlags;
 
3409
 
3350
3410
        typedef [flag(NDR_NOALIGN)] struct {
3351
 
                boolean8                IsHierarchy;
 
3411
                SyncImportDeletesFlags  Flags;
3352
3412
                mapi_SPropValue_array   PropertyValues;
3353
3413
        } SyncImportDeletes_req;
3354
3414
 
3364
3424
                SP_PidTagCnsetRead      = 0x67d20102
3365
3425
        } StateProperty;
3366
3426
 
 
3427
        typedef [v1_enum,flag(NDR_PAHEX)] enum {
 
3428
                DP_PidTagIdsetDeleted           = 0x67e50102,
 
3429
                DP_PidTagIdsetNoLongerInScope   = 0x40210102,
 
3430
                DP_PidTagIdsetExpired           = 0x67930102,
 
3431
                DP_PidTagIdsetRead              = 0x402d0102,
 
3432
                DP_PidTagIdsetUnread            = 0x402e0102
 
3433
        } DeltaProperty;
 
3434
 
3367
3435
        typedef [flag(NDR_NOALIGN)] struct {
3368
3436
                StateProperty           StateProperty;
3369
3437
                uint32                  TransferBufferSize;
3467
3535
 
3468
3536
        /*************************/
3469
3537
        /* EcDoRpc Function 0x80 */
3470
 
//      typedef [flag(NDR_NOALIGN)] struct {
3471
 
//              uint16          MessageSize;
3472
 
//              uint8           MessageId[MessageSize];
3473
 
//              boolean8        MarkAsRead;
3474
 
//      } MessageReadStates;
 
3538
        typedef [public,flag(NDR_NOALIGN)] struct {
 
3539
                uint16          MessageIdSize;
 
3540
                uint8           MessageId[MessageIdSize];
 
3541
                boolean8        MarkAsRead;
 
3542
        } MessageReadState;
3475
3543
 
3476
3544
        typedef [flag(NDR_NOALIGN)] struct {
3477
 
                uint16          MessageReadStateSize;
3478
 
                [subcontext(0),subcontext_size(MessageReadStateSize),flag(NDR_REMAINING)] DATA_BLOB MessageStates;
 
3545
                [subcontext(2),flag(NDR_REMAINING|NDR_NOALIGN)] DATA_BLOB MessageReadStates;
3479
3546
        } SyncImportReadStateChanges_req;
3480
3547
 
3481
3548
        typedef [flag(NDR_NOALIGN)] struct {
3550
3617
        /*************************/
3551
3618
        /* EcDoRpc Function 0x90 */
3552
3619
        typedef [flag(NDR_NOALIGN)] struct {
3553
 
                [subcontext(2), flag(NDR_REMAINING)] DATA_BLOB  data;
 
3620
                [subcontext(2), flag(NDR_REMAINING|NDR_NOALIGN)] DATA_BLOB      data;
3554
3621
        } WriteAndCommitStream_req;
3555
3622
 
3556
3623
 
3584
3651
 
3585
3652
        /*************************/
3586
3653
        /* EcDoRpc Function 0x93 */
3587
 
        typedef [flag(NDR_NOALIGN)] struct {
 
3654
        typedef [public,flag(NDR_NOALIGN)] struct {
3588
3655
                LongTermId      MinLongTermId;
3589
3656
                LongTermId      MaxLongTermId;
3590
3657
        } LongTermIdRange;
3591
3658
 
3592
3659
        typedef [flag(NDR_NOALIGN)] struct {
3593
 
                uint16          DataSize;
3594
 
                uint32          LongTermIdRangeCount;
3595
 
                LongTermIdRange LongTermIdRanges[LongTermIdRangeCount];
 
3660
                uint16                  DataSize;
 
3661
                uint32                  LongTermIdRangeCount;
 
3662
                LongTermIdRange         LongTermIdRanges[LongTermIdRangeCount];
3596
3663
        } SetLocalReplicaMidsetDeleted_req;
3597
3664
 
3598
3665
        typedef [flag(NDR_NOALIGN)] struct {
3599
3666
        } SetLocalReplicaMidsetDeleted_repl;
3600
3667
 
 
3668
        /**************************/
 
3669
        /* EcDoRpc Function 0xF9   */
 
3670
        typedef [nopush,nopull,flag(NDR_NOALIGN)] struct {
 
3671
        } Backoff_req;
 
3672
 
 
3673
        typedef [nopush,nopull,flag(NDR_NOALIGN)] struct {
 
3674
        } Backoff_repl;
 
3675
 
3601
3676
        /*************************/
3602
3677
        /* EcDoRpc Function 0xFE */
3603
3678
        typedef [public,bitmap8bit] bitmap {
3645
3720
        } ResponseFlags;
3646
3721
 
3647
3722
        typedef [flag(NDR_NOALIGN)] struct {
3648
 
                hyper                   FolderIds[13];
 
3723
                /* folders */
 
3724
                hyper                   Root;
 
3725
                hyper                   IPMSubTree;
 
3726
                hyper                   NonIPMSubTree;
 
3727
                hyper                   EFormsRegistry;
 
3728
                hyper                   FreeBusy;
 
3729
                hyper                   OAB;
 
3730
                hyper                   LocalizedEFormsRegistry;
 
3731
                hyper                   LocalFreeBusy;
 
3732
                hyper                   LocalOAB;
 
3733
                hyper                   NNTPIndex;
 
3734
                hyper                   _empty[3];
 
3735
 
3649
3736
                uint16                  ReplId;
3650
3737
                GUID                    Guid;
3651
3738
                GUID                    PerUserGuid;
3652
3739
        } store_pf;
3653
3740
 
3654
3741
        typedef [flag(NDR_NOALIGN)] struct {
3655
 
                hyper                   FolderIds[13];
 
3742
                /* folders */
 
3743
                hyper                   Root;
 
3744
                hyper                   DeferredAction;
 
3745
                hyper                   SpoolerQueue;
 
3746
                hyper                   IPMSubTree;
 
3747
                hyper                   Inbox;
 
3748
                hyper                   Outbox;
 
3749
                hyper                   SentItems;
 
3750
                hyper                   DeletedItems;
 
3751
                hyper                   CommonViews;
 
3752
                hyper                   Schedule;
 
3753
                hyper                   Search;
 
3754
                hyper                   Views;
 
3755
                hyper                   Shortcuts;
 
3756
 
3656
3757
                ResponseFlags           ResponseFlags;
3657
3758
                GUID                    MailboxGuid;
3658
3759
                uint16                  ReplId;
3689
3790
                astring         ServerName;
3690
3791
        } Logon_redirect;
3691
3792
 
 
3793
        /**************************/
 
3794
        /* EcDoRpc Function 0xFF   */
 
3795
        typedef [nopush,nopull,flag(NDR_NOALIGN)] struct {
 
3796
        } BufferTooSmall_req;
 
3797
 
 
3798
        typedef [nopush,nopull,flag(NDR_NOALIGN)] struct {
 
3799
        } BufferTooSmall_repl;
 
3800
 
3692
3801
        /*************************/
3693
3802
        /* EcDoRpc Function 0xA5 */
3694
3803
        typedef [flag(NDR_NOALIGN)] struct {
3828
3937
                [case(op_MAPI_HardDeleteMessages)] HardDeleteMessages_req mapi_HardDeleteMessages;
3829
3938
                [case(op_MAPI_HardDeleteMessagesAndSubfolders)] HardDeleteMessagesAndSubfolders_req mapi_HardDeleteMessagesAndSubfolders;
3830
3939
                [case(op_MAPI_SetLocalReplicaMidsetDeleted)] SetLocalReplicaMidsetDeleted_req mapi_SetLocalReplicaMidsetDeleted;
 
3940
                [case(op_MAPI_Backoff)] Backoff_req mapi_Backoff;
3831
3941
                [case(op_MAPI_Logon)] Logon_req mapi_Logon;
 
3942
                [case(op_MAPI_BufferTooSmall)] BufferTooSmall_req mapi_BufferTooSmall;
3832
3943
                [case(op_MAPI_proxypack)] proxypack_req mapi_proxypack;
3833
3944
        } EcDoRpc_MAPI_REQ_UNION;
3834
3945
 
3962
4073
                [case(op_MAPI_HardDeleteMessages)] HardDeleteMessages_repl mapi_HardDeleteMessages;
3963
4074
                [case(op_MAPI_HardDeleteMessagesAndSubfolders)] HardDeleteMessagesAndSubfolders_repl mapi_HardDeleteMessagesAndSubfolders;
3964
4075
                [case(op_MAPI_SetLocalReplicaMidsetDeleted)] SetLocalReplicaMidsetDeleted_repl mapi_SetLocalReplicaMidsetDeleted;
 
4076
                [case(op_MAPI_Backoff)] Backoff_repl mapi_Backoff;
3965
4077
                [case(op_MAPI_Logon)] Logon_repl mapi_Logon;
 
4078
                [case(op_MAPI_BufferTooSmall)] BufferTooSmall_repl mapi_BufferTooSmall;
3966
4079
                [case(op_MAPI_proxypack)] proxypack_repl mapi_proxypack;
3967
4080
 
3968
4081
        } EcDoRpc_MAPI_REPL_UNION;
4040
4153
 
4041
4154
        MAPISTATUS EcRRegisterPushNotification(
4042
4155
               [in,out] policy_handle                   *handle,
4043
 
               [in] NotificationFlags                   ulEventMask,
 
4156
               [in] uint32                              iRpc,
4044
4157
               [in,size_is(cbContext)] uint8            rgbContext[*],
4045
4158
               [in] uint16                              cbContext,
4046
4159
               [in] uint32                              grbitAdviseBits,
4047
 
               [in,size_is(cbCallbackAddress)] uint8    rgCallbackAddress[*],
 
4160
               [in,size_is(cbCallbackAddress)] uint8    rgbCallbackAddress[*],
4048
4161
               [in] uint16                              cbCallbackAddress,
4049
4162
               [out,ref] uint32                         *hNotification
4050
4163
                );
4070
4183
 
4071
4184
        /*****************/
4072
4185
        /* Function 0x09 */
4073
 
        void EcDoRpcExt();
 
4186
        [public,noprint] MAPISTATUS EcDoRpcExt (
 
4187
                 [in,out] policy_handle                                         *handle,
 
4188
                 [in,out] uint32                                                *pulFlags,
 
4189
                 [in, size_is(cbIn)] uint8                                      rgbIn[],
 
4190
                 [in] uint32                                                    cbIn,
 
4191
                 [out, length_is(*pcbOut), size_is(*pcbOut)] uint8              rgbOut[],
 
4192
                 [in,out][range(0x0,0x40000)] uint32                            *pcbOut,
 
4193
                 [in,out,length_is(*Reserved1),size_is(*Reserved1)] uint8       Reserved0[],
 
4194
                 [in,out] uint32                                                *Reserved1,
 
4195
                 [out] uint32                                                   *pulTransTime
 
4196
                );
4074
4197
 
4075
4198
        /*****************/
4076
4199
        /* Function 0xa  */
4339
4462
                uint32          MajorVersion;
4340
4463
                uint32          MinorVersion;
4341
4464
                uint32          BuildNumber;
4342
 
                [subcontext(0), subcontext_size(132), flag(NDR_NOALIGN|NDR_REMAINING)] DATA_BLOB Reserved_1;
 
4465
                [subcontext(0), subcontext_size(132), flag(NDR_REMAINING|NDR_NOALIGN)] DATA_BLOB Reserved_1;
4343
4466
                uint16          ServicePackMajor;
4344
4467
                uint16          ServicePackMinor;
4345
4468
                uint32          Reserved_2;
4444
4567
                [out]                           uint16                                  rgwServerVersion[3],
4445
4568
                [out]                           uint16                                  rgwBestVersion[3],
4446
4569
                [in,out]                        uint32                                  *pulTimeStamp,
4447
 
                [in,subcontext(4),flag(NDR_NOALIGN|NDR_REMAINING)] mapi2k7_AuxInfo      *rgbAuxIn,
 
4570
                [in,subcontext(4),flag(NDR_REMAINING|NDR_NOALIGN)] mapi2k7_AuxInfo      *rgbAuxIn,
4448
4571
                [in]                            uint32                                  cbAuxIn,
4449
4572
                [out, length_is(*pcbAuxOut), size_is(*pcbAuxOut)] mapi2k7_AuxInfo       *rgbAuxOut,
4450
4573
                [in,out][range(0,0x1008)]       uint32                                  *pcbAuxOut
4465
4588
 
4466
4589
        typedef [public,nopull] struct {
4467
4590
                RPC_HEADER_EXT                                                  header;
4468
 
                [subcontext(0),flag(NDR_NOALIGN|NDR_REMAINING)] mapi_response   *mapi_response;
 
4591
                [subcontext(0),flag(NDR_REMAINING|NDR_NOALIGN)] mapi_response   *mapi_response;
4469
4592
        } mapi2k7_response;
4470
4593
 
4471
4594
        [public,noprint] MAPISTATUS EcDoRpcExt2(