--- /dev/null
+#ifndef MIDLTESTS_C_CODE
+
+[
+ uuid("225b9fcb-eb3d-497b-8b0b-591f049a2507"),
+ pointer_default(unique)
+]
+interface midltests
+{
+ long midltests_fn(
+ [out,ref] long *count,
+ [out,ref,size_is(,*count),range(0,1)] long **array,
+ [out,ref] long *error
+ );
+}
+
+#elif MIDLTESTS_C_CODE
+
+static void midltests(void)
+{
+ long count;
+ long *array;
+ long error;
+
+ cli_midltests_fn(&count, &array, &error);
+}
+
+long srv_midltests_fn(long *count, long **array, long *error)
+{
+ printf("srv_midltests_fn: Start\n");
+ *count=2;
+ *array=(long *)malloc((*count) * sizeof(long));
+ (*array)[0] = 7;
+ (*array)[1] = 7;
+ *error=0;
+ printf("srv_midltests_fn: End\n");
+ return 0x65757254;
+}
+
+#endif
--- /dev/null
+#ifndef MIDLTESTS_C_CODE
+
+[
+ uuid("225b9fcb-eb3d-497b-8b0b-591f049a2507"),
+ pointer_default(unique)
+]
+interface midltests
+{
+ typedef pipe char pipe_char;
+
+ struct msg {
+ long l;
+ [size_is(l)] char *m;
+ };
+
+ long midltests_fn(
+ [out,ref] struct msg *out1,
+ [out] pipe_char outp,
+ [in] pipe_char inp,
+ [in] struct msg in1
+ );
+}
+
+#elif MIDLTESTS_C_CODE
+\r
+struct pipe_char_state {\r
+ const char *name;\r
+ unsigned long count;\r
+ unsigned long sleep;\r
+};\r
+\r
+void pipe_char_pull(\r
+ char * _state,\r
+ unsigned char * buf,\r
+ unsigned long esize,\r
+ unsigned long * ecount)\r
+{\r
+ struct pipe_char_state *state = (struct pipe_char_state *)_state;\r
+\r
+ printf("pull1:%s: esize[%u] ecount[%u]\n",\r
+ state->name, esize, *ecount);\r
+ *ecount = state->count--;\r
+ if (*ecount > esize) {\r
+ *ecount = esize;\r
+ }\r
+ memset(buf, 0xDD, *ecount);\r
+ printf("pull2:%s: esize[%u] ecount[%u]\n",\r
+ state->name, esize, *ecount);\r
+}\r
+\r
+void pipe_char_push(\r
+ char * _state,\r
+ unsigned char * buf,\r
+ unsigned long ecount)\r
+{\r
+ struct pipe_char_state *state = (struct pipe_char_state *)_state;\r
+\r
+ printf("push:%s: ecount[%u]\n",\r
+ state->name, ecount);\r
+}\r
+\r
+void pipe_char_alloc(\r
+ char * _state,\r
+ unsigned long bsize,\r
+ unsigned char * * buf,\r
+ unsigned long * bcount)\r
+{\r
+ struct pipe_char_state *state = (struct pipe_char_state *)_state;\r
+\r
+ printf("alloc1:%s: bsize[%u], bcount[%u]\n",\r
+ state->name, bsize, *bcount);\r
+ *bcount = bsize / sizeof(**buf);\r
+ *buf = malloc(*bcount * sizeof(**buf));\r
+ printf("alloc2:%s: bsize[%u], bcount[%u]\n",\r
+ state->name, bsize, *bcount);\r
+}\r
+
+static void midltests(void)
+{
+ struct msg out1;
+ unsigned char out1b[3];
+ struct pipe_char_state outs;
+ pipe_char outp;
+ struct pipe_char_state ins;
+ pipe_char inp;
+ struct msg in1;
+ unsigned char in1b[3];
+
+ in1.l = sizeof(in1b);
+ memset(&in1b, 0xAA, sizeof(in1b));
+ in1.m = in1b;
+
+ memset(&outs, 0, sizeof(outs));
+ outs.name = "outp";
+ memset(&outp, 0, sizeof(outp));
+ outp.pull = pipe_char_pull;
+ outp.push = pipe_char_push;
+ outp.alloc = pipe_char_alloc;
+ outp.state = (char *)&outs;
+
+ memset(&ins, 0, sizeof(ins));
+ ins.name = "inp";
+ ins.count = 1;
+ memset(&inp, 0, sizeof(inp));
+ inp.pull = pipe_char_pull;
+ inp.push = pipe_char_push;
+ inp.alloc = pipe_char_alloc;
+ inp.state = (char *)&ins;
+
+ out1.l = sizeof(out1b);
+ memset(&out1b, 0xFF, sizeof(out1b));
+ out1.m = out1b;
+
+ cli_midltests_fn(&out1, outp, inp, in1);
+}
+
+long srv_midltests_fn(
+ /* [ref][out] */ struct msg *out1,\r
+ /* [out] */ pipe_char outp,\r
+ /* [in] */ pipe_char inp,\r
+ /* [in] */ struct msg in1)
+{
+ char inb[500];
+ unsigned long inb_len = 0;
+ char *outb = NULL;
+ unsigned long outb_size = 0;
+ unsigned long outb_len = 0;
+
+ printf("srv_midltests_fn: Start\n");
+
+ do {
+ inp.pull(inp.state, inb, sizeof(inb), &inb_len);
+ printf("pull inp_len[%u]\n", inb_len);
+ } while (inb_len > 0);
+
+ outb_size = 5;
+ do {
+ outp.alloc(outp.state, outb_size, &outb, &outb_len);
+ memset(outb, 0xCC, outb_len);
+ outp.push(outp.state, outb, outb_len);
+ printf("push outb_len[%u]\n", outb_len);
+ //Sleep(1000);
+ outb_size--;
+ } while (outb_len > 0);
+
+ out1->l = 3;
+ out1->m = (unsigned char *)malloc(out1->l);
+ memset(out1->m, 0xBB, out1->l);
+ printf("srv_midltests_fn: End\n");
+ return 0x65757254;
+}
+
+#endif
--- /dev/null
+#ifndef MIDLTESTS_C_CODE
+
+[
+ uuid("225b9fcb-eb3d-497b-8b0b-591f049a2507"),
+ pointer_default(unique)
+]
+interface midltests
+{
+ typedef pipe char pipe_char;
+ typedef pipe hyper pipe_hyper;
+
+ struct msg {
+ long l;
+ [size_is(l)] char *m;
+ };
+
+ long midltests_fn(
+ [out,ref] struct msg *out1,
+ [out] pipe_hyper outp,
+ [in] pipe_hyper inp,
+ [in] struct msg in1
+ );
+}
+
+#elif MIDLTESTS_C_CODE
+\r
+struct pipe_char_state {\r
+ const char *name;\r
+ unsigned long count;\r
+ unsigned long sleep;\r
+};\r
+\r
+void pipe_char_pull(\r
+ char * _state,\r
+ unsigned char * buf,\r
+ unsigned long esize,\r
+ unsigned long * ecount)\r
+{\r
+ struct pipe_char_state *state = (struct pipe_char_state *)_state;\r
+\r
+ printf("pull1:%s: esize[%u] ecount[%u]\n",\r
+ state->name, esize, *ecount);\r
+ *ecount = state->count--;\r
+ if (*ecount > esize) {\r
+ *ecount = esize;\r
+ }\r
+ memset(buf, 0xDD, *ecount * sizeof(*buf));
+ printf("pull2:%s: esize[%u] ecount[%u]\n",\r
+ state->name, esize, *ecount);\r
+}\r
+\r
+void pipe_char_push(\r
+ char * _state,\r
+ unsigned char * buf,\r
+ unsigned long ecount)\r
+{\r
+ struct pipe_char_state *state = (struct pipe_char_state *)_state;\r
+\r
+ printf("push:%s: ecount[%u]\n",\r
+ state->name, ecount);\r
+}\r
+\r
+void pipe_char_alloc(\r
+ char * _state,\r
+ unsigned long bsize,\r
+ unsigned char * * buf,\r
+ unsigned long * bcount)\r
+{\r
+ struct pipe_char_state *state = (struct pipe_char_state *)_state;\r
+\r
+ printf("alloc1:%s: bsize[%u], bcount[%u]\n",\r
+ state->name, bsize, *bcount);\r
+ *bcount = bsize / sizeof(**buf);\r
+ *buf = malloc(*bcount * sizeof(**buf));\r
+ printf("alloc2:%s: bsize[%u], bcount[%u]\n",\r
+ state->name, bsize, *bcount);\r
+}\r
+
+struct pipe_hyper_state {
+ const char *name;
+ unsigned long count;
+ unsigned long sleep;
+};
+
+void pipe_hyper_pull(
+ char * _state,
+ hyper * buf,
+ unsigned long esize,
+ unsigned long * ecount)
+{
+ struct pipe_hyper_state *state = (struct pipe_hyper_state *)_state;
+
+ printf("pull1:%s: esize[%u] ecount[%u]\n",
+ state->name, esize, *ecount);
+ *ecount = state->count--;
+ if (*ecount > esize) {
+ *ecount = esize;
+ }
+ memset(buf, 0xDD, *ecount * sizeof(*buf));
+ printf("pull2:%s: esize[%u] ecount[%u]\n",
+ state->name, esize, *ecount);
+}
+
+void pipe_hyper_push(
+ char * _state,
+ hyper * buf,
+ unsigned long ecount)
+{
+ struct pipe_hyper_state *state = (struct pipe_hyper_state *)_state;
+
+ printf("push:%s: ecount[%u]\n",
+ state->name, ecount);
+}
+
+void pipe_hyper_alloc(
+ char * _state,
+ unsigned long bsize,
+ hyper * * buf,
+ unsigned long * bcount)
+{
+ struct pipe_hyper_state *state = (struct pipe_hyper_state *)_state;
+
+ printf("alloc1:%s: bsize[%u], bcount[%u]\n",
+ state->name, bsize, *bcount);
+ *bcount = bsize / sizeof(**buf);
+ *buf = malloc(*bcount * sizeof(**buf));
+ printf("alloc2:%s: bsize[%u], bcount[%u]\n",
+ state->name, bsize, *bcount);
+}
+static void midltests(void)
+{
+ struct msg out1;
+ unsigned char out1b[3];
+ struct pipe_hyper_state outs;
+ pipe_hyper outp;
+ struct pipe_hyper_state ins;
+ pipe_hyper inp;
+ struct msg in1;
+ unsigned char in1b[3];
+
+ in1.l = sizeof(in1b);
+ memset(&in1b, 0xAA, sizeof(in1b));
+ in1.m = in1b;
+
+ memset(&outs, 0, sizeof(outs));
+ outs.name = "outp";
+ memset(&outp, 0, sizeof(outp));
+ outp.pull = pipe_hyper_pull;
+ outp.push = pipe_hyper_push;
+ outp.alloc = pipe_hyper_alloc;
+ outp.state = (char *)&outs;
+
+ memset(&ins, 0, sizeof(ins));
+ ins.name = "inp";
+ ins.count = 1;
+ memset(&inp, 0, sizeof(inp));
+ inp.pull = pipe_hyper_pull;
+ inp.push = pipe_hyper_push;
+ inp.alloc = pipe_hyper_alloc;
+ inp.state = (char *)&ins;
+
+ out1.l = sizeof(out1b);
+ memset(&out1b, 0xFF, sizeof(out1b));
+ out1.m = out1b;
+
+ cli_midltests_fn(&out1, outp, inp, in1);
+}
+
+long srv_midltests_fn(
+ /* [ref][out] */ struct msg *out1,\r
+ /* [out] */ pipe_hyper outp,
+ /* [in] */ pipe_hyper inp,
+ /* [in] */ struct msg in1)
+{
+ hyper inb[500];
+ unsigned long inb_len = 0;
+ hyper *outb = NULL;
+ unsigned long outb_size = 0;
+ unsigned long outb_len = 0;
+
+ printf("srv_midltests_fn: Start\n");
+
+ do {
+ inp.pull(inp.state, inb, sizeof(inb), &inb_len);
+ printf("pull inp_len[%u]\n", inb_len);
+ } while (inb_len > 0);
+
+ outb_size = 5;
+ do {
+ outp.alloc(outp.state, outb_size, &outb, &outb_len);
+ memset(outb, 0xCC, outb_len * sizeof(*outb));
+ outp.push(outp.state, outb, outb_len);
+ printf("push outb_len[%u]\n", outb_len);
+ //Sleep(1000);
+ outb_size--;
+ } while (outb_len > 0);
+
+ out1->l = 3;
+ out1->m = (unsigned char *)malloc(out1->l);
+ memset(out1->m, 0xBB, out1->l);
+ printf("srv_midltests_fn: End\n");
+ return 0x65757254;
+}
+
+#endif
--- /dev/null
+#ifndef MIDLTESTS_C_CODE
+
+[
+ uuid("225b9fcb-eb3d-497b-8b0b-591f049a2507"),
+ pointer_default(unique)
+]
+interface midltests
+{
+ typedef pipe char pipe_char;
+ typedef pipe hyper pipe_hyper;
+ typedef struct {
+ long l;
+ short s;
+ } structtype;
+ typedef pipe structtype pipe_structtype;
+
+ struct msg {
+ long l;
+ [size_is(l)] char *m;
+ };
+
+ long midltests_fn(
+ [out,ref] struct msg *out1,
+ [out] pipe_structtype outp,
+ [in] pipe_structtype inp,
+ [in] struct msg in1
+ );
+
+ long midltests_ping( [in] struct msg in1);
+
+}
+
+#elif MIDLTESTS_C_CODE
+\r
+struct pipe_char_state {\r
+ const char *name;\r
+ unsigned long count;\r
+ unsigned long sleep;\r
+};\r
+\r
+void pipe_char_pull(\r
+ char * _state,\r
+ unsigned char * buf,\r
+ unsigned long esize,\r
+ unsigned long * ecount)\r
+{\r
+ struct pipe_char_state *state = (struct pipe_char_state *)_state;\r
+\r
+ printf("pull1:%s: esize[%u] ecount[%u]\n",\r
+ state->name, esize, *ecount);\r
+ *ecount = state->count--;\r
+ if (*ecount > esize) {\r
+ *ecount = esize;\r
+ }\r
+ memset(buf, 0xDD, *ecount * sizeof(*buf));
+ printf("pull2:%s: esize[%u] ecount[%u]\n",\r
+ state->name, esize, *ecount);\r
+}\r
+\r
+void pipe_char_push(\r
+ char * _state,\r
+ unsigned char * buf,\r
+ unsigned long ecount)\r
+{\r
+ struct pipe_char_state *state = (struct pipe_char_state *)_state;\r
+\r
+ printf("push:%s: ecount[%u]\n",\r
+ state->name, ecount);\r
+}\r
+\r
+void pipe_char_alloc(\r
+ char * _state,\r
+ unsigned long bsize,\r
+ unsigned char * * buf,\r
+ unsigned long * bcount)\r
+{\r
+ struct pipe_char_state *state = (struct pipe_char_state *)_state;\r
+\r
+ printf("alloc1:%s: bsize[%u], bcount[%u]\n",\r
+ state->name, bsize, *bcount);\r
+ *bcount = bsize / sizeof(**buf);\r
+ *buf = malloc(*bcount * sizeof(**buf));\r
+ printf("alloc2:%s: bsize[%u], bcount[%u]\n",\r
+ state->name, bsize, *bcount);\r
+}\r
+
+struct pipe_hyper_state {
+ const char *name;
+ unsigned long count;
+ unsigned long sleep;
+};
+
+void pipe_hyper_pull(
+ char * _state,
+ hyper * buf,
+ unsigned long esize,
+ unsigned long * ecount)
+{
+ struct pipe_hyper_state *state = (struct pipe_hyper_state *)_state;
+
+ printf("pull1:%s: esize[%u] ecount[%u]\n",
+ state->name, esize, *ecount);
+ *ecount = state->count--;
+ if (*ecount > esize) {
+ *ecount = esize;
+ }
+ memset(buf, 0xDD, *ecount * sizeof(*buf));
+ printf("pull2:%s: esize[%u] ecount[%u]\n",
+ state->name, esize, *ecount);
+}
+
+void pipe_hyper_push(
+ char * _state,
+ hyper * buf,
+ unsigned long ecount)
+{
+ struct pipe_hyper_state *state = (struct pipe_hyper_state *)_state;
+
+ printf("push:%s: ecount[%u]\n",
+ state->name, ecount);
+}
+
+void pipe_hyper_alloc(
+ char * _state,
+ unsigned long bsize,
+ hyper * * buf,
+ unsigned long * bcount)
+{
+ struct pipe_hyper_state *state = (struct pipe_hyper_state *)_state;
+
+ printf("alloc1:%s: bsize[%u], bcount[%u]\n",
+ state->name, bsize, *bcount);
+ *bcount = bsize / sizeof(**buf);
+ *buf = malloc(*bcount * sizeof(**buf));
+ printf("alloc2:%s: bsize[%u], bcount[%u]\n",
+ state->name, bsize, *bcount);
+}
+struct pipe_structtype_state {
+ const char *name;
+ unsigned long count;
+ unsigned long sleep;
+};
+
+void pipe_structtype_pull(
+ char * _state,
+ structtype * buf,
+ unsigned long esize,
+ unsigned long * ecount)
+{
+ struct pipe_structtype_state *state = (struct pipe_structtype_state *)_state;
+
+ printf("pull1:%s: esize[%u] ecount[%u]\n",
+ state->name, esize, *ecount);
+ *ecount = state->count--;
+ if (*ecount > esize) {
+ *ecount = esize;
+ }
+ memset(buf, 0xDD, *ecount * sizeof(*buf));
+ printf("pull2:%s: esize[%u] ecount[%u]\n",
+ state->name, esize, *ecount);
+}
+
+void pipe_structtype_push(
+ char * _state,
+ structtype * buf,
+ unsigned long ecount)
+{
+ struct pipe_structtype_state *state = (struct pipe_structtype_state *)_state;
+
+ printf("push:%s: ecount[%u]\n",
+ state->name, ecount);
+}
+
+void pipe_structtype_alloc(
+ char * _state,
+ unsigned long bsize,
+ structtype * * buf,
+ unsigned long * bcount)
+{
+ struct pipe_structtype_state *state = (struct pipe_structtype_state *)_state;
+
+ printf("alloc1:%s: bsize[%u], bcount[%u]\n",
+ state->name, bsize, *bcount);
+ *bcount = bsize / sizeof(**buf);
+ *buf = malloc(*bcount * sizeof(**buf));
+ printf("alloc2:%s: bsize[%u], bcount[%u]\n",
+ state->name, bsize, *bcount);
+}
+static void midltests(void)
+{
+ struct msg out1;
+ unsigned char out1b[3];
+ struct pipe_structtype_state outs;
+ pipe_structtype outp;
+ struct pipe_structtype_state ins;
+ pipe_structtype inp;
+ struct msg in1;
+ unsigned char in1b[3];
+
+ in1.l = sizeof(in1b);
+ memset(&in1b, 0xAA, sizeof(in1b));
+ in1.m = in1b;
+
+ memset(&outs, 0, sizeof(outs));
+ outs.name = "outp";
+ memset(&outp, 0, sizeof(outp));
+ outp.pull = pipe_structtype_pull;
+ outp.push = pipe_structtype_push;
+ outp.alloc = pipe_structtype_alloc;
+ outp.state = (char *)&outs;
+
+ memset(&ins, 0, sizeof(ins));
+ ins.name = "inp";
+ ins.count = 1;
+ memset(&inp, 0, sizeof(inp));
+ inp.pull = pipe_structtype_pull;
+ inp.push = pipe_structtype_push;
+ inp.alloc = pipe_structtype_alloc;
+ inp.state = (char *)&ins;
+
+ out1.l = sizeof(out1b);
+ memset(&out1b, 0xFF, sizeof(out1b));
+ out1.m = out1b;
+
+ cli_midltests_ping(in1);
+ cli_midltests_fn(&out1, outp, inp, in1);
+}
+
+long srv_midltests_fn(
+ /* [ref][out] */ struct msg *out1,\r
+ /* [out] */ pipe_structtype outp,
+ /* [in] */ pipe_structtype inp,
+ /* [in] */ struct msg in1)
+{
+ structtype inb[500];
+ unsigned long inb_len = 0;
+ structtype *outb = NULL;
+ unsigned long outb_size = 0;
+ unsigned long outb_len = 0;
+
+ printf("srv_midltests_fn: Start\n");
+
+ do {
+ inp.pull(inp.state, inb, sizeof(inb), &inb_len);
+ printf("pull inp_len[%u]\n", inb_len);
+ } while (inb_len > 0);
+
+ outb_size = 5;
+ do {
+ outp.alloc(outp.state, outb_size, &outb, &outb_len);
+ memset(outb, 0xCC, outb_len * sizeof(*outb));
+ outp.push(outp.state, outb, outb_len);
+ printf("push outb_len[%u]\n", outb_len);
+ //Sleep(1000);
+ outb_size--;
+ } while (outb_len > 0);
+
+ out1->l = 3;
+ out1->m = (unsigned char *)malloc(out1->l);
+ memset(out1->m, 0xBB, out1->l);
+ printf("srv_midltests_fn: End\n");
+ return 0x65757254;
+}
+
+long srv_midltests_ping(
+ /* [in] */ struct msg in1)
+{
+ printf("srv_midltests_fn: Start\n");
+ printf("srv_midltests_fn: End\n");
+ return 0x65757254;
+}
+#endif
--- /dev/null
+#ifndef MIDLTESTS_C_CODE
+[
+ uuid("225b9fcb-eb3d-497b-8b0b-591f049a2507"),
+ pointer_default(unique)
+]
+interface midltests
+{
+/* typedef struct st_wire {
+ long len;
+ //[size_is(len)] char data[*];
+ [size_is(l2)] char *d2;
+ long l2;
+ } st_wire_t;
+ struct st_local {
+ short s1;
+ short s2;
+ };
+ typedef [transmit_as(st_wire_t)] struct st_local st_local_t;
+
+ long midltests_fn(
+ [in] st_local_t st
+
+ );
+*/
+/* struct my_ace {
+ long ace1;
+ long ace2;
+ };
+ struct my_acl {
+ long revision;
+ long num_aces;
+ [size_is(num_aces)] struct my_ace *aces;
+ };
+ long midltests_fn(
+ [in,ref] struct my_acl *acl
+ );
+*/
+/* struct my_str {
+ long l1;
+ [string] wchar_t str[260+1];
+ long l2;
+ };
+ long midltests_fn(
+ [in,out,ref] struct my_str *str
+ );
+*/
+ long foo();
+ long midltests_fn(
+ [in] long size,
+ [out,ref,size_is(size),length_is(*length)] byte *bytes,
+ [out,ref] long *length
+ );
+
+ typedef pipe byte BYTE_PIPE;
+ typedef pipe long LONG_PIPE;
+
+ long midltests_fn_pipe(
+ [in] long count,
+ [out,ref] long *start_magic,
+ [out] BYTE_PIPE b,
+ [out, ref] long *mid_magic,
+ [out] LONG_PIPE l,
+ [out,ref] long *end_magic
+ );
+
+}
+#elif MIDLTESTS_C_CODE
+/*
+void __RPC_USER st_local_t_to_xmit(st_local_t *l, st_wire_t **w)
+{
+ *w = malloc(4+ sizeof(st_wire_t));
+ (*w)->len = sizeof(st_local_t);
+ //(*w)->data = malloc((*w)->len);
+ memcpy((*w)->data, l, sizeof(st_local_t));
+ //memset(*w, 0xcd, sizeof(st_wire_t));
+}
+
+void __RPC_USER st_local_t_from_xmit(st_wire_t *w, st_local_t *l)
+{
+ memcpy(l, w->data, sizeof(st_local_t));
+// memset(l, 0, sizeof(st_local_t));
+}
+
+void __RPC_USER st_local_t_free_inst(st_local_t *l)
+{
+
+}
+
+void __RPC_USER st_local_t_free_xmit(st_wire_t *w)
+{
+ //free(w->data);
+ free(w);
+}
+*/
+
+void __RPC_USER cli_push_b(char * state,
+ byte * buf,
+ unsigned long ecount)
+{
+ printf("cli_push_b ecount[%lu]\n", ecount);
+}
+
+void __RPC_USER cli_alloc_b(char * state,
+ unsigned long bsize,
+ byte * * buf,
+ unsigned long * bcount )
+{
+ printf("cli_alloc_b bsize[%lu]\n", bsize);
+ *buf = NULL;
+ *bcount = 0;
+}
+
+void __RPC_USER cli_push_l(char * state,
+ long * buf,
+ unsigned long ecount)
+{
+ printf("cli_push_l ecount[%lu]\n", ecount);
+}
+
+void __RPC_USER cli_alloc_l(char * state,
+ unsigned long bsize,
+ long * * buf,
+ unsigned long * bcount )
+{
+ printf("cli_alloc_l bsize[%lu]\n", bsize);
+ *buf = NULL;
+ *bcount = 0;
+}
+
+static void midltests()
+{
+/* st_local_t st;
+ st.s1 = 1;
+ st.s2 = 2;
+ cli_midltests_fn(st);
+*/
+/* struct my_acl acl;
+ struct my_ace aces[3];
+ aces[0].ace1 = 1;
+ aces[0].ace2 = 2;
+ aces[1].ace1 = 1;
+ aces[1].ace2 = 2;
+ aces[2].ace1 = 1;
+ aces[2].ace2 = 2;
+ acl.revision = 5;
+ acl.num_aces = 1;
+ acl.aces = aces;
+ cli_midltests_fn(&acl);
+*/
+/* struct my_str str;
+ memset(&str, 0, sizeof(str));
+ str.l1 = 1;
+ printf("here: %d\n", __LINE__);
+ //wcscpy(str.str, L'Hello World\0');
+ str.l2 = 2;
+ printf("here: %d\n", __LINE__);
+ cli_midltests_fn(&str);
+*/
+ byte buf[10];
+ long length = 0;
+ memset(buf, 0xdf, sizeof(buf));
+// cli_midltests_fn(sizeof(buf), buf, &length);
+
+/* long count = 2;
+ long start_magic;
+ BYTE_PIPE b;
+ long mid_magic;
+ LONG_PIPE l;
+ long end_magic;
+
+
+ memset(&b, 0, sizeof(b));
+ memset(&l, 0, sizeof(l));
+
+ b.alloc = cli_alloc_b;
+ b.push = cli_push_b;
+
+ l.alloc = cli_alloc_l;
+ l.push = cli_push_l;
+
+ printf("cli call start\n");
+ cli_midltests_fn(count,
+ &start_magic,
+ b,
+ &mid_magic,
+ l,
+ &end_magic);
+ printf("cli call end\n");
+*/
+}
+
+//long srv_midltests_fn(struct my_str *str)//struct my_acl *acl)//st_local_t st)
+//long srv_midltests_fn(long size, byte *bytes, long *length)
+#if 1
+long srv_midltests_fn(
+ /* [in] */ long count,
+ /* [ref][out] */ long *start_magic,
+ /* [out] */ BYTE_PIPE b,
+ /* [ref][out] */ long *mid_magic,
+ /* [out] */ LONG_PIPE l,
+ /* [ref][out] */ long *end_magic)
+#endif
+{
+/* byte bytes[10];
+ long longs[10];
+ int i;
+*/
+ printf("srv_midltests_fn: Start\n");
+ //printf("s1[%d] s2[%d]\n", st.s1, st.s2);
+ //printf(l1[%d] str[%s] l2[%d]\n", str->l1, str->str, str->l2);
+
+/* *start_magic = 0x01234567;
+ *mid_magic = 0x88888888;
+ *end_magic = 0xFEDCBA09;
+
+ memset(bytes, 0xBE, sizeof(bytes));
+ memset(longs, 0xAC, sizeof(longs));
+
+ for (i=0; i < count; i++) {
+ b.push(b.state, bytes, sizeof(bytes)/sizeof(bytes[0]));
+ }
+ b.push(b.state, NULL, 0);
+
+ for (i=0; i < count; i++) {
+ l.push(l.state, longs, sizeof(longs)/sizeof(longs[0]));
+ }
+ l.push(l.state, NULL, 0);
+*/
+ printf("srv_midltests_fn: End\n");
+ return 0x65757254;
+}
+
+#endif
\ No newline at end of file
--- /dev/null
+#ifndef MIDLTESTS_C_CODE
+
+[
+ uuid("225b9fcb-eb3d-497b-8b0b-591f049a2507"),
+ pointer_default(unique)
+]
+interface midltests
+{
+ long midltests_fn(
+ [in,out,ref,string] wchar_t *s
+ );
+}
+
+#elif MIDLTESTS_C_CODE
+
+static void midltests(void)
+{
+ wchar_t s[] = { 's', 'a', 'm', 'b', 'a', 0 };
+
+ cli_midltests_fn(s);
+}
+
+long srv_midltests_fn(wchar_t *s)
+{
+ printf("srv_midltests_fn: Start\n");
+ s[1] = 0;
+ s[2] = 'M';
+ s[5] = '4';
+ printf("srv_midltests_fn: End\n");
+ return 0x65757254;
+}
+
+#endif
--- /dev/null
+#ifndef MIDLTESTS_C_CODE
+[
+ uuid("225b9fcb-eb3d-497b-8b0b-591f049a2507"),
+ pointer_default(unique)
+]
+interface midltests
+{
+ typedef struct st_wire {
+ char data[20];
+ } st_wire_t;
+ struct st_local {
+ short s1;
+ short s2;
+ };
+ typedef [transmit_as(st_wire_t)] struct st_local st_local_t;
+
+ long midltests_fn(
+ [in] st_local_t st
+ );
+}
+#elif MIDLTESTS_C_CODE
+
+void __RPC_USER st_local_t_to_xmit(st_local_t *l, st_wire_t **w)
+{
+ *w = malloc(sizeof(st_wire_t));
+ memset(*w, 0xcd, sizeof(st_wire_t));
+}
+
+void __RPC_USER st_local_t_from_xmit(st_wire_t *w, st_local_t *l)
+{
+ memset(l, 0, sizeof(st_local_t));
+}
+
+void __RPC_USER st_local_t_free_inst(st_local_t *l)
+{
+
+}
+
+void __RPC_USER st_local_t_free_xmit(st_wire_t *w)
+{
+ free(w);
+}
+
+static void midltests()
+{
+ char s[64];
+ st_local_t st;
+ strcpy(s, "TestString");
+ cli_midltests_fn(st);
+}
+
+long srv_midltests_fn(st_local_t st)
+{
+ printf("srv_midltests_fn: Start\n");
+ printf("srv_midltests_fn: End\n");
+ return 0x65757254;
+}
+
+#endif
\ No newline at end of file
--- /dev/null
+[
+ uuid("225b9fcb-eb3d-497b-8b0b-591f049a2507"),
+ pointer_default(ptr)
+]
+interface midltests
+{
+ struct midltests_struct {
+ [ref] long ****p;
+ [ref] long **a;
+ [ref] long **b;
+ [ref] long **c;
+ };
+
+ void midltests_fn(
+ //[in] long size,
+ [in,out,ref] struct midltests_struct *s
+ //[in,ref,size_is(,size)] long ***array
+ );
+
+}
\ No newline at end of file
git.samba.org / gd / samba-autobuild / .git / commitdiff