TB9.2 Example Applications: examples/DataComms/Rconnection/rconnection.cpp Source File

00001 // Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies).
+00002 // All rights reserved.
+00003 // This component and the accompanying materials are made available
+00004 // under the terms of "Eclipse Public License v1.0"
+00005 // which accompanies this distribution, and is available
+00006 // at the URL "http://www.eclipse.org/legal/epl-v10.html".
+00007 //
+00008 // Initial Contributors:
+00009 // Nokia Corporation - initial contribution.
+00010 //
+00011 // Contributors:
+00012 //
+00013 // Description:
+00014 //
+00015 
+00016 
+00017 
+00018 #include "rconnection.h"
+00019 
+00020 _LIT(KContinueNote,"Press any key to continue\n");
+00021 _LIT(KOpenErr,"Open() unsuccessful\n");
+00022 _LIT(KStartErr,"RConnection::Start() unsuccessful\n");
+00023 _LIT(KInterfaceUp,"Connection has started and interface is up\n");
+00024 _LIT(KInterfaceDown,"Connection has closed and interface is down\n");
+00025 _LIT(KConnectionUpNote,"Connection is up....\n");
+00026 _LIT(KConnectionStartNote,"Start() was called on the connection\n");
+00027 _LIT(KConnectionClosingNote,"The connection is about to be closed\n");
+00028 _LIT(KWaitNote,"Waiting for the connection to close.....\n");
+00029 _LIT(KUpLinkData,"Data volume on uplink=%d bytes\n");
+00030 _LIT(KDownLinkData,"Data volume on downlink=%d bytes\n");
+00031 _LIT(KDataTransferNote,"Calling DataSendAndReceive()\n");
+00032 _LIT(KSocketErrNote,"Socket preparation failed\n");
+00033 _LIT(KSocketSetNote,"Socket successfully established\n");
+00034 
+00035 _LIT(KRow1,"**********************************************************\n");
+00036 _LIT(KRow2,"    Section Demonstrating  :                  \n");
+00037 _LIT(KRow3,"**********************************************************\n");
+00038 _LIT(KTab,"\t");
+00039 _LIT(KNewLine,"\n");
+00040 
+00041 #define KEchoPort 0xAB                  //Port value for client socket.
+00042 #define KMaxBufferLength 2048   //Maximum length of buffer used to send and receive data.
+00043 #define KDelay 1000000                  //Time interval in microseconds to wait before carrying out the next task.
+00044 
+00048 CRConnection::CRConnection(CConsoleBase* aConsole)
+00049         :iConsole(aConsole)     
+00050         {
+00051         //Set the destination address and port.
+00052         //Before running the example user should start an Echo server 
+00053         //and then specify the respective IP Address and port of the echo server 
+00054         //for iDestAddr.
+00055         //Until the Echo Server is established send and receive functionality won't work properly. 
+00056         
+00057         
+00058         _LIT(KDestAddr,"127.0.0.1");  
+00059         const TInt KSockPort= 7;
+00060         
+00061         iDestAddr.Input(KDestAddr);
+00062         iDestAddr.SetPort(KSockPort);
+00063           
+00064         StartESOCK();
+00065         }
+00066 
+00067 
+00071 CRConnection::~CRConnection()
+00072         {
+00073         //Closing the monitor and socket server session.
+00074         iMonitor.Close();
+00075         iSocketServ.Close();
+00076         }
+00077 
+00083 void CRConnection::StartESOCK() 
+00084         {
+00085         
+00086         //Connects to the socket server.
+00087         TInt err=iSocketServ.Connect();
+00088         if(err!=KErrNone)
+00089                 {
+00090                 _LIT(KConnectErr,"Connect failed\n");
+00091                 User::Panic(KConnectErr,err);           
+00092                 }       
+00093         
+00094         //Opens the monitor to receive notification when another connection
+00095         //that uses the same socket server goes up or down. 
+00096         err=iMonitor.Open(iSocketServ);
+00097         if(err!=KErrNone)
+00098                 {
+00099                 iConsole->Printf(KOpenErr);
+00100                 return; 
+00101                 }       
+00102         }
+00103                 
+00111 TInt CRConnection::ConnectWithoutDbOverrideL()
+00112         {
+00113         // Opens an RConnection and associates it with the same socket server session as iMonitor.
+00114         // To use an RConnection instance first it needs to be opened on an existing socket server session 
+00115         // and then Start() must be called to associate it with an underlying interface.
+00116         TInt err=iConnection.Open(iSocketServ); 
+00117         if(err!=KErrNone)
+00118                 {
+00119                 iConsole->Printf(KOpenErr);
+00120                 return err;     
+00121                 }
+00122         
+00123         //Starts the connection using default CommDb settings.
+00124         err=iConnection.Start();
+00125         if(err!=KErrNone)
+00126                 {
+00127                 iConsole->Printf(KStartErr);
+00128                 return err;     
+00129                 }
+00130         else
+00131                 {
+00132                 iConsole->Printf(KConnectionStartNote); 
+00133                 return err;
+00134                 }                               
+00135         }
+00136         
+00140 TInt CRConnection::ConnectWithDbOverrideL()
+00141         {
+00142         // To use an RConnection instance first it needs to be opened on an existing socket server session 
+00143         // and then Start() must be called to associate it with an underlying interface.
+00144         TInt err=iConnection.Open(iSocketServ); 
+00145         if(err!=KErrNone)
+00146                 {
+00147                 iConsole->Printf(KOpenErr);
+00148                 return err;
+00149                 }
+00150         
+00151         // Overrides some Commdb connection preferences.
+00152         const TInt KIapId=9;
+00153         TCommDbConnPref prefs;
+00154         prefs.SetDialogPreference(ECommDbDialogPrefDoNotPrompt);
+00155         prefs.SetIapId(KIapId);    //The commdb is set for Ethernet with Daemon Static IP. 
+00156                                                                         
+00157         //Starts an outgoing connection.
+00158         err=iConnection.Start(prefs);
+00159         
+00160         if(err==KErrNone)
+00161                 {
+00162                 iConsole->Printf(KConnectionStartNote); 
+00163                 return err;
+00164                 }
+00165         else
+00166                 {
+00167                 iConsole->Printf(KStartErr);
+00168                 return err;     
+00169                 }               
+00170         }
+00176 void CRConnection::GetProgressNotification()
+00177         {
+00178         TRequestStatus status;
+00179         TNifProgressBuf buffer; //filled with progress/error information on completion 
+00180         while((TUint)(buffer().iStage)!=KConnectionUp) 
+00181                 {
+00182                 iConnection.ProgressNotification(buffer,status);
+00183                 User::WaitForRequest(status);
+00184                 if(status==KErrNone&&(buffer().iError)==KErrNone)
+00185                         {
+00186                         DisplayProgressinfo(buffer());
+00187                         }
+00188                 User::After(KDelay);
+00189                 }
+00190         iConsole->Printf(KConnectionUpNote); //Link layer is now open.  
+00191                 
+00192                         
+00193         }
+00194         
+00199 void CRConnection::DisplayProgressinfo(const TNifProgress& aProgress)
+00200         {
+00201         switch(aProgress.iStage)
+00202                 {
+00203                 case KStartingSelection:
+00204                         {
+00205                         _LIT(KStartSelectionNote,"Starting Selection...........\n");
+00206                         iConsole->Printf(KStartSelectionNote);
+00207                         break;  
+00208                         }
+00209                                         
+00210                 case KFinishedSelection:
+00211                         {
+00212                         _LIT(KFinishedSelectionNote,"Finished Selection...........\n");
+00213                         iConsole->Printf(KFinishedSelectionNote);
+00214                         break;  
+00215                         }
+00216                                         
+00217                 case KConnectionOpen:
+00218                         {
+00219                         _LIT(KWlanAgtConnected,"Wlan agent connected....\n");
+00220                         iConsole->Printf(KWlanAgtConnected);
+00221                         break;  
+00222                         }
+00223                                                 
+00224                 //Generic progress notifications from the configuration daemon.                         
+00225                 case KConfigDaemonLoading:
+00226                         {
+00227                         _LIT(KConfigDaemonLoadingNote,"Daemon loading....\n");
+00228                         iConsole->Printf(KConfigDaemonLoadingNote);
+00229                         break;  
+00230                         }
+00231                                         
+00232                 case KConfigDaemonLoaded:
+00233                         {
+00234                         _LIT(KConfigDaemonLoadedNote,"Daemon loaded....\n");
+00235                         iConsole->Printf(KConfigDaemonLoadedNote);
+00236                         break;  
+00237                         }
+00238                                                 
+00239                 case KConfigDaemonStartingRegistration:
+00240                         {
+00241                         _LIT(KConfigDaemonStartingRegistrationNote,"Daemon starting registration....\n");
+00242                         iConsole->Printf(KConfigDaemonStartingRegistrationNote);
+00243                         break;  
+00244                         }
+00245                                                 
+00246                 case KConfigDaemonFinishedRegistration:
+00247                         {
+00248                         _LIT(KConfigDaemonFinishedRegistrationNote,"Daemon registration finished....\n");
+00249                         iConsole->Printf(KConfigDaemonFinishedRegistrationNote);
+00250                         break;  
+00251                         }       
+00252         
+00253                 default:
+00254                         break;                  
+00255                 }
+00256         }
+00257 
+00263 TInt CRConnection::PrepareSocket()
+00264         {
+00265         TInt err = iSocket.Open(iSocketServ, KAfInet, KSockDatagram, KProtocolInetUdp, iConnection);
+00266         if (err != KErrNone)
+00267                 {
+00268                 return err;     
+00269                 }
+00270                 
+00271         //Sets a socket option. These options affect operations such as the routing of packets, 
+00272         //out-of-band data transfer, and so on. Here the option level "KSolInetIp" is set for an IP socket,
+00273         //and the option being set is "KSoReuseAddr". This means the socket is allowed to be bound to a local
+00274         //address that is already in use.
+00275         //The third parameter i.e 1 states that the option is enabled.A value of 0 means disabled.
+00276         
+00277         err = iSocket.SetOpt(KSoReuseAddr, KSolInetIp, 1); 
+00278         if (err != KErrNone)
+00279                 {
+00280                 return err;     
+00281                 }
+00282         
+00283         //Sets a local port for the socket.
+00284         err = iSocket.SetLocalPort(KEchoPort); 
+00285         if (err != KErrNone)
+00286                 {
+00287                 return err;     
+00288                 }
+00289         return err;             
+00290         }
+00296 TInt CRConnection::SendUdpData(TUint aPayloadSize)
+00297         {
+00298         
+00299         TBuf8<KMaxBufferLength> buffer;
+00300         // construct an ICMP packet to send on the socket.
+00301         buffer.SetMax();
+00302         buffer.FillZ();
+00303         buffer[0] = (TUint8) 0x08; // ICMP type = 8.
+00304         buffer[1] = (TUint8) 0x00; // ICMP code = 0.
+00305         buffer[2] = (TUint8) 0xF7; // ICMP checksum high byte.
+00306         buffer[3] = (TUint8) 0xFF; // ICMP checksum low byte.
+00307         
+00308         // NB the rest of the buffer is zero
+00309         // hence the checksum (0xFFFF - 0x800) since 0x8
+00310         // is the only non-zero element of the buffer
+00311 
+00312         // set the length of the data to be sent to that specified (payload size!).
+00313         buffer.SetLength(aPayloadSize);
+00314 
+00315         TRequestStatus status;
+00316 
+00317         // send the data out over the socket.
+00318         iSocket.SendTo(buffer, iDestAddr, 0, status);
+00319         User::WaitForRequest(status);
+00320 
+00321         return status.Int();
+00322         }
+00323 
+00329 TInt CRConnection::RecvUdpData(TUint aPayloadSize)
+00330         {
+00331         
+00332         TInt timeoutInSecs = 30;
+00333         RTimer timer;
+00334         
+00335         /* 
+00336         Creates a timer so that we can handle error situation arising due to lost udp packet
+00337         and dont completely rely on being errored by esock alone. This code waits for 30sec for
+00338         udp data packet to arrive from the server. If the data is not available within this
+00339         time the socket waiting for data is closed and the error value of KErrTimedOut is 
+00340         returned. 
+00341         */
+00342         TInt ret;
+00343         if ((ret = timer.CreateLocal()) != KErrNone)
+00344                 {
+00345                 timer.Close(); // closing the timer.
+00346                 return ret;
+00347                 }
+00348         TRequestStatus timerStatus;
+00349         timer.After(timerStatus, timeoutInSecs * 1000000); //setting timer.
+00350         
+00351         TBuf8<KMaxBufferLength> buffer;
+00352         buffer.Zero();
+00353         buffer.SetLength(aPayloadSize);
+00354 
+00355         TRequestStatus status;
+00356         iSocket.RecvFrom(buffer, iDestAddr, 0, status); //waiting on data from the server.
+00357         User::WaitForRequest(status, timerStatus);
+00358 
+00359         // Timer expired, and if no data is received cancel the receive operation.
+00360         if(timerStatus != KRequestPending)
+00361                 {
+00362                 iSocket.CancelAll();
+00363                 User::WaitForRequest(status);
+00364                 timer.Close();
+00365                 return KErrTimedOut;
+00366                 }
+00367         // otherwise cancel the timer.
+00368         timer.Cancel();
+00369         User::WaitForRequest(timerStatus);
+00370         timer.Close();
+00371 
+00372         //when data is successfully received, check against the previously sent buffer data,
+00373         //to see what is received is what was sent.
+00374         if (status != KErrNone)
+00375                 return status.Int();
+00376         else
+00377                 {   
+00378                 if(buffer[0] == 0x08)
+00379                         {
+00380                         if(buffer[1] == 0x00)
+00381                                 {
+00382                                 if(buffer[2] == 0xF7)
+00383                                         {
+00384                                         if(buffer[3] == 0xFF)
+00385                                                 {
+00386                                                 ;       
+00387                                                 }
+00388                                         else 
+00389                                                 {
+00390                                                 _LIT(KFourthDataSet,"Fourth set of data not received\n");
+00391                                                 iConsole->Printf(KFourthDataSet);
+00392                                                 }               
+00393                                         }
+00394                                 else
+00395                                         {
+00396                                         _LIT(KThirdDataSet,"Third set of data not received\n");
+00397                                         iConsole->Printf(KThirdDataSet);        
+00398                                         }       
+00399 
+00400                                 }
+00401                         else
+00402                                 {
+00403                                 _LIT(KSecondDataSet,"Second set of data not received\n");
+00404                                 iConsole->Printf(KSecondDataSet);       
+00405                                 }
+00406                         }
+00407                 else
+00408                         {
+00409                         _LIT(KFirstDataSet,"First set of data not received\n");
+00410                         iConsole->Printf(KFirstDataSet);        
+00411                         }       
+00412                         
+00413                 }
+00414         return KErrNone;
+00415         }
+00416 
+00420 void CRConnection::DataSendAndReceive(TUint aPayloadSize)
+00421         {
+00422         //Sends UDP Data.
+00423         TInt err = SendUdpData(aPayloadSize);
+00424         if (err != KErrNone)
+00425                 {
+00426                 _LIT(KDataSentErrNote,"DataSend Failed\n");
+00427                 iConsole->Printf(KDataSentErrNote);
+00428                 return ;        
+00429                 }
+00430         else
+00431                 {
+00432                 _LIT(KDataSentNote,"DataSend Successful\n");
+00433                 iConsole->Printf(KDataSentNote);        
+00434                 }
+00435 
+00436         //Receives UDP Data.
+00437         err = RecvUdpData(aPayloadSize);
+00438         if(err!=KErrNone)
+00439                 {
+00440                 _LIT(KDataReceiveErrNote,"DataReceive Failed\n");
+00441                 iConsole->Printf(KDataReceiveErrNote);
+00442                 return ;        
+00443                 }
+00444         else
+00445                 {
+00446                 _LIT(KDataReceiveNote,"DataReceive Successful\n");
+00447                 iConsole->Printf(KDataReceiveNote);
+00448                 }       
+00449                 
+00450         }
+00451 
+00455 void CRConnection::DataTransferredRequest()
+00456         {
+00457         TPckg<TUint> uplinkVolumeDes(0); //holds the amount of data received.
+00458         TPckg<TUint> downlinkVolumeDes(0); //holds the amount of data transmitted.
+00459         
+00460         TRequestStatus datastatus;
+00461 
+00462         iConnection.DataTransferredRequest(uplinkVolumeDes, downlinkVolumeDes, datastatus);
+00463         User::WaitForRequest(datastatus);
+00464         
+00465         if(datastatus==KErrNone)
+00466                 {
+00467                 iConsole->Printf(KUpLinkData,uplinkVolumeDes());
+00468                 iConsole->Printf(KDownLinkData,downlinkVolumeDes());    
+00469                 }
+00470                         
+00471         }
+00476 void CRConnection::DataTransferNotificationRequest()
+00477         {
+00478         const TUint KHundredBytes = 100; //The threshold value for notification.
+00479         const TUint KThousandBytes = 1000; //The total amount of data to send/receive.
+00480         TPckg< TUint > uplinkPkg(0); //Holds the amount of data sent.
+00481         TPckg< TUint > downlinkPkg(0);//Holds the amount of data received.
+00482         TRequestStatus dataSentStatus,dataReceivedStatus;
+00483         
+00484         //Registers for data sent notification. The process gets notified when 100 bytes of data are sent. 
+00485         iConnection.DataSentNotificationRequest(KHundredBytes, uplinkPkg, dataSentStatus );
+00486         
+00487         //Registers for data received notification. The process gets notified when 100 bytes of data are received.
+00488         iConnection.DataReceivedNotificationRequest(KHundredBytes, downlinkPkg, dataReceivedStatus );
+00489         iConsole->Printf(KDataTransferNote);
+00490         
+00491         //Sends and receives 1000 bytes of data.
+00492         DataSendAndReceive(KThousandBytes);
+00493                 
+00494         /*
+00495         Gets the total data sent/received = datavolume+UdpPacketOverhead
+00496         here datavolume=1000 bytes,thus total data send/receive > 1000 as 
+00497         some overhead gets added on top of the actual datavolume.
+00498         */
+00499         
+00500         User::WaitForRequest(dataSentStatus);
+00501         User::WaitForRequest(dataReceivedStatus);
+00502         if ((dataSentStatus.Int())== KErrNone)
+00503                 {
+00504                 _LIT(KSentSuccessNote,"DataSentNotificationRequest is successful and\n ");      
+00505                 iConsole->Printf(KSentSuccessNote);
+00506                 }
+00507         else
+00508                 {
+00509                 _LIT(KSentFailureNote,"DataSentNotificationRequest has failed and \n");
+00510                 iConsole->Printf(KSentFailureNote);
+00511                 }
+00512         iConsole->Printf(KUpLinkData,uplinkPkg());
+00513                                         
+00514         if (dataReceivedStatus.Int()==KErrNone)
+00515                 {
+00516                 _LIT(KReceivedSuccessNote,"DataReceivedNotificationRequest is successful and \n");      
+00517                 iConsole->Printf(KReceivedSuccessNote);
+00518                 }
+00519         else 
+00520                 {
+00521                 _LIT(KReceivedFailureNote,"DataReceivedNotificationRequest has failed and \n");
+00522                 iConsole->Printf(KReceivedFailureNote);
+00523                 }               
+00524         iConsole->Printf(KDownLinkData,downlinkPkg());  
+00525 
+00526         }
+00527         
+00528 void CRConnection::DisplaySectionToDemo(const TDesC& aText)
+00529         {
+00530         TBuf<120> newtext;
+00531         newtext.Append(KTab);
+00532         newtext.Append(aText);
+00533         newtext.Append(KTab);
+00534         newtext.Append(KNewLine);
+00535         iConsole->Printf(KRow1);
+00536         iConsole->Printf(KRow2);
+00537         iConsole->Printf(newtext);
+00538         iConsole->Printf(KRow3);
+00539         iConsole->Printf(KNewLine);
+00540         }
+00541 
+00552 void CRConnection::DemoApiWithoutDbOverrideL()
+00553         {
+00554         _LIT(KDemoApiWithoutDbOverride,"RConnection API without CommDb override\n");
+00555         iConsole->ClearScreen();
+00556         DisplaySectionToDemo(KDemoApiWithoutDbOverride);
+00557         
+00558         TRequestStatus status;
+00559         TInterfaceNotificationBuf info;
+00560         //Makes a request for notification when the interface goes up i.e. the connection starts.
+00561         iMonitor.AllInterfaceNotification(info,status);
+00562                 
+00563         //Makes an explicit connection without CommDb override. 
+00564         TInt err=ConnectWithoutDbOverrideL();
+00565         if(err!=KErrNone)
+00566                 return;
+00567         
+00568         //Waits on TRequestStatus until the interface is up.
+00569         User::WaitForRequest(status);
+00570         if(info().iState==EInterfaceUp)
+00571                 {
+00572                 iConsole->Printf(KInterfaceUp); 
+00573                 }                               
+00574         
+00575         //Gets and prints progress notification for the connection.
+00576         GetProgressNotification();
+00577         User::After(KDelay);  // waits for a while and then proceeds. This helps to get a sequential flow.
+00578         
+00579         err=PrepareSocket(); // Once the socket is ready for data transfer, send and receive operations can be carried out.
+00580         if(err!=KErrNone)
+00581                 {
+00582                 iConsole->Printf(KSocketErrNote);
+00583                 return; 
+00584                 }
+00585         else
+00586                 {
+00587                 iConsole->Printf(KSocketSetNote);       
+00588                 }       
+00589         
+00590         iConsole->Printf(KDataTransferNote);
+00591         
+00592         const TUint KPayLoadSize=512;
+00593         //Sends and receives data through the socket.
+00594         DataSendAndReceive(KPayLoadSize);
+00595         
+00596         DataTransferredRequest();// Gets and prints the amount of data that has been transferred.
+00597                 
+00598         User::After(KDelay);//Wait for a while, before proceeding.      
+00599 
+00600         //Makes a request for notification when the interface goes down i.e. the connection closes.
+00601         iMonitor.AllInterfaceNotification(info,status); 
+00602                 
+00603         // All the operations related to the socket and connection are done, so close both.
+00604         iSocket.Close();
+00605         iConsole->Printf(KConnectionClosingNote);
+00606         iConnection.Close();
+00607         iConsole->Printf(KWaitNote); 
+00608         
+00609         //Waits for the 'interface down' notification
+00610         User::WaitForRequest(status);
+00611         if(info().iState==EInterfaceDown)
+00612                 {
+00613                 iConsole->Printf(KInterfaceDown);       
+00614                 }
+00615                 
+00616         iConsole->Printf(KContinueNote);
+00617         iConsole->Getch();
+00618 
+00619         }
+00620         
+00631 void CRConnection::DemoApiWithDbOverrideL()
+00632         {
+00633         
+00634         _LIT(KDemoApiWithDbOverride,"RConnection API with CommDb override\n");
+00635         iConsole->ClearScreen();
+00636         DisplaySectionToDemo(KDemoApiWithDbOverride);
+00637                 
+00638         TRequestStatus status;
+00639         TInterfaceNotificationBuf info;
+00640         
+00641         // Requests notification when the connection is established.
+00642         // Notification request is issued before calling Start().
+00643         iMonitor.AllInterfaceNotification(info,status);
+00644         
+00645         //Start an explicit connection with CommDb override. 
+00646         TInt err=ConnectWithDbOverrideL();
+00647         if(err!=KErrNone)
+00648                 return;
+00649         
+00650         //Waits on TRequestStatus until the interface is up.
+00651         User::WaitForRequest(status);
+00652         if(info().iState==EInterfaceUp)
+00653                 {
+00654                 iConsole->Printf(KInterfaceUp); 
+00655                 }       
+00656 
+00657         //Gets and prints progress notification for the connection.
+00658         GetProgressNotification();
+00659         
+00660         //Waits for a while before next operation.
+00661         User::After(KDelay);
+00662         
+00663         err=PrepareSocket(); //Once the socket is ready for data transfer, send and receive operations can be carried out.
+00664         if(err!=KErrNone)
+00665                 {
+00666                 iConsole->Printf(KSocketErrNote);
+00667                 return; 
+00668                 }
+00669         else    
+00670                 {
+00671                 iConsole->Printf(KSocketSetNote);       
+00672                 }
+00673         //Sends and receives data and requests notification when a threshold amount of data is transferred.
+00674         DataTransferNotificationRequest(); 
+00675         User::After(KDelay);
+00676 
+00677         //Makes a request for notification when the interface goes down i.e. the connection closes.
+00678         iMonitor.AllInterfaceNotification(info,status);
+00679                 
+00680         //Closes socket 
+00681         iSocket.Close();
+00682         iConsole->Printf(KConnectionClosingNote);
+00683                 
+00684         //Closes the connection.
+00685         iConnection.Close();
+00686         iConsole->Printf(KWaitNote); 
+00687         
+00688         //Waits on the TRequestStatus until the interface is down 
+00689         User::WaitForRequest(status);
+00690         if(info().iState==EInterfaceDown)
+00691                 {
+00692                 iConsole->Printf(KInterfaceDown);       
+00693                 }       
+00694         
+00695         iConsole->Printf(KContinueNote);
+00696         iConsole->Getch();
+00697         
+00698         }
+00699 
+00709 void CRConnection::AttachToExistingInterfaceL()
+00710         {
+00711         
+00712         _LIT(KAttachToConnection,"Attaching to a connection\n");
+00713         iConsole->ClearScreen();
+00714         DisplaySectionToDemo(KAttachToConnection);
+00715         
+00716         // Attaching to a connection is done as follows:
+00717         // 1)first open a connection interface.
+00718         // 2)on this connection interface, obtain the no. of active connections and their connection info.
+00719         // 3)a second connection is opened.
+00720         // 4)this 2nd connection is attached to the existing active connection interface.
+00721          
+00722         RConnection conn;
+00723         
+00724         //Opens the first RConnection.
+00725         TInt err = conn.Open(iSocketServ);
+00726         if(err==KErrNone)
+00727                 {
+00728                 CleanupClosePushL(conn);        
+00729                 }
+00730         else
+00731                 {
+00732                 iConsole->Printf(KOpenErr);
+00733                 return; 
+00734                 }       
+00735         
+00736         //Opens the 2nd connection. 
+00737         err =  iConnection.Open(iSocketServ);
+00738         if(err!=KErrNone)
+00739                 {
+00740                 iConsole->Printf(KOpenErr);
+00741                 return; 
+00742                 }       
+00743         
+00744         //Starts the 1st connection.
+00745         err=conn.Start();
+00746         if(err!=KErrNone)
+00747                 {
+00748                 iConsole->Printf(KStartErr);
+00749                 return; 
+00750                 }
+00751         
+00752         // Enumerates the total number of connections on the 1st connection interface.
+00753         // This call returns a count of 1.      
+00754         TUint connectionCount;
+00755         err = conn.EnumerateConnections(connectionCount);
+00756         if((err != KErrNone) || (connectionCount < 1))
+00757                 {
+00758                 return;
+00759                 }
+00760         
+00761         
+00762         // Gets connection info for the 1st connection (conn) which will be used by the 
+00763         // 2nd connection to attach to. 
+00764         TConnectionInfoBuf connectionInfo;
+00765         err = conn.GetConnectionInfo(connectionCount, connectionInfo); // gets connection info about the indexed connection
+00766                                                                                                                                    // (the 1st connection).
+00767         if(err != KErrNone)
+00768                 {
+00769                 return;
+00770                 }
+00771 
+00772         // Attaches iConnection to the existing underlying interface.
+00773         // The connection is used for normal data transfer.
+00774         // Both connections are now actively associated with an interface.
+00775         err = iConnection.Attach(connectionInfo,RConnection::EAttachTypeNormal);
+00776         if(err==KErrNone)
+00777                 {
+00778                 _LIT(KAttachNote,"Attached to interface\n");    
+00779                 iConsole->Printf(KAttachNote);                  
+00780                 }
+00781         else
+00782                 return; 
+00783         
+00784         // Gets progress info and prints it to the console. 
+00785     TNifProgress progress;
+00786     err = iConnection.Progress(progress);
+00787     if(err==KErrNone&&progress.iError==KErrNone)
+00788             {
+00789             if((TUint)(progress.iStage)==KConnectionUp)
+00790                 iConsole->Printf(KConnectionUpNote);    
+00791             }
+00792         
+00793         User::After(KDelay);  //waits for a while before proceeding.
+00794         
+00795         iConsole->Printf(KConnectionClosingNote);
+00796                 
+00797         //closes both connections.
+00798         iConnection.Close();
+00799         CleanupStack::PopAndDestroy(&conn); //conn.
+00800         
+00801         _LIT(KConnectionClosedNote,"Connection Closed\n");
+00802         iConsole->Printf(KConnectionClosedNote);
+00803         
+00804         }
+00805 
+