TB10.1 Example Applications: examples/Bluetooth/BTExample1/src/panconnection.cpp Source File

00001 // Copyright (c) 2006-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 #include <e32cons.h>
+00018 #include <comms-infras/nifif.h>
+00019 #include <comms-infras/nifagt.h>
+00020 #include <panprog.h>
+00021 #include <panctrl.h>
+00022 #include <commbbconnpref.h>
+00023 #include <bt_sock.h>
+00024 #include <es_sock.h>
+00025 #include <in_sock.h>
+00026 #include <c32comm.h>
+00027 
+00028 
+00029 #include "panconnection.h"
+00030 #include "gameconstants.h"
+00031 
+00032 
+00033 
+00037 CPanConnections* CPanConnections::NewL(CConsoleBase & aConsole)
+00038         {
+00039         CPanConnections* self = new CPanConnections(aConsole);
+00040         return self;
+00041         }
+00042 
+00046 CPanConnections::CPanConnections(CConsoleBase & aConsole) 
+00047         : CActive(EPriorityNormal),
+00048         iIapStarted(EFalse), 
+00049         iActivePanConn(KErrNotFound), 
+00050         iConsole(aConsole), 
+00051         iRemoteIpAddr(0)
+00052         {       
+00053         CActiveScheduler::Add(this);
+00054         }
+00055 
+00059 CPanConnections::~CPanConnections()
+00060         {
+00061 
+00062         for (TInt i=0; i < iSocketArray.Count();i++)
+00063                 {
+00064                 iSocketArray[i].Close();
+00065                 }       
+00066         iSocketArray.Close();
+00067         iSocket.Close();
+00068         
+00069         if (iIapStarted != EFalse)
+00070                 {
+00071                 iConnection.Stop();
+00072                 iConnection.Close();
+00073                 iIapStarted = EFalse;
+00074                 }
+00075         
+00076         iIapLoading = EFalse;
+00077 
+00078         iActiveConnections.Close();
+00079         iSockSvr.Close();
+00080         iSdp.Close();
+00081         iSdpdb.Close();
+00082         
+00083 
+00084 
+00085         }
+00086 
+00090 TInt CPanConnections::Initialise()
+00091         {
+00092         
+00093         #if defined (__WINS__)
+00094                 _LIT(KPDDName, "ECDRV");
+00095         #else           
+00096                 _LIT(KPDDName, "EUART1");               
+00097         #endif
+00098                 _LIT(KLDDName, "ECOMM");        
+00099         TInt rerr = KErrNone;
+00100         rerr = StartC32();// For any Serial comms
+00101         // Load required drivers
+00102         rerr = User::LoadPhysicalDevice(KPDDName);
+00103         if(rerr != KErrNone && rerr != KErrAlreadyExists)
+00104                 {
+00105                 return rerr;
+00106                 }
+00107                 
+00108         rerr = User::LoadLogicalDevice(KLDDName);
+00109         if(rerr != KErrNone && rerr != KErrAlreadyExists)
+00110                 {
+00111                 return rerr;
+00112                 }
+00113 
+00114         rerr = iSockSvr.Connect();
+00115         if(rerr)
+00116                 {
+00117                 return rerr;
+00118                 }
+00119 
+00120         TProtocolDesc iProtocolInfo;
+00121         TRequestStatus status;
+00122 
+00123         rerr = iSockSvr.FindProtocol(_L("L2CAP"), iProtocolInfo);
+00124         if(rerr)
+00125                 {
+00126                 return rerr;
+00127                 }
+00128         // After Socket server is connected, start L2CAP protocol
+00129         iSockSvr.StartProtocol(iProtocolInfo.iAddrFamily, iProtocolInfo.iSockType, iProtocolInfo.iProtocol, status);
+00130         User::WaitForRequest(status);
+00131         // Register SDP record.
+00132         TRAP(rerr, RegisterSdpL());
+00133         
+00134         return rerr;
+00135         }
+00136 
+00137 void CPanConnections::RegisterSdpL()
+00138         {
+00139         User::LeaveIfError(iSdp.Connect());
+00140         User::LeaveIfError(iSdpdb.Open(iSdp));
+00141                 
+00142         TSdpServRecordHandle handle = 0;
+00143                 
+00144         switch (iLocalRole)
+00145                 {
+00146                 case KPanUUUID:
+00147                         iSdpdb.CreateServiceRecordL(KPanUUUID, handle);
+00148                 break;
+00149                 
+00150                 case KPanGnUUID:
+00151                         iSdpdb.CreateServiceRecordL(KPanGnUUID, handle);
+00152                 break;
+00153                 
+00154                 default:
+00155                         iSdpdb.CreateServiceRecordL(KPanUUUID, handle);
+00156                 break;
+00157                 }
+00158         
+00159                 
+00160         // A list of protocols supported
+00161         CSdpAttrValueDES* protocols = CSdpAttrValueDES::NewDESL(0);
+00162         CleanupStack::PushL(protocols);
+00163                 protocols
+00164                 ->StartListL()
+00165                         ->BuildDESL()
+00166                         ->StartListL()
+00167                                 ->BuildUUIDL(KL2CAPUUID)
+00168                                 ->BuildUUIDL(KBnepUUID)
+00169                                 ->BuildUUIDL(KIpUUID)
+00170                                 ->BuildUUIDL(KTcpUUID) 
+00171                         ->EndListL()
+00172                         
+00173                 ->EndListL();
+00174                 
+00175                 
+00176         iSdpdb.UpdateAttributeL(handle, KSdpAttrIdProtocolDescriptorList,*protocols);
+00177         CleanupStack::PopAndDestroy(protocols);
+00178                 
+00179         // Service Name attribute, a universal attribute that defines the name of this service.
+00180         iSdpdb.UpdateAttributeL(handle, KSdpAttrIdServiceName, KServiceName);
+00181         // Service description attribute
+00182         iSdpdb.UpdateAttributeL(handle, KSdpAttrIdServiceDescription, KServiceDescription);                     
+00183         
+00184         }
+00185 
+00186 
+00190 void CPanConnections::IapStarted()
+00191         {               
+00192         TInt rerr;
+00193         if (!iIapLoading)
+00194                 {
+00195 
+00196                 }
+00197         
+00198         iIapLoading = EFalse;
+00199         iIapStarted = ETrue;
+00200         // Open TCP socket with interface to existing RConnection
+00201 
+00202         if (iUseTcpTransport)
+00203                 {
+00204                 rerr = iSocket.Open(iSockSvr, KAfInet, KSockStream, KProtocolInetTcp, iConnection);
+00205                 }
+00206         else
+00207                 {
+00208                 // User wants a UDP socket
+00209                 rerr = iSocket.Open(iSockSvr, KAfInet, KSockDatagram, KProtocolInetUdp, iConnection);
+00210                 }
+00211                 
+00212         if (rerr != KErrNone)
+00213                 {
+00214                 return;
+00215                 }
+00216         // Start TCP connection sequence                        
+00217         if (iListening && iUseTcpTransport)
+00218                 {
+00219                 TcpIpBindAndListen();
+00220                 AcceptNewSocket();
+00221                 }
+00222         // If we are a UDP socket then bind, a wait is required 
+00223         if (!iUseTcpTransport)
+00224                 {
+00225                 TInt duration;
+00226                 if (iLocalRole == (TUint32)KPanGnUUID)
+00227                         {
+00228                         duration = 4000000;
+00229                         }
+00230                 else 
+00231                         {
+00232                         duration = 6000000;
+00233                         }
+00234                         
+00235                 RTimer timer;
+00236                 TRequestStatus status;
+00237                 timer.CreateLocal();
+00238                 timer.After(status, duration);
+00239                 User::WaitForRequest(status);
+00240                 timer.Close();
+00241                 rerr = UdpBind();
+00242                 if (iLocalRole == (TUint32)KPanGnUUID)
+00243                         {
+00244                         ReceiveRemoteName();
+00245                         }
+00246                 else
+00247                         {
+00248                 
+00249                         TPckgBuf<TInt> buff = 1;
+00250                         TRequestStatus status;
+00251                         TInetAddr addr(KDealerIpAddr,KGenericPort);
+00252                         iSocket.SendTo(buff, addr, 0, status);
+00253                         User::WaitForRequest(status); 
+00254                         iConsole.Printf(_L("\nJoined the PAN, press ENTER to continue..."));
+00255                         }
+00256                         
+00257                 
+00258                 }
+00259                 
+00260 
+00261         }
+00262 
+00263 
+00268 void CPanConnections::RunL()
+00269         {
+00270         // Something wrong with RConnection start
+00271         if (iStatus != KErrNone)
+00272                 {
+00273                 // PRINT SOMETHING HERE
+00274                                 iConsole.Printf(_L("\nError eith iStatus : %d\n"), iStatus.Int());
+00275                 }
+00276         else
+00277                 {
+00278                 switch (iActiveMode)
+00279                         {
+00280                         case EIAPStart:
+00281                                 // Start the IAP
+00282                                 IapStarted();
+00283                         break;
+00284                 
+00285                         case ESocketAccept:
+00286                                 TcpIpListenComplete();
+00287                         break;
+00288                         
+00289                         case ESocketConnect:
+00290                                 TcpIpConnectionComplete();
+00291                         break;
+00292                 
+00293                         case EUdpReceive:
+00294                                 iRemoteNames.AppendL(iRemoteName);
+00295                                 iConsole.Printf(_L("\nReady to connect another device"));
+00296                         break;
+00297                 
+00298                         default:
+00299                         break;
+00300                         }
+00301 
+00302                 }
+00303 
+00304         }
+00305 
+00310 void CPanConnections::DoCancel()
+00311         {
+00312         CancelIap();
+00313         }
+00314                 
+00315 
+00316 
+00317 
+00321 TInt CPanConnections::StartConnection(TBTDevAddr* aDevAddr, TBool aUsePANNotifier, TBool aUseTcpTransport)
+00322         {
+00323         TInt err = KErrNone;
+00324         iUseTcpTransport = aUseTcpTransport;
+00325         
+00326         // Check if there is an existing IAP.
+00327         if(iIapLoading == EFalse && iIapStarted == EFalse)
+00328                 {
+00329                 // No existing connection so configure IAP in CommDb and start IAP,
+00330                 // this is done by overriding RConnection's preferences with our IAP
+00331                 // information
+00332                 TRAP(err, ConfigureIAPL(ETrue, aDevAddr, aUsePANNotifier));
+00333                 if(err != KErrNone)
+00334                         {
+00335                         iConsole.Printf(_L("IAP Configuration Failed - %d.\n"), err);
+00336                         }
+00337                 else
+00338                         {
+00339                         err = StartIAP();
+00340                         if(err != KErrNone)
+00341                                 {
+00342                                 iConsole.Printf(_L("Failed to start IAP - %d.\n"), err);
+00343                                 }
+00344                         }
+00345                 }
+00346         else
+00347                 {
+00348                 #ifdef __NO_CONTROL_DURING_START__
+00349                         if(iIapLoading && aDevAddr != NULL)
+00350                                 {
+00351                                 // A new connection is required but a listening IAP is pending.
+00352                                 Cancel();
+00353                                 iConnection.Close();
+00354                         
+00355                                 TRAP(err, ConfigureIAPL(ETrue, aDevAddr, aUsePANNotifier));
+00356                                 if(err != KErrNone)
+00357                                         {
+00358                                         iConsole.Printf(_L("IAP Configuration Failed - %d.\n"), err);
+00359                                         }
+00360                                 else
+00361                                         {
+00362                                         err = StartIAP();
+00363                                         if(err != KErrNone)
+00364                                                 {
+00365                                                 iConsole.Printf(_L("Failed to start IAP - %d.\n"), err);
+00366                                                 }
+00367                                         }
+00368                                 return err;
+00369                                 }
+00370                 #endif                  
+00371                 // An IAP already exists.
+00372                 // Make sure that we can store another connection
+00373                 if(iActiveConnections.Count() == 7)
+00374                         {
+00375                         err = KErrOverflow;
+00376                         }
+00377                 else if(aDevAddr)
+00378                         {
+00379                         // Add the BT address of the device to the existing RConnection
+00380                         iControlAddr = *aDevAddr;
+00381                         TPtr8 ptr = iControlAddr.Des();
+00382                         err = iConnection.Control(KCOLAgent, KCOAgentPanConnectDevice, ptr);
+00383                         if(err != KErrNone)
+00384                                 {
+00385                                 __DEBUGGER();
+00386                                 }
+00387                         if (!iUseTcpTransport)
+00388                                 {
+00389                                 ReceiveRemoteName();
+00390                                 }
+00391                         }
+00392                 }       
+00393         return err;
+00394         }
+00395         
+00396         
+00400 TInt CPanConnections::StartIAP()
+00401         {
+00402         TInt rerr = KErrNone;
+00403         // Create a set of connection preferences to override existing
+00404         // set in CommDb when RConnection::Start is called.
+00405         TCommDbConnPref connPref;
+00406         PanProfileIAPs iap(EGeneralIAP);
+00407                 
+00408         connPref.SetIapId(iap);
+00409         connPref.SetDialogPreference(ECommDbDialogPrefDoNotPrompt);
+00410         
+00411         // load BT stack        
+00412         rerr = Initialise();
+00413         if(rerr == KErrNone)
+00414                 {
+00415                 // Open the connection
+00416                 rerr = iConnection.Open(iSockSvr);
+00417                 if(rerr == KErrNone)
+00418                         {
+00419                         // Start the connection
+00420                         // use the iStatus of active object, if it doesn't complete (we are listening)
+00421                         // then the active object deals with it, otherwise AO calls IapStarted function on this class
+00422                         // Something wrong with RConnection start
+00423                         iActiveMode = EIAPStart;        
+00424                         iConnection.Start(connPref, iStatus);
+00425                         SetActive();
+00426                         iIapLoading = ETrue;
+00427                         }
+00428                 }
+00429         return rerr;
+00430         }
+00431         
+00432         
+00437 void CPanConnections::ConfigureIAPL(TBool aIsListening, TBTDevAddr* aDevAddr, TBool aUsePANNotifier)
+00438         {
+00439         // Open CommDb and get a view of the PAN service extentions table.
+00440         CCommsDatabase* db = CCommsDatabase::NewL();
+00441         CleanupStack::PushL(db);
+00442         CCommsDbTableView* tableView = db->OpenTableLC(TPtrC(PAN_SERVICE_EXTENSIONS));
+00443 
+00444         TBuf<KMaxBufferSize> tableName;
+00445         TInt err = tableView->GotoFirstRecord();
+00446         if(err == KErrNone)
+00447                 {
+00448                 tableView->ReadTextL(TPtrC(COMMDB_NAME), tableName);
+00449                 if(tableName == TPtrC(_S("PANServiceExtensionsTable1")))
+00450                         {
+00451                         
+00452                         User::LeaveIfError(tableView->UpdateRecord());// Start update
+00453                         //enable listening mode 
+00454                         tableView->WriteBoolL(TPtrC(PAN_ALLOW_INCOMING),aIsListening);
+00455                         tableView->WriteBoolL(TPtrC(PAN_DISABLE_SDP_QUERY), 0);
+00456 
+00457                         tableView->WriteBoolL(TPtrC(PAN_PROMPT_FOR_REMOTE_DEVICES), aUsePANNotifier);
+00458 
+00459                         if(aDevAddr)
+00460                                 {
+00461                                 TBuf<KMaxBufferSize> buf;
+00462                                 aDevAddr->GetReadable(buf);
+00463 
+00464                                 tableView->WriteTextL(TPtrC(PAN_PEER_MAC_ADDRESSES), buf);
+00465                                 }
+00466                         else
+00467                                 {
+00468                                 tableView->WriteTextL(TPtrC(PAN_PEER_MAC_ADDRESSES), _L(""));
+00469                                 }
+00470                         // Finalise changes made.
+00471                         User::LeaveIfError(tableView->PutRecordChanges());// Finish update
+00472                         User::LeaveIfError(db->CommitTransaction());
+00473 
+00474                         CleanupStack::PopAndDestroy(2); // db & tableView
+00475                         return;
+00476                         }
+00477                 }
+00478         User::Leave(KErrNotFound);
+00479         }
+00480         
+00481         
+00487 void CPanConnections::SetLocalIpAddrL(TUint32 addr)
+00488         {
+00489         iLocalIpAddr = addr;
+00490         iSrcAddr.SetAddress(iLocalIpAddr);
+00491         CCommsDatabase* db = CCommsDatabase::NewL();
+00492         CleanupStack::PushL(db);
+00493         // Get the LAN service table
+00494         CCommsDbTableView* tableView = db->OpenTableLC(TPtrC(LAN_SERVICE));
+00495 
+00496         TBuf<KMaxBufferSize> tableName;
+00497         TInt err = tableView->GotoFirstRecord();
+00498         if(err == KErrNone)
+00499                 {
+00500                 // Get the name of the table
+00501                 tableView->ReadTextL(TPtrC(COMMDB_NAME), tableName);
+00502                 if(tableName == TPtrC(_S("BluetoothPANProfile")))
+00503                         {
+00504                         TInetAddr tempAddr;
+00505                         TBuf<KMaxBufferSize> dispBuf;
+00506                         tempAddr.SetAddress(iLocalIpAddr);
+00507                         tempAddr.Output(dispBuf);
+00508                         
+00509                         User::LeaveIfError(tableView->UpdateRecord());  
+00510                         tableView->WriteTextL(_L("IpAddr"), dispBuf);
+00511                 
+00512                         User::LeaveIfError(tableView->PutRecordChanges());
+00513                         User::LeaveIfError(db->CommitTransaction());    
+00514                         }
+00515                 }
+00516         else
+00517                 {
+00518                 User::Leave(KErrNotFound);
+00519                 }
+00520         CleanupStack::PopAndDestroy(2);//db & tableView 
+00521         }
+00522         
+00523         
+00524         
+00530 void CPanConnections::SetFixedRoleL(TSide aSide, TUint aRole)
+00531         {
+00532         if (aSide == ELocalRole)
+00533                 iLocalRole = aRole;
+00534         else
+00535                 iPeerRole = aRole;
+00536         
+00537         CCommsDatabase* db = CCommsDatabase::NewL();
+00538         CleanupStack::PushL(db);
+00539         CCommsDbTableView* tableView = db->OpenTableLC(TPtrC(PAN_SERVICE_EXTENSIONS));
+00540 
+00541         TBuf<KMaxBufferSize> tableName;
+00542         TInt err = tableView->GotoFirstRecord();
+00543         if(err == KErrNone)
+00544                 {
+00545                 tableView->ReadTextL(TPtrC(COMMDB_NAME), tableName);
+00546                 if(tableName == TPtrC(_S("PANServiceExtensionsTable1")))
+00547                         {
+00548                         User::LeaveIfError(tableView->UpdateRecord());  
+00549                         if(aSide == ELocalRole)
+00550                                 {
+00551                                 tableView->WriteBoolL(TPtrC(PAN_LOCAL_ROLE), aRole);
+00552                                 }
+00553                         else 
+00554                                 {
+00555                                 tableView->WriteBoolL(TPtrC(PAN_PEER_ROLE), aRole);
+00556                                 }
+00557                         User::LeaveIfError(tableView->PutRecordChanges());
+00558                         User::LeaveIfError(db->CommitTransaction());
+00559 
+00560                         CleanupStack::PopAndDestroy(2);
+00561                         return;
+00562                         }
+00563                 }
+00564         User::Leave(KErrNotFound);
+00565         }
+00566         
+00571 void CPanConnections::PrintIAPL()
+00572         {
+00573         CCommsDatabase* db = CCommsDatabase::NewL();
+00574         CleanupStack::PushL(db);
+00575         CCommsDbTableView* tableView = db->OpenTableLC(TPtrC(PAN_SERVICE_EXTENSIONS));
+00576 
+00577         TInt err = tableView->GotoFirstRecord();
+00578         
+00579         if(err == KErrNone)
+00580                 {
+00581                 // Print the IAP
+00582                 TUint32 uVal;
+00583                 TBool bVal;
+00584                 TBuf<KMaxBufferSize> sVal;
+00585         
+00586 
+00587                 iConsole.Printf(_L("------------------- CURRENT IAP ------------------\n"));
+00588                 
+00589                 tableView->ReadUintL(TPtrC(PAN_LOCAL_ROLE), uVal);
+00590                 iConsole.Printf(_L("Local Role: %d, "), uVal);                  
+00591                 tableView->ReadUintL(TPtrC(PAN_PEER_ROLE), uVal);
+00592                 iConsole.Printf(_L("Peer Role: %d\n"), uVal);
+00593                 tableView->ReadBoolL(TPtrC(PAN_PROMPT_FOR_REMOTE_DEVICES), bVal);
+00594                 iConsole.Printf(_L("Peer Prompt: %d, "), bVal);                 
+00595                 tableView->ReadBoolL(TPtrC(PAN_DISABLE_SDP_QUERY), bVal);
+00596                 iConsole.Printf(_L("Disable SDP: %d, "), bVal);                 
+00597                 tableView->ReadBoolL(TPtrC(PAN_ALLOW_INCOMING), bVal);
+00598                 iConsole.Printf(_L("Listening: %d\n"), bVal);                   
+00599                 tableView->ReadTextL(TPtrC(PAN_PEER_MAC_ADDRESSES), sVal);
+00600                 iConsole.Printf(_L("Peer MAC Addr: %S\n"), &sVal);
+00601 
+00602                 iConsole.Printf(_L("--------------------------------------------------\n"));
+00603                 CleanupStack::PopAndDestroy(2);
+00604                 return;
+00605                 }
+00606         User::Leave(KErrNotFound);
+00607         }
+00608 
+00609 
+00613 TInt CPanConnections::StopIAP()
+00614         {
+00615         TInt rerr = KErrNone;
+00616         if(iIapLoading)
+00617                 {
+00618                 Cancel();
+00619                 }
+00620         else
+00621                 {
+00622                 if(iIapStarted)
+00623                         {
+00624                         rerr = iConnection.Stop();
+00625                         if(rerr != KErrNone)
+00626                                 {
+00627                                 iConsole.Printf(_L("Failed to STOP IAP.  Err %d.\n"), rerr);
+00628                                 }
+00629                         iIapStarted = EFalse;
+00630                         }
+00631                 }
+00632         return rerr;
+00633         }
+00634         
+00635         
+00640 void CPanConnections::CancelIap()
+00641         {
+00642         iIapLoading = EFalse;
+00643         iConnection.Stop();
+00644         }
+00645         
+00652 TInt CPanConnections::StopConnection()
+00653         {
+00654         TInt rerr = KErrNone;
+00655         if(iActivePanConn >= iActiveConnections.Count())
+00656                 {
+00657                 rerr = KErrArgument;
+00658                 }
+00659         else if(iActivePanConn != KErrNotFound)
+00660                 {
+00661                 // get the deivce we wish to disconnect
+00662                 TPtr8 ptr = iActiveConnections[iActivePanConn].Des();
+00663                 rerr = iConnection.Control(KCOLAgent, KCOAgentPanDisconnectDevice, ptr);
+00664                 if(rerr != KErrNone)
+00665                         {
+00666                         __DEBUGGER();
+00667                         }
+00668                 }
+00669         else 
+00670                 {
+00671                 rerr = KErrNotFound;
+00672                 }
+00673         return rerr;
+00674         }
+00675         
+00676         
+00682 TInt CPanConnections::SetActivePanConn(TUint aConnIndex)
+00683         {
+00684         TInt rerr = KErrArgument;
+00685         
+00686         if((TInt)aConnIndex < iActiveConnections.Count())
+00687                 {
+00688                 iActivePanConn = aConnIndex;
+00689                 rerr = KErrNone;
+00690                 }
+00691         return rerr;
+00692         }
+00693 
+00694 
+00695 
+00700 TInt CPanConnections::UpdateCurrentConnections()
+00701         {
+00702         TInt rerr = KErrNone;
+00703         HBufC8* buffer=0;
+00704         const TInt KAddrLen = sizeof(TBTDevAddr);
+00705 
+00706         TRAP(rerr, buffer = HBufC8::NewL(7*KAddrLen));// create a buffer to house the device address
+00707         if(rerr == KErrNone)
+00708                 {
+00709                 TPtr8 ptr = buffer->Des();
+00710                 // use RConnection to enumerate all the devices
+00711                 rerr = iConnection.Control(KCOLAgent, KCOAgentPanEnumerateDevices, ptr);
+00712                 if(rerr == KErrNone)
+00713                         {
+00714                         iActiveConnections.Reset();
+00715                         while(ptr.Length()>=KBTDevAddrSize)
+00716                                 {
+00717                                 // inspect the addr's in the descriptor and append them to the array.
+00718                                 TBTDevAddr parsedAddr(ptr.Mid(ptr.Length()-KAddrLen, KBTDevAddrSize));
+00719                                 ptr.SetLength(Max(ptr.Length()-KAddrLen, 0));
+00720                                 iActiveConnections.Append(parsedAddr);
+00721                                 }
+00722                         }
+00723                 }
+00724         delete buffer;
+00725         return rerr;
+00726         }
+00727 
+00731 void CPanConnections::PrintConns()
+00732         {
+00733         iConsole.Printf(_L("\nRemotenames : %d\n"), iRemoteNames.Count());
+00734         PrintTcpSocketConnections();
+00735         iConsole.Printf(_L("--------------------------------------------------\n"));
+00736         iConsole.Printf(_L("Listening Mode: "));
+00737         iListening ? iConsole.Printf(_L("Enabled        ")) : iConsole.Printf(_L("Disabled        "));
+00738         if(iIapStarted)
+00739                 {
+00740                 iConsole.Printf(_L("       IAP Started"));
+00741 
+00742                 TInt err = UpdateCurrentConnections();
+00743                 if(err != KErrNone)
+00744                         {
+00745                         iConsole.Printf(_L("FAILED TO ENUMERATE CONNECTIONS. Err %d\n"), err);
+00746                         }
+00747                 else
+00748                         {
+00749                         iConsole.Printf(_L("\n------------------ CONNECTIONS -------------------\n"));
+00750                         iConsole.Printf(_L("Index  Remote Addr\n"));
+00751                         
+00752                         
+00753                         for(TInt i=0;i<iActiveConnections.Count();i++)
+00754                                 {
+00755                                 TBuf<KMaxBufferSize> dispBuf;
+00756                                 iActiveConnections[i].GetReadable(dispBuf);
+00757 
+00758                                 if(iActivePanConn == i)
+00759                                         {
+00760                                         iConsole.Printf(_L("-> "));
+00761                                         }
+00762                                 else
+00763                                         {
+00764                                         iConsole.Printf(_L("   "));
+00765                                         }
+00766                                 iConsole.Printf(_L("%d   0x%S\n"), i, &dispBuf);                                
+00767                                 }
+00768                         }
+00769                 }
+00770         
+00771         if(iLocalIpAddr == 0)
+00772                 {
+00773                 iConsole.Printf(_L("\nNo local IP address set\n"));
+00774                 }
+00775         else
+00776                 {
+00777                 TInetAddr tempAddr;
+00778                 TBuf<KMaxBufferSize> dispBuf;
+00779                 
+00780                 tempAddr.SetAddress(iLocalIpAddr);
+00781                 tempAddr.Output(dispBuf);
+00782                 
+00783                 iConsole.Printf(_L("\nLocal IP address: %S\n"), &dispBuf);
+00784                 }
+00785 
+00786         }
+00787 
+00791 TUint32 CPanConnections::GetLocalIpAddr()
+00792         {
+00793         return iLocalIpAddr;
+00794         }
+00795 
+00796 
+00797         
+00802 void CPanConnections::TcpIpConnectionComplete()
+00803         {
+00804         if (iStatus == KErrNone)
+00805                 {
+00806                 iConsole.Printf(_L("\nSuccessfully joined PAN\n"));
+00807                 }
+00808         else
+00809                 {
+00810                 iConsole.Printf(_L("Join PAN Failed!, Socket error : %d"), iStatus.Int());
+00811                 }
+00812 
+00813         }
+00814         
+00815         
+00816 
+00817         
+00821 void CPanConnections::ConnectDoCancel()
+00822         {
+00823         iConsole.Printf(_L("TCP/IP connection Canceled!\n"));
+00824         iSocket.CancelConnect();
+00825         }
+00826         
+00831 RArray<TInetAddr>& CPanConnections::RemoteNames()
+00832         {
+00833         return iRemoteNames;
+00834         }
+00835         
+00836 RSocket& CPanConnections::GetSocket()
+00837         {
+00838         return iSocket;
+00839         }
+00840         
+00841 RArray<RSocket>& CPanConnections::GetSocketArray()
+00842         {
+00843         return iSocketArray;
+00844         }
+00845         
+00852 void CPanConnections::TcpIpListenComplete()
+00853         {
+00854         // iPanEstablished ????
+00855         if (iStatus == KErrNone)
+00856                 iConsole.Printf(_L("Player Joined\n"));
+00857         else
+00858                 iConsole.Printf(_L("TCP socket failed : %d\n"), iStatus.Int());
+00859         // Call accept for the next device to connect to
+00860         TInt err = AcceptNewSocket();
+00861         if (err!=KErrNone)
+00862                 iConsole.Printf(_L("AcceptNewSocket() Failed : %d\n"),err);
+00863         }
+00864         
+00865         
+00870 void CPanConnections::ListenDoCancel()
+00871         {
+00872         iConsole.Printf(_L("\nTCP/IP accept Canceled!\n"));
+00873         iSocket.CancelAccept(); 
+00874         }
+00875         
+00876         
+00881 void CPanConnections::SetRemoteIpAddr(TUint32 aAddr)
+00882         {
+00883         iRemoteIpAddr = aAddr;
+00884         }
+00885 
+00889 TUint32 CPanConnections::GetRemoteIpAddr() const
+00890         {
+00891         return iRemoteIpAddr;
+00892         }
+00893         
+00894 TInt CPanConnections::UdpBind()
+00895         {
+00896         iSrcAddr.SetPort(KGenericPort);
+00897         iSrcAddr.SetAddress(iLocalIpAddr);
+00898         return iSocket.Bind(iSrcAddr);
+00899         }
+00900         
+00901 // This function will be used if a PAN-Gn
+00902 void CPanConnections::ReceiveRemoteName()
+00903         {
+00904         // Attempt to receive, this will happen one by one due to authorisation 
+00905 //      if (iRemoteNames.Count() < iActiveConnections.Count())
+00906 //              {
+00907                 
+00908                 iActiveMode = EUdpReceive;
+00909                 iSocket.RecvFrom(iBuff,iRemoteName, 0, iStatus);
+00910                 SetActive();
+00911 //              }
+00912 //      else
+00913 //              {
+00914 //              iConsole.Printf(_L("\nAll devices have told us:!!!!!!"));
+00915 //              }
+00916         }
+00917 
+00918 void CPanConnections::CancelRecvFrom()
+00919         {
+00920         iSocket.CancelRecv();
+00921         }
+00926 TInt CPanConnections::TcpIpBindAndConnect()
+00927         {
+00928         TInt rerr;
+00929 
+00930         if (iRemoteIpAddr == 0)
+00931                 {
+00932                 iConsole.Printf(_L("You need to set a destination IP address.\n"));
+00933                 return (KErrArgument);
+00934                 }
+00935                 
+00936         if (!IsActive()/* && iTcpIpMode != ETcpReceive*/)
+00937                 {
+00938                 // Setup the TInetAddrs inc. port number
+00939                 iDstAddr.SetPort(KGenericPort);
+00940                 iDstAddr.SetAddress(iRemoteIpAddr);
+00941                 iSrcAddr.SetPort(KGenericPort);
+00942                 iSrcAddr.SetAddress(iLocalIpAddr);
+00943 
+00944                 rerr = iSocket.Bind(iSrcAddr);// Bind the socket
+00945                 if (rerr != KErrNone)
+00946                         {
+00947                         iConsole.Printf(_L("Failed : %d"), rerr);
+00948                         return (rerr);
+00949                         }
+00950                 iActiveMode = ESocketConnect; // Set the mode for the active object
+00951                 iSocket.Connect(iDstAddr, iStatus);// Attempt connection to dest. addr
+00952                 SetActive();
+00953                 }
+00954         return KErrNone;
+00955         }
+00956         
+00960 TInt CPanConnections::TcpIpBindAndListen()
+00961         {
+00962         TInt rerr;
+00963         iDstAddr.SetPort(KGenericPort);
+00964         iDstAddr.SetAddress(iRemoteIpAddr);
+00965         iSrcAddr.SetPort(KGenericPort);
+00966         iSrcAddr.SetAddress(iLocalIpAddr);
+00967         
+00968         rerr = iSocket.Bind(iSrcAddr);
+00969         if (rerr != KErrNone)
+00970                 {
+00971                 iConsole.Printf(_L("Failed to bind with socket : %d"), rerr);
+00972                 return (rerr);
+00973                 }
+00974         rerr = iSocket.Listen(7);// maximum devices is 7
+00975         if (rerr != KErrNone)
+00976                 {
+00977                 iConsole.Printf(_L("Failed to listen on socket : %d"), rerr);
+00978                 return (rerr);
+00979                 }
+00980         return (KErrNone);
+00981         }
+00982 
+00990 TInt CPanConnections::AcceptNewSocket()
+00991         {
+00992 
+00993 // Accept new socket will only be called if using TCP sockets   
+00994         TInt currentSocketCount = iSocketArray.Count();
+00995         TInt rerr;
+00996         if (currentSocketCount == iActiveConnections.Count())
+00997                 {
+00998                 // We already have the same number of connections as 
+00999                 // devices on the PAN, move on to dish out player numbers
+01000                 iConsole.Printf(_L("\nAll players on PAN have joined!!\n"));
+01001                 TRequestStatus status;
+01002                 for (TInt i=0;i<iSocketArray.Count();i++)
+01003                         {
+01004                         status = KRequestPending;
+01005                 //      iPlayerNum = i;
+01006                 //      iSocketArray[i].Send(iPlayerNum, 0, status);
+01007                         User::WaitForRequest(status);
+01008                         if (status != KErrNone)
+01009                                 {
+01010                                 // We have failed to send player number to the player
+01011                                 // Remove them from the socket array and the network
+01012                                 iSocketArray[i].Close();
+01013                                 iSocketArray.Remove(i);
+01014                                 TPtr8 ptr = iActiveConnections[i].Des();
+01015                                 iConnection.Control(KCOLAgent, KCOAgentPanDisconnectDevice, ptr);
+01016                                 i--;
+01017                                 }
+01018                         }
+01019                 ListenDoCancel();// Cancel any oustanding Accepts.
+01020                 return (KErrNone);
+01021                 }
+01022         else
+01023                 {
+01024                 RSocket socket;
+01025                 iSocketArray.Append(socket);
+01026                 TInt last = iSocketArray.Count()-1;
+01027                 rerr = iSocketArray[last].Open(iSockSvr);
+01028                 if (rerr != KErrNone)
+01029                         {
+01030                         iConsole.Printf(_L("Failed to open 'Service' Socket : %d"), rerr);
+01031                         return (rerr);
+01032                         }
+01033                 iActiveMode = ESocketAccept;// set the mode for the active object 
+01034                 iSocket.Accept(iSocketArray[last], iStatus);
+01035                 SetActive();    
+01036                 return (rerr);
+01037                 }
+01038         }
+01039         
+01043 TInt CPanConnections::CloseTcpIpSocketConnect()
+01044         {
+01045         TRequestStatus status;
+01046         // Shutdown immediately
+01047         iSocket.Shutdown(RSocket::EImmediate, status);
+01048         User::WaitForRequest(status);
+01049         iConsole.Printf(_L("\nConnection closed with error: %d"), status.Int());
+01050         return (status.Int());
+01051         }
+01052         
+01057 TInt CPanConnections::CloseAllTcpIpSockets()
+01058         {
+01059         TRequestStatus status;
+01060         for (TInt i=0; i<iSocketArray.Count(); i++)
+01061                 {
+01062                 iSocketArray[i].Shutdown(RSocket::EImmediate, status);
+01063                 User::WaitForRequest(status);
+01064                 iConsole.Printf(_L("\nConnection to %d closed with error: %d"), i, status.Int());
+01065                 }
+01066         return (KErrNone); 
+01067         }
+01068         
+01072 TInt CPanConnections::CloseCurrentTcpIpSocket()
+01073         {
+01074         TRequestStatus status;
+01075         iSocketArray[iActiveTcpSocket].Shutdown(RSocket::EImmediate, status);
+01076         User::WaitForRequest(status);
+01077         iConsole.Printf(_L("\nConnection closed with error: %d"), status.Int());
+01078         return (status.Int());
+01079         }
+01080         
+01084 void CPanConnections::PrintTcpSocketConnections()
+01085         {
+01086         iConsole.Printf(_L("---------------- UDP CONNECTIONS -----------------\n"));
+01087         iConsole.Printf(_L("Devices on Piconet\n"));
+01088 //      if (iSocketArray.Count() <= 1 && IsActive())
+01089 //              {
+01090 //              // We only have one socket, make sure it is connected
+01091                 // as it might still be accepting.
+01092 //              iConsole.Printf(_L("\n                  NO DEVICES\n"));
+01093 //              }
+01094 //      else
+01095 //              {
+01096                 TInt count;
+01097                 if (IsActive() && iActiveMode == ESocketAccept)
+01098                         count = iRemoteNames.Count()-1;
+01099                 else
+01100                         count = iRemoteNames.Count();
+01101                 for(TInt i=0;i<count;i++)
+01102                         {
+01103                         TBuf<KMaxBufferSize> dispBuf;
+01104                         //TInetAddr address;
+01105                 //      iRemoteNames[i].RemoteName(address);
+01106                         iRemoteNames[i].Output(dispBuf);
+01107                         iConsole.Printf(_L("            %d - %S\n"), i, &dispBuf);                              
+01108                         }
+01109 //              }
+01110         iConsole.Printf(_L("--------------------------------------------------\n"));
+01111         }
+01112         
+01116 TInt CPanConnections::GetLocalRole() const
+01117         {
+01118         return (iLocalRole);
+01119         }
+01120         
+01121 
+01122 
+01126 TInt CPanConnections::ActiveConnCount()
+01127         {
+01128         return iActiveConnections.Count();
+01129         }
+01130 
+01131 
+01132 void CPanConnections::CancelAllOperations()
+01133         {
+01134         for (TInt i=0;i<iSocketArray.Count();i++)
+01135                 {
+01136                 iSocketArray[i].CancelAll();
+01137                 }
+01138         }
+