source: trunk/server/testprogs/win32/midltests/todo/midltests-pipe-first.idl

#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