|
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 (errno != EINVAL ) |
|
1639 { |
|
1640 INFO_PRINTF2(_L("Accept return with errno = %d"), errno); |
|
1641 ret = KErrAccept; |
|
1642 goto close; |
|
1643 } |
|
1644 |
|
1645 ret = KErrNone; |
|
1646 close: |
|
1647 |
|
1648 close(sock_fd); |
|
1649 return ret; |
|
1650 |
|
1651 } |
|
1652 |
|
1653 TInt CTestSocket::AcceptTestNullAddr() |
|
1654 { |
|
1655 int sock_fd,newsock_fd; |
|
1656 sockaddr_in serv_addr; |
|
1657 TInt ret = KErrNone; |
|
1658 |
|
1659 sock_fd = socket(AF_INET,SOCK_STREAM,0); |
|
1660 if (sock_fd < 0) |
|
1661 { |
|
1662 INFO_PRINTF2(_L("socket return with errno = %d"), errno); |
|
1663 return KErrSocket; |
|
1664 } |
|
1665 serv_addr.sin_family = AF_INET; |
|
1666 serv_addr.sin_addr.s_addr = htonl(INADDR_ANY); |
|
1667 serv_addr.sin_port = htons(12345); |
|
1668 char buf[20]; |
|
1669 int readLen = 0; |
|
1670 pthread_t threadId; |
|
1671 if (bind(sock_fd,(sockaddr*)&serv_addr,sizeof(serv_addr)) < 0) |
|
1672 { |
|
1673 INFO_PRINTF2(_L("bind return with errno = %d"), errno); |
|
1674 ret = KErrBind; |
|
1675 goto close; |
|
1676 } |
|
1677 if (listen(sock_fd,1) < 0) |
|
1678 { |
|
1679 INFO_PRINTF2(_L("listen return with errno = %d"), errno); |
|
1680 ret = KErrListen; |
|
1681 goto close; |
|
1682 } |
|
1683 |
|
1684 pthread_create(&threadId,NULL,SocketClient,NULL); |
|
1685 newsock_fd = accept(sock_fd,0,0); |
|
1686 if (errno != 0 ) |
|
1687 { |
|
1688 INFO_PRINTF2(_L("Accept return with errno = %d"), errno); |
|
1689 ret = -1; |
|
1690 goto close; |
|
1691 } |
|
1692 |
|
1693 readLen = strlen("testing")+1; |
|
1694 if(read(newsock_fd,buf, readLen) != readLen) |
|
1695 { |
|
1696 INFO_PRINTF2(_L("read return with errno = %d"), errno); |
|
1697 ret = -1; |
|
1698 goto close; |
|
1699 } |
|
1700 close(newsock_fd); |
|
1701 close: |
|
1702 pthread_join(threadId,NULL); |
|
1703 close(sock_fd); |
|
1704 return ret; |
|
1705 |
|
1706 } |
|
1707 |
|
1708 |
|
1709 TInt CTestSocket::ConnectTestFailCases() |
|
1710 { |
|
1711 sockaddr_in serv_addr; |
|
1712 int sock_fd; |
|
1713 int ret = KErrNone; |
|
1714 char paramets[10][256]; |
|
1715 |
|
1716 /** |
|
1717 * paramets[0]=socket family; |
|
1718 * paramets[1]=address |
|
1719 */ |
|
1720 GetParameters(paramets); |
|
1721 serv_addr.sin_family = atoi(paramets[0]); |
|
1722 serv_addr.sin_addr.s_addr = htonl(atoi(paramets[1])); |
|
1723 serv_addr.sin_port = 0; |
|
1724 |
|
1725 sock_fd = socket(AF_INET,SOCK_STREAM,0); |
|
1726 if (sock_fd < 0) |
|
1727 { |
|
1728 ret = KErrSocket; |
|
1729 goto close; |
|
1730 } |
|
1731 // Failure expected |
|
1732 ret = connect(sock_fd,(sockaddr*)&serv_addr,sizeof(serv_addr)); |
|
1733 if (ret == KErrNone) |
|
1734 { |
|
1735 ret = KErrConnect; |
|
1736 goto close; |
|
1737 } |
|
1738 else |
|
1739 { |
|
1740 ret = KErrNone; |
|
1741 } |
|
1742 |
|
1743 ret = connect(sock_fd,(sockaddr*)&serv_addr,0); |
|
1744 if (errno != EINVAL ) |
|
1745 { |
|
1746 ret = KErrConnect; |
|
1747 goto close; |
|
1748 } |
|
1749 if (ret == KErrNone) |
|
1750 { |
|
1751 ret = KErrConnect; |
|
1752 goto close; |
|
1753 } |
|
1754 |
|
1755 ret = connect(sock_fd,(sockaddr*)0,sizeof(serv_addr)); |
|
1756 if (errno != EFAULT ) |
|
1757 { |
|
1758 ret = KErrConnect; |
|
1759 goto close; |
|
1760 } |
|
1761 if (ret == KErrNone) |
|
1762 { |
|
1763 ret = KErrConnect; |
|
1764 goto close; |
|
1765 } |
|
1766 |
|
1767 ret = KErrNone; |
|
1768 close: |
|
1769 shutdown(sock_fd,SHUT_RDWR); |
|
1770 close(sock_fd); |
|
1771 return ret; |
|
1772 } |
|
1773 |
|
1774 TInt CTestSocket::ConnectUsingFileDescriptor( ) |
|
1775 { |
|
1776 int ret = KErrNone; |
|
1777 sockaddr_in addr; |
|
1778 |
|
1779 ret = connect(0,(sockaddr*)&addr,sizeof(addr)); |
|
1780 if (ret < 0) |
|
1781 { |
|
1782 ret = KErrNone; |
|
1783 goto close; |
|
1784 } |
|
1785 close: |
|
1786 return ret; |
|
1787 } |
|
1788 |
|
1789 TInt CTestSocket::ConnectUsingInvalidSocketDescriptor( ) |
|
1790 { |
|
1791 int ret = KErrNone; |
|
1792 sockaddr_in addr; |
|
1793 |
|
1794 ret = connect(-1,(sockaddr*)&addr,sizeof(addr)); |
|
1795 if (ret < 0) |
|
1796 { |
|
1797 ret = KErrNone; |
|
1798 goto close; |
|
1799 } |
|
1800 close: |
|
1801 return ret; |
|
1802 } |
|
1803 |
|
1804 TInt CTestSocket::RecvTestFailCases() |
|
1805 { |
|
1806 int sock_fd; |
|
1807 char buf[5]; |
|
1808 sockaddr_in serv_addr; |
|
1809 char paramets[10][256]; |
|
1810 TInt ret = KErrNone; |
|
1811 |
|
1812 /** |
|
1813 * paramets[0]=socket family; |
|
1814 * paramets[1]=address |
|
1815 * paramets[2]=protocol |
|
1816 */ |
|
1817 GetParameters(paramets); |
|
1818 |
|
1819 sock_fd = socket ( atoi(paramets[0]), atoi(paramets[1]), atoi(paramets[2]) ); |
|
1820 if (sock_fd < 0) |
|
1821 { |
|
1822 ret = KErrSocket; |
|
1823 goto close; |
|
1824 } |
|
1825 |
|
1826 serv_addr.sin_family = AF_INET; |
|
1827 serv_addr.sin_addr.s_addr = htonl(INADDR_ANY); |
|
1828 serv_addr.sin_port = 0; |
|
1829 if ( bind(sock_fd,(sockaddr*)&serv_addr,sizeof(serv_addr)) < 0 ) |
|
1830 { |
|
1831 ret = KErrBind; |
|
1832 goto close; |
|
1833 } |
|
1834 if (recv(sock_fd,buf,5,0) < 0 ) |
|
1835 { |
|
1836 ret = KErrNone; |
|
1837 goto close; |
|
1838 } |
|
1839 |
|
1840 close: |
|
1841 close(sock_fd); |
|
1842 return ret; |
|
1843 } |
|
1844 |
|
1845 TInt CTestSocket::RecvUsingFileDescriptor( ) |
|
1846 { |
|
1847 int ret = KErrNone; |
|
1848 char buf[5]; |
|
1849 |
|
1850 ret = recv(0,buf,5,0); // Code should fail here |
|
1851 if (ret < 0) |
|
1852 { |
|
1853 ret = KErrNone; |
|
1854 goto close; |
|
1855 } |
|
1856 close: |
|
1857 return ret; |
|
1858 } |
|
1859 |
|
1860 TInt CTestSocket::RecvUsingInvalidSocketDescriptor( ) |
|
1861 { |
|
1862 int ret = KErrNone; |
|
1863 char buf[5]; |
|
1864 |
|
1865 ret = recv(-1,buf,5,0); // Code should fail here |
|
1866 if (ret < 0) |
|
1867 { |
|
1868 ret = KErrNone; |
|
1869 goto close; |
|
1870 } |
|
1871 close: |
|
1872 return ret; |
|
1873 } |
|
1874 |
|
1875 TInt CTestSocket::SendTestFailCases() |
|
1876 { |
|
1877 int sock_fd; |
|
1878 char buf[5]; |
|
1879 sockaddr_in serv_addr; |
|
1880 TInt ret = KErrNone; |
|
1881 |
|
1882 char paramets[10][256]; |
|
1883 |
|
1884 /** |
|
1885 * paramets[0]=-1/O_NONBLOCK |
|
1886 */ |
|
1887 GetParameters(paramets); |
|
1888 |
|
1889 serv_addr.sin_family = AF_INET; |
|
1890 serv_addr.sin_addr.s_addr = htonl(INADDR_ANY); |
|
1891 serv_addr.sin_port = 0; |
|
1892 |
|
1893 sock_fd = socket(AF_INET,SOCK_STREAM,IPPROTO_TCP); |
|
1894 if ( sock_fd < 0 ) |
|
1895 { |
|
1896 ret = KErrSocket; |
|
1897 goto close; |
|
1898 } |
|
1899 if ( bind( sock_fd,(sockaddr*)&serv_addr,sizeof(serv_addr) ) < 0 ) |
|
1900 { |
|
1901 ret = KErrBind; |
|
1902 goto close; |
|
1903 } |
|
1904 if ( atoi(paramets[0]) == O_NONBLOCK ) |
|
1905 { |
|
1906 fcntl( sock_fd, F_SETFL, O_NONBLOCK ); |
|
1907 } |
|
1908 if ( send( sock_fd,buf,5,0 ) < 0) |
|
1909 { |
|
1910 if (errno == EPIPE) |
|
1911 { |
|
1912 ret = KErrNone; |
|
1913 } |
|
1914 goto close; |
|
1915 } |
|
1916 close: |
|
1917 close(sock_fd); |
|
1918 return ret; |
|
1919 } |
|
1920 |
|
1921 TInt CTestSocket::SendUsingFileDescriptor( ) |
|
1922 { |
|
1923 int ret = KErrNone; |
|
1924 char buf[5]; |
|
1925 |
|
1926 ret = send(0,buf,5,0); // Code should fail here |
|
1927 if (ret < 0) |
|
1928 { |
|
1929 ret = KErrNone; |
|
1930 goto close; |
|
1931 } |
|
1932 close: |
|
1933 return ret; |
|
1934 } |
|
1935 |
|
1936 TInt CTestSocket::SendUsingInvalidSocketDescriptor( ) |
|
1937 { |
|
1938 int ret = KErrNone; |
|
1939 char buf[5]; |
|
1940 |
|
1941 ret = send(-1,buf,5,0); // Code should fail here |
|
1942 if (ret < 0) |
|
1943 { |
|
1944 ret = KErrNone; |
|
1945 goto close; |
|
1946 } |
|
1947 close: |
|
1948 return ret; |
|
1949 } |
|
1950 |
|
1951 TInt CTestSocket::SendToTestFailCases() |
|
1952 { |
|
1953 int sock_fd; |
|
1954 int ret = KErrNone; |
|
1955 char line[KMaxLine]; |
|
1956 unsigned int receiver_len = 0; |
|
1957 sockaddr_in receiver_addr,dest_addr; |
|
1958 |
|
1959 char paramets[10][256]; |
|
1960 |
|
1961 /** |
|
1962 * paramets[0]=socket family; |
|
1963 * paramets[1]=address |
|
1964 * paramets[2]=protocol |
|
1965 * parameter[3]=Blocking/Nonblocking case |
|
1966 * parameter[4]=Size |
|
1967 * parameter[5]=flags, eg.MSG_OOB |
|
1968 */ |
|
1969 GetParameters(paramets); |
|
1970 |
|
1971 sock_fd = socket( atoi(paramets[0]), atoi(paramets[1]), atoi(paramets[2]) ); |
|
1972 receiver_addr.sin_family = AF_INET; |
|
1973 receiver_addr.sin_addr.s_addr = htonl(INADDR_ANY); |
|
1974 receiver_addr.sin_port = 0; |
|
1975 |
|
1976 dest_addr.sin_family = AF_INET; |
|
1977 dest_addr.sin_addr.s_addr = htonl(INADDR_LOOPBACK); |
|
1978 dest_addr.sin_port = receiver_addr.sin_port; |
|
1979 int error = -1; |
|
1980 if (sock_fd < 0) |
|
1981 { |
|
1982 ret = KErrSocket; |
|
1983 goto close; |
|
1984 } |
|
1985 if ( atoi(paramets[3]) > 0) |
|
1986 { |
|
1987 if ( atoi(paramets[3]) == 1) // Set Non-block mode |
|
1988 { |
|
1989 fcntl(sock_fd,F_SETFL,O_NONBLOCK); |
|
1990 } |
|
1991 } |
|
1992 |
|
1993 if (bind(sock_fd,(sockaddr*)&receiver_addr,sizeof(receiver_addr)) < 0) |
|
1994 { |
|
1995 ret = KErrBind; |
|
1996 goto close; |
|
1997 } |
|
1998 receiver_len = sizeof(receiver_addr); |
|
1999 if (getsockname(sock_fd, (sockaddr*)&receiver_addr, &receiver_len) < 0) |
|
2000 { |
|
2001 ret = KErrGetSockName; |
|
2002 goto close; |
|
2003 } |
|
2004 |
|
2005 if ( atoi(paramets[4]) > 0) // set the send window size |
|
2006 { |
|
2007 int optionValue = KMaxLine - 50; |
|
2008 setsockopt(sock_fd,SOL_SOCKET,SO_SNDBUF,&optionValue,sizeof(optionValue)); |
|
2009 } |
|
2010 |
|
2011 error = sendto(sock_fd, line, KMaxLine, atoi(paramets[5]), (sockaddr*)&dest_addr, sizeof(dest_addr) ); |
|
2012 if (error < 0) |
|
2013 { |
|
2014 ret = KErrNone; |
|
2015 goto close; |
|
2016 } |
|
2017 close: |
|
2018 shutdown(sock_fd,SHUT_RDWR); // 2 -> SHUT_RDWT |
|
2019 close(sock_fd); |
|
2020 return ret; |
|
2021 } |
|
2022 |
|
2023 TInt CTestSocket::SendToUsingFileDescriptor( ) |
|
2024 { |
|
2025 int ret = KErrNone; |
|
2026 char line[KMaxLine]; |
|
2027 int dest_len; |
|
2028 sockaddr_in dest_addr; |
|
2029 |
|
2030 dest_len = sizeof(dest_addr); |
|
2031 dest_addr.sin_family = AF_INET; |
|
2032 dest_addr.sin_addr.s_addr = htonl(INADDR_LOOPBACK); |
|
2033 dest_addr.sin_port = 0; |
|
2034 sendto( 0, line, KMaxLine, 0,(sockaddr*)&dest_addr,dest_len ); |
|
2035 if (ret < 0) |
|
2036 { |
|
2037 ret = KErrNone; |
|
2038 goto close; |
|
2039 } |
|
2040 close: |
|
2041 return ret; |
|
2042 } |
|
2043 |
|
2044 TInt CTestSocket::SendToUsingInvalidSocketDescriptor( ) |
|
2045 { |
|
2046 int ret = KErrNone; |
|
2047 char line[KMaxLine]; |
|
2048 int dest_len; |
|
2049 sockaddr_in dest_addr; |
|
2050 |
|
2051 dest_len = sizeof(dest_addr); |
|
2052 dest_addr.sin_family = AF_INET; |
|
2053 dest_addr.sin_addr.s_addr = htonl(INADDR_LOOPBACK); |
|
2054 dest_addr.sin_port = 0; |
|
2055 sendto( -1, line, KMaxLine, 0,(sockaddr*)&dest_addr,dest_len ); |
|
2056 if (ret < 0) |
|
2057 { |
|
2058 ret = KErrNone; |
|
2059 goto close; |
|
2060 } |
|
2061 close: |
|
2062 return ret; |
|
2063 } |
|
2064 |
|
2065 int client(int port) |
|
2066 { |
|
2067 int flag = 0; |
|
2068 int clientsockid = socket(PF_INET, SOCK_STREAM, IPPROTO_TCP); |
|
2069 if (clientsockid < 0) |
|
2070 { |
|
2071 printf("[Client] Create Tcp socket fail"); |
|
2072 return -1; |
|
2073 } |
|
2074 |
|
2075 int result = -1; |
|
2076 |
|
2077 struct sockaddr_in addr; |
|
2078 addr.sin_family = AF_INET; |
|
2079 addr.sin_port = htons(port); |
|
2080 addr.sin_addr.s_addr = htonl(INADDR_LOOPBACK); |
|
2081 |
|
2082 do |
|
2083 { |
|
2084 int ret = connect(clientsockid, (sockaddr*) &addr, sizeof(addr)); |
|
2085 if (ret < 0) |
|
2086 { |
|
2087 printf("[Client] connect to server fail\n"); |
|
2088 break; |
|
2089 } |
|
2090 |
|
2091 ret = send(clientsockid, tcpdata, strlen(tcpdata), flag); |
|
2092 if(ret!=strlen(tcpdata)) |
|
2093 globalflag++; |
|
2094 if (ret < 0) |
|
2095 { |
|
2096 printf("[Client] send data to server fail\n"); |
|
2097 break; |
|
2098 } |
|
2099 int bytes = ret; |
|
2100 |
|
2101 printf("[Client] send %d bytes: %s\n",ret,tcpdata); |
|
2102 char buff[50]; |
|
2103 char* p = buff; |
|
2104 |
|
2105 |
|
2106 ret = recv(clientsockid, p, 50, flag); |
|
2107 if (ret < 0) |
|
2108 { |
|
2109 printf("[Client] recv data from server fail\n"); |
|
2110 break; |
|
2111 } |
|
2112 p += ret; |
|
2113 *p = '\0'; |
|
2114 printf("[Client] recv %d bytes: %s\n", p-buff, buff); |
|
2115 result = 0; |
|
2116 } |
|
2117 while (0); |
|
2118 close(clientsockid); |
|
2119 return result; |
|
2120 } |
|
2121 |
|
2122 void* myclie(void* pv) |
|
2123 { |
|
2124 client( (int)pv); |
|
2125 return 0; |
|
2126 } |
|
2127 |
|
2128 TInt CTestSocket::TestSendReturnValue( ) |
|
2129 { |
|
2130 int ret1=0; |
|
2131 pthread_t t; |
|
2132 int flag = 0; |
|
2133 _LIT(KWelcome,"Hello Open C and OPENENV!\n"); |
|
2134 INFO_PRINTF1(KWelcome) ; |
|
2135 int servsockid = socket(PF_INET, SOCK_STREAM, IPPROTO_TCP); |
|
2136 if (servsockid < 0) |
|
2137 { |
|
2138 printf("[Server] Create Tcp socket fail\n"); |
|
2139 return -1; |
|
2140 } |
|
2141 // reuseaddr |
|
2142 int set = 1; |
|
2143 setsockopt(servsockid, SOL_SOCKET, SO_REUSEADDR, &set, sizeof(set)); |
|
2144 |
|
2145 int result = -1; |
|
2146 struct sockaddr_in addr; |
|
2147 addr.sin_family = AF_INET; |
|
2148 addr.sin_port = htons(5000); |
|
2149 addr.sin_addr.s_addr = htonl(INADDR_ANY); |
|
2150 |
|
2151 do |
|
2152 { |
|
2153 int ret = bind(servsockid, (sockaddr*) &addr, sizeof(addr)); |
|
2154 if (ret < 0) |
|
2155 { |
|
2156 printf("[Server] server bind fail\n"); |
|
2157 break; |
|
2158 } |
|
2159 |
|
2160 ret = listen(servsockid, 2); |
|
2161 if (ret < 0) |
|
2162 { |
|
2163 printf("[Server] listen fail\n"); |
|
2164 break; |
|
2165 } |
|
2166 |
|
2167 |
|
2168 ret1= pthread_create(&t, 0 , myclie, (void*) 5000 ); |
|
2169 |
|
2170 |
|
2171 socklen_t len = sizeof(addr); |
|
2172 int clientid = accept(servsockid, (sockaddr*) &addr, &len); |
|
2173 if (clientid < 0) |
|
2174 { |
|
2175 printf("[Server] accept fail\n"); |
|
2176 break; |
|
2177 } |
|
2178 |
|
2179 char buff[50]; |
|
2180 ret = recv(clientid, buff, 50, flag); |
|
2181 if (ret < 0) |
|
2182 { |
|
2183 printf("[Server] recv data from client fail\n"); |
|
2184 close(clientid); |
|
2185 break; |
|
2186 } |
|
2187 else |
|
2188 { |
|
2189 buff[ret] = '\0'; |
|
2190 printf("[Server] recv data from client %d bytes: %s\n", ret, buff); |
|
2191 } |
|
2192 |
|
2193 ret = send(clientid, buff, ret, flag); |
|
2194 if (ret < 0) |
|
2195 { |
|
2196 printf("[Server] send data to client fail\n"); |
|
2197 close(clientid); |
|
2198 break; |
|
2199 } |
|
2200 else |
|
2201 { |
|
2202 printf("[Server] send data to client %d bytes: %s\n", ret, buff); |
|
2203 } |
|
2204 close(clientid); |
|
2205 result = 0; |
|
2206 } |
|
2207 while (0); |
|
2208 close(servsockid); |
|
2209 |
|
2210 _LIT(KWait,"wait...\n"); |
|
2211 INFO_PRINTF1(KWait) ; |
|
2212 pthread_join(t, 0); |
|
2213 if(globalflag!=0) |
|
2214 { |
|
2215 _LIT(Kerr , "Send() API Failed to send the actual number of bytes sent") ; |
|
2216 INFO_PRINTF1(Kerr) ; |
|
2217 return KErrGeneral ; |
|
2218 } |
|
2219 |
|
2220 return 0; |
|
2221 } |
|
2222 |
|
2223 TInt CTestSocket::RecvFromTestFailCases() |
|
2224 { |
|
2225 int ret = KErrNone; |
|
2226 int sock_fd; |
|
2227 char line[KMaxLine]; |
|
2228 |
|
2229 char paramets[10][256]; |
|
2230 /** |
|
2231 * parameter[0] = Blocking/Nonblocking case |
|
2232 */ |
|
2233 GetParameters(paramets); |
|
2234 |
|
2235 sock_fd = socket(AF_INET,SOCK_DGRAM,IPPROTO_UDP); |
|
2236 if (sock_fd < 0) |
|
2237 { |
|
2238 ret = KErrSocket; |
|
2239 goto close; |
|
2240 } |
|
2241 if ( atoi(paramets[0]) == 1 ) // Set Non-block mode |
|
2242 { |
|
2243 fcntl(sock_fd,F_SETFL,O_NONBLOCK); |
|
2244 } |
|
2245 if (recvfrom(sock_fd,line,KMaxLine,0,(sockaddr*)NULL,0) < 0) |
|
2246 { |
|
2247 ret = KErrNone; |
|
2248 goto close; |
|
2249 } |
|
2250 close: |
|
2251 close(sock_fd); |
|
2252 return ret; |
|
2253 } |
|
2254 |
|
2255 TInt CTestSocket::SocketOptions() |
|
2256 { |
|
2257 int sock_fd; |
|
2258 long int parameter[10]; |
|
2259 int ret = KErrNone; |
|
2260 int paramLength; |
|
2261 |
|
2262 unsigned int optionLen=0; |
|
2263 TPtrC String1,String2, String3, String4, String5, String6, String7; |
|
2264 TBuf8<256> stringBuffer; |
|
2265 stringBuffer.Copy(String1); |
|
2266 _LIT( KString1, "Parameter1" ); |
|
2267 TBool res = GetStringFromConfig(ConfigSection(), KString1, String1); |
|
2268 if(!res) |
|
2269 { |
|
2270 _LIT(Kerr , "Failed to read parameter 1") ; |
|
2271 INFO_PRINTF1(Kerr) ; |
|
2272 return KErrGeneral ; |
|
2273 } |
|
2274 stringBuffer.Copy(String1); |
|
2275 paramLength = String1.Length(); |
|
2276 char* text=(char *)(stringBuffer.Ptr()); |
|
2277 *(text + paramLength) ='\0'; |
|
2278 parameter[0] = atol(text); |
|
2279 |
|
2280 _LIT( KString2, "Parameter2" ); |
|
2281 res = GetStringFromConfig(ConfigSection(), KString2, String2 ); |
|
2282 if(!res) |
|
2283 { |
|
2284 _LIT(Kerr , "Failed to read parameter 2") ; |
|
2285 INFO_PRINTF1(Kerr) ; |
|
2286 return KErrGeneral ; |
|
2287 } |
|
2288 stringBuffer.Copy(String2); |
|
2289 paramLength = String2.Length(); |
|
2290 text=(char *)(stringBuffer.Ptr()); |
|
2291 *(text + paramLength) ='\0'; |
|
2292 parameter[1] = atol(text); |
|
2293 |
|
2294 _LIT( KString3, "Parameter3" ); |
|
2295 res = GetStringFromConfig(ConfigSection(), KString3, String3 ); |
|
2296 if(!res) |
|
2297 { |
|
2298 _LIT(Kerr , "Failed to read parameter 3") ; |
|
2299 INFO_PRINTF1(Kerr) ; |
|
2300 return KErrGeneral ; |
|
2301 } |
|
2302 stringBuffer.Copy(String3); |
|
2303 paramLength = String3.Length(); |
|
2304 text=(char *)(stringBuffer.Ptr()); |
|
2305 *(text + paramLength) ='\0'; |
|
2306 parameter[2] = atol(text); |
|
2307 |
|
2308 _LIT( KString4, "Parameter4" ); |
|
2309 res = GetStringFromConfig(ConfigSection(), KString4, String4 ); |
|
2310 if(!res) |
|
2311 { |
|
2312 _LIT(Kerr , "Failed to read parameter 4") ; |
|
2313 INFO_PRINTF1(Kerr) ; |
|
2314 return KErrGeneral ; |
|
2315 } |
|
2316 stringBuffer.Copy(String4); |
|
2317 paramLength = String4.Length(); |
|
2318 text=(char *)(stringBuffer.Ptr()); |
|
2319 *(text + paramLength) ='\0'; |
|
2320 parameter[3] = atol(text); |
|
2321 |
|
2322 _LIT( KString5, "Parameter5" ); |
|
2323 res = GetStringFromConfig(ConfigSection(), KString5, String5 ); |
|
2324 if(!res) |
|
2325 { |
|
2326 _LIT(Kerr , "Failed to read parameter 5") ; |
|
2327 INFO_PRINTF1(Kerr) ; |
|
2328 return KErrGeneral ; |
|
2329 } |
|
2330 stringBuffer.Copy(String5); |
|
2331 paramLength = String5.Length(); |
|
2332 text=(char *)(stringBuffer.Ptr()); |
|
2333 *(text + paramLength) ='\0'; |
|
2334 parameter[4] = atol(text); |
|
2335 |
|
2336 _LIT( KString6, "Parameter6" ); |
|
2337 res = GetStringFromConfig(ConfigSection(), KString6, String6); |
|
2338 if(!res) |
|
2339 { |
|
2340 _LIT(Kerr , "Failed to read parameter 6") ; |
|
2341 INFO_PRINTF1(Kerr) ; |
|
2342 return KErrGeneral ; |
|
2343 } |
|
2344 stringBuffer.Copy(String6); |
|
2345 paramLength = String6.Length(); |
|
2346 text=(char *)(stringBuffer.Ptr()); |
|
2347 *(text + paramLength) ='\0'; |
|
2348 parameter[5] = atol(text); |
|
2349 |
|
2350 _LIT( KString7, "Parameter7" ); |
|
2351 res = GetStringFromConfig(ConfigSection(), KString7, String7 ); |
|
2352 if(!res) |
|
2353 { |
|
2354 _LIT(Kerr , "Failed to read parameter 7") ; |
|
2355 INFO_PRINTF1(Kerr) ; |
|
2356 return KErrGeneral ; |
|
2357 } |
|
2358 stringBuffer.Copy(String7); |
|
2359 paramLength = String7.Length(); |
|
2360 text=(char *)(stringBuffer.Ptr()); |
|
2361 *(text + paramLength) ='\0'; |
|
2362 parameter[6] = atol(text); |
|
2363 |
|
2364 |
|
2365 /*while ( aItem.GetNextString ( stringPtr ) == KErrNone ) |
|
2366 { |
|
2367 stringBuffer.Copy(stringPtr); |
|
2368 paramLength = stringPtr.Length(); |
|
2369 char* text=(char *)(stringBuffer.Ptr()); |
|
2370 *(text + paramLength) ='\0'; |
|
2371 parameter[i] = atol(text); |
|
2372 i++; |
|
2373 } |
|
2374 */ |
|
2375 /** |
|
2376 * parameter[0] = domain |
|
2377 * parameter[1] = type |
|
2378 * parameter[2] = socket des, |
|
2379 * for testing purpose if parameter[2] <= 0,cfg file is supplying sockfd. |
|
2380 * parameter[3] = level |
|
2381 * parameter[4] = option_name |
|
2382 * parameter[5] = option_value |
|
2383 * As of now only integer values are supported for option value |
|
2384 * parameter[6] = Get or Set or Both |
|
2385 */ |
|
2386 |
|
2387 if (parameter[2] > 0) |
|
2388 { |
|
2389 sock_fd = socket(parameter[0],parameter[1],IPPROTO_TCP); |
|
2390 if (sock_fd < 0) |
|
2391 { |
|
2392 return KErrSocket; |
|
2393 } |
|
2394 } |
|
2395 else |
|
2396 { |
|
2397 sock_fd = parameter[3]; |
|
2398 } |
|
2399 int level = parameter[3]; |
|
2400 int optionName = parameter[4]; |
|
2401 int optionValue = parameter[5]; |
|
2402 optionLen = sizeof(optionValue); |
|
2403 int readOptionValue = 0; |
|
2404 |
|
2405 /** |
|
2406 * For options which allow get and set, first test case |
|
2407 * will set and then get the value. |
|
2408 */ |
|
2409 |
|
2410 if (parameter[6] == KSoGet) |
|
2411 { |
|
2412 ret = getsockopt(sock_fd,level,optionName,(void*)&readOptionValue,&optionLen); |
|
2413 if (ret != KErrNone) |
|
2414 { |
|
2415 ret = KErrGeneral; |
|
2416 } |
|
2417 } |
|
2418 if (parameter[6] & KSoSet) |
|
2419 { |
|
2420 ret = setsockopt(sock_fd,level,optionName,&optionValue,optionLen); |
|
2421 if (ret != KErrNone) |
|
2422 { |
|
2423 ret = KErrGeneral; |
|
2424 } |
|
2425 } |
|
2426 if ((parameter[6] == KSoGetSet) & (ret == KErrNone)) |
|
2427 { |
|
2428 ret = getsockopt(sock_fd,level,optionName,(void*)&readOptionValue,&optionLen); |
|
2429 if (ret != KErrNone) |
|
2430 { |
|
2431 ret = KErrGeneral; |
|
2432 } |
|
2433 else |
|
2434 { |
|
2435 if (readOptionValue == optionValue) |
|
2436 { |
|
2437 ret = KErrNone; |
|
2438 } |
|
2439 else |
|
2440 { |
|
2441 ret = KErrGeneral; |
|
2442 } |
|
2443 } |
|
2444 } |
|
2445 shutdown(sock_fd,SHUT_RDWR); // 2 -> SHUT_RDWT |
|
2446 close(sock_fd); |
|
2447 return ret; |
|
2448 } |
|
2449 |
|
2450 TInt CTestSocket::GetSockOptFailCases() |
|
2451 { |
|
2452 int sock_fd; |
|
2453 int ret = KErrNone; |
|
2454 int level = 0; |
|
2455 int optionName = 0; |
|
2456 int optionValue; |
|
2457 unsigned int optionLen; |
|
2458 int error; |
|
2459 |
|
2460 sock_fd = socket(AF_INET,SOCK_STREAM,0); |
|
2461 if (sock_fd < 0) |
|
2462 { |
|
2463 ret = KErrSocket; |
|
2464 goto close; |
|
2465 } |
|
2466 |
|
2467 // errno shoud be EFAULT |
|
2468 optionLen = sizeof(optionValue); |
|
2469 ret = getsockopt(sock_fd,level,optionName,(void*)0,&optionLen); |
|
2470 if (errno != EFAULT ) |
|
2471 { |
|
2472 ret = KErrGetSockOpt; |
|
2473 goto close; |
|
2474 } |
|
2475 if (ret == KErrNone) |
|
2476 { |
|
2477 ret = KErrGetSockOpt; |
|
2478 goto close; |
|
2479 } |
|
2480 // errno shoud be EINVAL |
|
2481 optionLen = 0; |
|
2482 ret = getsockopt(sock_fd,level,optionName,(void*)&optionValue,&optionLen); |
|
2483 if (errno != EINVAL ) |
|
2484 { |
|
2485 ret = KErrGetSockOpt; |
|
2486 goto close; |
|
2487 } |
|
2488 if (ret == KErrNone) |
|
2489 { |
|
2490 ret = KErrGetSockOpt; |
|
2491 goto close; |
|
2492 } |
|
2493 |
|
2494 // Wrong sockfd, errno shoud be ENOTSOCK |
|
2495 optionLen = sizeof(optionValue); |
|
2496 ret = getsockopt(1,level,optionName,(void*)&optionValue,&optionLen); |
|
2497 if (errno != ENOTSOCK) |
|
2498 { |
|
2499 ret = KErrGetSockOpt; |
|
2500 goto close; |
|
2501 } |
|
2502 if (ret == KErrNone) |
|
2503 { |
|
2504 ret = KErrGetSockOpt; |
|
2505 goto close; |
|
2506 } |
|
2507 |
|
2508 // Wrong sock_fd, errno shoud be EBADF |
|
2509 ret = getsockopt(sock_fd + 100,level,optionName,(void*)&optionValue,&optionLen); |
|
2510 if (errno != EBADF ) |
|
2511 { |
|
2512 ret = KErrGetSockOpt; |
|
2513 goto close; |
|
2514 } |
|
2515 if (ret == KErrNone) |
|
2516 { |
|
2517 ret = KErrGetSockOpt; |
|
2518 goto close; |
|
2519 } |
|
2520 |
|
2521 // Invalid level |
|
2522 level = -1; |
|
2523 optionName = SO_OOBINLINE; |
|
2524 optionValue = 1; |
|
2525 optionLen = sizeof(optionValue); |
|
2526 ret = getsockopt(sock_fd,level,optionName,(void*)&optionValue,&optionLen); |
|
2527 error = errno; |
|
2528 if (error != ENOPROTOOPT ) |
|
2529 { |
|
2530 ret = KErrGetSockOpt; |
|
2531 goto close; |
|
2532 } |
|
2533 if (ret == KErrNone) |
|
2534 { |
|
2535 ret = KErrGetSockOpt; |
|
2536 goto close; |
|
2537 } |
|
2538 |
|
2539 // Invalid name |
|
2540 level = SOL_TCP; |
|
2541 optionName = -1; |
|
2542 optionValue = 1; |
|
2543 optionLen = sizeof(optionValue); |
|
2544 ret = getsockopt(sock_fd,level,optionName,(void*)&optionValue,&optionLen); |
|
2545 error = errno; |
|
2546 if (error != ENOPROTOOPT ) |
|
2547 { |
|
2548 ret = KErrGetSockOpt; |
|
2549 goto close; |
|
2550 } |
|
2551 if (ret == KErrNone) |
|
2552 { |
|
2553 ret = KErrGetSockOpt; |
|
2554 goto close; |
|
2555 } |
|
2556 |
|
2557 ret = KErrNone; |
|
2558 |
|
2559 close: |
|
2560 close(sock_fd); |
|
2561 return ret; |
|
2562 } |
|
2563 |
|
2564 TInt CTestSocket::SetSockOptFailCases() |
|
2565 { |
|
2566 int sock_fd; |
|
2567 int ret = KErrNone; |
|
2568 int level = 0; |
|
2569 int optionName = 0; |
|
2570 int optionValue; |
|
2571 unsigned int optionLen; |
|
2572 int error; |
|
2573 |
|
2574 sock_fd = socket(AF_INET,SOCK_STREAM,0); |
|
2575 if (sock_fd < 0) |
|
2576 { |
|
2577 ret = KErrSocket; |
|
2578 goto close; |
|
2579 } |
|
2580 |
|
2581 // errno shoud be EFAULT |
|
2582 optionLen = sizeof(optionValue); |
|
2583 ret = setsockopt(sock_fd,level,optionName,(void*)0,optionLen); |
|
2584 if (errno != EFAULT ) |
|
2585 { |
|
2586 ret = KErrGetSockOpt; |
|
2587 goto close; |
|
2588 } |
|
2589 if (ret == KErrNone) |
|
2590 { |
|
2591 ret = KErrGetSockOpt; |
|
2592 goto close; |
|
2593 } |
|
2594 // errno shoud be EINVAL |
|
2595 optionLen = 0; |
|
2596 ret = setsockopt(sock_fd,level,optionName,(void*)&optionValue,optionLen); |
|
2597 if (errno != EINVAL ) |
|
2598 { |
|
2599 ret = KErrGetSockOpt; |
|
2600 goto close; |
|
2601 } |
|
2602 if (ret == KErrNone) |
|
2603 { |
|
2604 ret = KErrGetSockOpt; |
|
2605 goto close; |
|
2606 } |
|
2607 |
|
2608 // Wrong sockfd, errno shoud be ENOTSOCK |
|
2609 optionLen = sizeof(optionValue); |
|
2610 ret = setsockopt(1,level,optionName,(void*)&optionValue,optionLen); |
|
2611 if (errno != ENOTSOCK) |
|
2612 { |
|
2613 ret = KErrGetSockOpt; |
|
2614 goto close; |
|
2615 } |
|
2616 if (ret == KErrNone) |
|
2617 { |
|
2618 ret = KErrGetSockOpt; |
|
2619 goto close; |
|
2620 } |
|
2621 |
|
2622 // Wrong sockfd, errno shoud be EBADF |
|
2623 ret = setsockopt(sock_fd + 100,level,optionName,(void*)&optionValue,optionLen); |
|
2624 if (errno != EBADF ) |
|
2625 { |
|
2626 ret = KErrGetSockOpt; |
|
2627 goto close; |
|
2628 } |
|
2629 if (ret == KErrNone) |
|
2630 { |
|
2631 ret = KErrGetSockOpt; |
|
2632 goto close; |
|
2633 } |
|
2634 |
|
2635 // Invalid level |
|
2636 level = -1; |
|
2637 optionName = SO_OOBINLINE; |
|
2638 optionValue = 1; |
|
2639 optionLen = sizeof(optionValue); |
|
2640 ret = setsockopt(sock_fd,level,optionName,(void*)&optionValue,optionLen); |
|
2641 error = errno; |
|
2642 if (error != ENOPROTOOPT ) |
|
2643 { |
|
2644 ret = KErrGetSockOpt; |
|
2645 goto close; |
|
2646 } |
|
2647 if (ret == KErrNone) |
|
2648 { |
|
2649 ret = KErrGetSockOpt; |
|
2650 goto close; |
|
2651 } |
|
2652 |
|
2653 // Invalid name |
|
2654 level = SOL_TCP; |
|
2655 optionName = -10; |
|
2656 optionValue = 1; |
|
2657 optionLen = sizeof(optionValue); |
|
2658 ret = setsockopt(sock_fd,level,optionName,(void*)&optionValue,optionLen); |
|
2659 error = errno; |
|
2660 if (error != ENOPROTOOPT ) |
|
2661 { |
|
2662 INFO_PRINTF2(_L("ERROR NO: %d"), errno); |
|
2663 ret = KErrGetSockOpt; |
|
2664 goto close; |
|
2665 } |
|
2666 if (ret == KErrNone) |
|
2667 { |
|
2668 ret = KErrGetSockOpt; |
|
2669 goto close; |
|
2670 } |
|
2671 |
|
2672 ret = KErrNone; |
|
2673 |
|
2674 close: |
|
2675 close(sock_fd); |
|
2676 return ret; |
|
2677 } |
|
2678 |
|
2679 TInt CTestSocket::SockAtMark() |
|
2680 { |
|
2681 int sockfd; |
|
2682 sockaddr_in selfAddr; |
|
2683 int ret = KErrNone; |
|
2684 |
|
2685 sockfd = socket(AF_INET,SOCK_STREAM,IPPROTO_TCP); |
|
2686 if (sockfd < 0) |
|
2687 { |
|
2688 ret = KErrSocket; |
|
2689 goto close; |
|
2690 } |
|
2691 |
|
2692 selfAddr.sin_family = AF_INET; |
|
2693 selfAddr.sin_addr.s_addr = INADDR_ANY; |
|
2694 selfAddr.sin_port = 0; |
|
2695 |
|
2696 ret = bind(sockfd,(struct sockaddr*)&selfAddr, sizeof(selfAddr)); |
|
2697 if (ret != KErrNone) |
|
2698 { |
|
2699 ret = KErrBind; |
|
2700 goto close; |
|
2701 } |
|
2702 ret = sockatmark(sockfd); |
|
2703 if (ret != KErrNone) |
|
2704 { |
|
2705 ret = KErrSockAtMark; |
|
2706 goto close; |
|
2707 } |
|
2708 close: |
|
2709 close(sockfd); |
|
2710 return ret; |
|
2711 } |
|
2712 |
|
2713 |
|
2714 TInt CTestSocket::BindResvPort() |
|
2715 { |
|
2716 int sockfd; |
|
2717 sockaddr_in selfAddr; |
|
2718 int ret = KErrNone; |
|
2719 char paramets[10][256]; |
|
2720 |
|
2721 /** |
|
2722 * parameter[0] = Port number to bind |
|
2723 */ |
|
2724 GetParameters(paramets); |
|
2725 |
|
2726 sockfd = socket(AF_INET,SOCK_STREAM,IPPROTO_TCP); |
|
2727 if (sockfd < 0) |
|
2728 { |
|
2729 ret = KErrSocket; |
|
2730 goto close; |
|
2731 } |
|
2732 |
|
2733 selfAddr.sin_family = AF_INET; |
|
2734 selfAddr.sin_addr.s_addr = INADDR_ANY; |
|
2735 selfAddr.sin_port = htons(atoi(paramets[0])); /* echo */ |
|
2736 ret = bindresvport(sockfd, &selfAddr); |
|
2737 if (ret != KErrNone) |
|
2738 { |
|
2739 ret = KErrSockAtMark; |
|
2740 goto close; |
|
2741 } |
|
2742 close: |
|
2743 close(sockfd); |
|
2744 return ret; |
|
2745 } |
|
2746 |
|
2747 |
|
2748 TInt CTestSocket::BindResvPortFailCases() |
|
2749 { |
|
2750 sockaddr_in selfAddr; |
|
2751 int ret = KErrNone; |
|
2752 |
|
2753 selfAddr.sin_family = AF_INET; |
|
2754 selfAddr.sin_addr.s_addr = INADDR_ANY; |
|
2755 selfAddr.sin_port = htons(1234); |
|
2756 ret = bindresvport(0, &selfAddr); |
|
2757 if (ret != KErrNone) |
|
2758 { |
|
2759 ret = KErrNone; |
|
2760 goto close; |
|
2761 } |
|
2762 |
|
2763 selfAddr.sin_family = AF_INET; |
|
2764 selfAddr.sin_addr.s_addr = INADDR_ANY; |
|
2765 selfAddr.sin_port = htons(1234); |
|
2766 ret = bindresvport(5, &selfAddr); |
|
2767 if (ret != KErrNone) |
|
2768 { |
|
2769 ret = KErrNone; |
|
2770 goto close; |
|
2771 } |
|
2772 close: |
|
2773 return ret; |
|
2774 } |
|
2775 |
|
2776 TInt CTestSocket::HErrNoLocation() |
|
2777 { |
|
2778 //TInt *ptr = __h_errno_location(); |
|
2779 return KErrNone; |
|
2780 } |
|
2781 |
|
2782 void* UDPThreadSendMsg(TAny* aParam) |
|
2783 { |
|
2784 sockaddr_in receiver_addr; |
|
2785 int sock_fd; |
|
2786 char line[KMaxLine]; |
|
2787 struct msghdr msg; |
|
2788 struct iovec iov; |
|
2789 //TInt ret = KErrNone; |
|
2790 int error; |
|
2791 sock_fd = socket(AF_INET,SOCK_DGRAM,IPPROTO_UDP); |
|
2792 char character = 'A'; |
|
2793 unsigned int cnt = 0; |
|
2794 if (sock_fd < 0) |
|
2795 { |
|
2796 |
|
2797 //ret = KErrSocket; |
|
2798 goto close; |
|
2799 } |
|
2800 for(; cnt < KMaxLine - 1; cnt++) |
|
2801 { |
|
2802 line[cnt] = character; |
|
2803 character++; |
|
2804 if (character > 'Z') |
|
2805 { |
|
2806 character = 'A'; |
|
2807 } |
|
2808 } |
|
2809 line[cnt] = '\0'; |
|
2810 receiver_addr.sin_family = AF_INET; |
|
2811 receiver_addr.sin_addr.s_addr = htonl(INADDR_LOOPBACK); |
|
2812 receiver_addr.sin_port = (int)aParam; |
|
2813 |
|
2814 msg.msg_name = &receiver_addr; |
|
2815 msg.msg_namelen = sizeof(receiver_addr); |
|
2816 msg.msg_iov = &iov; |
|
2817 msg.msg_iovlen = 1; |
|
2818 msg.msg_iov->iov_base = line; |
|
2819 msg.msg_iov->iov_len = KMaxLine; |
|
2820 msg.msg_control = 0; |
|
2821 msg.msg_controllen = 0; |
|
2822 msg.msg_flags = 0; |
|
2823 error = sendmsg(sock_fd,&msg,0); |
|
2824 if ( error < 0) |
|
2825 { |
|
2826 |
|
2827 //ret = KWriteError; |
|
2828 goto close; |
|
2829 } |
|
2830 |
|
2831 close: |
|
2832 close(sock_fd); |
|
2833 return (void*)NULL; |
|
2834 } |
|
2835 |
|
2836 TInt CTestSocket::SendMsgRecvMsg() |
|
2837 { |
|
2838 TInt ret = KErrNone; |
|
2839 int sock_fd; |
|
2840 unsigned int sender_len, receiver_len; |
|
2841 struct msghdr msg; |
|
2842 struct iovec iov; |
|
2843 sockaddr_in receiver_addr,sender_addr; |
|
2844 char line[KMaxLine]; |
|
2845 int error = -1; |
|
2846 sock_fd = socket(AF_INET,SOCK_DGRAM,IPPROTO_UDP); |
|
2847 receiver_addr.sin_family = AF_INET; |
|
2848 receiver_addr.sin_addr.s_addr = htonl(INADDR_ANY); |
|
2849 receiver_addr.sin_port = 0; |
|
2850 |
|
2851 pthread_t testThread; |
|
2852 int threadRetVal; |
|
2853 void *threadRetValPtr = (void*)&threadRetVal; |
|
2854 if (sock_fd < 0) |
|
2855 { |
|
2856 ret = KErrSocket; |
|
2857 goto close; |
|
2858 } |
|
2859 |
|
2860 if (bind(sock_fd,(sockaddr*)&receiver_addr,sizeof(receiver_addr)) < 0) |
|
2861 { |
|
2862 shutdown(sock_fd,SHUT_RDWR); |
|
2863 close(sock_fd); |
|
2864 ret = KErrBind; |
|
2865 goto close; |
|
2866 } |
|
2867 receiver_len = sizeof(receiver_addr); |
|
2868 if (getsockname(sock_fd, (sockaddr*)&receiver_addr, &receiver_len) < 0) |
|
2869 { |
|
2870 ret = KErrGetSockName; |
|
2871 goto close; |
|
2872 } |
|
2873 |
|
2874 // Create the thread and thread is client code |
|
2875 |
|
2876 pthread_create(&testThread, NULL, &UDPThreadSendMsg, (void*)(receiver_addr.sin_port)); |
|
2877 |
|
2878 sender_len = sizeof(sender_addr); |
|
2879 msg.msg_name = &sender_addr; |
|
2880 msg.msg_namelen = sender_len; |
|
2881 msg.msg_iov = &iov; |
|
2882 msg.msg_iovlen = 1; |
|
2883 msg.msg_iov->iov_base = line; |
|
2884 msg.msg_iov->iov_len = 10; |
|
2885 msg.msg_control = 0; |
|
2886 msg.msg_controllen = 0; |
|
2887 msg.msg_flags = 0; |
|
2888 error = recvmsg(sock_fd,&msg,0); |
|
2889 if (error < 0) |
|
2890 { |
|
2891 pthread_join(testThread, &threadRetValPtr); |
|
2892 ret = KReadError; |
|
2893 goto close; |
|
2894 } |
|
2895 |
|
2896 pthread_join(testThread, &threadRetValPtr); |
|
2897 |
|
2898 close: |
|
2899 shutdown(sock_fd,SHUT_RDWR); |
|
2900 close(sock_fd); |
|
2901 return ret; |
|
2902 } |
|
2903 |
|
2904 TInt CTestSocket::TestRecv() |
|
2905 { |
|
2906 sockaddr_in serv_addr; |
|
2907 int sock_fd; |
|
2908 char line[2000]; |
|
2909 int ret = KErrNone; |
|
2910 char address[] = "172.30.176.119"; |
|
2911 int left; |
|
2912 |
|
2913 serv_addr.sin_family = AF_INET; |
|
2914 serv_addr.sin_addr.s_addr = inet_addr(address); |
|
2915 serv_addr.sin_port = htons(7000); |
|
2916 |
|
2917 sock_fd = socket(AF_INET,SOCK_STREAM,0); |
|
2918 if (sock_fd < 0) |
|
2919 { |
|
2920 ret = KErrSocket; |
|
2921 goto close; |
|
2922 } |
|
2923 |
|
2924 struct ifreq ifr; |
|
2925 strcpy(ifr.ifr_name, "Ethernet with Daemon Dynamic IP"); |
|
2926 if ( ioctl(sock_fd,SIOCSIFNAME, &ifr) < 0) |
|
2927 { |
|
2928 ret = KErrIoctl; |
|
2929 goto close; |
|
2930 } |
|
2931 if ( ioctl(sock_fd,SIOCIFSTART , NULL) < 0) |
|
2932 { |
|
2933 ret = KErrIoctl; |
|
2934 goto close; |
|
2935 } |
|
2936 |
|
2937 if (connect(sock_fd,(sockaddr*)&serv_addr,sizeof(serv_addr)) < 0) |
|
2938 { |
|
2939 ret = KErrConnect; |
|
2940 goto close; |
|
2941 } |
|
2942 |
|
2943 printf("How many bytes to read\n"); |
|
2944 scanf("%d", &left); |
|
2945 |
|
2946 if (recv(sock_fd,line,left,0) < 0) |
|
2947 { |
|
2948 ret = KErrRead; |
|
2949 goto close; |
|
2950 } |
|
2951 |
|
2952 close: |
|
2953 ioctl(sock_fd, SIOCIFSTOP , NULL); |
|
2954 close(sock_fd); |
|
2955 ret = KErrNone; |
|
2956 return ret; |
|
2957 } |
|
2958 |
|
2959 TInt CTestSocket::TestReadStream() |
|
2960 { |
|
2961 sockaddr_in serv_addr; |
|
2962 int sock_fd; |
|
2963 char line[2000]; |
|
2964 int ret = KErrNone; |
|
2965 char address[] = "172.30.176.119"; |
|
2966 int left; |
|
2967 |
|
2968 serv_addr.sin_family = AF_INET; |
|
2969 serv_addr.sin_addr.s_addr = inet_addr(address); |
|
2970 serv_addr.sin_port = htons(7000); |
|
2971 |
|
2972 sock_fd = socket(AF_INET,SOCK_STREAM,0); |
|
2973 if (sock_fd < 0) |
|
2974 { |
|
2975 ret = KErrSocket; |
|
2976 goto close; |
|
2977 } |
|
2978 |
|
2979 struct ifreq ifr; |
|
2980 strcpy(ifr.ifr_name, "Ethernet with Daemon Dynamic IP"); |
|
2981 if ( ioctl(sock_fd,SIOCSIFNAME, &ifr) < 0) |
|
2982 { |
|
2983 ret = KErrIoctl; |
|
2984 goto close; |
|
2985 } |
|
2986 if ( ioctl(sock_fd,SIOCIFSTART , NULL) < 0) |
|
2987 { |
|
2988 ret = KErrIoctl; |
|
2989 goto close; |
|
2990 } |
|
2991 |
|
2992 if (connect(sock_fd,(sockaddr*)&serv_addr,sizeof(serv_addr)) < 0) |
|
2993 { |
|
2994 ret = KErrConnect; |
|
2995 goto close; |
|
2996 } |
|
2997 |
|
2998 printf("How many bytes to read\n"); |
|
2999 scanf("%d", &left); |
|
3000 |
|
3001 if (read(sock_fd,line,left) < 0) |
|
3002 { |
|
3003 ret = KErrRead; |
|
3004 goto close; |
|
3005 } |
|
3006 |
|
3007 close: |
|
3008 ioctl(sock_fd, SIOCIFSTOP , NULL); |
|
3009 close(sock_fd); |
|
3010 ret = KErrNone; |
|
3011 return ret; |
|
3012 } |
|
3013 |
|
3014 TInt CTestSocket::TestReadDatagram() |
|
3015 { |
|
3016 sockaddr_in serv_addr; |
|
3017 int sock_fd; |
|
3018 char line[2000]; |
|
3019 int ret = KErrNone; |
|
3020 char address[] = "172.30.176.119"; |
|
3021 int left; |
|
3022 |
|
3023 serv_addr.sin_family = AF_INET; |
|
3024 serv_addr.sin_addr.s_addr = inet_addr(address); |
|
3025 serv_addr.sin_port = htons(7000); |
|
3026 |
|
3027 sock_fd = socket(AF_INET,SOCK_DGRAM,0); |
|
3028 if (sock_fd < 0) |
|
3029 { |
|
3030 ret = KErrSocket; |
|
3031 goto close; |
|
3032 } |
|
3033 |
|
3034 struct ifreq ifr; |
|
3035 strcpy(ifr.ifr_name, "Ethernet with Daemon Dynamic IP"); |
|
3036 if ( ioctl(sock_fd,SIOCSIFNAME, &ifr) < 0) |
|
3037 { |
|
3038 ret = KErrIoctl; |
|
3039 goto close; |
|
3040 } |
|
3041 if ( ioctl(sock_fd,SIOCIFSTART , NULL) < 0) |
|
3042 { |
|
3043 ret = KErrIoctl; |
|
3044 goto close; |
|
3045 } |
|
3046 |
|
3047 if (connect(sock_fd,(sockaddr*)&serv_addr,sizeof(serv_addr)) < 0) |
|
3048 { |
|
3049 ret = KErrConnect; |
|
3050 goto close; |
|
3051 } |
|
3052 |
|
3053 printf("How many bytes to read\n"); |
|
3054 scanf("%d", &left); |
|
3055 |
|
3056 if (read(sock_fd,line,left) < 0) |
|
3057 { |
|
3058 ret = KErrRead; |
|
3059 goto close; |
|
3060 } |
|
3061 |
|
3062 close: |
|
3063 ioctl(sock_fd, SIOCIFSTOP , NULL); |
|
3064 close(sock_fd); |
|
3065 ret = KErrNone; |
|
3066 return ret; |
|
3067 } |
|
3068 |
|
3069 TInt CTestSocket::GetHostName() |
|
3070 { |
|
3071 char hostname[256]; |
|
3072 int ret = KErrNone; |
|
3073 |
|
3074 ret = gethostname(hostname, 256); |
|
3075 if (ret == KErrNone) |
|
3076 { |
|
3077 return ret; |
|
3078 } |
|
3079 else |
|
3080 { |
|
3081 return KErrGetHostName; |
|
3082 } |
|
3083 } |
|
3084 |
|
3085 TInt CTestSocket::GetHostNameNull() |
|
3086 { |
|
3087 int ret = KErrNone; |
|
3088 |
|
3089 ret = gethostname((char*)0, 256); |
|
3090 if (errno != EFAULT ) |
|
3091 { |
|
3092 ret = KErrGetHostName; |
|
3093 goto close; |
|
3094 } |
|
3095 if (ret == KErrNone) |
|
3096 { |
|
3097 ret = KErrGetHostName; |
|
3098 goto close; |
|
3099 } |
|
3100 |
|
3101 ret = KErrNone; |
|
3102 |
|
3103 close: |
|
3104 return ret; |
|
3105 } |
|
3106 |
|
3107 TInt CTestSocket::GetHostNameZero() |
|
3108 { |
|
3109 char hostname[256]; |
|
3110 int ret = KErrNone; |
|
3111 |
|
3112 ret = gethostname(hostname, 0); |
|
3113 if (errno != EFAULT ) |
|
3114 { |
|
3115 ret = KErrGetHostName; |
|
3116 goto close; |
|
3117 } |
|
3118 if (ret == KErrNone) |
|
3119 { |
|
3120 ret = KErrGetHostName; |
|
3121 goto close; |
|
3122 } |
|
3123 |
|
3124 ret = KErrNone; |
|
3125 |
|
3126 close: |
|
3127 return ret; |
|
3128 } |
|
3129 |
|
3130 void CTestSocket::GetParameters(char aParamets[10][256]) |
|
3131 { |
|
3132 TPtrC string1, string2, string3, string4, string5, string6, string7; |
|
3133 char *textPtr; |
|
3134 TBuf8<256> stringBuffer; |
|
3135 |
|
3136 _LIT( Kstring1, "Parameter1" ); |
|
3137 TBool res = GetStringFromConfig(ConfigSection(), Kstring1, string1); |
|
3138 if(!res) return; |
|
3139 |
|
3140 stringBuffer.Copy(string1); |
|
3141 textPtr = (char*)stringBuffer.Ptr(); |
|
3142 *( textPtr + stringBuffer.Length() ) = '\0'; |
|
3143 strcpy(aParamets[0], textPtr); |
|
3144 |
|
3145 _LIT( Kstring2, "Parameter2" ); |
|
3146 res = GetStringFromConfig(ConfigSection(), Kstring2, string2); |
|
3147 if(!res) |
|
3148 return; |
|
3149 |
|
3150 stringBuffer.Copy(string2); |
|
3151 textPtr = (char*)stringBuffer.Ptr(); |
|
3152 *( textPtr + stringBuffer.Length() ) = '\0'; |
|
3153 strcpy(aParamets[1], textPtr); |
|
3154 |
|
3155 _LIT( Kstring3, "Parameter3" ); |
|
3156 res = GetStringFromConfig(ConfigSection(), Kstring3, string3); |
|
3157 if(!res) |
|
3158 return ; |
|
3159 |
|
3160 stringBuffer.Copy(string3); |
|
3161 textPtr = (char*)stringBuffer.Ptr(); |
|
3162 *( textPtr + stringBuffer.Length() ) = '\0'; |
|
3163 strcpy(aParamets[2], textPtr); |
|
3164 |
|
3165 _LIT( Kstring4, "Parameter4" ); |
|
3166 res = GetStringFromConfig(ConfigSection(), Kstring4, string4); |
|
3167 if(!res) |
|
3168 return ; |
|
3169 |
|
3170 stringBuffer.Copy(string4); |
|
3171 textPtr = (char*)stringBuffer.Ptr(); |
|
3172 *( textPtr + stringBuffer.Length() ) = '\0'; |
|
3173 strcpy(aParamets[3], textPtr); |
|
3174 |
|
3175 _LIT( Kstring5, "Parameter5" ); |
|
3176 res = GetStringFromConfig(ConfigSection(), Kstring5, string5); |
|
3177 if(!res) |
|
3178 return; |
|
3179 |
|
3180 stringBuffer.Copy(string5); |
|
3181 textPtr = (char*)stringBuffer.Ptr(); |
|
3182 *( textPtr + stringBuffer.Length() ) = '\0'; |
|
3183 strcpy(aParamets[4], textPtr); |
|
3184 |
|
3185 _LIT( Kstring6, "Parameter6" ); |
|
3186 res = GetStringFromConfig(ConfigSection(), Kstring6, string6); |
|
3187 if(!res) |
|
3188 return ; |
|
3189 |
|
3190 stringBuffer.Copy(string6); |
|
3191 textPtr = (char*)stringBuffer.Ptr(); |
|
3192 *( textPtr + stringBuffer.Length() ) = '\0'; |
|
3193 strcpy(aParamets[5], textPtr); |
|
3194 |
|
3195 _LIT( Kstring7, "Parameter7" ); |
|
3196 res = GetStringFromConfig(ConfigSection(), Kstring7, string7); |
|
3197 if(!res) |
|
3198 return; |
|
3199 |
|
3200 stringBuffer.Copy(string7); |
|
3201 textPtr = (char*)stringBuffer.Ptr(); |
|
3202 *( textPtr + stringBuffer.Length() ) = '\0'; |
|
3203 strcpy(aParamets[6], textPtr); |
|
3204 |
|
3205 } |
|
3206 |
|
3207 TInt CTestSocket::TestSktlseek() |
|
3208 { |
|
3209 int sock_fd; |
|
3210 int ret=KErrNone; |
|
3211 sock_fd=socket(AF_INET,SOCK_STREAM,0); |
|
3212 if (sock_fd < 0) |
|
3213 { |
|
3214 ret = KErrSocket; |
|
3215 return ret; |
|
3216 } |
|
3217 if (lseek(sock_fd,0,SEEK_CUR)<0) |
|
3218 { |
|
3219 ret= KErrLseek; |
|
3220 INFO_PRINTF2(_L("Lseek on socket returned %d"),ret ); |
|
3221 close(sock_fd); |
|
3222 return KErrNone; |
|
3223 } |
|
3224 else |
|
3225 { |
|
3226 close(sock_fd); |
|
3227 return KErrGeneral; |
|
3228 } |
|
3229 |
|
3230 } |
|
3231 |
|
3232 TInt CTestSocket::TestSockAfLocal() |
|
3233 { |
|
3234 int ret=KErrNone; |
|
3235 int fd = -1; |
|
3236 int rslt = -1; |
|
3237 int sz = 0; |
|
3238 const char path[] = "testipc"; |
|
3239 struct sockaddr_un server; |
|
3240 char errstr[256]; |
|
3241 |
|
3242 server.sun_family = PF_LOCAL; |
|
3243 strncpy(server.sun_path, path, strlen(path)+1); |
|
3244 sz = SUN_LEN(&server); |
|
3245 fd = socket(PF_LOCAL, SOCK_STREAM, 0); |
|
3246 if (fd < 0) |
|
3247 { |
|
3248 sprintf( errstr, strerror(errno) ); // protocol not supported!! |
|
3249 printf("%s", errstr); |
|
3250 } |
|
3251 |
|
3252 rslt = bind(fd, (struct sockaddr*)&server, sz); |
|
3253 |
|
3254 if (rslt) |
|
3255 { |
|
3256 printf("socket binding error\n"); |
|
3257 } |
|
3258 unlink(path); |
|
3259 close(fd); |
|
3260 |
|
3261 return ret; |
|
3262 } |
|
3263 |
|
3264 TInt CTestSocket::TestSktfstat() |
|
3265 { |
|
3266 int sock_fd,res; |
|
3267 int ret=KErrNone; |
|
3268 struct stat buf ; |
|
3269 sock_fd=socket(AF_INET,SOCK_STREAM,0); |
|
3270 if (sock_fd < 0) |
|
3271 { |
|
3272 ret = KErrGeneral; |
|
3273 INFO_PRINTF1(_L("socket creation failed")); |
|
3274 } |
|
3275 res=fstat(sock_fd,&buf); |
|
3276 if(res == 0 && buf.st_mode == S_IFSOCK ) |
|
3277 { |
|
3278 INFO_PRINTF1(_L("Test Passed")); |
|
3279 ret = KErrNone; |
|
3280 } |
|
3281 else |
|
3282 { |
|
3283 INFO_PRINTF1(_L("Test Failed")); |
|
3284 ret = KErrGeneral; |
|
3285 } |
|
3286 close(sock_fd); |
|
3287 return ret; |
|
3288 } |
|
3289 TInt CTestSocket::TestSktfsync() |
|
3290 { |
|
3291 int sock_fd,res; |
|
3292 int ret=KErrNone; |
|
3293 sock_fd=socket(AF_INET,SOCK_STREAM,0); |
|
3294 if (sock_fd < 0) |
|
3295 { |
|
3296 ret = KErrGeneral; |
|
3297 INFO_PRINTF1(_L("socket creation failed")); |
|
3298 } |
|
3299 res=fsync(sock_fd); |
|
3300 if(res == 0) |
|
3301 { |
|
3302 INFO_PRINTF1(_L("Test Passed")); |
|
3303 ret = KErrNone; |
|
3304 } |
|
3305 else |
|
3306 { |
|
3307 INFO_PRINTF1(_L("Test Failed")); |
|
3308 ret = KErrGeneral; |
|
3309 } |
|
3310 close(sock_fd); |
|
3311 return ret; |
|
3312 } |
|
3313 |
|
3314 TInt CTestSocket::TestGreaterThan16kReadWrite() |
|
3315 { |
|
3316 int sockfd = -1; |
|
3317 char *buffer; |
|
3318 struct sockaddr_in their_addr; |
|
3319 int no_bytes = 0; |
|
3320 fd_set fds; |
|
3321 struct timeval tv; |
|
3322 |
|
3323 if ((sockfd = socket(PF_INET, SOCK_STREAM, 0)) == -1) |
|
3324 { |
|
3325 INFO_PRINTF1(_L("socket creation failed")); |
|
3326 return KErrGeneral; |
|
3327 } |
|
3328 popen("z:\\sys\\bin\\greaterthan16kreadwriteserver.exe","r"); |
|
3329 sleep(5); |
|
3330 |
|
3331 memset(&their_addr, '\0', sizeof(their_addr)); |
|
3332 their_addr.sin_family = AF_INET; |
|
3333 their_addr.sin_port = htons(PORT); // short, network byte order |
|
3334 their_addr.sin_addr.s_addr = inet_addr("127.0.0.1"); |
|
3335 errno = 0; |
|
3336 |
|
3337 if (connect(sockfd, (struct sockaddr *)&their_addr,sizeof(their_addr)) == -1) |
|
3338 { |
|
3339 INFO_PRINTF1(_L("connect failed")); |
|
3340 return KErrGeneral; |
|
3341 } |
|
3342 fcntl (sockfd, F_SETFL, O_NONBLOCK); |
|
3343 |
|
3344 FD_ZERO(&fds); |
|
3345 FD_SET(sockfd,&fds); |
|
3346 tv.tv_sec = 1; |
|
3347 tv.tv_usec = 1; |
|
3348 buffer = (char *)malloc(100*1024); |
|
3349 while(1) |
|
3350 { |
|
3351 int rc = select(sockfd+1, &fds, NULL, NULL, &tv); |
|
3352 int size = read(sockfd,buffer,10*1024); |
|
3353 if(size == -1) |
|
3354 break; |
|
3355 if(size > 0) |
|
3356 no_bytes += size; |
|
3357 } |
|
3358 free(buffer); |
|
3359 close(sockfd); |
|
3360 return 0; |
|
3361 } |
|
3362 |
|
3363 static void* call_select(void *arg) |
|
3364 { |
|
3365 int ret; |
|
3366 fd_set fdset; |
|
3367 struct sockaddr_in server; |
|
3368 char buf[50]; |
|
3369 unsigned int len = sizeof(struct sockaddr); |
|
3370 int fd = *(int*)arg; |
|
3371 FD_ZERO(&fdset); |
|
3372 FD_SET(fd,&fdset); |
|
3373 ret = select(fd+1,&fdset,NULL,NULL,NULL); |
|
3374 if (ret < 0) |
|
3375 { |
|
3376 printf("select failed"); |
|
3377 return NULL; |
|
3378 } |
|
3379 ret = recvfrom(fd,&buf,sizeof(buf),0,(struct sockaddr*)&server,&len); |
|
3380 *(int*)arg = ret; |
|
3381 return NULL; |
|
3382 } |
|
3383 |
|
3384 // Port shared by the function TestNotify |
|
3385 TInt Port; |
|
3386 static void* call_ioctl(void *arg) |
|
3387 { |
|
3388 int ret; |
|
3389 int fd = *(int*)arg; |
|
3390 struct sockaddr_in server; |
|
3391 char buf[50]; |
|
3392 unsigned int len = sizeof(struct sockaddr); |
|
3393 unsigned status=1; //Is the socket ready to receive? |
|
3394 ret = ioctl(fd,E32IOSELECT,(char*)&status); |
|
3395 if (ret < 0) |
|
3396 { |
|
3397 printf("ioctl failed"); |
|
3398 return NULL; |
|
3399 } |
|
3400 ret = recvfrom(fd,&buf,sizeof(buf),0,(struct sockaddr*)&server,&len); |
|
3401 *(int*)arg = ret; |
|
3402 return NULL; |
|
3403 } |
|
3404 |
|
3405 static void* clientfun(void* /*param*/) |
|
3406 { |
|
3407 int sock; |
|
3408 int ret; |
|
3409 char buf[10] = "Hello"; |
|
3410 struct sockaddr_in server; |
|
3411 server.sin_addr.s_addr = inet_addr("127.0.0.1"); |
|
3412 server.sin_family = AF_INET; |
|
3413 server.sin_port = htons(Port); |
|
3414 sock = socket(AF_INET,SOCK_DGRAM,0); |
|
3415 sleep(5); |
|
3416 ret = sendto(sock,&buf,sizeof(buf),0,(struct sockaddr*)&server,sizeof(struct sockaddr)); |
|
3417 ret = sendto(sock,&buf,sizeof(buf),0,(struct sockaddr*)&server,sizeof(struct sockaddr)); |
|
3418 close(sock); |
|
3419 return NULL; |
|
3420 } |
|
3421 TInt CTestSocket::TestNotify() |
|
3422 { |
|
3423 int fd,ret; //Desc for open |
|
3424 struct sockaddr_in addr; |
|
3425 pthread_t spawn,client; |
|
3426 void* call_select(void *); |
|
3427 int threadRetVal = 0; |
|
3428 void *threadRetValPtr = (void*)&threadRetVal; |
|
3429 _LIT( KPort, "Port" ); |
|
3430 TBool res = GetIntFromConfig(ConfigSection(), KPort, Port); |
|
3431 if(!res) |
|
3432 return KErrGeneral; |
|
3433 addr.sin_family = AF_INET; |
|
3434 addr.sin_port = htons(Port); |
|
3435 addr.sin_addr.s_addr = INADDR_ANY; |
|
3436 fd = socket(AF_INET , SOCK_DGRAM , 0); |
|
3437 if ( fd < 0 ) |
|
3438 { |
|
3439 INFO_PRINTF1(_L("Error in socket\n")); |
|
3440 return -1; |
|
3441 } |
|
3442 ret = bind (fd,(struct sockaddr*)&addr,sizeof(addr)); |
|
3443 if ( ret < 0 ) |
|
3444 { |
|
3445 INFO_PRINTF1(_L("Error in bind\n")); |
|
3446 return -1; |
|
3447 } |
|
3448 |
|
3449 TPtrC TestCall; |
|
3450 _LIT( KTestCall, "TestCall" ); |
|
3451 res = GetStringFromConfig(ConfigSection(), KTestCall, TestCall); |
|
3452 if(!res) |
|
3453 return KErrGeneral; |
|
3454 ret = pthread_create(&client,NULL,&clientfun,NULL); |
|
3455 if(!TestCall.Compare(_L("Select"))) |
|
3456 { |
|
3457 INFO_PRINTF1(_L("Checking Select call")); |
|
3458 ret = pthread_create(&spawn,NULL,&call_select,&fd); |
|
3459 call_select(&fd); |
|
3460 } |
|
3461 else if(!TestCall.Compare(_L("Ioctl"))) |
|
3462 { |
|
3463 INFO_PRINTF1(_L("Checking Ioctl call")); |
|
3464 ret = pthread_create(&spawn,NULL,&call_ioctl,&fd); |
|
3465 call_ioctl(&fd); |
|
3466 } |
|
3467 else |
|
3468 { |
|
3469 INFO_PRINTF1(_L("Invalid Paramater")); |
|
3470 return KErrGeneral; |
|
3471 } |
|
3472 ret = pthread_join(spawn,&threadRetValPtr); |
|
3473 ret = pthread_join(client,NULL); |
|
3474 INFO_PRINTF2(_L("No. of bytes read %d\n"),fd); |
|
3475 if( fd > 0) |
|
3476 { |
|
3477 INFO_PRINTF1(_L("Test Passed")); |
|
3478 close(fd); |
|
3479 return KErrNone; |
|
3480 } |
|
3481 else |
|
3482 { |
|
3483 INFO_PRINTF1(_L("Test Failed")); |
|
3484 close(fd); |
|
3485 return KErrGeneral; |
|
3486 } |
|
3487 } |
|
3488 |
|
3489 /* Test 'peeking' at incoming message using MSG_PEEK flag |
|
3490 * in a connected socket. |
|
3491 */ |
|
3492 TInt CTestSocket::TestRecvMsgPeekTCP( ) |
|
3493 { |
|
3494 int flags; |
|
3495 int serverSock; |
|
3496 int serverPort; |
|
3497 |
|
3498 //Create server socket |
|
3499 serverSock = socket( AF_INET, SOCK_STREAM, IPPROTO_TCP ); |
|
3500 if( serverSock < 0 ) |
|
3501 return KErrSocket; |
|
3502 |
|
3503 //Set the server socket in non blocking mode |
|
3504 flags = fcntl( serverSock, F_GETFL, 0 ); |
|
3505 if ( flags < 0 ) |
|
3506 { |
|
3507 close( serverSock ); |
|
3508 return KErrGetSockOpt; |
|
3509 } |
|
3510 |
|
3511 if ( fcntl( serverSock, F_SETFL, flags | O_NONBLOCK ) < 0 ) |
|
3512 { |
|
3513 close( serverSock ); |
|
3514 return KErrGetSockOpt; |
|
3515 } |
|
3516 |
|
3517 //Bind the server socket |
|
3518 struct sockaddr_in addr; |
|
3519 addr.sin_family = AF_INET; |
|
3520 addr.sin_addr.s_addr = htonl( INADDR_ANY ); |
|
3521 addr.sin_port = htons( 0 ); |
|
3522 if( bind( serverSock, ( struct sockaddr* ) &addr, sizeof( addr ) ) < 0 ) |
|
3523 { |
|
3524 close( serverSock ); |
|
3525 return KErrBind; |
|
3526 } |
|
3527 |
|
3528 //Listen server socket |
|
3529 if( listen( serverSock, 1 ) < 0 ) |
|
3530 { |
|
3531 close( serverSock ); |
|
3532 return KErrListen; |
|
3533 } |
|
3534 |
|
3535 //Get the bind port number |
|
3536 struct sockaddr_in sa; |
|
3537 socklen_t sockAddrSize = sizeof( sa ); |
|
3538 memset(&sa, 0, sizeof(sa)); |
|
3539 |
|
3540 if( getsockname( serverSock, ( struct sockaddr * ) &sa, &sockAddrSize ) < 0 ) |
|
3541 { |
|
3542 close( serverSock ); |
|
3543 return KErrBind; |
|
3544 } |
|
3545 serverPort = ntohs( sa.sin_port ); |
|
3546 |
|
3547 //Create client socket |
|
3548 int clientSock = socket( AF_INET, SOCK_STREAM, IPPROTO_TCP); |
|
3549 |
|
3550 //Set the client socket in non blocking mode |
|
3551 flags = fcntl( clientSock, F_GETFL, 0 ); |
|
3552 if ( flags < 0 ) |
|
3553 { |
|
3554 close( serverSock ); |
|
3555 close( clientSock ); |
|
3556 return KErrGetSockOpt; |
|
3557 } |
|
3558 |
|
3559 if ( fcntl( clientSock, F_SETFL, flags | O_NONBLOCK ) < 0 ) |
|
3560 { |
|
3561 close( serverSock ); |
|
3562 close( clientSock ); |
|
3563 return KErrGetSockOpt; |
|
3564 } |
|
3565 |
|
3566 //Connect to the server |
|
3567 struct sockaddr_in servAddr; |
|
3568 servAddr.sin_family = AF_INET; |
|
3569 servAddr.sin_addr.s_addr = htonl( INADDR_LOOPBACK ); |
|
3570 servAddr.sin_port = htons( serverPort ); |
|
3571 connect( clientSock,( struct sockaddr* ) &servAddr, sizeof( servAddr ) ); |
|
3572 |
|
3573 //Accept the server sock |
|
3574 int newSock; |
|
3575 struct sockaddr acceptAddr; |
|
3576 unsigned int addrLen = sizeof( acceptAddr ); |
|
3577 newSock = accept( serverSock, &acceptAddr, &addrLen ); |
|
3578 if( newSock < 0 ) |
|
3579 { |
|
3580 close( serverSock ); |
|
3581 close( clientSock ); |
|
3582 return KErrAccept; |
|
3583 } |
|
3584 |
|
3585 //Send some data |
|
3586 const int bufSize = 50; |
|
3587 char writeData[bufSize]; |
|
3588 char readData[bufSize]; |
|
3589 memset( writeData, '@', bufSize ); |
|
3590 |
|
3591 if( write( newSock, writeData, bufSize ) < 0 ) |
|
3592 { |
|
3593 close( newSock ); |
|
3594 close( serverSock ); |
|
3595 close( clientSock ); |
|
3596 return KWriteError; |
|
3597 } |
|
3598 |
|
3599 //Wait for the data in client using select |
|
3600 fd_set fds; |
|
3601 FD_ZERO(&fds); |
|
3602 FD_SET(clientSock, &fds); |
|
3603 |
|
3604 struct timeval tv; |
|
3605 tv.tv_sec = 10; //10 seconds |
|
3606 tv.tv_usec = 0; |
|
3607 |
|
3608 if( select( clientSock + 1, &fds, 0, 0, &tv ) <= 0 ) |
|
3609 { |
|
3610 close( serverSock ); |
|
3611 close( clientSock ); |
|
3612 return KErrGetSockOpt; |
|
3613 } |
|
3614 |
|
3615 //Now, at the client side, peek at the data |
|
3616 errno = 0; |
|
3617 if( recv( clientSock, ( void* ) readData, bufSize, MSG_PEEK ) < 0 ) |
|
3618 { |
|
3619 close( newSock ); |
|
3620 close( serverSock ); |
|
3621 close( clientSock ); |
|
3622 return KErrRead; |
|
3623 } |
|
3624 |
|
3625 //Now, try reading the data |
|
3626 if( recv( clientSock, ( void* ) readData, bufSize, 0 ) < 0 ) |
|
3627 { |
|
3628 close( newSock ); |
|
3629 close( serverSock ); |
|
3630 close( clientSock ); |
|
3631 return KErrRead; |
|
3632 } |
|
3633 |
|
3634 close( clientSock ); |
|
3635 close( newSock ); |
|
3636 close( serverSock ); |
|
3637 return KErrNone; |
|
3638 } |
|
3639 |
|
3640 /* Test 'peeking' at incoming message using MSG_PEEK flag |
|
3641 * in a connection-less socket. |
|
3642 */ |
|
3643 TInt CTestSocket::TestRecvMsgPeekUDP( ) |
|
3644 { |
|
3645 int flags; |
|
3646 int serverSock; |
|
3647 int serverPort; |
|
3648 |
|
3649 //Create server socket |
|
3650 serverSock = socket( AF_INET, SOCK_DGRAM, IPPROTO_UDP ); |
|
3651 if( serverSock < 0 ) |
|
3652 return KErrSocket; |
|
3653 |
|
3654 //Set the server socket in non blocking mode |
|
3655 flags = fcntl( serverSock, F_GETFL, 0 ); |
|
3656 if ( flags < 0 ) |
|
3657 { |
|
3658 close( serverSock ); |
|
3659 return KErrGetSockOpt; |
|
3660 } |
|
3661 |
|
3662 if ( fcntl( serverSock, F_SETFL, flags | O_NONBLOCK ) < 0 ) |
|
3663 { |
|
3664 close( serverSock ); |
|
3665 return KErrGetSockOpt; |
|
3666 } |
|
3667 |
|
3668 //Bind the server socket |
|
3669 struct sockaddr_in addr; |
|
3670 addr.sin_family = AF_INET; |
|
3671 addr.sin_addr.s_addr = htonl( INADDR_ANY ); |
|
3672 addr.sin_port = htons( 0 ); |
|
3673 if( bind( serverSock, ( struct sockaddr* ) &addr, sizeof( addr ) ) < 0 ) |
|
3674 { |
|
3675 close( serverSock ); |
|
3676 return KErrBind; |
|
3677 } |
|
3678 |
|
3679 //Get the bind port number |
|
3680 struct sockaddr_in sa; |
|
3681 socklen_t sockAddrSize = sizeof( sa ); |
|
3682 memset(&sa, 0, sizeof(sa)); |
|
3683 |
|
3684 if( getsockname( serverSock, ( struct sockaddr * ) &sa, &sockAddrSize ) < 0 ) |
|
3685 { |
|
3686 close( serverSock ); |
|
3687 return KErrBind; |
|
3688 } |
|
3689 serverPort = ntohs( sa.sin_port ); |
|
3690 |
|
3691 //Create client socket |
|
3692 int clientSock = socket( AF_INET, SOCK_DGRAM, IPPROTO_UDP ); |
|
3693 |
|
3694 //Set the client socket in non blocking mode |
|
3695 flags = fcntl( clientSock, F_GETFL, 0 ); |
|
3696 if ( flags < 0 ) |
|
3697 { |
|
3698 close( serverSock ); |
|
3699 close( clientSock ); |
|
3700 return KErrGetSockOpt; |
|
3701 } |
|
3702 |
|
3703 if ( fcntl( clientSock, F_SETFL, flags | O_NONBLOCK ) < 0 ) |
|
3704 { |
|
3705 close( serverSock ); |
|
3706 close( clientSock ); |
|
3707 return KErrGetSockOpt; |
|
3708 } |
|
3709 |
|
3710 //Send some data |
|
3711 const int bufSize = 50; |
|
3712 char writeData[bufSize]; |
|
3713 char readData[bufSize]; |
|
3714 memset( writeData, '@', bufSize ); |
|
3715 |
|
3716 struct sockaddr_in sendAddr; |
|
3717 memset(&sendAddr, 0, sizeof(sendAddr)); |
|
3718 sendAddr.sin_family = AF_INET; |
|
3719 sendAddr.sin_addr.s_addr = htonl( INADDR_LOOPBACK ); |
|
3720 sendAddr.sin_port = htons( serverPort ); |
|
3721 if( sendto( clientSock, writeData, bufSize, 0, ( struct sockaddr* ) &sendAddr, sizeof( sendAddr ) ) < 0 ) |
|
3722 { |
|
3723 close( serverSock ); |
|
3724 close( clientSock ); |
|
3725 return KWriteError; |
|
3726 } |
|
3727 |
|
3728 //Wait for the data in server using select |
|
3729 fd_set fds; |
|
3730 FD_ZERO(&fds); |
|
3731 FD_SET(serverSock, &fds); |
|
3732 struct timeval tv; |
|
3733 tv.tv_sec = 10; //10 seconds |
|
3734 tv.tv_usec = 0; |
|
3735 |
|
3736 if( select( serverSock + 1, &fds, 0, 0, &tv ) <= 0 ) |
|
3737 { |
|
3738 close( serverSock ); |
|
3739 close( clientSock ); |
|
3740 return KErrGetSockOpt; |
|
3741 } |
|
3742 |
|
3743 struct sockaddr_in fromAddr; |
|
3744 unsigned int fromLen = sizeof( struct sockaddr_in ); |
|
3745 |
|
3746 //Now, at the client side, peek at the data |
|
3747 if( recvfrom( serverSock, readData, bufSize, MSG_PEEK, ( struct sockaddr* ) &fromAddr, &fromLen ) < 0 ) |
|
3748 { |
|
3749 close( serverSock ); |
|
3750 close( clientSock ); |
|
3751 return KErrRead; |
|
3752 } |
|
3753 |
|
3754 //Now, try reading the data |
|
3755 if( recvfrom( serverSock, readData, bufSize, 0, ( struct sockaddr* ) &fromAddr, &fromLen ) < 0 ) |
|
3756 { |
|
3757 close( serverSock ); |
|
3758 close( clientSock ); |
|
3759 return KErrRead; |
|
3760 } |
|
3761 |
|
3762 close( clientSock ); |
|
3763 close( serverSock ); |
|
3764 return KErrNone; |
|
3765 } |
|
3766 int sockfd = -1; |
|
3767 |
|
3768 #ifdef __SYMBIAN32__ |
|
3769 void OpenInterface(char *ifname) |
|
3770 { |
|
3771 printf( " ...Opening Interface - START\n" ); |
|
3772 ifreq ifr; |
|
3773 strcpy(ifr.ifr_name, ifname); |
|
3774 sockfd = socket(AF_INET,SOCK_DGRAM,IPPROTO_UDP); |
|
3775 int err = ioctl(sockfd,SIOCSIFNAME, &ifr); |
|
3776 if( err == -1 ) |
|
3777 { |
|
3778 err = errno; // debug |
|
3779 close( sockfd ); |
|
3780 } |
|
3781 err = ioctl(sockfd, SIOCIFSTART , &ifr); |
|
3782 if( err == -1 ) |
|
3783 { |
|
3784 err = errno; // debug |
|
3785 close( sockfd ); |
|
3786 } |
|
3787 printf( " ...Opening Interface - END\n" ); |
|
3788 } |
|
3789 |
|
3790 void CloseInterface( char *ifname ) |
|
3791 { |
|
3792 printf( " ...Closing Interface - START\n" ); |
|
3793 ifreq ifr; |
|
3794 strcpy(ifr.ifr_name, ifname); |
|
3795 int err = ioctl(sockfd, SIOCIFSTOP, &ifr); |
|
3796 if( err == -1 ) |
|
3797 { |
|
3798 err = errno; // debug |
|
3799 } |
|
3800 close(sockfd); |
|
3801 printf( " ...Closing Interface - END\n" ); |
|
3802 } |
|
3803 #endif |
|
3804 |
|
3805 |
|
3806 TInt CTestSocket::TestLargeUDP() |
|
3807 { |
|
3808 #if defined( __SYMBIAN32__ ) && defined ( __WINSCW__ ) |
|
3809 OpenInterface( "Ethernet with Daemon Dynamic IP" ); |
|
3810 #endif |
|
3811 TInt err = 0; |
|
3812 TInt ret = KErrNone; |
|
3813 TInt flags; |
|
3814 TInt serverport =0; |
|
3815 TInt sockoptdata = 49152; |
|
3816 // Server socket code |
|
3817 // ======================================================================================== |
|
3818 INFO_PRINTF1(_L( " ...UDP receiver start-up\n" )); |
|
3819 INFO_PRINTF1(_L( " ...Creating and initializing receiving socket\n" )); |
|
3820 int server_sockfd = socket( AF_INET, SOCK_DGRAM, IPPROTO_UDP); |
|
3821 if(server_sockfd == -1) |
|
3822 { |
|
3823 _LIT(KServ,"socket creation failed: server_sockfd = %d,errno = %d"); |
|
3824 INFO_PRINTF3(KServ,server_sockfd,errno); |
|
3825 ret = KErrGeneral; |
|
3826 return ret; |
|
3827 } |
|
3828 flags = fcntl(server_sockfd, F_GETFL, 0); |
|
3829 if (flags == -1) |
|
3830 { |
|
3831 INFO_PRINTF1(_L("fcntl(F_GETFL) FAILED\n")); |
|
3832 ret = KErrGeneral; |
|
3833 return ret; |
|
3834 } |
|
3835 |
|
3836 if(fcntl(server_sockfd, F_SETFL, flags | O_NONBLOCK) == -1) |
|
3837 { |
|
3838 INFO_PRINTF1(_L("Make the socket nonblocking FAILED\n")); |
|
3839 ret = KErrGeneral; |
|
3840 return ret; |
|
3841 } |
|
3842 |
|
3843 err = setsockopt(server_sockfd, SOL_SOCKET, SO_RCVBUF, (char *) &sockoptdata, sizeof(sockoptdata)); |
|
3844 if(err == -1) |
|
3845 { |
|
3846 _LIT(KRcv," ...setsockopt(SO_RCVBUF) failed: err = %d, errno = %d\n"); |
|
3847 INFO_PRINTF3(KRcv,err,errno); |
|
3848 ret = KErrGeneral; |
|
3849 return ret; |
|
3850 } |
|
3851 err = setsockopt(server_sockfd, SOL_SOCKET, SO_SNDBUF, (char *) &sockoptdata, sizeof(sockoptdata)); |
|
3852 if(err == -1) |
|
3853 { |
|
3854 _LIT(KSnd," ...setsockopt(SO_SNDBUF) failed: err = %d, errno = %d\n"); |
|
3855 INFO_PRINTF3(KSnd,err,errno); |
|
3856 ret = KErrGeneral; |
|
3857 return ret; |
|
3858 } |
|
3859 |
|
3860 INFO_PRINTF1(_L( " ...Binding listening socket\n" )); |
|
3861 struct sockaddr_in servaddr; |
|
3862 servaddr.sin_family = AF_INET; |
|
3863 servaddr.sin_addr.s_addr = htonl(INADDR_ANY); |
|
3864 servaddr.sin_port = htons(0); |
|
3865 err = bind(server_sockfd,(struct sockaddr*)&servaddr,sizeof(servaddr)); |
|
3866 if( err == -1 ) |
|
3867 { |
|
3868 _LIT(KInfo," ...bind failed: err = %d, errno = %d\n"); |
|
3869 INFO_PRINTF3( KInfo, err, errno ); |
|
3870 ret = KErrGeneral; |
|
3871 return ret; |
|
3872 } |
|
3873 INFO_PRINTF1( _L(" ...Check server port we are listening\n" )); |
|
3874 // Determine local port |
|
3875 struct sockaddr_in sa; |
|
3876 struct sockaddr *sockAddrPtr = (struct sockaddr *) &sa; |
|
3877 socklen_t sockAddrSize = sizeof(sa); |
|
3878 |
|
3879 memset(&sa, 0, sizeof(sa)); |
|
3880 if (getsockname(server_sockfd, sockAddrPtr, &sockAddrSize) == 0 ) |
|
3881 { |
|
3882 serverport = ntohs(sa.sin_port); |
|
3883 _LIT(KPort,"Listening port: %d"); |
|
3884 INFO_PRINTF2(KPort,serverport); |
|
3885 } |
|
3886 |
|
3887 INFO_PRINTF1(_L( " ...UDP client start-up\n" )); |
|
3888 INFO_PRINTF1( _L(" ...Creating and initializing sending socket\n" )); |
|
3889 |
|
3890 int client_sockfd = socket(AF_INET,SOCK_DGRAM,IPPROTO_UDP); |
|
3891 if(client_sockfd == -1) |
|
3892 { |
|
3893 _LIT(KCli,"socket creation failed: client_sockfd = %d,errno = %d"); |
|
3894 INFO_PRINTF3(KCli,client_sockfd,errno); |
|
3895 ret = KErrGeneral; |
|
3896 return ret; |
|
3897 } |
|
3898 flags = fcntl(client_sockfd, F_GETFL, 0); |
|
3899 if (flags == -1) |
|
3900 { |
|
3901 INFO_PRINTF1(_L("fcntl(F_GETFL) FAILED\n")); |
|
3902 ret = KErrGeneral; |
|
3903 return ret; |
|
3904 } |
|
3905 if(fcntl(client_sockfd, F_SETFL, flags | O_NONBLOCK) == -1) |
|
3906 { |
|
3907 INFO_PRINTF1(_L("Make the socket nonblocking FAILED\n")); |
|
3908 ret = KErrGeneral; |
|
3909 return ret; |
|
3910 } |
|
3911 err = setsockopt(client_sockfd, SOL_SOCKET, SO_RCVBUF, (char *) &sockoptdata, sizeof(sockoptdata)); |
|
3912 if(err == -1) |
|
3913 { |
|
3914 _LIT(KClircv," ...setsockopt(SO_RCVBUF) failed: err = %d, errno = %d\n"); |
|
3915 INFO_PRINTF3(KClircv,err,errno); |
|
3916 ret = KErrGeneral; |
|
3917 return ret; |
|
3918 } |
|
3919 err = setsockopt(client_sockfd, SOL_SOCKET, SO_SNDBUF, (char *) &sockoptdata, sizeof(sockoptdata)); |
|
3920 if(err == -1) |
|
3921 { |
|
3922 _LIT(KClisnd," ...setsockopt(SO_RCVBUF) failed: err = %d, errno = %d\n"); |
|
3923 INFO_PRINTF3(KClisnd,err,errno); |
|
3924 ret = KErrGeneral; |
|
3925 return ret; |
|
3926 } |
|
3927 |
|
3928 INFO_PRINTF1(_L( " ...Initializing buffers for writing and receiving\n" )); |
|
3929 |
|
3930 TInt Parameter1; |
|
3931 _LIT( KParameter1, "Parameter1" ); |
|
3932 TBool res = GetIntFromConfig(ConfigSection(), KParameter1, Parameter1); |
|
3933 const int bufsize = Parameter1; |
|
3934 char* writedata = (char *) malloc(bufsize); |
|
3935 char* rcvdata = (char *) malloc(bufsize); |
|
3936 |
|
3937 memset(writedata, '@', bufsize); |
|
3938 |
|
3939 _LIT(KInfo," ...Writing large buffer of data to socket. Bufsize: %d\n"); |
|
3940 INFO_PRINTF2(KInfo, bufsize ); |
|
3941 |
|
3942 struct sockaddr_in addr; |
|
3943 memset(&addr, 0, sizeof(addr)); |
|
3944 addr.sin_family = AF_INET; |
|
3945 addr.sin_addr.s_addr = htonl(INADDR_LOOPBACK); |
|
3946 addr.sin_port = htons(serverport); |
|
3947 unsigned int addrlen = sizeof(addr); |
|
3948 int written = sendto(client_sockfd, writedata, bufsize, 0,(struct sockaddr*)&addr,sizeof(addr)); |
|
3949 _LIT(KErr,"error no is %d\n"); |
|
3950 INFO_PRINTF2(KErr,errno); |
|
3951 int receive = recvfrom(server_sockfd,rcvdata, bufsize, 0,(struct sockaddr *)&addr,&addrlen); |
|
3952 if (receive < 0) |
|
3953 { |
|
3954 ret = KReadError; |
|
3955 } |
|
3956 if(written != -1) |
|
3957 { |
|
3958 if(written == receive ) |
|
3959 { |
|
3960 INFO_PRINTF1(_L("Test Passed")); |
|
3961 ret = KErrNone; |
|
3962 } |
|
3963 else |
|
3964 { |
|
3965 INFO_PRINTF1(_L("Test Failed")); |
|
3966 ret = KErrGeneral; |
|
3967 } |
|
3968 } |
|
3969 else if( written == -1 && errno == EAGAIN) |
|
3970 { |
|
3971 INFO_PRINTF1(_L("Test Passed")); |
|
3972 ret = KErrNone; |
|
3973 } |
|
3974 else |
|
3975 { |
|
3976 INFO_PRINTF1(_L("Test Failed")); |
|
3977 ret = KErrGeneral; |
|
3978 } |
|
3979 |
|
3980 free(writedata); |
|
3981 free(rcvdata); |
|
3982 // Close sockets |
|
3983 close( server_sockfd ); |
|
3984 close( client_sockfd ); |
|
3985 |
|
3986 #if defined( __SYMBIAN32__ ) && defined ( __WINSCW__ ) |
|
3987 CloseInterface( "Ethernet with Daemon Dynamic IP" ); |
|
3988 #endif |
|
3989 |
|
3990 return ret; |
|
3991 } |
|
3992 |
|
3993 size_t bytesAvail( int client_sockfd ) |
|
3994 { |
|
3995 size_t nbytes = 0; |
|
3996 |
|
3997 ioctl(client_sockfd, FIONREAD, (char *) &nbytes); |
|
3998 return nbytes; |
|
3999 } |
|
4000 |
|
4001 TInt CTestSocket::TestFionread() |
|
4002 { |
|
4003 int server_sockfd = ::socket( AF_INET, SOCK_DGRAM, IPPROTO_UDP); |
|
4004 TInt ret = KErrNone; |
|
4005 struct sockaddr_in servaddr; |
|
4006 servaddr.sin_family = AF_INET; |
|
4007 servaddr.sin_addr.s_addr = htonl(INADDR_ANY); |
|
4008 servaddr.sin_port = htons(0); |
|
4009 int err = ::bind(server_sockfd,(struct sockaddr*)&servaddr,sizeof(servaddr)); |
|
4010 if( err == -1 ) |
|
4011 INFO_PRINTF3(_L( " ...bind failed: err = %d, errno = %d\n"), err, errno ); |
|
4012 struct sockaddr_in sa; |
|
4013 struct sockaddr *sockAddrPtr = (struct sockaddr *) &sa; |
|
4014 |
|
4015 socklen_t sockAddrSize = sizeof(sa); |
|
4016 |
|
4017 memset(&sa, 0, sizeof(sa)); |
|
4018 int serverport = 0; |
|
4019 if (getsockname(server_sockfd, sockAddrPtr, &sockAddrSize) == 0 ) |
|
4020 { |
|
4021 serverport = ntohs(sa.sin_port); |
|
4022 INFO_PRINTF2(_L( " ...Listening port: %d\n"), serverport ); |
|
4023 } |
|
4024 int client_sockfd; |
|
4025 client_sockfd = socket(AF_INET,SOCK_DGRAM,IPPROTO_UDP); |
|
4026 const int bufsize = 1000; |
|
4027 char writedata[bufsize]; |
|
4028 memset(writedata, '@', bufsize); |
|
4029 |
|
4030 struct sockaddr_in addr; |
|
4031 memset(&addr, 0, sizeof(addr)); |
|
4032 addr.sin_family = AF_INET; |
|
4033 addr.sin_addr.s_addr = htonl(INADDR_LOOPBACK); |
|
4034 addr.sin_port = htons(serverport); |
|
4035 |
|
4036 int written = ::sendto(client_sockfd, writedata, bufsize, 0,(struct sockaddr*)&addr,sizeof(addr)+1); |
|
4037 fd_set fds; |
|
4038 FD_ZERO(&fds); |
|
4039 FD_SET(server_sockfd, &fds); |
|
4040 |
|
4041 const int timeout = 5000; // 5 seconds |
|
4042 |
|
4043 struct timeval tv; |
|
4044 tv.tv_sec = timeout / 1000; |
|
4045 tv.tv_usec = (timeout % 1000) * 1000; |
|
4046 |
|
4047 int selectRet = select(server_sockfd + 1, &fds, 0, 0, &tv ); |
|
4048 |
|
4049 size_t avail = bytesAvail( server_sockfd ); |
|
4050 |
|
4051 |
|
4052 close( server_sockfd ); |
|
4053 close( client_sockfd ); |
|
4054 |
|
4055 if(avail == 1028) |
|
4056 { |
|
4057 INFO_PRINTF1(_L( "Test Case passed \n")); |
|
4058 } |
|
4059 else |
|
4060 { |
|
4061 INFO_PRINTF1(_L( "Test Case passed \n")); |
|
4062 ret = KErrGeneral; |
|
4063 } |
|
4064 return ret; |
|
4065 } |
|
4066 TInt CTestSocket::TestBind1() |
|
4067 { |
|
4068 TInt ret = KErrNone; |
|
4069 int sock_fd1, sock_fd2; |
|
4070 sock_fd1 = socket(AF_INET,SOCK_STREAM,IPPROTO_TCP); |
|
4071 sock_fd2 = socket(AF_INET,SOCK_STREAM,IPPROTO_TCP); |
|
4072 |
|
4073 |
|
4074 struct sockaddr_in sockAddrIPv4; |
|
4075 struct sockaddr *sockAddrPtr = 0; |
|
4076 socklen_t sockAddrSize = 0; |
|
4077 memset(&sockAddrIPv4, 0, sizeof(sockAddrIPv4)); |
|
4078 sockAddrIPv4.sin_family = AF_INET; |
|
4079 sockAddrIPv4.sin_port = htons(31180); |
|
4080 sockAddrIPv4.sin_addr.s_addr = inet_addr("0.0.0.0"); |
|
4081 sockAddrSize = sizeof(sockAddrIPv4); |
|
4082 sockAddrPtr = (struct sockaddr *) &sockAddrIPv4; |
|
4083 |
|
4084 int bindResult1 = ::bind(sock_fd1, sockAddrPtr, sockAddrSize); |
|
4085 if( bindResult1 == -1 ) |
|
4086 { |
|
4087 INFO_PRINTF2(_L("Bind1 Failed with errno %d"),errno); |
|
4088 ret = KErrGeneral; |
|
4089 } |
|
4090 else |
|
4091 { |
|
4092 INFO_PRINTF1(_L("Bind1 Passed")); |
|
4093 } |
|
4094 errno = 0; |
|
4095 int bindResult2 = ::bind(sock_fd2, sockAddrPtr, sockAddrSize); |
|
4096 if( bindResult2 == -1 && errno == EADDRINUSE) |
|
4097 { |
|
4098 INFO_PRINTF1(_L("Bind2 Passed")); |
|
4099 } |
|
4100 else |
|
4101 { |
|
4102 INFO_PRINTF2(_L("Bind2 Failed with errno %d"),errno); |
|
4103 ret = KErrGeneral; |
|
4104 } |
|
4105 |
|
4106 close( sock_fd1 ); |
|
4107 close( sock_fd2 ); |
|
4108 return ret; |
|
4109 } |
|
4110 |
|
4111 /* Test connect() using a non-blocking socket. Tests the value returned |
|
4112 * when a duplicate connect is issued when the previous connect is already |
|
4113 * in progress. |
|
4114 */ |
|
4115 TInt CTestSocket::TestConnectNonBlocking( ) |
|
4116 { |
|
4117 int flags; |
|
4118 int serverSock; |
|
4119 int serverPort; |
|
4120 int ret = 0; |
|
4121 |
|
4122 //Create server socket |
|
4123 serverSock = socket( AF_INET, SOCK_STREAM, IPPROTO_TCP ); |
|
4124 if( serverSock < 0 ) |
|
4125 return KErrSocket; |
|
4126 |
|
4127 //Set the server socket in non blocking mode |
|
4128 flags = fcntl( serverSock, F_GETFL, 0 ); |
|
4129 if ( flags < 0 ) |
|
4130 { |
|
4131 close( serverSock ); |
|
4132 return KErrGetSockOpt; |
|
4133 } |
|
4134 |
|
4135 if ( fcntl( serverSock, F_SETFL, flags | O_NONBLOCK ) < 0 ) |
|
4136 { |
|
4137 close( serverSock ); |
|
4138 return KErrGetSockOpt; |
|
4139 } |
|
4140 |
|
4141 //Bind the server socket |
|
4142 struct sockaddr_in addr; |
|
4143 addr.sin_family = AF_INET; |
|
4144 addr.sin_addr.s_addr = htonl( INADDR_ANY ); |
|
4145 addr.sin_port = htons( 0 ); |
|
4146 if( bind( serverSock, ( struct sockaddr* ) &addr, sizeof( addr ) ) < 0 ) |
|
4147 { |
|
4148 close( serverSock ); |
|
4149 return KErrBind; |
|
4150 } |
|
4151 |
|
4152 //Listen server socket |
|
4153 if( listen( serverSock, 1 ) < 0 ) |
|
4154 { |
|
4155 close( serverSock ); |
|
4156 return KErrListen; |
|
4157 } |
|
4158 |
|
4159 //Get the bind port number |
|
4160 struct sockaddr_in sa; |
|
4161 socklen_t sockAddrSize = sizeof( sa ); |
|
4162 memset(&sa, 0, sizeof(sa)); |
|
4163 |
|
4164 if( getsockname( serverSock, ( struct sockaddr * ) &sa, &sockAddrSize ) < 0 ) |
|
4165 { |
|
4166 close( serverSock ); |
|
4167 return KErrBind; |
|
4168 } |
|
4169 serverPort = ntohs( sa.sin_port ); |
|
4170 |
|
4171 //Create client socket |
|
4172 int clientSock = socket( AF_INET, SOCK_STREAM, IPPROTO_TCP); |
|
4173 |
|
4174 //Set the client socket in non blocking mode |
|
4175 flags = fcntl( clientSock, F_GETFL, 0 ); |
|
4176 if ( flags < 0 ) |
|
4177 { |
|
4178 close( serverSock ); |
|
4179 close( clientSock ); |
|
4180 return KErrGetSockOpt; |
|
4181 } |
|
4182 |
|
4183 if ( fcntl( clientSock, F_SETFL, flags | O_NONBLOCK ) < 0 ) |
|
4184 { |
|
4185 close( serverSock ); |
|
4186 close( clientSock ); |
|
4187 return KErrGetSockOpt; |
|
4188 } |
|
4189 |
|
4190 //Connect to the server |
|
4191 struct sockaddr_in servAddr; |
|
4192 servAddr.sin_family = AF_INET; |
|
4193 servAddr.sin_addr.s_addr = htonl( INADDR_LOOPBACK ); |
|
4194 servAddr.sin_port = htons( serverPort ); |
|
4195 ret = connect( clientSock,( struct sockaddr* ) &servAddr, sizeof( servAddr ) ); |
|
4196 //This should return -1 |
|
4197 if( ret != -1 || errno != EINPROGRESS ) |
|
4198 { |
|
4199 close( serverSock ); |
|
4200 close( clientSock ); |
|
4201 return KErrConnect; |
|
4202 } |
|
4203 |
|
4204 //Try connecting the client multiple times before the server accpets |
|
4205 ret = connect( clientSock,( struct sockaddr* ) &servAddr, sizeof( servAddr ) ); |
|
4206 //This should return -1 |
|
4207 if( ret != -1 ) |
|
4208 { |
|
4209 close( serverSock ); |
|
4210 close( clientSock ); |
|
4211 return KErrConnect; |
|
4212 } |
|
4213 //Try again.. |
|
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 |
|
4223 //Accept the server sock |
|
4224 int newSock; |
|
4225 struct sockaddr acceptAddr; |
|
4226 unsigned int addrLen = sizeof( acceptAddr ); |
|
4227 newSock = accept( serverSock, &acceptAddr, &addrLen ); |
|
4228 if( newSock < 0 ) |
|
4229 { |
|
4230 close( serverSock ); |
|
4231 close( clientSock ); |
|
4232 return KErrAccept; |
|
4233 } |
|
4234 |
|
4235 //Try connect again (now the socket is connected |
|
4236 ret = connect( clientSock,( struct sockaddr* ) &servAddr, sizeof( servAddr ) ); |
|
4237 //This should return -1 |
|
4238 if( ret != -1 ) |
|
4239 { |
|
4240 close( newSock ); |
|
4241 close( serverSock ); |
|
4242 close( clientSock ); |
|
4243 return KErrConnect; |
|
4244 } |
|
4245 |
|
4246 //Send some data |
|
4247 const int bufSize = 50; |
|
4248 char writeData[bufSize]; |
|
4249 char readData[bufSize]; |
|
4250 memset( writeData, '@', bufSize ); |
|
4251 |
|
4252 if( write( newSock, writeData, bufSize ) < 0 ) |
|
4253 { |
|
4254 close( newSock ); |
|
4255 close( serverSock ); |
|
4256 close( clientSock ); |
|
4257 return KWriteError; |
|
4258 } |
|
4259 |
|
4260 //Wait for the data in client using select |
|
4261 fd_set fds; |
|
4262 FD_ZERO(&fds); |
|
4263 FD_SET(clientSock, &fds); |
|
4264 |
|
4265 struct timeval tv; |
|
4266 tv.tv_sec = 10; //10 seconds |
|
4267 tv.tv_usec = 0; |
|
4268 |
|
4269 if( select( clientSock + 1, &fds, 0, 0, &tv ) <= 0 ) |
|
4270 { |
|
4271 close( serverSock ); |
|
4272 close( clientSock ); |
|
4273 return KErrGetSockOpt; |
|
4274 } |
|
4275 |
|
4276 //Now, try reading the data |
|
4277 if( recv( clientSock, ( void* ) readData, bufSize, 0 ) < 0 ) |
|
4278 { |
|
4279 close( newSock ); |
|
4280 close( serverSock ); |
|
4281 close( clientSock ); |
|
4282 return KErrRead; |
|
4283 } |
|
4284 |
|
4285 close( clientSock ); |
|
4286 close( newSock ); |
|
4287 close( serverSock ); |
|
4288 return KErrNone; |
|
4289 } |
|
4290 |
|
4291 |
|
4292 |
|
4293 TInt CTestSocket::TCP1( ) |
|
4294 { |
|
4295 int sock_fd,newsock_fd; |
|
4296 int error; |
|
4297 unsigned int addr_len, serv_len; |
|
4298 sockaddr_in serv_addr,new_socket; |
|
4299 TInt ret = KErrNone; |
|
4300 |
|
4301 sock_fd = socket(AF_INET,SOCK_STREAM,0); |
|
4302 if (sock_fd < 0) |
|
4303 { |
|
4304 return KErrSocket; |
|
4305 } |
|
4306 serv_addr.sin_family = AF_INET; |
|
4307 serv_addr.sin_addr.s_addr = htonl(INADDR_ANY); |
|
4308 serv_addr.sin_port = 0; |
|
4309 pthread_t testThread; |
|
4310 int threadRetVal; |
|
4311 void *threadRetValPtr = (void*)&threadRetVal; |
|
4312 |
|
4313 if (bind(sock_fd,(sockaddr*)&serv_addr,sizeof(serv_addr)) < 0) |
|
4314 { |
|
4315 ret = KErrBind; |
|
4316 goto close; |
|
4317 } |
|
4318 serv_len = sizeof(serv_addr); |
|
4319 if (getsockname(sock_fd, (sockaddr*)&serv_addr, &serv_len) < 0) |
|
4320 { |
|
4321 ret = KErrGetSockName; |
|
4322 goto close; |
|
4323 } |
|
4324 |
|
4325 if (listen(sock_fd,1) < 0) |
|
4326 { |
|
4327 ret = KErrListen; |
|
4328 goto close; |
|
4329 } |
|
4330 |
|
4331 addr_len = sizeof(new_socket); |
|
4332 |
|
4333 // Create the thread and thread is client code |
|
4334 pthread_create(&testThread, NULL, &TCPThread1, (void*)(serv_addr.sin_port)); |
|
4335 |
|
4336 newsock_fd = accept(sock_fd,(sockaddr*)&new_socket,&addr_len); // Code blocks here |
|
4337 error = write1(newsock_fd); |
|
4338 if (error < 0) |
|
4339 { |
|
4340 ret = error; |
|
4341 goto close; |
|
4342 } |
|
4343 |
|
4344 close: |
|
4345 pthread_join(testThread, &threadRetValPtr); |
|
4346 shutdown(sock_fd,SHUT_RDWR); |
|
4347 close(sock_fd); |
|
4348 return ret; |
|
4349 } |
|
4350 |
|
4351 |
|
4352 |
|
4353 int write1(int sock_fd) |
|
4354 { |
|
4355 char line[KMaxLine]; |
|
4356 |
|
4357 char character = 'A'; |
|
4358 unsigned int cnt = 0; |
|
4359 for(; cnt < KMaxLine - 1; cnt++) |
|
4360 { |
|
4361 line[cnt] = character; |
|
4362 character++; |
|
4363 if (character > 'Z') |
|
4364 { |
|
4365 character = 'A'; |
|
4366 } |
|
4367 } |
|
4368 line[cnt] = '\0'; |
|
4369 if (send(sock_fd,line,KMaxLine,0) < 0) |
|
4370 { |
|
4371 return KWriteError; |
|
4372 } |
|
4373 |
|
4374 return KErrNone; |
|
4375 } |
|
4376 |
|
4377 static void* TCPThread1(TAny* aParam) |
|
4378 { |
|
4379 sockaddr_in serv_addr; |
|
4380 int sock_fd,ret; |
|
4381 char line[KMaxLine ]; |
|
4382 |
|
4383 serv_addr.sin_family = AF_INET; |
|
4384 serv_addr.sin_addr.s_addr = htonl(INADDR_LOOPBACK); |
|
4385 serv_addr.sin_port = (int)aParam; |
|
4386 |
|
4387 sock_fd = socket(AF_INET,SOCK_STREAM,0); |
|
4388 if (sock_fd < 0) |
|
4389 { |
|
4390 goto close; |
|
4391 } |
|
4392 if (connect(sock_fd,(sockaddr*)&serv_addr,sizeof(serv_addr)) < 0) |
|
4393 { |
|
4394 goto close; |
|
4395 } |
|
4396 if (read1(sock_fd,line) < 0) |
|
4397 { |
|
4398 goto close; |
|
4399 } |
|
4400 errno = 0; |
|
4401 ret = connect(sock_fd,(sockaddr*)&serv_addr,sizeof(serv_addr)); |
|
4402 if(ret != -1 && errno != EISCONN) |
|
4403 { |
|
4404 goto close; |
|
4405 } |
|
4406 |
|
4407 close: |
|
4408 close(sock_fd); |
|
4409 return (void*)NULL; |
|
4410 } |
|
4411 |
|
4412 |
|
4413 |
|
4414 int read1(int newsock_fd,char *line) |
|
4415 { |
|
4416 int ret; |
|
4417 int left = KMaxLine; |
|
4418 |
|
4419 while (1) |
|
4420 { |
|
4421 |
|
4422 ret = recv(newsock_fd,line,left,0); |
|
4423 |
|
4424 if (ret < 0) |
|
4425 { |
|
4426 return KReadError; |
|
4427 } |
|
4428 else if (ret == 0) |
|
4429 { |
|
4430 break; |
|
4431 } |
|
4432 left -= ret; |
|
4433 line += ret; |
|
4434 if (left <= 0) |
|
4435 { |
|
4436 break; |
|
4437 } |
|
4438 } |
|
4439 return KErrNone; |
|
4440 } |
|
4441 |
|
4442 /* |
|
4443 * Test the ip address mapping to sockaddr_in structure |
|
4444 * when the native code returns the address in ipv4 mapped |
|
4445 * ipv6 format. |
|
4446 */ |
|
4447 TInt CTestSocket::TestV4MappedAddress() |
|
4448 { |
|
4449 const char* localIP = "127.0.0.1"; |
|
4450 |
|
4451 int sock = socket( AF_INET, SOCK_DGRAM, IPPROTO_UDP ); |
|
4452 if( sock < 0 ) |
|
4453 { |
|
4454 ERR_PRINTF2(_L("socket() Failed, errno = %d"), errno); |
|
4455 return KErrGeneral; |
|
4456 } |
|
4457 |
|
4458 const int bufSize = 5; |
|
4459 char writeData[bufSize]; |
|
4460 |
|
4461 //Send a packet to the loopback address. The sender socket will |
|
4462 //have the local host ip when queried using getsockname(). This |
|
4463 //ip is returned by the native API in the ipv6 (ipv4 mapped) format. |
|
4464 |
|
4465 struct sockaddr_in sendAddr; |
|
4466 memset(&sendAddr, 0, sizeof(sendAddr)); |
|
4467 sendAddr.sin_family = AF_INET; |
|
4468 sendAddr.sin_addr.s_addr = htonl(INADDR_LOOPBACK); |
|
4469 sendAddr.sin_port = htons( 2222 ); |
|
4470 if(sendto(sock, writeData, bufSize, 0, (struct sockaddr*) &sendAddr, sizeof( sendAddr )) < 0) |
|
4471 { |
|
4472 ERR_PRINTF2(_L("sendto() Failed, errno = %d"), errno); |
|
4473 close( sock ); |
|
4474 return KErrGeneral; |
|
4475 } |
|
4476 |
|
4477 struct sockaddr_in localAddr; |
|
4478 unsigned int sizeAddr = sizeof(localAddr); |
|
4479 if(getsockname(sock,(struct sockaddr*) &localAddr, &sizeAddr) != 0) |
|
4480 { |
|
4481 ERR_PRINTF2(_L("getsockname() Failed, errno = %d"), errno); |
|
4482 close( sock ); |
|
4483 return KErrGeneral; |
|
4484 } |
|
4485 |
|
4486 if(strcmp(inet_ntoa(localAddr.sin_addr), localIP) != 0) |
|
4487 { |
|
4488 ERR_PRINTF1(_L("getsockname() did not retrieve the local host address")); |
|
4489 close( sock ); |
|
4490 return KErrGeneral; |
|
4491 } |
|
4492 |
|
4493 close( sock ); |
|
4494 return KErrNone; |
|
4495 } |
|
4496 |
|
4497 void * myclie1(void* pv) |
|
4498 { |
|
4499 doClient1(5000,(int)pv); |
|
4500 return 0; |
|
4501 } |
|
4502 |
|
4503 void * myserv1(void* /* pv */) |
|
4504 { |
|
4505 doServer1(5000); |
|
4506 return 0; |
|
4507 } |
|
4508 |
|
4509 int doServer1(int port) |
|
4510 { |
|
4511 int s = socket(PF_INET, SOCK_STREAM, IPPROTO_TCP); |
|
4512 if (s < 0) |
|
4513 { |
|
4514 printf("[S] Create Tcp socket fail\n"); |
|
4515 flag++; |
|
4516 return -1; |
|
4517 } |
|
4518 // reuseaddr |
|
4519 int set = 1; |
|
4520 setsockopt(s, SOL_SOCKET, SO_REUSEADDR, &set, sizeof(set)); |
|
4521 |
|
4522 int result = -1; |
|
4523 struct sockaddr_in addr; |
|
4524 addr.sin_family = AF_INET; |
|
4525 addr.sin_port = htons(port); |
|
4526 addr.sin_addr.s_addr = htonl(INADDR_ANY); |
|
4527 |
|
4528 do |
|
4529 { |
|
4530 int ret = bind(s, (struct sockaddr*) &addr, sizeof(addr)); |
|
4531 if (ret < 0) |
|
4532 { |
|
4533 printf("[S] server bind fail %d\n", errno); |
|
4534 flag++; |
|
4535 break; |
|
4536 } |
|
4537 |
|
4538 ret = listen(s, 2); |
|
4539 if (ret < 0) |
|
4540 { |
|
4541 printf("[S] listen fail %d\n", errno); |
|
4542 flag++; |
|
4543 break; |
|
4544 } |
|
4545 |
|
4546 socklen_t len = sizeof(addr); |
|
4547 int cli = accept(s, (struct sockaddr*) &addr, &len); |
|
4548 if (cli < 0) |
|
4549 { |
|
4550 printf("[S] accept fail %d\n", errno); |
|
4551 flag++; |
|
4552 break; |
|
4553 } |
|
4554 |
|
4555 char buff[10]; |
|
4556 ret = read(cli, buff, 10); |
|
4557 if (ret < 0) |
|
4558 { |
|
4559 printf("[S] read data from socket fail %d\n", errno); |
|
4560 close(cli); |
|
4561 flag++; |
|
4562 break; |
|
4563 } |
|
4564 else |
|
4565 { |
|
4566 printf("[S] read data from socket %d bytes\n", ret); |
|
4567 } |
|
4568 |
|
4569 ret = write(cli, buff, ret); |
|
4570 if (ret < 0) |
|
4571 { |
|
4572 printf("[S] write data on socket fail %d\n", errno); |
|
4573 close(cli); |
|
4574 flag++; |
|
4575 break; |
|
4576 } |
|
4577 else |
|
4578 { |
|
4579 printf("[S] write data on socket %d bytes\n", ret); |
|
4580 } |
|
4581 sleep(2); |
|
4582 printf("[S] socket closed\n"); |
|
4583 close(cli); |
|
4584 result =0; |
|
4585 } |
|
4586 while (0); |
|
4587 close(s); |
|
4588 return result; |
|
4589 } |
|
4590 |
|
4591 int doClient1(int port, int size) |
|
4592 { |
|
4593 sleep(1); |
|
4594 int c = socket(PF_INET, SOCK_STREAM, IPPROTO_TCP); |
|
4595 if (c < 0) |
|
4596 { |
|
4597 printf("[C] Create Tcp socket fail\n"); |
|
4598 flag++; |
|
4599 return -1; |
|
4600 } |
|
4601 |
|
4602 int result = -1; |
|
4603 |
|
4604 struct sockaddr_in addr; |
|
4605 addr.sin_family = AF_INET; |
|
4606 addr.sin_port = htons(port); |
|
4607 addr.sin_addr.s_addr = htonl(INADDR_LOOPBACK); |
|
4608 |
|
4609 do |
|
4610 { |
|
4611 int ret = connect(c, (struct sockaddr*) &addr, sizeof(addr)); |
|
4612 if (ret < 0) |
|
4613 { |
|
4614 printf("[C] connect to server fail %d\n", errno); |
|
4615 flag++; |
|
4616 break; |
|
4617 } |
|
4618 |
|
4619 ret = write(c, safdata, 5); |
|
4620 if (ret < 0) |
|
4621 { |
|
4622 printf("[C] write data on socket fail %d\n", errno); |
|
4623 flag++; |
|
4624 break; |
|
4625 } |
|
4626 printf("[C] write on socket %d bytes\n", ret); |
|
4627 char buff[10]; |
|
4628 char* p = buff; |
|
4629 |
|
4630 do |
|
4631 { |
|
4632 int left = size + buff - p; |
|
4633 if( left == 0 ) |
|
4634 left = 1; |
|
4635 ret = read(c, p, left ); |
|
4636 if (ret < 0) |
|
4637 { |
|
4638 printf("[C] read data from socket fail %d\n", errno); |
|
4639 flag++; |
|
4640 break; |
|
4641 } |
|
4642 else |
|
4643 { |
|
4644 printf("[C] read from socket %d bytes\n", ret); |
|
4645 p += ret; |
|
4646 } |
|
4647 } |
|
4648 while (ret > 0); |
|
4649 // compare data |
|
4650 int len = p - buff; |
|
4651 if (len != 5 || memcmp(buff, safdata, 5) != 0) |
|
4652 { |
|
4653 printf("[C] read data unmatch, length is %d/%d\n", len, 5); |
|
4654 flag++; |
|
4655 break; |
|
4656 } |
|
4657 result = 0; |
|
4658 } |
|
4659 while (0); |
|
4660 close(c); |
|
4661 |
|
4662 return result; |
|
4663 } |
|
4664 |
|
4665 TInt CTestSocket::ReadTestFailCase() |
|
4666 { |
|
4667 pthread_t t[2]; |
|
4668 pthread_create((unsigned int *)&t[0], (pthread_attr_t *)NULL,myserv1, (void *)0); |
|
4669 pthread_create((unsigned int *)&t[1], (pthread_attr_t *)NULL, myclie1, (void *)10); |
|
4670 |
|
4671 pthread_join(t[0],0); |
|
4672 pthread_join(t[1],0); |
|
4673 if(flag == 0) |
|
4674 return KErrNone; |
|
4675 return KErrGeneral; |
|
4676 } |
|
4677 /* |
|
4678 * Test code to verify the fix for DEF128776. |
|
4679 * Scenario: On a connected socket, one thread makes a write |
|
4680 * and another thread reads after a select. |
|
4681 */ |
|
4682 static void* Create_connection(void* /*aParam*/) |
|
4683 { |
|
4684 // Only make a write on the sock_fd |
|
4685 int ret; |
|
4686 struct sockaddr_in host; |
|
4687 int dest_fd; |
|
4688 char buf[50]; |
|
4689 host.sin_port = htons(5002); |
|
4690 host.sin_family = AF_INET; |
|
4691 host.sin_addr.s_addr = inet_addr("127.0.0.1"); |
|
4692 dest_fd = socket(AF_INET,SOCK_STREAM,0); |
|
4693 ret = connect(dest_fd,(struct sockaddr*)&host,sizeof(host)); |
|
4694 ret = read(dest_fd,buf,sizeof(buf)); |
|
4695 ret = write(dest_fd,buf,ret); |
|
4696 close(dest_fd); |
|
4697 return NULL; |
|
4698 } |
|
4699 |
|
4700 static void* socket_write(void* aSock) |
|
4701 { |
|
4702 int *sock_fd = (int*)aSock; |
|
4703 char buf[] = "Write from second thread"; |
|
4704 int ret = write(*sock_fd,buf,sizeof(buf)); |
|
4705 if (ret < 0) |
|
4706 { |
|
4707 exit(1); |
|
4708 } |
|
4709 return NULL; |
|
4710 } |
|
4711 |
|
4712 TInt CTestSocket::TestNotify1() |
|
4713 { |
|
4714 int ret; |
|
4715 pthread_t client,sockwrite; |
|
4716 char buf[50]; |
|
4717 fd_set fds; |
|
4718 FD_ZERO(&fds); |
|
4719 int sock_fd; |
|
4720 int listen_sock = socket(AF_INET,SOCK_STREAM,0); |
|
4721 struct sockaddr_in host,dest; |
|
4722 host.sin_port = htons(5002); |
|
4723 host.sin_family = AF_INET; |
|
4724 host.sin_addr.s_addr = inet_addr("127.0.0.1"); |
|
4725 ret = bind(listen_sock,(struct sockaddr*)&host,sizeof(host)); |
|
4726 if(ret<0) |
|
4727 { |
|
4728 INFO_PRINTF1(_L("Error in bind\n")); |
|
4729 return -1; |
|
4730 } |
|
4731 ret = listen(listen_sock,1); |
|
4732 if(ret<0) |
|
4733 { |
|
4734 INFO_PRINTF1(_L("Error in listen\n")); |
|
4735 return -1; |
|
4736 } |
|
4737 unsigned size = sizeof(host); |
|
4738 ret = pthread_create(&client,(pthread_attr_t*)NULL,&Create_connection,NULL); |
|
4739 if(ret<0) |
|
4740 { |
|
4741 INFO_PRINTF2(_L("Error creating thread:%d\n"),errno); |
|
4742 exit(1); |
|
4743 } |
|
4744 // This socket monitored by 2 threads - one for read, and one for write. |
|
4745 sock_fd = accept(listen_sock,(struct sockaddr*)&dest,&size); |
|
4746 close(listen_sock); |
|
4747 // Spawn the write thread. |
|
4748 ret = pthread_create(&sockwrite,(pthread_attr_t*)NULL,&socket_write,&sock_fd); |
|
4749 if(ret<0) |
|
4750 { |
|
4751 INFO_PRINTF2(_L("Error creating thread:%d\n"),errno); |
|
4752 return -1; |
|
4753 } |
|
4754 // Read thread. |
|
4755 FD_SET(sock_fd,&fds); |
|
4756 ret = select(sock_fd+1,&fds,NULL,NULL,NULL); |
|
4757 if (ret && FD_ISSET(sock_fd,&fds)) |
|
4758 { |
|
4759 ret = read(sock_fd,buf,sizeof(buf)); |
|
4760 TPtr8 ptr((TText8 *)buf, ret); |
|
4761 } |
|
4762 ret = pthread_join(sockwrite,(void**)NULL); |
|
4763 ret = pthread_join(client,(void**)NULL); |
|
4764 close(sock_fd); |
|
4765 return KErrNone; |
|
4766 } |
|
4767 |
|
4768 TInt CTestSocket::TestSockFcntl() |
|
4769 { |
|
4770 // Socket code |
|
4771 // ============ |
|
4772 INFO_PRINTF1(_L("Creating and initializing socket\n")); |
|
4773 int sockfd = socket(AF_INET,SOCK_DGRAM,IPPROTO_UDP); |
|
4774 |
|
4775 INFO_PRINTF1(_L("Configuring socket to non-blocking\n")); |
|
4776 int flags1; |
|
4777 int flags = fcntl(sockfd, F_GETFL, 0); |
|
4778 if (flags == -1) |
|
4779 { |
|
4780 INFO_PRINTF1(_L("fcntl(F_GETFL) FAILED\n")); |
|
4781 return KErrGeneral; |
|
4782 } |
|
4783 flags = flags | O_NONBLOCK; |
|
4784 if ((flags1 = fcntl(sockfd, F_SETFL, flags)) == -1) |
|
4785 { |
|
4786 INFO_PRINTF1(_L("Make the socket nonblocking FAILED\n")); |
|
4787 return KErrGeneral; |
|
4788 } |
|
4789 |
|
4790 if(flags1 != (flags & (O_APPEND|O_NONBLOCK|O_SYNC|O_ACCMODE))) |
|
4791 { |
|
4792 INFO_PRINTF1(_L("fcntl returned wrong flag values\n")); |
|
4793 return KErrGeneral; |
|
4794 } |
|
4795 |
|
4796 close(sockfd); |
|
4797 return KErrNone; |
|
4798 } |
|
4799 |
|
4800 //#warning Replace with correct iap name |
|
4801 const char* g_IapName = "Ethernet with Daemon Dynamic IP"; |
|
4802 //#warning Use proper ip |
|
4803 const char* g_Ip = "10.192.204.41"; |
|
4804 |
|
4805 TInt CTestSocket::create_udp_socket(int port) |
|
4806 { |
|
4807 int s; |
|
4808 struct ifreq ifr; |
|
4809 int err = KErrNone; |
|
4810 |
|
4811 struct sockaddr_in host_address; |
|
4812 s=socket(PF_INET, SOCK_DGRAM, IPPROTO_UDP); |
|
4813 memset((void*)&host_address, 0, sizeof(host_address)); |
|
4814 host_address.sin_family=PF_INET; |
|
4815 host_address.sin_addr.s_addr=INADDR_ANY; |
|
4816 host_address.sin_port=htons(port); |
|
4817 |
|
4818 strcpy(ifr.ifr_name, g_IapName); |
|
4819 err = ioctl(s, SIOCSIFNAME, &ifr); |
|
4820 INFO_PRINTF2(_L("SIOCSIFNAME completed with %d\n"),err); |
|
4821 if(KErrNone != err) |
|
4822 { |
|
4823 return KErrGeneral; |
|
4824 } |
|
4825 err = ioctl(s, SIOCIFSTART, &ifr); |
|
4826 INFO_PRINTF2(_L("SIOCIFSTART completed with %d\n"),err); |
|
4827 if(KErrNone != err) |
|
4828 { |
|
4829 return KErrGeneral; |
|
4830 } |
|
4831 |
|
4832 err = bind(s, (struct sockaddr*)&host_address, sizeof(host_address)); |
|
4833 INFO_PRINTF2(_L("bind completed with %d\n"),err); |
|
4834 if(KErrNone != err) |
|
4835 { |
|
4836 return KErrGeneral; |
|
4837 } |
|
4838 return s; |
|
4839 } |
|
4840 |
|
4841 TInt CTestSocket::send_packet(int s) |
|
4842 { |
|
4843 int j; |
|
4844 char buffer[1000]; |
|
4845 struct sockaddr_in target_host_address; |
|
4846 |
|
4847 target_host_address.sin_family=PF_INET; |
|
4848 target_host_address.sin_port=htons(5000); |
|
4849 |
|
4850 if (inet_aton(g_Ip, &target_host_address.sin_addr)==0) |
|
4851 { |
|
4852 INFO_PRINTF1(_L("inet_aton() failed\n")); |
|
4853 return KErrGeneral; |
|
4854 } |
|
4855 |
|
4856 for (j = 0; j < 100; j++) { |
|
4857 buffer[j] = (unsigned char)((int) (255.0*rand()/(RAND_MAX+1.0))); |
|
4858 } |
|
4859 |
|
4860 return sendto(s, buffer, 100, 0, |
|
4861 (struct sockaddr*)&target_host_address, sizeof(struct sockaddr)); |
|
4862 } |
|
4863 |
|
4864 TInt CTestSocket::close_socket(int fd) |
|
4865 { |
|
4866 // (doesn't really matter if we call SIOCIFSTOP or not) |
|
4867 struct ifreq ifr; |
|
4868 int err = KErrNone; |
|
4869 strcpy(ifr.ifr_name, g_IapName); |
|
4870 err = ioctl(fd, SIOCSIFNAME, &ifr); |
|
4871 INFO_PRINTF2(_L("SIOCSIFNAME completed with %d\n"),err); |
|
4872 if(KErrNone != err) |
|
4873 { |
|
4874 return KErrGeneral; |
|
4875 } |
|
4876 err = ioctl(fd, SIOCIFSTOP, &ifr); |
|
4877 INFO_PRINTF2(_L("SIOCIFSTOP completed with %d\n"),err); |
|
4878 if(KErrNone != err) |
|
4879 { |
|
4880 return KErrGeneral; |
|
4881 } |
|
4882 |
|
4883 close(fd); |
|
4884 return err; |
|
4885 } |
|
4886 |
|
4887 TInt CTestSocket::TestSockIoctl() |
|
4888 { |
|
4889 int val; |
|
4890 int sockfd = -1; |
|
4891 int err = KErrNone; |
|
4892 |
|
4893 sockfd = create_udp_socket(6667); |
|
4894 if(sockfd < 0) |
|
4895 { |
|
4896 INFO_PRINTF2(_L("create_udp_socket returned %d\n"),sockfd); |
|
4897 return KErrGeneral; |
|
4898 } |
|
4899 val = send_packet(sockfd); |
|
4900 INFO_PRINTF2(_L("sent %d bytes\n"),val); |
|
4901 err = close_socket(sockfd); |
|
4902 if(KErrNone != err) |
|
4903 { |
|
4904 INFO_PRINTF2(_L("close_socket returned %d\n"),err); |
|
4905 return KErrGeneral; |
|
4906 } |
|
4907 |
|
4908 sleep(1); |
|
4909 |
|
4910 sockfd = -1; |
|
4911 sockfd = create_udp_socket(6667); |
|
4912 if(sockfd < 0) |
|
4913 { |
|
4914 INFO_PRINTF2(_L("create_udp_socket returned %d\n"),sockfd); |
|
4915 return KErrGeneral; |
|
4916 } |
|
4917 val = send_packet(sockfd); // Causes iap query dialog |
|
4918 INFO_PRINTF2(_L("sent %d bytes\n"),val); |
|
4919 err = close_socket(sockfd); |
|
4920 if(KErrNone != err) |
|
4921 { |
|
4922 INFO_PRINTF2(_L("close_socket returned %d\n"),err); |
|
4923 return KErrGeneral; |
|
4924 } |
|
4925 |
|
4926 return KErrNone; |
|
4927 } |
|
4928 |
|
4929 int sockfd1 = -1; |
|
4930 |
|
4931 int checkip() |
|
4932 { |
|
4933 int client_sockfd = socket( AF_INET, SOCK_STREAM, IPPROTO_TCP); |
|
4934 |
|
4935 struct sockaddr_in addr; |
|
4936 |
|
4937 addr.sin_family = AF_INET; |
|
4938 addr.sin_addr.s_addr = inet_addr( "198.133.219.25" ); |
|
4939 addr.sin_port = htons(80); |
|
4940 int err = connect(client_sockfd,(struct sockaddr*)&addr,sizeof(addr)); |
|
4941 |
|
4942 // Determine local port |
|
4943 struct sockaddr_in sa; |
|
4944 struct sockaddr *sockAddrPtr = (struct sockaddr *) &sa; |
|
4945 socklen_t sockAddrSize = sizeof(sa); |
|
4946 |
|
4947 memset(&sa, 0, sizeof(sa)); |
|
4948 if (getsockname(client_sockfd, sockAddrPtr, &sockAddrSize) == 0 ) |
|
4949 { |
|
4950 printf( " ...Listening IP: %s\n", inet_ntoa(sa.sin_addr)); |
|
4951 } |
|
4952 |
|
4953 shutdown( client_sockfd, SHUT_RDWR ); |
|
4954 close( client_sockfd ); |
|
4955 return 0; |
|
4956 } |
|
4957 |
|
4958 void* client_connection (void *a) |
|
4959 { |
|
4960 int *serverport; |
|
4961 serverport = (int *) a; /* type cast to a pointer to thdata */ |
|
4962 int ret; |
|
4963 struct sockaddr_in host; |
|
4964 int dest_fd; |
|
4965 char buf[50]; |
|
4966 strcpy(buf, "HelloWorld?"); |
|
4967 |
|
4968 host.sin_port = htons (*serverport); |
|
4969 host.sin_family = AF_INET; |
|
4970 host.sin_addr.s_addr = inet_addr ("10.253.2.197"); |
|
4971 |
|
4972 dest_fd = socket (AF_INET, SOCK_STREAM, IPPROTO_TCP); |
|
4973 ret = connect (dest_fd, (struct sockaddr *) &host, sizeof (host)); |
|
4974 if(ret!=0) |
|
4975 { |
|
4976 //this gives me KErrHostUnreach |
|
4977 printf("The connect returned with errno = %d\n", errno); |
|
4978 } |
|
4979 ret = write(dest_fd,buf,12); |
|
4980 if(ret < 0) |
|
4981 { |
|
4982 printf("write failed\n %d\n",errno); |
|
4983 } |
|
4984 else |
|
4985 { |
|
4986 printf("write passed %d\n",ret); |
|
4987 } |
|
4988 shutdown( dest_fd, SHUT_RDWR ); |
|
4989 close( dest_fd ); |
|
4990 return NULL; |
|
4991 } |
|
4992 |
|
4993 //ECONNRESET |
|
4994 TInt CTestSocket::SockErrnoTest() |
|
4995 { |
|
4996 #if defined( __SYMBIAN32__ ) && defined ( __WINSCW__ ) |
|
4997 OpenInterface( "Ethernet with Daemon Dynamic IP" ); |
|
4998 #endif |
|
4999 checkip(); |
|
5000 |
|
5001 int err = 0; |
|
5002 int server_sockfd = socket( AF_INET, SOCK_STREAM, IPPROTO_TCP); |
|
5003 |
|
5004 // Receive OOB data inline |
|
5005 int sockoptdata = 1; |
|
5006 err = setsockopt(server_sockfd, SOL_SOCKET, SO_OOBINLINE, (char *) &sockoptdata, sizeof(sockoptdata)); |
|
5007 if( err == -1 ) |
|
5008 { |
|
5009 INFO_PRINTF3(_L( " ...setsockopt(SO_OOBINLINE) failed: err = %d, errno = %d\n"), err, errno ); |
|
5010 } |
|
5011 |
|
5012 // Bind |
|
5013 struct sockaddr_in addr; |
|
5014 |
|
5015 addr.sin_family = AF_INET; |
|
5016 addr.sin_addr.s_addr = htonl(INADDR_ANY); |
|
5017 addr.sin_port = htons(0); |
|
5018 err = bind(server_sockfd,(struct sockaddr*)&addr,sizeof(addr)); |
|
5019 |
|
5020 // Listen |
|
5021 err = listen(server_sockfd,1); |
|
5022 |
|
5023 INFO_PRINTF1(_L( " ...Check local port we are listening\n" )); |
|
5024 |
|
5025 // Determine local port |
|
5026 struct sockaddr_in sa; |
|
5027 struct sockaddr *sockAddrPtr = (struct sockaddr *) &sa; |
|
5028 socklen_t sockAddrSize = sizeof(sa); |
|
5029 |
|
5030 memset(&sa, 0, sizeof(sa)); |
|
5031 int serverport; |
|
5032 if (getsockname(server_sockfd, sockAddrPtr, &sockAddrSize) == 0 ) |
|
5033 { |
|
5034 serverport = ntohs(sa.sin_port); |
|
5035 } |
|
5036 pthread_t client; |
|
5037 int pthread_ret = pthread_create (&client, (pthread_attr_t *) NULL, &client_connection, |
|
5038 (void *) &serverport); |
|
5039 |
|
5040 unsigned int addr_len; |
|
5041 int newsockfd = accept( server_sockfd, (sockaddr*)&newsockfd,&addr_len); |
|
5042 sleep(2); |
|
5043 shutdown( server_sockfd, SHUT_RDWR ); |
|
5044 close(server_sockfd); |
|
5045 |
|
5046 const int bufsize = 20000; |
|
5047 char readdata[bufsize]; |
|
5048 |
|
5049 int myerr = 0; |
|
5050 TInt ret = KErrNone; |
|
5051 while (myerr >= 0) |
|
5052 { |
|
5053 fd_set fds; |
|
5054 FD_ZERO(&fds); |
|
5055 FD_SET(newsockfd, &fds); |
|
5056 |
|
5057 const int timeout = 10000; |
|
5058 |
|
5059 struct timeval tv; |
|
5060 tv.tv_sec = timeout / 1000; |
|
5061 tv.tv_usec = (timeout % 1000) * 1000; |
|
5062 |
|
5063 int selectRet = select(newsockfd + 1, &fds, 0, 0, &tv ); |
|
5064 if( selectRet == 0 ) |
|
5065 { |
|
5066 myerr = -1; |
|
5067 INFO_PRINTF1(_L( " ...select time limit expired\n" )); |
|
5068 } |
|
5069 else |
|
5070 { |
|
5071 INFO_PRINTF2(_L( " ...Data available for reading (selectRet=%d): \n"), selectRet); |
|
5072 } |
|
5073 |
|
5074 size_t avail = bytesAvail( newsockfd ); |
|
5075 sleep(2); |
|
5076 int received = read( newsockfd, readdata, bufsize); |
|
5077 if( received == -1 ) |
|
5078 { |
|
5079 myerr = -1; |
|
5080 ret = errno; |
|
5081 INFO_PRINTF2(_L( " ...Read FAILED: errno %d\n"), errno ); |
|
5082 } |
|
5083 else |
|
5084 { |
|
5085 INFO_PRINTF2(_L( " ...%d of data received from socket\n"), received ); |
|
5086 if( received == 0 ) |
|
5087 { |
|
5088 myerr = -1; |
|
5089 ret = errno; |
|
5090 } |
|
5091 } |
|
5092 } |
|
5093 shutdown( newsockfd, SHUT_RDWR ); |
|
5094 close( newsockfd ); |
|
5095 |
|
5096 #if defined( __SYMBIAN32__ ) && defined ( __WINSCW__ ) |
|
5097 CloseInterface( "Ethernet with Daemon Dynamic IP" ); |
|
5098 #endif |
|
5099 if(ret!= ECONNRESET) |
|
5100 return ret; |
|
5101 else |
|
5102 return KErrNone; |
|
5103 } |
|
5104 |
|
5105 /* test case to check socket send() api over a broken connection |
|
5106 |
|
5107 expected result:If a socket client writes any data when the server side socket is closed, |
|
5108 then the send() api should return positive value for the first time and the next send() calls should fail returning -1. |
|
5109 */ |
|
5110 |
|
5111 |
|
5112 |
|
5113 void* create_socket( TAny* aParam ) |
|
5114 { |
|
5115 sockaddr_in serv_addr; |
|
5116 int err1; |
|
5117 int ret = 0; |
|
5118 char *msg ="testing socket send"; |
|
5119 int sock_fd; |
|
5120 serv_addr.sin_family = AF_INET; |
|
5121 serv_addr.sin_addr.s_addr = inet_addr("127.0.0.1"); |
|
5122 serv_addr.sin_port = (int)aParam; |
|
5123 sock_fd = socket(AF_INET,SOCK_STREAM,0); |
|
5124 if (sock_fd < 0) |
|
5125 { |
|
5126 ret = -1; |
|
5127 goto close; |
|
5128 } |
|
5129 if (connect(sock_fd,(sockaddr*)&serv_addr,sizeof(serv_addr)) < 0) |
|
5130 { |
|
5131 ret = -1; |
|
5132 goto close; |
|
5133 } |
|
5134 sleep(5); |
|
5135 err1 = send(sock_fd, msg, 5, 0); |
|
5136 if(err1 < 0) |
|
5137 { |
|
5138 ret = -1; |
|
5139 goto close; |
|
5140 } |
|
5141 sleep(5); |
|
5142 err1 = send(sock_fd, msg, 5, 0); |
|
5143 if(err1 == -1 ) |
|
5144 { |
|
5145 printf("send() failed returned errno = %d", errno); |
|
5146 } |
|
5147 else |
|
5148 { |
|
5149 ret = -1; |
|
5150 } |
|
5151 close: |
|
5152 close(sock_fd); |
|
5153 return (void*)ret; |
|
5154 } |
|
5155 |
|
5156 |
|
5157 TInt CTestSocket::SockSendOnClosedConn() |
|
5158 { |
|
5159 int sock_fd,newsock_fd; |
|
5160 unsigned int addr_len; |
|
5161 sockaddr_in serv_addr,new_socket; |
|
5162 TInt ret = KErrNone; |
|
5163 |
|
5164 int threadRetVal = 0; |
|
5165 void *threadRetValPtr = (void*)&threadRetVal; |
|
5166 sock_fd = socket(AF_INET,SOCK_STREAM,0); |
|
5167 if (sock_fd < 0) |
|
5168 { |
|
5169 return KErrSocket; |
|
5170 } |
|
5171 serv_addr.sin_family = AF_INET; |
|
5172 serv_addr.sin_addr.s_addr = inet_addr("127.0.0.1"); |
|
5173 serv_addr.sin_port = htons(12349); |
|
5174 pthread_t clientThread; |
|
5175 if (bind(sock_fd,(sockaddr*)&serv_addr,sizeof(serv_addr)) < 0) |
|
5176 { |
|
5177 INFO_PRINTF2(_L("bind return with errno = %d"), errno); |
|
5178 return KErrBind; |
|
5179 } |
|
5180 if(-1 == listen(sock_fd, 1)) |
|
5181 { |
|
5182 printf("error listen failed"); |
|
5183 close(sock_fd); |
|
5184 return -1; |
|
5185 } |
|
5186 |
|
5187 pthread_create(&clientThread, NULL, &create_socket, (void*)(serv_addr.sin_port)); |
|
5188 addr_len = sizeof(new_socket); |
|
5189 newsock_fd = accept(sock_fd,(sockaddr*)&new_socket,&addr_len); |
|
5190 if (errno != 0 ) |
|
5191 { |
|
5192 INFO_PRINTF2(_L("Accept return with errno = %d"), errno); |
|
5193 ret = -1; |
|
5194 } |
|
5195 |
|
5196 close(newsock_fd); |
|
5197 close(sock_fd); |
|
5198 pthread_join(clientThread, &threadRetValPtr ); |
|
5199 if (threadRetVal < 0) |
|
5200 { |
|
5201 INFO_PRINTF1(_L("SockSendOnClosedConn failed")); |
|
5202 ret = threadRetVal; |
|
5203 } |
|
5204 return ret; |
|
5205 } |
|
5206 |
|
5207 // ========================== OTHER EXPORTED FUNCTIONS ========================= |
|
5208 // None |
|
5209 |
|
5210 // End of File |
|
5211 |
|
5212 |