static fz_error *
writeobject(fz_stream *out, pdf_xref *xref, pdf_crypt *encrypt, int oid, int gen)
{
pdf_xrefentry *x = xref->table + oid;
fz_error *error;
error = pdf_cacheobject(xref, oid, gen);
if (error)
return error;
if (encrypt)
pdf_cryptobj(encrypt, x->obj, oid, gen);
fz_print(out, "%d %d obj\n", oid, gen);
fz_printobj(out, x->obj, TIGHT);
fz_print(out, "\n");
if (encrypt)
pdf_cryptobj(encrypt, x->obj, oid, gen);
if (pdf_isstream(xref, oid, gen))
{
error = writestream(out, xref, encrypt, oid, gen);
if (error)
return error;
}
fz_print(out, "endobj\n\n");
return nil;
}
TVerdict CSmsCapsSmsIoctlDeleteSms::doTestStepL()
{
RSocket socket;
TRequestStatus status;
TInt ret=socket.Open(iSocketServer,KSMSAddrFamily,KSockDatagram,KSMSDatagramProtocol);
if(ret!=KErrNone)
User::Leave(ret);
CleanupClosePushL(socket);
TSmsAddr smsaddr;
smsaddr.SetSmsAddrFamily(ESmsAddrRecvAny);
ret=socket.Bind(smsaddr);
if(RProcess().HasCapability(ECapabilityWriteUserData, ECapabilityNetworkServices) && RProcess().HasCapability(ECapabilityReadUserData))
{
TESTL(ret != KErrPermissionDenied);
}
else
{
// skip this one
CleanupStack::PopAndDestroy(&socket);
return TestStepResult() ;
}
// Create message with SRR
_LIT(KText,"This is a simple SMS!");
CSmsMessage* msg=CreateSmsMessageL(KText,TSmsDataCodingScheme::ESmsAlphabet7Bit);
CleanupStack::PushL(msg);
RSmsSocketWriteStream writestream(socket);
writestream << *msg;
writestream.CommitL();
CleanupStack::PopAndDestroy(msg);
socket.Ioctl(KIoctlDeleteSmsMessage, status, NULL, KSolSmsProv);
User::WaitForRequest(status);
if(RProcess().HasCapability(ECapabilityWriteUserData))
{
TEST(status.Int() != KErrPermissionDenied);
}
else
{
TEST(status.Int() == KErrPermissionDenied);
}
CleanupStack::PopAndDestroy(&socket);
return TestStepResult();
}
//
// Called by the obex-layer when some event occurs.
//
void obexsrv_event(obex_t *handle, obex_object_t *object, int mode, int event, int obex_cmd, int obex_rsp)
{
obexsrv_t *srv = OBEX_GetUserData(handle);
//DBPRT("event: %d, cmd: %x, rsp: %x\n", event, obex_cmd, obex_rsp);
switch (event) {
case OBEX_EV_PROGRESS:
//DBPRT("Made some progress...");
break;
case OBEX_EV_ABORT:
BTERROR("Request aborted!");
break;
case OBEX_EV_REQDONE:
obexsrv_reqdone(handle, object, obex_cmd, obex_rsp);
break;
case OBEX_EV_REQHINT:
obexsrv_reqhint(handle, object, obex_cmd);
break;
case OBEX_EV_REQ:
obexsrv_req(handle, object, obex_cmd);
break;
case OBEX_EV_LINKERR:
if (srv->state != SRVSTATE_CLOSED) {
BTERROR("Link broken!");
srv->state = SRVSTATE_CLOSED;
srv->disconnect(srv);
}
srv->serverdone = TRUE;
break;
case OBEX_EV_PARSEERR:
BTERROR("Parse error!");
break;
case OBEX_EV_STREAMEMPTY:
writestream(handle, object);
break;
case OBEX_EV_STREAMAVAIL:
readstream(handle, object);
break;
default:
BTERROR("Unknown event %02x!", event);
break;
}
}
void CScriptEdit::OnSaveasGeneral(int type)
{
char BASED_CODE *szFilter;
CString tmpstr;
CString newname;
int fhandle;
int res;
if(readonly)
{
MessageBox("You opened it read only!","Warning",MB_ICONEXCLAMATION|MB_OK);
return;
}
res=OFN_HIDEREADONLY|OFN_ENABLESIZING|OFN_EXPLORER;
if(type!=-1) m_bcs=type;
szFilter=szFilterb;
if(m_bcs)
{
//szFilter=szFiltera;
tmpstr=bgfolder+"override\\"+itemname;
}
else
{
//szFilter=szFilterb;
tmpstr=makeitemname(".baf",1);
}
CMyFileDialog m_getfiledlg(FALSE, m_bcs?"bcs":"baf", tmpstr, res, szFilter);
m_getfiledlg.m_ofn.nFilterIndex = m_bcs+1;
restart:
if( m_getfiledlg.DoModal() == IDOK )
{
filepath=m_getfiledlg.GetPathName();
filepath.MakeLower();
if(filepath.Right(4)==".baf") m_bcs=0;
else if(filepath.Right(4)==".bcs") m_bcs=1; //this is the default
if(m_bcs)
{
if(filepath.Right(4)!=".bcs") filepath+=".bcs";
lastopenedoverride=filepath.Left(filepath.ReverseFind('\\'));
}
else
{
if(filepath.Right(4)!=".baf") filepath+=".baf";
lastopenedscript=filepath.Left(filepath.ReverseFind('\\'));
}
newname=m_getfiledlg.GetFileName();
newname.MakeUpper();
if(newname.Right(4)==".BCS") newname=newname.Left(newname.GetLength()-4);
else if(newname.Right(4)==".BAF") newname=newname.Left(newname.GetLength()-4);
if(newname.GetLength()>8 || newname.GetLength()<1 || newname.Find(" ",0)!=-1)
{
tmpstr.Format("The resource name '%s' is wrong, it should be 8 characters long and without spaces.",newname);
MessageBox(tmpstr,"Warning",MB_ICONEXCLAMATION|MB_OK);
goto restart;
}
if(newname!=itemname && file_exists(filepath) )
{
res=MessageBox("Do you want to overwrite "+newname+"?","Warning",MB_ICONQUESTION|MB_YESNO);
if(res==IDNO) goto restart;
}
itemname=newname;
res=0;
if(filepath.Right(4)==".bcs")
{
chdir(bgfolder);
tmpstr=bgfolder+weidudecompiled;
assure_dir_exists(tmpstr);
if(!dir_exists(tmpstr) )
{
res=-3;
}
else tmpstr+="\\"+newname+".baf";
}
if(!res)
{
fhandle=creat(tmpstr,S_IWRITE);
if(fhandle>0)
{
//this is the intended way of extracting info from a richedit control
res=writestream(fhandle,m_text_control);
close(fhandle);
}
else res=-2;
if(m_bcs)
{
if(!res) res=compile(tmpstr);
}
}
switch(res)
{
case -3:
newname.Format("Cannot create output path:%s",tmpstr);
MessageBox(tmpstr,"Script editor",MB_ICONSTOP|MB_OK);
break;
case -2:
newname.Format("Cannot create file:%s",tmpstr);
MessageBox(tmpstr,"Script editor",MB_ICONSTOP|MB_OK);
break;
case 0:
if(m_bcs) MessageBox("Script saved and compiled...","Script editor",MB_ICONINFORMATION|MB_OK);
else MessageBox("Script saved...","Script editor",MB_ICONINFORMATION|MB_OK);
break;
default:
MessageBox("Error during save.","Script editor",MB_ICONSTOP|MB_OK);
}
}
UpdateData(UD_DISPLAY);
the_script.m_changed=false;
CheckScript(0);
RefreshDialog();
}
TVerdict CteststreamingStep::doTestStepL()
/**
* @return - TVerdict code
* Override of base class pure virtual
* Our implementation only gets called if the base class doTestStepPreambleL() did
* not leave. That being the case, the current test result value will be EPass.
*/
{
_LIT(KTestEmsMsg8Bit1,"AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA");
TSmsDataCodingScheme::TSmsAlphabet alphabet=TSmsDataCodingScheme::ESmsAlphabet8Bit;
CSmsMessage* smsMessage=CreateSmsMessageL(KTestEmsMsg8Bit1,alphabet);
CleanupStack::PushL(smsMessage);
// format
CEmsFormatIE* object = CEmsFormatIE::NewL();
object->SetStartPosition(10);
object->SetFormatLength(1200);
object->SetBold(ETrue);
CleanupStack::PushL(object);
smsMessage->AddEMSInformationElementL(*object);
CleanupStack::PopAndDestroy(object);
// sounds
CEmsSoundIE* object2 = CEmsSoundIE::NewL(KOasisMelody());
object2->SetStartPosition(52);
CleanupStack::PushL(object2);
smsMessage->AddEMSInformationElementL(*object2);
CleanupStack::PopAndDestroy(object2);
CEmsSoundIE* object2a = CEmsSoundIE::NewL(KBarbieMelody());
object2a->SetStartPosition(52);
CleanupStack::PushL(object2a);
smsMessage->AddEMSInformationElementL(*object2a);
CleanupStack::PopAndDestroy(object2a);
// user prompt
CEmsUserPrompt* prompt = CEmsUserPrompt::NewL(2);
prompt->SetStartPosition(52);
CleanupStack::PushL(prompt);
smsMessage->AddEMSInformationElementL(*prompt);
CleanupStack::PopAndDestroy(prompt);
CEmsPreDefSoundIE* object3 = CEmsPreDefSoundIE::NewL( CEmsPreDefSoundIE::EChordLow);
object3->SetStartPosition(5);
CleanupStack::PushL(object3);
smsMessage->AddEMSInformationElementL(*object3);
CleanupStack::PopAndDestroy(object3);
// object distribution
CEmsObjectDistribution* odi = CEmsObjectDistribution::NewL(3, CEmsObjectDistribution::ENoForward);
odi->SetStartPosition(52);
CleanupStack::PushL(odi);
smsMessage->AddEMSInformationElementL(*odi);
CleanupStack::PopAndDestroy(odi);
// pictures
CFbsBitmap* bitmap=NULL;
CEmsPictureIE* pic=NULL;
FbsStartup();
User::LeaveIfError(RFbsSession::Connect());
bitmap = new (ELeave) CFbsBitmap();
CleanupStack::PushL(bitmap);
TESTL(!LoadBitmap(*bitmap,KPicsMBM,0));
pic = CEmsPictureIE::NewL(*bitmap);
pic->SetStartPosition(5);
CleanupStack::PushL(pic);
smsMessage->AddEMSInformationElementL(*pic);
CleanupStack::PopAndDestroy(pic);
CleanupStack::PopAndDestroy(bitmap);
bitmap = new (ELeave) CFbsBitmap();
CleanupStack::PushL(bitmap);
TESTL(!LoadBitmap(*bitmap,KPicsMBM,1));
pic = CEmsPictureIE::NewL(*bitmap);
pic->SetStartPosition(5);
CleanupStack::PushL(pic);
smsMessage->AddEMSInformationElementL(*pic);
CleanupStack::PopAndDestroy(pic);
CleanupStack::PopAndDestroy(bitmap);
bitmap = new (ELeave) CFbsBitmap();
CleanupStack::PushL(bitmap);
TESTL(!LoadBitmap(*bitmap,KPicsMBM,2));
pic = CEmsPictureIE::NewL(*bitmap);
pic->SetStartPosition(5);
CleanupStack::PushL(pic);
smsMessage->AddEMSInformationElementL(*pic);
CleanupStack::PopAndDestroy(pic);
CleanupStack::PopAndDestroy(bitmap);
RFbsSession::Disconnect();
// animations
CEmsAnimationIE* anim=NULL;
CEmsPreDefAnimationIE* predefanim=NULL;
FbsStartup();
User::LeaveIfError(RFbsSession::Connect());
bitmap = new (ELeave) CFbsBitmap();
CleanupStack::PushL(bitmap);
TESTL(!LoadBitmap(*bitmap,KAnimsMBM,0));
anim = CEmsAnimationIE::NewL(*bitmap);
anim->SetStartPosition(5);
CleanupStack::PushL(anim);
smsMessage->AddEMSInformationElementL(*anim);
CleanupStack::PopAndDestroy(anim);
CleanupStack::PopAndDestroy(bitmap);
bitmap = new (ELeave) CFbsBitmap();
CleanupStack::PushL(bitmap);
TESTL(!LoadBitmap(*bitmap,KAnimsMBM,1));
anim = CEmsAnimationIE::NewL(*bitmap);
anim->SetStartPosition(5);
CleanupStack::PushL(anim);
smsMessage->AddEMSInformationElementL(*anim);
CleanupStack::PopAndDestroy(anim);
CleanupStack::PopAndDestroy(bitmap);
predefanim = CEmsPreDefAnimationIE::NewL(CEmsPreDefAnimationIE::EWinking);
predefanim->SetStartPosition(5);
CleanupStack::PushL(predefanim);
smsMessage->AddEMSInformationElementL(*predefanim);
CleanupStack::PopAndDestroy(predefanim);
RFbsSession::Disconnect();
CSmsMessage* smsMessage2=CreateSmsMessageL(KTestEmsMsg8Bit1,alphabet);
CleanupStack::PushL(smsMessage2);
CBufSeg* aReadBufSeg = CBufSeg::NewL(KSmsMaxEMSLength);
CleanupStack::PushL(aReadBufSeg);
RBufReadStream readstream(*aReadBufSeg);
readstream.Open(*aReadBufSeg,0);
CleanupClosePushL(readstream);
RBufWriteStream writestream(*aReadBufSeg);
writestream.Open(*aReadBufSeg,0);
CleanupClosePushL(writestream);
writestream << *smsMessage;
readstream >> *smsMessage2;
CleanupStack::PopAndDestroy(); // writesream
CleanupStack::PopAndDestroy(); // readsream
//
CleanupStack::PopAndDestroy(aReadBufSeg);
CompareEmsElementsL(*smsMessage,*smsMessage2);
CSmsMessage* smsMessage3=CreateSmsMessageL(KTestEmsMsg8Bit1,alphabet);
CleanupStack::PushL(smsMessage3);
smsMessage2->CopyEmsElementsL(*smsMessage3);
CompareEmsElementsL(*smsMessage3,*smsMessage2);
CleanupStack::PopAndDestroy(smsMessage3);
CleanupStack::PopAndDestroy(smsMessage2);
CleanupStack::PopAndDestroy(smsMessage);
return TestStepResult();
}
void SRamSPI::write(unsigned int address, uint8_t c)
{
writestream(address);
RWdata(c);
closeRWstream();
}
TVerdict CSmsCapsSmsIoctlWriteParamsSms::doTestStepL()
{
RSocket socket;
TRequestStatus status;
TInt ret=socket.Open(iSocketServer,KSMSAddrFamily,KSockDatagram,KSMSDatagramProtocol);
if(ret!=KErrNone)
User::Leave(ret);
CleanupClosePushL(socket);
TSmsAddr smsaddr;
smsaddr.SetSmsAddrFamily(ESmsAddrLocalOperation);
ret=socket.Bind(smsaddr);
if(RProcess().HasCapability(ECapabilityWriteUserData, ECapabilityNetworkServices) && RProcess().HasCapability(ECapabilityReadUserData))
{
TESTL(ret != KErrPermissionDenied);
}
else
{
// skip this one
CleanupStack::PopAndDestroy(&socket);
return TestStepResult();
}
CMobilePhoneSmspList* smspList=CMobilePhoneSmspList::NewL();
CleanupStack::PushL(smspList);
RMobileSmsMessaging::TMobileSmspEntryV1 entryToTsy;
entryToTsy.iText = SMSCAPS_STORE_TEXT1;
entryToTsy.iValidParams = SMSCAPS_STORE_VALID_PARAMS1;
entryToTsy.iDestination.iTypeOfNumber = SMSCAPS_MESSAGE_DESTINATION_TON_0;
entryToTsy.iDestination.iNumberPlan = SMSCAPS_MESSAGE_DESTINATION_NP_0;
entryToTsy.iDestination.iTelNumber = SMSCAPS_MESSAGE_DESTINATION_TEL_NUMBER_0;
entryToTsy.iValidityPeriod = SMSCAPS_STORE_VALIDITY1;
entryToTsy.iServiceCentre.iTypeOfNumber = SMSCAPS_MESSAGE_GSMSERVICECENTRE_TON_1;
entryToTsy.iServiceCentre.iNumberPlan = SMSCAPS_MESSAGE_GSMSERVICECENTRE_NP_1;
entryToTsy.iServiceCentre.iTelNumber = SMSCAPS_MESSAGE_GSMSERVICECENTRE_TEL_NUMBER_1;
entryToTsy.iProtocolId = SMSCAPS_STORE_PID1;
entryToTsy.iDcs = SMSCAPS_STORE_DCS1;
entryToTsy.iIndex = 0;
smspList->AddEntryL(entryToTsy);
RSmsSocketWriteStream writestream(socket);
TRAP(ret,writestream << *smspList);
User::LeaveIfError(ret);
TRAP(ret,writestream.CommitL());
User::LeaveIfError(ret);
socket.Ioctl(KIoctlWriteSmsParams,status,NULL, KSolSmsProv);
User::WaitForRequest(status);
if(RProcess().HasCapability(ECapabilityWriteDeviceData))
{
TEST(status.Int() != KErrPermissionDenied);
}
else
{
TEST(status.Int() == KErrPermissionDenied);
}
CleanupStack::PopAndDestroy(smspList);
CleanupStack::PopAndDestroy(&socket);
return TestStepResult() ;
}
TVerdict CSmsCapsSmsIoctlWriteSms::doTestStepL()
{
TInt ret;
//
// Set TSY to the test case
//
//
TInt testNo=13;
RProperty testNumberProperty;
User::LeaveIfError(testNumberProperty.Attach(KUidPSSimTsyCategory, KPSSimTsyTestNumber));
CleanupClosePushL(testNumberProperty);
TRequestStatus status;
testNumberProperty.Subscribe(status);
User::LeaveIfError(testNumberProperty.Set(KUidPSSimTsyCategory,KPSSimTsyTestNumber,testNo));
User::WaitForRequest(status);
TEST(status.Int() == KErrNone);
TInt testNumberCheck;
User::LeaveIfError(testNumberProperty.Get(testNumberCheck));
if (testNo != testNumberCheck)
User::Leave(KErrNotFound);
CleanupStack::PopAndDestroy(&testNumberProperty);
//
RSocket socket;
ret=socket.Open(iSocketServer,KSMSAddrFamily,KSockDatagram,KSMSDatagramProtocol);
if(ret!=KErrNone)
User::Leave(ret);
CleanupClosePushL(socket);
TSmsAddr smsaddr;
smsaddr.SetSmsAddrFamily(ESmsAddrRecvAny);
ret=socket.Bind(smsaddr);
if(RProcess().HasCapability(ECapabilityWriteUserData, ECapabilityNetworkServices) && RProcess().HasCapability(ECapabilityReadUserData))
{
TESTL(ret != KErrPermissionDenied);
}
else
{
// skip this one
CleanupStack::PopAndDestroy(&socket);
return TestStepResult() ;
}
// Create message with SRR
_LIT(KText,"This is a simple SMS!");
CSmsMessage* msg=CreateSmsMessageL(KText,TSmsDataCodingScheme::ESmsAlphabet7Bit);
CleanupStack::PushL(msg);
// Send message
RSmsSocketWriteStream writestream(socket);
TRAP(ret,writestream << *msg);
User::LeaveIfError(ret);
TRAP(ret,writestream.CommitL());
User::LeaveIfError(ret);
socket.Ioctl(KIoctlWriteSmsMessage,status,NULL, KSolSmsProv);
User::WaitForRequest(status);
if(RProcess().HasCapability(ECapabilityWriteUserData))
{
TEST(status.Int() != KErrPermissionDenied);
}
else
{
TEST(status.Int() == KErrPermissionDenied);
}
CleanupStack::PopAndDestroy(msg);
CleanupStack::PopAndDestroy(&socket);
return TestStepResult() ;
}
int
main(int argc, char* argv[])
{
if (argc != 3) {
std::cerr << "Usage: " + std::string(argv[0]) + " SERVER-HOST-OR-IP PORT-NUMBER" << std::endl;
exit(EXIT_FAILURE);
}
/*Create a socket*/
int sockfd;
if ((sockfd = socket(AF_INET, SOCK_DGRAM, 0)) < 0) {
std::cerr << "Error: could not bind to socket" << std::endl;
exit(EXIT_FAILURE);
}
/*Resolve a host name*/
struct hostent *hp;
hp = gethostbyname(argv[1]);
if (!hp) {
std::cerr << "Error: could not obtain address of host " + std::string(argv[1]) << std::endl;
exit(EXIT_FAILURE);
}
/*Set up parameters of the serverAddress*/
struct sockaddr_in serverAddress;
socklen_t addressLength = sizeof(serverAddress);
memset((char *)&serverAddress, 0, sizeof(serverAddress));
serverAddress.sin_family = AF_INET;
serverAddress.sin_port = htons(std::atoi(argv[2]));
memcpy((void *)&serverAddress.sin_addr, hp->h_addr_list[0], hp->h_length);
/*Open file for writing*/
std::ofstream writestream("received.data", std::ios::in | std::ios::trunc | std::ios::binary);
/*Basic initializations*/
char buf[BUFSIZE]; //initiailize temporary buffer for storing data
uint16_t currSeqNum = rand() % MAXSEQNUM; //initialize random sequence number
uint16_t currAckNum = 0;
uint16_t expectedSeqNum = 0;
int bytesReceived;
fsmstate curr_state = HANDSHAKE;
Packet syn_packet;
int syn_tries = 0;
bool syn_acked = false;
Packet fin_packet;
while(1) {
if(curr_state == HANDSHAKE) {
/*Set initial SYN TCPHeader*/
syn_packet.setHeaderFields(currSeqNum, currAckNum, RECEIVEWINSIZE, false, true, false);
clock_gettime(CLOCK_MONOTONIC, &syn_packet.m_time);
sendto(sockfd, (void *)&syn_packet.m_header, sizeof(struct TCPHeader), 0, (struct sockaddr *)&serverAddress, addressLength);
syn_packet.printSYNSend(false);
syn_tries++;
curr_state = TRANSFER;
continue;
}
//check for syn-packet expiration
if (syn_acked == false) {
struct timespec now;
clock_gettime(CLOCK_MONOTONIC, &now);
if (syn_packet.hasExpired(now, TIMEOUT)) {
// if (syn_tries > 2) {
// fprintf(stderr, "Could not connect to server in 3 tries. Exiting.\n");
// break;
// }
sendto(sockfd, (void *)&syn_packet.m_header, sizeof(struct TCPHeader), 0, (struct sockaddr *)&serverAddress, addressLength);
syn_packet.printSYNSend(true);
clock_gettime(CLOCK_MONOTONIC, &syn_packet.m_time);
syn_tries++;
}
}
//check for fin-ack packet expiration
if (curr_state == TEARDOWN) {
struct timespec now;
clock_gettime(CLOCK_MONOTONIC, &now);
if(fin_packet.hasExpired(now, TIMEOUT)) {
clock_gettime(CLOCK_MONOTONIC, &fin_packet.m_time);
sendto(sockfd, (void *)&fin_packet.m_header, sizeof(struct TCPHeader), 0, (struct sockaddr *)&serverAddress, addressLength);
fin_packet.printAckSend(true, false, true);
}
}
bytesReceived = recvfrom(sockfd, buf, BUFSIZE, MSG_DONTWAIT, (struct sockaddr *)&serverAddress, &addressLength);
if (bytesReceived < (int) sizeof(struct TCPHeader)) {
//std::cerr << "Problem with received packet or didn't receive anything yet." << std::endl;
continue;
}
Packet received_packet(buf, bytesReceived);
if (curr_state == TRANSFER) {
/*if SYN-ACK packet was received*/
if (received_packet.isSYNACK()) {
received_packet.printSeqReceive();
//fprintf(stderr, "Received a SYN-ACK.\n");
currSeqNum = received_packet.getAckNumber();
currAckNum = received_packet.getSeqNumber() + 1; //consume the SYN-ACK
expectedSeqNum = currAckNum;
/*Send ACK back to begin the process of transfer*/
Packet ack_packet;
ack_packet.setHeaderFields(currSeqNum, currAckNum, RECEIVEWINSIZE, true, false, false);
sendto(sockfd, (void *)&ack_packet.m_header, sizeof(struct TCPHeader), 0, (struct sockaddr *)&serverAddress, addressLength);
ack_packet.printAckSend(false, false, false);
syn_acked = true;
}
/*if data packet, i.e. ASF = 000, send ACK back*/
else if (received_packet.isDATA()) {
received_packet.printSeqReceive();
if (received_packet.getSeqNumber() == expectedSeqNum) {
int payloadSize = bytesReceived - sizeof(struct TCPHeader);
//fprintf(stderr, "Payload Size = %d\n", payloadSize);
// for (int i = 0; i < payloadSize; i++) {
// fprintf(stderr, "%c",received_packet.data[i]);
// }
// fprintf(stderr, "\n");
writestream.write(received_packet.data, payloadSize);
writestream.flush();
currAckNum = received_packet.getSeqNumber() + payloadSize;
if(currAckNum > MAXSEQNUM) {
currAckNum -= MAXSEQNUM;
//fprintf(stderr, "set it to %u\n", currAckNum);
}
expectedSeqNum = currAckNum;
}
/* currAckNum will still be our expected AckNumber */
Packet delivery_packet;
delivery_packet.setHeaderFields(currSeqNum, currAckNum, RECEIVEWINSIZE, true, false, false);
sendto(sockfd, (void *)&delivery_packet.m_header, sizeof(struct TCPHeader), 0, (struct sockaddr *)&serverAddress, addressLength);
delivery_packet.printAckSend(false, false, false);
}
/*if FIN packet from server, send FIN-ACK back and transition to teardown phase*/
else if (received_packet.isFIN()) {
received_packet.printSeqReceive();
//fprintf(stderr, "Received FIN.\n");
currAckNum++;
fin_packet.setHeaderFields(currSeqNum, currAckNum, RECEIVEWINSIZE, true, false, true);
clock_gettime(CLOCK_MONOTONIC, &fin_packet.m_time);
sendto(sockfd, (void *)&fin_packet.m_header, sizeof(struct TCPHeader), 0, (struct sockaddr *)&serverAddress, addressLength);
fin_packet.printAckSend(false, false, true);
curr_state = TEARDOWN;
continue;
}
}
if (curr_state == TEARDOWN) {
/*if ACK from server, we are done*/
if (received_packet.isACK()) {
//received_packet.printSeqReceive();
//std::cerr << "Received ACK, terminating client." << std::endl;
break;
}
}
}
writestream.close();
close(sockfd);
}
