OLD | NEW |
1 /* | 1 /* |
2 * test_socket.c | 2 * test_socket.c |
3 * | 3 * |
4 * Test Socket Type | 4 * Test Socket Type |
5 * | 5 * |
6 * Copyright 2004-2005 Sun Microsystems, Inc. All rights reserved. | 6 * Copyright 2004-2005 Sun Microsystems, Inc. All rights reserved. |
7 * | 7 * |
8 * Redistribution and use in source and binary forms, with or without | 8 * Redistribution and use in source and binary forms, with or without |
9 * modification, are permitted provided that the following conditions are met: | 9 * modification, are permitted provided that the following conditions are met: |
10 * | 10 * |
(...skipping 26 matching lines...) Expand all Loading... |
37 | 37 |
38 #include "testutil.h" | 38 #include "testutil.h" |
39 #include "testutil_nss.h" | 39 #include "testutil_nss.h" |
40 #include "pkix_pl_common.h" | 40 #include "pkix_pl_common.h" |
41 | 41 |
42 #define LDAP_PORT 389 | 42 #define LDAP_PORT 389 |
43 | 43 |
44 static void *plContext = NULL; | 44 static void *plContext = NULL; |
45 | 45 |
46 typedef enum { | 46 typedef enum { |
47 SERVER_LISTENING, | 47 SERVER_LISTENING, |
48 SERVER_RECV1, | 48 SERVER_RECV1, |
49 SERVER_POLL1, | 49 SERVER_POLL1, |
50 SERVER_SEND2, | 50 SERVER_SEND2, |
51 SERVER_POLL2, | 51 SERVER_POLL2, |
52 SERVER_RECV3, | 52 SERVER_RECV3, |
53 SERVER_POLL3, | 53 SERVER_POLL3, |
54 SERVER_SEND4, | 54 SERVER_SEND4, |
55 SERVER_POLL4, | 55 SERVER_POLL4, |
56 SERVER_DONE, | 56 SERVER_DONE, |
57 SERVER_FAILED | 57 SERVER_FAILED |
58 } SERVER_STATE; | 58 } SERVER_STATE; |
59 | 59 |
60 typedef enum { | 60 typedef enum { |
61 CLIENT_WAITFORCONNECT, | 61 CLIENT_WAITFORCONNECT, |
62 CLIENT_SEND1, | 62 CLIENT_SEND1, |
63 CLIENT_POLL1, | 63 CLIENT_POLL1, |
64 CLIENT_RECV2, | 64 CLIENT_RECV2, |
65 CLIENT_POLL2, | 65 CLIENT_POLL2, |
66 CLIENT_SEND3, | 66 CLIENT_SEND3, |
67 CLIENT_POLL3, | 67 CLIENT_POLL3, |
68 CLIENT_RECV4, | 68 CLIENT_RECV4, |
69 CLIENT_POLL4, | 69 CLIENT_POLL4, |
70 CLIENT_DONE, | 70 CLIENT_DONE, |
71 CLIENT_FAILED | 71 CLIENT_FAILED |
72 } CLIENT_STATE; | 72 } CLIENT_STATE; |
73 | 73 |
74 SERVER_STATE serverState; | 74 SERVER_STATE serverState; |
75 CLIENT_STATE clientState; | 75 CLIENT_STATE clientState; |
76 PKIX_PL_Socket *sSock = NULL; | 76 PKIX_PL_Socket *sSock = NULL; |
77 PKIX_PL_Socket *cSock = NULL; | 77 PKIX_PL_Socket *cSock = NULL; |
78 PKIX_PL_Socket *rendezvousSock = NULL; | 78 PKIX_PL_Socket *rendezvousSock = NULL; |
79 PKIX_PL_Socket_Callback *sCallbackList; | 79 PKIX_PL_Socket_Callback *sCallbackList; |
80 PKIX_PL_Socket_Callback *cCallbackList; | 80 PKIX_PL_Socket_Callback *cCallbackList; |
81 PKIX_PL_Socket_Callback *rvCallbackList; | 81 PKIX_PL_Socket_Callback *rvCallbackList; |
82 PRNetAddr serverNetAddr; | 82 PRNetAddr serverNetAddr; |
83 PRNetAddr clientNetAddr; | 83 PRNetAddr clientNetAddr; |
84 PRIntn backlog = 0; | 84 PRIntn backlog = 0; |
85 PRIntervalTime timeout = 0; | 85 PRIntervalTime timeout = 0; |
86 char *sendBuf1 = "Hello, world!"; | 86 char *sendBuf1 = "Hello, world!"; |
87 char *sendBuf2 = "Ack"; | 87 char *sendBuf2 = "Ack"; |
88 char *sendBuf3 = "What do you mean, \"Ack\"?"; | 88 char *sendBuf3 = "What do you mean, \"Ack\"?"; |
89 char *sendBuf4 = "What do you mean, \"What do you mean, \'Ack\'?\"?"; | 89 char *sendBuf4 = "What do you mean, \"What do you mean, \'Ack\'?\"?"; |
90 char rcvBuf1[100]; | 90 char rcvBuf1[100]; |
91 char rcvBuf2[100]; | 91 char rcvBuf2[100]; |
92 | 92 |
93 static | 93 static void printUsage(char *testname) { |
94 void printUsage(char *testname) | 94 char *fmt = "USAGE: %s [-arenas] server:port\n"; |
95 { | 95 printf(fmt, testname); |
96 char *fmt = "USAGE: %s [-arenas] server:port\n"; | |
97 printf(fmt, testname); | |
98 } | 96 } |
99 | 97 |
100 /* Functional tests for Socket public functions */ | 98 /* Functional tests for Socket public functions */ |
101 static· | 99 static void do_other_work(void) {/* while waiting for nonblocking I/O to |
102 void do_other_work(void)· | 100 complete */ |
103 { /* while waiting for nonblocking I/O to complete */ | 101 (void)PR_Sleep(2 * 60); |
104 (void) PR_Sleep(2*60); | 102 } |
105 } | 103 |
106 | 104 static PKIX_Boolean server() { |
107 static· | 105 PKIX_Int32 bytesRead = 0; |
108 PKIX_Boolean server() | 106 PKIX_Int32 bytesWritten = 0; |
109 { | 107 PKIX_Boolean keepGoing = PKIX_FALSE; |
110 PKIX_Int32 bytesRead = 0; | 108 |
111 PKIX_Int32 bytesWritten = 0; | 109 PKIX_TEST_STD_VARS(); |
112 PKIX_Boolean keepGoing = PKIX_FALSE; | 110 |
113 | 111 switch (serverState) { |
114 PKIX_TEST_STD_VARS(); | 112 case SERVER_LISTENING: |
115 | 113 subTest("SERVER_LISTENING"); |
116 switch (serverState) { | 114 PKIX_TEST_EXPECT_NO_ERROR( |
117 case SERVER_LISTENING: | 115 sCallbackList->acceptCallback(sSock, &rendezvousSock, plContext)); |
118 subTest("SERVER_LISTENING"); | 116 if (rendezvousSock) { |
119 PKIX_TEST_EXPECT_NO_ERROR(sCallbackList->acceptCallback | 117 PKIX_TEST_EXPECT_NO_ERROR(pkix_pl_Socket_GetCallbackList( |
120 (sSock, &rendezvousSock, plContext)); | 118 rendezvousSock, &rvCallbackList, plContext)); |
121 if (rendezvousSock) { | 119 |
122 PKIX_TEST_EXPECT_NO_ERROR(pkix_pl_Socket_GetCallbackList | 120 serverState = SERVER_RECV1; |
123 (rendezvousSock, &rvCallbackList, plContext)); | 121 } |
124 | 122 break; |
125 serverState = SERVER_RECV1; | 123 case SERVER_RECV1: |
126 } | 124 subTest("SERVER_RECV1"); |
127 break; | 125 PKIX_TEST_EXPECT_NO_ERROR(rvCallbackList->recvCallback( |
128 case SERVER_RECV1: | 126 rendezvousSock, rcvBuf1, sizeof(rcvBuf1), &bytesRead, plContext)); |
129 subTest("SERVER_RECV1"); | 127 |
130 PKIX_TEST_EXPECT_NO_ERROR(rvCallbackList->recvCallback | 128 if (bytesRead > 0) { |
131 (rendezvousSock, | 129 /* confirm that rcvBuf1 = sendBuf1 */ |
132 rcvBuf1, | 130 if ((bytesRead != (PRInt32)PL_strlen(sendBuf1) + 1) || |
133 sizeof(rcvBuf1), | 131 (strncmp(sendBuf1, rcvBuf1, bytesRead) != 0)) { |
134 &bytesRead, | 132 testError("Receive buffer mismatch\n"); |
135 plContext)); | |
136 | |
137 if (bytesRead > 0) { | |
138 /* confirm that rcvBuf1 = sendBuf1 */ | |
139 if ((bytesRead != (PRInt32)PL_strlen(sendBuf1) + 1) || | |
140 (strncmp(sendBuf1, rcvBuf1, bytesRead) != 0)) { | |
141 testError("Receive buffer mismatch\n"); | |
142 } | |
143 | |
144 serverState = SERVER_SEND2; | |
145 keepGoing = PKIX_TRUE; | |
146 } else { | |
147 serverState = SERVER_POLL1; | |
148 } | |
149 break; | |
150 case SERVER_POLL1: | |
151 subTest("SERVER_POLL1"); | |
152 PKIX_TEST_EXPECT_NO_ERROR(rvCallbackList->pollCallback | |
153 (rendezvousSock, NULL, &bytesRead, plContext)); | |
154 | |
155 if (bytesRead > 0) { | |
156 /* confirm that rcvBuf1 = sendBuf1 */ | |
157 if ((bytesRead != (PRInt32)PL_strlen(sendBuf1) + 1) || | |
158 (strncmp(sendBuf1, rcvBuf1, bytesRead) != 0)) { | |
159 testError("Receive buffer mismatch\n"); | |
160 } | |
161 | |
162 serverState = SERVER_SEND2; | |
163 keepGoing = PKIX_TRUE; | |
164 } | |
165 break; | |
166 case SERVER_SEND2: | |
167 subTest("SERVER_SEND2"); | |
168 PKIX_TEST_EXPECT_NO_ERROR(rvCallbackList->sendCallback | |
169 (rendezvousSock, | |
170 sendBuf2, | |
171 strlen(sendBuf2) + 1, | |
172 &bytesWritten, | |
173 plContext)); | |
174 if (bytesWritten > 0) { | |
175 serverState = SERVER_RECV3; | |
176 } else { | |
177 serverState = SERVER_POLL2; | |
178 } | |
179 break; | |
180 case SERVER_POLL2: | |
181 subTest("SERVER_POLL2"); | |
182 PKIX_TEST_EXPECT_NO_ERROR(rvCallbackList->pollCallback | |
183 (rendezvousSock, &bytesWritten, NULL, plContext)); | |
184 if (bytesWritten > 0) { | |
185 serverState = SERVER_RECV3; | |
186 } | |
187 break; | |
188 case SERVER_RECV3: | |
189 subTest("SERVER_RECV3"); | |
190 PKIX_TEST_EXPECT_NO_ERROR(rvCallbackList->recvCallback | |
191 (rendezvousSock, | |
192 rcvBuf1, | |
193 sizeof(rcvBuf1), | |
194 &bytesRead, | |
195 plContext)); | |
196 | |
197 if (bytesRead > 0) { | |
198 serverState = SERVER_SEND4; | |
199 keepGoing = PKIX_TRUE; | |
200 } else { | |
201 serverState = SERVER_POLL3; | |
202 } | |
203 break; | |
204 case SERVER_POLL3: | |
205 subTest("SERVER_POLL3"); | |
206 PKIX_TEST_EXPECT_NO_ERROR(rvCallbackList->pollCallback | |
207 (rendezvousSock, NULL, &bytesRead, plContext)); | |
208 if (bytesRead > 0) { | |
209 serverState = SERVER_SEND4; | |
210 keepGoing = PKIX_TRUE; | |
211 } | |
212 break; | |
213 case SERVER_SEND4: | |
214 subTest("SERVER_SEND4"); | |
215 PKIX_TEST_EXPECT_NO_ERROR(rvCallbackList->sendCallback | |
216 (rendezvousSock, | |
217 sendBuf4, | |
218 strlen(sendBuf4) + 1, | |
219 &bytesWritten, | |
220 plContext)); | |
221 | |
222 if (bytesWritten > 0) { | |
223 PKIX_TEST_EXPECT_NO_ERROR(rvCallbackList->shutdownCallba
ck | |
224 (rendezvousSock, plContext)); | |
225 PKIX_TEST_DECREF_BC(sSock); | |
226 PKIX_TEST_DECREF_BC(rendezvousSock); | |
227 serverState = SERVER_DONE; | |
228 } else { | |
229 serverState = SERVER_POLL4; | |
230 } | |
231 break; | |
232 case SERVER_POLL4: | |
233 subTest("SERVER_POLL4"); | |
234 PKIX_TEST_EXPECT_NO_ERROR(rvCallbackList->pollCallback | |
235 (rendezvousSock, &bytesWritten, NULL, plContext)); | |
236 if (bytesWritten > 0) { | |
237 PKIX_TEST_EXPECT_NO_ERROR(rvCallbackList->shutdownCallba
ck | |
238 (rendezvousSock, plContext)); | |
239 PKIX_TEST_DECREF_BC(sSock); | |
240 PKIX_TEST_DECREF_BC(rendezvousSock); | |
241 serverState = SERVER_DONE; | |
242 } | |
243 break; | |
244 case SERVER_DONE: | |
245 default: | |
246 subTest("SERVER_DONE"); | |
247 break; | |
248 } | 133 } |
249 | 134 |
| 135 serverState = SERVER_SEND2; |
| 136 keepGoing = PKIX_TRUE; |
| 137 } else { |
| 138 serverState = SERVER_POLL1; |
| 139 } |
| 140 break; |
| 141 case SERVER_POLL1: |
| 142 subTest("SERVER_POLL1"); |
| 143 PKIX_TEST_EXPECT_NO_ERROR(rvCallbackList->pollCallback( |
| 144 rendezvousSock, NULL, &bytesRead, plContext)); |
| 145 |
| 146 if (bytesRead > 0) { |
| 147 /* confirm that rcvBuf1 = sendBuf1 */ |
| 148 if ((bytesRead != (PRInt32)PL_strlen(sendBuf1) + 1) || |
| 149 (strncmp(sendBuf1, rcvBuf1, bytesRead) != 0)) { |
| 150 testError("Receive buffer mismatch\n"); |
| 151 } |
| 152 |
| 153 serverState = SERVER_SEND2; |
| 154 keepGoing = PKIX_TRUE; |
| 155 } |
| 156 break; |
| 157 case SERVER_SEND2: |
| 158 subTest("SERVER_SEND2"); |
| 159 PKIX_TEST_EXPECT_NO_ERROR(rvCallbackList->sendCallback( |
| 160 rendezvousSock, sendBuf2, strlen(sendBuf2) + 1, &bytesWritten, |
| 161 plContext)); |
| 162 if (bytesWritten > 0) { |
| 163 serverState = SERVER_RECV3; |
| 164 } else { |
| 165 serverState = SERVER_POLL2; |
| 166 } |
| 167 break; |
| 168 case SERVER_POLL2: |
| 169 subTest("SERVER_POLL2"); |
| 170 PKIX_TEST_EXPECT_NO_ERROR(rvCallbackList->pollCallback( |
| 171 rendezvousSock, &bytesWritten, NULL, plContext)); |
| 172 if (bytesWritten > 0) { |
| 173 serverState = SERVER_RECV3; |
| 174 } |
| 175 break; |
| 176 case SERVER_RECV3: |
| 177 subTest("SERVER_RECV3"); |
| 178 PKIX_TEST_EXPECT_NO_ERROR(rvCallbackList->recvCallback( |
| 179 rendezvousSock, rcvBuf1, sizeof(rcvBuf1), &bytesRead, plContext)); |
| 180 |
| 181 if (bytesRead > 0) { |
| 182 serverState = SERVER_SEND4; |
| 183 keepGoing = PKIX_TRUE; |
| 184 } else { |
| 185 serverState = SERVER_POLL3; |
| 186 } |
| 187 break; |
| 188 case SERVER_POLL3: |
| 189 subTest("SERVER_POLL3"); |
| 190 PKIX_TEST_EXPECT_NO_ERROR(rvCallbackList->pollCallback( |
| 191 rendezvousSock, NULL, &bytesRead, plContext)); |
| 192 if (bytesRead > 0) { |
| 193 serverState = SERVER_SEND4; |
| 194 keepGoing = PKIX_TRUE; |
| 195 } |
| 196 break; |
| 197 case SERVER_SEND4: |
| 198 subTest("SERVER_SEND4"); |
| 199 PKIX_TEST_EXPECT_NO_ERROR(rvCallbackList->sendCallback( |
| 200 rendezvousSock, sendBuf4, strlen(sendBuf4) + 1, &bytesWritten, |
| 201 plContext)); |
| 202 |
| 203 if (bytesWritten > 0) { |
| 204 PKIX_TEST_EXPECT_NO_ERROR( |
| 205 rvCallbackList->shutdownCallback(rendezvousSock, plContext)); |
| 206 PKIX_TEST_DECREF_BC(sSock); |
| 207 PKIX_TEST_DECREF_BC(rendezvousSock); |
| 208 serverState = SERVER_DONE; |
| 209 } else { |
| 210 serverState = SERVER_POLL4; |
| 211 } |
| 212 break; |
| 213 case SERVER_POLL4: |
| 214 subTest("SERVER_POLL4"); |
| 215 PKIX_TEST_EXPECT_NO_ERROR(rvCallbackList->pollCallback( |
| 216 rendezvousSock, &bytesWritten, NULL, plContext)); |
| 217 if (bytesWritten > 0) { |
| 218 PKIX_TEST_EXPECT_NO_ERROR( |
| 219 rvCallbackList->shutdownCallback(rendezvousSock, plContext)); |
| 220 PKIX_TEST_DECREF_BC(sSock); |
| 221 PKIX_TEST_DECREF_BC(rendezvousSock); |
| 222 serverState = SERVER_DONE; |
| 223 } |
| 224 break; |
| 225 case SERVER_DONE: |
| 226 default: |
| 227 subTest("SERVER_DONE"); |
| 228 break; |
| 229 } |
| 230 |
250 cleanup: | 231 cleanup: |
251 | 232 |
252 PKIX_TEST_RETURN(); | 233 PKIX_TEST_RETURN(); |
253 | 234 |
254 return (keepGoing); | 235 return (keepGoing); |
255 } | 236 } |
256 | 237 |
257 static· | 238 static PKIX_Boolean client() { |
258 PKIX_Boolean client()· | 239 PKIX_Boolean keepGoing = PKIX_FALSE; |
259 { | 240 PKIX_Int32 bytesRead = 0; |
260 PKIX_Boolean keepGoing = PKIX_FALSE; | 241 PKIX_Int32 bytesWritten = 0; |
261 PKIX_Int32 bytesRead = 0; | 242 PRErrorCode cStat = 0; |
262 PKIX_Int32 bytesWritten = 0; | 243 |
263 PRErrorCode cStat = 0; | 244 /* At 2 seconds each cycle, this should suffice! */ |
264 | 245 PKIX_UInt32 giveUpCount = 10; |
265 /* At 2 seconds each cycle, this should suffice! */ | 246 |
266 PKIX_UInt32 giveUpCount = 10; | 247 PKIX_TEST_STD_VARS(); |
267 | 248 |
268 PKIX_TEST_STD_VARS(); | 249 switch (clientState) { |
269 | 250 case CLIENT_WAITFORCONNECT: |
270 switch (clientState) { | 251 subTest("CLIENT_WAITFORCONNECT"); |
271 case CLIENT_WAITFORCONNECT: | 252 clientState = CLIENT_FAILED; |
272 subTest("CLIENT_WAITFORCONNECT"); | 253 PKIX_TEST_EXPECT_NO_ERROR( |
273 clientState = CLIENT_FAILED; | 254 cCallbackList->connectcontinueCallback(cSock, &cStat, plContext)); |
274 PKIX_TEST_EXPECT_NO_ERROR(cCallbackList->connectcontinueCallback | 255 if (cStat == 0) { |
275 (cSock, &cStat, plContext)); | 256 clientState = CLIENT_SEND1; |
276 if (cStat == 0) { | 257 keepGoing = PKIX_TRUE; |
277 clientState = CLIENT_SEND1; | 258 } else { |
278 keepGoing = PKIX_TRUE; | 259 clientState = CLIENT_WAITFORCONNECT; |
279 } else { | 260 if (--giveUpCount == 0) { |
280 clientState = CLIENT_WAITFORCONNECT; | 261 testError("Client unable to connect"); |
281 if (--giveUpCount == 0) { | |
282 testError("Client unable to connect"); | |
283 } | |
284 } | |
285 break; | |
286 case CLIENT_SEND1: | |
287 subTest("CLIENT_SEND1"); | |
288 clientState = CLIENT_FAILED; | |
289 PKIX_TEST_EXPECT_NO_ERROR(cCallbackList->sendCallback | |
290 (cSock, | |
291 sendBuf1, | |
292 strlen(sendBuf1) + 1, | |
293 &bytesWritten, | |
294 plContext)); | |
295 if (bytesWritten > 0) { | |
296 clientState = CLIENT_RECV2; | |
297 } else { | |
298 clientState = CLIENT_POLL1; | |
299 } | |
300 break; | |
301 case CLIENT_POLL1: | |
302 subTest("CLIENT_POLL1"); | |
303 clientState = CLIENT_FAILED; | |
304 PKIX_TEST_EXPECT_NO_ERROR(cCallbackList->pollCallback | |
305 (cSock, &bytesWritten, NULL, plContext)); | |
306 if (bytesWritten > 0) { | |
307 clientState = CLIENT_RECV2; | |
308 } else { | |
309 clientState = CLIENT_POLL1; | |
310 } | |
311 break; | |
312 case CLIENT_RECV2: | |
313 subTest("CLIENT_RECV2"); | |
314 clientState = CLIENT_FAILED; | |
315 PKIX_TEST_EXPECT_NO_ERROR(cCallbackList->recvCallback | |
316 (cSock, | |
317 rcvBuf2, | |
318 sizeof(rcvBuf2), | |
319 &bytesRead, | |
320 plContext)); | |
321 | |
322 if (bytesRead > 0) { | |
323 /* confirm that rcvBuf2 = sendBuf2 */ | |
324 if ((bytesRead != (PRInt32)PL_strlen(sendBuf2) + 1) || | |
325 (strncmp(sendBuf2, rcvBuf2, bytesRead) != 0)) { | |
326 testError("Receive buffer mismatch\n"); | |
327 } | |
328 clientState = CLIENT_SEND3; | |
329 keepGoing = PKIX_TRUE; | |
330 } else { | |
331 clientState = CLIENT_POLL2; | |
332 } | |
333 break; | |
334 case CLIENT_POLL2: | |
335 subTest("CLIENT_POLL2"); | |
336 clientState = CLIENT_FAILED; | |
337 PKIX_TEST_EXPECT_NO_ERROR(cCallbackList->pollCallback | |
338 (cSock, NULL, &bytesRead, plContext)); | |
339 if (bytesRead > 0) { | |
340 /* confirm that rcvBuf2 = sendBuf2 */ | |
341 if ((bytesRead != (PRInt32)PL_strlen(sendBuf2) + 1) || | |
342 (strncmp(sendBuf2, rcvBuf2, bytesRead) != 0)) { | |
343 testError("Receive buffer mismatch\n"); | |
344 } | |
345 clientState = CLIENT_SEND3; | |
346 } else { | |
347 clientState = CLIENT_POLL2; | |
348 } | |
349 break; | |
350 case CLIENT_SEND3: | |
351 subTest("CLIENT_SEND3"); | |
352 clientState = CLIENT_FAILED; | |
353 PKIX_TEST_EXPECT_NO_ERROR(cCallbackList->sendCallback | |
354 (cSock, | |
355 sendBuf3, | |
356 strlen(sendBuf3) + 1, | |
357 &bytesWritten, | |
358 plContext)); | |
359 | |
360 if (bytesWritten > 0) { | |
361 clientState = CLIENT_RECV4; | |
362 } else { | |
363 clientState = CLIENT_POLL3; | |
364 } | |
365 break; | |
366 case CLIENT_POLL3: | |
367 subTest("CLIENT_POLL3"); | |
368 clientState = CLIENT_FAILED; | |
369 PKIX_TEST_EXPECT_NO_ERROR(cCallbackList->pollCallback | |
370 (cSock, &bytesWritten, NULL, plContext)); | |
371 if (bytesWritten > 0) { | |
372 clientState = CLIENT_RECV4; | |
373 } else { | |
374 clientState = CLIENT_POLL3; | |
375 } | |
376 break; | |
377 case CLIENT_RECV4: | |
378 subTest("CLIENT_RECV4"); | |
379 clientState = CLIENT_FAILED; | |
380 PKIX_TEST_EXPECT_NO_ERROR(cCallbackList->recvCallback | |
381 (cSock, | |
382 rcvBuf2, | |
383 sizeof(rcvBuf2), | |
384 &bytesRead, | |
385 plContext)); | |
386 | |
387 if (bytesRead > 0) { | |
388 PKIX_TEST_EXPECT_NO_ERROR(cCallbackList->shutdownCallbac
k | |
389 (cSock, plContext)); | |
390 PKIX_TEST_DECREF_BC(cSock); | |
391 clientState = CLIENT_DONE; | |
392 } else { | |
393 clientState = CLIENT_POLL4; | |
394 } | |
395 break; | |
396 case CLIENT_POLL4: | |
397 subTest("CLIENT_POLL4"); | |
398 clientState = CLIENT_FAILED; | |
399 PKIX_TEST_EXPECT_NO_ERROR(cCallbackList->pollCallback | |
400 (cSock, NULL, &bytesRead, plContext)); | |
401 if (bytesRead > 0) { | |
402 PKIX_TEST_EXPECT_NO_ERROR(cCallbackList->shutdownCallbac
k | |
403 (cSock, plContext)); | |
404 PKIX_TEST_DECREF_BC(cSock); | |
405 clientState = CLIENT_DONE; | |
406 } else { | |
407 clientState = CLIENT_POLL4; | |
408 } | |
409 break; | |
410 case CLIENT_DONE: | |
411 default: | |
412 subTest("CLIENT_DONE"); | |
413 break; | |
414 } | 262 } |
| 263 } |
| 264 break; |
| 265 case CLIENT_SEND1: |
| 266 subTest("CLIENT_SEND1"); |
| 267 clientState = CLIENT_FAILED; |
| 268 PKIX_TEST_EXPECT_NO_ERROR(cCallbackList->sendCallback( |
| 269 cSock, sendBuf1, strlen(sendBuf1) + 1, &bytesWritten, plContext)); |
| 270 if (bytesWritten > 0) { |
| 271 clientState = CLIENT_RECV2; |
| 272 } else { |
| 273 clientState = CLIENT_POLL1; |
| 274 } |
| 275 break; |
| 276 case CLIENT_POLL1: |
| 277 subTest("CLIENT_POLL1"); |
| 278 clientState = CLIENT_FAILED; |
| 279 PKIX_TEST_EXPECT_NO_ERROR( |
| 280 cCallbackList->pollCallback(cSock, &bytesWritten, NULL, plContext)); |
| 281 if (bytesWritten > 0) { |
| 282 clientState = CLIENT_RECV2; |
| 283 } else { |
| 284 clientState = CLIENT_POLL1; |
| 285 } |
| 286 break; |
| 287 case CLIENT_RECV2: |
| 288 subTest("CLIENT_RECV2"); |
| 289 clientState = CLIENT_FAILED; |
| 290 PKIX_TEST_EXPECT_NO_ERROR(cCallbackList->recvCallback( |
| 291 cSock, rcvBuf2, sizeof(rcvBuf2), &bytesRead, plContext)); |
| 292 |
| 293 if (bytesRead > 0) { |
| 294 /* confirm that rcvBuf2 = sendBuf2 */ |
| 295 if ((bytesRead != (PRInt32)PL_strlen(sendBuf2) + 1) || |
| 296 (strncmp(sendBuf2, rcvBuf2, bytesRead) != 0)) { |
| 297 testError("Receive buffer mismatch\n"); |
| 298 } |
| 299 clientState = CLIENT_SEND3; |
| 300 keepGoing = PKIX_TRUE; |
| 301 } else { |
| 302 clientState = CLIENT_POLL2; |
| 303 } |
| 304 break; |
| 305 case CLIENT_POLL2: |
| 306 subTest("CLIENT_POLL2"); |
| 307 clientState = CLIENT_FAILED; |
| 308 PKIX_TEST_EXPECT_NO_ERROR( |
| 309 cCallbackList->pollCallback(cSock, NULL, &bytesRead, plContext)); |
| 310 if (bytesRead > 0) { |
| 311 /* confirm that rcvBuf2 = sendBuf2 */ |
| 312 if ((bytesRead != (PRInt32)PL_strlen(sendBuf2) + 1) || |
| 313 (strncmp(sendBuf2, rcvBuf2, bytesRead) != 0)) { |
| 314 testError("Receive buffer mismatch\n"); |
| 315 } |
| 316 clientState = CLIENT_SEND3; |
| 317 } else { |
| 318 clientState = CLIENT_POLL2; |
| 319 } |
| 320 break; |
| 321 case CLIENT_SEND3: |
| 322 subTest("CLIENT_SEND3"); |
| 323 clientState = CLIENT_FAILED; |
| 324 PKIX_TEST_EXPECT_NO_ERROR(cCallbackList->sendCallback( |
| 325 cSock, sendBuf3, strlen(sendBuf3) + 1, &bytesWritten, plContext)); |
| 326 |
| 327 if (bytesWritten > 0) { |
| 328 clientState = CLIENT_RECV4; |
| 329 } else { |
| 330 clientState = CLIENT_POLL3; |
| 331 } |
| 332 break; |
| 333 case CLIENT_POLL3: |
| 334 subTest("CLIENT_POLL3"); |
| 335 clientState = CLIENT_FAILED; |
| 336 PKIX_TEST_EXPECT_NO_ERROR( |
| 337 cCallbackList->pollCallback(cSock, &bytesWritten, NULL, plContext)); |
| 338 if (bytesWritten > 0) { |
| 339 clientState = CLIENT_RECV4; |
| 340 } else { |
| 341 clientState = CLIENT_POLL3; |
| 342 } |
| 343 break; |
| 344 case CLIENT_RECV4: |
| 345 subTest("CLIENT_RECV4"); |
| 346 clientState = CLIENT_FAILED; |
| 347 PKIX_TEST_EXPECT_NO_ERROR(cCallbackList->recvCallback( |
| 348 cSock, rcvBuf2, sizeof(rcvBuf2), &bytesRead, plContext)); |
| 349 |
| 350 if (bytesRead > 0) { |
| 351 PKIX_TEST_EXPECT_NO_ERROR( |
| 352 cCallbackList->shutdownCallback(cSock, plContext)); |
| 353 PKIX_TEST_DECREF_BC(cSock); |
| 354 clientState = CLIENT_DONE; |
| 355 } else { |
| 356 clientState = CLIENT_POLL4; |
| 357 } |
| 358 break; |
| 359 case CLIENT_POLL4: |
| 360 subTest("CLIENT_POLL4"); |
| 361 clientState = CLIENT_FAILED; |
| 362 PKIX_TEST_EXPECT_NO_ERROR( |
| 363 cCallbackList->pollCallback(cSock, NULL, &bytesRead, plContext)); |
| 364 if (bytesRead > 0) { |
| 365 PKIX_TEST_EXPECT_NO_ERROR( |
| 366 cCallbackList->shutdownCallback(cSock, plContext)); |
| 367 PKIX_TEST_DECREF_BC(cSock); |
| 368 clientState = CLIENT_DONE; |
| 369 } else { |
| 370 clientState = CLIENT_POLL4; |
| 371 } |
| 372 break; |
| 373 case CLIENT_DONE: |
| 374 default: |
| 375 subTest("CLIENT_DONE"); |
| 376 break; |
| 377 } |
415 | 378 |
416 cleanup: | 379 cleanup: |
417 | 380 |
418 PKIX_TEST_RETURN(); | 381 PKIX_TEST_RETURN(); |
419 | 382 |
420 return (keepGoing); | 383 return (keepGoing); |
421 } | 384 } |
422 | 385 |
423 static | 386 static void dispatcher() { |
424 void dispatcher() | 387 PKIX_Boolean keepGoing = PKIX_FALSE; |
425 { | 388 |
426 PKIX_Boolean keepGoing = PKIX_FALSE; | 389 PKIX_TEST_STD_VARS(); |
427 | 390 |
428 PKIX_TEST_STD_VARS(); | 391 do { |
429 | 392 if (serverState < SERVER_DONE) { |
430 do { | 393 do { |
431 if (serverState < SERVER_DONE) { | 394 keepGoing = server(); |
432 do { | 395 } while (keepGoing == PKIX_TRUE); |
433 keepGoing = server(); | 396 } |
434 } while (keepGoing == PKIX_TRUE); | 397 if (clientState < CLIENT_DONE) { |
435 } | 398 do { |
436 if (clientState < CLIENT_DONE) { | 399 keepGoing = client(); |
437 do { | 400 } while (keepGoing == PKIX_TRUE); |
438 keepGoing = client(); | 401 } |
439 } while (keepGoing == PKIX_TRUE); | 402 do_other_work(); |
440 } | 403 |
441 do_other_work(); | 404 } while ((serverState < SERVER_DONE) || (clientState < CLIENT_DONE)); |
442 ········ | 405 |
443 } while ((serverState < SERVER_DONE) || (clientState < CLIENT_DONE)); | 406 PKIX_TEST_RETURN(); |
444 | 407 } |
445 PKIX_TEST_RETURN(); | 408 |
446 } | 409 int test_socket(int argc, char *argv[]) { |
447 | 410 |
448 int test_socket(int argc, char *argv[]) | 411 int j = 0; |
449 { | 412 PKIX_UInt32 actualMinorVersion; |
450 | 413 char buf[PR_NETDB_BUF_SIZE]; |
451 int j = 0; | 414 char *serverName = NULL; |
452 PKIX_UInt32 actualMinorVersion; | 415 char *sepPtr = NULL; |
453 char buf[PR_NETDB_BUF_SIZE]; | 416 PRHostEnt hostent; |
454 char *serverName = NULL; | 417 PRUint16 portNum = 0; |
455 char *sepPtr = NULL; | 418 PRStatus prstatus = PR_FAILURE; |
456 PRHostEnt hostent; | 419 PRErrorCode cStat = 0; |
457 PRUint16 portNum = 0; | 420 void *ipaddr = NULL; |
458 PRStatus prstatus = PR_FAILURE; | 421 PKIX_Error *bindError = NULL; |
459 PRErrorCode cStat = 0; | 422 PRIntn hostenum; |
460 void *ipaddr = NULL; | 423 |
461 PKIX_Error *bindError = NULL; | 424 PKIX_TEST_STD_VARS(); |
462 PRIntn hostenum; | 425 |
463 | 426 startTests("Socket"); |
464 PKIX_TEST_STD_VARS(); | 427 |
465 | 428 PKIX_TEST_EXPECT_NO_ERROR( |
466 startTests("Socket"); | 429 PKIX_PL_NssContext_Create(0, PKIX_FALSE, NULL, &plContext)); |
467 | 430 |
468 PKIX_TEST_EXPECT_NO_ERROR( | 431 if (argc != (j + 2)) { |
469 PKIX_PL_NssContext_Create(0, PKIX_FALSE, NULL, &plContext)); | 432 printUsage(argv[0]); |
470 | 433 pkixTestErrorMsg = "Missing command line argument."; |
471 if (argc != (j + 2)) { | 434 goto cleanup; |
472 printUsage(argv[0]); | 435 } |
473 pkixTestErrorMsg = "Missing command line argument."; | 436 |
474 goto cleanup; | 437 serverName = argv[j + 1]; |
475 } | 438 |
476 | 439 subTest("Using pkix_pl_Socket_CreateByName"); |
477 serverName = argv[j + 1]; | 440 |
478 | 441 PKIX_TEST_EXPECT_NO_ERROR(pkix_pl_Socket_CreateByName( |
479 subTest("Using pkix_pl_Socket_CreateByName"); | 442 PKIX_TRUE, timeout, serverName, &cStat, &sSock, plContext)); |
480 | 443 |
481 PKIX_TEST_EXPECT_NO_ERROR(pkix_pl_Socket_CreateByName | 444 PKIX_TEST_EXPECT_NO_ERROR( |
482 (PKIX_TRUE, timeout, serverName, &cStat, &sSock, plContext)); | 445 pkix_pl_Socket_GetCallbackList(sSock, &sCallbackList, plContext)); |
483 | 446 |
484 PKIX_TEST_EXPECT_NO_ERROR(pkix_pl_Socket_GetCallbackList | 447 PKIX_TEST_EXPECT_NO_ERROR( |
485 (sSock, &sCallbackList, plContext)); | 448 sCallbackList->listenCallback(sSock, backlog, plContext)); |
486 | 449 |
487 PKIX_TEST_EXPECT_NO_ERROR(sCallbackList->listenCallback | 450 serverState = SERVER_LISTENING; |
488 (sSock, backlog, plContext)); | 451 |
489 | 452 PKIX_TEST_EXPECT_NO_ERROR(pkix_pl_Socket_CreateByName( |
490 serverState = SERVER_LISTENING; | 453 PKIX_FALSE, timeout, serverName, &cStat, &cSock, plContext)); |
491 | 454 |
492 PKIX_TEST_EXPECT_NO_ERROR(pkix_pl_Socket_CreateByName | 455 PKIX_TEST_EXPECT_NO_ERROR( |
493 (PKIX_FALSE, timeout, serverName, &cStat, &cSock, plContext)); | 456 pkix_pl_Socket_GetCallbackList(cSock, &cCallbackList, plContext)); |
494 | 457 |
495 PKIX_TEST_EXPECT_NO_ERROR(pkix_pl_Socket_GetCallbackList | 458 if ((timeout == 0) && (cStat == PR_IN_PROGRESS_ERROR)) { |
496 (cSock, &cCallbackList, plContext)); | 459 clientState = CLIENT_WAITFORCONNECT; |
497 | 460 } else { |
498 if ((timeout == 0) && (cStat == PR_IN_PROGRESS_ERROR)) { | 461 clientState = CLIENT_SEND1; |
499 clientState = CLIENT_WAITFORCONNECT; | 462 } |
500 } else { | 463 |
501 clientState = CLIENT_SEND1; | 464 dispatcher(); |
502 } | 465 |
503 | 466 subTest("Using pkix_pl_Socket_Create"); |
504 dispatcher(); | 467 |
505 | 468 sepPtr = strchr(serverName, ':'); |
506 subTest("Using pkix_pl_Socket_Create"); | 469 /* First strip off the portnum, if present, from the end of the name */ |
507 | 470 if (sepPtr) { |
508 sepPtr = strchr(serverName, ':'); | 471 *sepPtr++ = '\0'; |
509 /* First strip off the portnum, if present, from the end of the name */ | 472 portNum = (PRUint16)atoi(sepPtr); |
510 if (sepPtr) { | 473 } else { |
511 *sepPtr++ = '\0'; | 474 portNum = (PRUint16)LDAP_PORT; |
512 portNum = (PRUint16)atoi(sepPtr); | 475 } |
513 } else { | 476 /* |
514 portNum = (PRUint16)LDAP_PORT; | 477 * The hostname may be a fully-qualified name. Just |
515 } | 478 * use the leftmost component in our lookup. |
516 /* | 479 */ |
517 * The hostname may be a fully-qualified name. Just | 480 sepPtr = strchr(serverName, '.'); |
518 * use the leftmost component in our lookup. | 481 if (sepPtr) { |
519 */ | 482 *sepPtr++ = '\0'; |
520 sepPtr = strchr(serverName, '.'); | 483 } |
521 if (sepPtr) { | 484 prstatus = PR_GetHostByName(serverName, buf, sizeof(buf), &hostent); |
522 *sepPtr++ = '\0'; | 485 |
523 } | 486 if ((prstatus != PR_SUCCESS) || (hostent.h_length != 4)) { |
524 prstatus = PR_GetHostByName(serverName, buf, sizeof(buf), &hostent); | 487 printUsage(argv[0]); |
525 | 488 pkixTestErrorMsg = "PR_GetHostByName rejects command line argument."; |
526 if ((prstatus != PR_SUCCESS) || (hostent.h_length != 4)) { | 489 goto cleanup; |
527 printUsage(argv[0]); | 490 } |
528 pkixTestErrorMsg = | 491 |
529 "PR_GetHostByName rejects command line argument."; | 492 serverNetAddr.inet.family = PR_AF_INET; |
530 goto cleanup; | 493 serverNetAddr.inet.port = PR_htons(portNum); |
531 } | 494 serverNetAddr.inet.ip = PR_INADDR_ANY; |
532 | 495 |
533 serverNetAddr.inet.family = PR_AF_INET; | 496 hostenum = PR_EnumerateHostEnt(0, &hostent, portNum, &clientNetAddr); |
534 serverNetAddr.inet.port = PR_htons(portNum); | 497 if (hostenum == -1) { |
535 serverNetAddr.inet.ip = PR_INADDR_ANY; | 498 pkixTestErrorMsg = "PR_EnumerateHostEnt failed."; |
536 | 499 goto cleanup; |
537 hostenum = PR_EnumerateHostEnt(0, &hostent, portNum, &clientNetAddr); | 500 } |
538 if (hostenum == -1) { | 501 |
539 pkixTestErrorMsg = | 502 backlog = 5; |
540 "PR_EnumerateHostEnt failed."; | 503 |
541 goto cleanup; | 504 /* timeout = PR_INTERVAL_NO_TIMEOUT; */ |
542 } | 505 /* timeout = 0; nonblocking */ |
543 | 506 timeout = 0; |
544 backlog = 5; | 507 |
545 | 508 bindError = pkix_pl_Socket_Create(PKIX_TRUE, timeout, &serverNetAddr, &cStat, |
546 /* timeout = PR_INTERVAL_NO_TIMEOUT; */ | 509 &sSock, plContext); |
547 /* timeout = 0; nonblocking */ | 510 |
548 timeout = 0; | 511 /* If PR_Bind can't handle INADDR_ANY, try it with the real name */ |
549 | 512 if (bindError) { |
550 bindError = pkix_pl_Socket_Create | 513 PKIX_TEST_DECREF_BC(bindError); |
551 (PKIX_TRUE, timeout, &serverNetAddr, &cStat, &sSock, plContext); | 514 serverNetAddr.inet.ip = PR_htonl(*(PRUint32 *)ipaddr); |
552 | 515 |
553 /* If PR_Bind can't handle INADDR_ANY, try it with the real name */ | 516 PKIX_TEST_EXPECT_NO_ERROR(pkix_pl_Socket_Create( |
554 if (bindError) { | 517 PKIX_TRUE, timeout, &serverNetAddr, &cStat, &sSock, plContext)); |
555 PKIX_TEST_DECREF_BC(bindError); | 518 } |
556 serverNetAddr.inet.ip = PR_htonl(*(PRUint32 *)ipaddr);· | 519 |
557 | 520 PKIX_TEST_EXPECT_NO_ERROR( |
558 PKIX_TEST_EXPECT_NO_ERROR(pkix_pl_Socket_Create | 521 pkix_pl_Socket_GetCallbackList(sSock, &sCallbackList, plContext)); |
559 (PKIX_TRUE, | 522 |
560 timeout, | 523 PKIX_TEST_EXPECT_NO_ERROR( |
561 &serverNetAddr, | 524 sCallbackList->listenCallback(sSock, backlog, plContext)); |
562 &cStat, | 525 |
563 &sSock, | 526 serverState = SERVER_LISTENING; |
564 plContext)); | 527 |
565 } | 528 PKIX_TEST_EXPECT_NO_ERROR(pkix_pl_Socket_Create( |
566 | 529 PKIX_FALSE, timeout, &clientNetAddr, &cStat, &cSock, plContext)); |
567 PKIX_TEST_EXPECT_NO_ERROR(pkix_pl_Socket_GetCallbackList | 530 |
568 (sSock, &sCallbackList, plContext)); | 531 PKIX_TEST_EXPECT_NO_ERROR( |
569 | 532 pkix_pl_Socket_GetCallbackList(cSock, &cCallbackList, plContext)); |
570 PKIX_TEST_EXPECT_NO_ERROR(sCallbackList->listenCallback | 533 |
571 (sSock, backlog, plContext)); | 534 if ((timeout == 0) && (cStat == PR_IN_PROGRESS_ERROR)) { |
572 | 535 clientState = CLIENT_WAITFORCONNECT; |
573 serverState = SERVER_LISTENING; | 536 } else { |
574 | 537 clientState = CLIENT_SEND1; |
575 PKIX_TEST_EXPECT_NO_ERROR(pkix_pl_Socket_Create | 538 } |
576 (PKIX_FALSE, timeout, &clientNetAddr, &cStat, &cSock, plContext)); | 539 |
577 | 540 dispatcher(); |
578 PKIX_TEST_EXPECT_NO_ERROR(pkix_pl_Socket_GetCallbackList | |
579 (cSock, &cCallbackList, plContext)); | |
580 | |
581 if ((timeout == 0) && (cStat == PR_IN_PROGRESS_ERROR)) { | |
582 clientState = CLIENT_WAITFORCONNECT; | |
583 } else { | |
584 clientState = CLIENT_SEND1; | |
585 } | |
586 | |
587 dispatcher(); | |
588 | 541 |
589 cleanup: | 542 cleanup: |
590 | 543 |
591 PKIX_TEST_DECREF_AC(sSock); | 544 PKIX_TEST_DECREF_AC(sSock); |
592 PKIX_TEST_DECREF_AC(cSock); | 545 PKIX_TEST_DECREF_AC(cSock); |
593 PKIX_TEST_DECREF_AC(rendezvousSock); | 546 PKIX_TEST_DECREF_AC(rendezvousSock); |
594 | 547 |
595 PKIX_TEST_RETURN(); | 548 PKIX_TEST_RETURN(); |
596 | 549 |
597 endTests("Socket"); | 550 endTests("Socket"); |
598 | 551 |
599 return (0); | 552 return (0); |
600 } | 553 } |
OLD | NEW |