|
1 /* |
|
2 * Copyright (c) 2002-2009 Nokia Corporation and/or its subsidiary(-ies). |
|
3 * All rights reserved. |
|
4 * This component and the accompanying materials are made available |
|
5 * under the terms of "Eclipse Public License v1.0" |
|
6 * which accompanies this distribution, and is available |
|
7 * at the URL "http://www.eclipse.org/legal/epl-v10.html". |
|
8 * |
|
9 * Initial Contributors: |
|
10 * Nokia Corporation - initial contribution. |
|
11 * |
|
12 * Contributors: |
|
13 * |
|
14 * Description: |
|
15 * |
|
16 */ |
|
17 |
|
18 |
|
19 |
|
20 #include "tsocket.h" |
|
21 #include <sys/un.h> |
|
22 |
|
23 const char* tcpdata = "Hello Open C and OPENENV!"; |
|
24 void* myclie(void* pv); |
|
25 int globalflag=0; |
|
26 int flag=0; |
|
27 const char * safdata="hello"; |
|
28 |
|
29 int doClient1(int port, int size); |
|
30 int doServer1(int port); |
|
31 |
|
32 const TUint KMaxLine = 100; |
|
33 const TInt KReadError = -1000; |
|
34 const TInt KWriteError = -1001; |
|
35 const TInt KErrSocket = -1002; |
|
36 const TInt KErrBind = -1003; |
|
37 const TInt KErrGetSockName=-1004; |
|
38 const TInt KErrListen=-1006; |
|
39 const TInt KErrShutdown = -1007; |
|
40 const TInt KErrRead = -1008; |
|
41 const TInt KErrConnect = -1009; |
|
42 const TInt KErrSockAtMark = -1011; |
|
43 const TInt KErrGetPeerName = -1012; |
|
44 const TInt KErrIoctl = -1013; |
|
45 const TInt KErrGetSocketName = -1014; |
|
46 const TInt KErrGetSockOpt = -1015; |
|
47 const TInt KErrAccept = -1016; |
|
48 const TInt KErrGetHostName = -1017; |
|
49 const TInt KErrLseek = -1018; |
|
50 |
|
51 const char KSoGet = 1; |
|
52 const char KSoSet = 2; |
|
53 const char KSoGetSet = 3; |
|
54 |
|
55 int read(int newsock_fd,char *line); |
|
56 int write(int sock_fd); |
|
57 |
|
58 int read1(int newsock_fd,char *line); |
|
59 int write1(int sock_fd); |
|
60 |
|
61 static void* UDPThread(TAny* ptr); |
|
62 static void* TCPThread(TAny* ptr); |
|
63 static void* ClientThread(TAny* ptr); |
|
64 static void* ShutDownThread(TAny* ptr); |
|
65 static void* UDPThreadSendMsg(TAny* ptr); |
|
66 |
|
67 static void* TCPThread1(TAny* ptr); |
|
68 #define PORT 5000 |
|
69 |
|
70 |
|
71 // ----------------------------------------------------------------------------- |
|
72 // CTestSocket::ExampleL |
|
73 // Example test method function. |
|
74 // (other items were commented in a header). |
|
75 // ----------------------------------------------------------------------------- |
|
76 // |
|
77 TInt CTestSocket::ExampleL( ) |
|
78 { |
|
79 _LIT( Ktsocket, "tsocket: ExampleL" ); |
|
80 // Print to log file |
|
81 INFO_PRINTF1( Ktsocket ); |
|
82 TPtrC string; |
|
83 _LIT( KParam, "Parameter: %S" ); |
|
84 |
|
85 _LIT( Kstring, "Parameter1" ); |
|
86 TBool res = GetStringFromConfig(ConfigSection(), Kstring, string ); |
|
87 if(!res) |
|
88 { |
|
89 _LIT(Kerr , "Failed to read input file name") ; |
|
90 INFO_PRINTF1(Kerr) ; |
|
91 return KErrGeneral ; |
|
92 } |
|
93 |
|
94 INFO_PRINTF2(KParam, &string ); |
|
95 return KErrNone; |
|
96 |
|
97 } |
|
98 |
|
99 |
|
100 TInt CTestSocket::UDP( ) |
|
101 { |
|
102 int sock_fd; |
|
103 unsigned int sender_len, receiver_len; |
|
104 sockaddr_in receiver_addr,sender_addr; |
|
105 char line[KMaxLine]; |
|
106 TInt ret = KErrNone; |
|
107 int threadRetVal = 0; |
|
108 int error ; |
|
109 pthread_t testThread; |
|
110 void *threadRetValPtr = (void*)&threadRetVal; |
|
111 sock_fd = socket(AF_INET,SOCK_DGRAM,IPPROTO_UDP); |
|
112 if (sock_fd < 0) |
|
113 { |
|
114 ret = KErrSocket; |
|
115 goto close; |
|
116 } |
|
117 receiver_addr.sin_family = AF_INET; |
|
118 receiver_addr.sin_addr.s_addr = htonl(INADDR_ANY); |
|
119 receiver_addr.sin_port = 0; |
|
120 if (bind(sock_fd,(sockaddr*)&receiver_addr,sizeof(receiver_addr)) < 0) |
|
121 { |
|
122 ret = KErrBind; |
|
123 goto close; |
|
124 } |
|
125 |
|
126 receiver_len = sizeof(receiver_addr); |
|
127 if (getsockname(sock_fd, (sockaddr*)&receiver_addr, &receiver_len) < 0) |
|
128 { |
|
129 ret = KErrGetSockName; |
|
130 goto close; |
|
131 } |
|
132 pthread_create(&testThread, NULL, &UDPThread, (void*)(receiver_addr.sin_port)); |
|
133 sender_len = sizeof(sender_addr); |
|
134 INFO_PRINTF1(_L("B recvfrom\n")); |
|
135 error = recvfrom(sock_fd,line,KMaxLine,0,(sockaddr*)&sender_addr,&sender_len); |
|
136 if (error < 0) |
|
137 { |
|
138 ret = KReadError; |
|
139 goto close; |
|
140 } |
|
141 pthread_join(testThread, &threadRetValPtr); |
|
142 if (threadRetVal < 0) |
|
143 { |
|
144 ret = threadRetVal; |
|
145 goto close; |
|
146 } |
|
147 close: |
|
148 shutdown(sock_fd,SHUT_RDWR); |
|
149 close(sock_fd); |
|
150 return ret; |
|
151 } |
|
152 |
|
153 static void* UDPThread(TAny* aParam) |
|
154 { |
|
155 sockaddr_in receiver_addr; |
|
156 int sock_fd; |
|
157 char character = 'A'; |
|
158 unsigned int cnt = 0; |
|
159 char line[KMaxLine]; |
|
160 sock_fd = socket(AF_INET,SOCK_DGRAM,IPPROTO_UDP); |
|
161 if (sock_fd < 0) |
|
162 { |
|
163 goto close; |
|
164 } |
|
165 |
|
166 |
|
167 for(; cnt < KMaxLine - 1; cnt++) |
|
168 { |
|
169 line[cnt] = character; |
|
170 character++; |
|
171 if (character > 'Z') |
|
172 { |
|
173 character = 'A'; |
|
174 } |
|
175 } |
|
176 line[cnt] = '\0'; |
|
177 |
|
178 receiver_addr.sin_family = AF_INET; |
|
179 receiver_addr.sin_addr.s_addr = htonl(INADDR_LOOPBACK); |
|
180 receiver_addr.sin_port = (int)aParam; |
|
181 if (sendto(sock_fd,line,KMaxLine,0,(sockaddr*)&receiver_addr,sizeof(receiver_addr)) < 0) |
|
182 { |
|
183 goto close; |
|
184 } |
|
185 close: |
|
186 shutdown(sock_fd,SHUT_RDWR); |
|
187 close(sock_fd); |
|
188 return (void*)NULL; |
|
189 } |
|
190 |
|
191 TInt CTestSocket::TCP( ) |
|
192 { |
|
193 int sock_fd,newsock_fd; |
|
194 int error; |
|
195 unsigned int addr_len, serv_len; |
|
196 sockaddr_in serv_addr,new_socket; |
|
197 TInt ret = KErrNone; |
|
198 |
|
199 sock_fd = socket(AF_INET,SOCK_STREAM,0); |
|
200 if (sock_fd < 0) |
|
201 { |
|
202 return KErrSocket; |
|
203 } |
|
204 serv_addr.sin_family = AF_INET; |
|
205 serv_addr.sin_addr.s_addr = htonl(INADDR_ANY); |
|
206 serv_addr.sin_port = 0; |
|
207 |
|
208 pthread_t testThread; |
|
209 int threadRetVal; |
|
210 void *threadRetValPtr = (void*)&threadRetVal; |
|
211 |
|
212 if (bind(sock_fd,(sockaddr*)&serv_addr,sizeof(serv_addr)) < 0) |
|
213 { |
|
214 ret = KErrBind; |
|
215 goto close; |
|
216 } |
|
217 serv_len = sizeof(serv_addr); |
|
218 if (getsockname(sock_fd, (sockaddr*)&serv_addr, &serv_len) < 0) |
|
219 { |
|
220 ret = KErrGetSockName; |
|
221 goto close; |
|
222 } |
|
223 |
|
224 if (listen(sock_fd,1) < 0) |
|
225 { |
|
226 ret = KErrListen; |
|
227 goto close; |
|
228 } |
|
229 |
|
230 addr_len = sizeof(new_socket); |
|
231 |
|
232 // Create the thread and thread is client code |
|
233 |
|
234 pthread_create(&testThread, NULL, &TCPThread, (void*)(serv_addr.sin_port)); |
|
235 |
|
236 newsock_fd = accept(sock_fd,(sockaddr*)&new_socket,&addr_len); // Code blocks here |
|
237 error = write(newsock_fd); |
|
238 if (error < 0) |
|
239 { |
|
240 ret = error; |
|
241 goto close; |
|
242 } |
|
243 |
|
244 close: |
|
245 pthread_join(testThread, &threadRetValPtr); |
|
246 shutdown(sock_fd,SHUT_RDWR); |
|
247 close(sock_fd); |
|
248 return ret; |
|
249 } |
|
250 |
|
251 |
|
252 |
|
253 int write(int sock_fd) |
|
254 { |
|
255 char line[KMaxLine]; |
|
256 |
|
257 char character = 'A'; |
|
258 unsigned int cnt = 0; |
|
259 for(; cnt < KMaxLine - 1; cnt++) |
|
260 { |
|
261 line[cnt] = character; |
|
262 character++; |
|
263 if (character > 'Z') |
|
264 { |
|
265 character = 'A'; |
|
266 } |
|
267 } |
|
268 line[cnt] = '\0'; |
|
269 if (send(sock_fd,line,KMaxLine,0) < 0) |
|
270 { |
|
271 return KWriteError; |
|
272 } |
|
273 |
|
274 return KErrNone; |
|
275 } |
|
276 |
|
277 static void* TCPThread(TAny* aParam) |
|
278 { |
|
279 sockaddr_in serv_addr; |
|
280 int sock_fd; |
|
281 char line[KMaxLine ]; |
|
282 |
|
283 serv_addr.sin_family = AF_INET; |
|
284 serv_addr.sin_addr.s_addr = htonl(INADDR_LOOPBACK); |
|
285 serv_addr.sin_port = (int)aParam; |
|
286 |
|
287 sock_fd = socket(AF_INET,SOCK_STREAM,0); |
|
288 if (sock_fd < 0) |
|
289 { |
|
290 goto close; |
|
291 } |
|
292 if (connect(sock_fd,(sockaddr*)&serv_addr,sizeof(serv_addr)) < 0) |
|
293 { |
|
294 goto close; |
|
295 } |
|
296 if (read(sock_fd,line) < 0) |
|
297 { |
|
298 goto close; |
|
299 } |
|
300 close: |
|
301 close(sock_fd); |
|
302 return (void*)NULL; |
|
303 } |
|
304 |
|
305 |
|
306 |
|
307 int read(int newsock_fd,char *line) |
|
308 { |
|
309 int ret; |
|
310 int left = KMaxLine; |
|
311 |
|
312 while (1) |
|
313 { |
|
314 |
|
315 ret = recv(newsock_fd,line,left,0); |
|
316 |
|
317 if (ret < 0) |
|
318 { |
|
319 return KReadError; |
|
320 } |
|
321 else if (ret == 0) |
|
322 { |
|
323 break; |
|
324 } |
|
325 left -= ret; |
|
326 line += ret; |
|
327 if (left <= 0) |
|
328 { |
|
329 break; |
|
330 } |
|
331 } |
|
332 return KErrNone; |
|
333 } |
|
334 |
|
335 |
|
336 TInt CTestSocket::GetSocketName( ) |
|
337 { |
|
338 int sock_fd; |
|
339 sockaddr_in addr,ss; |
|
340 TInt ret = KErrNone; |
|
341 char paramets[10][256]; |
|
342 unsigned int len = 0, addr_len = 0; |
|
343 |
|
344 /** |
|
345 * paramets[0]=socket family; |
|
346 * paramets[1]=sockettype |
|
347 * paramets[2]=protocol |
|
348 */ |
|
349 GetParameters(paramets); |
|
350 |
|
351 sock_fd=socket(atoi(paramets[0]), atoi(paramets[1]), atoi(paramets[2]) ); |
|
352 |
|
353 addr.sin_family = AF_INET; |
|
354 addr.sin_addr.s_addr = htonl(INADDR_ANY); |
|
355 addr.sin_port = 0; |
|
356 if (sock_fd < 0) |
|
357 { |
|
358 ret = KErrSocket; |
|
359 goto close; |
|
360 } |
|
361 if ( bind(sock_fd,(sockaddr*)&addr,sizeof(addr)) < 0) |
|
362 { |
|
363 ret = KErrBind; |
|
364 goto close; |
|
365 } |
|
366 addr_len = sizeof(addr); |
|
367 if (getsockname(sock_fd, (sockaddr*)&addr, &addr_len) < 0) |
|
368 { |
|
369 ret = KErrGetSockName; |
|
370 goto close; |
|
371 } |
|
372 |
|
373 len=sizeof(ss); |
|
374 if ( getsockname(sock_fd,(sockaddr*)&ss,&len) < 0) |
|
375 { |
|
376 ret = KErrGetSockName; |
|
377 return KErrGeneral; |
|
378 } |
|
379 |
|
380 ret = KErrNone; |
|
381 |
|
382 close: |
|
383 close(sock_fd); |
|
384 return ret; |
|
385 } |
|
386 |
|
387 TInt CTestSocket::GetSocketNameUsingFileDescriptor( ) |
|
388 { |
|
389 sockaddr_in ss; |
|
390 unsigned int len; |
|
391 int ret = KErrNone; |
|
392 |
|
393 len = sizeof(ss); |
|
394 |
|
395 // Wrong sockfd, errno shoud be ENOTSOCK |
|
396 ret = getsockname(0, (sockaddr*)&ss, &len); |
|
397 if (errno != ENOTSOCK) |
|
398 { |
|
399 ret = KErrGetSocketName; |
|
400 goto close; |
|
401 } |
|
402 if (ret == KErrNone) |
|
403 { |
|
404 ret = KErrGetSocketName; |
|
405 goto close; |
|
406 } |
|
407 |
|
408 ret = KErrNone; |
|
409 |
|
410 close: |
|
411 return ret; |
|
412 } |
|
413 |
|
414 TInt CTestSocket::GetSocketNameUsingInvalidSocketDescriptor( ) |
|
415 { |
|
416 sockaddr_in ss; |
|
417 unsigned int len; |
|
418 int ret = KErrNone; |
|
419 |
|
420 len = sizeof(ss); |
|
421 |
|
422 // Invalid fd, errno shoud be EBADF |
|
423 ret = getsockname(-1, (sockaddr*)&ss, &len); |
|
424 if (errno != EBADF ) |
|
425 { |
|
426 ret = KErrGetSocketName; |
|
427 goto close; |
|
428 } |
|
429 if (ret == KErrNone) |
|
430 { |
|
431 ret = KErrGetSocketName; |
|
432 goto close; |
|
433 } |
|
434 |
|
435 ret = KErrNone; |
|
436 |
|
437 close: |
|
438 return ret; |
|
439 } |
|
440 |
|
441 TInt CTestSocket::GetSocketNameInvalidSocketBuffer( ) |
|
442 { |
|
443 int sock_fd; |
|
444 sockaddr_in addr,ss; |
|
445 TInt ret = KErrNone; |
|
446 char paramets[10][256]; |
|
447 unsigned int len; |
|
448 |
|
449 /** |
|
450 * paramets[0]=socket family; |
|
451 * paramets[1]=sockettype |
|
452 * paramets[2]=protocol |
|
453 */ |
|
454 GetParameters(paramets); |
|
455 |
|
456 sock_fd=socket(atoi(paramets[0]), atoi(paramets[1]), atoi(paramets[2]) ); |
|
457 addr.sin_family = AF_INET; |
|
458 addr.sin_addr.s_addr = htonl(INADDR_ANY); |
|
459 addr.sin_port = 0; |
|
460 if (sock_fd < 0) |
|
461 { |
|
462 ret = KErrSocket; |
|
463 goto close; |
|
464 } |
|
465 if ( bind(sock_fd,(sockaddr*)&addr,sizeof(addr)) < 0) |
|
466 { |
|
467 ret = KErrBind; |
|
468 goto close; |
|
469 } |
|
470 len=sizeof(ss); |
|
471 ret = getsockname(sock_fd,(sockaddr*)0,&len); |
|
472 if (errno != EFAULT ) |
|
473 { |
|
474 ret = KErrGetSocketName; |
|
475 goto close; |
|
476 } |
|
477 if (ret == KErrNone) |
|
478 { |
|
479 ret = KErrGetSocketName; |
|
480 goto close; |
|
481 } |
|
482 |
|
483 ret = KErrNone; |
|
484 |
|
485 close: |
|
486 close(sock_fd); |
|
487 return ret; |
|
488 } |
|
489 |
|
490 TInt CTestSocket::GetSocketNameInvalidLength( ) |
|
491 { |
|
492 int sock_fd; |
|
493 sockaddr_in addr,ss; |
|
494 TInt ret = KErrNone; |
|
495 char paramets[10][256]; |
|
496 unsigned int len; |
|
497 |
|
498 /** |
|
499 * paramets[0]=socket family; |
|
500 * paramets[1]=sockettype |
|
501 * paramets[2]=protocol |
|
502 */ |
|
503 GetParameters(paramets); |
|
504 |
|
505 sock_fd=socket(atoi(paramets[0]), atoi(paramets[1]), atoi(paramets[2]) ); |
|
506 addr.sin_family = AF_INET; |
|
507 addr.sin_addr.s_addr = htonl(INADDR_ANY); |
|
508 addr.sin_port = 0; |
|
509 if (sock_fd < 0) |
|
510 { |
|
511 ret = KErrSocket; |
|
512 goto close; |
|
513 } |
|
514 if ( bind(sock_fd,(sockaddr*)&addr,sizeof(addr)) < 0) |
|
515 { |
|
516 ret = KErrBind; |
|
517 goto close; |
|
518 } |
|
519 len=1; |
|
520 ret = getsockname(sock_fd,(sockaddr*)&ss,&len); |
|
521 if (errno != KErrNone ) |
|
522 { |
|
523 ret = KErrGetSocketName; |
|
524 goto close; |
|
525 } |
|
526 |
|
527 |
|
528 ret = KErrNone; |
|
529 |
|
530 close: |
|
531 close(sock_fd); |
|
532 return ret; |
|
533 } |
|
534 |
|
535 TInt CTestSocket::GetPeerSocketName( ) |
|
536 { |
|
537 int sock_fd; |
|
538 int newsock_fd=0; |
|
539 int ret = KErrNone; |
|
540 char paramets[10][256]; |
|
541 unsigned int addr_len, serv_len; |
|
542 sockaddr_in serv_addr,new_socket,peer_addr; |
|
543 size_t peerlen = sizeof(peer_addr); |
|
544 |
|
545 /** |
|
546 * paramets[0]=socket family; |
|
547 * paramets[1]=sockettype |
|
548 * paramets[2]=protocol |
|
549 * paramets[3]=for shutdown() socket |
|
550 */ |
|
551 GetParameters(paramets); |
|
552 |
|
553 sock_fd = socket(atoi(paramets[0]), atoi(paramets[1]), atoi(paramets[2]) ); |
|
554 if (sock_fd < 0) |
|
555 { |
|
556 return KErrSocket; |
|
557 } |
|
558 serv_addr.sin_family = AF_INET; |
|
559 serv_addr.sin_addr.s_addr = htonl(INADDR_ANY); |
|
560 serv_addr.sin_port = 0; |
|
561 if (bind(sock_fd,(sockaddr*)&serv_addr,sizeof(serv_addr)) < 0) |
|
562 { |
|
563 close(sock_fd); |
|
564 return KErrBind; |
|
565 } |
|
566 serv_len = sizeof(serv_addr); |
|
567 pthread_t testThread; |
|
568 int threadRetVal; |
|
569 void *threadRetValPtr = (void*)&threadRetVal; |
|
570 if (getsockname(sock_fd, (sockaddr*)&serv_addr, &serv_len) < 0) |
|
571 { |
|
572 ret = KErrGetSockName; |
|
573 goto close; |
|
574 } |
|
575 |
|
576 if (listen(sock_fd,1) < 0) |
|
577 { |
|
578 close(sock_fd); |
|
579 return KErrListen; |
|
580 } |
|
581 |
|
582 addr_len = sizeof(new_socket); |
|
583 // Create the thread and thread is client code |
|
584 pthread_create(&testThread, NULL, &ShutDownThread, (void*)(serv_addr.sin_port)); |
|
585 newsock_fd = accept(sock_fd,(sockaddr*)&new_socket,&addr_len); // Code blocks here |
|
586 |
|
587 //for checking functionality of getpeername on shutdown socket |
|
588 if (atoi(paramets[3]) == 1) |
|
589 { |
|
590 shutdown(newsock_fd,SHUT_RDWR); |
|
591 pthread_join(testThread, &threadRetValPtr); |
|
592 } |
|
593 if (getpeername(newsock_fd,(sockaddr *)&peer_addr,&peerlen) != 0) |
|
594 { |
|
595 if (atoi(paramets[3]) == 1) // Expected error |
|
596 { |
|
597 ret = KErrNone; |
|
598 } |
|
599 else |
|
600 { |
|
601 ret = KErrGetPeerName; |
|
602 } |
|
603 goto close; |
|
604 } |
|
605 send(newsock_fd, (void*)"a", 1, 0); |
|
606 close: |
|
607 pthread_join(testThread, &threadRetValPtr); |
|
608 shutdown(newsock_fd,SHUT_RDWR) ; |
|
609 close(sock_fd); |
|
610 return ret; |
|
611 } |
|
612 |
|
613 TInt CTestSocket::GetPeerSocketNameUsingFileDescriptor( ) |
|
614 { |
|
615 sockaddr_in ss; |
|
616 unsigned int len; |
|
617 int ret = KErrNone; |
|
618 |
|
619 len = sizeof(ss); |
|
620 ret = getpeername(0, (sockaddr*)&ss, &len); |
|
621 if (errno != ENOTSOCK) |
|
622 { |
|
623 ret = KErrGetPeerName; |
|
624 goto close; |
|
625 } |
|
626 if (ret == KErrNone) |
|
627 { |
|
628 ret = KErrGetPeerName; |
|
629 goto close; |
|
630 } |
|
631 |
|
632 ret = KErrNone; |
|
633 |
|
634 close: |
|
635 return ret; |
|
636 } |
|
637 |
|
638 TInt CTestSocket::GetPeerSocketNameUsingInvalidSocketDescriptor( ) |
|
639 { |
|
640 sockaddr_in ss; |
|
641 unsigned int len; |
|
642 int ret = KErrNone; |
|
643 |
|
644 len = sizeof(ss); |
|
645 ret = getpeername(-1, (sockaddr*)&ss, &len); |
|
646 if (errno != EBADF ) |
|
647 { |
|
648 ret = KErrBind; |
|
649 goto close; |
|
650 } |
|
651 if (ret == KErrNone) |
|
652 { |
|
653 ret = KErrBind; |
|
654 goto close; |
|
655 } |
|
656 |
|
657 ret = KErrNone; |
|
658 |
|
659 close: |
|
660 return ret; |
|
661 } |
|
662 |
|
663 TInt CTestSocket::GetPeerSocketNameforUnconnectedSocket( ) |
|
664 { |
|
665 sockaddr_in ss; |
|
666 unsigned int len; |
|
667 int ret = KErrNone; |
|
668 int err; |
|
669 len = sizeof(ss); |
|
670 int sock_fd; |
|
671 |
|
672 sock_fd=socket(AF_INET,SOCK_STREAM,IPPROTO_TCP); |
|
673 if (getpeername(sock_fd, (sockaddr*)&ss, &len) < 0) |
|
674 { |
|
675 err=errno; |
|
676 if(err!=ENOTCONN) |
|
677 { |
|
678 ret=KErrGetPeerName; |
|
679 } |
|
680 else |
|
681 { |
|
682 ret = KErrNone; |
|
683 } |
|
684 goto close; |
|
685 } |
|
686 close: |
|
687 return ret; |
|
688 } |
|
689 |
|
690 TInt CTestSocket::GetPeerSocketNameInvalidLengthSockAddr( ) |
|
691 { |
|
692 sockaddr_in ss; |
|
693 unsigned int len; |
|
694 int ret = KErrNone; |
|
695 int err; |
|
696 len = sizeof(ss); |
|
697 int sock_fd; |
|
698 |
|
699 sock_fd=socket(AF_INET,SOCK_STREAM,IPPROTO_TCP); |
|
700 |
|
701 len = 0; |
|
702 if (getpeername(sock_fd, (sockaddr*)&ss, &len) < 0) |
|
703 { |
|
704 err=errno; |
|
705 if(err!= ENOTCONN) |
|
706 { |
|
707 ret=KErrGetPeerName; |
|
708 goto close; |
|
709 } |
|
710 else |
|
711 { |
|
712 ret = KErrNone; |
|
713 } |
|
714 } |
|
715 // Invalid sockaddr, EFAULT is expected in errno |
|
716 len = sizeof(ss); |
|
717 if (getpeername(sock_fd, (sockaddr*)0, &len) < 0) |
|
718 { |
|
719 err=errno; |
|
720 if(err!=EFAULT) |
|
721 { |
|
722 ret=KErrGetPeerName; |
|
723 goto close; |
|
724 } |
|
725 else |
|
726 { |
|
727 ret = KErrNone; |
|
728 } |
|
729 } |
|
730 |
|
731 close: |
|
732 return ret; |
|
733 } |
|
734 |
|
735 TInt CTestSocket::SocketTest( ) |
|
736 { |
|
737 int sock_fd; |
|
738 char paramets[10][256]; |
|
739 int ret = KErrNone; |
|
740 int error; |
|
741 int errnoExpected = 0; |
|
742 |
|
743 /** |
|
744 * paramets[0]=socket family; |
|
745 * paramets[1]=sockettype |
|
746 * paramets[2]=protocol |
|
747 * paramets[3]=expected errno |
|
748 */ |
|
749 GetParameters(paramets); |
|
750 errnoExpected = atoi(paramets[3]); |
|
751 sock_fd = socket(atoi(paramets[0]), atoi(paramets[1]), atoi(paramets[2]) ); |
|
752 error = errno; |
|
753 if (errnoExpected == 0) |
|
754 { |
|
755 if (sock_fd < 0) |
|
756 { |
|
757 ret = KErrSocket; |
|
758 goto close; |
|
759 } |
|
760 } |
|
761 else // Error expected |
|
762 { |
|
763 if (sock_fd != -1) |
|
764 { |
|
765 ret = KErrSocket; |
|
766 goto close; |
|
767 } |
|
768 if (error != errnoExpected) |
|
769 { |
|
770 ret = KErrSocket; |
|
771 goto close; |
|
772 } |
|
773 } |
|
774 ret = KErrNone; |
|
775 close: |
|
776 close(sock_fd); |
|
777 return ret; |
|
778 } |
|
779 |
|
780 TInt CTestSocket::BindTest( ) |
|
781 { |
|
782 int sock_fd; |
|
783 int ret = KErrNone; |
|
784 sockaddr_in addr; |
|
785 |
|
786 char paramets[10][256]; |
|
787 /** |
|
788 * paramets[0]=socket family; |
|
789 * paramets[1]=sockettype |
|
790 * paramets[2]=protocol |
|
791 */ |
|
792 GetParameters(paramets); |
|
793 |
|
794 sock_fd = socket( atoi(paramets[0]), atoi(paramets[1]), atoi(paramets[2]) ); |
|
795 if (sock_fd < 0) |
|
796 { |
|
797 ret = KErrSocket; |
|
798 goto close; |
|
799 } |
|
800 |
|
801 addr.sin_family = atoi(paramets[0]); |
|
802 addr.sin_addr.s_addr = htonl(INADDR_ANY); |
|
803 addr.sin_port = 0; |
|
804 if (bind(sock_fd,(sockaddr*)&addr,sizeof(addr)) < 0) |
|
805 { |
|
806 ret = KErrBind; |
|
807 goto close; |
|
808 } |
|
809 close: |
|
810 close(sock_fd); |
|
811 return ret; |
|
812 } |
|
813 |
|
814 TInt CTestSocket::MultipleBindOnSameSocket( ) |
|
815 { |
|
816 int sock_fd; |
|
817 int ret = KErrNone; |
|
818 sockaddr_in addr; |
|
819 int error; |
|
820 |
|
821 char paramets[10][256]; |
|
822 /** |
|
823 * paramets[0]=socket family; |
|
824 * paramets[1]=sockettype |
|
825 * paramets[2]=protocol |
|
826 */ |
|
827 GetParameters(paramets); |
|
828 |
|
829 sock_fd = socket(atoi(paramets[0]), atoi(paramets[1]), atoi(paramets[2]) ); |
|
830 if (sock_fd < 0) |
|
831 { |
|
832 ret = KErrSocket; |
|
833 goto close; |
|
834 } |
|
835 |
|
836 addr.sin_family = atoi(paramets[0]); |
|
837 addr.sin_addr.s_addr = htonl(INADDR_ANY); |
|
838 addr.sin_port = 0; |
|
839 if (bind(sock_fd,(sockaddr*)&addr,sizeof(addr)) < 0) |
|
840 { |
|
841 ret = KErrBind; |
|
842 goto close; |
|
843 } |
|
844 if (bind(sock_fd,(sockaddr*)&addr,sizeof(addr)) < 0) |
|
845 { |
|
846 error = errno; |
|
847 if (error != EADDRINUSE) |
|
848 { |
|
849 ret = KErrBind; |
|
850 goto close; |
|
851 } |
|
852 ret = KErrNone; |
|
853 goto close; |
|
854 } |
|
855 close: |
|
856 close(sock_fd); |
|
857 return ret; |
|
858 } |
|
859 |
|
860 TInt CTestSocket::BindInvalidAddress( ) |
|
861 { |
|
862 int sock_fd; |
|
863 int ret = KErrNone; |
|
864 sockaddr_in addr; |
|
865 int error; |
|
866 |
|
867 char paramets[10][256]; |
|
868 /** |
|
869 * paramets[0]=socket family; |
|
870 * paramets[1]=sockettype |
|
871 * paramets[2]=protocol |
|
872 * paramets[3]=Address |
|
873 */ |
|
874 GetParameters(paramets); |
|
875 sock_fd = socket(atoi(paramets[0]), atoi(paramets[1]), atoi(paramets[2]) ); |
|
876 if (sock_fd < 0) |
|
877 { |
|
878 ret = KErrSocket; |
|
879 goto close; |
|
880 } |
|
881 |
|
882 addr.sin_family = atoi(paramets[0]); |
|
883 addr.sin_addr.s_addr = htonl(atoi(paramets[3])); |
|
884 addr.sin_port = 0; |
|
885 if (bind(sock_fd,(sockaddr*)&addr,sizeof(addr)) < 0) |
|
886 { |
|
887 error = errno; |
|
888 if (error != EADDRNOTAVAIL) |
|
889 { |
|
890 ret = KErrBind; |
|
891 goto close; |
|
892 } |
|
893 ret = KErrNone; |
|
894 goto close; |
|
895 } |
|
896 close: |
|
897 close(sock_fd); |
|
898 return ret; |
|
899 } |
|
900 |
|
901 TInt CTestSocket::BindUsingFileDescriptor( ) |
|
902 { |
|
903 int ret = KErrNone; |
|
904 sockaddr_in addr; |
|
905 |
|
906 char paramets[10][256]; |
|
907 /** |
|
908 * paramets[0]=socket family; |
|
909 */ |
|
910 GetParameters(paramets); |
|
911 addr.sin_family = atoi(paramets[0]); |
|
912 addr.sin_addr.s_addr = htonl(INADDR_ANY); |
|
913 addr.sin_port = 0; |
|
914 if (bind(0,(sockaddr*)&addr,sizeof(addr)) < 0) |
|
915 { |
|
916 ret = KErrNone; |
|
917 goto close; |
|
918 } |
|
919 close: |
|
920 return ret; |
|
921 } |
|
922 |
|
923 TInt CTestSocket::BindUsingInvalidSocketDescriptor( ) |
|
924 { |
|
925 int ret = KErrNone; |
|
926 sockaddr_in addr; |
|
927 |
|
928 char paramets[10][256]; |
|
929 /** |
|
930 * paramets[0]=socket family; |
|
931 */ |
|
932 GetParameters(paramets); |
|
933 |
|
934 addr.sin_family = atoi(paramets[0]); |
|
935 addr.sin_addr.s_addr = htonl(INADDR_ANY); |
|
936 addr.sin_port = 0; |
|
937 if (bind(-1,(sockaddr*)&addr,sizeof(addr)) < 0) |
|
938 { |
|
939 ret = KErrNone; |
|
940 goto close; |
|
941 } |
|
942 close: |
|
943 return ret; |
|
944 } |
|
945 |
|
946 |
|
947 |
|
948 TInt CTestSocket::BindFailCases() |
|
949 { |
|
950 int sock_fd; |
|
951 int ret = KErrNone; |
|
952 struct sockaddr_in socketInfo; |
|
953 |
|
954 /* setup the sock_addr data structure */ |
|
955 socketInfo.sin_family = AF_INET; |
|
956 socketInfo.sin_port = 0; |
|
957 socketInfo.sin_addr.s_addr = htonl( INADDR_ANY ); |
|
958 |
|
959 /* create the new socket */ |
|
960 sock_fd = socket( AF_INET, SOCK_STREAM, 0 ); |
|
961 if( sock_fd == -1 ) |
|
962 { |
|
963 ret = KErrSocket; |
|
964 goto close; |
|
965 } |
|
966 |
|
967 /* bind the socket */ |
|
968 // Wrong socklen, errno shoud be EINVAL |
|
969 ret = bind(sock_fd, (struct sockaddr *)&socketInfo, 1); |
|
970 if (ret == KErrNone) |
|
971 { |
|
972 ret = KErrBind; |
|
973 goto close; |
|
974 } |
|
975 if (errno != EINVAL) |
|
976 { |
|
977 ret = KErrBind; |
|
978 goto close; |
|
979 } |
|
980 |
|
981 // Wrong socklen, errno shoud be EFAULT |
|
982 ret = bind(sock_fd, (struct sockaddr *)0, sizeof(socketInfo)); |
|
983 if (ret == KErrNone) |
|
984 { |
|
985 ret = KErrBind; |
|
986 goto close; |
|
987 } |
|
988 if (errno != EFAULT) |
|
989 { |
|
990 ret = KErrBind; |
|
991 goto close; |
|
992 } |
|
993 |
|
994 // Wrong sockfd, errno shoud be ENOTSOCK |
|
995 ret = bind(1, (struct sockaddr *)&socketInfo, sizeof(socketInfo)); |
|
996 if (errno != ENOTSOCK) |
|
997 { |
|
998 ret = KErrBind; |
|
999 goto close; |
|
1000 } |
|
1001 if (ret == KErrNone) |
|
1002 { |
|
1003 ret = KErrBind; |
|
1004 goto close; |
|
1005 } |
|
1006 |
|
1007 // Wrong sock_fd, errno shoud be EBADF |
|
1008 ret = bind(sock_fd + 100, (struct sockaddr *)&socketInfo, sizeof(socketInfo)); |
|
1009 if (errno != EBADF ) |
|
1010 { |
|
1011 ret = KErrBind; |
|
1012 goto close; |
|
1013 } |
|
1014 if (ret == KErrNone) |
|
1015 { |
|
1016 ret = KErrBind; |
|
1017 goto close; |
|
1018 } |
|
1019 ret = KErrNone; |
|
1020 close: |
|
1021 close(sock_fd); |
|
1022 return ret; |
|
1023 } |
|
1024 |
|
1025 TInt CTestSocket::ListenTest() |
|
1026 { |
|
1027 int sock_fd; |
|
1028 int ret = KErrNone; |
|
1029 sockaddr_in addr; |
|
1030 |
|
1031 /** |
|
1032 * paramets[0]=socket family; |
|
1033 * paramets[1]=sockettype |
|
1034 * paramets[2]=protocol |
|
1035 */ |
|
1036 char paramets[10][256]; |
|
1037 GetParameters(paramets); |
|
1038 |
|
1039 sock_fd = socket( atoi(paramets[0]), atoi(paramets[1]), atoi(paramets[2]) ); |
|
1040 if (sock_fd < 0) |
|
1041 { |
|
1042 ret = KErrSocket; |
|
1043 goto close; |
|
1044 } |
|
1045 addr.sin_family = AF_INET; |
|
1046 addr.sin_addr.s_addr = htonl(INADDR_ANY); |
|
1047 addr.sin_port = 0; |
|
1048 |
|
1049 if ( bind(sock_fd,(sockaddr*)&addr,sizeof(addr)) < 0 ) |
|
1050 { |
|
1051 ret = KErrBind; |
|
1052 goto close; |
|
1053 } |
|
1054 |
|
1055 if ( listen(sock_fd, 5) < 0 ) |
|
1056 { |
|
1057 ret = KErrBind; |
|
1058 goto close; |
|
1059 } |
|
1060 |
|
1061 close: |
|
1062 close(sock_fd ); |
|
1063 return ret; |
|
1064 } |
|
1065 |
|
1066 TInt CTestSocket::ListenUsingFileDescriptor( ) |
|
1067 { |
|
1068 int ret = KErrNone; |
|
1069 |
|
1070 if (listen(0, 5) < 0) |
|
1071 { |
|
1072 // Expected errno is ENOTSOCK |
|
1073 if (errno != ENOTSOCK) |
|
1074 { |
|
1075 ret = KErrListen; |
|
1076 goto close; |
|
1077 } |
|
1078 ret = KErrNone; |
|
1079 goto close; |
|
1080 } |
|
1081 close: |
|
1082 return ret; |
|
1083 } |
|
1084 |
|
1085 TInt CTestSocket::ListenUsingInvalidSocketDescriptor( ) |
|
1086 { |
|
1087 int ret = KErrNone; |
|
1088 |
|
1089 if (listen(-1, 5) < 0) |
|
1090 { |
|
1091 // Expected errno is EBADF |
|
1092 if (errno != EBADF) |
|
1093 { |
|
1094 ret = KErrListen; |
|
1095 goto close; |
|
1096 } |
|
1097 ret = KErrNone; |
|
1098 goto close; |
|
1099 } |
|
1100 close: |
|
1101 return ret; |
|
1102 } |
|
1103 |
|
1104 |
|
1105 TInt CTestSocket::ListenUdp() |
|
1106 { |
|
1107 int sock_fd; |
|
1108 sockaddr_in receiver_addr; |
|
1109 TInt ret = KErrNone; |
|
1110 |
|
1111 sock_fd = socket(AF_INET,SOCK_DGRAM,IPPROTO_UDP); |
|
1112 if (sock_fd < 0) |
|
1113 { |
|
1114 ret = KErrSocket; |
|
1115 goto close; |
|
1116 } |
|
1117 receiver_addr.sin_family = AF_INET; |
|
1118 receiver_addr.sin_addr.s_addr = htonl(INADDR_ANY); |
|
1119 receiver_addr.sin_port = 0; |
|
1120 if (bind(sock_fd,(sockaddr*)&receiver_addr,sizeof(receiver_addr)) < 0) |
|
1121 { |
|
1122 ret = KErrBind; |
|
1123 goto close; |
|
1124 } |
|
1125 if (listen(sock_fd,1) < 0) |
|
1126 { |
|
1127 if (errno != EOPNOTSUPP) |
|
1128 { |
|
1129 ret = KErrListen; |
|
1130 goto close; |
|
1131 } |
|
1132 } |
|
1133 else |
|
1134 { |
|
1135 ret = KErrListen; |
|
1136 goto close; |
|
1137 } |
|
1138 |
|
1139 ret = KErrNone; |
|
1140 |
|
1141 close: |
|
1142 shutdown(sock_fd,SHUT_RDWR); |
|
1143 close(sock_fd); |
|
1144 return ret; |
|
1145 } |
|
1146 |
|
1147 TInt CTestSocket::ShutdownTest( ) |
|
1148 { |
|
1149 int sock_fd; |
|
1150 sockaddr_in addr; |
|
1151 int ret = KErrNone; |
|
1152 |
|
1153 /** |
|
1154 * parameter[0]=howto shutdown |
|
1155 */ |
|
1156 char paramets[10][256]; |
|
1157 GetParameters(paramets); |
|
1158 |
|
1159 sock_fd = socket(AF_INET, SOCK_STREAM, 0); |
|
1160 if (sock_fd < 0) |
|
1161 { |
|
1162 ret = KErrSocket; |
|
1163 goto close; |
|
1164 } |
|
1165 |
|
1166 addr.sin_family = AF_INET; |
|
1167 addr.sin_addr.s_addr = htonl(INADDR_ANY); |
|
1168 addr.sin_port = 0; |
|
1169 if (bind(sock_fd,(sockaddr*)&addr,sizeof(addr)) < 0) |
|
1170 { |
|
1171 ret = KErrBind; |
|
1172 goto close; |
|
1173 } |
|
1174 if ( shutdown(sock_fd,atoi(paramets[0])) < 0 ) |
|
1175 { |
|
1176 ret = KErrShutdown; |
|
1177 goto close; |
|
1178 } |
|
1179 close: |
|
1180 close(sock_fd); |
|
1181 return ret; |
|
1182 } |
|
1183 |
|
1184 TInt CTestSocket::ShutDownTestWithInvalidShutdownOption( ) |
|
1185 { |
|
1186 int sock_fd; |
|
1187 sockaddr_in addr; |
|
1188 int ret = KErrNone; |
|
1189 |
|
1190 /** |
|
1191 * parameter[0]=howto shutdown |
|
1192 */ |
|
1193 char paramets[10][256]; |
|
1194 GetParameters(paramets); |
|
1195 |
|
1196 sock_fd = socket(AF_INET, SOCK_STREAM, 0); |
|
1197 if (sock_fd < 0) |
|
1198 { |
|
1199 ret = KErrSocket; |
|
1200 goto close; |
|
1201 } |
|
1202 |
|
1203 addr.sin_family = AF_INET; |
|
1204 addr.sin_addr.s_addr = htonl(INADDR_ANY); |
|
1205 addr.sin_port = 0; |
|
1206 if (bind(sock_fd,(sockaddr*)&addr,sizeof(addr)) < 0) |
|
1207 { |
|
1208 ret = KErrBind; |
|
1209 goto close; |
|
1210 } |
|
1211 |
|
1212 if ( shutdown(sock_fd,-1) < 0 ) |
|
1213 { |
|
1214 ret = KErrNone; |
|
1215 goto close; |
|
1216 } |
|
1217 close: |
|
1218 close(sock_fd); |
|
1219 return ret; |
|
1220 } |
|
1221 |
|
1222 |
|
1223 TInt CTestSocket::ShutdownDisconnectedSocket( ) |
|
1224 { |
|
1225 int sock_fd; |
|
1226 int newsock_fd=0; |
|
1227 sockaddr_in addr, new_addr; |
|
1228 unsigned int addr_len; |
|
1229 int ret = KErrNone; |
|
1230 |
|
1231 char paramets[10][256]; |
|
1232 GetParameters(paramets); |
|
1233 sock_fd = socket(AF_INET, SOCK_STREAM, 0); |
|
1234 addr.sin_family = AF_INET; |
|
1235 addr.sin_addr.s_addr = htonl(INADDR_ANY); |
|
1236 addr.sin_port = 0; |
|
1237 |
|
1238 pthread_t testThread; |
|
1239 int threadRetVal; |
|
1240 void *threadRetValPtr = (void*)&threadRetVal; |
|
1241 |
|
1242 |
|
1243 if (sock_fd < 0) |
|
1244 { |
|
1245 ret = KErrSocket; |
|
1246 goto close; |
|
1247 } |
|
1248 |
|
1249 if (bind(sock_fd,(sockaddr*)&addr,sizeof(addr)) < 0) |
|
1250 { |
|
1251 ret = KErrBind; |
|
1252 goto close; |
|
1253 } |
|
1254 addr_len = sizeof(addr); |
|
1255 if (getsockname(sock_fd, (sockaddr*)&addr, &addr_len) < 0) |
|
1256 { |
|
1257 ret = KErrGetSockName; |
|
1258 goto close; |
|
1259 } |
|
1260 if (listen(sock_fd,1) < 0) |
|
1261 { |
|
1262 ret = KErrListen; |
|
1263 goto close; |
|
1264 } |
|
1265 |
|
1266 pthread_create(&testThread, NULL, &ShutDownThread, (void*)(addr.sin_port)); |
|
1267 addr_len = sizeof(new_addr); |
|
1268 newsock_fd = accept(sock_fd,(sockaddr*)&new_addr,&addr_len); // Code blocks here |
|
1269 send(newsock_fd, (void*)"a", 1, 0); |
|
1270 pthread_join(testThread, &threadRetValPtr); |
|
1271 if (shutdown(newsock_fd,atoi(paramets[0])) < 0) |
|
1272 { |
|
1273 ret = KErrNone; |
|
1274 goto close; |
|
1275 } |
|
1276 close: |
|
1277 close(sock_fd); |
|
1278 close(newsock_fd); |
|
1279 return ret; |
|
1280 } |
|
1281 |
|
1282 TInt CTestSocket::ShutdownUsingFileDescriptor( ) |
|
1283 { |
|
1284 int ret = KErrNone; |
|
1285 |
|
1286 if (shutdown(0,SHUT_RDWR) < 0) |
|
1287 { |
|
1288 ret = KErrNone; |
|
1289 goto close; |
|
1290 } |
|
1291 close: |
|
1292 return ret; |
|
1293 } |
|
1294 |
|
1295 TInt CTestSocket::ShutdownUsingInvalidSocketDescriptor( ) |
|
1296 { |
|
1297 int ret = KErrNone; |
|
1298 |
|
1299 if (shutdown(-1,SHUT_RDWR) < 0) |
|
1300 { |
|
1301 ret = KErrNone; |
|
1302 goto close; |
|
1303 } |
|
1304 close: |
|
1305 return ret; |
|
1306 |
|
1307 } |
|
1308 |
|
1309 void* ShutDownThread(TAny* aParam) |
|
1310 { |
|
1311 sockaddr_in serv_addr; |
|
1312 int sock_fd; |
|
1313 char line[1]; |
|
1314 int size = 1; |
|
1315 |
|
1316 serv_addr.sin_family = AF_INET; |
|
1317 serv_addr.sin_addr.s_addr = htonl(INADDR_LOOPBACK); |
|
1318 serv_addr.sin_port = (int)aParam; |
|
1319 TInt ret = KErrNone; |
|
1320 |
|
1321 sock_fd = socket(AF_INET,SOCK_STREAM,0); |
|
1322 if (sock_fd < 0) |
|
1323 { |
|
1324 ret = KErrSocket; |
|
1325 goto close; |
|
1326 } |
|
1327 |
|
1328 ret = connect(sock_fd,(sockaddr*)&serv_addr,sizeof(serv_addr)); |
|
1329 if (ret < 0) |
|
1330 { |
|
1331 ret = KErrConnect; |
|
1332 goto close; |
|
1333 } |
|
1334 recv(sock_fd, line, size, 0); |
|
1335 close: |
|
1336 shutdown(sock_fd,SHUT_RDWR); // 2 -> SHUT_RDWT |
|
1337 close(sock_fd); |
|
1338 return (void*)NULL; |
|
1339 } |
|
1340 |
|
1341 void* ClientThread(TAny* aParam) |
|
1342 { |
|
1343 sockaddr_in serv_addr; |
|
1344 int sock_fd; |
|
1345 char line[KMaxLine]; |
|
1346 TInt ret = KErrNone; |
|
1347 int error = -1; |
|
1348 serv_addr.sin_family = AF_INET; |
|
1349 serv_addr.sin_addr.s_addr = htonl(INADDR_LOOPBACK); |
|
1350 serv_addr.sin_port = (int)aParam; |
|
1351 sock_fd = socket(AF_INET,SOCK_STREAM,0); |
|
1352 if (sock_fd < 0) |
|
1353 { |
|
1354 ret = KErrSocket; |
|
1355 goto close; |
|
1356 } |
|
1357 ret = connect(sock_fd,(sockaddr*)&serv_addr,sizeof(serv_addr)); |
|
1358 if (ret < 0) |
|
1359 { |
|
1360 ret = KErrConnect; |
|
1361 goto close; |
|
1362 } |
|
1363 error = read(sock_fd,line); |
|
1364 if (error < 0) |
|
1365 { |
|
1366 ret = KErrRead; |
|
1367 goto close; |
|
1368 } |
|
1369 close: |
|
1370 shutdown(sock_fd,SHUT_RDWR); // 2 -> SHUT_RDWT |
|
1371 close(sock_fd); |
|
1372 return (void*)NULL; |
|
1373 } |
|
1374 |
|
1375 TInt CTestSocket::AcceptTest() |
|
1376 { |
|
1377 int sock_fd,newsock_fd; |
|
1378 int error; |
|
1379 unsigned int addr_len, serv_len; |
|
1380 sockaddr_in serv_addr,new_socket; |
|
1381 TInt ret = KErrNone; |
|
1382 int expectedErrno; |
|
1383 char paramets[10][256]; |
|
1384 |
|
1385 /** |
|
1386 * paramets[0]=socket family; |
|
1387 * paramets[1]=sockettype |
|
1388 * paramets[2]=protocol |
|
1389 * paramets[3]=Expected errno |
|
1390 */ |
|
1391 GetParameters(paramets); |
|
1392 |
|
1393 sock_fd = socket ( atoi(paramets[0]), atoi(paramets[1]), atoi(paramets[2]) ); |
|
1394 serv_addr.sin_family = AF_INET; |
|
1395 serv_addr.sin_addr.s_addr = htonl(INADDR_ANY); |
|
1396 serv_addr.sin_port = 0; |
|
1397 // Create the thread and thread is client code |
|
1398 pthread_t testThread; |
|
1399 int threadRetVal; |
|
1400 void *threadRetValPtr = (void*)&threadRetVal; |
|
1401 if (sock_fd < 0) |
|
1402 { |
|
1403 ret = KErrGeneral; |
|
1404 goto close; |
|
1405 } |
|
1406 if (bind(sock_fd,(sockaddr*)&serv_addr,sizeof(serv_addr)) < 0) |
|
1407 { |
|
1408 ret = KErrBind; |
|
1409 goto close; |
|
1410 } |
|
1411 serv_len = sizeof(serv_addr); |
|
1412 if (getsockname(sock_fd, (sockaddr*)&serv_addr, &serv_len) < 0) |
|
1413 { |
|
1414 ret = KErrGetSockName; |
|
1415 goto close; |
|
1416 } |
|
1417 if (listen(sock_fd,1) < 0) |
|
1418 { |
|
1419 ret = KErrListen; |
|
1420 goto close; |
|
1421 } |
|
1422 addr_len = sizeof(new_socket); |
|
1423 pthread_create(&testThread, NULL, &ClientThread, (void*)(serv_addr.sin_port)); |
|
1424 expectedErrno = atoi(paramets[3]); |
|
1425 newsock_fd = accept(sock_fd,(sockaddr*)&new_socket,&addr_len); // Code blocks here |
|
1426 if (expectedErrno != 0) |
|
1427 { |
|
1428 if (errno != expectedErrno) |
|
1429 { |
|
1430 ret = KErrAccept; |
|
1431 goto close; |
|
1432 } |
|
1433 } |
|
1434 error = write(newsock_fd); |
|
1435 if (error < 0) |
|
1436 { |
|
1437 ret = KErrWrite; |
|
1438 goto close; |
|
1439 } |
|
1440 |
|
1441 pthread_join(testThread, &threadRetValPtr); |
|
1442 |
|
1443 close: |
|
1444 shutdown(sock_fd,SHUT_RDWR); // 2 -> SHUT_RDWT |
|
1445 close(sock_fd); |
|
1446 return ret; |
|
1447 } |
|
1448 |
|
1449 TInt CTestSocket::UDPAccept() |
|
1450 { |
|
1451 int sock_fd,newsock_fd; |
|
1452 unsigned int addr_len; |
|
1453 sockaddr_in serv_addr,new_socket; |
|
1454 TInt ret = KErrNone; |
|
1455 |
|
1456 sock_fd = socket (AF_INET, SOCK_DGRAM, IPPROTO_UDP); |
|
1457 serv_addr.sin_family = AF_INET; |
|
1458 serv_addr.sin_addr.s_addr = htonl(INADDR_ANY); |
|
1459 serv_addr.sin_port = 0; |
|
1460 if (sock_fd < 0) |
|
1461 { |
|
1462 ret = KErrGeneral; |
|
1463 goto close; |
|
1464 } |
|
1465 if (bind(sock_fd,(sockaddr*)&serv_addr,sizeof(serv_addr)) < 0) |
|
1466 { |
|
1467 ret = KErrBind; |
|
1468 goto close; |
|
1469 } |
|
1470 newsock_fd = accept(sock_fd,(sockaddr*)&new_socket,&addr_len); // Code blocks here |
|
1471 if (newsock_fd > 0) |
|
1472 { |
|
1473 ret = KErrAccept; |
|
1474 goto close; |
|
1475 } |
|
1476 |
|
1477 close: |
|
1478 shutdown(sock_fd,SHUT_RDWR); // 2 -> SHUT_RDWT |
|
1479 close(sock_fd); |
|
1480 return ret; |
|
1481 } |
|
1482 |
|
1483 TInt CTestSocket::AcceptUsingFileDescriptor( ) |
|
1484 { |
|
1485 int ret = KErrNone; |
|
1486 sockaddr_in addr; |
|
1487 unsigned int addr_len; |
|
1488 addr_len = sizeof(addr); |
|
1489 if ( accept(0,(sockaddr*)&addr,&addr_len) < 0 ) |
|
1490 { |
|
1491 ret = KErrNone; |
|
1492 goto close; |
|
1493 } |
|
1494 close: |
|
1495 return ret; |
|
1496 } |
|
1497 |
|
1498 TInt CTestSocket::AcceptUsingInvalidSocketDescriptor( ) |
|
1499 { |
|
1500 int ret = KErrNone; |
|
1501 sockaddr_in addr; |
|
1502 unsigned int addr_len; |
|
1503 |
|
1504 addr_len = sizeof(addr); |
|
1505 if ( accept (-1,(sockaddr*)&addr,&addr_len) < 0 ) |
|
1506 { |
|
1507 ret = KErrNone; |
|
1508 goto close; |
|
1509 } |
|
1510 close: |
|
1511 return ret; |
|
1512 } |
|
1513 |
|
1514 TInt CTestSocket::AcceptFailCases() |
|
1515 { |
|
1516 int sock_fd,newsock_fd; |
|
1517 unsigned int addr_len; |
|
1518 sockaddr_in serv_addr,new_socket; |
|
1519 TInt ret = KErrNone; |
|
1520 |
|
1521 sock_fd = socket(AF_INET,SOCK_STREAM,0); |
|
1522 if (sock_fd < 0) |
|
1523 { |
|
1524 return KErrSocket; |
|
1525 } |
|
1526 serv_addr.sin_family = AF_INET; |
|
1527 serv_addr.sin_addr.s_addr = htonl(INADDR_ANY); |
|
1528 serv_addr.sin_port = 0; |
|
1529 |
|
1530 if (bind(sock_fd,(sockaddr*)&serv_addr,sizeof(serv_addr)) < 0) |
|
1531 { |
|
1532 ret = KErrBind; |
|
1533 goto close; |
|
1534 } |
|
1535 if (listen(sock_fd,1) < 0) |
|
1536 { |
|
1537 ret = KErrListen; |
|
1538 goto close; |
|
1539 } |
|
1540 |
|
1541 addr_len = sizeof(new_socket); |
|
1542 |
|
1543 // Wrong sock_fd, errno shoud be EBADF |
|
1544 newsock_fd = accept(sock_fd + 100,(sockaddr*)&new_socket,&addr_len); |
|
1545 if (errno != EBADF ) |
|
1546 { |
|
1547 ret = KErrBind; |
|
1548 goto close; |
|
1549 } |
|
1550 if (newsock_fd == KErrNone) |
|
1551 { |
|
1552 ret = KErrBind; |
|
1553 goto close; |
|
1554 } |
|
1555 |
|
1556 // Wrong sockfd, errno shoud be ENOTSOCK |
|
1557 newsock_fd = accept(0,(sockaddr*)&new_socket,&addr_len); |
|
1558 if (errno != ENOTSOCK) |
|
1559 { |
|
1560 ret = KErrBind; |
|
1561 goto close; |
|
1562 } |
|
1563 if (newsock_fd == KErrNone) |
|
1564 { |
|
1565 ret = KErrBind; |
|
1566 goto close; |
|
1567 } |
|
1568 |
|
1569 |
|
1570 ret = KErrNone; |
|
1571 close: |
|
1572 close(sock_fd); |
|
1573 return ret; |
|
1574 } |
|
1575 |
|
1576 static void * SocketClient(void *) |
|
1577 { |
|
1578 sockaddr_in socket_addr; |
|
1579 int socketfd; |
|
1580 socket_addr.sin_family = AF_INET; |
|
1581 socket_addr.sin_addr.s_addr = htonl(INADDR_LOOPBACK); |
|
1582 socket_addr.sin_port = htons(12345); |
|
1583 |
|
1584 if((socketfd = socket(AF_INET, SOCK_STREAM, 0)) < 0) |
|
1585 { |
|
1586 printf("Error creating socket\n"); |
|
1587 return NULL; |
|
1588 } |
|
1589 |
|
1590 sleep(1); |
|
1591 if(connect(socketfd,(sockaddr*)&socket_addr,sizeof(socket_addr)) < 0) |
|
1592 { |
|
1593 printf("Error connecting, errno = %d\n",errno); |
|
1594 return NULL; |
|
1595 } |
|
1596 if(write(socketfd,"testing",strlen("testing")+1) == -1) |
|
1597 { |
|
1598 printf("Error writing to socket, errno = %d\n",errno); |
|
1599 } |
|
1600 close(socketfd); |
|
1601 return NULL; |
|
1602 } |
|
1603 |
|
1604 |
|
1605 /* |
|
1606 * This test case checks if the accept() fails when length passed to it is 0. |
|
1607 * It verifies that the errno returned is EINVAL. |
|
1608 * */ |
|
1609 TInt CTestSocket::AcceptTestZeroAddrLen() |
|
1610 { |
|
1611 int sock_fd,newsock_fd; |
|
1612 sockaddr_in serv_addr,new_socket; |
|
1613 TInt ret = KErrNone; |
|
1614 |
|
1615 sock_fd = socket(AF_INET,SOCK_STREAM,0); |
|
1616 if (sock_fd < 0) |
|
1617 { |
|
1618 INFO_PRINTF2(_L("socket return with errno = %d"), errno); |
|
1619 return KErrSocket; |
|
1620 } |
|
1621 serv_addr.sin_family = AF_INET; |
|
1622 serv_addr.sin_addr.s_addr = htonl(INADDR_ANY); |
|
1623 serv_addr.sin_port = htons(12345); |
|
1624 if (bind(sock_fd,(sockaddr*)&serv_addr,sizeof(serv_addr)) < 0) |
|
1625 { |
|
1626 INFO_PRINTF2(_L("bind return with errno = %d"), errno); |
|
1627 ret = KErrBind; |
|
1628 goto close; |
|
1629 } |
|
1630 if (listen(sock_fd,1) < 0) |
|
1631 { |
|
1632 INFO_PRINTF2(_L("listen return with errno = %d"), errno); |
|
1633 ret = KErrListen; |
|
1634 goto close; |
|
1635 } |
|
1636 |
|
1637 newsock_fd = accept(sock_fd,(sockaddr*)&new_socket,0); |
|
1638 if (newsock_fd > 0) |
|
1639 { |
|
1640 ret = KErrAccept; |
|
1641 goto close; |
|
1642 } |
|
1643 if (errno != EINVAL ) |
|
1644 { |
|
1645 INFO_PRINTF2(_L("Accept return with errno = %d"), errno); |
|
1646 ret = KErrAccept; |
|
1647 goto close; |
|
1648 } |
|
1649 |
|
1650 ret = KErrNone; |
|
1651 close: |
|
1652 |
|
1653 close(sock_fd); |
|
1654 return ret; |
|
1655 |
|
1656 } |
|
1657 |
|
1658 TInt CTestSocket::AcceptTestNullAddr() |
|
1659 { |
|
1660 int sock_fd,newsock_fd; |
|
1661 sockaddr_in serv_addr; |
|
1662 TInt ret = KErrNone; |
|
1663 |
|
1664 sock_fd = socket(AF_INET,SOCK_STREAM,0); |
|
1665 if (sock_fd < 0) |
|
1666 { |
|
1667 INFO_PRINTF2(_L("socket return with errno = %d"), errno); |
|
1668 return KErrSocket; |
|
1669 } |
|
1670 serv_addr.sin_family = AF_INET; |
|
1671 serv_addr.sin_addr.s_addr = htonl(INADDR_ANY); |
|
1672 serv_addr.sin_port = htons(12345); |
|
1673 char buf[20]; |
|
1674 int readLen = 0; |
|
1675 pthread_t threadId; |
|
1676 if (bind(sock_fd,(sockaddr*)&serv_addr,sizeof(serv_addr)) < 0) |
|
1677 { |
|
1678 INFO_PRINTF2(_L("bind return with errno = %d"), errno); |
|
1679 ret = KErrBind; |
|
1680 goto close; |
|
1681 } |
|
1682 if (listen(sock_fd,1) < 0) |
|
1683 { |
|
1684 INFO_PRINTF2(_L("listen return with errno = %d"), errno); |
|
1685 ret = KErrListen; |
|
1686 goto close; |
|
1687 } |
|
1688 |
|
1689 pthread_create(&threadId,NULL,SocketClient,NULL); |
|
1690 newsock_fd = accept(sock_fd,0,0); |
|
1691 if (errno != 0 ) |
|
1692 { |
|
1693 INFO_PRINTF2(_L("Accept return with errno = %d"), errno); |
|
1694 ret = -1; |
|
1695 goto close; |
|
1696 } |
|
1697 |
|
1698 readLen = strlen("testing")+1; |
|
1699 if(read(newsock_fd,buf, readLen) != readLen) |
|
1700 { |
|
1701 INFO_PRINTF2(_L("read return with errno = %d"), errno); |
|
1702 ret = -1; |
|
1703 goto close; |
|
1704 } |
|
1705 close(newsock_fd); |
|
1706 close: |
|
1707 pthread_join(threadId,NULL); |
|
1708 close(sock_fd); |
|
1709 return ret; |
|
1710 |
|
1711 } |
|
1712 |
|
1713 |
|
1714 TInt CTestSocket::ConnectTestFailCases() |
|
1715 { |
|
1716 sockaddr_in serv_addr; |
|
1717 int sock_fd; |
|
1718 int ret = KErrNone; |
|
1719 char paramets[10][256]; |
|
1720 |
|
1721 /** |
|
1722 * paramets[0]=socket family; |
|
1723 * paramets[1]=address |
|
1724 */ |
|
1725 GetParameters(paramets); |
|
1726 serv_addr.sin_family = atoi(paramets[0]); |
|
1727 serv_addr.sin_addr.s_addr = htonl(atoi(paramets[1])); |
|
1728 serv_addr.sin_port = 0; |
|
1729 |
|
1730 sock_fd = socket(AF_INET,SOCK_STREAM,0); |
|
1731 if (sock_fd < 0) |
|
1732 { |
|
1733 ret = KErrSocket; |
|
1734 goto close; |
|
1735 } |
|
1736 // Failure expected |
|
1737 ret = connect(sock_fd,(sockaddr*)&serv_addr,sizeof(serv_addr)); |
|
1738 if (ret == KErrNone) |
|
1739 { |
|
1740 ret = KErrConnect; |
|
1741 goto close; |
|
1742 } |
|
1743 else |
|
1744 { |
|
1745 ret = KErrNone; |
|
1746 } |
|
1747 |
|
1748 ret = connect(sock_fd,(sockaddr*)&serv_addr,0); |
|
1749 if (errno != EINVAL ) |
|
1750 { |
|
1751 ret = KErrConnect; |
|
1752 goto close; |
|
1753 } |
|
1754 if (ret == KErrNone) |
|
1755 { |
|
1756 ret = KErrConnect; |
|
1757 goto close; |
|
1758 } |
|
1759 |
|
1760 ret = connect(sock_fd,(sockaddr*)0,sizeof(serv_addr)); |
|
1761 if (errno != EFAULT ) |
|
1762 { |
|
1763 ret = KErrConnect; |
|
1764 goto close; |
|
1765 } |
|
1766 if (ret == KErrNone) |
|
1767 { |
|
1768 ret = KErrConnect; |
|
1769 goto close; |
|
1770 } |
|
1771 |
|
1772 ret = KErrNone; |
|
1773 close: |
|
1774 shutdown(sock_fd,SHUT_RDWR); |
|
1775 close(sock_fd); |
|
1776 return ret; |
|
1777 } |
|
1778 |
|
1779 TInt CTestSocket::ConnectUsingFileDescriptor( ) |
|
1780 { |
|
1781 int ret = KErrNone; |
|
1782 sockaddr_in addr; |
|
1783 |
|
1784 ret = connect(0,(sockaddr*)&addr,sizeof(addr)); |
|
1785 if (ret < 0) |
|
1786 { |
|
1787 ret = KErrNone; |
|
1788 goto close; |
|
1789 } |
|
1790 close: |
|
1791 return ret; |
|
1792 } |
|
1793 |
|
1794 TInt CTestSocket::ConnectUsingInvalidSocketDescriptor( ) |
|
1795 { |
|
1796 int ret = KErrNone; |
|
1797 sockaddr_in addr; |
|
1798 |
|
1799 ret = connect(-1,(sockaddr*)&addr,sizeof(addr)); |
|
1800 if (ret < 0) |
|
1801 { |
|
1802 ret = KErrNone; |
|
1803 goto close; |
|
1804 } |
|
1805 close: |
|
1806 return ret; |
|
1807 } |
|
1808 |
|
1809 TInt CTestSocket::RecvTestFailCases() |
|
1810 { |
|
1811 int sock_fd; |
|
1812 char buf[5]; |
|
1813 sockaddr_in serv_addr; |
|
1814 char paramets[10][256]; |
|
1815 TInt ret = KErrNone; |
|
1816 |
|
1817 /** |
|
1818 * paramets[0]=socket family; |
|
1819 * paramets[1]=address |
|
1820 * paramets[2]=protocol |
|
1821 */ |
|
1822 GetParameters(paramets); |
|
1823 |
|
1824 sock_fd = socket ( atoi(paramets[0]), atoi(paramets[1]), atoi(paramets[2]) ); |
|
1825 if (sock_fd < 0) |
|
1826 { |
|
1827 ret = KErrSocket; |
|
1828 goto close; |
|
1829 } |
|
1830 |
|
1831 serv_addr.sin_family = AF_INET; |
|
1832 serv_addr.sin_addr.s_addr = htonl(INADDR_ANY); |
|
1833 serv_addr.sin_port = 0; |
|
1834 if ( bind(sock_fd,(sockaddr*)&serv_addr,sizeof(serv_addr)) < 0 ) |
|
1835 { |
|
1836 ret = KErrBind; |
|
1837 goto close; |
|
1838 } |
|
1839 if (recv(sock_fd,buf,5,0) < 0 ) |
|
1840 { |
|
1841 ret = KErrNone; |
|
1842 goto close; |
|
1843 } |
|
1844 |
|
1845 close: |
|
1846 close(sock_fd); |
|
1847 return ret; |
|
1848 } |
|
1849 |
|
1850 TInt CTestSocket::RecvUsingFileDescriptor( ) |
|
1851 { |
|
1852 int ret = KErrNone; |
|
1853 char buf[5]; |
|
1854 |
|
1855 ret = recv(0,buf,5,0); // Code should fail here |
|
1856 if (ret < 0) |
|
1857 { |
|
1858 ret = KErrNone; |
|
1859 goto close; |
|
1860 } |
|
1861 close: |
|
1862 return ret; |
|
1863 } |
|
1864 |
|
1865 TInt CTestSocket::RecvUsingInvalidSocketDescriptor( ) |
|
1866 { |
|
1867 int ret = KErrNone; |
|
1868 char buf[5]; |
|
1869 |
|
1870 ret = recv(-1,buf,5,0); // Code should fail here |
|
1871 if (ret < 0) |
|
1872 { |
|
1873 ret = KErrNone; |
|
1874 goto close; |
|
1875 } |
|
1876 close: |
|
1877 return ret; |
|
1878 } |
|
1879 |
|
1880 TInt CTestSocket::SendTestFailCases() |
|
1881 { |
|
1882 int sock_fd; |
|
1883 char buf[5]; |
|
1884 sockaddr_in serv_addr; |
|
1885 TInt ret = KErrNone; |
|
1886 |
|
1887 char paramets[10][256]; |
|
1888 |
|
1889 /** |
|
1890 * paramets[0]=-1/O_NONBLOCK |
|
1891 */ |
|
1892 GetParameters(paramets); |
|
1893 |
|
1894 serv_addr.sin_family = AF_INET; |
|
1895 serv_addr.sin_addr.s_addr = htonl(INADDR_ANY); |
|
1896 serv_addr.sin_port = 0; |
|
1897 |
|
1898 sock_fd = socket(AF_INET,SOCK_STREAM,IPPROTO_TCP); |
|
1899 if ( sock_fd < 0 ) |
|
1900 { |
|
1901 ret = KErrSocket; |
|
1902 goto close; |
|
1903 } |
|
1904 if ( bind( sock_fd,(sockaddr*)&serv_addr,sizeof(serv_addr) ) < 0 ) |
|
1905 { |
|
1906 ret = KErrBind; |
|
1907 goto close; |
|
1908 } |
|
1909 if ( atoi(paramets[0]) == O_NONBLOCK ) |
|
1910 { |
|
1911 fcntl( sock_fd, F_SETFL, O_NONBLOCK ); |
|
1912 } |
|
1913 if ( send( sock_fd,buf,5,0 ) < 0) |
|
1914 { |
|
1915 if (errno == EPIPE) |
|
1916 { |
|
1917 ret = KErrNone; |
|
1918 } |
|
1919 goto close; |
|
1920 } |
|
1921 close: |
|
1922 close(sock_fd); |
|
1923 return ret; |
|
1924 } |
|
1925 |
|
1926 TInt CTestSocket::SendUsingFileDescriptor( ) |
|
1927 { |
|
1928 int ret = KErrNone; |
|
1929 char buf[5]; |
|
1930 |
|
1931 ret = send(0,buf,5,0); // Code should fail here |
|
1932 if (ret < 0) |
|
1933 { |
|
1934 ret = KErrNone; |
|
1935 goto close; |
|
1936 } |
|
1937 close: |
|
1938 return ret; |
|
1939 } |
|
1940 |
|
1941 TInt CTestSocket::SendUsingInvalidSocketDescriptor( ) |
|
1942 { |
|
1943 int ret = KErrNone; |
|
1944 char buf[5]; |
|
1945 |
|
1946 ret = send(-1,buf,5,0); // Code should fail here |
|
1947 if (ret < 0) |
|
1948 { |
|
1949 ret = KErrNone; |
|
1950 goto close; |
|
1951 } |
|
1952 close: |
|
1953 return ret; |
|
1954 } |
|
1955 |
|
1956 TInt CTestSocket::SendToTestFailCases() |
|
1957 { |
|
1958 int sock_fd; |
|
1959 int ret = KErrNone; |
|
1960 char line[KMaxLine]; |
|
1961 unsigned int receiver_len = 0; |
|
1962 sockaddr_in receiver_addr,dest_addr; |
|
1963 |
|
1964 char paramets[10][256]; |
|
1965 |
|
1966 /** |
|
1967 * paramets[0]=socket family; |
|
1968 * paramets[1]=address |
|
1969 * paramets[2]=protocol |
|
1970 * parameter[3]=Blocking/Nonblocking case |
|
1971 * parameter[4]=Size |
|
1972 * parameter[5]=flags, eg.MSG_OOB |
|
1973 */ |
|
1974 GetParameters(paramets); |
|
1975 |
|
1976 sock_fd = socket( atoi(paramets[0]), atoi(paramets[1]), atoi(paramets[2]) ); |
|
1977 receiver_addr.sin_family = AF_INET; |
|
1978 receiver_addr.sin_addr.s_addr = htonl(INADDR_ANY); |
|
1979 receiver_addr.sin_port = 0; |
|
1980 |
|
1981 dest_addr.sin_family = AF_INET; |
|
1982 dest_addr.sin_addr.s_addr = htonl(INADDR_LOOPBACK); |
|
1983 dest_addr.sin_port = receiver_addr.sin_port; |
|
1984 int error = -1; |
|
1985 if (sock_fd < 0) |
|
1986 { |
|
1987 ret = KErrSocket; |
|
1988 goto close; |
|
1989 } |
|
1990 if ( atoi(paramets[3]) > 0) |
|
1991 { |
|
1992 if ( atoi(paramets[3]) == 1) // Set Non-block mode |
|
1993 { |
|
1994 fcntl(sock_fd,F_SETFL,O_NONBLOCK); |
|
1995 } |
|
1996 } |
|
1997 |
|
1998 if (bind(sock_fd,(sockaddr*)&receiver_addr,sizeof(receiver_addr)) < 0) |
|
1999 { |
|
2000 ret = KErrBind; |
|
2001 goto close; |
|
2002 } |
|
2003 receiver_len = sizeof(receiver_addr); |
|
2004 if (getsockname(sock_fd, (sockaddr*)&receiver_addr, &receiver_len) < 0) |
|
2005 { |
|
2006 ret = KErrGetSockName; |
|
2007 goto close; |
|
2008 } |
|
2009 |
|
2010 if ( atoi(paramets[4]) > 0) // set the send window size |
|
2011 { |
|
2012 int optionValue = KMaxLine - 50; |
|
2013 setsockopt(sock_fd,SOL_SOCKET,SO_SNDBUF,&optionValue,sizeof(optionValue)); |
|
2014 } |
|
2015 |
|
2016 error = sendto(sock_fd, line, KMaxLine, atoi(paramets[5]), (sockaddr*)&dest_addr, sizeof(dest_addr) ); |
|
2017 if (error < 0) |
|
2018 { |
|
2019 ret = KErrNone; |
|
2020 goto close; |
|
2021 } |
|
2022 close: |
|
2023 shutdown(sock_fd,SHUT_RDWR); // 2 -> SHUT_RDWT |
|
2024 close(sock_fd); |
|
2025 return ret; |
|
2026 } |
|
2027 |
|
2028 TInt CTestSocket::SendToUsingFileDescriptor( ) |
|
2029 { |
|
2030 int ret = KErrNone; |
|
2031 char line[KMaxLine]; |
|
2032 int dest_len; |
|
2033 sockaddr_in dest_addr; |
|
2034 |
|
2035 dest_len = sizeof(dest_addr); |
|
2036 dest_addr.sin_family = AF_INET; |
|
2037 dest_addr.sin_addr.s_addr = htonl(INADDR_LOOPBACK); |
|
2038 dest_addr.sin_port = 0; |
|
2039 sendto( 0, line, KMaxLine, 0,(sockaddr*)&dest_addr,dest_len ); |
|
2040 if (ret < 0) |
|
2041 { |
|
2042 ret = KErrNone; |
|
2043 goto close; |
|
2044 } |
|
2045 close: |
|
2046 return ret; |
|
2047 } |
|
2048 |
|
2049 TInt CTestSocket::SendToUsingInvalidSocketDescriptor( ) |
|
2050 { |
|
2051 int ret = KErrNone; |
|
2052 char line[KMaxLine]; |
|
2053 int dest_len; |
|
2054 sockaddr_in dest_addr; |
|
2055 |
|
2056 dest_len = sizeof(dest_addr); |
|
2057 dest_addr.sin_family = AF_INET; |
|
2058 dest_addr.sin_addr.s_addr = htonl(INADDR_LOOPBACK); |
|
2059 dest_addr.sin_port = 0; |
|
2060 sendto( -1, line, KMaxLine, 0,(sockaddr*)&dest_addr,dest_len ); |
|
2061 if (ret < 0) |
|
2062 { |
|
2063 ret = KErrNone; |
|
2064 goto close; |
|
2065 } |
|
2066 close: |
|
2067 return ret; |
|
2068 } |
|
2069 |
|
2070 int client(int port) |
|
2071 { |
|
2072 int flag = 0; |
|
2073 int clientsockid = socket(PF_INET, SOCK_STREAM, IPPROTO_TCP); |
|
2074 if (clientsockid < 0) |
|
2075 { |
|
2076 printf("[Client] Create Tcp socket fail"); |
|
2077 return -1; |
|
2078 } |
|
2079 |
|
2080 int result = -1; |
|
2081 |
|
2082 struct sockaddr_in addr; |
|
2083 addr.sin_family = AF_INET; |
|
2084 addr.sin_port = htons(port); |
|
2085 addr.sin_addr.s_addr = htonl(INADDR_LOOPBACK); |
|
2086 |
|
2087 do |
|
2088 { |
|
2089 int ret = connect(clientsockid, (sockaddr*) &addr, sizeof(addr)); |
|
2090 if (ret < 0) |
|
2091 { |
|
2092 printf("[Client] connect to server fail\n"); |
|
2093 break; |
|
2094 } |
|
2095 |
|
2096 ret = send(clientsockid, tcpdata, strlen(tcpdata), flag); |
|
2097 if(ret!=strlen(tcpdata)) |
|
2098 globalflag++; |
|
2099 if (ret < 0) |
|
2100 { |
|
2101 printf("[Client] send data to server fail\n"); |
|
2102 break; |
|
2103 } |
|
2104 //int bytes = ret; |
|
2105 |
|
2106 printf("[Client] send %d bytes: %s\n",ret,tcpdata); |
|
2107 char buff[50]; |
|
2108 char* p = buff; |
|
2109 |
|
2110 |
|
2111 ret = recv(clientsockid, p, 50, flag); |
|
2112 if (ret < 0) |
|
2113 { |
|
2114 printf("[Client] recv data from server fail\n"); |
|
2115 break; |
|
2116 } |
|
2117 p += ret; |
|
2118 *p = '\0'; |
|
2119 printf("[Client] recv %d bytes: %s\n", p-buff, buff); |
|
2120 result = 0; |
|
2121 } |
|
2122 while (0); |
|
2123 close(clientsockid); |
|
2124 return result; |
|
2125 } |
|
2126 |
|
2127 void* myclie(void* pv) |
|
2128 { |
|
2129 client( (int)pv); |
|
2130 return 0; |
|
2131 } |
|
2132 |
|
2133 TInt CTestSocket::TestSendReturnValue( ) |
|
2134 { |
|
2135 // int ret1=0; |
|
2136 pthread_t t; |
|
2137 int flag = 0; |
|
2138 _LIT(KWelcome,"Hello Open C and OPENENV!\n"); |
|
2139 INFO_PRINTF1(KWelcome) ; |
|
2140 int servsockid = socket(PF_INET, SOCK_STREAM, IPPROTO_TCP); |
|
2141 if (servsockid < 0) |
|
2142 { |
|
2143 printf("[Server] Create Tcp socket fail\n"); |
|
2144 return -1; |
|
2145 } |
|
2146 // reuseaddr |
|
2147 int set = 1; |
|
2148 setsockopt(servsockid, SOL_SOCKET, SO_REUSEADDR, &set, sizeof(set)); |
|
2149 |
|
2150 // int result = -1; |
|
2151 struct sockaddr_in addr; |
|
2152 addr.sin_family = AF_INET; |
|
2153 addr.sin_port = htons(5000); |
|
2154 addr.sin_addr.s_addr = htonl(INADDR_ANY); |
|
2155 |
|
2156 do |
|
2157 { |
|
2158 int ret = bind(servsockid, (sockaddr*) &addr, sizeof(addr)); |
|
2159 if (ret < 0) |
|
2160 { |
|
2161 printf("[Server] server bind fail\n"); |
|
2162 break; |
|
2163 } |
|
2164 |
|
2165 ret = listen(servsockid, 2); |
|
2166 if (ret < 0) |
|
2167 { |
|
2168 printf("[Server] listen fail\n"); |
|
2169 break; |
|
2170 } |
|
2171 |
|
2172 |
|
2173 ret = pthread_create(&t, 0 , myclie, (void*) 5000 ); |
|
2174 |
|
2175 |
|
2176 socklen_t len = sizeof(addr); |
|
2177 int clientid = accept(servsockid, (sockaddr*) &addr, &len); |
|
2178 if (clientid < 0) |
|
2179 { |
|
2180 printf("[Server] accept fail\n"); |
|
2181 break; |
|
2182 } |
|
2183 |
|
2184 char buff[50]; |
|
2185 ret = recv(clientid, buff, 50, flag); |
|
2186 if (ret < 0) |
|
2187 { |
|
2188 printf("[Server] recv data from client fail\n"); |
|
2189 close(clientid); |
|
2190 break; |
|
2191 } |
|
2192 else |
|
2193 { |
|
2194 buff[ret] = '\0'; |
|
2195 printf("[Server] recv data from client %d bytes: %s\n", ret, buff); |
|
2196 } |
|
2197 |
|
2198 ret = send(clientid, buff, ret, flag); |
|
2199 if (ret < 0) |
|
2200 { |
|
2201 printf("[Server] send data to client fail\n"); |
|
2202 close(clientid); |
|
2203 break; |
|
2204 } |
|
2205 else |
|
2206 { |
|
2207 printf("[Server] send data to client %d bytes: %s\n", ret, buff); |
|
2208 } |
|
2209 close(clientid); |
|
2210 // result = 0; |
|
2211 } |
|
2212 while (0); |
|
2213 close(servsockid); |
|
2214 |
|
2215 _LIT(KWait,"wait...\n"); |
|
2216 INFO_PRINTF1(KWait) ; |
|
2217 pthread_join(t, 0); |
|
2218 if(globalflag!=0) |
|
2219 { |
|
2220 _LIT(Kerr , "Send() API Failed to send the actual number of bytes sent") ; |
|
2221 INFO_PRINTF1(Kerr) ; |
|
2222 return KErrGeneral ; |
|
2223 } |
|
2224 |
|
2225 return 0; |
|
2226 } |
|
2227 |
|
2228 TInt CTestSocket::RecvFromTestFailCases() |
|
2229 { |
|
2230 int ret = KErrNone; |
|
2231 int sock_fd; |
|
2232 char line[KMaxLine]; |
|
2233 |
|
2234 char paramets[10][256]; |
|
2235 /** |
|
2236 * parameter[0] = Blocking/Nonblocking case |
|
2237 */ |
|
2238 GetParameters(paramets); |
|
2239 |
|
2240 sock_fd = socket(AF_INET,SOCK_DGRAM,IPPROTO_UDP); |
|
2241 if (sock_fd < 0) |
|
2242 { |
|
2243 ret = KErrSocket; |
|
2244 goto close; |
|
2245 } |
|
2246 if ( atoi(paramets[0]) == 1 ) // Set Non-block mode |
|
2247 { |
|
2248 fcntl(sock_fd,F_SETFL,O_NONBLOCK); |
|
2249 } |
|
2250 if (recvfrom(sock_fd,line,KMaxLine,0,(sockaddr*)NULL,0) < 0) |
|
2251 { |
|
2252 ret = KErrNone; |
|
2253 goto close; |
|
2254 } |
|
2255 close: |
|
2256 close(sock_fd); |
|
2257 return ret; |
|
2258 } |
|
2259 |
|
2260 TInt CTestSocket::SocketOptions() |
|
2261 { |
|
2262 int sock_fd; |
|
2263 long int parameter[10]; |
|
2264 int ret = KErrNone; |
|
2265 int paramLength; |
|
2266 |
|
2267 unsigned int optionLen=0; |
|
2268 TPtrC String1,String2, String3, String4, String5, String6, String7; |
|
2269 TBuf8<256> stringBuffer; |
|
2270 stringBuffer.Copy(String1); |
|
2271 _LIT( KString1, "Parameter1" ); |
|
2272 TBool res = GetStringFromConfig(ConfigSection(), KString1, String1); |
|
2273 if(!res) |
|
2274 { |
|
2275 _LIT(Kerr , "Failed to read parameter 1") ; |
|
2276 INFO_PRINTF1(Kerr) ; |
|
2277 return KErrGeneral ; |
|
2278 } |
|
2279 stringBuffer.Copy(String1); |
|
2280 paramLength = String1.Length(); |
|
2281 char* text=(char *)(stringBuffer.Ptr()); |
|
2282 *(text + paramLength) ='\0'; |
|
2283 parameter[0] = atol(text); |
|
2284 |
|
2285 _LIT( KString2, "Parameter2" ); |
|
2286 res = GetStringFromConfig(ConfigSection(), KString2, String2 ); |
|
2287 if(!res) |
|
2288 { |
|
2289 _LIT(Kerr , "Failed to read parameter 2") ; |
|
2290 INFO_PRINTF1(Kerr) ; |
|
2291 return KErrGeneral ; |
|
2292 } |
|
2293 stringBuffer.Copy(String2); |
|
2294 paramLength = String2.Length(); |
|
2295 text=(char *)(stringBuffer.Ptr()); |
|
2296 *(text + paramLength) ='\0'; |
|
2297 parameter[1] = atol(text); |
|
2298 |
|
2299 _LIT( KString3, "Parameter3" ); |
|
2300 res = GetStringFromConfig(ConfigSection(), KString3, String3 ); |
|
2301 if(!res) |
|
2302 { |
|
2303 _LIT(Kerr , "Failed to read parameter 3") ; |
|
2304 INFO_PRINTF1(Kerr) ; |
|
2305 return KErrGeneral ; |
|
2306 } |
|
2307 stringBuffer.Copy(String3); |
|
2308 paramLength = String3.Length(); |
|
2309 text=(char *)(stringBuffer.Ptr()); |
|
2310 *(text + paramLength) ='\0'; |
|
2311 parameter[2] = atol(text); |
|
2312 |
|
2313 _LIT( KString4, "Parameter4" ); |
|
2314 res = GetStringFromConfig(ConfigSection(), KString4, String4 ); |
|
2315 if(!res) |
|
2316 { |
|
2317 _LIT(Kerr , "Failed to read parameter 4") ; |
|
2318 INFO_PRINTF1(Kerr) ; |
|
2319 return KErrGeneral ; |
|
2320 } |
|
2321 stringBuffer.Copy(String4); |
|
2322 paramLength = String4.Length(); |
|
2323 text=(char *)(stringBuffer.Ptr()); |
|
2324 *(text + paramLength) ='\0'; |
|
2325 parameter[3] = atol(text); |
|
2326 |
|
2327 _LIT( KString5, "Parameter5" ); |
|
2328 res = GetStringFromConfig(ConfigSection(), KString5, String5 ); |
|
2329 if(!res) |
|
2330 { |
|
2331 _LIT(Kerr , "Failed to read parameter 5") ; |
|
2332 INFO_PRINTF1(Kerr) ; |
|
2333 return KErrGeneral ; |
|
2334 } |
|
2335 stringBuffer.Copy(String5); |
|
2336 paramLength = String5.Length(); |
|
2337 text=(char *)(stringBuffer.Ptr()); |
|
2338 *(text + paramLength) ='\0'; |
|
2339 parameter[4] = atol(text); |
|
2340 |
|
2341 _LIT( KString6, "Parameter6" ); |
|
2342 res = GetStringFromConfig(ConfigSection(), KString6, String6); |
|
2343 if(!res) |
|
2344 { |
|
2345 _LIT(Kerr , "Failed to read parameter 6") ; |
|
2346 INFO_PRINTF1(Kerr) ; |
|
2347 return KErrGeneral ; |
|
2348 } |
|
2349 stringBuffer.Copy(String6); |
|
2350 paramLength = String6.Length(); |
|
2351 text=(char *)(stringBuffer.Ptr()); |
|
2352 *(text + paramLength) ='\0'; |
|
2353 parameter[5] = atol(text); |
|
2354 |
|
2355 _LIT( KString7, "Parameter7" ); |
|
2356 res = GetStringFromConfig(ConfigSection(), KString7, String7 ); |
|
2357 if(!res) |
|
2358 { |
|
2359 _LIT(Kerr , "Failed to read parameter 7") ; |
|
2360 INFO_PRINTF1(Kerr) ; |
|
2361 return KErrGeneral ; |
|
2362 } |
|
2363 stringBuffer.Copy(String7); |
|
2364 paramLength = String7.Length(); |
|
2365 text=(char *)(stringBuffer.Ptr()); |
|
2366 *(text + paramLength) ='\0'; |
|
2367 parameter[6] = atol(text); |
|
2368 |
|
2369 |
|
2370 /*while ( aItem.GetNextString ( stringPtr ) == KErrNone ) |
|
2371 { |
|
2372 stringBuffer.Copy(stringPtr); |
|
2373 paramLength = stringPtr.Length(); |
|
2374 char* text=(char *)(stringBuffer.Ptr()); |
|
2375 *(text + paramLength) ='\0'; |
|
2376 parameter[i] = atol(text); |
|
2377 i++; |
|
2378 } |
|
2379 */ |
|
2380 /** |
|
2381 * parameter[0] = domain |
|
2382 * parameter[1] = type |
|
2383 * parameter[2] = socket des, |
|
2384 * for testing purpose if parameter[2] <= 0,cfg file is supplying sockfd. |
|
2385 * parameter[3] = level |
|
2386 * parameter[4] = option_name |
|
2387 * parameter[5] = option_value |
|
2388 * As of now only integer values are supported for option value |
|
2389 * parameter[6] = Get or Set or Both |
|
2390 */ |
|
2391 |
|
2392 if (parameter[2] > 0) |
|
2393 { |
|
2394 sock_fd = socket(parameter[0],parameter[1],IPPROTO_TCP); |
|
2395 if (sock_fd < 0) |
|
2396 { |
|
2397 return KErrSocket; |
|
2398 } |
|
2399 } |
|
2400 else |
|
2401 { |
|
2402 sock_fd = parameter[3]; |
|
2403 } |
|
2404 int level = parameter[3]; |
|
2405 int optionName = parameter[4]; |
|
2406 int optionValue = parameter[5]; |
|
2407 optionLen = sizeof(optionValue); |
|
2408 int readOptionValue = 0; |
|
2409 |
|
2410 /** |
|
2411 * For options which allow get and set, first test case |
|
2412 * will set and then get the value. |
|
2413 */ |
|
2414 |
|
2415 if (parameter[6] == KSoGet) |
|
2416 { |
|
2417 ret = getsockopt(sock_fd,level,optionName,(void*)&readOptionValue,&optionLen); |
|
2418 if (ret != KErrNone) |
|
2419 { |
|
2420 ret = KErrGeneral; |
|
2421 } |
|
2422 } |
|
2423 if (parameter[6] & KSoSet) |
|
2424 { |
|
2425 ret = setsockopt(sock_fd,level,optionName,&optionValue,optionLen); |
|
2426 if (ret != KErrNone) |
|
2427 { |
|
2428 ret = KErrGeneral; |
|
2429 } |
|
2430 } |
|
2431 if ((parameter[6] == KSoGetSet) & (ret == KErrNone)) |
|
2432 { |
|
2433 ret = getsockopt(sock_fd,level,optionName,(void*)&readOptionValue,&optionLen); |
|
2434 if (ret != KErrNone) |
|
2435 { |
|
2436 ret = KErrGeneral; |
|
2437 } |
|
2438 else |
|
2439 { |
|
2440 if (readOptionValue == optionValue) |
|
2441 { |
|
2442 ret = KErrNone; |
|
2443 } |
|
2444 else |
|
2445 { |
|
2446 ret = KErrGeneral; |
|
2447 } |
|
2448 } |
|
2449 } |
|
2450 shutdown(sock_fd,SHUT_RDWR); // 2 -> SHUT_RDWT |
|
2451 close(sock_fd); |
|
2452 return ret; |
|
2453 } |
|
2454 |
|
2455 TInt CTestSocket::GetSockOptFailCases() |
|
2456 { |
|
2457 int sock_fd; |
|
2458 int ret = KErrNone; |
|
2459 int level = 0; |
|
2460 int optionName = 0; |
|
2461 int optionValue; |
|
2462 unsigned int optionLen; |
|
2463 int error; |
|
2464 |
|
2465 sock_fd = socket(AF_INET,SOCK_STREAM,0); |
|
2466 if (sock_fd < 0) |
|
2467 { |
|
2468 ret = KErrSocket; |
|
2469 goto close; |
|
2470 } |
|
2471 |
|
2472 // errno shoud be EFAULT |
|
2473 optionLen = sizeof(optionValue); |
|
2474 ret = getsockopt(sock_fd,level,optionName,(void*)0,&optionLen); |
|
2475 if (errno != EFAULT ) |
|
2476 { |
|
2477 ret = KErrGetSockOpt; |
|
2478 goto close; |
|
2479 } |
|
2480 if (ret == KErrNone) |
|
2481 { |
|
2482 ret = KErrGetSockOpt; |
|
2483 goto close; |
|
2484 } |
|
2485 // errno shoud be EINVAL |
|
2486 optionLen = 0; |
|
2487 ret = getsockopt(sock_fd,level,optionName,(void*)&optionValue,&optionLen); |
|
2488 if (errno != EINVAL ) |
|
2489 { |
|
2490 ret = KErrGetSockOpt; |
|
2491 goto close; |
|
2492 } |
|
2493 if (ret == KErrNone) |
|
2494 { |
|
2495 ret = KErrGetSockOpt; |
|
2496 goto close; |
|
2497 } |
|
2498 |
|
2499 // Wrong sockfd, errno shoud be ENOTSOCK |
|
2500 optionLen = sizeof(optionValue); |
|
2501 ret = getsockopt(1,level,optionName,(void*)&optionValue,&optionLen); |
|
2502 if (errno != ENOTSOCK) |
|
2503 { |
|
2504 ret = KErrGetSockOpt; |
|
2505 goto close; |
|
2506 } |
|
2507 if (ret == KErrNone) |
|
2508 { |
|
2509 ret = KErrGetSockOpt; |
|
2510 goto close; |
|
2511 } |
|
2512 |
|
2513 // Wrong sock_fd, errno shoud be EBADF |
|
2514 ret = getsockopt(sock_fd + 100,level,optionName,(void*)&optionValue,&optionLen); |
|
2515 if (errno != EBADF ) |
|
2516 { |
|
2517 ret = KErrGetSockOpt; |
|
2518 goto close; |
|
2519 } |
|
2520 if (ret == KErrNone) |
|
2521 { |
|
2522 ret = KErrGetSockOpt; |
|
2523 goto close; |
|
2524 } |
|
2525 |
|
2526 // Invalid level |
|
2527 level = -1; |
|
2528 optionName = SO_OOBINLINE; |
|
2529 optionValue = 1; |
|
2530 optionLen = sizeof(optionValue); |
|
2531 ret = getsockopt(sock_fd,level,optionName,(void*)&optionValue,&optionLen); |
|
2532 error = errno; |
|
2533 if (error != ENOPROTOOPT ) |
|
2534 { |
|
2535 ret = KErrGetSockOpt; |
|
2536 goto close; |
|
2537 } |
|
2538 if (ret == KErrNone) |
|
2539 { |
|
2540 ret = KErrGetSockOpt; |
|
2541 goto close; |
|
2542 } |
|
2543 |
|
2544 // Invalid name |
|
2545 level = SOL_TCP; |
|
2546 optionName = -1; |
|
2547 optionValue = 1; |
|
2548 optionLen = sizeof(optionValue); |
|
2549 ret = getsockopt(sock_fd,level,optionName,(void*)&optionValue,&optionLen); |
|
2550 error = errno; |
|
2551 if (error != ENOPROTOOPT ) |
|
2552 { |
|
2553 ret = KErrGetSockOpt; |
|
2554 goto close; |
|
2555 } |
|
2556 if (ret == KErrNone) |
|
2557 { |
|
2558 ret = KErrGetSockOpt; |
|
2559 goto close; |
|
2560 } |
|
2561 |
|
2562 ret = KErrNone; |
|
2563 |
|
2564 close: |
|
2565 close(sock_fd); |
|
2566 return ret; |
|
2567 } |
|
2568 |
|
2569 TInt CTestSocket::SetSockOptFailCases() |
|
2570 { |
|
2571 int sock_fd; |
|
2572 int ret = KErrNone; |
|
2573 int level = 0; |
|
2574 int optionName = 0; |
|
2575 int optionValue; |
|
2576 unsigned int optionLen; |
|
2577 int error; |
|
2578 |
|
2579 sock_fd = socket(AF_INET,SOCK_STREAM,0); |
|
2580 if (sock_fd < 0) |
|
2581 { |
|
2582 ret = KErrSocket; |
|
2583 goto close; |
|
2584 } |
|
2585 |
|
2586 // errno shoud be EFAULT |
|
2587 optionLen = sizeof(optionValue); |
|
2588 ret = setsockopt(sock_fd,level,optionName,(void*)0,optionLen); |
|
2589 if (errno != EFAULT ) |
|
2590 { |
|
2591 ret = KErrGetSockOpt; |
|
2592 goto close; |
|
2593 } |
|
2594 if (ret == KErrNone) |
|
2595 { |
|
2596 ret = KErrGetSockOpt; |
|
2597 goto close; |
|
2598 } |
|
2599 // errno shoud be EINVAL |
|
2600 optionLen = 0; |
|
2601 ret = setsockopt(sock_fd,level,optionName,(void*)&optionValue,optionLen); |
|
2602 if (errno != EINVAL ) |
|
2603 { |
|
2604 ret = KErrGetSockOpt; |
|
2605 goto close; |
|
2606 } |
|
2607 if (ret == KErrNone) |
|
2608 { |
|
2609 ret = KErrGetSockOpt; |
|
2610 goto close; |
|
2611 } |
|
2612 |
|
2613 // Wrong sockfd, errno shoud be ENOTSOCK |
|
2614 optionLen = sizeof(optionValue); |
|
2615 ret = setsockopt(1,level,optionName,(void*)&optionValue,optionLen); |
|
2616 if (errno != ENOTSOCK) |
|
2617 { |
|
2618 ret = KErrGetSockOpt; |
|
2619 goto close; |
|
2620 } |
|
2621 if (ret == KErrNone) |
|
2622 { |
|
2623 ret = KErrGetSockOpt; |
|
2624 goto close; |
|
2625 } |
|
2626 |
|
2627 // Wrong sockfd, errno shoud be EBADF |
|
2628 ret = setsockopt(sock_fd + 100,level,optionName,(void*)&optionValue,optionLen); |
|
2629 if (errno != EBADF ) |
|
2630 { |
|
2631 ret = KErrGetSockOpt; |
|
2632 goto close; |
|
2633 } |
|
2634 if (ret == KErrNone) |
|
2635 { |
|
2636 ret = KErrGetSockOpt; |
|
2637 goto close; |
|
2638 } |
|
2639 |
|
2640 // Invalid level |
|
2641 level = -1; |
|
2642 optionName = SO_OOBINLINE; |
|
2643 optionValue = 1; |
|
2644 optionLen = sizeof(optionValue); |
|
2645 ret = setsockopt(sock_fd,level,optionName,(void*)&optionValue,optionLen); |
|
2646 error = errno; |
|
2647 if (error != ENOPROTOOPT ) |
|
2648 { |
|
2649 ret = KErrGetSockOpt; |
|
2650 goto close; |
|
2651 } |
|
2652 if (ret == KErrNone) |
|
2653 { |
|
2654 ret = KErrGetSockOpt; |
|
2655 goto close; |
|
2656 } |
|
2657 |
|
2658 // Invalid name |
|
2659 level = SOL_TCP; |
|
2660 optionName = -10; |
|
2661 optionValue = 1; |
|
2662 optionLen = sizeof(optionValue); |
|
2663 ret = setsockopt(sock_fd,level,optionName,(void*)&optionValue,optionLen); |
|
2664 error = errno; |
|
2665 if (error != ENOPROTOOPT ) |
|
2666 { |
|
2667 INFO_PRINTF2(_L("ERROR NO: %d"), errno); |
|
2668 ret = KErrGetSockOpt; |
|
2669 goto close; |
|
2670 } |
|
2671 if (ret == KErrNone) |
|
2672 { |
|
2673 ret = KErrGetSockOpt; |
|
2674 goto close; |
|
2675 } |
|
2676 |
|
2677 ret = KErrNone; |
|
2678 |
|
2679 close: |
|
2680 close(sock_fd); |
|
2681 return ret; |
|
2682 } |
|
2683 |
|
2684 TInt CTestSocket::SockAtMark() |
|
2685 { |
|
2686 int sockfd; |
|
2687 sockaddr_in selfAddr; |
|
2688 int ret = KErrNone; |
|
2689 |
|
2690 sockfd = socket(AF_INET,SOCK_STREAM,IPPROTO_TCP); |
|
2691 if (sockfd < 0) |
|
2692 { |
|
2693 ret = KErrSocket; |
|
2694 goto close; |
|
2695 } |
|
2696 |
|
2697 selfAddr.sin_family = AF_INET; |
|
2698 selfAddr.sin_addr.s_addr = INADDR_ANY; |
|
2699 selfAddr.sin_port = 0; |
|
2700 |
|
2701 ret = bind(sockfd,(struct sockaddr*)&selfAddr, sizeof(selfAddr)); |
|
2702 if (ret != KErrNone) |
|
2703 { |
|
2704 ret = KErrBind; |
|
2705 goto close; |
|
2706 } |
|
2707 ret = sockatmark(sockfd); |
|
2708 if (ret != KErrNone) |
|
2709 { |
|
2710 ret = KErrSockAtMark; |
|
2711 goto close; |
|
2712 } |
|
2713 close: |
|
2714 close(sockfd); |
|
2715 return ret; |
|
2716 } |
|
2717 |
|
2718 |
|
2719 TInt CTestSocket::BindResvPort() |
|
2720 { |
|
2721 int sockfd; |
|
2722 sockaddr_in selfAddr; |
|
2723 int ret = KErrNone; |
|
2724 char paramets[10][256]; |
|
2725 |
|
2726 /** |
|
2727 * parameter[0] = Port number to bind |
|
2728 */ |
|
2729 GetParameters(paramets); |
|
2730 |
|
2731 sockfd = socket(AF_INET,SOCK_STREAM,IPPROTO_TCP); |
|
2732 if (sockfd < 0) |
|
2733 { |
|
2734 ret = KErrSocket; |
|
2735 goto close; |
|
2736 } |
|
2737 |
|
2738 selfAddr.sin_family = AF_INET; |
|
2739 selfAddr.sin_addr.s_addr = INADDR_ANY; |
|
2740 selfAddr.sin_port = htons(atoi(paramets[0])); /* echo */ |
|
2741 ret = bindresvport(sockfd, &selfAddr); |
|
2742 if (ret != KErrNone) |
|
2743 { |
|
2744 ret = KErrSockAtMark; |
|
2745 goto close; |
|
2746 } |
|
2747 close: |
|
2748 close(sockfd); |
|
2749 return ret; |
|
2750 } |
|
2751 |
|
2752 |
|
2753 TInt CTestSocket::BindResvPortFailCases() |
|
2754 { |
|
2755 sockaddr_in selfAddr; |
|
2756 int ret = KErrNone; |
|
2757 |
|
2758 selfAddr.sin_family = AF_INET; |
|
2759 selfAddr.sin_addr.s_addr = INADDR_ANY; |
|
2760 selfAddr.sin_port = htons(1234); |
|
2761 ret = bindresvport(0, &selfAddr); |
|
2762 if (ret != KErrNone) |
|
2763 { |
|
2764 ret = KErrNone; |
|
2765 goto close; |
|
2766 } |
|
2767 |
|
2768 selfAddr.sin_family = AF_INET; |
|
2769 selfAddr.sin_addr.s_addr = INADDR_ANY; |
|
2770 selfAddr.sin_port = htons(1234); |
|
2771 ret = bindresvport(5, &selfAddr); |
|
2772 if (ret != KErrNone) |
|
2773 { |
|
2774 ret = KErrNone; |
|
2775 goto close; |
|
2776 } |
|
2777 close: |
|
2778 return ret; |
|
2779 } |
|
2780 |
|
2781 TInt CTestSocket::HErrNoLocation() |
|
2782 { |
|
2783 //TInt *ptr = __h_errno_location(); |
|
2784 return KErrNone; |
|
2785 } |
|
2786 |
|
2787 void* UDPThreadSendMsg(TAny* aParam) |
|
2788 { |
|
2789 sockaddr_in receiver_addr; |
|
2790 int sock_fd; |
|
2791 char line[KMaxLine]; |
|
2792 struct msghdr msg; |
|
2793 struct iovec iov; |
|
2794 //TInt ret = KErrNone; |
|
2795 int error; |
|
2796 sock_fd = socket(AF_INET,SOCK_DGRAM,IPPROTO_UDP); |
|
2797 char character = 'A'; |
|
2798 unsigned int cnt = 0; |
|
2799 if (sock_fd < 0) |
|
2800 { |
|
2801 |
|
2802 //ret = KErrSocket; |
|
2803 goto close; |
|
2804 } |
|
2805 for(; cnt < KMaxLine - 1; cnt++) |
|
2806 { |
|
2807 line[cnt] = character; |
|
2808 character++; |
|
2809 if (character > 'Z') |
|
2810 { |
|
2811 character = 'A'; |
|
2812 } |
|
2813 } |
|
2814 line[cnt] = '\0'; |
|
2815 receiver_addr.sin_family = AF_INET; |
|
2816 receiver_addr.sin_addr.s_addr = htonl(INADDR_LOOPBACK); |
|
2817 receiver_addr.sin_port = (int)aParam; |
|
2818 |
|
2819 msg.msg_name = &receiver_addr; |
|
2820 msg.msg_namelen = sizeof(receiver_addr); |
|
2821 msg.msg_iov = &iov; |
|
2822 msg.msg_iovlen = 1; |
|
2823 msg.msg_iov->iov_base = line; |
|
2824 msg.msg_iov->iov_len = KMaxLine; |
|
2825 msg.msg_control = 0; |
|
2826 msg.msg_controllen = 0; |
|
2827 msg.msg_flags = 0; |
|
2828 error = sendmsg(sock_fd,&msg,0); |
|
2829 if ( error < 0) |
|
2830 { |
|
2831 |
|
2832 //ret = KWriteError; |
|
2833 goto close; |
|
2834 } |
|
2835 |
|
2836 close: |
|
2837 close(sock_fd); |
|
2838 return (void*)NULL; |
|
2839 } |
|
2840 |
|
2841 TInt CTestSocket::SendMsgRecvMsg() |
|
2842 { |
|
2843 TInt ret = KErrNone; |
|
2844 int sock_fd; |
|
2845 unsigned int sender_len, receiver_len; |
|
2846 struct msghdr msg; |
|
2847 struct iovec iov; |
|
2848 sockaddr_in receiver_addr,sender_addr; |
|
2849 char line[KMaxLine]; |
|
2850 int error = -1; |
|
2851 sock_fd = socket(AF_INET,SOCK_DGRAM,IPPROTO_UDP); |
|
2852 receiver_addr.sin_family = AF_INET; |
|
2853 receiver_addr.sin_addr.s_addr = htonl(INADDR_ANY); |
|
2854 receiver_addr.sin_port = 0; |
|
2855 |
|
2856 pthread_t testThread; |
|
2857 int threadRetVal; |
|
2858 void *threadRetValPtr = (void*)&threadRetVal; |
|
2859 if (sock_fd < 0) |
|
2860 { |
|
2861 ret = KErrSocket; |
|
2862 goto close; |
|
2863 } |
|
2864 |
|
2865 if (bind(sock_fd,(sockaddr*)&receiver_addr,sizeof(receiver_addr)) < 0) |
|
2866 { |
|
2867 shutdown(sock_fd,SHUT_RDWR); |
|
2868 close(sock_fd); |
|
2869 ret = KErrBind; |
|
2870 goto close; |
|
2871 } |
|
2872 receiver_len = sizeof(receiver_addr); |
|
2873 if (getsockname(sock_fd, (sockaddr*)&receiver_addr, &receiver_len) < 0) |
|
2874 { |
|
2875 ret = KErrGetSockName; |
|
2876 goto close; |
|
2877 } |
|
2878 |
|
2879 // Create the thread and thread is client code |
|
2880 |
|
2881 pthread_create(&testThread, NULL, &UDPThreadSendMsg, (void*)(receiver_addr.sin_port)); |
|
2882 |
|
2883 sender_len = sizeof(sender_addr); |
|
2884 msg.msg_name = &sender_addr; |
|
2885 msg.msg_namelen = sender_len; |
|
2886 msg.msg_iov = &iov; |
|
2887 msg.msg_iovlen = 1; |
|
2888 msg.msg_iov->iov_base = line; |
|
2889 msg.msg_iov->iov_len = 10; |
|
2890 msg.msg_control = 0; |
|
2891 msg.msg_controllen = 0; |
|
2892 msg.msg_flags = 0; |
|
2893 error = recvmsg(sock_fd,&msg,0); |
|
2894 if (error < 0) |
|
2895 { |
|
2896 pthread_join(testThread, &threadRetValPtr); |
|
2897 ret = KReadError; |
|
2898 goto close; |
|
2899 } |
|
2900 |
|
2901 pthread_join(testThread, &threadRetValPtr); |
|
2902 |
|
2903 close: |
|
2904 shutdown(sock_fd,SHUT_RDWR); |
|
2905 close(sock_fd); |
|
2906 return ret; |
|
2907 } |
|
2908 |
|
2909 TInt CTestSocket::TestRecv() |
|
2910 { |
|
2911 sockaddr_in serv_addr; |
|
2912 int sock_fd; |
|
2913 char line[2000]; |
|
2914 int ret = KErrNone; |
|
2915 char address[] = "172.30.176.119"; |
|
2916 int left; |
|
2917 |
|
2918 serv_addr.sin_family = AF_INET; |
|
2919 serv_addr.sin_addr.s_addr = inet_addr(address); |
|
2920 serv_addr.sin_port = htons(7000); |
|
2921 |
|
2922 sock_fd = socket(AF_INET,SOCK_STREAM,0); |
|
2923 if (sock_fd < 0) |
|
2924 { |
|
2925 ret = KErrSocket; |
|
2926 goto close; |
|
2927 } |
|
2928 |
|
2929 struct ifreq ifr; |
|
2930 strcpy(ifr.ifr_name, "Ethernet with Daemon Dynamic IP"); |
|
2931 if ( ioctl(sock_fd,SIOCSIFNAME, &ifr) < 0) |
|
2932 { |
|
2933 ret = KErrIoctl; |
|
2934 goto close; |
|
2935 } |
|
2936 if ( ioctl(sock_fd,SIOCIFSTART , NULL) < 0) |
|
2937 { |
|
2938 ret = KErrIoctl; |
|
2939 goto close; |
|
2940 } |
|
2941 |
|
2942 if (connect(sock_fd,(sockaddr*)&serv_addr,sizeof(serv_addr)) < 0) |
|
2943 { |
|
2944 ret = KErrConnect; |
|
2945 goto close; |
|
2946 } |
|
2947 |
|
2948 printf("How many bytes to read\n"); |
|
2949 scanf("%d", &left); |
|
2950 |
|
2951 if (recv(sock_fd,line,left,0) < 0) |
|
2952 { |
|
2953 ret = KErrRead; |
|
2954 goto close; |
|
2955 } |
|
2956 |
|
2957 close: |
|
2958 ioctl(sock_fd, SIOCIFSTOP , NULL); |
|
2959 close(sock_fd); |
|
2960 ret = KErrNone; |
|
2961 return ret; |
|
2962 } |
|
2963 |
|
2964 TInt CTestSocket::TestReadStream() |
|
2965 { |
|
2966 sockaddr_in serv_addr; |
|
2967 int sock_fd; |
|
2968 char line[2000]; |
|
2969 int ret = KErrNone; |
|
2970 char address[] = "172.30.176.119"; |
|
2971 int left; |
|
2972 |
|
2973 serv_addr.sin_family = AF_INET; |
|
2974 serv_addr.sin_addr.s_addr = inet_addr(address); |
|
2975 serv_addr.sin_port = htons(7000); |
|
2976 |
|
2977 sock_fd = socket(AF_INET,SOCK_STREAM,0); |
|
2978 if (sock_fd < 0) |
|
2979 { |
|
2980 ret = KErrSocket; |
|
2981 goto close; |
|
2982 } |
|
2983 |
|
2984 struct ifreq ifr; |
|
2985 strcpy(ifr.ifr_name, "Ethernet with Daemon Dynamic IP"); |
|
2986 if ( ioctl(sock_fd,SIOCSIFNAME, &ifr) < 0) |
|
2987 { |
|
2988 ret = KErrIoctl; |
|
2989 goto close; |
|
2990 } |
|
2991 if ( ioctl(sock_fd,SIOCIFSTART , NULL) < 0) |
|
2992 { |
|
2993 ret = KErrIoctl; |
|
2994 goto close; |
|
2995 } |
|
2996 |
|
2997 if (connect(sock_fd,(sockaddr*)&serv_addr,sizeof(serv_addr)) < 0) |
|
2998 { |
|
2999 ret = KErrConnect; |
|
3000 goto close; |
|
3001 } |
|
3002 |
|
3003 printf("How many bytes to read\n"); |
|
3004 scanf("%d", &left); |
|
3005 |
|
3006 if (read(sock_fd,line,left) < 0) |
|
3007 { |
|
3008 ret = KErrRead; |
|
3009 goto close; |
|
3010 } |
|
3011 |
|
3012 close: |
|
3013 ioctl(sock_fd, SIOCIFSTOP , NULL); |
|
3014 close(sock_fd); |
|
3015 ret = KErrNone; |
|
3016 return ret; |
|
3017 } |
|
3018 |
|
3019 TInt CTestSocket::TestReadDatagram() |
|
3020 { |
|
3021 sockaddr_in serv_addr; |
|
3022 int sock_fd; |
|
3023 char line[2000]; |
|
3024 int ret = KErrNone; |
|
3025 char address[] = "172.30.176.119"; |
|
3026 int left; |
|
3027 |
|
3028 serv_addr.sin_family = AF_INET; |
|
3029 serv_addr.sin_addr.s_addr = inet_addr(address); |
|
3030 serv_addr.sin_port = htons(7000); |
|
3031 |
|
3032 sock_fd = socket(AF_INET,SOCK_DGRAM,0); |
|
3033 if (sock_fd < 0) |
|
3034 { |
|
3035 ret = KErrSocket; |
|
3036 goto close; |
|
3037 } |
|
3038 |
|
3039 struct ifreq ifr; |
|
3040 strcpy(ifr.ifr_name, "Ethernet with Daemon Dynamic IP"); |
|
3041 if ( ioctl(sock_fd,SIOCSIFNAME, &ifr) < 0) |
|
3042 { |
|
3043 ret = KErrIoctl; |
|
3044 goto close; |
|
3045 } |
|
3046 if ( ioctl(sock_fd,SIOCIFSTART , NULL) < 0) |
|
3047 { |
|
3048 ret = KErrIoctl; |
|
3049 goto close; |
|
3050 } |
|
3051 |
|
3052 if (connect(sock_fd,(sockaddr*)&serv_addr,sizeof(serv_addr)) < 0) |
|
3053 { |
|
3054 ret = KErrConnect; |
|
3055 goto close; |
|
3056 } |
|
3057 |
|
3058 printf("How many bytes to read\n"); |
|
3059 scanf("%d", &left); |
|
3060 |
|
3061 if (read(sock_fd,line,left) < 0) |
|
3062 { |
|
3063 ret = KErrRead; |
|
3064 goto close; |
|
3065 } |
|
3066 |
|
3067 close: |
|
3068 ioctl(sock_fd, SIOCIFSTOP , NULL); |
|
3069 close(sock_fd); |
|
3070 ret = KErrNone; |
|
3071 return ret; |
|
3072 } |
|
3073 |
|
3074 TInt CTestSocket::GetHostName() |
|
3075 { |
|
3076 char hostname[256]; |
|
3077 int ret = KErrNone; |
|
3078 |
|
3079 ret = gethostname(hostname, 256); |
|
3080 if (ret == KErrNone) |
|
3081 { |
|
3082 return ret; |
|
3083 } |
|
3084 else |
|
3085 { |
|
3086 return KErrGetHostName; |
|
3087 } |
|
3088 } |
|
3089 |
|
3090 TInt CTestSocket::GetHostNameNull() |
|
3091 { |
|
3092 int ret = KErrNone; |
|
3093 |
|
3094 ret = gethostname((char*)0, 256); |
|
3095 if (errno != EFAULT ) |
|
3096 { |
|
3097 ret = KErrGetHostName; |
|
3098 goto close; |
|
3099 } |
|
3100 if (ret == KErrNone) |
|
3101 { |
|
3102 ret = KErrGetHostName; |
|
3103 goto close; |
|
3104 } |
|
3105 |
|
3106 ret = KErrNone; |
|
3107 |
|
3108 close: |
|
3109 return ret; |
|
3110 } |
|
3111 |
|
3112 TInt CTestSocket::GetHostNameZero() |
|
3113 { |
|
3114 char hostname[256]; |
|
3115 int ret = KErrNone; |
|
3116 |
|
3117 ret = gethostname(hostname, 0); |
|
3118 if (errno != EFAULT ) |
|
3119 { |
|
3120 ret = KErrGetHostName; |
|
3121 goto close; |
|
3122 } |
|
3123 if (ret == KErrNone) |
|
3124 { |
|
3125 ret = KErrGetHostName; |
|
3126 goto close; |
|
3127 } |
|
3128 |
|
3129 ret = KErrNone; |
|
3130 |
|
3131 close: |
|
3132 return ret; |
|
3133 } |
|
3134 |
|
3135 void CTestSocket::GetParameters(char aParamets[10][256]) |
|
3136 { |
|
3137 TPtrC string1, string2, string3, string4, string5, string6, string7; |
|
3138 char *textPtr; |
|
3139 TBuf8<256> stringBuffer; |
|
3140 |
|
3141 _LIT( Kstring1, "Parameter1" ); |
|
3142 TBool res = GetStringFromConfig(ConfigSection(), Kstring1, string1); |
|
3143 if(!res) return; |
|
3144 |
|
3145 stringBuffer.Copy(string1); |
|
3146 textPtr = (char*)stringBuffer.Ptr(); |
|
3147 *( textPtr + stringBuffer.Length() ) = '\0'; |
|
3148 strcpy(aParamets[0], textPtr); |
|
3149 |
|
3150 _LIT( Kstring2, "Parameter2" ); |
|
3151 res = GetStringFromConfig(ConfigSection(), Kstring2, string2); |
|
3152 if(!res) |
|
3153 return; |
|
3154 |
|
3155 stringBuffer.Copy(string2); |
|
3156 textPtr = (char*)stringBuffer.Ptr(); |
|
3157 *( textPtr + stringBuffer.Length() ) = '\0'; |
|
3158 strcpy(aParamets[1], textPtr); |
|
3159 |
|
3160 _LIT( Kstring3, "Parameter3" ); |
|
3161 res = GetStringFromConfig(ConfigSection(), Kstring3, string3); |
|
3162 if(!res) |
|
3163 return ; |
|
3164 |
|
3165 stringBuffer.Copy(string3); |
|
3166 textPtr = (char*)stringBuffer.Ptr(); |
|
3167 *( textPtr + stringBuffer.Length() ) = '\0'; |
|
3168 strcpy(aParamets[2], textPtr); |
|
3169 |
|
3170 _LIT( Kstring4, "Parameter4" ); |
|
3171 res = GetStringFromConfig(ConfigSection(), Kstring4, string4); |
|
3172 if(!res) |
|
3173 return ; |
|
3174 |
|
3175 stringBuffer.Copy(string4); |
|
3176 textPtr = (char*)stringBuffer.Ptr(); |
|
3177 *( textPtr + stringBuffer.Length() ) = '\0'; |
|
3178 strcpy(aParamets[3], textPtr); |
|
3179 |
|
3180 _LIT( Kstring5, "Parameter5" ); |
|
3181 res = GetStringFromConfig(ConfigSection(), Kstring5, string5); |
|
3182 if(!res) |
|
3183 return; |
|
3184 |
|
3185 stringBuffer.Copy(string5); |
|
3186 textPtr = (char*)stringBuffer.Ptr(); |
|
3187 *( textPtr + stringBuffer.Length() ) = '\0'; |
|
3188 strcpy(aParamets[4], textPtr); |
|
3189 |
|
3190 _LIT( Kstring6, "Parameter6" ); |
|
3191 res = GetStringFromConfig(ConfigSection(), Kstring6, string6); |
|
3192 if(!res) |
|
3193 return ; |
|
3194 |
|
3195 stringBuffer.Copy(string6); |
|
3196 textPtr = (char*)stringBuffer.Ptr(); |
|
3197 *( textPtr + stringBuffer.Length() ) = '\0'; |
|
3198 strcpy(aParamets[5], textPtr); |
|
3199 |
|
3200 _LIT( Kstring7, "Parameter7" ); |
|
3201 res = GetStringFromConfig(ConfigSection(), Kstring7, string7); |
|
3202 if(!res) |
|
3203 return; |
|
3204 |
|
3205 stringBuffer.Copy(string7); |
|
3206 textPtr = (char*)stringBuffer.Ptr(); |
|
3207 *( textPtr + stringBuffer.Length() ) = '\0'; |
|
3208 strcpy(aParamets[6], textPtr); |
|
3209 |
|
3210 } |
|
3211 |
|
3212 TInt CTestSocket::TestSktlseek() |
|
3213 { |
|
3214 int sock_fd; |
|
3215 int ret=KErrNone; |
|
3216 sock_fd=socket(AF_INET,SOCK_STREAM,0); |
|
3217 if (sock_fd < 0) |
|
3218 { |
|
3219 ret = KErrSocket; |
|
3220 return ret; |
|
3221 } |
|
3222 if (lseek(sock_fd,0,SEEK_CUR)<0) |
|
3223 { |
|
3224 ret= KErrLseek; |
|
3225 INFO_PRINTF2(_L("Lseek on socket returned %d"),ret ); |
|
3226 close(sock_fd); |
|
3227 return KErrNone; |
|
3228 } |
|
3229 else |
|
3230 { |
|
3231 close(sock_fd); |
|
3232 return KErrGeneral; |
|
3233 } |
|
3234 |
|
3235 } |
|
3236 |
|
3237 TInt CTestSocket::TestSockAfLocal() |
|
3238 { |
|
3239 int ret=KErrNone; |
|
3240 int fd = -1; |
|
3241 int rslt = -1; |
|
3242 int sz = 0; |
|
3243 const char path[] = "testipc"; |
|
3244 struct sockaddr_un server; |
|
3245 char errstr[256]; |
|
3246 |
|
3247 server.sun_family = PF_LOCAL; |
|
3248 strncpy(server.sun_path, path, strlen(path)+1); |
|
3249 sz = SUN_LEN(&server); |
|
3250 fd = socket(PF_LOCAL, SOCK_STREAM, 0); |
|
3251 if (fd < 0) |
|
3252 { |
|
3253 sprintf( errstr, strerror(errno) ); // protocol not supported!! |
|
3254 printf("%s", errstr); |
|
3255 } |
|
3256 |
|
3257 rslt = bind(fd, (struct sockaddr*)&server, sz); |
|
3258 |
|
3259 if (rslt) |
|
3260 { |
|
3261 printf("socket binding error\n"); |
|
3262 } |
|
3263 unlink(path); |
|
3264 close(fd); |
|
3265 |
|
3266 return ret; |
|
3267 } |
|
3268 |
|
3269 TInt CTestSocket::TestSktfstat() |
|
3270 { |
|
3271 int sock_fd,res; |
|
3272 int ret=KErrNone; |
|
3273 struct stat buf ; |
|
3274 sock_fd=socket(AF_INET,SOCK_STREAM,0); |
|
3275 if (sock_fd < 0) |
|
3276 { |
|
3277 ret = KErrGeneral; |
|
3278 INFO_PRINTF1(_L("socket creation failed")); |
|
3279 } |
|
3280 res=fstat(sock_fd,&buf); |
|
3281 if(res == 0 && buf.st_mode == S_IFSOCK ) |
|
3282 { |
|
3283 INFO_PRINTF1(_L("Test Passed")); |
|
3284 ret = KErrNone; |
|
3285 } |
|
3286 else |
|
3287 { |
|
3288 INFO_PRINTF1(_L("Test Failed")); |
|
3289 ret = KErrGeneral; |
|
3290 } |
|
3291 close(sock_fd); |
|
3292 return ret; |
|
3293 } |
|
3294 TInt CTestSocket::TestSktfsync() |
|
3295 { |
|
3296 int sock_fd,res; |
|
3297 int ret=KErrNone; |
|
3298 sock_fd=socket(AF_INET,SOCK_STREAM,0); |
|
3299 if (sock_fd < 0) |
|
3300 { |
|
3301 ret = KErrGeneral; |
|
3302 INFO_PRINTF1(_L("socket creation failed")); |
|
3303 } |
|
3304 res=fsync(sock_fd); |
|
3305 if(res == 0) |
|
3306 { |
|
3307 INFO_PRINTF1(_L("Test Passed")); |
|
3308 ret = KErrNone; |
|
3309 } |
|
3310 else |
|
3311 { |
|
3312 INFO_PRINTF1(_L("Test Failed")); |
|
3313 ret = KErrGeneral; |
|
3314 } |
|
3315 close(sock_fd); |
|
3316 return ret; |
|
3317 } |
|
3318 |
|
3319 TInt CTestSocket::TestGreaterThan16kReadWrite() |
|
3320 { |
|
3321 int sockfd = -1; |
|
3322 char *buffer; |
|
3323 struct sockaddr_in their_addr; |
|
3324 int no_bytes = 0; |
|
3325 fd_set fds; |
|
3326 struct timeval tv; |
|
3327 |
|
3328 if ((sockfd = socket(PF_INET, SOCK_STREAM, 0)) == -1) |
|
3329 { |
|
3330 INFO_PRINTF1(_L("socket creation failed")); |
|
3331 return KErrGeneral; |
|
3332 } |
|
3333 popen("z:\\sys\\bin\\greaterthan16kreadwriteserver.exe","r"); |
|
3334 sleep(5); |
|
3335 |
|
3336 memset(&their_addr, '\0', sizeof(their_addr)); |
|
3337 their_addr.sin_family = AF_INET; |
|
3338 their_addr.sin_port = htons(PORT); // short, network byte order |
|
3339 their_addr.sin_addr.s_addr = inet_addr("127.0.0.1"); |
|
3340 errno = 0; |
|
3341 |
|
3342 if (connect(sockfd, (struct sockaddr *)&their_addr,sizeof(their_addr)) == -1) |
|
3343 { |
|
3344 INFO_PRINTF1(_L("connect failed")); |
|
3345 return KErrGeneral; |
|
3346 } |
|
3347 fcntl (sockfd, F_SETFL, O_NONBLOCK); |
|
3348 |
|
3349 FD_ZERO(&fds); |
|
3350 FD_SET(sockfd,&fds); |
|
3351 tv.tv_sec = 1; |
|
3352 tv.tv_usec = 1; |
|
3353 buffer = (char *)malloc(100*1024); |
|
3354 while(1) |
|
3355 { |
|
3356 int rc = select(sockfd+1, &fds, NULL, NULL, &tv); |
|
3357 int size = read(sockfd,buffer,10*1024); |
|
3358 if(size == -1) |
|
3359 break; |
|
3360 if(size > 0) |
|
3361 no_bytes += size; |
|
3362 } |
|
3363 free(buffer); |
|
3364 close(sockfd); |
|
3365 return 0; |
|
3366 } |
|
3367 |
|
3368 static void* call_select(void *arg) |
|
3369 { |
|
3370 int ret; |
|
3371 fd_set fdset; |
|
3372 struct sockaddr_in server; |
|
3373 char buf[50]; |
|
3374 unsigned int len = sizeof(struct sockaddr); |
|
3375 int fd = *(int*)arg; |
|
3376 FD_ZERO(&fdset); |
|
3377 FD_SET(fd,&fdset); |
|
3378 ret = select(fd+1,&fdset,NULL,NULL,NULL); |
|
3379 if (ret < 0) |
|
3380 { |
|
3381 printf("select failed"); |
|
3382 return NULL; |
|
3383 } |
|
3384 ret = recvfrom(fd,&buf,sizeof(buf),0,(struct sockaddr*)&server,&len); |
|
3385 *(int*)arg = ret; |
|
3386 return NULL; |
|
3387 } |
|
3388 |
|
3389 // Port shared by the function TestNotify |
|
3390 TInt Port; |
|
3391 static void* call_ioctl(void *arg) |
|
3392 { |
|
3393 int ret; |
|
3394 int fd = *(int*)arg; |
|
3395 struct sockaddr_in server; |
|
3396 char buf[50]; |
|
3397 unsigned int len = sizeof(struct sockaddr); |
|
3398 unsigned status=1; //Is the socket ready to receive? |
|
3399 ret = ioctl(fd,E32IOSELECT,(char*)&status); |
|
3400 if (ret < 0) |
|
3401 { |
|
3402 printf("ioctl failed"); |
|
3403 return NULL; |
|
3404 } |
|
3405 ret = recvfrom(fd,&buf,sizeof(buf),0,(struct sockaddr*)&server,&len); |
|
3406 *(int*)arg = ret; |
|
3407 return NULL; |
|
3408 } |
|
3409 |
|
3410 static void* clientfun(void* /*param*/) |
|
3411 { |
|
3412 int sock; |
|
3413 int ret; |
|
3414 char buf[10] = "Hello"; |
|
3415 struct sockaddr_in server; |
|
3416 server.sin_addr.s_addr = inet_addr("127.0.0.1"); |
|
3417 server.sin_family = AF_INET; |
|
3418 server.sin_port = htons(Port); |
|
3419 sock = socket(AF_INET,SOCK_DGRAM,0); |
|
3420 sleep(5); |
|
3421 ret = sendto(sock,&buf,sizeof(buf),0,(struct sockaddr*)&server,sizeof(struct sockaddr)); |
|
3422 ret = sendto(sock,&buf,sizeof(buf),0,(struct sockaddr*)&server,sizeof(struct sockaddr)); |
|
3423 if( ret == -1 ) |
|
3424 { |
|
3425 printf("sendto failed \n"); |
|
3426 } |
|
3427 close(sock); |
|
3428 return NULL; |
|
3429 } |
|
3430 TInt CTestSocket::TestNotify() |
|
3431 { |
|
3432 int fd,ret; //Desc for open |
|
3433 struct sockaddr_in addr; |
|
3434 pthread_t spawn,client; |
|
3435 void* call_select(void *); |
|
3436 int threadRetVal = 0; |
|
3437 void *threadRetValPtr = (void*)&threadRetVal; |
|
3438 _LIT( KPort, "Port" ); |
|
3439 TBool res = GetIntFromConfig(ConfigSection(), KPort, Port); |
|
3440 if(!res) |
|
3441 return KErrGeneral; |
|
3442 addr.sin_family = AF_INET; |
|
3443 addr.sin_port = htons(Port); |
|
3444 addr.sin_addr.s_addr = INADDR_ANY; |
|
3445 fd = socket(AF_INET , SOCK_DGRAM , 0); |
|
3446 if ( fd < 0 ) |
|
3447 { |
|
3448 INFO_PRINTF1(_L("Error in socket\n")); |
|
3449 return -1; |
|
3450 } |
|
3451 ret = bind (fd,(struct sockaddr*)&addr,sizeof(addr)); |
|
3452 if ( ret < 0 ) |
|
3453 { |
|
3454 INFO_PRINTF1(_L("Error in bind\n")); |
|
3455 return -1; |
|
3456 } |
|
3457 |
|
3458 TPtrC TestCall; |
|
3459 _LIT( KTestCall, "TestCall" ); |
|
3460 res = GetStringFromConfig(ConfigSection(), KTestCall, TestCall); |
|
3461 if(!res) |
|
3462 return KErrGeneral; |
|
3463 ret = pthread_create(&client,NULL,&clientfun,NULL); |
|
3464 if(!TestCall.Compare(_L("Select"))) |
|
3465 { |
|
3466 INFO_PRINTF1(_L("Checking Select call")); |
|
3467 ret = pthread_create(&spawn,NULL,&call_select,&fd); |
|
3468 call_select(&fd); |
|
3469 } |
|
3470 else if(!TestCall.Compare(_L("Ioctl"))) |
|
3471 { |
|
3472 INFO_PRINTF1(_L("Checking Ioctl call")); |
|
3473 ret = pthread_create(&spawn,NULL,&call_ioctl,&fd); |
|
3474 call_ioctl(&fd); |
|
3475 } |
|
3476 else |
|
3477 { |
|
3478 INFO_PRINTF1(_L("Invalid Paramater")); |
|
3479 return KErrGeneral; |
|
3480 } |
|
3481 ret = pthread_join(spawn,&threadRetValPtr); |
|
3482 ret = pthread_join(client,NULL); |
|
3483 INFO_PRINTF2(_L("No. of bytes read %d\n"),fd); |
|
3484 if( fd > 0) |
|
3485 { |
|
3486 INFO_PRINTF1(_L("Test Passed")); |
|
3487 close(fd); |
|
3488 return KErrNone; |
|
3489 } |
|
3490 else |
|
3491 { |
|
3492 INFO_PRINTF1(_L("Test Failed")); |
|
3493 close(fd); |
|
3494 return KErrGeneral; |
|
3495 } |
|
3496 } |
|
3497 |
|
3498 /* Test 'peeking' at incoming message using MSG_PEEK flag |
|
3499 * in a connected socket. |
|
3500 */ |
|
3501 TInt CTestSocket::TestRecvMsgPeekTCP( ) |
|
3502 { |
|
3503 int flags; |
|
3504 int serverSock; |
|
3505 int serverPort; |
|
3506 |
|
3507 //Create server socket |
|
3508 serverSock = socket( AF_INET, SOCK_STREAM, IPPROTO_TCP ); |
|
3509 if( serverSock < 0 ) |
|
3510 return KErrSocket; |
|
3511 |
|
3512 //Set the server socket in non blocking mode |
|
3513 flags = fcntl( serverSock, F_GETFL, 0 ); |
|
3514 if ( flags < 0 ) |
|
3515 { |
|
3516 close( serverSock ); |
|
3517 return KErrGetSockOpt; |
|
3518 } |
|
3519 |
|
3520 if ( fcntl( serverSock, F_SETFL, flags | O_NONBLOCK ) < 0 ) |
|
3521 { |
|
3522 close( serverSock ); |
|
3523 return KErrGetSockOpt; |
|
3524 } |
|
3525 |
|
3526 //Bind the server socket |
|
3527 struct sockaddr_in addr; |
|
3528 addr.sin_family = AF_INET; |
|
3529 addr.sin_addr.s_addr = htonl( INADDR_ANY ); |
|
3530 addr.sin_port = htons( 0 ); |
|
3531 if( bind( serverSock, ( struct sockaddr* ) &addr, sizeof( addr ) ) < 0 ) |
|
3532 { |
|
3533 close( serverSock ); |
|
3534 return KErrBind; |
|
3535 } |
|
3536 |
|
3537 //Listen server socket |
|
3538 if( listen( serverSock, 1 ) < 0 ) |
|
3539 { |
|
3540 close( serverSock ); |
|
3541 return KErrListen; |
|
3542 } |
|
3543 |
|
3544 //Get the bind port number |
|
3545 struct sockaddr_in sa; |
|
3546 socklen_t sockAddrSize = sizeof( sa ); |
|
3547 memset(&sa, 0, sizeof(sa)); |
|
3548 |
|
3549 if( getsockname( serverSock, ( struct sockaddr * ) &sa, &sockAddrSize ) < 0 ) |
|
3550 { |
|
3551 close( serverSock ); |
|
3552 return KErrBind; |
|
3553 } |
|
3554 serverPort = ntohs( sa.sin_port ); |
|
3555 |
|
3556 //Create client socket |
|
3557 int clientSock = socket( AF_INET, SOCK_STREAM, IPPROTO_TCP); |
|
3558 |
|
3559 //Set the client socket in non blocking mode |
|
3560 flags = fcntl( clientSock, F_GETFL, 0 ); |
|
3561 if ( flags < 0 ) |
|
3562 { |
|
3563 close( serverSock ); |
|
3564 close( clientSock ); |
|
3565 return KErrGetSockOpt; |
|
3566 } |
|
3567 |
|
3568 if ( fcntl( clientSock, F_SETFL, flags | O_NONBLOCK ) < 0 ) |
|
3569 { |
|
3570 close( serverSock ); |
|
3571 close( clientSock ); |
|
3572 return KErrGetSockOpt; |
|
3573 } |
|
3574 |
|
3575 //Connect to the server |
|
3576 struct sockaddr_in servAddr; |
|
3577 servAddr.sin_family = AF_INET; |
|
3578 servAddr.sin_addr.s_addr = htonl( INADDR_LOOPBACK ); |
|
3579 servAddr.sin_port = htons( serverPort ); |
|
3580 connect( clientSock,( struct sockaddr* ) &servAddr, sizeof( servAddr ) ); |
|
3581 |
|
3582 //Accept the server sock |
|
3583 int newSock; |
|
3584 struct sockaddr acceptAddr; |
|
3585 unsigned int addrLen = sizeof( acceptAddr ); |
|
3586 newSock = accept( serverSock, &acceptAddr, &addrLen ); |
|
3587 if( newSock < 0 ) |
|
3588 { |
|
3589 close( serverSock ); |
|
3590 close( clientSock ); |
|
3591 return KErrAccept; |
|
3592 } |
|
3593 |
|
3594 //Send some data |
|
3595 const int bufSize = 50; |
|
3596 char writeData[bufSize]; |
|
3597 char readData[bufSize]; |
|
3598 memset( writeData, '@', bufSize ); |
|
3599 |
|
3600 if( write( newSock, writeData, bufSize ) < 0 ) |
|
3601 { |
|
3602 close( newSock ); |
|
3603 close( serverSock ); |
|
3604 close( clientSock ); |
|
3605 return KWriteError; |
|
3606 } |
|
3607 |
|
3608 //Wait for the data in client using select |
|
3609 fd_set fds; |
|
3610 FD_ZERO(&fds); |
|
3611 FD_SET(clientSock, &fds); |
|
3612 |
|
3613 struct timeval tv; |
|
3614 tv.tv_sec = 10; //10 seconds |
|
3615 tv.tv_usec = 0; |
|
3616 |
|
3617 if( select( clientSock + 1, &fds, 0, 0, &tv ) <= 0 ) |
|
3618 { |
|
3619 close( serverSock ); |
|
3620 close( clientSock ); |
|
3621 return KErrGetSockOpt; |
|
3622 } |
|
3623 |
|
3624 //Now, at the client side, peek at the data |
|
3625 errno = 0; |
|
3626 if( recv( clientSock, ( void* ) readData, bufSize, MSG_PEEK ) < 0 ) |
|
3627 { |
|
3628 close( newSock ); |
|
3629 close( serverSock ); |
|
3630 close( clientSock ); |
|
3631 return KErrRead; |
|
3632 } |
|
3633 |
|
3634 //Now, try reading the data |
|
3635 if( recv( clientSock, ( void* ) readData, bufSize, 0 ) < 0 ) |
|
3636 { |
|
3637 close( newSock ); |
|
3638 close( serverSock ); |
|
3639 close( clientSock ); |
|
3640 return KErrRead; |
|
3641 } |
|
3642 |
|
3643 close( clientSock ); |
|
3644 close( newSock ); |
|
3645 close( serverSock ); |
|
3646 return KErrNone; |
|
3647 } |
|
3648 |
|
3649 /* Test 'peeking' at incoming message using MSG_PEEK flag |
|
3650 * in a connection-less socket. |
|
3651 */ |
|
3652 TInt CTestSocket::TestRecvMsgPeekUDP( ) |
|
3653 { |
|
3654 int flags; |
|
3655 int serverSock; |
|
3656 int serverPort; |
|
3657 |
|
3658 //Create server socket |
|
3659 serverSock = socket( AF_INET, SOCK_DGRAM, IPPROTO_UDP ); |
|
3660 if( serverSock < 0 ) |
|
3661 return KErrSocket; |
|
3662 |
|
3663 //Set the server socket in non blocking mode |
|
3664 flags = fcntl( serverSock, F_GETFL, 0 ); |
|
3665 if ( flags < 0 ) |
|
3666 { |
|
3667 close( serverSock ); |
|
3668 return KErrGetSockOpt; |
|
3669 } |
|
3670 |
|
3671 if ( fcntl( serverSock, F_SETFL, flags | O_NONBLOCK ) < 0 ) |
|
3672 { |
|
3673 close( serverSock ); |
|
3674 return KErrGetSockOpt; |
|
3675 } |
|
3676 |
|
3677 //Bind the server socket |
|
3678 struct sockaddr_in addr; |
|
3679 addr.sin_family = AF_INET; |
|
3680 addr.sin_addr.s_addr = htonl( INADDR_ANY ); |
|
3681 addr.sin_port = htons( 0 ); |
|
3682 if( bind( serverSock, ( struct sockaddr* ) &addr, sizeof( addr ) ) < 0 ) |
|
3683 { |
|
3684 close( serverSock ); |
|
3685 return KErrBind; |
|
3686 } |
|
3687 |
|
3688 //Get the bind port number |
|
3689 struct sockaddr_in sa; |
|
3690 socklen_t sockAddrSize = sizeof( sa ); |
|
3691 memset(&sa, 0, sizeof(sa)); |
|
3692 |
|
3693 if( getsockname( serverSock, ( struct sockaddr * ) &sa, &sockAddrSize ) < 0 ) |
|
3694 { |
|
3695 close( serverSock ); |
|
3696 return KErrBind; |
|
3697 } |
|
3698 serverPort = ntohs( sa.sin_port ); |
|
3699 |
|
3700 //Create client socket |
|
3701 int clientSock = socket( AF_INET, SOCK_DGRAM, IPPROTO_UDP ); |
|
3702 |
|
3703 //Set the client socket in non blocking mode |
|
3704 flags = fcntl( clientSock, F_GETFL, 0 ); |
|
3705 if ( flags < 0 ) |
|
3706 { |
|
3707 close( serverSock ); |
|
3708 close( clientSock ); |
|
3709 return KErrGetSockOpt; |
|
3710 } |
|
3711 |
|
3712 if ( fcntl( clientSock, F_SETFL, flags | O_NONBLOCK ) < 0 ) |
|
3713 { |
|
3714 close( serverSock ); |
|
3715 close( clientSock ); |
|
3716 return KErrGetSockOpt; |
|
3717 } |
|
3718 |
|
3719 //Send some data |
|
3720 const int bufSize = 50; |
|
3721 char writeData[bufSize]; |
|
3722 char readData[bufSize]; |
|
3723 memset( writeData, '@', bufSize ); |
|
3724 |
|
3725 struct sockaddr_in sendAddr; |
|
3726 memset(&sendAddr, 0, sizeof(sendAddr)); |
|
3727 sendAddr.sin_family = AF_INET; |
|
3728 sendAddr.sin_addr.s_addr = htonl( INADDR_LOOPBACK ); |
|
3729 sendAddr.sin_port = htons( serverPort ); |
|
3730 if( sendto( clientSock, writeData, bufSize, 0, ( struct sockaddr* ) &sendAddr, sizeof( sendAddr ) ) < 0 ) |
|
3731 { |
|
3732 close( serverSock ); |
|
3733 close( clientSock ); |
|
3734 return KWriteError; |
|
3735 } |
|
3736 |
|
3737 //Wait for the data in server using select |
|
3738 fd_set fds; |
|
3739 FD_ZERO(&fds); |
|
3740 FD_SET(serverSock, &fds); |
|
3741 struct timeval tv; |
|
3742 tv.tv_sec = 10; //10 seconds |
|
3743 tv.tv_usec = 0; |
|
3744 |
|
3745 if( select( serverSock + 1, &fds, 0, 0, &tv ) <= 0 ) |
|
3746 { |
|
3747 close( serverSock ); |
|
3748 close( clientSock ); |
|
3749 return KErrGetSockOpt; |
|
3750 } |
|
3751 |
|
3752 struct sockaddr_in fromAddr; |
|
3753 unsigned int fromLen = sizeof( struct sockaddr_in ); |
|
3754 |
|
3755 //Now, at the client side, peek at the data |
|
3756 if( recvfrom( serverSock, readData, bufSize, MSG_PEEK, ( struct sockaddr* ) &fromAddr, &fromLen ) < 0 ) |
|
3757 { |
|
3758 close( serverSock ); |
|
3759 close( clientSock ); |
|
3760 return KErrRead; |
|
3761 } |
|
3762 |
|
3763 //Now, try reading the data |
|
3764 if( recvfrom( serverSock, readData, bufSize, 0, ( struct sockaddr* ) &fromAddr, &fromLen ) < 0 ) |
|
3765 { |
|
3766 close( serverSock ); |
|
3767 close( clientSock ); |
|
3768 return KErrRead; |
|
3769 } |
|
3770 |
|
3771 close( clientSock ); |
|
3772 close( serverSock ); |
|
3773 return KErrNone; |
|
3774 } |
|
3775 int sockfd = -1; |
|
3776 |
|
3777 #ifdef __SYMBIAN32__ |
|
3778 void OpenInterface(char *ifname) |
|
3779 { |
|
3780 printf( " ...Opening Interface - START\n" ); |
|
3781 ifreq ifr; |
|
3782 strcpy(ifr.ifr_name, ifname); |
|
3783 sockfd = socket(AF_INET,SOCK_DGRAM,IPPROTO_UDP); |
|
3784 int err = ioctl(sockfd,SIOCSIFNAME, &ifr); |
|
3785 if( err == -1 ) |
|
3786 { |
|
3787 err = errno; // debug |
|
3788 close( sockfd ); |
|
3789 } |
|
3790 err = ioctl(sockfd, SIOCIFSTART , &ifr); |
|
3791 if( err == -1 ) |
|
3792 { |
|
3793 err = errno; // debug |
|
3794 close( sockfd ); |
|
3795 } |
|
3796 printf( " ...Opening Interface - END\n" ); |
|
3797 } |
|
3798 |
|
3799 void CloseInterface( char *ifname ) |
|
3800 { |
|
3801 printf( " ...Closing Interface - START\n" ); |
|
3802 ifreq ifr; |
|
3803 strcpy(ifr.ifr_name, ifname); |
|
3804 int err = ioctl(sockfd, SIOCIFSTOP, &ifr); |
|
3805 if( err == -1 ) |
|
3806 { |
|
3807 err = errno; // debug |
|
3808 } |
|
3809 close(sockfd); |
|
3810 printf( " ...Closing Interface - END\n" ); |
|
3811 } |
|
3812 #endif |
|
3813 |
|
3814 |
|
3815 TInt CTestSocket::TestLargeUDP() |
|
3816 { |
|
3817 #if defined( __SYMBIAN32__ ) && defined ( __WINSCW__ ) |
|
3818 OpenInterface( "Ethernet with Daemon Dynamic IP" ); |
|
3819 #endif |
|
3820 TInt err = 0; |
|
3821 TInt ret = KErrNone; |
|
3822 TInt flags; |
|
3823 TInt serverport =0; |
|
3824 TInt sockoptdata = 49152; |
|
3825 // Server socket code |
|
3826 // ======================================================================================== |
|
3827 INFO_PRINTF1(_L( " ...UDP receiver start-up\n" )); |
|
3828 INFO_PRINTF1(_L( " ...Creating and initializing receiving socket\n" )); |
|
3829 int server_sockfd = socket( AF_INET, SOCK_DGRAM, IPPROTO_UDP); |
|
3830 if(server_sockfd == -1) |
|
3831 { |
|
3832 _LIT(KServ,"socket creation failed: server_sockfd = %d,errno = %d"); |
|
3833 INFO_PRINTF3(KServ,server_sockfd,errno); |
|
3834 ret = KErrGeneral; |
|
3835 return ret; |
|
3836 } |
|
3837 flags = fcntl(server_sockfd, F_GETFL, 0); |
|
3838 if (flags == -1) |
|
3839 { |
|
3840 INFO_PRINTF1(_L("fcntl(F_GETFL) FAILED\n")); |
|
3841 ret = KErrGeneral; |
|
3842 return ret; |
|
3843 } |
|
3844 |
|
3845 if(fcntl(server_sockfd, F_SETFL, flags | O_NONBLOCK) == -1) |
|
3846 { |
|
3847 INFO_PRINTF1(_L("Make the socket nonblocking FAILED\n")); |
|
3848 ret = KErrGeneral; |
|
3849 return ret; |
|
3850 } |
|
3851 |
|
3852 err = setsockopt(server_sockfd, SOL_SOCKET, SO_RCVBUF, (char *) &sockoptdata, sizeof(sockoptdata)); |
|
3853 if(err == -1) |
|
3854 { |
|
3855 _LIT(KRcv," ...setsockopt(SO_RCVBUF) failed: err = %d, errno = %d\n"); |
|
3856 INFO_PRINTF3(KRcv,err,errno); |
|
3857 ret = KErrGeneral; |
|
3858 return ret; |
|
3859 } |
|
3860 err = setsockopt(server_sockfd, SOL_SOCKET, SO_SNDBUF, (char *) &sockoptdata, sizeof(sockoptdata)); |
|
3861 if(err == -1) |
|
3862 { |
|
3863 _LIT(KSnd," ...setsockopt(SO_SNDBUF) failed: err = %d, errno = %d\n"); |
|
3864 INFO_PRINTF3(KSnd,err,errno); |
|
3865 ret = KErrGeneral; |
|
3866 return ret; |
|
3867 } |
|
3868 |
|
3869 INFO_PRINTF1(_L( " ...Binding listening socket\n" )); |
|
3870 struct sockaddr_in servaddr; |
|
3871 servaddr.sin_family = AF_INET; |
|
3872 servaddr.sin_addr.s_addr = htonl(INADDR_ANY); |
|
3873 servaddr.sin_port = htons(0); |
|
3874 err = bind(server_sockfd,(struct sockaddr*)&servaddr,sizeof(servaddr)); |
|
3875 if( err == -1 ) |
|
3876 { |
|
3877 _LIT(KInfo," ...bind failed: err = %d, errno = %d\n"); |
|
3878 INFO_PRINTF3( KInfo, err, errno ); |
|
3879 ret = KErrGeneral; |
|
3880 return ret; |
|
3881 } |
|
3882 INFO_PRINTF1( _L(" ...Check server port we are listening\n" )); |
|
3883 // Determine local port |
|
3884 struct sockaddr_in sa; |
|
3885 struct sockaddr *sockAddrPtr = (struct sockaddr *) &sa; |
|
3886 socklen_t sockAddrSize = sizeof(sa); |
|
3887 |
|
3888 memset(&sa, 0, sizeof(sa)); |
|
3889 if (getsockname(server_sockfd, sockAddrPtr, &sockAddrSize) == 0 ) |
|
3890 { |
|
3891 serverport = ntohs(sa.sin_port); |
|
3892 _LIT(KPort,"Listening port: %d"); |
|
3893 INFO_PRINTF2(KPort,serverport); |
|
3894 } |
|
3895 |
|
3896 INFO_PRINTF1(_L( " ...UDP client start-up\n" )); |
|
3897 INFO_PRINTF1( _L(" ...Creating and initializing sending socket\n" )); |
|
3898 |
|
3899 int client_sockfd = socket(AF_INET,SOCK_DGRAM,IPPROTO_UDP); |
|
3900 if(client_sockfd == -1) |
|
3901 { |
|
3902 _LIT(KCli,"socket creation failed: client_sockfd = %d,errno = %d"); |
|
3903 INFO_PRINTF3(KCli,client_sockfd,errno); |
|
3904 ret = KErrGeneral; |
|
3905 return ret; |
|
3906 } |
|
3907 flags = fcntl(client_sockfd, F_GETFL, 0); |
|
3908 if (flags == -1) |
|
3909 { |
|
3910 INFO_PRINTF1(_L("fcntl(F_GETFL) FAILED\n")); |
|
3911 ret = KErrGeneral; |
|
3912 return ret; |
|
3913 } |
|
3914 if(fcntl(client_sockfd, F_SETFL, flags | O_NONBLOCK) == -1) |
|
3915 { |
|
3916 INFO_PRINTF1(_L("Make the socket nonblocking FAILED\n")); |
|
3917 ret = KErrGeneral; |
|
3918 return ret; |
|
3919 } |
|
3920 err = setsockopt(client_sockfd, SOL_SOCKET, SO_RCVBUF, (char *) &sockoptdata, sizeof(sockoptdata)); |
|
3921 if(err == -1) |
|
3922 { |
|
3923 _LIT(KClircv," ...setsockopt(SO_RCVBUF) failed: err = %d, errno = %d\n"); |
|
3924 INFO_PRINTF3(KClircv,err,errno); |
|
3925 ret = KErrGeneral; |
|
3926 return ret; |
|
3927 } |
|
3928 err = setsockopt(client_sockfd, SOL_SOCKET, SO_SNDBUF, (char *) &sockoptdata, sizeof(sockoptdata)); |
|
3929 if(err == -1) |
|
3930 { |
|
3931 _LIT(KClisnd," ...setsockopt(SO_RCVBUF) failed: err = %d, errno = %d\n"); |
|
3932 INFO_PRINTF3(KClisnd,err,errno); |
|
3933 ret = KErrGeneral; |
|
3934 return ret; |
|
3935 } |
|
3936 |
|
3937 INFO_PRINTF1(_L( " ...Initializing buffers for writing and receiving\n" )); |
|
3938 |
|
3939 TInt Parameter1; |
|
3940 _LIT( KParameter1, "Parameter1" ); |
|
3941 TBool res = GetIntFromConfig(ConfigSection(), KParameter1, Parameter1); |
|
3942 const int bufsize = Parameter1; |
|
3943 char* writedata = (char *) malloc(bufsize); |
|
3944 char* rcvdata = (char *) malloc(bufsize); |
|
3945 |
|
3946 memset(writedata, '@', bufsize); |
|
3947 |
|
3948 _LIT(KInfo," ...Writing large buffer of data to socket. Bufsize: %d\n"); |
|
3949 INFO_PRINTF2(KInfo, bufsize ); |
|
3950 |
|
3951 struct sockaddr_in addr; |
|
3952 memset(&addr, 0, sizeof(addr)); |
|
3953 addr.sin_family = AF_INET; |
|
3954 addr.sin_addr.s_addr = htonl(INADDR_LOOPBACK); |
|
3955 addr.sin_port = htons(serverport); |
|
3956 unsigned int addrlen = sizeof(addr); |
|
3957 int written = sendto(client_sockfd, writedata, bufsize, 0,(struct sockaddr*)&addr,sizeof(addr)); |
|
3958 _LIT(KErr,"error no is %d\n"); |
|
3959 INFO_PRINTF2(KErr,errno); |
|
3960 int receive = recvfrom(server_sockfd,rcvdata, bufsize, 0,(struct sockaddr *)&addr,&addrlen); |
|
3961 if (receive < 0) |
|
3962 { |
|
3963 ret = KReadError; |
|
3964 } |
|
3965 if(written != -1) |
|
3966 { |
|
3967 if(written == receive ) |
|
3968 { |
|
3969 INFO_PRINTF1(_L("Test Passed")); |
|
3970 ret = KErrNone; |
|
3971 } |
|
3972 else |
|
3973 { |
|
3974 INFO_PRINTF1(_L("Test Failed")); |
|
3975 ret = KErrGeneral; |
|
3976 } |
|
3977 } |
|
3978 else if( written == -1 && errno == EAGAIN) |
|
3979 { |
|
3980 INFO_PRINTF1(_L("Test Passed")); |
|
3981 ret = KErrNone; |
|
3982 } |
|
3983 else |
|
3984 { |
|
3985 INFO_PRINTF1(_L("Test Failed")); |
|
3986 ret = KErrGeneral; |
|
3987 } |
|
3988 |
|
3989 free(writedata); |
|
3990 free(rcvdata); |
|
3991 // Close sockets |
|
3992 close( server_sockfd ); |
|
3993 close( client_sockfd ); |
|
3994 |
|
3995 #if defined( __SYMBIAN32__ ) && defined ( __WINSCW__ ) |
|
3996 CloseInterface( "Ethernet with Daemon Dynamic IP" ); |
|
3997 #endif |
|
3998 |
|
3999 return ret; |
|
4000 } |
|
4001 |
|
4002 size_t bytesAvail( int client_sockfd ) |
|
4003 { |
|
4004 size_t nbytes = 0; |
|
4005 |
|
4006 ioctl(client_sockfd, FIONREAD, (char *) &nbytes); |
|
4007 return nbytes; |
|
4008 } |
|
4009 |
|
4010 TInt CTestSocket::TestFionread() |
|
4011 { |
|
4012 int server_sockfd = ::socket( AF_INET, SOCK_DGRAM, IPPROTO_UDP); |
|
4013 TInt ret = KErrNone; |
|
4014 struct sockaddr_in servaddr; |
|
4015 servaddr.sin_family = AF_INET; |
|
4016 servaddr.sin_addr.s_addr = htonl(INADDR_ANY); |
|
4017 servaddr.sin_port = htons(0); |
|
4018 int err = ::bind(server_sockfd,(struct sockaddr*)&servaddr,sizeof(servaddr)); |
|
4019 if( err == -1 ) |
|
4020 INFO_PRINTF3(_L( " ...bind failed: err = %d, errno = %d\n"), err, errno ); |
|
4021 struct sockaddr_in sa; |
|
4022 struct sockaddr *sockAddrPtr = (struct sockaddr *) &sa; |
|
4023 |
|
4024 socklen_t sockAddrSize = sizeof(sa); |
|
4025 |
|
4026 memset(&sa, 0, sizeof(sa)); |
|
4027 int serverport = 0; |
|
4028 if (getsockname(server_sockfd, sockAddrPtr, &sockAddrSize) == 0 ) |
|
4029 { |
|
4030 serverport = ntohs(sa.sin_port); |
|
4031 INFO_PRINTF2(_L( " ...Listening port: %d\n"), serverport ); |
|
4032 } |
|
4033 int client_sockfd; |
|
4034 client_sockfd = socket(AF_INET,SOCK_DGRAM,IPPROTO_UDP); |
|
4035 const int bufsize = 1000; |
|
4036 char writedata[bufsize]; |
|
4037 memset(writedata, '@', bufsize); |
|
4038 |
|
4039 struct sockaddr_in addr; |
|
4040 memset(&addr, 0, sizeof(addr)); |
|
4041 addr.sin_family = AF_INET; |
|
4042 addr.sin_addr.s_addr = htonl(INADDR_LOOPBACK); |
|
4043 addr.sin_port = htons(serverport); |
|
4044 |
|
4045 int written = ::sendto(client_sockfd, writedata, bufsize, 0,(struct sockaddr*)&addr,sizeof(addr)+1); |
|
4046 fd_set fds; |
|
4047 FD_ZERO(&fds); |
|
4048 FD_SET(server_sockfd, &fds); |
|
4049 |
|
4050 const int timeout = 5000; // 5 seconds |
|
4051 |
|
4052 struct timeval tv; |
|
4053 tv.tv_sec = timeout / 1000; |
|
4054 tv.tv_usec = (timeout % 1000) * 1000; |
|
4055 |
|
4056 int selectRet = select(server_sockfd + 1, &fds, 0, 0, &tv ); |
|
4057 |
|
4058 size_t avail = bytesAvail( server_sockfd ); |
|
4059 |
|
4060 |
|
4061 close( server_sockfd ); |
|
4062 close( client_sockfd ); |
|
4063 |
|
4064 if(avail == 1028) |
|
4065 { |
|
4066 INFO_PRINTF1(_L( "Test Case passed \n")); |
|
4067 } |
|
4068 else |
|
4069 { |
|
4070 INFO_PRINTF1(_L( "Test Case passed \n")); |
|
4071 ret = KErrGeneral; |
|
4072 } |
|
4073 return ret; |
|
4074 } |
|
4075 TInt CTestSocket::TestBind1() |
|
4076 { |
|
4077 TInt ret = KErrNone; |
|
4078 int sock_fd1, sock_fd2; |
|
4079 sock_fd1 = socket(AF_INET,SOCK_STREAM,IPPROTO_TCP); |
|
4080 sock_fd2 = socket(AF_INET,SOCK_STREAM,IPPROTO_TCP); |
|
4081 |
|
4082 |
|
4083 struct sockaddr_in sockAddrIPv4; |
|
4084 struct sockaddr *sockAddrPtr = 0; |
|
4085 socklen_t sockAddrSize = 0; |
|
4086 memset(&sockAddrIPv4, 0, sizeof(sockAddrIPv4)); |
|
4087 sockAddrIPv4.sin_family = AF_INET; |
|
4088 sockAddrIPv4.sin_port = htons(31180); |
|
4089 sockAddrIPv4.sin_addr.s_addr = inet_addr("0.0.0.0"); |
|
4090 sockAddrSize = sizeof(sockAddrIPv4); |
|
4091 sockAddrPtr = (struct sockaddr *) &sockAddrIPv4; |
|
4092 |
|
4093 int bindResult1 = ::bind(sock_fd1, sockAddrPtr, sockAddrSize); |
|
4094 if( bindResult1 == -1 ) |
|
4095 { |
|
4096 INFO_PRINTF2(_L("Bind1 Failed with errno %d"),errno); |
|
4097 ret = KErrGeneral; |
|
4098 } |
|
4099 else |
|
4100 { |
|
4101 INFO_PRINTF1(_L("Bind1 Passed")); |
|
4102 } |
|
4103 errno = 0; |
|
4104 int bindResult2 = ::bind(sock_fd2, sockAddrPtr, sockAddrSize); |
|
4105 if( bindResult2 == -1 && errno == EADDRINUSE) |
|
4106 { |
|
4107 INFO_PRINTF1(_L("Bind2 Passed")); |
|
4108 } |
|
4109 else |
|
4110 { |
|
4111 INFO_PRINTF2(_L("Bind2 Failed with errno %d"),errno); |
|
4112 ret = KErrGeneral; |
|
4113 } |
|
4114 |
|
4115 close( sock_fd1 ); |
|
4116 close( sock_fd2 ); |
|
4117 return ret; |
|
4118 } |
|
4119 |
|
4120 /* Test connect() using a non-blocking socket. Tests the value returned |
|
4121 * when a duplicate connect is issued when the previous connect is already |
|
4122 * in progress. |
|
4123 */ |
|
4124 TInt CTestSocket::TestConnectNonBlocking( ) |
|
4125 { |
|
4126 int flags; |
|
4127 int serverSock; |
|
4128 int serverPort; |
|
4129 int ret = 0; |
|
4130 |
|
4131 //Create server socket |
|
4132 serverSock = socket( AF_INET, SOCK_STREAM, IPPROTO_TCP ); |
|
4133 if( serverSock < 0 ) |
|
4134 return KErrSocket; |
|
4135 |
|
4136 //Set the server socket in non blocking mode |
|
4137 flags = fcntl( serverSock, F_GETFL, 0 ); |
|
4138 if ( flags < 0 ) |
|
4139 { |
|
4140 close( serverSock ); |
|
4141 return KErrGetSockOpt; |
|
4142 } |
|
4143 |
|
4144 if ( fcntl( serverSock, F_SETFL, flags | O_NONBLOCK ) < 0 ) |
|
4145 { |
|
4146 close( serverSock ); |
|
4147 return KErrGetSockOpt; |
|
4148 } |
|
4149 |
|
4150 //Bind the server socket |
|
4151 struct sockaddr_in addr; |
|
4152 addr.sin_family = AF_INET; |
|
4153 addr.sin_addr.s_addr = htonl( INADDR_ANY ); |
|
4154 addr.sin_port = htons( 0 ); |
|
4155 if( bind( serverSock, ( struct sockaddr* ) &addr, sizeof( addr ) ) < 0 ) |
|
4156 { |
|
4157 close( serverSock ); |
|
4158 return KErrBind; |
|
4159 } |
|
4160 |
|
4161 //Listen server socket |
|
4162 if( listen( serverSock, 1 ) < 0 ) |
|
4163 { |
|
4164 close( serverSock ); |
|
4165 return KErrListen; |
|
4166 } |
|
4167 |
|
4168 //Get the bind port number |
|
4169 struct sockaddr_in sa; |
|
4170 socklen_t sockAddrSize = sizeof( sa ); |
|
4171 memset(&sa, 0, sizeof(sa)); |
|
4172 |
|
4173 if( getsockname( serverSock, ( struct sockaddr * ) &sa, &sockAddrSize ) < 0 ) |
|
4174 { |
|
4175 close( serverSock ); |
|
4176 return KErrBind; |
|
4177 } |
|
4178 serverPort = ntohs( sa.sin_port ); |
|
4179 |
|
4180 //Create client socket |
|
4181 int clientSock = socket( AF_INET, SOCK_STREAM, IPPROTO_TCP); |
|
4182 |
|
4183 //Set the client socket in non blocking mode |
|
4184 flags = fcntl( clientSock, F_GETFL, 0 ); |
|
4185 if ( flags < 0 ) |
|
4186 { |
|
4187 close( serverSock ); |
|
4188 close( clientSock ); |
|
4189 return KErrGetSockOpt; |
|
4190 } |
|
4191 |
|
4192 if ( fcntl( clientSock, F_SETFL, flags | O_NONBLOCK ) < 0 ) |
|
4193 { |
|
4194 close( serverSock ); |
|
4195 close( clientSock ); |
|
4196 return KErrGetSockOpt; |
|
4197 } |
|
4198 |
|
4199 //Connect to the server |
|
4200 struct sockaddr_in servAddr; |
|
4201 servAddr.sin_family = AF_INET; |
|
4202 servAddr.sin_addr.s_addr = htonl( INADDR_LOOPBACK ); |
|
4203 servAddr.sin_port = htons( serverPort ); |
|
4204 ret = connect( clientSock,( struct sockaddr* ) &servAddr, sizeof( servAddr ) ); |
|
4205 //This should return -1 |
|
4206 if( ret != -1 || errno != EINPROGRESS ) |
|
4207 { |
|
4208 close( serverSock ); |
|
4209 close( clientSock ); |
|
4210 return KErrConnect; |
|
4211 } |
|
4212 |
|
4213 //Try connecting the client multiple times before the server accpets |
|
4214 ret = connect( clientSock,( struct sockaddr* ) &servAddr, sizeof( servAddr ) ); |
|
4215 //This should return -1 |
|
4216 if( ret != -1 ) |
|
4217 { |
|
4218 close( serverSock ); |
|
4219 close( clientSock ); |
|
4220 return KErrConnect; |
|
4221 } |
|
4222 //Try again.. |
|
4223 ret = connect( clientSock,( struct sockaddr* ) &servAddr, sizeof( servAddr ) ); |
|
4224 //This should return -1 |
|
4225 if( ret != -1 ) |
|
4226 { |
|
4227 close( serverSock ); |
|
4228 close( clientSock ); |
|
4229 return KErrConnect; |
|
4230 } |
|
4231 |
|
4232 //Accept the server sock |
|
4233 int newSock; |
|
4234 struct sockaddr acceptAddr; |
|
4235 unsigned int addrLen = sizeof( acceptAddr ); |
|
4236 newSock = accept( serverSock, &acceptAddr, &addrLen ); |
|
4237 if( newSock < 0 ) |
|
4238 { |
|
4239 close( serverSock ); |
|
4240 close( clientSock ); |
|
4241 return KErrAccept; |
|
4242 } |
|
4243 |
|
4244 //Try connect again (now the socket is connected |
|
4245 ret = connect( clientSock,( struct sockaddr* ) &servAddr, sizeof( servAddr ) ); |
|
4246 //This should return -1 |
|
4247 if( ret != -1 ) |
|
4248 { |
|
4249 close( newSock ); |
|
4250 close( serverSock ); |
|
4251 close( clientSock ); |
|
4252 return KErrConnect; |
|
4253 } |
|
4254 |
|
4255 //Send some data |
|
4256 const int bufSize = 50; |
|
4257 char writeData[bufSize]; |
|
4258 char readData[bufSize]; |
|
4259 memset( writeData, '@', bufSize ); |
|
4260 |
|
4261 if( write( newSock, writeData, bufSize ) < 0 ) |
|
4262 { |
|
4263 close( newSock ); |
|
4264 close( serverSock ); |
|
4265 close( clientSock ); |
|
4266 return KWriteError; |
|
4267 } |
|
4268 |
|
4269 //Wait for the data in client using select |
|
4270 fd_set fds; |
|
4271 FD_ZERO(&fds); |
|
4272 FD_SET(clientSock, &fds); |
|
4273 |
|
4274 struct timeval tv; |
|
4275 tv.tv_sec = 10; //10 seconds |
|
4276 tv.tv_usec = 0; |
|
4277 |
|
4278 if( select( clientSock + 1, &fds, 0, 0, &tv ) <= 0 ) |
|
4279 { |
|
4280 close( serverSock ); |
|
4281 close( clientSock ); |
|
4282 return KErrGetSockOpt; |
|
4283 } |
|
4284 |
|
4285 //Now, try reading the data |
|
4286 if( recv( clientSock, ( void* ) readData, bufSize, 0 ) < 0 ) |
|
4287 { |
|
4288 close( newSock ); |
|
4289 close( serverSock ); |
|
4290 close( clientSock ); |
|
4291 return KErrRead; |
|
4292 } |
|
4293 |
|
4294 close( clientSock ); |
|
4295 close( newSock ); |
|
4296 close( serverSock ); |
|
4297 return KErrNone; |
|
4298 } |
|
4299 |
|
4300 |
|
4301 |
|
4302 TInt CTestSocket::TCP1( ) |
|
4303 { |
|
4304 int sock_fd,newsock_fd; |
|
4305 int error; |
|
4306 unsigned int addr_len, serv_len; |
|
4307 sockaddr_in serv_addr,new_socket; |
|
4308 TInt ret = KErrNone; |
|
4309 |
|
4310 sock_fd = socket(AF_INET,SOCK_STREAM,0); |
|
4311 if (sock_fd < 0) |
|
4312 { |
|
4313 return KErrSocket; |
|
4314 } |
|
4315 serv_addr.sin_family = AF_INET; |
|
4316 serv_addr.sin_addr.s_addr = htonl(INADDR_ANY); |
|
4317 serv_addr.sin_port = 0; |
|
4318 pthread_t testThread; |
|
4319 int threadRetVal; |
|
4320 void *threadRetValPtr = (void*)&threadRetVal; |
|
4321 |
|
4322 if (bind(sock_fd,(sockaddr*)&serv_addr,sizeof(serv_addr)) < 0) |
|
4323 { |
|
4324 ret = KErrBind; |
|
4325 goto close; |
|
4326 } |
|
4327 serv_len = sizeof(serv_addr); |
|
4328 if (getsockname(sock_fd, (sockaddr*)&serv_addr, &serv_len) < 0) |
|
4329 { |
|
4330 ret = KErrGetSockName; |
|
4331 goto close; |
|
4332 } |
|
4333 |
|
4334 if (listen(sock_fd,1) < 0) |
|
4335 { |
|
4336 ret = KErrListen; |
|
4337 goto close; |
|
4338 } |
|
4339 |
|
4340 addr_len = sizeof(new_socket); |
|
4341 |
|
4342 // Create the thread and thread is client code |
|
4343 pthread_create(&testThread, NULL, &TCPThread1, (void*)(serv_addr.sin_port)); |
|
4344 |
|
4345 newsock_fd = accept(sock_fd,(sockaddr*)&new_socket,&addr_len); // Code blocks here |
|
4346 error = write1(newsock_fd); |
|
4347 if (error < 0) |
|
4348 { |
|
4349 ret = error; |
|
4350 goto close; |
|
4351 } |
|
4352 |
|
4353 close: |
|
4354 pthread_join(testThread, &threadRetValPtr); |
|
4355 shutdown(sock_fd,SHUT_RDWR); |
|
4356 close(sock_fd); |
|
4357 return ret; |
|
4358 } |
|
4359 |
|
4360 |
|
4361 |
|
4362 int write1(int sock_fd) |
|
4363 { |
|
4364 char line[KMaxLine]; |
|
4365 |
|
4366 char character = 'A'; |
|
4367 unsigned int cnt = 0; |
|
4368 for(; cnt < KMaxLine - 1; cnt++) |
|
4369 { |
|
4370 line[cnt] = character; |
|
4371 character++; |
|
4372 if (character > 'Z') |
|
4373 { |
|
4374 character = 'A'; |
|
4375 } |
|
4376 } |
|
4377 line[cnt] = '\0'; |
|
4378 if (send(sock_fd,line,KMaxLine,0) < 0) |
|
4379 { |
|
4380 return KWriteError; |
|
4381 } |
|
4382 |
|
4383 return KErrNone; |
|
4384 } |
|
4385 |
|
4386 static void* TCPThread1(TAny* aParam) |
|
4387 { |
|
4388 sockaddr_in serv_addr; |
|
4389 int sock_fd,ret; |
|
4390 char line[KMaxLine ]; |
|
4391 |
|
4392 serv_addr.sin_family = AF_INET; |
|
4393 serv_addr.sin_addr.s_addr = htonl(INADDR_LOOPBACK); |
|
4394 serv_addr.sin_port = (int)aParam; |
|
4395 |
|
4396 sock_fd = socket(AF_INET,SOCK_STREAM,0); |
|
4397 if (sock_fd < 0) |
|
4398 { |
|
4399 goto close; |
|
4400 } |
|
4401 if (connect(sock_fd,(sockaddr*)&serv_addr,sizeof(serv_addr)) < 0) |
|
4402 { |
|
4403 goto close; |
|
4404 } |
|
4405 if (read1(sock_fd,line) < 0) |
|
4406 { |
|
4407 goto close; |
|
4408 } |
|
4409 errno = 0; |
|
4410 ret = connect(sock_fd,(sockaddr*)&serv_addr,sizeof(serv_addr)); |
|
4411 if(ret != -1 && errno != EISCONN) |
|
4412 { |
|
4413 goto close; |
|
4414 } |
|
4415 |
|
4416 close: |
|
4417 close(sock_fd); |
|
4418 return (void*)NULL; |
|
4419 } |
|
4420 |
|
4421 |
|
4422 |
|
4423 int read1(int newsock_fd,char *line) |
|
4424 { |
|
4425 int ret; |
|
4426 int left = KMaxLine; |
|
4427 |
|
4428 while (1) |
|
4429 { |
|
4430 |
|
4431 ret = recv(newsock_fd,line,left,0); |
|
4432 |
|
4433 if (ret < 0) |
|
4434 { |
|
4435 return KReadError; |
|
4436 } |
|
4437 else if (ret == 0) |
|
4438 { |
|
4439 break; |
|
4440 } |
|
4441 left -= ret; |
|
4442 line += ret; |
|
4443 if (left <= 0) |
|
4444 { |
|
4445 break; |
|
4446 } |
|
4447 } |
|
4448 return KErrNone; |
|
4449 } |
|
4450 |
|
4451 /* |
|
4452 * Test the ip address mapping to sockaddr_in structure |
|
4453 * when the native code returns the address in ipv4 mapped |
|
4454 * ipv6 format. |
|
4455 */ |
|
4456 TInt CTestSocket::TestV4MappedAddress() |
|
4457 { |
|
4458 const char* localIP = "127.0.0.1"; |
|
4459 |
|
4460 int sock = socket( AF_INET, SOCK_DGRAM, IPPROTO_UDP ); |
|
4461 if( sock < 0 ) |
|
4462 { |
|
4463 ERR_PRINTF2(_L("socket() Failed, errno = %d"), errno); |
|
4464 return KErrGeneral; |
|
4465 } |
|
4466 |
|
4467 const int bufSize = 5; |
|
4468 char writeData[bufSize]; |
|
4469 |
|
4470 //Send a packet to the loopback address. The sender socket will |
|
4471 //have the local host ip when queried using getsockname(). This |
|
4472 //ip is returned by the native API in the ipv6 (ipv4 mapped) format. |
|
4473 |
|
4474 struct sockaddr_in sendAddr; |
|
4475 memset(&sendAddr, 0, sizeof(sendAddr)); |
|
4476 sendAddr.sin_family = AF_INET; |
|
4477 sendAddr.sin_addr.s_addr = htonl(INADDR_LOOPBACK); |
|
4478 sendAddr.sin_port = htons( 2222 ); |
|
4479 if(sendto(sock, writeData, bufSize, 0, (struct sockaddr*) &sendAddr, sizeof( sendAddr )) < 0) |
|
4480 { |
|
4481 ERR_PRINTF2(_L("sendto() Failed, errno = %d"), errno); |
|
4482 close( sock ); |
|
4483 return KErrGeneral; |
|
4484 } |
|
4485 |
|
4486 struct sockaddr_in localAddr; |
|
4487 unsigned int sizeAddr = sizeof(localAddr); |
|
4488 if(getsockname(sock,(struct sockaddr*) &localAddr, &sizeAddr) != 0) |
|
4489 { |
|
4490 ERR_PRINTF2(_L("getsockname() Failed, errno = %d"), errno); |
|
4491 close( sock ); |
|
4492 return KErrGeneral; |
|
4493 } |
|
4494 |
|
4495 if(strcmp(inet_ntoa(localAddr.sin_addr), localIP) != 0) |
|
4496 { |
|
4497 ERR_PRINTF1(_L("getsockname() did not retrieve the local host address")); |
|
4498 close( sock ); |
|
4499 return KErrGeneral; |
|
4500 } |
|
4501 |
|
4502 close( sock ); |
|
4503 return KErrNone; |
|
4504 } |
|
4505 |
|
4506 void * myclie1(void* pv) |
|
4507 { |
|
4508 doClient1(5000,(int)pv); |
|
4509 return 0; |
|
4510 } |
|
4511 |
|
4512 void * myserv1(void* /* pv */) |
|
4513 { |
|
4514 doServer1(5000); |
|
4515 return 0; |
|
4516 } |
|
4517 |
|
4518 int doServer1(int port) |
|
4519 { |
|
4520 int s = socket(PF_INET, SOCK_STREAM, IPPROTO_TCP); |
|
4521 if (s < 0) |
|
4522 { |
|
4523 printf("[S] Create Tcp socket fail\n"); |
|
4524 flag++; |
|
4525 return -1; |
|
4526 } |
|
4527 // reuseaddr |
|
4528 int set = 1; |
|
4529 setsockopt(s, SOL_SOCKET, SO_REUSEADDR, &set, sizeof(set)); |
|
4530 |
|
4531 int result = -1; |
|
4532 struct sockaddr_in addr; |
|
4533 addr.sin_family = AF_INET; |
|
4534 addr.sin_port = htons(port); |
|
4535 addr.sin_addr.s_addr = htonl(INADDR_ANY); |
|
4536 |
|
4537 do |
|
4538 { |
|
4539 int ret = bind(s, (struct sockaddr*) &addr, sizeof(addr)); |
|
4540 if (ret < 0) |
|
4541 { |
|
4542 printf("[S] server bind fail %d\n", errno); |
|
4543 flag++; |
|
4544 break; |
|
4545 } |
|
4546 |
|
4547 ret = listen(s, 2); |
|
4548 if (ret < 0) |
|
4549 { |
|
4550 printf("[S] listen fail %d\n", errno); |
|
4551 flag++; |
|
4552 break; |
|
4553 } |
|
4554 |
|
4555 socklen_t len = sizeof(addr); |
|
4556 int cli = accept(s, (struct sockaddr*) &addr, &len); |
|
4557 if (cli < 0) |
|
4558 { |
|
4559 printf("[S] accept fail %d\n", errno); |
|
4560 flag++; |
|
4561 break; |
|
4562 } |
|
4563 |
|
4564 char buff[10]; |
|
4565 ret = read(cli, buff, 10); |
|
4566 if (ret < 0) |
|
4567 { |
|
4568 printf("[S] read data from socket fail %d\n", errno); |
|
4569 close(cli); |
|
4570 flag++; |
|
4571 break; |
|
4572 } |
|
4573 else |
|
4574 { |
|
4575 printf("[S] read data from socket %d bytes\n", ret); |
|
4576 } |
|
4577 |
|
4578 ret = write(cli, buff, ret); |
|
4579 if (ret < 0) |
|
4580 { |
|
4581 printf("[S] write data on socket fail %d\n", errno); |
|
4582 close(cli); |
|
4583 flag++; |
|
4584 break; |
|
4585 } |
|
4586 else |
|
4587 { |
|
4588 printf("[S] write data on socket %d bytes\n", ret); |
|
4589 } |
|
4590 sleep(2); |
|
4591 printf("[S] socket closed\n"); |
|
4592 close(cli); |
|
4593 result =0; |
|
4594 } |
|
4595 while (0); |
|
4596 close(s); |
|
4597 return result; |
|
4598 } |
|
4599 |
|
4600 int doClient1(int port, int size) |
|
4601 { |
|
4602 sleep(1); |
|
4603 int c = socket(PF_INET, SOCK_STREAM, IPPROTO_TCP); |
|
4604 if (c < 0) |
|
4605 { |
|
4606 printf("[C] Create Tcp socket fail\n"); |
|
4607 flag++; |
|
4608 return -1; |
|
4609 } |
|
4610 |
|
4611 int result = -1; |
|
4612 |
|
4613 struct sockaddr_in addr; |
|
4614 addr.sin_family = AF_INET; |
|
4615 addr.sin_port = htons(port); |
|
4616 addr.sin_addr.s_addr = htonl(INADDR_LOOPBACK); |
|
4617 |
|
4618 do |
|
4619 { |
|
4620 int ret = connect(c, (struct sockaddr*) &addr, sizeof(addr)); |
|
4621 if (ret < 0) |
|
4622 { |
|
4623 printf("[C] connect to server fail %d\n", errno); |
|
4624 flag++; |
|
4625 break; |
|
4626 } |
|
4627 |
|
4628 ret = write(c, safdata, 5); |
|
4629 if (ret < 0) |
|
4630 { |
|
4631 printf("[C] write data on socket fail %d\n", errno); |
|
4632 flag++; |
|
4633 break; |
|
4634 } |
|
4635 printf("[C] write on socket %d bytes\n", ret); |
|
4636 char buff[10]; |
|
4637 char* p = buff; |
|
4638 |
|
4639 do |
|
4640 { |
|
4641 int left = size + buff - p; |
|
4642 if( left == 0 ) |
|
4643 left = 1; |
|
4644 ret = read(c, p, left ); |
|
4645 if (ret < 0) |
|
4646 { |
|
4647 printf("[C] read data from socket fail %d\n", errno); |
|
4648 flag++; |
|
4649 break; |
|
4650 } |
|
4651 else |
|
4652 { |
|
4653 printf("[C] read from socket %d bytes\n", ret); |
|
4654 p += ret; |
|
4655 } |
|
4656 } |
|
4657 while (ret > 0); |
|
4658 // compare data |
|
4659 int len = p - buff; |
|
4660 if (len != 5 || memcmp(buff, safdata, 5) != 0) |
|
4661 { |
|
4662 printf("[C] read data unmatch, length is %d/%d\n", len, 5); |
|
4663 flag++; |
|
4664 break; |
|
4665 } |
|
4666 result = 0; |
|
4667 } |
|
4668 while (0); |
|
4669 close(c); |
|
4670 |
|
4671 return result; |
|
4672 } |
|
4673 |
|
4674 TInt CTestSocket::ReadTestFailCase() |
|
4675 { |
|
4676 pthread_t t[2]; |
|
4677 pthread_create((unsigned int *)&t[0], (pthread_attr_t *)NULL,myserv1, (void *)0); |
|
4678 pthread_create((unsigned int *)&t[1], (pthread_attr_t *)NULL, myclie1, (void *)10); |
|
4679 |
|
4680 pthread_join(t[0],0); |
|
4681 pthread_join(t[1],0); |
|
4682 if(flag == 0) |
|
4683 return KErrNone; |
|
4684 return KErrGeneral; |
|
4685 } |
|
4686 /* |
|
4687 * Test code to verify the fix for DEF128776. |
|
4688 * Scenario: On a connected socket, one thread makes a write |
|
4689 * and another thread reads after a select. |
|
4690 */ |
|
4691 static void* Create_connection(void* /*aParam*/) |
|
4692 { |
|
4693 // Only make a write on the sock_fd |
|
4694 int ret; |
|
4695 struct sockaddr_in host; |
|
4696 int dest_fd; |
|
4697 char buf[50]; |
|
4698 host.sin_port = htons(5002); |
|
4699 host.sin_family = AF_INET; |
|
4700 host.sin_addr.s_addr = inet_addr("127.0.0.1"); |
|
4701 dest_fd = socket(AF_INET,SOCK_STREAM,0); |
|
4702 ret = connect(dest_fd,(struct sockaddr*)&host,sizeof(host)); |
|
4703 ret = read(dest_fd,buf,sizeof(buf)); |
|
4704 ret = write(dest_fd,buf,ret); |
|
4705 close(dest_fd); |
|
4706 return NULL; |
|
4707 } |
|
4708 |
|
4709 static void* socket_write(void* aSock) |
|
4710 { |
|
4711 int *sock_fd = (int*)aSock; |
|
4712 char buf[] = "Write from second thread"; |
|
4713 int ret = write(*sock_fd,buf,sizeof(buf)); |
|
4714 if (ret < 0) |
|
4715 { |
|
4716 exit(1); |
|
4717 } |
|
4718 return NULL; |
|
4719 } |
|
4720 |
|
4721 TInt CTestSocket::TestNotify1() |
|
4722 { |
|
4723 int ret; |
|
4724 pthread_t client,sockwrite; |
|
4725 char buf[50]; |
|
4726 fd_set fds; |
|
4727 FD_ZERO(&fds); |
|
4728 int sock_fd; |
|
4729 int listen_sock = socket(AF_INET,SOCK_STREAM,0); |
|
4730 struct sockaddr_in host,dest; |
|
4731 host.sin_port = htons(5002); |
|
4732 host.sin_family = AF_INET; |
|
4733 host.sin_addr.s_addr = inet_addr("127.0.0.1"); |
|
4734 ret = bind(listen_sock,(struct sockaddr*)&host,sizeof(host)); |
|
4735 if(ret<0) |
|
4736 { |
|
4737 INFO_PRINTF1(_L("Error in bind\n")); |
|
4738 return -1; |
|
4739 } |
|
4740 ret = listen(listen_sock,1); |
|
4741 if(ret<0) |
|
4742 { |
|
4743 INFO_PRINTF1(_L("Error in listen\n")); |
|
4744 return -1; |
|
4745 } |
|
4746 unsigned size = sizeof(host); |
|
4747 ret = pthread_create(&client,(pthread_attr_t*)NULL,&Create_connection,NULL); |
|
4748 if(ret<0) |
|
4749 { |
|
4750 INFO_PRINTF2(_L("Error creating thread:%d\n"),errno); |
|
4751 exit(1); |
|
4752 } |
|
4753 // This socket monitored by 2 threads - one for read, and one for write. |
|
4754 sock_fd = accept(listen_sock,(struct sockaddr*)&dest,&size); |
|
4755 close(listen_sock); |
|
4756 // Spawn the write thread. |
|
4757 ret = pthread_create(&sockwrite,(pthread_attr_t*)NULL,&socket_write,&sock_fd); |
|
4758 if(ret<0) |
|
4759 { |
|
4760 INFO_PRINTF2(_L("Error creating thread:%d\n"),errno); |
|
4761 return -1; |
|
4762 } |
|
4763 // Read thread. |
|
4764 FD_SET(sock_fd,&fds); |
|
4765 ret = select(sock_fd+1,&fds,NULL,NULL,NULL); |
|
4766 if (ret && FD_ISSET(sock_fd,&fds)) |
|
4767 { |
|
4768 ret = read(sock_fd,buf,sizeof(buf)); |
|
4769 TPtr8 ptr((TText8 *)buf, ret); |
|
4770 } |
|
4771 ret = pthread_join(sockwrite,(void**)NULL); |
|
4772 ret = pthread_join(client,(void**)NULL); |
|
4773 close(sock_fd); |
|
4774 return KErrNone; |
|
4775 } |
|
4776 |
|
4777 TInt CTestSocket::TestSockFcntl() |
|
4778 { |
|
4779 // Socket code |
|
4780 // ============ |
|
4781 INFO_PRINTF1(_L("Creating and initializing socket\n")); |
|
4782 int sockfd = socket(AF_INET,SOCK_DGRAM,IPPROTO_UDP); |
|
4783 |
|
4784 INFO_PRINTF1(_L("Configuring socket to non-blocking\n")); |
|
4785 int flags1; |
|
4786 int flags = fcntl(sockfd, F_GETFL, 0); |
|
4787 if (flags == -1) |
|
4788 { |
|
4789 INFO_PRINTF1(_L("fcntl(F_GETFL) FAILED\n")); |
|
4790 return KErrGeneral; |
|
4791 } |
|
4792 flags = flags | O_NONBLOCK; |
|
4793 if ((flags1 = fcntl(sockfd, F_SETFL, flags)) == -1) |
|
4794 { |
|
4795 INFO_PRINTF1(_L("Make the socket nonblocking FAILED\n")); |
|
4796 return KErrGeneral; |
|
4797 } |
|
4798 |
|
4799 if(flags1 != (flags & (O_APPEND|O_NONBLOCK|O_SYNC|O_ACCMODE))) |
|
4800 { |
|
4801 INFO_PRINTF1(_L("fcntl returned wrong flag values\n")); |
|
4802 return KErrGeneral; |
|
4803 } |
|
4804 |
|
4805 close(sockfd); |
|
4806 return KErrNone; |
|
4807 } |
|
4808 |
|
4809 //#warning Replace with correct iap name |
|
4810 const char* g_IapName = "Ethernet with Daemon Dynamic IP"; |
|
4811 //#warning Use proper ip |
|
4812 const char* g_Ip = "10.192.204.41"; |
|
4813 |
|
4814 TInt CTestSocket::create_udp_socket(int port) |
|
4815 { |
|
4816 int s; |
|
4817 struct ifreq ifr; |
|
4818 int err = KErrNone; |
|
4819 |
|
4820 struct sockaddr_in host_address; |
|
4821 s=socket(PF_INET, SOCK_DGRAM, IPPROTO_UDP); |
|
4822 memset((void*)&host_address, 0, sizeof(host_address)); |
|
4823 host_address.sin_family=PF_INET; |
|
4824 host_address.sin_addr.s_addr=INADDR_ANY; |
|
4825 host_address.sin_port=htons(port); |
|
4826 |
|
4827 strcpy(ifr.ifr_name, g_IapName); |
|
4828 err = ioctl(s, SIOCSIFNAME, &ifr); |
|
4829 INFO_PRINTF2(_L("SIOCSIFNAME completed with %d\n"),err); |
|
4830 if(KErrNone != err) |
|
4831 { |
|
4832 return KErrGeneral; |
|
4833 } |
|
4834 err = ioctl(s, SIOCIFSTART, &ifr); |
|
4835 INFO_PRINTF2(_L("SIOCIFSTART completed with %d\n"),err); |
|
4836 if(KErrNone != err) |
|
4837 { |
|
4838 return KErrGeneral; |
|
4839 } |
|
4840 |
|
4841 err = bind(s, (struct sockaddr*)&host_address, sizeof(host_address)); |
|
4842 INFO_PRINTF2(_L("bind completed with %d\n"),err); |
|
4843 if(KErrNone != err) |
|
4844 { |
|
4845 return KErrGeneral; |
|
4846 } |
|
4847 return s; |
|
4848 } |
|
4849 |
|
4850 TInt CTestSocket::send_packet(int s) |
|
4851 { |
|
4852 int j; |
|
4853 char buffer[1000]; |
|
4854 struct sockaddr_in target_host_address; |
|
4855 |
|
4856 target_host_address.sin_family=PF_INET; |
|
4857 target_host_address.sin_port=htons(5000); |
|
4858 |
|
4859 if (inet_aton(g_Ip, &target_host_address.sin_addr)==0) |
|
4860 { |
|
4861 INFO_PRINTF1(_L("inet_aton() failed\n")); |
|
4862 return KErrGeneral; |
|
4863 } |
|
4864 |
|
4865 for (j = 0; j < 100; j++) { |
|
4866 buffer[j] = (unsigned char)((int) (255.0*rand()/(RAND_MAX+1.0))); |
|
4867 } |
|
4868 |
|
4869 return sendto(s, buffer, 100, 0, |
|
4870 (struct sockaddr*)&target_host_address, sizeof(struct sockaddr)); |
|
4871 } |
|
4872 |
|
4873 TInt CTestSocket::close_socket(int fd) |
|
4874 { |
|
4875 // (doesn't really matter if we call SIOCIFSTOP or not) |
|
4876 struct ifreq ifr; |
|
4877 int err = KErrNone; |
|
4878 strcpy(ifr.ifr_name, g_IapName); |
|
4879 err = ioctl(fd, SIOCSIFNAME, &ifr); |
|
4880 INFO_PRINTF2(_L("SIOCSIFNAME completed with %d\n"),err); |
|
4881 if(KErrNone != err) |
|
4882 { |
|
4883 return KErrGeneral; |
|
4884 } |
|
4885 err = ioctl(fd, SIOCIFSTOP, &ifr); |
|
4886 INFO_PRINTF2(_L("SIOCIFSTOP completed with %d\n"),err); |
|
4887 if(KErrNone != err) |
|
4888 { |
|
4889 return KErrGeneral; |
|
4890 } |
|
4891 |
|
4892 close(fd); |
|
4893 return err; |
|
4894 } |
|
4895 |
|
4896 TInt CTestSocket::TestSockIoctl() |
|
4897 { |
|
4898 int val; |
|
4899 int sockfd = -1; |
|
4900 int err = KErrNone; |
|
4901 |
|
4902 sockfd = create_udp_socket(6667); |
|
4903 if(sockfd < 0) |
|
4904 { |
|
4905 INFO_PRINTF2(_L("create_udp_socket returned %d\n"),sockfd); |
|
4906 return KErrGeneral; |
|
4907 } |
|
4908 val = send_packet(sockfd); |
|
4909 INFO_PRINTF2(_L("sent %d bytes\n"),val); |
|
4910 err = close_socket(sockfd); |
|
4911 if(KErrNone != err) |
|
4912 { |
|
4913 INFO_PRINTF2(_L("close_socket returned %d\n"),err); |
|
4914 return KErrGeneral; |
|
4915 } |
|
4916 |
|
4917 sleep(1); |
|
4918 |
|
4919 sockfd = -1; |
|
4920 sockfd = create_udp_socket(6667); |
|
4921 if(sockfd < 0) |
|
4922 { |
|
4923 INFO_PRINTF2(_L("create_udp_socket returned %d\n"),sockfd); |
|
4924 return KErrGeneral; |
|
4925 } |
|
4926 val = send_packet(sockfd); // Causes iap query dialog |
|
4927 INFO_PRINTF2(_L("sent %d bytes\n"),val); |
|
4928 err = close_socket(sockfd); |
|
4929 if(KErrNone != err) |
|
4930 { |
|
4931 INFO_PRINTF2(_L("close_socket returned %d\n"),err); |
|
4932 return KErrGeneral; |
|
4933 } |
|
4934 |
|
4935 return KErrNone; |
|
4936 } |
|
4937 |
|
4938 int sockfd1 = -1; |
|
4939 |
|
4940 int checkip() |
|
4941 { |
|
4942 int client_sockfd = socket( AF_INET, SOCK_STREAM, IPPROTO_TCP); |
|
4943 |
|
4944 struct sockaddr_in addr; |
|
4945 |
|
4946 addr.sin_family = AF_INET; |
|
4947 addr.sin_addr.s_addr = inet_addr( "198.133.219.25" ); |
|
4948 addr.sin_port = htons(80); |
|
4949 int err = connect(client_sockfd,(struct sockaddr*)&addr,sizeof(addr)); |
|
4950 |
|
4951 // Determine local port |
|
4952 struct sockaddr_in sa; |
|
4953 struct sockaddr *sockAddrPtr = (struct sockaddr *) &sa; |
|
4954 socklen_t sockAddrSize = sizeof(sa); |
|
4955 |
|
4956 memset(&sa, 0, sizeof(sa)); |
|
4957 if (getsockname(client_sockfd, sockAddrPtr, &sockAddrSize) == 0 ) |
|
4958 { |
|
4959 printf( " ...Listening IP: %s\n", inet_ntoa(sa.sin_addr)); |
|
4960 } |
|
4961 |
|
4962 shutdown( client_sockfd, SHUT_RDWR ); |
|
4963 close( client_sockfd ); |
|
4964 return 0; |
|
4965 } |
|
4966 |
|
4967 void* client_connection (void *a) |
|
4968 { |
|
4969 int *serverport; |
|
4970 serverport = (int *) a; /* type cast to a pointer to thdata */ |
|
4971 int ret; |
|
4972 struct sockaddr_in host; |
|
4973 int dest_fd; |
|
4974 char buf[50]; |
|
4975 strcpy(buf, "HelloWorld?"); |
|
4976 |
|
4977 host.sin_port = htons (*serverport); |
|
4978 host.sin_family = AF_INET; |
|
4979 host.sin_addr.s_addr = inet_addr ("10.253.2.197"); |
|
4980 |
|
4981 dest_fd = socket (AF_INET, SOCK_STREAM, IPPROTO_TCP); |
|
4982 ret = connect (dest_fd, (struct sockaddr *) &host, sizeof (host)); |
|
4983 if(ret!=0) |
|
4984 { |
|
4985 //this gives me KErrHostUnreach |
|
4986 printf("The connect returned with errno = %d\n", errno); |
|
4987 } |
|
4988 ret = write(dest_fd,buf,12); |
|
4989 if(ret < 0) |
|
4990 { |
|
4991 printf("write failed\n %d\n",errno); |
|
4992 } |
|
4993 else |
|
4994 { |
|
4995 printf("write passed %d\n",ret); |
|
4996 } |
|
4997 shutdown( dest_fd, SHUT_RDWR ); |
|
4998 close( dest_fd ); |
|
4999 return NULL; |
|
5000 } |
|
5001 |
|
5002 //ECONNRESET |
|
5003 TInt CTestSocket::SockErrnoTest() |
|
5004 { |
|
5005 #if defined( __SYMBIAN32__ ) && defined ( __WINSCW__ ) |
|
5006 OpenInterface( "Ethernet with Daemon Dynamic IP" ); |
|
5007 #endif |
|
5008 checkip(); |
|
5009 |
|
5010 int err = 0; |
|
5011 int server_sockfd = socket( AF_INET, SOCK_STREAM, IPPROTO_TCP); |
|
5012 |
|
5013 // Receive OOB data inline |
|
5014 int sockoptdata = 1; |
|
5015 err = setsockopt(server_sockfd, SOL_SOCKET, SO_OOBINLINE, (char *) &sockoptdata, sizeof(sockoptdata)); |
|
5016 if( err == -1 ) |
|
5017 { |
|
5018 INFO_PRINTF3(_L( " ...setsockopt(SO_OOBINLINE) failed: err = %d, errno = %d\n"), err, errno ); |
|
5019 } |
|
5020 |
|
5021 // Bind |
|
5022 struct sockaddr_in addr; |
|
5023 |
|
5024 addr.sin_family = AF_INET; |
|
5025 addr.sin_addr.s_addr = htonl(INADDR_ANY); |
|
5026 addr.sin_port = htons(0); |
|
5027 err = bind(server_sockfd,(struct sockaddr*)&addr,sizeof(addr)); |
|
5028 |
|
5029 // Listen |
|
5030 err = listen(server_sockfd,1); |
|
5031 |
|
5032 INFO_PRINTF1(_L( " ...Check local port we are listening\n" )); |
|
5033 |
|
5034 // Determine local port |
|
5035 struct sockaddr_in sa; |
|
5036 struct sockaddr *sockAddrPtr = (struct sockaddr *) &sa; |
|
5037 socklen_t sockAddrSize = sizeof(sa); |
|
5038 |
|
5039 memset(&sa, 0, sizeof(sa)); |
|
5040 int serverport; |
|
5041 if (getsockname(server_sockfd, sockAddrPtr, &sockAddrSize) == 0 ) |
|
5042 { |
|
5043 serverport = ntohs(sa.sin_port); |
|
5044 } |
|
5045 pthread_t client; |
|
5046 int pthread_ret = pthread_create (&client, (pthread_attr_t *) NULL, &client_connection, |
|
5047 (void *) &serverport); |
|
5048 |
|
5049 unsigned int addr_len; |
|
5050 int newsockfd = accept( server_sockfd, (sockaddr*)&newsockfd,&addr_len); |
|
5051 sleep(2); |
|
5052 shutdown( server_sockfd, SHUT_RDWR ); |
|
5053 close(server_sockfd); |
|
5054 |
|
5055 const int bufsize = 20000; |
|
5056 char readdata[bufsize]; |
|
5057 |
|
5058 int myerr = 0; |
|
5059 TInt ret = KErrNone; |
|
5060 while (myerr >= 0) |
|
5061 { |
|
5062 fd_set fds; |
|
5063 FD_ZERO(&fds); |
|
5064 FD_SET(newsockfd, &fds); |
|
5065 |
|
5066 const int timeout = 10000; |
|
5067 |
|
5068 struct timeval tv; |
|
5069 tv.tv_sec = timeout / 1000; |
|
5070 tv.tv_usec = (timeout % 1000) * 1000; |
|
5071 |
|
5072 int selectRet = select(newsockfd + 1, &fds, 0, 0, &tv ); |
|
5073 if( selectRet == 0 ) |
|
5074 { |
|
5075 myerr = -1; |
|
5076 INFO_PRINTF1(_L( " ...select time limit expired\n" )); |
|
5077 } |
|
5078 else |
|
5079 { |
|
5080 INFO_PRINTF2(_L( " ...Data available for reading (selectRet=%d): \n"), selectRet); |
|
5081 } |
|
5082 |
|
5083 size_t avail = bytesAvail( newsockfd ); |
|
5084 sleep(2); |
|
5085 int received = read( newsockfd, readdata, bufsize); |
|
5086 if( received == -1 ) |
|
5087 { |
|
5088 myerr = -1; |
|
5089 ret = errno; |
|
5090 INFO_PRINTF2(_L( " ...Read FAILED: errno %d\n"), errno ); |
|
5091 } |
|
5092 else |
|
5093 { |
|
5094 INFO_PRINTF2(_L( " ...%d of data received from socket\n"), received ); |
|
5095 if( received == 0 ) |
|
5096 { |
|
5097 myerr = -1; |
|
5098 ret = errno; |
|
5099 } |
|
5100 } |
|
5101 } |
|
5102 shutdown( newsockfd, SHUT_RDWR ); |
|
5103 close( newsockfd ); |
|
5104 |
|
5105 #if defined( __SYMBIAN32__ ) && defined ( __WINSCW__ ) |
|
5106 CloseInterface( "Ethernet with Daemon Dynamic IP" ); |
|
5107 #endif |
|
5108 if(ret!= ECONNRESET) |
|
5109 return ret; |
|
5110 else |
|
5111 return KErrNone; |
|
5112 } |
|
5113 |
|
5114 /* test case to check socket send() api over a broken connection |
|
5115 |
|
5116 expected result:If a socket client writes any data when the server side socket is closed, |
|
5117 then the send() api should return positive value for the first time and the next send() calls should fail returning -1. |
|
5118 */ |
|
5119 |
|
5120 |
|
5121 |
|
5122 void* create_socket( TAny* aParam ) |
|
5123 { |
|
5124 sockaddr_in serv_addr; |
|
5125 int err1; |
|
5126 int ret = 0; |
|
5127 char *msg ="testing socket send"; |
|
5128 int sock_fd; |
|
5129 serv_addr.sin_family = AF_INET; |
|
5130 serv_addr.sin_addr.s_addr = inet_addr("127.0.0.1"); |
|
5131 serv_addr.sin_port = (int)aParam; |
|
5132 sock_fd = socket(AF_INET,SOCK_STREAM,0); |
|
5133 if (sock_fd < 0) |
|
5134 { |
|
5135 ret = -1; |
|
5136 goto close; |
|
5137 } |
|
5138 if (connect(sock_fd,(sockaddr*)&serv_addr,sizeof(serv_addr)) < 0) |
|
5139 { |
|
5140 ret = -1; |
|
5141 goto close; |
|
5142 } |
|
5143 sleep(5); |
|
5144 err1 = send(sock_fd, msg, 5, 0); |
|
5145 if(err1 < 0) |
|
5146 { |
|
5147 ret = -1; |
|
5148 goto close; |
|
5149 } |
|
5150 sleep(5); |
|
5151 err1 = send(sock_fd, msg, 5, 0); |
|
5152 if(err1 == -1 ) |
|
5153 { |
|
5154 printf("send() failed returned errno = %d", errno); |
|
5155 } |
|
5156 else |
|
5157 { |
|
5158 ret = -1; |
|
5159 } |
|
5160 close: |
|
5161 close(sock_fd); |
|
5162 return (void*)ret; |
|
5163 } |
|
5164 |
|
5165 |
|
5166 TInt CTestSocket::SockSendOnClosedConn() |
|
5167 { |
|
5168 int sock_fd,newsock_fd; |
|
5169 unsigned int addr_len; |
|
5170 sockaddr_in serv_addr,new_socket; |
|
5171 TInt ret = KErrNone; |
|
5172 |
|
5173 int threadRetVal = 0; |
|
5174 void *threadRetValPtr = (void*)&threadRetVal; |
|
5175 sock_fd = socket(AF_INET,SOCK_STREAM,0); |
|
5176 if (sock_fd < 0) |
|
5177 { |
|
5178 return KErrSocket; |
|
5179 } |
|
5180 serv_addr.sin_family = AF_INET; |
|
5181 serv_addr.sin_addr.s_addr = inet_addr("127.0.0.1"); |
|
5182 serv_addr.sin_port = htons(12349); |
|
5183 pthread_t clientThread; |
|
5184 if (bind(sock_fd,(sockaddr*)&serv_addr,sizeof(serv_addr)) < 0) |
|
5185 { |
|
5186 INFO_PRINTF2(_L("bind return with errno = %d"), errno); |
|
5187 return KErrBind; |
|
5188 } |
|
5189 if(-1 == listen(sock_fd, 1)) |
|
5190 { |
|
5191 printf("error listen failed"); |
|
5192 close(sock_fd); |
|
5193 return -1; |
|
5194 } |
|
5195 |
|
5196 pthread_create(&clientThread, NULL, &create_socket, (void*)(serv_addr.sin_port)); |
|
5197 addr_len = sizeof(new_socket); |
|
5198 newsock_fd = accept(sock_fd,(sockaddr*)&new_socket,&addr_len); |
|
5199 if (errno != 0 ) |
|
5200 { |
|
5201 INFO_PRINTF2(_L("Accept return with errno = %d"), errno); |
|
5202 ret = -1; |
|
5203 } |
|
5204 |
|
5205 close(newsock_fd); |
|
5206 close(sock_fd); |
|
5207 pthread_join(clientThread, &threadRetValPtr ); |
|
5208 if (threadRetVal < 0) |
|
5209 { |
|
5210 INFO_PRINTF1(_L("SockSendOnClosedConn failed")); |
|
5211 ret = threadRetVal; |
|
5212 } |
|
5213 return ret; |
|
5214 } |
|
5215 |
|
5216 // ========================== OTHER EXPORTED FUNCTIONS ========================= |
|
5217 // None |
|
5218 |
|
5219 // End of File |
|
5220 |
|
5221 |