SCTPServer Class Reference

#include <SCTPServer.h>

List of all members.

Public Member Functions

 ~SCTPServer ()
void initialize ()
void handleMessage (cMessage *msg)
void finish ()
void handleTimer (cMessage *msg)
void generateAndSend ()

Protected Types

typedef std::map< int32,
ServerAssocStat
ServerAssocStatMap
typedef std::map< int32,
cOutVector * > 
BytesPerAssoc
typedef std::map< int32,
cDoubleHistogram * > 
HistEndToEndDelay
typedef std::map< int32,
cOutVector * > 
EndToEndDelay

Protected Member Functions

void sendOrSchedule (cPacket *msg)
cPacket * makeAbortNotification (cPacket *msg)
cPacket * makeReceiveRequest (cPacket *msg)
cPacket * makeDefaultReceive ()

Protected Attributes

int32 notifications
int32 assocId
SCTPSocketsocket
double delay
double echoFactor
double delayFirstRead
bool readInt
bool schedule
bool firstData
cPar * delT
bool shutdownReceived
uint64 bytesSent
uint64 packetsSent
uint64 packetsRcvd
int32 numSessions
uint64 numRequestsToSend
bool ordered
bool abortSent
int32 queueSize
int32 count
cMessage * timeoutMsg
cMessage * delayTimer
cMessage * delayFirstReadTimer
cPacket * abort
int32 outboundStreams
int32 lastStream
ServerAssocStatMap serverAssocStatMap
BytesPerAssoc bytesPerAssoc
HistEndToEndDelay histEndToEndDelay
EndToEndDelay endToEndDelay
int32 ssn

Classes

struct  pathStatus
struct  ServerAssocStat


Member Typedef Documentation

typedef std::map<int32,ServerAssocStat> SCTPServer::ServerAssocStatMap [protected]

typedef std::map<int32,cOutVector*> SCTPServer::BytesPerAssoc [protected]

typedef std::map<int32,cDoubleHistogram*> SCTPServer::HistEndToEndDelay [protected]

typedef std::map<int32,cOutVector*> SCTPServer::EndToEndDelay [protected]


Constructor & Destructor Documentation

SCTPServer::~SCTPServer (  )  [inline]

00078 {};


Member Function Documentation

void SCTPServer::sendOrSchedule ( cPacket *  msg  )  [protected]

Referenced by generateAndSend(), handleMessage(), and handleTimer().

00089 {
00090         if (delay==0)
00091         {
00092                 send(msg, "sctpOut");
00093         }
00094         else
00095         {
00096                 scheduleAt(simulation.getSimTime()+delay, msg);
00097         }
00098 }

cPacket * SCTPServer::makeAbortNotification ( cPacket *  msg  )  [protected]

Referenced by handleMessage().

00161 {
00162         SCTPCommand *ind = check_and_cast<SCTPCommand *>(msg->getControlInfo()->dup());
00163         cPacket* cmsg = new cPacket("AbortNotification");
00164         SCTPSendCommand *cmd = new SCTPSendCommand("Send4");
00165         assocId = ind->getAssocId();
00166         cmd->setAssocId(assocId);
00167         cmd->setSid(ind->getSid());
00168         cmd->setNumMsgs(ind->getNumMsgs());
00169         cmsg->setControlInfo(cmd);
00170         delete ind;
00171         //delete msg;
00172         cmsg->setKind(SCTP_C_ABORT);
00173         return cmsg;
00174 }

cPacket * SCTPServer::makeReceiveRequest ( cPacket *  msg  )  [protected]

Referenced by handleMessage().

00135 {
00136         SCTPCommand *ind = check_and_cast<SCTPCommand *>(msg->removeControlInfo());
00137         cPacket* cmsg = new cPacket("ReceiveRequest");
00138         SCTPSendCommand *cmd = new SCTPSendCommand("Send2");
00139         cmd->setAssocId(ind->getAssocId());
00140         cmd->setSid(ind->getSid());
00141         cmd->setNumMsgs(ind->getNumMsgs());
00142         cmsg->setKind(SCTP_C_RECEIVE);
00143         cmsg->setControlInfo(cmd);
00144         delete ind;
00145         return cmsg;
00146 }

