dlls/rpcrt4/tests/server.idl

   1 /*
   2  * A simple interface to test the RPC server.
   3  *
   4  * Copyright (C) Google 2007 (Dan Hipschman)
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2.1 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with this library; if not, write to the Free Software
  18  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  19  */
  20
  21 #include "server_defines.h"
  22
  23 typedef struct tag_vector
  24 {
  25   int x;
  26   int y;
  27   int z;
  28 } vector_t;
  29
  30 typedef int fnprintf(const char *format, ...);
  31
  32 [
  33   uuid(00000000-4114-0704-2301-000000000000),
  34   implicit_handle(handle_t IServer_IfHandle)
  35 ]
  36 interface IServer
  37 {
  38 cpp_quote("#if 0")
  39   typedef wchar_t WCHAR;
  40 cpp_quote("#endif")
  41
  42   typedef [string] char *str_t;
  43   typedef [string] WCHAR *wstr_t;
  44
  45   typedef struct
  46   {
  47     int *pi;
  48     int **ppi;
  49     int ***pppi;
  50   } pints_t;
  51
  52   typedef struct
  53   {
  54     char *pc;
  55     short *ps;
  56     long *pl;
  57     float *pf;
  58     double *pd;
  59   } ptypes_t;
  60
  61   typedef struct
  62   {
  63     vector_t *pu;
  64     vector_t **pv;
  65   } pvectors_t;
  66
  67   typedef struct
  68   {
  69     [switch_is(s)] union
  70     {
  71       [case(SUN_I)] int i;
  72       [case(SUN_F1, SUN_F2)] float f;
  73       [case(SUN_PI)] int *pi;
  74     } u;
  75
  76     int s;
  77   } sun_t;
  78
  79   int int_return(void);
  80   int square(int x);
  81   int sum(int x, int y);
  82   signed char sum_char(signed char x, signed char y);
  83   short sum_short(short x, short y);
  84   int sum_float(float x, float y);
  85   int sum_double_int(int x, double y);
  86   hyper sum_hyper(hyper x, hyper y);
  87   int sum_hyper_int(hyper x, hyper y);
  88   int sum_char_hyper(signed char x, hyper y);
  89   void square_out(int x, [out] int *y);
  90   void square_ref([in, out] int *x);
  91   int str_length([string] const char *s);
  92   int str_t_length(str_t s);
  93   int cstr_length([string, size_is(n)] const char *s, int n);
  94   int dot_self(vector_t *v);
  95   double square_half(double x, [out] double *y);
  96   float square_half_float(float x, [out] float *y);
  97   long square_half_long(long x, [out] long *y);
  98   int sum_fixed_array(int a[5]);
  99   int pints_sum(pints_t *pints);
 100   double ptypes_sum(ptypes_t *ptypes);
 101   int dot_pvectors(pvectors_t *pvectors);
 102
 103   /* don't use this anywhere except in sp_t */
 104   typedef struct
 105   {
 106     int x;
 107   } sp_inner_t;
 108
 109   typedef struct
 110   {
 111     int x;
 112     sp_inner_t *s;
 113   } sp_t;
 114
 115   int sum_sp(sp_t *sp);
 116   double square_sun(sun_t *su);
 117
 118   typedef struct test_list
 119   {
 120     int t;
 121     [switch_is(t)] union
 122     {
 123       [case(TL_NULL)] char x;  /* end of list */
 124       [case(TL_LIST)] struct test_list *tail;
 125     } u;
 126   } test_list_t;
 127
 128   typedef [ref] int *refpint_t;
 129
 130   int test_list_length(test_list_t *ls);
 131   int sum_fixed_int_3d(int m[2][3][4]);
 132   int sum_conf_array([size_is(n)] int x[], int n);
 133   int sum_conf_ptr_by_conf_ptr(int n1, [size_is(n1)] int *n2_then_x1, [size_is(*n2_then_x1)] int *x2);
 134   int sum_unique_conf_array([size_is(n), unique] int x[], int n);
 135   int sum_unique_conf_ptr([size_is(n), unique] int *x, int n);
 136   int sum_var_array([length_is(n)] int x[20], int n);
 137   int dot_two_vectors(vector_t vs[2]);
 138   void get_number_array([out, length_is(*n)] int x[20], [out] int *n);
 139
 140   typedef struct
 141   {
 142     int n;
 143     [size_is(n)] int ca[];
 144   } cs_t;
 145
 146   typedef struct
 147   {
 148     int *pn;
 149     [size_is(*pn)] int *ca1;
 150     [size_is(n * 2)] int *ca2;
 151     int n;
 152   } cps_t;
 153
 154   typedef struct
 155   {
 156     [size_is(c ? a : b)] int *ca;
 157     int a;
 158     int b;
 159     int c;
 160   } cpsc_t;
 161
 162   int sum_cs(cs_t *cs);
 163   int sum_cps(cps_t *cps);
 164   int sum_cpsc(cpsc_t *cpsc);
 165   int get_cpsc(int n, [out] cpsc_t *cpsc );
 166   int sum_complex_array(int n, [size_is(n)] refpint_t pi[]);
 167
 168   typedef [wire_marshal(int)] void *puint_t;
 169   int square_puint(puint_t p);
 170
 171   typedef struct
 172   {
 173     [size_is(n)] puint_t *ps;
 174     int n;
 175   } puints_t;
 176
 177   /* Same thing as puints_t, but make it complex (needs padding).  */
 178   typedef struct
 179   {
 180     [size_is(n)] puint_t *ps;
 181     char n;
 182   } cpuints_t;
 183
 184   int sum_puints(puints_t *p);
 185   int sum_cpuints(cpuints_t *p);
 186   int dot_copy_vectors(vector_t u, vector_t v);
 187
 188   typedef struct wire_us *wire_us_t;
 189   typedef [wire_marshal(wire_us_t)] struct us us_t;
 190   struct us
 191   {
 192     void *x;
 193   };
 194   struct wire_us
 195   {
 196     int x;
 197   };
 198   typedef struct
 199   {
 200     us_t us;
 201   } test_us_t;
 202
 203   int square_test_us(test_us_t *tus);
 204
 205   typedef union encu switch (int t)
 206   {
 207   case ENCU_I: int i;
 208   case ENCU_F: float f;
 209   } encu_t;
 210
 211   typedef [switch_type(int)] union unencu
 212   {
 213     [case (ENCU_I)] int i;
 214     [case (ENCU_F)] float f;
 215   } unencu_t;
 216
 217   typedef enum
 218   {
 219     E1 = 23,
 220     E2 = 4,
 221     E3 = 0,
 222     E4 = 64
 223   } e_t;
 224
 225   typedef union encue switch (e_t t)
 226   {
 227   case E1: int i1;
 228   case E2: float f2;
 229   } encue_t;
 230
 231   typedef struct
 232   {
 233     e_t f;
 234   } se_t;
 235
 236   double square_encu(encu_t *eu);
 237   double square_unencu(int t, [switch_is(t)] unencu_t *eu);
 238   int sum_parr(int *a[3]);
 239   int sum_pcarr([size_is(n)] int *a[], int n);
 240   int enum_ord(e_t e);
 241   double square_encue(encue_t *eue);
 242   void check_se2(se_t *s);
 243
 244   int sum_toplev_conf_2n([size_is(n * 2)] int *x, int n);
 245   int sum_toplev_conf_cond([size_is(c ? a : b)] int *x, int a, int b, int c);
 246
 247   typedef struct
 248   {
 249     char c;
 250     int i;
 251     short s;
 252     double d;
 253   } aligns_t;
 254
 255   double sum_aligns(aligns_t *a);
 256
 257   typedef struct
 258   {
 259     int i;
 260     char c;
 261   } padded_t;
 262
 263   int sum_padded(padded_t *p);
 264   int sum_padded2(padded_t ps[2]);
 265   int sum_padded_conf([size_is(n)] padded_t *ps, int n);
 266
 267   typedef struct
 268   {
 269     int *p1;
 270   } bogus_helper_t;
 271
 272   typedef struct
 273   {
 274     bogus_helper_t h;
 275     int *p2;
 276     int *p3;
 277     char c;
 278   } bogus_t;
 279
 280   int sum_bogus(bogus_t *b);
 281   void check_null([unique] int *null);
 282
 283   typedef struct
 284   {
 285     str_t s;
 286   } str_struct_t;
 287
 288   typedef struct
 289   {
 290     wstr_t s;
 291   } wstr_struct_t;
 292
 293   int str_struct_len(str_struct_t *s);
 294   int wstr_struct_len(wstr_struct_t *s);
 295
 296   typedef struct
 297   {
 298     unsigned int n;
 299     [size_is(n)] byte a[];
 300   } doub_carr_1_t;
 301
 302   typedef struct
 303   {
 304     int n;
 305     [size_is(n)] doub_carr_1_t *a[];
 306   } doub_carr_t;
 307
 308   int sum_doub_carr(doub_carr_t *dc);
 309   void make_pyramid_doub_carr(unsigned char n, [out] doub_carr_t **dc);
 310
 311   typedef struct
 312   {
 313     short n;
 314     [size_is(n)] short data[];
 315   } user_bstr_t;
 316
 317   typedef [unique] user_bstr_t *wire_bstr_t;
 318   typedef [wire_marshal(wire_bstr_t)] short *bstr_t;
 319   unsigned hash_bstr(bstr_t s);
 320   void get_a_bstr([out]bstr_t *s);
 321   typedef struct
 322   {
 323     [string, size_is(size)] char *name;
 324     unsigned int size;
 325   } name_t;
 326   void get_name([in,out] name_t *name);
 327
 328   int sum_pcarr2(int n, [size_is(, n)] int **pa);
 329   int sum_L1_norms(int n, [size_is(n)] vector_t *vs);
 330
 331   /* Don't use this except in the get_s123 test.  */
 332   typedef struct
 333   {
 334     int f1;
 335     int f2;
 336     int f3;
 337   } s123_t;
 338
 339   /* Make sure WIDL generates a type format string for a previously unseen
 340      type as a return value.  */
 341   s123_t *get_s123(void);
 342
 343   typedef struct
 344   {
 345     unsigned int length;
 346     unsigned int size;
 347     [size_is(size), length_is(length)] pints_t numbers[];
 348   } numbers_struct_t;
 349
 350   void get_numbers([in] int length, [in] int size, [out, length_is(length), size_is(size)] pints_t pn[]);
 351   void get_numbers_struct([out] numbers_struct_t **ns);
 352
 353   str_t get_filename(void);
 354
 355   enum renum
 356   {
 357     RE0,
 358     RE1,
 359     RE2,
 360     RE3,
 361   };
 362   const int RE_MIN = RE0;
 363   const int RE_MAX = RE3;
 364   typedef [range(RE_MIN, RE_MAX)] enum renum renum_t;
 365   typedef [range(0, 100)] int rint_t;
 366   rint_t echo_ranged_int([range(0, 10)] int i, [range(0, 20)] int j, [range(0, 100)] int k);
 367   rint_t echo_ranged_int2([range(0, 40)] int i);
 368   void get_ranged_enum([out] renum_t *re);
 369
 370   void context_handle_test(void);
 371
 372   void full_pointer_test([in, ptr] int *a, [in, ptr] int *b);
 373   void full_pointer_null_test([in, ptr] int *a, [in, ptr] int *b);
 374
 375   void authinfo_test(unsigned int protseq, int secure);
 376
 377   void stop(void);
 378 }