00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019 #include <string.h>
00020 #include <platdep/sockets.h>
00021 #include <stdexcept>
00022 #include <omnetpp.h>
00023 #include "cnetcommbuffer.h"
00024
00025
00026
00027
00028
00029
00030 #define STOREARRAY(type,d,size) {memcpy(mBuffer+mMsgSize,d,size*sizeof(type)); mMsgSize+=size*sizeof(type);}
00031 #define EXTRACTARRAY(type,d,size) {\
00032 if ((mPosition + size*sizeof(type)) <= (uint32_t)mBufferSize) {\
00033 memcpy(d,mBuffer+mPosition,size*sizeof(type)); mPosition+=size*sizeof(type);\
00034 } else {\
00035 throw cRuntimeError("OverSim cnetcommbuffer.cc: EXTRACTARRAY buffer overflow!");\
00036 }\
00037 }
00038
00039 #define STORE(type,d) {memcpy(mBuffer+mMsgSize,(void*)&d,sizeof(type)); mMsgSize+=sizeof(type);}
00040 #define EXTRACT(type,d) {\
00041 if ((mPosition + sizeof(type)) <= (uint32_t)mBufferSize) {\
00042 memcpy((void*)&d,mBuffer+mPosition,sizeof(type)); mPosition+=sizeof(type);\
00043 } else {\
00044 throw cRuntimeError("OverSim cnetcommbuffer.cc: EXTRACT buffer overflow!");\
00045 }\
00046 }
00047
00048 cNetCommBuffer::cNetCommBuffer()
00049 {
00050 }
00051
00052 cNetCommBuffer::~cNetCommBuffer ()
00053 {
00054 }
00055
00056
00057 void cNetCommBuffer::pack(char d)
00058 {
00059 extendBufferFor(sizeof(char));
00060 STORE(char,d);
00061 }
00062
00063
00064 void cNetCommBuffer::pack(unsigned char d)
00065 {
00066 extendBufferFor(sizeof(unsigned char));
00067 STORE(unsigned char,d);
00068 }
00069
00070
00071 void cNetCommBuffer::pack(bool d)
00072 {
00073 extendBufferFor(sizeof(bool));
00074 STORE(bool,d);
00075 }
00076
00077
00078 void cNetCommBuffer::pack(short d)
00079 {
00080 extendBufferFor(sizeof(short));
00081 short d_buf = htons(d);
00082 STORE(short,d_buf);
00083 }
00084
00085
00086 void cNetCommBuffer::pack(unsigned short d)
00087 {
00088 extendBufferFor(sizeof(unsigned short));
00089 unsigned short d_buf = htons(d);
00090 STORE(unsigned short,d_buf);
00091 }
00092
00093
00094 void cNetCommBuffer::pack(int d)
00095 {
00096 extendBufferFor(sizeof(int));
00097 int d_buf = htonl(d);
00098 STORE(int,d_buf);
00099 }
00100
00101
00102 void cNetCommBuffer::pack(unsigned int d)
00103 {
00104 extendBufferFor(sizeof(unsigned int));
00105 unsigned int d_buf = htonl(d);
00106 STORE(unsigned int,d_buf);
00107 }
00108
00109
00110 void cNetCommBuffer::pack(long d)
00111 {
00112 extendBufferFor(sizeof(long));
00113 long d_buf = htonl(d);
00114 STORE(long,d_buf);
00115 }
00116
00117
00118 void cNetCommBuffer::pack(unsigned long d)
00119 {
00120 extendBufferFor(sizeof(unsigned long));
00121 unsigned long d_buf = htonl(d);
00122 STORE(unsigned long,d_buf);
00123 }
00124
00125
00126 void cNetCommBuffer::pack(opp_long_long d)
00127 {
00128 extendBufferFor(sizeof(opp_long_long));
00129 STORE(opp_long_long,d);
00130 }
00131
00132
00133 void cNetCommBuffer::pack(opp_unsigned_long_long d)
00134 {
00135 extendBufferFor(sizeof(opp_unsigned_long_long));
00136 STORE(opp_unsigned_long_long,d);
00137 }
00138
00139
00140 void cNetCommBuffer::pack(float d)
00141 {
00142 extendBufferFor(sizeof(float));
00143 STORE(float,d);
00144 }
00145
00146
00147 void cNetCommBuffer::pack(double d)
00148 {
00149 extendBufferFor(sizeof(double));
00150 STORE(double,d);
00151 }
00152
00153
00154 void cNetCommBuffer::pack(long double d)
00155 {
00156 extendBufferFor(sizeof(long double));
00157 STORE(long double,d);
00158 }
00159
00160
00161
00162
00163 void cNetCommBuffer::pack(const char *d)
00164 {
00165 int len = d ? strlen(d) : 0;
00166
00167 pack(len);
00168 extendBufferFor(len*sizeof(char));
00169 STOREARRAY(char,d,len);
00170 }
00171
00172 void cNetCommBuffer::pack(const opp_string& d)
00173 {
00174 pack(d.c_str());
00175 }
00176
00177 void cNetCommBuffer::pack(const SimTime *d, int size)
00178 {
00179 for (int i = 0; i < size; i++)
00180 pack(d[i]);
00181 }
00182
00183 void cNetCommBuffer::pack(const char *d, int size)
00184 {
00185 extendBufferFor(size*sizeof(char));
00186 STOREARRAY(char,d,size);
00187 }
00188
00189
00190 void cNetCommBuffer::pack(const unsigned char *d, int size)
00191 {
00192 extendBufferFor(size*sizeof(unsigned char));
00193 STOREARRAY(unsigned char,d,size);
00194 }
00195
00196
00197 void cNetCommBuffer::pack(const bool *d, int size)
00198 {
00199 extendBufferFor(size*sizeof(bool));
00200 STOREARRAY(bool,d,size);
00201 }
00202
00203
00204 void cNetCommBuffer::pack(const short *d, int size)
00205 {
00206 extendBufferFor(size*sizeof(short));
00207 STOREARRAY(short,d,size);
00208 }
00209
00210
00211
00212 void cNetCommBuffer::pack(const unsigned short *d, int size)
00213 {
00214 extendBufferFor(size*sizeof(unsigned short));
00215 STOREARRAY(unsigned short,d,size);
00216 }
00217
00218
00219
00220 void cNetCommBuffer::pack(const int *d, int size)
00221 {
00222 extendBufferFor(size*sizeof(int));
00223 STOREARRAY(int,d,size);
00224 }
00225
00226
00227
00228 void cNetCommBuffer::pack(const unsigned int *d, int size)
00229 {
00230 extendBufferFor(size*sizeof(unsigned int));
00231 STOREARRAY(unsigned int,d,size);
00232 }
00233
00234
00235
00236 void cNetCommBuffer::pack(const long *d, int size)
00237 {
00238 extendBufferFor(size*sizeof(long));
00239 STOREARRAY(long,d,size);
00240 }
00241
00242
00243
00244 void cNetCommBuffer::pack(const unsigned long *d, int size)
00245 {
00246 extendBufferFor(size*sizeof(unsigned long));
00247 STOREARRAY(unsigned long,d,size);
00248 }
00249
00250
00251 void cNetCommBuffer::pack(const opp_long_long *d, int size)
00252 {
00253 extendBufferFor(size*sizeof(opp_long_long));
00254 STOREARRAY(opp_long_long,d,size);
00255 }
00256
00257
00258 void cNetCommBuffer::pack(const opp_unsigned_long_long *d, int size)
00259 {
00260 extendBufferFor(size*sizeof(opp_unsigned_long_long));
00261 STOREARRAY(opp_unsigned_long_long,d,size);
00262 }
00263
00264
00265 void cNetCommBuffer::pack(const float *d, int size)
00266 {
00267 extendBufferFor(size*sizeof(float));
00268 STOREARRAY(float,d,size);
00269 }
00270
00271
00272 void cNetCommBuffer::pack(const double *d, int size)
00273 {
00274 extendBufferFor(size*sizeof(double));
00275 STOREARRAY(double,d,size);
00276 }
00277
00278
00279 void cNetCommBuffer::pack(const long double *d, int size)
00280 {
00281 extendBufferFor(size*sizeof(long double));
00282 STOREARRAY(long double,d,size);
00283 }
00284
00285
00286
00287 void cNetCommBuffer::pack(const char **d, int size)
00288 {
00289 for (int i = 0; i < size; i++)
00290 pack(d[i]);
00291 }
00292
00293 void cNetCommBuffer::pack(const opp_string *d, int size)
00294 {
00295 for (int i = 0; i < size; i++)
00296 pack(d[i]);
00297 }
00298
00299 void cNetCommBuffer::pack(SimTime d)
00300 {
00301 pack((opp_long_long)d.raw());
00302 }
00303
00304
00305
00306 void cNetCommBuffer::unpack(char& d)
00307 {
00308 EXTRACT(char,d);
00309 }
00310
00311
00312 void cNetCommBuffer::unpack(unsigned char& d)
00313 {
00314 EXTRACT(unsigned char,d);
00315 }
00316
00317 void cNetCommBuffer::unpack(bool& d)
00318 {
00319 EXTRACT(bool,d);
00320 }
00321
00322 void cNetCommBuffer::unpack(short& d)
00323 {
00324 EXTRACT(short,d);
00325 d = ntohs(d);
00326 }
00327
00328
00329 void cNetCommBuffer::unpack(unsigned short& d)
00330 {
00331 EXTRACT(unsigned short,d);
00332 d = ntohs(d);
00333 }
00334
00335
00336 void cNetCommBuffer::unpack(int& d)
00337 {
00338 EXTRACT(int,d);
00339 d = ntohl(d);
00340 }
00341
00342
00343 void cNetCommBuffer::unpack(unsigned int& d)
00344 {
00345 EXTRACT(unsigned int,d);
00346 d = ntohl(d);
00347 }
00348
00349
00350 void cNetCommBuffer::unpack(long& d)
00351 {
00352 EXTRACT(long,d);
00353 d = ntohl(d);
00354 }
00355
00356
00357 void cNetCommBuffer::unpack(unsigned long& d)
00358 {
00359 EXTRACT(unsigned long,d);
00360 d = ntohl(d);
00361 }
00362
00363
00364 void cNetCommBuffer::unpack(opp_long_long& d)
00365 {
00366 EXTRACT(opp_long_long,d);
00367 }
00368
00369
00370 void cNetCommBuffer::unpack(opp_unsigned_long_long& d)
00371 {
00372 EXTRACT(opp_unsigned_long_long,d);
00373 }
00374
00375
00376 void cNetCommBuffer::unpack(float& d)
00377 {
00378 EXTRACT(float,d);
00379 }
00380
00381
00382 void cNetCommBuffer::unpack(double& d)
00383 {
00384 EXTRACT(double,d);
00385 }
00386
00387
00388 void cNetCommBuffer::unpack(long double& d)
00389 {
00390 EXTRACT(long double,d);
00391 }
00392
00393
00394
00395 void cNetCommBuffer::unpack(const char *&d)
00396 {
00397 int len;
00398 unpack(len);
00399
00400 char *tmp = new char[len+1];
00401 EXTRACTARRAY(char,tmp,len);
00402 tmp[len] = '\0';
00403 d = tmp;
00404 }
00405
00406
00407 void cNetCommBuffer::unpack(opp_string& d)
00408 {
00409 int len;
00410 unpack(len);
00411
00412 d.reserve(len+1);
00413 EXTRACTARRAY(char,d.buffer(),len);
00414 d.buffer()[len] = '\0';
00415 }
00416
00417
00418 void cNetCommBuffer::unpack(SimTime& d)
00419 {
00420 opp_long_long raw;
00421 unpack(raw);
00422 d.setRaw(raw);
00423 }
00424
00425
00426 void cNetCommBuffer::unpack(char *d, int size)
00427 {
00428 EXTRACTARRAY(char,d,size);
00429 }
00430
00431 void cNetCommBuffer::unpack(unsigned char *d, int size)
00432 {
00433 EXTRACTARRAY(unsigned char,d,size);
00434 }
00435
00436
00437 void cNetCommBuffer::unpack(bool *d, int size)
00438 {
00439 EXTRACTARRAY(bool,d,size);
00440 }
00441
00442 void cNetCommBuffer::unpack(short *d, int size)
00443 {
00444 EXTRACTARRAY(short,d,size);
00445 }
00446
00447
00448 void cNetCommBuffer::unpack(unsigned short *d, int size)
00449 {
00450 EXTRACTARRAY(unsigned short,d,size);
00451 }
00452
00453
00454 void cNetCommBuffer::unpack(int *d, int size)
00455 {
00456 EXTRACTARRAY(int,d,size);
00457 }
00458
00459
00460 void cNetCommBuffer::unpack(unsigned int *d, int size)
00461 {
00462 EXTRACTARRAY(unsigned,d,size);
00463 }
00464
00465
00466 void cNetCommBuffer::unpack(long *d, int size)
00467 {
00468 EXTRACTARRAY(long,d,size);
00469 }
00470
00471
00472 void cNetCommBuffer::unpack(unsigned long *d, int size)
00473 {
00474 EXTRACTARRAY(unsigned long,d,size);
00475 }
00476
00477
00478 void cNetCommBuffer::unpack(opp_long_long *d, int size)
00479 {
00480 EXTRACTARRAY(opp_long_long,d,size);
00481 }
00482
00483
00484 void cNetCommBuffer::unpack(opp_unsigned_long_long *d, int size)
00485 {
00486 EXTRACTARRAY(opp_unsigned_long_long,d,size);
00487 }
00488
00489
00490 void cNetCommBuffer::unpack(float *d, int size)
00491 {
00492 EXTRACTARRAY(float,d,size);
00493 }
00494
00495
00496 void cNetCommBuffer::unpack(double *d, int size)
00497 {
00498 EXTRACTARRAY(double,d,size);
00499 }
00500
00501
00502 void cNetCommBuffer::unpack(long double *d, int size)
00503 {
00504 EXTRACTARRAY(long double,d,size);
00505 }
00506
00507 void cNetCommBuffer::unpack(const char **d, int size)
00508 {
00509 for (int i = 0; i < size; i++)
00510 unpack(d[i]);
00511 }
00512
00513 void cNetCommBuffer::unpack(opp_string *d, int size)
00514 {
00515 for (int i = 0; i < size; i++)
00516 unpack(d[i]);
00517 }
00518
00519
00520 void cNetCommBuffer::unpack(SimTime *d, int size)
00521 {
00522 for (int i = 0; i < size; i++)
00523 unpack(d[i]);
00524 }
00525
00526
00527 size_t cNetCommBuffer::getRemainingMessageSize()
00528 {
00529 return (mMsgSize - mPosition);
00530 }
00531
00532 void cNetCommBuffer::packObject(cObject *obj)
00533 {
00534 pack(obj->getClassName());
00535 obj->parsimPack(this);
00536 }
00537
00538 cObject *cNetCommBuffer::unpackObject()
00539 {
00540 char *classname = NULL;
00541 cObject *obj = NULL;
00542 try {
00543 unpack(classname);
00544 obj = createOne(classname);
00545 obj->parsimUnpack(this);
00546 } catch (...) {
00547 delete [] classname;
00548 delete obj;
00549 throw std::invalid_argument("Failed to parse received packet");
00550 }
00551
00552 delete [] classname;
00553 return obj;
00554 }
00555