cPacket * SCTPServer::makeDefaultReceive (  )  [protected]

Referenced by handleTimer().

00149 {
00150         cPacket* cmsg = new cPacket("DefaultReceive");
00151         SCTPSendCommand *cmd = new SCTPSendCommand("Send3");
00152         cmd->setAssocId(assocId);
00153         cmd->setSid(0);
00154         cmd->setNumMsgs(1);
00155         cmsg->setKind(SCTP_C_RECEIVE);
00156         cmsg->setControlInfo(cmd);
00157         return cmsg;
00158 }

void SCTPServer::initialize (  ) 

00034 {
00035         char * token;
00036         AddressVector addresses;
00037         sctpEV3<<"initialize SCTP Server\n";
00038         numSessions = packetsSent = packetsRcvd = bytesSent = notifications = 0;
00039         WATCH(numSessions);
00040         WATCH(packetsSent);
00041         WATCH(packetsRcvd);
00042         WATCH(bytesSent);
00043         WATCH(numRequestsToSend);
00044         // parameters
00045         const char* address = par("address");
00046         token = strtok((char*)address,",");
00047         while (token != NULL)
00048         {
00049                 addresses.push_back(IPvXAddress(token));
00050                 token = strtok(NULL, ",");
00051         }
00052         int32 port = par("port");
00053         echoFactor = par("echoFactor");
00054         delay = par("echoDelay");
00055         delayFirstRead = par("delayFirstRead");
00056         delT = &par("readingInterval");
00057         if (delT->isNumeric() && (double)*delT==0)
00058                 readInt=false;
00059         else
00060                 readInt=true;
00061         int32 messagesToPush = par("messagesToPush");
00062         outboundStreams = par("outboundStreams");
00063         ordered = (bool)par("ordered");
00064         queueSize = par("queueSize");
00065         lastStream = 0;
00066         abort = NULL;
00067         abortSent = false;
00068         timeoutMsg = new cMessage("SrvAppTimer");
00069         delayTimer = new cMessage("delayTimer");
00070         delayTimer->setContextPointer(this);
00071         delayFirstReadTimer = new cMessage("delayFirstReadTimer");
00072         firstData = true;
00073         SCTPSocket *socket = new SCTPSocket();
00074         socket->setOutputGate(gate("sctpOut"));
00075         socket->setOutboundStreams(outboundStreams);
00076         if (strcmp(address,"")==0)
00077                 socket->bind(port);
00078         else
00079         {
00080                 socket->bindx(addresses, port);
00081         }
00082         socket->listen(true, par("numPacketsToSendPerClient"), messagesToPush);
00083         sctpEV3<<"SCTPServer::initialized listen port="<<port<<"\n";
00084         schedule = false;
00085         shutdownReceived = false;
00086 }

void SCTPServer::handleMessage ( cMessage *  msg  ) 

