I dont think problem has to do something with Series80 SDK, in my view its generic problem irrespective of Series as I am trying on Series 60 Sdk 2.6 (Symbian 8.0a).

Regards
Pankaj

Yes, now I am able to connect using Socket server on emulator.

Hello Devi

You cant check behavior of RConnection establishing GPRS connection as it shows no indication, anyways here is the code for establishing GPRS connection. I have tested this code on Series60 SDK 2.6

#include <eikgted.h>
#include <cdbcols.h>
#include <commdb.h>
#include <es_sock.h>
#include <eikenv.h>
#include <commdbconnpref.h>
#include <StringLoader.h>   // StringLoader
#include <TcpipMultiHomingEx.rsg>

#include "TcpipMultiHomingExAppui.h"
#include "TcpipMultiHomingExTimer.h"
#include "TcpipMultiHomingEx.pan"

const TInt KTextMaxLength = 30;
const TInt KTimeOut = 30000000; // 30 seconds time-out
const TInt KDefaultPortNumber = 777;

// default values to acces daytime server
_LIT(KDefaultServerName, "time-a.nist.gov");


CTcpipMultiHomingExEngine* CTcpipMultiHomingExEngine::NewL(MTcpipMultiHomingExEngineObserver& aObserver)
   {
   CTcpipMultiHomingExEngine* self = CTcpipMultiHomingExEngine::NewLC(aObserver);
   CleanupStack::Pop(self);
   return self;
   }


CTcpipMultiHomingExEngine* CTcpipMultiHomingExEngine::NewLC(MTcpipMultiHomingExEngineObserver& aObserver)
   {
   CTcpipMultiHomingExEngine* self = new (ELeave) CTcpipMultiHomingExEngine(aObserver);
   CleanupStack::PushL(self);
   self->ConstructL();
   return self;
   }


CTcpipMultiHomingExEngine::CTcpipMultiHomingExEngine(MTcpipMultiHomingExEngineObserver& aObserver)
: CActive(EPriorityStandard),
 iObserver(aObserver),
 iPort(KDefaultPortNumber),
 iServerName(KDefaultServerName)
   {
   }


CTcpipMultiHomingExEngine::~CTcpipMultiHomingExEngine()
   {
   iEngineStatus = EDestroyed;
   Cancel();

   delete iTimer;

   if (iSocketServ.Handle() != 0)
      {
      iSocketServ.Close();
      }
   }


void CTcpipMultiHomingExEngine::ConstructL()
   {
   ChangeStatus(ENotConnected);

   // Start a timer
   iTimer = CTcpipMultiHomingExTimer::NewL(EPriorityHigh, *this);
   CActiveScheduler::Add(this);

   // Open channel to Socket Server
   User::LeaveIfError(iSocketServ.Connect());
   }


void CTcpipMultiHomingExEngine::ConnectL()
   {
   // Initiate connection process
   if (iEngineStatus == ENotConnected)
       {

      //Open an RConnection on the Socket Server
      User::LeaveIfError(iRConn.Open(iSocketServ));

      // Start the Connection
      iRConn.Start(iStatus);
      ChangeStatus(ERConnStarting);
      iTimer->After(KTimeOut);
      SetActive();
       }
   }


void CTcpipMultiHomingExEngine::ConnectL(TUint32 aAddr)
   {
   // Initiate attempt to connect to a socket by IP address
   if (iEngineStatus == ENotConnected)
       {
       // Open a TCP socket
       User::LeaveIfError(iSocket.Open(iSocketServ, KAfInet, KSockStream, KProtocolInetTcp, iRConn));

       // Set up address information
       iAddress.SetPort(iPort);
       iAddress.SetAddress(aAddr);

       // Initiate socket connection
       iSocket.Connect(iAddress, iStatus);
       ChangeStatus(EConnecting);

       // Start a timeout
       iTimer->After(KTimeOut);

       SetActive();
       }
   }


void CTcpipMultiHomingExEngine::Disconnect()
   {
   // cancel all outstanding operations
   Cancel();
   iSocket.Close();
   ChangeStatus(ENotConnected);
   }


// from CActive
void CTcpipMultiHomingExEngine::DoCancel()
   {
   iTimer->Cancel();

   TEngineState state = ENotConnected;
   // Cancel appropriate request to socket
   switch (iEngineStatus)
       {
      case EDestroyed:
         state = EDestroyed;
      case ENotConnected:
      case ERConnStarting:
       case EConnecting:
      case EConnected:
       case ELookingUp:
      case EReading:
         if (iRConn.SubSessionHandle() != 0)
            {
            iRConn.Close();
            }
           if (iResolver.SubSessionHandle() != 0)
            {
            iResolver.Cancel();
            iResolver.Close();
            }
            if (iSocket.SubSessionHandle() != 0)
            {
            iSocket.CancelAll();
             iSocket.Close();
            }
         break;
       default:
           User::Panic(KPanicTcpipMultiHomingExEngine, ETcpipMultiHomingExBadStatus);
           break;
       }

   ChangeStatus(state);
   }


void CTcpipMultiHomingExEngine::Read()
   {
   // Initiate read of data from socket
   if (iEngineStatus == EConnected)
       {
      // Initiate a new read from socket into iBuffer
      __ASSERT_ALWAYS(!IsActive(), User::Panic(KPanicTcpipMultiHomingExEngineRead, ETcpipMultiHomingExBadState));
      iSocket.RecvOneOrMore(iBuffer, 0, iStatus, iLength);
      ChangeStatus(EReading);
      SetActive();
       }
   }


