391 } |
391 } |
392 } |
392 } |
393 |
393 |
394 void CSocketDesc::Write (TDes8& aBuf, TRequestStatus& aStatus) |
394 void CSocketDesc::Write (TDes8& aBuf, TRequestStatus& aStatus) |
395 { |
395 { |
396 |
396 //Acquire the Lock before write and release it later |
397 TInt err = maybe_reopen_socket(); |
397 iWriteLock.Wait(); |
398 if (err != KErrNone) |
398 if (iSocketPtr == NULL) |
|
399 { |
|
400 TInt ret = OpenUsingPreference(); |
|
401 if (ret != KErrNone) // Error in open |
|
402 { |
|
403 Complete(aStatus,ret); |
|
404 iWriteLock.Signal(); |
|
405 return; |
|
406 } |
|
407 } |
|
408 CSockDescBase::Write(aBuf, aStatus); |
|
409 iWriteLock.Signal(); |
|
410 } |
|
411 |
|
412 void CSocketDesc::WriteCancel() |
|
413 { |
|
414 if (iSocketPtr != NULL) |
|
415 { |
|
416 CSockDescBase::WriteCancel(); |
|
417 } |
|
418 } |
|
419 |
|
420 |
|
421 TInt CSocketDesc::Bind(const struct sockaddr* aAddr, unsigned long aSize) |
|
422 { |
|
423 TInt ret; |
|
424 TUSockAddr addr(aAddr,aSize); |
|
425 |
|
426 if (addr.iError != 0) |
|
427 { |
|
428 return addr.iError; |
|
429 } |
|
430 |
|
431 if (iSocketPtr == NULL) |
|
432 { |
|
433 ret = OpenUsingPreference(); |
|
434 if (ret != KErrNone) // Error in open |
|
435 { |
|
436 return ret; |
|
437 } |
|
438 } |
|
439 return iSocket.Bind(addr); |
|
440 } |
|
441 |
|
442 TInt CSocketDesc::Listen(TUint qSize) |
|
443 { |
|
444 if (iStyle == SOCK_DGRAM) // Listen on UDP socket, crashing at RSocket::Listen(). |
|
445 { |
|
446 return EOPNOTSUPP; |
|
447 } |
|
448 if (iSocketPtr == NULL) |
|
449 { |
|
450 TInt ret = OpenUsingPreference(); |
|
451 if (ret != KErrNone) // Error in open |
|
452 { |
|
453 return ret; |
|
454 } |
|
455 } |
|
456 return CSockDescBase::Listen(qSize); |
|
457 } |
|
458 |
|
459 TInt CSocketDesc::SockName(int anEnd, struct sockaddr* anAddr,unsigned long* aSize) |
|
460 { |
|
461 TInt ret; |
|
462 if (iSocketPtr == NULL) |
399 { |
463 { |
400 Complete(aStatus, err); |
464 ret = OpenUsingPreference(); |
401 return; |
465 if (ret != KErrNone) // Error in open |
|
466 { |
|
467 return ret; |
|
468 } |
402 } |
469 } |
403 |
470 |
404 iWriteLock.Wait(); |
471 if ( anAddr == 0 ) // if the sockaddr passed is NULL return EFAULT. |
405 CSockDescBase::Write(aBuf, aStatus); |
|
406 iWriteLock.Signal(); |
|
407 } |
|
408 |
|
409 void CSocketDesc::WriteCancel() |
|
410 { |
|
411 if (iSocketPtr != NULL) |
|
412 { |
|
413 CSockDescBase::WriteCancel(); |
|
414 } |
|
415 } |
|
416 |
|
417 |
|
418 TInt CSocketDesc::Bind(const struct sockaddr* aAddr, unsigned long aSize) |
|
419 { |
|
420 TInt ret; |
|
421 TUSockAddr addr(aAddr,aSize); |
|
422 |
|
423 if (addr.iError != 0) |
|
424 { |
|
425 return addr.iError; |
|
426 } |
|
427 |
|
428 ret = maybe_reopen_socket(); |
|
429 if (ret != KErrNone) |
|
430 return ret; |
|
431 ATOMICSOCKETOP(ret = iSocket.Bind(addr),return KErrBadHandle) |
|
432 return ret; |
|
433 } |
|
434 |
|
435 TInt CSocketDesc::Listen(TUint qSize) |
|
436 { |
|
437 |
|
438 TInt ret; |
|
439 if (iStyle == SOCK_DGRAM) // Listen on UDP socket, crashing at RSocket::Listen(). |
|
440 { |
|
441 return EOPNOTSUPP; |
|
442 } |
|
443 |
|
444 ret = maybe_reopen_socket(); |
|
445 if (ret != KErrNone) |
|
446 return ret; |
|
447 |
|
448 return CSockDescBase::Listen(qSize); |
|
449 } |
|
450 |
|
451 TInt CSocketDesc::SockName(int anEnd, struct sockaddr* anAddr,unsigned long* aSize) |
|
452 { |
|
453 |
|
454 |
|
455 if (!anAddr) |
|
456 { |
472 { |
457 return EFAULT; |
473 return EFAULT; |
458 } |
474 } |
459 |
475 |
460 TInt ret = maybe_reopen_socket(); |
|
461 if (ret != KErrNone) |
|
462 return ret; |
|
463 |
|
464 |
476 |
465 struct sockaddr temp; |
477 struct sockaddr temp; |
466 unsigned long len = sizeof( temp ); |
478 unsigned long len = sizeof( temp ); |
467 |
479 |
468 TUSockAddr nSockAddr(&temp, len ); |
480 TUSockAddr nSockAddr(&temp, len ); |
489 } |
501 } |
490 if (anOption.Length() == 0) |
502 if (anOption.Length() == 0) |
491 { |
503 { |
492 return EINVAL; |
504 return EINVAL; |
493 } |
505 } |
494 |
506 if (iSocketPtr == NULL) |
495 ret = maybe_reopen_socket(); |
507 { |
496 if (ret != KErrNone) |
508 ret = OpenUsingPreference(); |
497 return ret; |
509 if (ret != KErrNone) // Error in open |
|
510 { |
|
511 return ret; |
|
512 } |
|
513 } |
498 |
514 |
499 if (SO_TYPE == anOptionName && SOL_SOCKET == anOptionLevel) |
515 if (SO_TYPE == anOptionName && SOL_SOCKET == anOptionLevel) |
500 { |
516 { |
501 TProtocolDesc protocolInfo; |
517 TProtocolDesc protocolInfo; |
502 ATOMICSOCKETOP(ret = iSocket.Info(protocolInfo), ret = KErrBadHandle) |
518 ret = iSocket.Info(protocolInfo); |
503 if (KErrNone == ret ) |
519 if (KErrNone == ret ) |
504 { |
520 { |
505 // Copy the Socket Type to the buffer |
521 //Copy the Socket Type to the buffer |
506 TInt size = (anOption.Length() < sizeof(protocolInfo.iSockType))? anOption.Length(): sizeof(protocolInfo.iSockType); |
522 TInt size; |
|
523 size = (anOption.Length() < sizeof(protocolInfo.iSockType))? anOption.Length(): sizeof(protocolInfo.iSockType); |
507 Mem::Copy((unsigned char*)anOption.Ptr(), &protocolInfo.iSockType, size); |
524 Mem::Copy((unsigned char*)anOption.Ptr(), &protocolInfo.iSockType, size); |
508 anOption.SetLength(size); |
525 anOption.SetLength(size); |
509 } |
526 } |
510 return ret; |
527 return ret; |
511 } |
528 } |
513 if(IPPROTO_IP == anOptionLevel && IP_MULTICAST_IF == anOptionName) |
530 if(IPPROTO_IP == anOptionLevel && IP_MULTICAST_IF == anOptionName) |
514 { |
531 { |
515 TUSockAddr addr; |
532 TUSockAddr addr; |
516 struct sockaddr_in sockAddress; |
533 struct sockaddr_in sockAddress; |
517 sockAddress.sin_family = AF_INET; |
534 sockAddress.sin_family = AF_INET; |
518 ATOMICSOCKETOP(sockAddress.sin_port = iSocket.LocalPort(),return KErrBadHandle) |
535 sockAddress.sin_port = iSocket.LocalPort(); |
519 ATOMICSOCKETOP(iSocket.LocalName(addr);,return KErrBadHandle) |
536 iSocket.LocalName(addr); |
|
537 |
520 TInt a = sizeof(sockAddress); |
538 TInt a = sizeof(sockAddress); |
521 addr.Get(&sockAddress,(unsigned long*)&a); |
539 addr.Get(&sockAddress,(unsigned long*)&a); |
522 TInt size = (anOption.Length() < sizeof(sockAddress.sin_addr))? anOption.Length(): sizeof(sockAddress.sin_addr); |
540 TInt size; |
|
541 size = (anOption.Length() < sizeof(sockAddress.sin_addr))? anOption.Length(): sizeof(sockAddress.sin_addr); |
523 Mem::Copy((unsigned char*)anOption.Ptr(), &(sockAddress.sin_addr), size); |
542 Mem::Copy((unsigned char*)anOption.Ptr(), &(sockAddress.sin_addr), size); |
524 anOption.SetLength(size); |
543 anOption.SetLength(size); |
525 return KErrNone; |
544 return KErrNone; |
526 } |
545 } |
|
546 |
|
547 |
527 |
548 |
528 switch(anOptionLevel) |
549 switch(anOptionLevel) |
529 { |
550 { |
530 case IPPROTO_TCP: |
551 case IPPROTO_TCP: |
531 anOptionLevel=SOL_TCP; |
552 anOptionLevel=SOL_TCP; |
575 aIndex = 0; |
596 aIndex = 0; |
576 return aIndex; |
597 return aIndex; |
577 } |
598 } |
578 else |
599 else |
579 { |
600 { |
580 TInt ret = KErrNone; |
601 TInt ret = iSocket.SetOpt(KSoInetEnumInterfaces, KSolInetIfCtrl); |
581 ATOMICSOCKETOP(ret = iSocket.SetOpt(KSoInetEnumInterfaces, KSolInetIfCtrl), ret = KErrBadHandle) |
|
582 if (ret != KErrNone) |
602 if (ret != KErrNone) |
583 return KErrGeneral; |
603 return KErrGeneral; |
584 |
604 |
585 TPckgBuf<TSoInetInterfaceInfo>iface; |
605 TPckgBuf<TSoInetInterfaceInfo>iface; |
586 ATOMICSOCKETOP( ret = iSocket.GetOpt(KSoInetNextInterface, KSolInetIfCtrl, iface), ret = KErrBadHandle ) |
606 while(iSocket.GetOpt(KSoInetNextInterface, KSolInetIfCtrl, iface) == KErrNone) |
587 while(ret == KErrNone) |
|
588 { |
607 { |
589 TSoInetInterfaceInfo &info = iface(); |
608 TSoInetInterfaceInfo &info = iface(); |
590 TInt result; |
609 TInt result; |
591 if(info.iState == EIfUp) |
610 if(info.iState == EIfUp) |
592 { |
611 { |
593 if (anAddr == info.iAddress.Address()) |
612 if (anAddr == info.iAddress.Address()) |
594 { |
613 { |
595 ifq().iName = info.iName; |
614 ifq().iName = info.iName; |
596 ATOMICSOCKETOP( result = iSocket.GetOpt(KSoInetIfQueryByName, KSolInetIfQuery, ifq), result = KErrBadHandle ) |
615 result = iSocket.GetOpt(KSoInetIfQueryByName, KSolInetIfQuery, ifq); |
597 if (result == KErrNone) |
616 if (result == KErrNone) |
598 aIndex = ifq().iIndex; |
617 aIndex = ifq().iIndex; |
599 |
618 |
600 } |
619 } |
601 } |
620 } |
602 ATOMICSOCKETOP( ret = iSocket.GetOpt(KSoInetNextInterface, KSolInetIfCtrl, iface), ret = KErrBadHandle ) |
621 |
603 } |
622 } |
604 } |
623 } |
605 return aIndex; |
624 return aIndex; |
606 } |
625 } |
607 |
626 |
669 // Set the multicast addr |
692 // Set the multicast addr |
670 from = (TUint8 *)anOption.Ptr(); |
693 from = (TUint8 *)anOption.Ptr(); |
671 maddr=(from[0]<<24)+(from[1]<<16)+(from[2]<<8)+from[3]; |
694 maddr=(from[0]<<24)+(from[1]<<16)+(from[2]<<8)+from[3]; |
672 multiAddr.SetAddress( maddr); |
695 multiAddr.SetAddress( maddr); |
673 multiAddr.ConvertToV4Mapped(); |
696 multiAddr.ConvertToV4Mapped(); |
674 if (multiAddr.IsMulticast()) |
697 if(multiAddr.IsMulticast()){ |
675 { |
698 req().iAddr = multiAddr.Ip6Address(); |
676 req().iAddr = multiAddr.Ip6Address(); |
699 req().iInterface = aIndex; |
677 req().iInterface = aIndex; |
700 } |
678 } |
701 return iSocket.SetOpt(anOptionName, anOptionLevel, req); |
679 ATOMICSOCKETOP( ret = iSocket.SetOpt(anOptionName, anOptionLevel, req), return KErrBadHandle ) |
|
680 return ret; |
|
681 |
702 |
682 case IP_MULTICAST_TTL: |
703 case IP_MULTICAST_TTL: |
683 anOptionLevel=KSolInetIp; |
704 anOptionLevel=KSolInetIp; |
684 anOptionName=KSoIp6MulticastHops; |
705 anOptionName=KSoIp6MulticastHops; |
685 Option = (TInt*)anOption.Ptr(); |
706 Option = (TInt*)anOption.Ptr(); |
686 ttlValue = *Option; |
707 ttlValue = *Option; |
687 ATOMICSOCKETOP( ret = iSocket.SetOpt(anOptionName,anOptionLevel,ttlValue), return KErrBadHandle ) |
708 return iSocket.SetOpt(anOptionName,anOptionLevel,ttlValue); |
688 return ret; |
709 |
689 |
|
690 case SO_BROADCAST: |
710 case SO_BROADCAST: |
691 //check if user is trying to disable broadcast |
711 //check if user is trying to disable broadcast |
692 Option = (TInt*)anOption.Ptr(); |
712 Option = (TInt*)anOption.Ptr(); |
693 return (*Option == 0 ? KErrNotSupported : KErrNone); |
713 if (*Option == 0) |
|
714 { |
|
715 return KErrNotSupported; |
|
716 } |
|
717 else |
|
718 { |
|
719 return KErrNone; |
|
720 } |
694 |
721 |
695 case IP_MULTICAST_IF: |
722 case IP_MULTICAST_IF: |
696 { |
723 { |
697 //No support for equivalent flag KsoIp6MulticastIf presently |
724 //No support for equivalent flag KsoIp6MulticastIf presently |
698 //call bind instead |
725 //call bind instead |
699 struct in_addr *inAddress = (struct in_addr*)anOption.Ptr(); |
726 struct in_addr *inAddress = (struct in_addr*)anOption.Ptr(); |
700 struct sockaddr_in sockAddress; |
727 struct sockaddr_in sockAddress; |
701 sockAddress.sin_family = AF_INET; |
728 sockAddress.sin_family = AF_INET; |
702 ATOMICSOCKETOP(sockAddress.sin_port = iSocket.LocalPort();,return KErrBadHandle) |
729 sockAddress.sin_port = iSocket.LocalPort(); |
703 sockAddress.sin_addr.s_addr = inAddress->s_addr; |
730 sockAddress.sin_addr.s_addr = inAddress->s_addr; |
704 TUSockAddr ifAddress(&sockAddress, sizeof(sockAddress)); |
731 TUSockAddr ifAddress(&sockAddress, sizeof(sockAddress)); |
705 ATOMICSOCKETOP( ret = iSocket.Bind(ifAddress), return KErrBadHandle ) |
732 return iSocket.Bind(ifAddress); |
706 return ret; |
|
707 } |
733 } |
708 |
734 |
709 case IP_MULTICAST_LOOP: |
735 case IP_MULTICAST_LOOP: |
710 anOptionLevel=KSolInetIp; |
736 anOptionLevel=KSolInetIp; |
711 anOptionName=KSoIp6MulticastLoop; |
737 anOptionName=KSoIp6MulticastLoop; |
712 break; |
738 break; |
713 |
739 |
714 |
740 default: |
715 |
741 break; |
716 } |
742 |
717 ATOMICSOCKETOP( ret = iSocket.SetOpt(anOptionName,anOptionLevel,anOption), return KErrBadHandle ) |
743 } |
718 return ret; |
744 return iSocket.SetOpt(anOptionName,anOptionLevel,anOption); |
719 } |
745 } |
720 |
746 |
721 void CSocketDesc::Sync (TRequestStatus& aStatus) |
747 void CSocketDesc::Sync (TRequestStatus& aStatus) |
722 { |
748 { |
723 // Judging from the Solaris man pages, this does nothing. |
749 // Judging from the Solaris man pages, this does nothing. |
724 Complete(aStatus,KErrNone); |
750 Complete(aStatus,KErrNone); |
725 } |
751 } |
726 |
752 |
727 void CSocketDesc::RecvFrom(TDes8& aDesc, TSockAddr& from, int flags, TRequestStatus& aStatus) |
753 void CSocketDesc::RecvFrom(TDes8& aDesc, TSockAddr& from, int flags, TRequestStatus& aStatus) |
728 { |
754 { |
729 TInt err = maybe_reopen_socket(); |
|
730 if (err != KErrNone) |
|
731 { |
|
732 Complete(aStatus, err); |
|
733 return; |
|
734 } |
|
735 |
|
736 iReadLock.Wait(); |
755 iReadLock.Wait(); |
|
756 // RSocket::Open() is postponed from socket() |
|
757 if (iSocketPtr == NULL) |
|
758 { |
|
759 TInt ret = OpenUsingPreference(); |
|
760 if (ret != KErrNone) |
|
761 { |
|
762 Complete(aStatus,ret); // Error in open |
|
763 iReadLock.Signal(); |
|
764 return; |
|
765 } |
|
766 } |
|
767 |
737 CSockDescBase::RecvFrom(aDesc, from, flags, aStatus); |
768 CSockDescBase::RecvFrom(aDesc, from, flags, aStatus); |
738 iReadLock.Signal(); |
769 iReadLock.Signal(); |
739 } |
770 } |
740 |
771 |
741 void CSocketDesc::RecvFromCancel() |
772 void CSocketDesc::RecvFromCancel() |
747 } |
778 } |
748 |
779 |
749 |
780 |
750 void CSocketDesc::SendTo(TDes8& aDesc, const struct sockaddr* anAddr, unsigned long aAddrLen, int flags, TRequestStatus& aStatus) |
781 void CSocketDesc::SendTo(TDes8& aDesc, const struct sockaddr* anAddr, unsigned long aAddrLen, int flags, TRequestStatus& aStatus) |
751 { |
782 { |
752 TInt err = maybe_reopen_socket(); |
783 iWriteLock.Wait(); |
753 if (err != KErrNone) |
784 |
754 { |
785 if (iSocketPtr == NULL) |
755 Complete(aStatus, err); |
786 { |
756 return; |
787 TInt ret = OpenUsingPreference(); |
757 } |
788 if (ret != KErrNone) |
758 |
789 { |
759 TUSockAddr toAddr(anAddr, aAddrLen); |
790 Complete(aStatus,ret); // Error in open |
760 |
791 iWriteLock.Signal(); |
761 iWriteLock.Wait(); |
792 return; |
|
793 } |
|
794 } |
|
795 TUSockAddr toAddr(anAddr,aAddrLen); |
762 CSockDescBase::SendTo(aDesc, toAddr, flags, aStatus); |
796 CSockDescBase::SendTo(aDesc, toAddr, flags, aStatus); |
763 iWriteLock.Signal(); |
797 iWriteLock.Signal(); |
764 } |
798 } |
765 |
799 |
766 void CSocketDesc::SendToCancel() |
800 void CSocketDesc::SendToCancel() |
767 { |
801 { |
768 // Should we use atomic loads here? |
|
769 if (iSocketPtr != NULL) |
802 if (iSocketPtr != NULL) |
770 { |
803 { |
771 CSockDescBase::SendToCancel(); |
804 CSockDescBase::SendToCancel(); |
772 } |
805 } |
773 } |
806 } |
774 |
807 |
775 void CSocketDesc::Shutdown(TUint aHow,TRequestStatus& aStatus) |
808 void CSocketDesc::Shutdown(TUint aHow,TRequestStatus& aStatus) |
776 { |
809 { |
777 |
810 if (iSocketPtr == NULL) // Not opened at all. Nothing to do. |
778 if (__e32_atomic_load_acq32(&iSocketPtr) == NULL) // Not opened at all. Nothing to do. |
|
779 { |
811 { |
780 Complete(aStatus,KErrNone); |
812 Complete(aStatus,KErrNone); |
781 return; |
813 return; |
782 } |
814 } |
783 |
815 |
785 return; |
817 return; |
786 } |
818 } |
787 |
819 |
788 void CSocketDesc::Accept(CFileDescBase*& aNewSocket, TRequestStatus& aStatus, RSocketServ& aSs, TSockAddr * /*aAddr*/) |
820 void CSocketDesc::Accept(CFileDescBase*& aNewSocket, TRequestStatus& aStatus, RSocketServ& aSs, TSockAddr * /*aAddr*/) |
789 { |
821 { |
790 aNewSocket = NULL; |
822 //Acquire the Lock before accept and release it later |
791 TInt err = maybe_reopen_socket(); |
|
792 if (err != KErrNone) |
|
793 { |
|
794 Complete(aStatus, err); |
|
795 return; |
|
796 } |
|
797 |
|
798 iReadLock.Wait(); |
823 iReadLock.Wait(); |
799 // what are the below coverity thingummichs? |
824 |
|
825 TInt err = KErrNone; |
|
826 if (iSocketPtr == NULL) |
|
827 { |
|
828 err = OpenUsingPreference(); |
|
829 if (err != KErrNone) // Error in open |
|
830 { |
|
831 Complete(aStatus,err); |
|
832 iReadLock.Signal(); |
|
833 return; |
|
834 } |
|
835 } |
|
836 |
800 //coverity[alloc_fn] |
837 //coverity[alloc_fn] |
801 //coverity[assign] |
838 //coverity[assign] |
802 CSocketDesc *newSocket = new CSocketDesc; |
839 CSocketDesc *newSocket = new CSocketDesc; |
803 if (!newSocket) |
840 if (newSocket!=0) |
804 { |
841 { |
805 Complete(aStatus, KErrNoMemory); |
842 err = newSocket->CreateLock(); |
806 iReadLock.Signal(); |
843 if (err) |
807 return; |
844 { |
808 } |
845 Complete(aStatus, KErrNoMemory); |
809 |
846 delete newSocket; |
810 err = newSocket->CreateLock(); |
847 aNewSocket = NULL; |
811 if (err) |
848 iReadLock.Signal(); |
812 { |
849 //coverity[memory_leak] |
813 Complete(aStatus, KErrNoMemory); |
850 return; |
814 delete newSocket; |
851 } |
815 iReadLock.Signal(); |
852 |
816 //coverity[memory_leak] |
853 err=newSocket->iSocket.Open(aSs); |
817 return; |
854 } |
818 } |
855 if (newSocket ==0 || err!=KErrNone) |
819 |
856 { |
820 err = newSocket->iSocket.Open(aSs); |
857 Complete(aStatus,KErrNoMemory); |
821 if (err) |
|
822 { |
|
823 Complete(aStatus, err); |
|
824 newSocket->FinalClose(); // this will Close locks |
|
825 delete newSocket; |
858 delete newSocket; |
826 |
859 aNewSocket = NULL; |
827 iReadLock.Signal(); |
860 iReadLock.Signal(); |
828 //coverity[memory_leak] |
861 //coverity[memory_leak] |
829 return; |
862 return; |
830 } |
863 } |
831 newSocket->iSocketPtr = &newSocket->iSocket; |
864 newSocket->iSocketPtr = &newSocket->iSocket; |
832 newSocket->iStyle = iStyle; |
865 newSocket->iStyle = iStyle; |
833 err = KErrNone; |
866 iSocket.Accept(newSocket->iSocket,aStatus); |
834 ATOMICSOCKETOP( iSocket.Accept(newSocket->iSocket,aStatus), err = KErrBadHandle ) |
867 aNewSocket = newSocket; |
835 if( err ) |
|
836 { |
|
837 Complete(aStatus, err); |
|
838 newSocket->FinalClose(); // this will Close locks |
|
839 delete newSocket; |
|
840 } |
|
841 else |
|
842 { |
|
843 aNewSocket = newSocket; |
|
844 } |
|
845 iReadLock.Signal(); |
868 iReadLock.Signal(); |
846 } |
869 } |
847 |
870 |
848 void CSocketDesc::AcceptCancel() |
871 void CSocketDesc::AcceptCancel() |
849 { |
872 { |
850 if (iSocketPtr != NULL) |
873 if (iSocketPtr != NULL) |
851 { |
874 { |
852 ATOMICSOCKETOP( iSocket.CancelAccept(), NOP ) |
875 iSocket.CancelAccept(); |
853 } |
876 } |
854 } |
877 } |
855 |
878 |
856 void CSocketDesc::Connect(const struct sockaddr* aAddr,unsigned long size,TRequestStatus& aStatus) |
879 void CSocketDesc::Connect(const struct sockaddr* aAddr,unsigned long size,TRequestStatus& aStatus) |
857 { |
880 { |
860 if (addr.iError != 0) |
883 if (addr.iError != 0) |
861 { |
884 { |
862 aStatus = addr.iError; |
885 aStatus = addr.iError; |
863 return; |
886 return; |
864 } |
887 } |
865 |
888 if (iSocketPtr == NULL) |
866 TInt err = maybe_reopen_socket(); |
889 { |
867 if (err != KErrNone) |
890 // RSocket::Open() is postponed from socket() |
868 { |
891 TInt ret = OpenUsingPreference(); |
869 aStatus = err; |
892 if (ret != KErrNone) // error in open |
870 return; |
893 { |
871 } |
894 aStatus = ret; |
872 |
895 return; |
873 iWriteLock.Wait(); |
896 } |
874 if( GetConnectionProgress() == EFalse ) |
897 } |
875 { |
898 |
876 ATOMICSOCKETOP(iSocket.Connect(addr, aStatus), Complete(aStatus,KErrBadHandle)) |
899 iSocket.Connect(addr,aStatus); |
877 User::WaitForRequest(aStatus); |
900 User::WaitForRequest(aStatus); |
878 if( aStatus.Int() == KErrWouldBlock ) |
|
879 SetConnectionProgress(ETrue); |
|
880 } |
|
881 else |
|
882 { |
|
883 aStatus = EALREADY; |
|
884 } |
|
885 iWriteLock.Signal(); |
|
886 } |
901 } |
887 |
902 |
888 void CSocketDesc::ConnectCancel() |
903 void CSocketDesc::ConnectCancel() |
889 { |
904 { |
890 if (iSocketPtr != NULL) |
905 if (iSocketPtr != NULL) |
891 { |
906 { |
892 ATOMICSOCKETOP(iSocket.CancelConnect(),NOP) |
907 iSocket.CancelConnect(); |
893 } |
908 } |
894 } |
909 } |
895 |
910 |
896 void CSocketDesc::Ioctl(int aCmd, void* aParam, TRequestStatus& aStatus) |
911 void CSocketDesc::Ioctl(int aCmd, void* aParam, TRequestStatus& aStatus) |
897 { |
912 { |
898 TInt ret = KErrNone; |
913 TInt ret=KErrNone; |
899 int* param = reinterpret_cast<int*>(aParam); |
914 int* param = reinterpret_cast<int*>(aParam); |
900 |
915 |
901 ret = maybe_reopen_socket(); |
916 if (iSocketPtr == NULL) |
902 if (ret != KErrNone) |
917 { |
903 { |
918 ret = OpenUsingPreference(); |
904 Complete(aStatus, ret); |
919 if (ret != KErrNone) // Error in open |
905 return; |
920 { |
906 } |
921 Complete(aStatus,ret); |
|
922 return; |
|
923 } |
|
924 } |
907 |
925 |
908 switch ((unsigned)aCmd) |
926 switch ((unsigned)aCmd) |
909 { |
927 { |
910 case FIONREAD: |
928 case FIONREAD: |
911 case E32IONREAD: |
929 case E32IONREAD: |
912 { |
930 ret=iSocket.GetOpt(KSOReadBytesPending,KSOLSocket,*param); |
913 ATOMICSOCKETOP( ret=iSocket.GetOpt(KSOReadBytesPending,KSOLSocket,*param), ret = KErrBadHandle ) |
|
914 } |
|
915 break; |
931 break; |
916 case E32IOSELECT: |
932 case E32IOSELECT: |
917 { |
933 { |
918 iIoctlBuf.Set((TText8*)aParam,4,4); |
934 iIoctlBuf.Set((TText8*)aParam,4,4); |
919 iIoctlLock.Wait(); |
935 iIoctlLock.Wait(); |
920 iIoctlFlag = ETrue; |
936 iIoctlFlag = ETrue; |
921 ATOMICSOCKETOP(iSocket.Ioctl(KIOctlSelect,aStatus,&iIoctlBuf,KSOLSocket), Complete(aStatus,KErrBadHandle)) |
937 iSocket.Ioctl(KIOctlSelect,aStatus,&iIoctlBuf,KSOLSocket); |
922 } |
938 } |
923 return; |
939 return; |
924 case SIOCGIFCONF: |
940 case SIOCGIFCONF: |
925 ret = GetInterfaceList(aParam); |
941 ret = GetInterfaceList(aParam); |
926 break; |
942 break; |
1008 // As of now fcntl supports F_SETFL and F_GETFL |
1024 // As of now fcntl supports F_SETFL and F_GETFL |
1009 // ----------------------------------------------------------------------------- |
1025 // ----------------------------------------------------------------------------- |
1010 // |
1026 // |
1011 TInt CSocketDesc::Fcntl(TUint anArg, TUint aCmd) |
1027 TInt CSocketDesc::Fcntl(TUint anArg, TUint aCmd) |
1012 { |
1028 { |
1013 |
1029 if (iSocketPtr == NULL) |
1014 TInt err = maybe_reopen_socket(); |
1030 { |
1015 if (err != KErrNone) |
1031 TInt ret = OpenUsingPreference(); |
1016 return err; |
1032 if (ret != KErrNone) // Error in open |
1017 |
1033 { |
1018 return CSockDescBase::Fcntl(anArg, aCmd); |
1034 return ret; |
|
1035 } |
|
1036 } |
|
1037 return CSockDescBase::Fcntl(anArg, aCmd); |
1019 } |
1038 } |
1020 |
1039 |
1021 TInt CSocketDesc :: GetIpAddress( void *aParam ) |
1040 TInt CSocketDesc :: GetIpAddress( void *aParam ) |
1022 { |
1041 { |
1023 TInetAddr myAddr; |
1042 TInetAddr myAddr; |
1024 ATOMICSOCKETOP( iSocket.LocalName(myAddr), return KErrBadHandle ) |
1043 iSocket.LocalName(myAddr); |
1025 TUint32 myIP = myAddr.Address(); |
1044 TUint32 myIP = myAddr.Address(); |
1026 if (myIP == 0) |
1045 ifreq *ifr = (ifreq *)aParam; |
|
1046 if(myIP == 0) |
1027 { |
1047 { |
1028 return KErrGeneral; |
1048 return KErrGeneral; |
1029 } |
1049 } |
1030 |
|
1031 ifreq *ifr = (ifreq *)aParam; |
|
1032 ((struct sockaddr_in *)&ifr->ifr_addr)->sin_addr.s_addr = myIP; |
1050 ((struct sockaddr_in *)&ifr->ifr_addr)->sin_addr.s_addr = myIP; |
1033 return KErrNone; |
1051 return KErrNone; |
1034 } |
1052 } |
1035 |
1053 |
1036 TInt CSocketDesc :: GetRemoteIpAddress( void *aParam ) |
1054 TInt CSocketDesc :: GetRemoteIpAddress( void *aParam ) |
1037 { |
1055 { |
1038 TInetAddr remoteAddr; |
1056 TInetAddr remoteAddr; |
1039 ATOMICSOCKETOP( iSocket.RemoteName(remoteAddr), return KErrBadHandle ) |
1057 iSocket.RemoteName(remoteAddr); |
1040 TUint32 remoteIP = remoteAddr.Address(); |
1058 TUint32 remoteIP = remoteAddr.Address(); |
1041 |
1059 ifreq *ifr = (ifreq *)aParam; |
1042 if (remoteIP == 0) |
1060 if(remoteIP == 0) |
1043 { |
1061 { |
1044 return KErrGeneral; |
1062 return KErrGeneral; |
1045 } |
1063 } |
1046 ifreq *ifr = (ifreq *)aParam; |
|
1047 ((struct sockaddr_in *)&ifr->ifr_dstaddr)->sin_addr.s_addr = remoteIP; |
1064 ((struct sockaddr_in *)&ifr->ifr_dstaddr)->sin_addr.s_addr = remoteIP; |
1048 return KErrNone; |
1065 return KErrNone; |
1049 } |
1066 } |
1050 |
1067 |
1051 TInt CSocketDesc :: GetInterafceNumber( void *aParam ) |
1068 TInt CSocketDesc :: GetInterafceNumber( void *aParam ) |
1189 { |
1206 { |
1190 ifreq *ifr = (ifreq *)aParam; |
1207 ifreq *ifr = (ifreq *)aParam; |
1191 TPckgBuf<TSoInetIfQuery> ifq; |
1208 TPckgBuf<TSoInetIfQuery> ifq; |
1192 TBuf8 <25> ipBuf8; |
1209 TBuf8 <25> ipBuf8; |
1193 TName aBuf; |
1210 TName aBuf; |
1194 TInt ret = KErrNone; |
1211 |
1195 ATOMICSOCKETOP( ret = iSocket.SetOpt(KSoInetEnumInterfaces, KSolInetIfCtrl), ret = KErrBadHandle ) |
1212 TInt ret = iSocket.SetOpt(KSoInetEnumInterfaces, KSolInetIfCtrl); |
1196 if (ret != KErrNone) |
1213 if (ret != KErrNone) |
1197 { |
1214 { |
1198 return KErrGeneral; |
1215 return KErrGeneral; |
1199 } |
1216 } |
1200 TPckgBuf<TSoInet6InterfaceInfo> info; |
1217 TPckgBuf<TSoInet6InterfaceInfo> info; |
1201 TSoInet6InterfaceInfo &in = info(); |
1218 TSoInet6InterfaceInfo &in = info(); |
1202 ATOMICSOCKETOP( ret = iSocket.GetOpt(KSoInetNextInterface, KSolInetIfCtrl, info), ret = KErrBadHandle ) |
1219 |
1203 while(ret == KErrNone) |
1220 while(iSocket.GetOpt(KSoInetNextInterface, KSolInetIfCtrl, info) == KErrNone) |
1204 { |
1221 { |
1205 if(info().iName != _L("") && info().iName != _L("loop6") && info().iName != _L("loop4")) |
1222 if(info().iName != _L("") && info().iName != _L("loop6") && info().iName != _L("loop4")) |
1206 { |
1223 { |
1207 TDes16& aName = info().iName; |
1224 TDes16& aName = info().iName; |
1208 if( ((aFlag == 0 ) && ( aName.FindC(_L("WLAN")) != KErrNotFound )) || |
1225 if( ((aFlag == 0 ) && ( aName.FindC(_L("WLAN")) != KErrNotFound )) || |
1305 default: |
1322 default: |
1306 break; |
1323 break; |
1307 } |
1324 } |
1308 } |
1325 } |
1309 |
1326 |
1310 } |
1327 } |
1311 ATOMICSOCKETOP( ret = iSocket.GetOpt(KSoInetNextInterface, KSolInetIfCtrl, info), ret = KErrBadHandle ) |
|
1312 } |
1328 } |
1313 setout: |
1329 setout: |
1314 TPckgBuf<TSoInet6InterfaceInfo> changeToNew(info()); |
1330 TPckgBuf<TSoInet6InterfaceInfo> changeToNew(info()); |
1315 ATOMICSOCKETOP(ret = iSocket.SetOpt(KSoInetConfigInterface, KSolInetIfCtrl,changeToNew), return KErrBadHandle ) |
1331 return iSocket.SetOpt(KSoInetConfigInterface, KSolInetIfCtrl,changeToNew); |
1316 return ret; |
|
1317 } |
1332 } |
1318 #endif // __SYMBIAN_COMPILE_UNUSED__ |
1333 #endif // __SYMBIAN_COMPILE_UNUSED__ |
1319 |
1334 |
1320 TInt CSocketDesc::GetInterfaceDetails( void *aParam ,TInt aFlag, TInt aType ) |
1335 TInt CSocketDesc::GetInterfaceDetails( void *aParam ,TInt aFlag, TInt aType ) |
1321 { |
1336 { |
|
1337 ifreq *ifr = (ifreq *)aParam; |
1322 TPckgBuf<TSoInetIfQuery> ifq; |
1338 TPckgBuf<TSoInetIfQuery> ifq; |
1323 |
1339 |
1324 TInt ret = KErrNone; |
1340 TInt ret = iSocket.SetOpt(KSoInetEnumInterfaces, KSolInetIfCtrl); |
1325 ATOMICSOCKETOP( ret = iSocket.SetOpt(KSoInetEnumInterfaces, KSolInetIfCtrl), ret = KErrBadHandle ) |
|
1326 if (ret != KErrNone) |
1341 if (ret != KErrNone) |
1327 { |
1342 { |
1328 return KErrGeneral; |
1343 return KErrGeneral; |
1329 } |
1344 } |
1330 |
|
1331 ifreq *ifr = (ifreq *)aParam; |
|
1332 *(ifr->ifr_addr.sa_data) = '\0'; |
1345 *(ifr->ifr_addr.sa_data) = '\0'; |
1333 |
1346 |
1334 TPckgBuf<TSoInetInterfaceInfo> info; |
1347 TPckgBuf<TSoInetInterfaceInfo> info; |
1335 ATOMICSOCKETOP( ret = iSocket.GetOpt(KSoInetNextInterface, KSolInetIfCtrl, info), ret = KErrBadHandle ) |
1348 while(iSocket.GetOpt(KSoInetNextInterface, KSolInetIfCtrl, info) == KErrNone) |
1336 while( ret == KErrNone) |
|
1337 { |
1349 { |
1338 |
1350 |
1339 if(info().iName != _L("") && info().iName != _L("loop6") && info().iName != _L("loop4")) |
1351 if(info().iName != _L("") && info().iName != _L("loop6") && info().iName != _L("loop4")) |
1340 { |
1352 { |
1341 TDes16& aName = info().iName; |
1353 TDes16& aName = info().iName; |
1446 /* if(info().iFeatures&KIfCanSetMTU) |
1458 /* if(info().iFeatures&KIfCanSetMTU) |
1447 if(info().iFeatures&KIfHasHardwareAddr) |
1459 if(info().iFeatures&KIfHasHardwareAddr) |
1448 if(info().iFeatures&KIfCanSetHardwareAddr) */ |
1460 if(info().iFeatures&KIfCanSetHardwareAddr) */ |
1449 |
1461 |
1450 break; |
1462 break; |
1451 |
1463 default: |
|
1464 break; |
1452 } |
1465 } |
1453 } |
1466 } |
1454 |
1467 |
1455 } |
1468 } |
1456 ATOMICSOCKETOP( ret = iSocket.GetOpt(KSoInetNextInterface, KSolInetIfCtrl, info), ret = KErrBadHandle ) |
|
1457 } |
1469 } |
1458 |
1470 |
1459 return KErrNone; |
1471 return KErrNone; |
1460 } |
1472 } |
1461 |
1473 |
1462 TInt CSocketDesc::Poll(TPollMode aMode,TBool& aReadyStatus,TInt& aErrno) |
1474 TInt CSocketDesc::Poll(TPollMode aMode,TBool& aReadyStatus,TInt& aErrno) |
1463 { |
1475 { |
1464 TInt ret = maybe_reopen_socket(); |
1476 TInt ret; |
1465 if (ret != KErrNone) |
1477 |
1466 { |
1478 if (iSocketPtr == NULL) |
1467 return ret; |
1479 { |
1468 } |
1480 ret = OpenUsingPreference(); |
|
1481 if (ret != KErrNone) // Error in open |
|
1482 { |
|
1483 return ret; |
|
1484 } |
|
1485 } |
1469 |
1486 |
1470 TInt status; |
1487 TInt status; |
1471 ATOMICSOCKETOP(ret = iSocket.GetOpt(KSOSelectPoll, KSOLSocket, status), ret = KErrBadHandle) |
1488 ret = iSocket.GetOpt(KSOSelectPoll, KSOLSocket, status); |
1472 if (ret == KErrNone) |
1489 if (ret == KErrNone) |
1473 { |
1490 { |
1474 aReadyStatus = status & aMode; |
1491 aReadyStatus = status & aMode; |
1475 } |
1492 } |
1476 |
1493 |
1750 Backend()->AddSocket(this); |
1771 Backend()->AddSocket(this); |
1751 } |
1772 } |
1752 } |
1773 } |
1753 else // No connection preference is set |
1774 else // No connection preference is set |
1754 { |
1775 { |
1755 ret = ECONNABORTED; |
1776 ret = iSocket.Open(*iSockServPtr,addrfamily,iStyle,iProtocol); |
1756 } |
1777 } |
1757 } |
1778 } |
1758 |
1779 |
1759 if (ret == KErrNone) |
1780 if(KErrNone == ret) |
1760 { |
1781 { |
1761 __e32_atomic_store_rel32(&iSocketPtr, (unsigned long)&iSocket); |
1782 iSocketPtr = &iSocket; |
1762 } |
1783 } |
1763 |
1784 iConnectInProgress = EFalse; |
1764 iConnectInProgress = EFalse; |
1785 return ret; |
1765 |
1786 } |
1766 return ret; |
|
1767 } |
|
1768 |
1787 |
1769 void CSocketDesc::TempClose() |
1788 void CSocketDesc::TempClose() |
1770 { |
1789 { |
1771 TUint32 ret = __e32_atomic_ior_ord32((void *)&iCount,0x8000); |
|
1772 if( ret >= 0x8000 ) |
|
1773 { |
|
1774 // This indicates a TempClose has already been done from one of the threads |
|
1775 return; |
|
1776 } |
|
1777 // loop and yeild till no more references are held to the iSocket |
|
1778 while( iCount != 0x8000 ) |
|
1779 { |
|
1780 // Yeild for 1 ms |
|
1781 User::After(1000); |
|
1782 } |
|
1783 if (iSocket.SubSessionHandle() != 0) |
1790 if (iSocket.SubSessionHandle() != 0) |
1784 { |
1791 { |
1785 iSocketPtr = NULL; |
1792 iSocketPtr = NULL; |
1786 iSocket.CancelAll(); |
1793 iSocket.CancelAll(); |
1787 TRequestStatus status; |
1794 TRequestStatus status; |
2167 return KErrNone; |
2173 return KErrNone; |
2168 } |
2174 } |
2169 |
2175 |
2170 TInt CSocketDesc::GetInterfaceByName(const TDesC& aIfName, TPckgBuf<TSoInetInterfaceInfo>& aIface) |
2176 TInt CSocketDesc::GetInterfaceByName(const TDesC& aIfName, TPckgBuf<TSoInetInterfaceInfo>& aIface) |
2171 { |
2177 { |
2172 TInt ret = KErrNone; |
2178 TInt ret = iSocket.SetOpt(KSoInetEnumInterfaces, KSolInetIfCtrl); |
2173 ATOMICSOCKETOP(ret = iSocket.SetOpt(KSoInetEnumInterfaces, KSolInetIfCtrl), ret = KErrBadHandle) |
|
2174 if (ret != KErrNone) |
2179 if (ret != KErrNone) |
2175 { |
2180 { |
2176 return ret; |
2181 return ret; |
2177 } |
2182 } |
2178 TPckgBuf<TSoInetInterfaceInfo> iface; |
2183 TPckgBuf<TSoInetInterfaceInfo> iface; |
2179 ATOMICSOCKETOP(ret = iSocket.GetOpt(KSoInetNextInterface, KSolInetIfCtrl, iface), ret = KErrBadHandle) |
2184 while((ret = iSocket.GetOpt(KSoInetNextInterface, KSolInetIfCtrl, iface)) == KErrNone) |
2180 while(ret == KErrNone) |
2185 { |
2181 { |
2186 if(!iface().iAddress.IsUnspecified() |
2182 if (!iface().iAddress.IsUnspecified() && iface().iName.CompareF(aIfName) == 0) |
2187 && iface().iName.CompareF(aIfName) == 0) |
2183 { |
2188 { |
2184 aIface = iface; |
2189 aIface = iface; |
2185 return ret; |
2190 return ret; |
2186 } |
2191 } |
2187 ATOMICSOCKETOP( ret = iSocket.GetOpt(KSoInetNextInterface, KSolInetIfCtrl, iface), ret = KErrBadHandle ) |
|
2188 } |
2192 } |
|
2193 |
2189 return KErrUnknown; |
2194 return KErrUnknown; |
2190 } |
2195 } |
2191 |
2196 |
2192 TInt CSocketDesc::GetInterfaceHWAddress(void *aParam) |
2197 TInt CSocketDesc::GetInterfaceHWAddress(void *aParam) |
2193 { |
2198 { |
2196 if (!ifr) |
2201 if (!ifr) |
2197 { |
2202 { |
2198 return KErrArgument; |
2203 return KErrArgument; |
2199 } |
2204 } |
2200 |
2205 |
2201 if (ifr->ifr_name[0] != '\0') |
2206 if (ifr->ifr_name[0]!='\0') |
2202 { |
2207 { |
2203 TPckgBuf<TSoInetInterfaceInfo> iface; |
2208 TPckgBuf<TSoInetInterfaceInfo> iface; |
2204 TFileName name; |
2209 TFileName name; |
2205 ifr->ifr_name[IFNAMSIZ-1] = 0; // don't assume NULL terminated input |
2210 name.Copy(TPtrC8((TText8*)ifr->ifr_name)); |
2206 name.Copy(TPtrC8((TText8*)ifr->ifr_name)); |
2211 |
2207 |
2212 TInt ret = GetInterfaceByName(name, iface); |
2208 TInt ret = GetInterfaceByName(name, iface); |
2213 |
2209 if (ret != KErrNone) |
2214 if (ret != KErrNone) |
2210 return ret; |
2215 { |
2211 |
2216 return ret; |
2212 if (iface().iHwAddr.Length() > sizeof(SSockAddr)) |
2217 } |
2213 { |
2218 |
2214 Mem::Copy(&(ifr->ifr_hwaddr.sa_data[0]),&(iface().iHwAddr[sizeof(SSockAddr)]), 6); |
2219 if(iface().iHwAddr.Length() > sizeof(SSockAddr)) |
2215 ifr->ifr_hwaddr.sa_family = (TUint16)iface().iHwAddr.Family(); |
2220 { |
2216 ifr->ifr_hwaddr.sa_port = ByteOrder::Swap16(iface().iHwAddr.Port()); |
2221 Mem::Copy(&(ifr->ifr_hwaddr.sa_data[0]),&(iface().iHwAddr[sizeof(SSockAddr)]), 6); |
2217 return ret; |
2222 ifr->ifr_hwaddr.sa_family = (TUint16)iface().iHwAddr.Family(); |
2218 } |
2223 ifr->ifr_hwaddr.sa_port = ByteOrder::Swap16(iface().iHwAddr.Port()); |
2219 } |
2224 return ret; |
|
2225 } |
|
2226 } |
2220 |
2227 |
2221 return KErrUnknown; |
2228 return KErrUnknown; |
2222 } |
2229 } |
2223 |
2230 |
2224 //This function retrieves the Currently active IAP ID using the RSocket Query. |
2231 //This function retrieves the Currently active IAP ID using the RSocket Query. |
2227 //will contain the snap id. User is supposed to call if_indextoname() api to get the IAP name |
2234 //will contain the snap id. User is supposed to call if_indextoname() api to get the IAP name |
2228 //from the ID retured with this Ioctl implementation. |
2235 //from the ID retured with this Ioctl implementation. |
2229 TInt CSocketDesc::GetActiveInterface( void *aParam) |
2236 TInt CSocketDesc::GetActiveInterface( void *aParam) |
2230 { |
2237 { |
2231 TInt ifindex = -1; |
2238 TInt ifindex = -1; |
2232 TInt ret = KErrNone; |
2239 TInt ret = iSocket.GetOpt(KSoInterfaceIndex, KSolInetIp , ifindex); |
2233 ATOMICSOCKETOP(ret = iSocket.GetOpt(KSoInterfaceIndex, KSolInetIp , ifindex), ret = KErrBadHandle) |
|
2234 if(ret!=KErrNone) |
2240 if(ret!=KErrNone) |
2235 { |
2241 { |
2236 return ret; |
2242 return ret; |
2237 } |
2243 } |
2238 TPckgBuf<TSoInetIfQuery> opt; |
2244 TPckgBuf<TSoInetIfQuery> opt; |
2239 opt().iIndex = ifindex; |
2245 opt().iIndex = ifindex; |
2240 ATOMICSOCKETOP(ret = iSocket.GetOpt(KSoInetIfQueryByIndex, KSolInetIfQuery, opt), ret = KErrBadHandle) |
2246 ret = iSocket.GetOpt(KSoInetIfQueryByIndex, KSolInetIfQuery, opt); |
2241 if(ret!=KErrNone) |
2247 if(ret!=KErrNone) |
2242 { |
2248 { |
2243 return ret; |
2249 return ret; |
2244 } |
2250 } |
2245 ifreq *ifr = (ifreq * )aParam; |
2251 ifreq *ifr = (ifreq * )aParam; |