00177 {
00178         int32 id;
00179         cPacket* cmsg;
00180 
00181         if (msg->isSelfMessage())
00182         {
00183 
00184                 handleTimer(msg);
00185         }
00186         else
00187         {
00188                 switch (msg->getKind())
00189                 {
00190                         case SCTP_I_PEER_CLOSED:
00191                         case SCTP_I_ABORT:
00192                         {
00193                                 sctpEV3<<"peer closed or abort\n";
00194                                 abort = makeAbortNotification(PK(msg));
00195                                 if ((long) par("numPacketsToReceivePerClient")==0)
00196                                 {
00197                                         sendOrSchedule(abort);
00198                                         abortSent = true;
00199                                 }
00200                                 else
00201                                 {
00202                                         if (serverAssocStatMap[assocId].rcvdPackets==(unsigned long) par("numPacketsToReceivePerClient"))
00203                                         {
00204                                                 sendOrSchedule(abort);
00205                                                 abortSent = true;
00206                                         }
00207                                 }
00208                                 if (delayTimer->isScheduled())
00209                                         cancelEvent(delayTimer);
00210                                 if (delayFirstReadTimer->isScheduled())
00211                                         cancelEvent(delayFirstReadTimer);
00212 
00213                                 delete msg;
00214                                 break;
00215                         }
00216                         case SCTP_I_ESTABLISHED:
00217                         {
00218                                 count=0;
00219                                 SCTPConnectInfo *connectInfo = dynamic_cast<SCTPConnectInfo *>(msg->removeControlInfo());
00220                                 numSessions++;
00221                                 assocId = connectInfo->getAssocId();
00222                                 outboundStreams = connectInfo->getOutboundStreams();
00223                                 serverAssocStatMap[assocId].rcvdPackets= (long) par("numPacketsToReceivePerClient");
00224                                 serverAssocStatMap[assocId].sentPackets= (long) par("numPacketsToSendPerClient");
00225                                 serverAssocStatMap[assocId].rcvdBytes=0;
00226                                 serverAssocStatMap[assocId].start=0;
00227                                 serverAssocStatMap[assocId].stop=0;
00228                                 serverAssocStatMap[assocId].lifeTime=0;
00229                                 char text[30];
00230                                 sprintf(text, "App: Received Bytes of assoc %d",assocId);
00231                                 bytesPerAssoc[assocId] = new cOutVector(text);
00232                                 sprintf(text, "App: EndToEndDelay of assoc %d",assocId);
00233                                 endToEndDelay[assocId] = new cOutVector(text);
00234 
00235                                 delete connectInfo;
00236                                 delete msg;
00237                                 if ((long) par("numPacketsToSendPerClient") > 0)
00238                                 {
00239                                         ServerAssocStatMap::iterator i = serverAssocStatMap.find(assocId);
00240                                         numRequestsToSend = i->second.sentPackets;
00241                                         if ((simtime_t)par("thinkTime") > 0)
00242                                         {
00243                                                 generateAndSend();
00244                                                 timeoutMsg->setKind(SCTP_C_SEND);
00245                                                 scheduleAt(simulation.getSimTime()+(simtime_t)par("thinkTime"), timeoutMsg);
00246                                                 numRequestsToSend--;
00247                                                 i->second.sentPackets = numRequestsToSend;
00248                                         }
00249                                         else
00250                                         {
00251                                                 if (queueSize==0)
00252                                                 {
00253                                                         while (numRequestsToSend > 0)
00254                                                         {
00255                                                                 generateAndSend();
00256                                                                 numRequestsToSend--;
00257                                                                 i->second.sentPackets = numRequestsToSend;
00258                                                         }
00259                                                 }
00260                                                 else if (queueSize>0)
00261                                                 {
00262                                                         while (numRequestsToSend > 0 && count++ < queueSize*2)
00263                                                         {
00264                                                                 generateAndSend();
00265                                                                 numRequestsToSend--;
00266                                                                 i->second.sentPackets = numRequestsToSend;
00267                                                         }
00268 
00269                                                         cPacket* cmsg = new cPacket("Queue");
00270                                                         SCTPInfo* qinfo = new SCTPInfo("Info1");
00271                                                         qinfo->setText(queueSize);
00272                                                         cmsg->setKind(SCTP_C_QUEUE);
00273                                                         qinfo->setAssocId(id);
00274                                                         cmsg->setControlInfo(qinfo);
00275                                                         sendOrSchedule(cmsg);
00276                                                 }
00277                                                 ServerAssocStatMap::iterator j=serverAssocStatMap.find(assocId);
00278                                                 if (j->second.rcvdPackets == 0 && (simtime_t)par("waitToClose")>0)
00279                                                 {
00280                                                         char as[5];
00281                                                         sprintf(as, "%d",assocId);
00282                                                         cPacket* abortMsg = new cPacket(as);
00283                                                         abortMsg->setKind(SCTP_I_ABORT);
00284                                                         scheduleAt(simulation.getSimTime()+(simtime_t)par("waitToClose"), abortMsg);
00285                                                 }
00286                                                 else
00287                                                 {
00288                                                         sctpEV3<<"no more packets to send, call shutdown for assoc "<<assocId<<"\n";
00289                                                         cPacket* cmsg = new cPacket("ShutdownRequest");
00290                                                         SCTPCommand* cmd = new SCTPCommand("Send5");
00291                                                         cmsg->setKind(SCTP_C_SHUTDOWN);
00292                                                         cmd->setAssocId(assocId);
00293                                                         cmsg->setControlInfo(cmd);
00294                                                         sendOrSchedule(cmsg);
00295                                                 }
00296                                         }
00297                                 }
00298                                 break;
00299                         }
00300                         case SCTP_I_DATA_NOTIFICATION:
00301                         {
00302                                 notifications++;
00303 
00304 
00305                                 if (schedule==false)
00306                                 {
00307                                         if (delayFirstRead>0 && !delayFirstReadTimer->isScheduled())
00308                                         {
00309 
00310                                                 cmsg=makeReceiveRequest(PK(msg));
00311                                                 scheduleAt(simulation.getSimTime()+delayFirstRead, cmsg);
00312                                                 scheduleAt(simulation.getSimTime()+delayFirstRead, delayFirstReadTimer);
00313                                         }
00314                                         else if (readInt && firstData)
00315                                         {
00316                                                 firstData=false;
00317                                                 cmsg=makeReceiveRequest(PK(msg));
00318                                                 scheduleAt(simulation.getSimTime()+(simtime_t)*delT, delayTimer);
00319                                                 sendOrSchedule(cmsg);
00320                                         }
00321                                         else if (delayFirstRead==0 && readInt==false)
00322                                         {
00323                                                 cmsg=makeReceiveRequest(PK(msg));
00324                                                 sendOrSchedule(cmsg);
00325                                         }
00326 
00327                                 }
00328                                 else
00329                                 {
00330                                         sctpEV3<<simulation.getSimTime()<<" makeReceiveRequest\n";
00331                                         cmsg=makeReceiveRequest(PK(msg));
00332                                         sendOrSchedule(cmsg);
00333                                 }
00334                                 delete msg;
00335                                 break;
00336                         }
00337                         case SCTP_I_DATA:
00338                         {
00339                                 notifications--;
00340                                 packetsRcvd++;
00341                                 sctpEV3<<simulation.getSimTime()<<" server: data arrived. "<<packetsRcvd<<" Packets received now\n";
00342                                 SCTPCommand *ind = check_and_cast<SCTPCommand *>(msg->removeControlInfo());
00343                                 id = ind->getAssocId();
00344                                 ServerAssocStatMap::iterator j=serverAssocStatMap.find(id);
00345                                 BytesPerAssoc::iterator k=bytesPerAssoc.find(id);
00346                                 if (j->second.rcvdBytes == 0)
00347                                         j->second.start = simulation.getSimTime();
00348                                 j->second.rcvdBytes+= PK(msg)->getByteLength();
00349                                 k->second->record(j->second.rcvdBytes);
00350 
00351                                 if (echoFactor==0)
00352                                 {
00353                                         if ((uint32)par("numPacketsToReceivePerClient")>0)
00354                                         {
00355                                                 j->second.rcvdPackets--;
00356                                                 SCTPSimpleMessage *smsg=check_and_cast<SCTPSimpleMessage*>(msg);
00357                                                 EndToEndDelay::iterator m=endToEndDelay.find(id);
00358                                                 m->second->record(simulation.getSimTime()-smsg->getCreationTime());
00359                                                 sctpEV3<<"server: Data received. Left packets to receive="<<j->second.rcvdPackets<<"\n";
00360 
00361                                                 if (j->second.rcvdPackets == 0)
00362                                                 {
00363                                                         if (abort != NULL)
00364                                                         {
00365                                                                 sendOrSchedule(abort);
00366                                                                 abortSent = true;
00367                                                         }
00368                                                         else
00369                                                         {
00370                                                                 cPacket* cmsg = new cPacket("Request");
00371                                                                 SCTPInfo* qinfo = new SCTPInfo("Info2");
00372                                                                 cmsg->setKind(SCTP_C_NO_OUTSTANDING);
00373                                                                 qinfo->setAssocId(id);
00374                                                                 cmsg->setControlInfo(qinfo);
00375                                                                 sendOrSchedule(cmsg);
00376                                                         }
00377                                                         j->second.stop = simulation.getSimTime();
00378                                                         j->second.lifeTime = j->second.stop - j->second.start;
00379                                                 }
00380                                         }
00381                                         delete msg;
00382                                 }
00383                                 else
00384                                 {
00385                                         SCTPSendCommand *cmd = new SCTPSendCommand("Send6");
00386                                         cmd->setAssocId(id);
00387                                         SCTPSimpleMessage *smsg=check_and_cast<SCTPSimpleMessage*>(msg->dup());
00388                                         EndToEndDelay::iterator n=endToEndDelay.find(id);
00389                                         n->second->record(simulation.getSimTime()-smsg->getCreationTime());
00390                                         cPacket* cmsg = new cPacket("SVData");
00391                                         bytesSent+=smsg->getBitLength()/8;
00392                                         cmd->setSendUnordered(cmd->getSendUnordered());
00393                                         lastStream=(lastStream+1)%outboundStreams;
00394                                         cmd->setSid(lastStream);
00395                                         cmd->setLast(true);
00396                                         cmsg->encapsulate(smsg);
00397                                         cmsg->setKind(SCTP_C_SEND);
00398                                         cmsg->setControlInfo(cmd);
00399                                         packetsSent++;
00400                                         delete msg;
00401                                         sendOrSchedule(cmsg);
00402                                 }
00403                                 delete ind;
00404                                 break;
00405                         }
00406                         case SCTP_I_SHUTDOWN_RECEIVED:
00407                         {
00408                                 SCTPCommand *command = check_and_cast<SCTPCommand *>(msg->removeControlInfo());
00409                                 id = command->getAssocId();
00410                                 sctpEV3<<"server: SCTP_I_SHUTDOWN_RECEIVED for assoc "<<id<<"\n";
00411                                 ServerAssocStatMap::iterator i=serverAssocStatMap.find(id);
00412                                 if (i->second.sentPackets == 0 || (long) par("numPacketsToSendPerClient")==0)
00413                                 {
00414                                         cPacket* cmsg = new cPacket("Request");
00415                                         SCTPInfo* qinfo = new SCTPInfo("Info3");
00416                                         cmsg->setKind(SCTP_C_NO_OUTSTANDING);
00417                                         qinfo->setAssocId(id);
00418                                         cmsg->setControlInfo(qinfo);
00419                                         sendOrSchedule(cmsg);
00420                                         i->second.stop = simulation.getSimTime();
00421                                         i->second.lifeTime = i->second.stop - i->second.start;
00422                                 }
00423                                 delete command;
00424                                 shutdownReceived = true;
00425                                 delete msg;
00426                                 break;
00427                         }
00428                         case SCTP_I_CLOSED:
00429                                 if (delayTimer->isScheduled())
00430                                         cancelEvent(delayTimer);
00431                                 delete msg;
00432                         break;
00433                         default: delete msg;
00434                 }
00435         }
00436 }