// from CActive
void CTcpipMultiHomingExEngine::RunL()
   {
   // Active object request complete handler.
   // iEngineStatus flags what request was made, so its
   // completion can be handled appropriately
   iTimer->Cancel(); // Cancel TimeOut timer before completion

   switch(iEngineStatus)
       {

      case ERConnStarting:
         // need to look up name using dns
         // Initiate DNS
         User::LeaveIfError(iResolver.Open(iSocketServ, KAfInet, KProtocolInetUdp, iRConn));
         // DNS request for name resolution
         iResolver.GetByName(iServerName, iNameEntry, iStatus);

         ChangeStatus(ELookingUp);
         // Request time out
         iTimer->After(KTimeOut);
         SetActive();
         break;

       case ELookingUp:
          iResolver.Close();
          if (iStatus == KErrNone)
              {
             // DNS look up successful
             iNameRecord = iNameEntry();

               ChangeStatus(ENotConnected);
            TInetAddr lInetAddr;
            _LIT(KInetAddr,"10.203.140.33");
            lInetAddr.Input(KInetAddr);
             ConnectL(lInetAddr.Address());
              }
          else
              {
               // DNS lookup failed
            Cancel();
            ReportErrorL(EDNSLookupFailed, iStatus.Int());
              }
          break;

       case EConnecting:
          // IP connection request
          if (iStatus == KErrNone)
              // Connection completed successfully
              {
             ChangeStatus(EConnected);
            // Get the time
             Read();
              }
          else
              {
             Cancel();
            ReportErrorL(EConnectionFailed, iStatus.Int());
               }
          break;
      case EReading:
         {
         switch (iStatus.Int())
            {
            case KErrNone:
               {
               // Character has been read from socket
               TBuf<KReadBufferSize> unicodeBuf;
               unicodeBuf.Copy(iBuffer);
               iObserver.ResponseReceivedL(unicodeBuf);
               Disconnect();
               }
               break;
             case KErrDisconnected:
               {
               Cancel();
               ReportErrorL(EDisconnected, iStatus.Int());
               }
               break;
            default:
               {
               Cancel();
               ReportErrorL(EGeneralReadError,iStatus.Int());
               }
               break;
            }
         break;
         }

       default:
           User::Panic(KPanicTcpipMultiHomingExEngine, ETcpipMultiHomingExBadStatus);
           break;

       };
   }


void CTcpipMultiHomingExEngine::TimerExpiredL()
   {
   Cancel();
   ReportErrorL(ETimedOut,KErrTimedOut);
   }


void CTcpipMultiHomingExEngine::ReportErrorL(TErrorType aErrorType, TInt aErrorCode)
   {
   // No recovery or retries are attempted in this example so we just
   // disconnect and inform the user
   Disconnect();
   TBuf<KTextMaxLength> text;

   switch (aErrorType)
       {
       case EDisconnected:
         StringLoader::Load(text, R_DISCONNECTED_TEXT);
           iObserver.ErrorL(text, aErrorCode);
           break;
       case EGeneralReadError:
         StringLoader::Load(text, R_READ_ERROR_TEXT);
           iObserver.ErrorL(text, aErrorCode);
           break;
      case EConnectionFailed:
         StringLoader::Load(text, R_CONN_FAILED_TEXT);
         iObserver.ErrorL(text, aErrorCode);
         break;
      case EDNSLookupFailed:
         StringLoader::Load(text, R_DNS_ERROR_TEXT);
         iObserver.ErrorL(text, aErrorCode);
         break;
      case ETimedOut:
         StringLoader::Load(text, R_TIMED_OUT);
         iObserver.ErrorL(text, KErrTimedOut);
         break;
       default:
           User::Panic(KPanicTcpipMultiHomingExEngine, ETcpipMultiHomingExBadStatus);
           break;
       }
   }


void CTcpipMultiHomingExEngine::ChangeStatus(TEngineState aNewStatus)
   {
   TBuf<KTextMaxLength> text;

   // Update the status (and the status display)
   switch (aNewStatus)
       {
       case ENotConnected:
         StringLoader::Load(text, R_NOT_CONNECTED_TEXT);
           iObserver.SetStatus(text);
           break;
      case ERConnStarting:
         StringLoader::Load(text, R_RCONNECTING_TEXT);
           iObserver.SetStatus(text);
         break;
       case EConnecting:
         StringLoader::Load(text, R_CONNECTING_TEXT);
           iObserver.SetStatus(text);
           break;
       case EConnected:
           StringLoader::Load(text, R_CONNECTED_TEXT);
           iObserver.SetStatus(text);
           break;
       case ELookingUp:
         StringLoader::Load(text, R_LOOKINGUP_TEXT);
           iObserver.SetStatus(text);
           break;
      case EReading:
         StringLoader::Load(text, R_READING_TEXT);
         iObserver.SetStatus(text);
         break;
      case EDestroyed:
         break;
       default:
           User::Panic(KPanicTcpipMultiHomingExEngine, ETcpipMultiHomingExBadStatus);
           break;
       }

   iEngineStatus = aNewStatus;
   }