00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011 #include "PacketProxy.h"
00012
00013
00015 Define_Module(PacketProxy);
00016
00020 PacketProxy::PacketProxy()
00021 {
00022 rtEvent = NULL;
00023 }
00024
00028 PacketProxy::~PacketProxy()
00029 {
00030 cancelAndDelete(rtEvent);
00031 }
00032
00036 void
00037 PacketProxy::initialize()
00038 {
00039 rtEvent = new cMessage("rtEvent");
00040 rtScheduler =
00041 check_and_cast<cUDPSocketRTScheduler *>(simulation.getScheduler());
00042 rtScheduler->setInterfaceModule(this, rtEvent, inBuffer,
00043 MAX_MSG_SIZE, &numRecvBytes);
00044 nodeManager =
00045 check_and_cast<NodeManager *>(simulation.getModuleByPath("nodemanager"));
00046 pktProcTime.setName("Packet Processing Time");
00047 }
00048
00054 void
00055 PacketProxy::handleMessage(cMessage *msg)
00056 {
00057
00058 switch(getMessageType((msgHeader *) inBuffer))
00059 {
00060 case DATA_MSG:
00061 ev << "PacketProxy.handleSocketEvent(): WLAN_MSG received\n";
00062 printDataMessage(inBuffer);
00063 processDataMsg((dataMsg *) inBuffer);
00064 break;
00065 case REGISTRATION_MSG:
00066 ev << "PacketProxy.handleSocketEvent(): REGISTRATION_MSG received\n";
00067 printRegisterMessage(inBuffer);
00068 processRegistrationMsg((registrationMsg *) inBuffer);
00069 break;
00070 case DEREGISTRATION_MSG:
00071 ev << "PacketProxy.handleSocketEvent(): DEREGISTRATION_MSG received\n";
00072 printPlainMessage(inBuffer);
00073 processDeregistrationMsg((plainMsg *) inBuffer);
00074 break;
00075 case CONFIG_MSG:
00076 ev << "PacketProxy.handleSocketEvent(): CONFIG_MSG received\n";
00077 printConfigMessage(inBuffer);
00078 processConfigurationMsg((configMsg *) inBuffer);
00079 break;
00080 default:
00081 ev << "PacketProxy.handleSocketEvent(): Unknown message received ("
00082 << getMessageType((msgHeader *) inBuffer) << ")\n";
00083 numRecvBytes = 0;
00084 break;
00085 }
00086 }
00087
00091 void
00092 PacketProxy::processDataMsg(dataMsg *msg)
00093 {
00094 host_id *hostId = (host_id *) &((msg->header).id);
00095
00096 cModule *host = (cModule *) nodeManager->isRegistered(hostId);
00097
00098 if (host != NULL)
00099 {
00100 MsgHandler *handler =
00101 check_and_cast<MsgHandler *>(host->getSubmodule("msgHandler"));
00102 handler->sendToModel((char *) msg->wlanPkt, msg->pktLength);
00103 }
00104
00105
00106 numRecvBytes = 0;
00107 }
00108
00112 void
00113 PacketProxy::processRegistrationMsg(registrationMsg *msg)
00114 {
00115 host_id *hostId = (host_id *) &((msg->header).id);
00116
00117 cModule *host = (cModule *) nodeManager->isRegistered(hostId);
00118
00119 if (host == NULL)
00120 {
00121 nodeManager->addNode(msg);
00122 } else {
00123 unsigned int msgId = (msg->info).msgId;
00124 MsgHandler *handler =
00125 check_and_cast<MsgHandler *>(host->getSubmodule("msgHandler"));
00126 handler->sendAck(msgId);
00127 }
00128
00129
00130 numRecvBytes = 0;
00131 }
00132
00136 void
00137 PacketProxy::processDeregistrationMsg(plainMsg *msg)
00138 {
00139 host_id *hostId = (host_id *) &((msg->header).id);
00140
00141 cModule *host = (cModule *) nodeManager->isRegistered(hostId);
00142
00143 if (host != NULL)
00144 nodeManager->removeNode(host);
00145
00146
00147 numRecvBytes = 0;
00148 }
00149
00153 void
00154 PacketProxy::processConfigurationMsg(configMsg *msg)
00155 {
00156 host_id *hostId = (host_id *) &((msg->header).id);
00157
00158 cModule *host = (cModule *) nodeManager->isRegistered(hostId);
00159
00160 if (host != NULL)
00161 {
00162 MsgHandler *handler =
00163 check_and_cast<MsgHandler *>(host->getSubmodule("msgHandler"));
00164 handler->updateVifParameter(&(msg->vifData));
00165 }
00166
00167
00168 numRecvBytes = 0;
00169 }
00170
00174 unsigned char
00175 PacketProxy::getMessageType(msgHeader *header)
00176 {
00177 return header->type;
00178 }
00179
00183 void
00184 PacketProxy::debugMessage(const char *msg, int length)
00185 {
00186 ev.printf("\n(%d bytes) data frame:\n", length);
00187 for (int i = 0; i < length; i+=2)
00188 {
00189 if (i % 16 == 0)
00190 {
00191 if (i == 0)
00192 ev.printf("(0x0000) ");
00193 else
00194 ev.printf("(%#.4x) ", i);
00195 }
00196 ev.printf("%02hhx%02hhx ", *(msg + i), *(msg + (i + 1)));
00197 if (((i + 2) % 16 == 0) && (i > 0))
00198 ev.printf("\n");
00199 }
00200 ev.printf("\n");
00201 }
00202
00203 void
00204 PacketProxy::printConfigMessage(const char *message)
00205 {
00206 msgHeader *header = (msgHeader *) message;
00207 ev.printf("\n[%4lu bytes] ========== CONFIGURE MESSAGE ===========\n",
00208 CONFIG_MSG_SIZE);
00209 ev.printf("[%4lu bytes] ,---------- msgHeader -------------------\n",
00210 sizeof(msgHeader));
00211 ev.printf("(%4lu bytes) | type:\t%i\n", sizeof(header->type), header->type);
00212 ev.printf("(%4lu bytes) | id:\t%s\n", sizeof(header->id), header->id);
00213
00214 configNotification info =
00215 (configNotification) ((configMsg *) message)->vifData;
00216 uint16_t type = info.type;
00217 vifParameter *value_p = &(info.value);
00218 ev.printf("(%4lu bytes) ,---------- configNotification ----------\n",
00219 sizeof(configNotification));
00220 switch (type)
00221 {
00222 case SIOCSIWFREQ:
00223 ev.printf("(%4lu bytes) | property:\t%4x (SIOCSIWFREQ)\n",
00224 sizeof(type), type);
00225 ev.printf("(%4lu bytes) | value:\t\t%i\n",
00226 sizeof(*value_p), value_p->channel);
00227 break;
00228 case SIOCSIWTXPOW:
00229 ev.printf("(%4i bytes) | property:\t%4x (SICSIWPOW)\n",
00230 sizeof(type), type);
00231 ev.printf("(%4i bytes) | value:\t\t%imW\n",
00232 sizeof(*value_p), value_p->txpower);
00233 break;
00234 case SIOCSIWRETRY:
00235 ev.printf("(%4i bytes) | property:\t%4x (SICSIWRETRY)\n",
00236 sizeof(type), type);
00237 ev.printf("(%4i bytes) | value:\t\t%i\n",
00238 sizeof(*value_p), value_p->retry);
00239 break;
00240 case SIOCSIWRTS:
00241 ev.printf("(%4i bytes) | property:\t%4x (SICSIWRTS)\n",
00242 sizeof(type), type);
00243 ev.printf("(%4i bytes) | value:\t\t%iB\n",
00244 sizeof(*value_p), value_p->rts);
00245 break;
00246 case SIOCSIWSENS:
00247 ev.printf("(%4i bytes) | property:\t%4x (SICSIWSENS)\n",
00248 sizeof(type), type);
00249 ev.printf("(%4i bytes) | value:\t\t%idB\n",
00250 sizeof(*value_p), value_p->sensitivity);
00251 break;
00252 default:
00253 ev.printf("(%4i bytes) | property:\t\t%4x (unknown)\n",
00254 sizeof(type), type);
00255 break;
00256 }
00257 printf("------------------------------------------------------\n");
00258 }
00259
00260 void
00261 PacketProxy::printRegisterMessage(const char *msg)
00262 {
00263 msgHeader *header = (msgHeader *) msg;
00264 ev.printf("\n[%4lu bytes] ========== REGISTRATION MESSAGE ========\n",
00265 sizeof(registrationMsg));
00266 ev.printf("[%4lu bytes] ,---------- msgHeader -------------------\n",
00267 sizeof(msgHeader));
00268 ev.printf("(%4lu bytes) | type:\t%i\n", sizeof(header->type), header->type);
00269 ev.printf("(%4lu bytes) | id:\t%s\n", sizeof(header->id), header->id);
00270
00271 registrationInfo *regInfo = &((registrationMsg *) msg)->info;
00272 ev.printf("[%4lu bytes] ,---------- registrationInfo ------------\n",
00273 sizeof(registrationInfo));
00274 ev.printf("(%4lu bytes) | name:\t%s\n", sizeof(regInfo->name), regInfo->name);
00275 ev.printf("[%4lu bytes] | ,---------------- addr ----------------\n",
00276 sizeof(regInfo->addr));
00277 ev.printf("(%4lu bytes) | | sin_family:\t%i\n",
00278 sizeof(regInfo->addr.ss_family), regInfo->addr.ss_family);
00279 if (regInfo->addr.ss_family == AF_INET)
00280 {
00281 ev.printf("(%4i bytes) | | sin_addr:\t%s\n", sizeof(struct in_addr),
00282 inet_ntoa(((struct sockaddr_in *) ®Info->addr)->sin_addr));
00283 ev.printf("(%4i bytes) | | sin_port:\t%i\n", sizeof(unsigned short),
00284 ntohs(((struct sockaddr_in *) ®Info->addr)->sin_port));
00285 }
00286 if (regInfo->addr.ss_family == AF_INET6)
00287 {
00288 char addr_string[INET6_ADDRSTRLEN];
00289 ev.printf("(%4i bytes) | | sin6_addr:\t%s\n", sizeof(struct in6_addr),
00290 inet_ntop(AF_INET6,
00291 &((struct sockaddr_in6 *) ®Info->addr)->sin6_addr,
00292 addr_string, INET6_ADDRSTRLEN));
00293 ev.printf("(%4i bytes) | | sin6_port:\t%i\n", sizeof(uint16_t),
00294 ntohs(((struct sockaddr_in6 *) ®Info->addr)->sin6_port));
00295 }
00296 ev.printf("(%4lu bytes) | msgId:\t%i\n",
00297 sizeof(regInfo->msgId), regInfo->msgId);
00298 ev.printf("(%4lu bytes) | numVif:\t%i\n",
00299 sizeof(regInfo->numVif), regInfo->numVif);
00300
00301 for (int i = 0; i < regInfo->numVif; i++)
00302 {
00303 vifRegistrationData *vifInfo =
00304 (vifRegistrationData *) ®Info->vifData[i];
00305 ev.printf("[%4lu bytes] | ,---------------- vifRegistrationData -\n",
00306 sizeof(vifRegistrationData));
00307 ev.printf("(%4i bytes) | | vif_name: \t%s\n",
00308 IFNAMSIZ + 1, vifInfo->vifName);
00309 unsigned char *mac = vifInfo->vifMac;
00310 ev.printf("(%4i bytes) | | vif_mac:\t%2.2x:%2.2x:%2.2x:%2.2x:%2.2x:%2.2x\n",
00311 ETH_ALEN, ((unsigned char *) mac)[0],
00312 ((unsigned char *) mac)[1], ((unsigned char *) mac)[2],
00313 ((unsigned char *) mac)[3], ((unsigned char *) mac)[4],
00314 ((unsigned char *) mac)[5]);
00315 ev.printf("(%4i bytes) | | vifIndex:\t%i\n",
00316 sizeof(int16_t), vifInfo->vifIndex);
00317 ev.printf("(%4i bytes) | | txpower:\t%imW\n",
00318 sizeof(int16_t), vifInfo->txpower);
00319 ev.printf("(%4i bytes) | | retry:\t\t%i\n",
00320 sizeof(int16_t), vifInfo->retry);
00321 ev.printf("(%4i bytes) | | rts:\t\t%iB\n",
00322 sizeof(int16_t), vifInfo->rts);
00323 ev.printf("(%4i bytes) | | sensitivity:\t%idB\n",
00324 sizeof(int16_t), vifInfo->sensitivity);
00325 ev.printf("(%4i bytes) | | channel:\t%i\n",
00326 sizeof(int64_t), vifInfo->channel);
00327 }
00328 }
00329
00330 void
00331 PacketProxy::printPlainMessage(const char *message)
00332 {
00333 msgHeader *header = (msgHeader *) message;
00334 if (header->type == ACK_MSG)
00335 ev.printf("\n[%4lu bytes] ========== ACKNOWLEDGE MESSAGE =========\n",
00336 sizeof(plainMsg));
00337 if (header->type == DEREGISTRATION_MSG)
00338 ev.printf("\n[%4lu bytes] ========== DEREGISTRATION MESSAGE ======\n",
00339 sizeof(plainMsg));
00340 ev.printf("[%4lu bytes] ,---------- msgHeader -------------------\n",
00341 sizeof(msgHeader));
00342 ev.printf("(%4lu bytes) | type:\t%i\n", sizeof(header->type), header->type);
00343 ev.printf("(%4lu bytes) | id:\t%s\n", sizeof(header->id), header->id);
00344
00345 plainMsg *msg = (plainMsg *) message;
00346 ev.printf("(%4lu bytes) msg_id:\t%i\n", sizeof(uint8_t), msg->msgId);
00347 }
00348
00349 void
00350 PacketProxy::printDataMessage(const char *message)
00351 {
00352 msgHeader *header = (msgHeader *) message;
00353 dataMsg *msg = (dataMsg *) message;
00354 int payloadSize = msg->pktLength;
00355 ev.printf("\n[%4lu bytes] ----------- DATA MESSAGE ----------------\n",
00356 DATA_PREAMBLE_SIZE + payloadSize);
00357 ev.printf("[%4lu bytes] ,---------- msgHeader -------------------\n",
00358 sizeof(msgHeader));
00359 ev.printf("(%4lu bytes) | type:\t%i\n", sizeof(header->type), header->type);
00360 ev.printf("(%4lu bytes) | id:\t%s\n", sizeof(header->id), header->id);
00361 ev.printf("(%4lu bytes) vifIndex:\t%u\n",
00362 sizeof(msg->vifIndex), msg->vifIndex);
00363 ev.printf("(%4lu bytes) pktLength:\t%u\n",
00364 sizeof(msg->pktLength), payloadSize);
00365 debugMessage((char *) msg->wlanPkt, payloadSize);
00366 }