void SCTPServer::finish (  ) 

00502 {
00503         delete timeoutMsg;
00504         if (delayTimer->isScheduled())
00505                 cancelEvent(delayTimer);
00506         delete delayTimer;
00507         delete delayFirstReadTimer;
00508 
00509         if (abort!= NULL && !abortSent)
00510         {
00511                 delete abort;
00512         }
00513 
00514                 ev << getFullPath() << ": opened " << numSessions << " sessions\n";
00515         ev << getFullPath() << ": sent " << bytesSent << " bytes in " << packetsSent << " packets\n";
00516         for (ServerAssocStatMap::iterator l=serverAssocStatMap.begin(); l!=serverAssocStatMap.end(); l++)
00517         {
00518                 ev << getFullPath() << " Assoc: "<<l->first<<"\n";
00519                 ev << "\tstart time: "<<l->second.start <<"\n";
00520                 ev << "\tstop time: "<<l->second.stop <<"\n";
00521                 ev << "\tlife time: "<<l->second.lifeTime <<"\n";
00522                 ev << "\treceived bytes:" << l->second.rcvdBytes << "\n";
00523                 ev << "\tthroughput: "<<(l->second.rcvdBytes / l->second.lifeTime.dbl())*8 <<" bit/sec\n";
00524                 recordScalar("bytes rcvd", l->second.rcvdBytes);
00525 
00526         }
00527         ev << getFullPath() << "Over all " << packetsRcvd << " packets received\n ";
00528         ev << getFullPath() << "Over all " << notifications << " notifications received\n ";
00529 
00530         BytesPerAssoc::iterator j;
00531         while ((j = bytesPerAssoc.begin())!= bytesPerAssoc.end())
00532         {
00533                 delete j->second;
00534                 bytesPerAssoc.erase(j);
00535         }
00536         EndToEndDelay::iterator k;
00537         while ((k = endToEndDelay.begin())!= endToEndDelay.end())
00538         {
00539                 delete k->second;
00540                 endToEndDelay.erase(k);
00541         }
00542         serverAssocStatMap.clear();
00543         sctpEV3<<"Server finished\n";
00544 }

