--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/irda/irdastack/irtranp/SCEP.CPP Fri Jan 15 08:13:17 2010 +0200
@@ -0,0 +1,922 @@
+// Copyright (c) 1997-2009 Nokia Corporation and/or its subsidiary(-ies).
+// All rights reserved.
+// This component and the accompanying materials are made available
+// under the terms of "Eclipse Public License v1.0"
+// which accompanies this distribution, and is available
+// at the URL "http://www.eclipse.org/legal/epl-v10.html".
+//
+// Initial Contributors:
+// Nokia Corporation - initial contribution.
+//
+// Contributors:
+//
+// Description:
+//
+
+#include "debug.h"
+
+#include <e32math.h>
+#include <e32svr.h>
+#include "comreadwrite.h"
+#include "tranp.h"
+#include "tranpprot.h"
+#include "SCEP.H"
+#include "COMMANDP.H"
+#include "ABSTRACT.H"
+#include "SCONREQC.H"
+#include "SCONCONC.H"
+#include "SRPSCOMM.H"
+#include "GLOBAL.H"
+#include "BFTP.H"
+
+
+SCEP::SCEP()
+ {
+ }
+
+/*
+* Method description: Leavable constructor for the SCEP layer
+*
+*/
+
+SCEP* SCEP::NewL(CTranpProtocol* aTranpProtocol, BFTP* a_oBFTP, const MTranpNotification* aNotifier)
+ {
+ DEBUG_OPEN();
+ SCEPPRINT(_L("SCEP::NewL()\n"));
+
+ SCEP* self = new(ELeave) SCEP();
+ CleanupStack::PushL(self);
+ self->ConstructL(aTranpProtocol, a_oBFTP, aNotifier);
+ CleanupStack::Pop();
+ return self;
+ }
+
+/*
+* Method description: Second part of the SCEP construction - creates the CommandProcessor and CComReadWrite.
+*
+* Parameter: Pointer to the BFTP class
+*
+*/
+
+void SCEP::ConstructL(CTranpProtocol* aTranpProtocol, BFTP* a_oBFTP, const MTranpNotification* aNotifier)
+ {
+
+ SCEPPRINT(_L("SCEP::ConstructL()\n"));
+ iNotifier = const_cast<MTranpNotification*>(aNotifier);
+ iState = EWaiting;
+
+ m_uiMaxPDU = 4;
+
+ m_oCommandP = new(ELeave) CommandProcessor();
+ iComReadWrite = CComReadWrite::NewL(*this);
+
+ m_oBFTP = a_oBFTP;
+ iTranpProtocol = aTranpProtocol;
+
+ m_packet = NULL;
+ m_iPicSize = 0;
+ }
+
+SCEP::~SCEP()
+ {
+ delete m_oCommandP;
+ delete iComReadWrite;
+ //delete m_packet; Ownership now belongs to TTranpPicture Object
+ }
+
+/*
+* Method description: Pump - receives and sends data, should be called periodically. Due to the way IrTran-P and
+* serial communication works, it also tries to check when it has received a complete SCEP
+* packet. This should be handled in a differerent (and more nice) way.
+*
+* Returns: An integer containing the progress from 0 to 100
+*/
+
+void SCEP::Abort()
+ {
+ iComReadWrite->Cancel();
+ iComReadWrite->Signal(KErrNone);
+ }
+
+TInt SCEP::Pump()
+ {
+ // Set up the IR port connection with a null write
+ //delete m_packet;
+ //m_packet = NULL;
+ //iState = EWaiting;
+ //iSCEPFrame.SetLength(0);
+ iComReadWrite->Open();
+ return 0;
+ }
+
+void SCEP::ReceiveComplete(TDesC8& aBuffer)
+ {
+ SCEPPRINT_2(_L("SCEP::ReceiveComplete(%d)\n"),aBuffer.Length());
+
+ iSCEPFrame.Append(aBuffer); // Add new data to cached packet
+
+ TBool loopagain;
+ do
+ {
+ loopagain = EFalse;
+
+ if ((iSCEPFrame[0]==0x00)&&(iSCEPFrame.Length()>=3))
+ {
+ TInt tempLength = 0;
+ TInt additionalLength = 0;
+ TInt lengthPos = 3;
+
+ if ((iSCEPFrame[1]==KTranpMsgTypeCER) && (iSCEPFrame[2]==KTranpInfTypeVer))
+ {
+ lengthPos = 5;
+ additionalLength = 4; // ... and that same packet has 4 trailing bytes
+ }
+
+ if (iSCEPFrame.Length()>lengthPos+2)// Otherwise we might miss out on the last packet
+ {
+ if(iSCEPFrame[0] == 0x00) // Let's guess it's an SCEP header - HARDCODED AND UGLY!!!
+ {
+ tempLength = iSCEPFrame[lengthPos];
+ if(tempLength == 0xff)
+ {
+ tempLength = IrTranpUtil::DExtract(iSCEPFrame, lengthPos+1);
+ lengthPos = 5;
+ }
+ SCEPPRINT_2(_L("tempLength = %d"), tempLength);
+ }
+
+ tempLength += ((lengthPos+1) + additionalLength);
+
+ SCEPPRINT_3(_L("iSCEPFrame.length(%d) >= templength(%d)"),iSCEPFrame.Length(),tempLength);
+
+ switch (iSCEPFrame[1])
+ {
+ case KTranpMsgTypeCER: // MsgType = Connection establishment request
+ case KTranpMsgTypeCEC: // MsgType = Connection establishment confirmation
+ case KTranpMsgTypeData: // Data (Command)
+ case KTranpMsgTypeDisc: // Disconnection
+ {
+ switch (iSCEPFrame[2])
+ {
+ case KTranpInfTypeVer: // Version of MsgType
+ case KTranpInfTypeNeg: // Negotiation Information
+ case KTranpInfTypeUser: // UserData
+ case KTranpInfTypeExt: // Extend in the future
+ case KTranpInfTypeRsn: // Reason
+ break;
+ default:
+ // bogus frame
+ SCEPPRINT(_L("SCEP::Bogus Inf Type in frame\n"));
+ iSCEPFrame.SetLength(0);
+ }
+ }
+ break;
+ default:
+ // bogus frame
+ SCEPPRINT(_L("SCEP::Bogus Msg Type in frame\n"));
+ iSCEPFrame.SetLength(0);
+ }
+
+ if(iSCEPFrame.Length() >= tempLength) // yes, complete packet
+ {
+ TInt oldLength = iSCEPFrame.Length();
+ iSCEPFrame.SetLength(tempLength); // We only want exactly one packet
+ ParseCommand(iSCEPFrame);
+
+ iSCEPFrame.SetLength(oldLength);
+ iSCEPFrame.Delete(0, tempLength); // The surplus data belongs to the next packet
+ SCEPPRINT(_L("\r\n***\r\n"));
+ //IrTranpUtil::HexOut(iSCEPFrame);
+ SCEPPRINT(_L("***\r\n"));
+ loopagain = (oldLength > tempLength) ? ETrue : EFalse;
+ }
+ }
+ }
+ else
+ {
+ SCEPPRINT(_L("SCEP:: Bogus Frame header\n"));
+ iSCEPFrame.SetLength(0);
+ }
+ } while (loopagain);
+
+
+ // let the commandprocessor send whatever's in queue
+
+ m_oCommandP->DoCommand();
+
+ if ( (!(iComReadWrite->IsActive())) && !(iState == EError) ) //Make sure that thre is always an outstanding request
+ iComReadWrite->Receive();
+
+ switch(iState)
+ {
+ case EConnected:
+ iNotifier->Connected();
+ iState = EProgress;
+ SCEPPRINT(_L("SCEP: EConnected -> EProgress\r\n"));
+ break;
+ case EDisconnected:
+ iNotifier->Disconnected();
+ iComReadWrite->Close();
+ iState = EWaiting;
+ SCEPPRINT(_L("SCEP: EDisconnected -> EWaiting\r\n"));
+ break;
+ case EProgress:
+ {
+ SCEPPRINT(_L("SCEP: EProgress\r\n"));
+
+ TInt32 progress = 0;
+ if(m_packet!=NULL)
+ {
+ if(m_packet->Length() != 0)
+ {
+ Math::Int(progress, m_packet->Length()*100 / m_iPicSize);
+ }
+ iNotifier->ProgressIndication(progress);
+ }
+ }
+ break;
+ case EWaiting:
+ SCEPPRINT(_L("SCEP: EWaiting\r\n"));
+ break;
+ case EError:
+ SCEPPRINT(_L("SCEP: EError\r\n"));
+ break;
+ case ECommunicationInt:
+ SCEPPRINT(_L("SCEP: ECommunicationInt\r\n"));
+ iNotifier->Disconnected();
+ iComReadWrite->Close();
+ iState = EWaiting;
+ break;
+ default:
+ SCEPPRINT(_L("SCEP: Unknown state\r\n"));
+ break;
+ }
+ SCEPPRINT(_L("SCEP: Exit ReceiveComplete\r\n"));
+ }
+
+void SCEP::SendComplete()
+ {
+ // Post Read Request
+ SCEPPRINT(_L("SCEP: Send Complete\n"));
+ iComReadWrite->Receive();
+ }
+
+void SCEP::SendError(TInt aError)
+ {
+ SCEPPRINT_2(_L("SCEP: Send Error %d\n"), aError);
+ iNotifier->Error(aError);
+ iState = EError;
+ }
+
+void SCEP::ReceiveError(TInt aError)
+ {
+ SCEPPRINT_2(_L("SCEP: Receive Error %d\n"), aError);
+ iNotifier->Error(aError);
+ iState = EError;
+ }
+void SCEP::Error(TInt aError)
+ {
+ SCEPPRINT_2(_L("SCEP: Error %d\n"), aError);
+ iNotifier->Error(aError);
+ iState = EError;
+ }
+
+
+/*
+* Method description: Called from BFTP when a connection request should be sent
+*
+*/
+
+void SCEP::SCONreqL()
+ {
+ SCONreqCommand* command = new(ELeave) SCONreqCommand(iComReadWrite);
+ command->SetPMID(m_PMID.Des());
+ command->SetSMID(m_SMID.Des());
+ command->SetPDU(m_uiMaxPDU);
+ command->Create();
+ //IrTranpUtil::HexOut(command->GetData());
+ m_oCommandP->Add(command);
+ }
+
+/*
+* Method description: Called from BFTP when a connection confirmed should be sent
+*
+*/
+
+void SCEP::SCONconL()
+ {
+ SCONconCommand* command = new(ELeave) SCONconCommand(iComReadWrite);
+ command->SetPMID(m_PMID.Des());
+ command->SetSMID(m_SMID.Des());
+ command->SetPDU(m_uiMaxPDU);
+ command->Create();
+// IrTranpUtil::HexOut(command->GetData());
+ m_oCommandP->Add(command);
+ }
+
+/*
+* Method description: Called from BFTP when a common BFTP packet should be sent
+*
+*/
+
+void SCEP::SCEPSendCommand(TDes8& a_userData, TUint8 a_pduType)
+ {
+ SRPSCommand* command = new (ELeave) SRPSCommand(iComReadWrite);
+ command->SetPMID(m_PMID.Des());
+ command->SetSMID(m_SMID.Des());
+ command->SetDPID(m_DPID);
+ command->SetSPID(m_SPID);
+ command->SetCmdId(m_CmdId);
+ command->SetPDUType(a_pduType);
+ command->SetUserData(a_userData);
+ command->Create();
+// IrTranpUtil::HexOut(command->GetData());
+ m_oCommandP->Add(command);
+ }
+
+/*
+* Method description: Private method called when a Connection Request packet should be parsed
+*
+* Parameter: a_Header - pointer to the packet buffer
+* Parameter: offset - where in the buffer to start parsing
+*/
+
+void SCEP::SCEPConRequest(TDes8& a_Header, TInt offset)
+ {
+ SCEPPRINT(_L("Inside SCEPConRequest\n"));
+
+ TInt length = a_Header.Length();
+
+ while(offset<length)
+ {
+ if(a_Header[offset] == KTranpInfTypeVer)
+ // case IrTranpUtil::InfTypeVer:
+ {
+ offset+=2;
+ }
+ else if(a_Header[offset] == KTranpInfTypeNeg)
+ {
+ // Negotiation information
+ // TUint8 length = a_Header[offset+1];
+ // TUint8 InfVer = a_Header[offset+2];
+ // TUint8 CFLG = a_Header[offset+3];
+
+ //TPtr8 SMID((unsigned char*)a_Header.Ptr()+offset+4, 8, a_Header.MaxLength());
+ TPtr8 PMID((unsigned char*)a_Header.Ptr()+offset+12, 8, a_Header.MaxLength());
+
+ m_PMID = PMID;
+ // m_SMID = SMID; // We want to keep ours
+
+ NegInf(a_Header, offset+20);
+
+ offset+=(length+2);
+ }
+ else if(a_Header[offset] == KTranpInfTypeExt)
+ {
+ // Ehh .. dunno .. "extend in the future"
+ offset+=4;
+ }
+ else
+ {
+ // Error Not a Valid SCEP connection request...
+ SCEPPRINT(_L("Not a Valid SCEPConRequest\n"));
+ iNotifier->Error(KErrIrtranpPeerDoesNotHaveIrtranp); //KErrIrtranpPeerDoesNotHaveIrtranp
+ break;
+ }
+ }
+ SCEPPRINT(_L("Exiting SCEPConRequest\n"));
+ }
+
+/*
+* Method description: Private method called when a commond Data packet should be parsed
+*
+* Parameter: a_Header - pointer to the packet buffer
+* Parameter: offset - where in the packet to start parsing
+*/
+
+void SCEP::SCEPDataCommand(TDes8& a_Header, TInt offset)
+ {
+ SCEPPRINT(_L("Inside SCEPDataCommand\n"));
+
+ if(a_Header[offset] == KTranpInfTypeUser)
+ {
+ // Always InfTypeUser when in SCEPDataCommand
+ TInt packetLength = a_Header[offset+1];
+ if(packetLength == 0xff)
+ {
+ // since length1 was 0xff, look at length2
+ packetLength = ((a_Header[offset+2] << 8) + (a_Header[offset+3])); // 16bit
+ offset+=4; // include inftype and length2
+ }
+ else
+ {
+ offset+=2; // include inftype and length1
+ }
+
+ // TUint8 InfVer = a_Header[offset];
+ TUint8 DFLG = a_Header[offset+1];
+ // TUint16 length3 = IrTranpUtil::DExtract(a_Header, offset+2);
+
+ if(DFLG == KTranpDFLGrcon)
+ {
+ // Reject to request connection
+ SCEPPRINT(_L("Connection rejected\n"));
+ }
+ else if(DFLG == KTranpDFLGnseg)
+ {
+ // PDU not segmented (single PDU)
+ DoCommand(a_Header, offset+4);
+ // break;
+ }
+ else if(DFLG == KTranpDFLGfPDU)
+ {
+ // First segmented PDU
+ // We do all reassembling in SCEP, and then send the complete (big) packet to bFTP
+ // restno * PDU must be able to hold the complete packet, right?
+
+ // Ownership of this data [m_packet] belongs to the TTranpPicture object
+ // so must ask the correct object to delete its heap.
+ // If we were already building a packet, get rid of it
+ iTranpProtocol->DeleteHeapData();
+
+ TUint32 seqno = IrTranpUtil::LExtract(a_Header, offset+4);
+ TUint32 restno = IrTranpUtil::LExtract(a_Header, offset+8);
+
+ TUint32 PDUSize;
+ switch(m_uiMaxPDU)
+ {
+ case '1':
+ {
+ PDUSize = 512;
+ break;
+ }
+ case '2':
+ {
+ PDUSize = 1024;
+ break;
+ }
+ case '3':
+ {
+ PDUSize = 2048;
+ break;
+ }
+ case '4':
+ {
+ PDUSize = 4096;
+ break;
+ }
+ default:
+ {
+ PDUSize = 512;
+ break;
+ }
+ }
+
+ // This should not leave and report an error back...
+ //__UHEAP_FAILNEXT(1);
+ TRAPD( err , m_packet = HBufC8::NewL(PDUSize*restno)); // should be enough
+ if (err != KErrNone)
+ {
+ iNotifier->Error(err);
+ iState = EError;
+ return;
+ }
+ else
+ iTranpProtocol->SetHeapData(m_packet);
+
+ m_iPicSize = PDUSize*restno;
+
+ SCEPPRINT(_L("ResizeL went well\n"));
+
+ m_seq = seqno;
+ AddSegment(a_Header, offset+12);
+ }
+ else if(DFLG == KTranpDFLGiPDU)
+ {
+ // Intermediate segmented PDUs
+
+ TUint32 seqno = IrTranpUtil::LExtract(a_Header, offset+4);
+ if(seqno == m_seq+1)
+ {
+ AddSegment(a_Header, offset+12);
+ m_seq++;
+ }
+ else
+ {
+ SCEPPRINT(_L("Error in intermediate PDU\n"));
+ }
+ }
+ else if(DFLG == KTranpDFLGlPDU)
+ {
+ // Last segmented PDU
+
+ m_seq++;
+ TUint32 restno = IrTranpUtil::LExtract(a_Header, offset+8);
+ if(restno == 1)
+ {
+ AddSegment(a_Header, offset+12);
+ //TPtr8 packetPtr = m_packet->Des();
+ DoCommand(*m_packet, 0); // Now let's play
+ iNotifier->ProgressIndication(100); // Makes sure 100% is reached
+ iNotifier->GetComplete();
+ TPtr8 temp2 = m_packet->Des();
+ temp2.Zero();
+ }
+ else
+ {
+ SCEPPRINT(_L("Error in last PDU\n"));
+ }
+ }
+ else if(DFLG == KTranpDFLGcint)
+ {
+ SCEPPRINT(_L("Communication interrupted\n"));
+ iState = ECommunicationInt;
+ }
+ else
+ {
+ // Ooops.
+ }
+ }
+ else
+ {
+ // oops
+ }
+
+ SCEPPRINT(_L("Exiting SCEPDataCommand\n"));
+}
+
+/*
+* Method description: Adds segmented packets into a complete packet
+*
+* Parameter: a_Header - pointer to the segment
+* Parameter: a_offset - where in the segment data to be assembled is
+*/
+
+void SCEP::AddSegment(TDes8& a_Header, TInt a_offset)
+ {
+ SCEPPRINT(_L("Entered AddSegment\n"));
+ TPtr8 temp((unsigned char*)a_Header.Ptr()+a_offset, a_Header.Length()-a_offset, a_Header.MaxLength());
+ TPtr8 temp2 = m_packet->Des();
+ temp2.Append(temp);
+ SCEPPRINT(_L("Exited AddSegment\n"));
+ }
+
+ /*
+ * Method description: Private method called to parse an SCEP disconnetion packet
+ *
+ * Parameter: a_Header - pointer to the packet
+ * Parameter: offset - where in the packet to start parsing
+*/
+
+void SCEP::SCEPDisconnect(TDes8& a_Header, TInt offset)
+ {
+ SCEPPRINT(_L("SCEP: SCEPDisconnect\n"));
+ SCEPPRINT_2(_L("SCEP: %d -> EDisconnected\r\n"), iState);
+
+ if(a_Header[offset] == KTranpInfTypeRsn)
+ {
+ TUint16 reason = IrTranpUtil::DExtract(a_Header, offset+2);
+ if(reason == KTranpDisPDUrsnUR)
+ {
+ SCEPPRINT(_L("SCEP: Disconnect: Unspecified Reason\n"));
+ iState = EDisconnected;
+
+ }
+ else if(reason == KTranpDisPDUrsnUD)
+ {
+ SCEPPRINT(_L("SCEP: Disconnect: User Disconnect\n"));
+ iState = EDisconnected;
+
+ }
+ else if(reason == KTranpDisPDUrsnPD)
+ {
+ SCEPPRINT(_L("SCEP: Disconnect: Provider Disconnect\n"));
+ iState = EDisconnected;
+
+ }
+ else
+ {
+ // reserved
+ }
+ }
+ else
+ {
+ // oops
+ }
+ SCEPPRINT(_L("SCEP: Exiting SCEPDisconnect\n"));
+ return;
+ }
+
+/*
+* Method description: Private method called when parsing a Connection Confirmed packet
+*
+* Parameter: a_Header - pointer to the packet
+* Parameter: offset - where in the packet to start parsing
+*/
+
+void SCEP::SCEPConConfirm(TDes8& a_Header, TInt offset)
+ {
+ SCEPPRINT(_L("Inside SCEPConConfirm\n"));
+
+ TInt length = a_Header.Length();
+
+ while(offset<length)
+ {
+ if(a_Header[offset] == KTranpInfTypeVer)
+ {
+ // Should always be 01?
+ offset+=2;
+ }
+ else if(a_Header[offset] == KTranpInfTypeNeg)
+ {
+ // Negotiation information
+ TUint8 length = a_Header[offset+1];
+ // TUint8 InfVer = a_Header[offset+2];
+ // TUint8 CFLG = a_Header[offset+3];
+
+ TPtr8 PMID((unsigned char*)a_Header.Ptr()+offset+4, 8, a_Header.MaxLength());
+ TPtr8 SMID((unsigned char*)a_Header.Ptr()+offset+12, 8, a_Header.MaxLength());
+
+ m_PMID = PMID;
+ m_SMID = SMID;
+
+ NegInf(a_Header, offset+20);
+ offset+=(length+2);
+ }
+ else if(a_Header[offset] == KTranpInfTypeExt)
+ {
+ // "extend in the future"
+
+ SCEPPRINT(_L("InfTypeExt appeared in ConConfirm - error in protocol\n"));
+ // Should not appear in a ConConfirm!
+ offset+=4;
+ }
+ else //default
+ {
+ }
+ } // End of While loop
+ }
+
+/*
+* Method description: Private method called when parsing the Command-section of a packet
+*
+* Parameter: a_Header - pointer to the packet
+* Parameter: a_offset - where in the packet the command is
+*/
+
+void SCEP::DoCommand(const TDesC8& a_Header, TInt a_offset)
+ {
+ SCEPPRINT(_L("SCEP: DoCommand\n"));
+
+ if(a_Header[a_offset] != 0x58) // Always 0x58 at the start of a command
+ {
+ SCEPPRINT(_L("SCEP: Command did not start with 0x58\n"));
+ return;
+ }
+
+ TUint8 switchVar = (TUint8)(a_Header[a_offset+1] & 0xc0); // we only want the two highest bits for PDU type
+ if(switchVar == KTranpPduTypeReq)
+ {
+ // Don't care about the MachineIDs for now
+ SCEPPRINT(_L("SCEP: PduTypeReq\n"));
+
+ m_SPID = IrTranpUtil::DExtract(a_Header, 22 + a_offset);
+ m_DPID = IrTranpUtil::DExtract(a_Header, 24 + a_offset);
+ m_CmdId = IrTranpUtil::DExtract(a_Header,26 + a_offset);
+ // Pass SCEP packet Payload to BFTP layer
+ m_oBFTP->ReqPDU(a_Header, a_offset + 28); // hardcoded, but always 28
+ }
+ else if(switchVar == KTranpPduTypeRplAck)
+ {
+ SCEPPRINT(_L("SCEP: PduTypeRplAck\n"));
+ }
+ else if(switchVar == KTranpPduTypeRplNack)
+ {
+ SCEPPRINT(_L("SCEP: PduTypeRplNack\n"));
+ }
+ else if(switchVar == KTranpPduTypeAbt)
+ {
+ SCEPPRINT(_L("SCEP: PduTypeAbt\n"));
+ }
+ else
+ {
+ SCEPPRINT(_L("SCEP: PduType Broken\n"));
+ }
+
+ SCEPPRINT(_L("SCEP: Exiting DoCommand\n"));
+ }
+
+/*
+* Method description: Private method called to parse the NegInf section of a packet
+*
+* Parameter: a_Header - pointer to the packet
+* Parameter: a_offset - where in the packet the NegInf is
+*/
+
+void SCEP::NegInf(TDes8& a_Header, TInt a_offset)
+ {
+ SCEPPRINT(_L("SCEP: NegInf\n"));
+
+ if(a_Header[a_offset] != KTranpNegVer)
+ {
+ return; // skip the NegInf totally
+ }
+ TInt length = a_Header.Length();
+ while(a_offset<length) // Parse all NegContent attributes
+ {
+ TBuf<8> l(8);
+ l.Num(a_offset);
+ TBuf<8> k(8);
+ k.Num(length);
+
+ TBufC8<4> temp;
+ TPtr8 temp2 = temp.Des();
+ for(TInt j=0;j<3;j++) // we don't like it .. hardcoded
+ {
+ temp2.Append(a_Header[a_offset+1+j]);
+ }
+
+ TInt valueOffset = a_offset+1+temp.Length();
+ if(temp.Compare(KTranpFR) == 0)
+ {
+ SCEPPRINT(_L("SCEP: Found FR attribute\n"));
+ // pump whitespace
+ if(a_Header[valueOffset] == ' ')
+ {
+ valueOffset++;
+ }
+
+ m_uiMaxPDU = a_Header[valueOffset];
+
+ // Now skip CRLF - pump
+ TBool found = FALSE;
+ while(found == FALSE)
+ {
+ if(a_Header[valueOffset] == KTranpLF) // Why look for both CR and LF? LF always follows CR ..
+ {
+ found = TRUE;
+ }
+ else
+ valueOffset++;
+ }
+ }
+ else if(temp.Compare(KTranpID) == 0)
+ {
+ SCEPPRINT(_L("SCEP: Found ID attribute\n"));
+ TBool found = FALSE;
+ TPtr8 temp = m_szPIS.Des();
+ temp.Zero();
+ do
+ {
+ if(a_Header[valueOffset] != KTranpCR)
+ {
+ temp.Append(a_Header[valueOffset++]);
+ }
+ else
+ {
+ found = TRUE;
+ valueOffset+=2; // skip LF too
+ }
+ }
+ while(found == FALSE);
+ }
+ else if(temp.Compare(KTranpNM) == 0)
+ {
+ SCEPPRINT(_L("SCEP: Found NM attribute\n"));
+ TBool found = FALSE;
+ TPtr8 temp = m_szUserName.Des();
+ temp.Zero();
+ do
+ {
+ if(a_Header[valueOffset] != KTranpCR)
+ {
+ temp.Append(a_Header[valueOffset++]);
+ }
+ else
+ {
+ found = TRUE;
+ valueOffset+=2; // skip LF too
+ }
+ }
+ while(found == FALSE);
+ }
+ else if(temp.Compare(KTranpPW) == 0)
+ {
+ SCEPPRINT(_L("SCEP: Found PW attribute\n"));
+ TBool found = FALSE;
+ TPtr8 temp = m_szPassword.Des();
+ temp.Zero();
+ do
+ {
+ if(a_Header[valueOffset] != KTranpCR)
+ {
+ temp.Append(a_Header[valueOffset++]);
+ }
+ else
+ {
+ found = TRUE;
+ valueOffset+=2; // skip LF too
+ }
+ }
+ while(found == FALSE);
+ }
+ else
+ {
+ // Something that wasn't an attribute
+ }
+ a_offset = valueOffset;
+
+ }
+ iState = EConnected;
+ //iNotifier->Connected();
+ SCEPPRINT(_L("SCEP: Exiting NegInf\n"));
+}
+
+//
+// Method description: Private method called when a packet has been received. Here is where the parsing begins.
+// Also creates the necessary reply-commands at SCEP level.
+//
+// Parameter: a_TempBuffer - the packet itself
+//
+
+void SCEP::ParseCommand(TDes8& a_TempBuffer)
+ {
+ SCEPPRINT(_L("SCEP: ParseCommand\n"));
+ // parse the incoming buffer and see what command we're talking about. Return an instance of such a command.
+
+ // Look at the first bytes, see what command it might be, call the correct private method and let it take care of the rest?
+
+ if(a_TempBuffer[1] == KTranpMsgTypeCER)
+ // MsgType = Connection establishment request
+ {
+ SCEPPRINT(_L("SCEP: Got a connection request"));
+ SCEPConRequest(a_TempBuffer, 2);
+
+ // Create and add a SCEPConConfirm!
+ SCONconL();
+ }
+ else if(a_TempBuffer[1] == KTranpMsgTypeCEC)
+ // MsgType = Connection establishment confirmation
+ {
+ SCEPPRINT(_L("SCEP: Got a connect ack"));
+ SCEPConConfirm(a_TempBuffer, 2);
+ }
+ else if(a_TempBuffer[1] == KTranpMsgTypeData)
+ // Data (Command)
+ {
+ SCEPPRINT(_L("SCEP: Got a data packet\n"));
+ SCEPDataCommand(a_TempBuffer, 2);
+ }
+ else if(a_TempBuffer[1] == KTranpMsgTypeDisc)
+ // Disconnection
+ {
+ SCEPPRINT(_L("SCEP: Got a disconnect packet\n"));
+ SCEPDisconnect(a_TempBuffer, 2);
+ if (m_packet != NULL)
+ m_iPicSize = m_packet->Length(); // Otherwise we'll never get to 100%
+ iSCEPFrame.Zero();
+ }
+ else
+ {
+ SCEPPRINT(_L("SCEP: Wacko! Default!\n"));
+ // Reserved
+ }
+
+
+ SCEPPRINT(_L("SCEP: Exiting ParseCommand\n"));
+
+ return;
+ }
+
+//
+// Method description: Sets the Primary Machine ID
+//
+// Parameter: a_PMID - the new Machine ID
+//
+
+void SCEP::SetPMID(const TDesC8& aPMID)
+ {
+ m_PMID = aPMID;
+ }
+
+//
+// Method description: Sets the Secondary Machine ID
+//
+// Parameter: a_SMID - the new Machine ID
+//
+
+void SCEP::SetSMID(const TDesC8& aSMID)
+ {
+ m_SMID = aSMID;
+ }
+
+//
+// Method description: Sets the maximum receivable PDU size
+//
+// Parameter: a_PDU - the new PDU size
+//
+void SCEP::SetPDU(TUint8 a_PDU)
+ {
+ m_uiMaxPDU = a_PDU;
+ }
+