Modified process status handling to provide appropriate tag
[dyninst.git] / igen / tests / test1.CLNT.C
1 #include <stdio.h>
2 #include <stdlib.h>
3 #include <assert.h>
4 #include "test1.h"
5
6
7 void testUser::triggerAsyncUpcall(int val) {
8     unsigned int __tag__;
9     __tag__ = test_triggerAsyncUpcall_REQ;
10     __xdrs__->x_op = XDR_ENCODE;
11     xdr_int(__xdrs__, &__tag__);
12     xdr_int(__xdrs__, &val);
13     xdrrec_endofrecord(__xdrs__, TRUE);
14     awaitResponce(test_triggerAsyncUpcall_RESP);
15 }
16
17
18 void testUser::triggerSyncUpcall(int val) {
19     unsigned int __tag__;
20     __tag__ = test_triggerSyncUpcall_REQ;
21     __xdrs__->x_op = XDR_ENCODE;
22     xdr_int(__xdrs__, &__tag__);
23     xdr_int(__xdrs__, &val);
24     xdrrec_endofrecord(__xdrs__, TRUE);
25     awaitResponce(test_triggerSyncUpcall_RESP);
26 }
27
28
29 String testUser::stringString(String test__12) {
30     unsigned int __tag__;
31     String test__22;
32     __tag__ = test_stringString_REQ;
33     __xdrs__->x_op = XDR_ENCODE;
34     xdr_int(__xdrs__, &__tag__);
35     xdr_String(__xdrs__, &test__12);
36     xdrrec_endofrecord(__xdrs__, TRUE);
37     awaitResponce(test_stringString_RESP);
38     xdr_String(__xdrs__, &(test__22)); 
39     return(test__22);
40 }
41
42
43 int_Array testUser::retVector(int len,int start) {
44     unsigned int __tag__;
45     int_Array test__23;
46     __tag__ = test_retVector_REQ;
47     __xdrs__->x_op = XDR_ENCODE;
48     xdr_int(__xdrs__, &__tag__);
49     xdr_int(__xdrs__, &len);
50     xdr_int(__xdrs__, &start);
51     xdrrec_endofrecord(__xdrs__, TRUE);
52     awaitResponce(test_retVector_RESP);
53     xdr_int_Array(__xdrs__, &(test__23)); 
54     return(test__23);
55 }
56
57
58 int testUser::sumVector(int_Array test__9) {
59     unsigned int __tag__;
60     int test__24;
61     __tag__ = test_sumVector_REQ;
62     __xdrs__->x_op = XDR_ENCODE;
63     xdr_int(__xdrs__, &__tag__);
64     xdr_int_Array(__xdrs__, &test__9);
65     xdrrec_endofrecord(__xdrs__, TRUE);
66     awaitResponce(test_sumVector_RESP);
67     xdr_int(__xdrs__, &(test__24)); 
68     return(test__24);
69 }
70
71
72 int testUser::add(int test__6,int test__7) {
73     unsigned int __tag__;
74     int test__25;
75     __tag__ = test_add_REQ;
76     __xdrs__->x_op = XDR_ENCODE;
77     xdr_int(__xdrs__, &__tag__);
78     xdr_int(__xdrs__, &test__6);
79     xdr_int(__xdrs__, &test__7);
80     xdrrec_endofrecord(__xdrs__, TRUE);
81     awaitResponce(test_add_RESP);
82     xdr_int(__xdrs__, &(test__25)); 
83     return(test__25);
84 }
85
86
87 int testUser::intString(String test__4) {
88     unsigned int __tag__;
89     int test__26;
90     __tag__ = test_intString_REQ;
91     __xdrs__->x_op = XDR_ENCODE;
92     xdr_int(__xdrs__, &__tag__);
93     xdr_String(__xdrs__, &test__4);
94     xdrrec_endofrecord(__xdrs__, TRUE);
95     awaitResponce(test_intString_RESP);
96     xdr_int(__xdrs__, &(test__26)); 
97     return(test__26);
98 }
99
100
101 void testUser::nullStruct(intStruct test__2) {
102     unsigned int __tag__;
103     __tag__ = test_nullStruct_REQ;
104     __xdrs__->x_op = XDR_ENCODE;
105     xdr_int(__xdrs__, &__tag__);
106     xdr_intStruct(__xdrs__, &test__2);
107     xdrrec_endofrecord(__xdrs__, TRUE);
108     awaitResponce(test_nullStruct_RESP);
109 }
110
111
112 int testUser::intNull(void) {
113     unsigned int __tag__;
114     int test__28;
115     __tag__ = test_intNull_REQ;
116     __xdrs__->x_op = XDR_ENCODE;
117     xdr_int(__xdrs__, &__tag__);
118     xdrrec_endofrecord(__xdrs__, TRUE);
119     awaitResponce(test_intNull_RESP);
120     xdr_int(__xdrs__, &(test__28)); 
121     return(test__28);
122 }
123
124
125 void testUser::nullNull(void) {
126     unsigned int __tag__;
127     __tag__ = test_nullNull_REQ;
128     __xdrs__->x_op = XDR_ENCODE;
129     xdr_int(__xdrs__, &__tag__);
130     xdrrec_endofrecord(__xdrs__, TRUE);
131     awaitResponce(test_nullNull_RESP);
132 }
133
134 void testUser::verifyProtocolAndVersion() {
135     unsigned int __tag__;
136     String proto;
137     int version;
138     __tag__ = 0;
139     __xdrs__->x_op = XDR_ENCODE;
140     xdr_int(__xdrs__, &__tag__);
141     xdrrec_endofrecord(__xdrs__, TRUE);
142     awaitResponce(0);
143     xdr_String(__xdrs__, &(proto));
144     xdr_int(__xdrs__, &(version));
145     if ((version != 1) || (strcmp(proto, "test"))) {
146         printf("protocol test version 1 expected\n");
147         printf("protocol %s version %d found\n", proto, version);
148             exit(-1);
149     }
150 }
151
152
153 testUser::testUser(int fd, xdrIOFunc r, xdrIOFunc w):
154 XDRrpc(fd, r, w) { if (__xdrs__) verifyProtocolAndVersion(); }
155 testUser::testUser(char *m,char *l,char *p,xdrIOFunc r,xdrIOFunc w):
156     XDRrpc(m, l, p, r, w) { if (__xdrs__) 
157        verifyProtocolAndVersion(); }
158
159 void testUser::awaitResponce(int __targetTag__) {
160     unsigned int __tag__;
161   while (1) {
162     __xdrs__->x_op = XDR_DECODE;
163     xdrrec_skiprecord(__xdrs__);
164     xdr_int(__xdrs__, &__tag__);
165     if (__tag__ == __targetTag__) return;
166     switch (__tag__) {
167         case test_asyncUpcall_REQ: {
168                     extern xdr_void(XDR*, void*);
169             test__17 __recvBuffer__;
170             xdr_int(__xdrs__, &__recvBuffer__.x);
171             asyncUpcall(__recvBuffer__.x);
172             break;
173          }
174
175         case test_syncUpcall_REQ: {
176                     extern xdr_void(XDR*, void*);
177             test__15 __recvBuffer__;
178             xdr_int(__xdrs__, &__recvBuffer__.x);
179             syncUpcall(__recvBuffer__.x);
180             __xdrs__->x_op = XDR_ENCODE;
181             __tag__ = test_syncUpcall_RESP;
182             xdr_int(__xdrs__, &__tag__);
183             xdrrec_endofrecord(__xdrs__, TRUE);
184             break;
185          }
186
187             default: 
188         abort();
189     }
190         if (__targetTag__ == -1) return;
191   }
192 }
193 int testUser::isValidUpCall(int tag) {
194     return((tag >= 2000) && (tag <= 2024));
195 }