void SCTPServer::handleTimer ( cMessage *  msg  ) 

Referenced by handleMessage().

00439 {
00440         cPacket* cmsg;
00441         SCTPCommand* cmd;
00442         int32 id;
00443 
00444         if (msg==delayTimer)
00445         {
00446                 ServerAssocStatMap::iterator i=serverAssocStatMap.find(assocId);
00447                 sctpEV3<<simulation.getSimTime()<<" delayTimer expired\n";
00448                 sendOrSchedule(makeDefaultReceive());
00449                 scheduleAt(simulation.getSimTime()+(double)*delT, delayTimer);
00450                 return;
00451         }
00452         else if (msg==delayFirstReadTimer)
00453         {
00454                 delayFirstRead = 0;
00455 
00456                 if (readInt && !delayTimer->isScheduled())
00457                 {
00458                         scheduleAt(simulation.getSimTime()+(simtime_t)*delT, delayTimer);
00459                         scheduleAt(simulation.getSimTime()+(simtime_t)*delT, makeDefaultReceive());
00460                 }
00461                 return;
00462         }
00463 
00464         switch (msg->getKind())
00465         {
00466         case SCTP_C_SEND:
00467                 if (numRequestsToSend>0)
00468                 {
00469                         generateAndSend();
00470                         if ((simtime_t)par("thinkTime") > 0)
00471                                 scheduleAt(simulation.getSimTime()+(simtime_t)par("thinkTime"), timeoutMsg);
00472                         numRequestsToSend--;
00473                 }
00474                 break;
00475         case SCTP_I_ABORT:
00476 
00477                 cmsg = new cPacket("CLOSE", SCTP_C_CLOSE);
00478                 cmd = new SCTPCommand("Send6");
00479                 id = atoi(msg->getName());
00480                 cmd->setAssocId(id);
00481                 cmsg->setControlInfo(cmd);
00482                 sendOrSchedule(cmsg);
00483                 break;
00484         case SCTP_C_RECEIVE:
00485 
00486                 sctpEV3<<simulation.getSimTime()<<" SCTPServer:SCTP_C_RECEIVE\n";
00487                 if (readInt || delayFirstRead > 0)
00488                         schedule = false;
00489                 else
00490                         schedule = true;
00491                 sendOrSchedule(PK(msg));
00492                 break;
00493         default:
00494 
00495                 sctpEV3<<"MsgKind ="<<msg->getKind()<<" unknown\n";
00496 
00497                 break;
00498         }
00499 }

void SCTPServer::generateAndSend (  ) 

Referenced by handleMessage(), and handleTimer().

00101 {
00102 uint32 numBytes;
00103 
00104         cPacket* cmsg = new cPacket("CMSG");
00105         SCTPSimpleMessage* msg=new SCTPSimpleMessage("Server");
00106         numBytes=(uint32)par("requestLength");
00107         msg->setDataArraySize(numBytes);
00108         for (uint32 i=0; i<numBytes; i++)
00109         {
00110                 msg->setData(i, 's');
00111         }
00112         msg->setDataLen(numBytes);
00113         msg->setBitLength(numBytes * 8);
00114         cmsg->encapsulate(msg);
00115         SCTPSendCommand *cmd = new SCTPSendCommand("Send1");
00116         cmd->setAssocId(assocId);
00117         if (ordered)
00118                 cmd->setSendUnordered(COMPLETE_MESG_ORDERED);
00119         else
00120                 cmd->setSendUnordered(COMPLETE_MESG_UNORDERED);
00121         lastStream=(lastStream+1)%outboundStreams;
00122         cmd->setSid(lastStream);
00123         if (queueSize>0 && numRequestsToSend > 0 && count < queueSize*2)
00124                 cmd->setLast(false);
00125         else
00126                 cmd->setLast(true);
00127         cmsg->setKind(SCTP_C_SEND);
00128         cmsg->setControlInfo(cmd);
00129         packetsSent++;
00130         bytesSent+=msg->getBitLength()/8;
00131         sendOrSchedule(cmsg);
00132 }


Member Data Documentation

int32 SCTPServer::notifications [protected]

Referenced by finish(), handleMessage(), and initialize().

int32 SCTPServer::assocId [protected]

Referenced by initialize().

double SCTPServer::delay [protected]

Referenced by initialize(), and sendOrSchedule().

double SCTPServer::echoFactor [protected]

Referenced by handleMessage(), and initialize().

double SCTPServer::delayFirstRead [protected]

bool SCTPServer::readInt [protected]

bool SCTPServer::schedule [protected]

bool SCTPServer::firstData [protected]

Referenced by handleMessage(), and initialize().

cPar* SCTPServer::delT [protected]

bool SCTPServer::shutdownReceived [protected]

Referenced by handleMessage(), and initialize().

uint64 SCTPServer::bytesSent [protected]

uint64 SCTPServer::packetsSent [protected]

uint64 SCTPServer::packetsRcvd [protected]

Referenced by finish(), handleMessage(), and initialize().

int32 SCTPServer::numSessions [protected]

Referenced by finish(), handleMessage(), and initialize().

uint64 SCTPServer::numRequestsToSend [protected]

bool SCTPServer::ordered [protected]

Referenced by generateAndSend(), and initialize().

bool SCTPServer::abortSent [protected]

Referenced by finish(), handleMessage(), and initialize().

int32 SCTPServer::queueSize [protected]

int32 SCTPServer::count [protected]

Referenced by generateAndSend(), and handleMessage().

cMessage* SCTPServer::timeoutMsg [protected]

cMessage* SCTPServer::delayTimer [protected]

cMessage* SCTPServer::delayFirstReadTimer [protected]

cPacket* SCTPServer::abort [protected]

Referenced by finish(), handleMessage(), and initialize().

int32 SCTPServer::outboundStreams [protected]

int32 SCTPServer::lastStream [protected]

Referenced by finish(), handleMessage(), and handleTimer().

Referenced by finish(), and handleMessage().

Referenced by finish(), and handleMessage().

int32 SCTPServer::ssn [protected]


The documentation for this class was generated from the following files:

Generated on Fri Mar 20 18:51:21 2009 for INET Framework for OMNeT++/OMNEST by  doxygen 1.5.5