serialize.cc

   1 /*
   2     Copyright 2004-2005 Chris Tallon, Andreas Vogel
   3
   4     This file is part of VOMP.
   5
   6     VOMP is free software; you can redistribute it and/or modify
   7     it under the terms of the GNU General Public License as published by
   8     the Free Software Foundation; either version 2 of the License, or
   9     (at your option) any later version.
  10
  11     VOMP is distributed in the hope that it will be useful,
  12     but WITHOUT ANY WARRANTY; without even the implied warranty of
  13     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14     GNU General Public License for more details.
  15
  16     You should have received a copy of the GNU General Public License
  17     along with VOMP; if not, write to the Free Software
  18     Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
  19 */
  20
  21 #include "serialize.h"
  22 #include <stdlib.h>
  23 #ifndef WIN32
  24 #include <arpa/inet.h>
  25 #else
  26 #include <winsock2.h>
  27 #endif
  28
  29
  30 #ifndef SNPRINTF
  31 #define SNPRINTF snprintf
  32 #endif
  33
  34 #define BUFFERINCREASE 1024
  35
  36 int SerializeBuffer::seek(int amount) {
  37   UCHAR *np=current+amount;
  38   if (np < start || np > end) return -1;
  39   current=np;
  40   return 0;
  41 }
  42
  43 void SerializeBuffer::rewind() {
  44   current=start;
  45 }
  46
  47 int SerializeBuffer::checkSpace(int amount) {
  48   if ((current+amount) <= end) return 0;
  49   if (owning && autoincrease) {
  50      if (start+size > current+amount) {
  51        end=start+size;
  52        return 0;
  53      }
  54      UCHAR *ns=new UCHAR[size+BUFFERINCREASE];
  55      if (!ns) return -1;
  56      memcpy(ns,start,end-start);
  57      size=size+BUFFERINCREASE;
  58      end=ns+size;
  59      if (useMalloc) free( start);
  60      else delete [] start;
  61      start=ns;
  62      return 0;
  63   }
  64   return -1;
  65 }
  66
  67 SerializeBuffer::~SerializeBuffer() {
  68   if (owning) {
  69     if (useMalloc) free(start);
  70     else delete[] start;
  71     start=NULL;
  72   }
  73 }
  74 SerializeBuffer::SerializeBuffer(ULONG sz,bool isMalloc,bool ai){
  75   autoincrease=ai;
  76   useMalloc=isMalloc;
  77   if (isMalloc) {
  78     start=(UCHAR *)malloc(sz);
  79   }
  80   else {
  81     start=new UCHAR[sz];
  82   }
  83   end=start;
  84   current=start;
  85   size=sz;
  86   owning=true;
  87 }
  88     //constructor for SerializeBuffers with external buffers
  89 SerializeBuffer::SerializeBuffer(UCHAR *buffer,ULONG sz,bool ow,bool isMalloc,bool ai) {
  90   useMalloc=isMalloc;
  91   autoincrease=ai;
  92   owning=ow;
  93   size=sz;
  94   start=buffer;
  95   current=start;
  96   end=start+size;
  97 }
  98 /**
  99   * helper for serialize and deserialize
 100   * always return != if no space
 101   * advance buffer pointer
 102   */
 103
 104 int SerializeBuffer::encodeLong(ULONG data) {
 105   if (checkSpace( (int)sizeof(ULONG))!=0) return -1;
 106   *((ULONG *)(current))=htonl(data);
 107   current+=sizeof(ULONG);
 108   return 0;
 109 }
 110 int SerializeBuffer::encodeShort(USHORT data) {
 111   if (checkSpace( (int)sizeof(USHORT))!=0) return -1;
 112   *((USHORT *)(current))=htons(data);
 113   current+=sizeof(USHORT);
 114   return 0;
 115 }
 116 int SerializeBuffer::encodeByte(UCHAR data) {
 117   if (checkSpace( (int)sizeof(UCHAR))!=0) return -1;
 118   *((UCHAR *)(current))=data;
 119   current+=sizeof(UCHAR);
 120   return 0;
 121 }
 122 int SerializeBuffer::encodeLongLong(ULLONG data) {
 123   if (checkSpace( (int)sizeof(ULLONG))!=0) return -1;
 124   *((ULONG *)(current))=htonl((data>>32) & 0xffffffff);
 125   current+=sizeof(ULONG);
 126   *((ULONG *)(current))=htonl(data & 0xffffffff);
 127   current+=sizeof(ULONG);
 128   return 0;
 129 }
 130 //string: 4 len, string with 0
 131 int SerializeBuffer::encodeString(const char *str) {
 132   if (checkSpace( (int)sizeof(ULONG))!=0) return -1;
 133   ULONG len=0;
 134   if (str) len=strlen(str)+1;
 135   *((ULONG *)(current))=htonl(len);
 136   current+=sizeof(ULONG);
 137   if (len == 0) return 0;
 138   if (checkSpace((int)len)!=0) return -1;
 139   strcpy((char *) current,str);
 140   current+=len;
 141   return 0;
 142 }
 143 int SerializeBuffer::decodeLong( int &data) {
 144   if (checkSpace( (int)sizeof(ULONG))!=0) return -1;
 145   data=(int)ntohl(*((ULONG *)(current)));
 146   current+=sizeof(ULONG);
 147   return 0;
 148 }
 149 int SerializeBuffer::decodeLong(ULONG &data) {
 150   if (checkSpace( (int)sizeof(ULONG))!=0) return -1;
 151   data=ntohl(*((ULONG *)(current)));
 152   current+=sizeof(ULONG);
 153   return 0;
 154 }
 155 int SerializeBuffer::decodeShort(USHORT &data) {
 156   if (checkSpace( (int)sizeof(USHORT))!=0) return -1;
 157   data=ntohs(*((USHORT *)(current)));
 158   current+=sizeof(USHORT);
 159   return 0;
 160 }
 161 int SerializeBuffer::decodeByte(UCHAR &data) {
 162   if (checkSpace( (int)sizeof(UCHAR))!=0) return -1;
 163   data=*((UCHAR *)current);
 164   current+=sizeof(UCHAR);
 165   return 0;
 166 }
 167 int SerializeBuffer::decodeLongLong(ULLONG &data) {
 168   if (checkSpace( (int)sizeof(ULLONG))!=0) return -1;
 169   ULLONG hd=ntohl(*((ULONG *)(current)));
 170   current+=sizeof(ULONG);
 171   ULLONG ld=ntohl(*((ULONG *)(current)));
 172   current+=sizeof(ULONG);
 173   data=(hd << 32) | ld;
 174   return 0;
 175 }
 176 //string: 4 len, string with 0
 177 int SerializeBuffer::decodeString(ULONG &len, char *&strbuf) {
 178   strbuf=NULL;
 179   len=0;
 180   if (checkSpace( (int)sizeof(ULONG))!=0) return -1;
 181   len=ntohl(*((ULONG *)(current)));
 182   current+=sizeof(ULONG);
 183   if (len == 0) return 0;
 184   if (checkSpace((int)len)!=0) return -1;
 185   strbuf=new char[len];
 186   strncpy(strbuf,(char *)current,len);
 187   *(strbuf+len-1)=0;
 188   current+=len;
 189   return 0;
 190 }
 191
 192
 193 UCHAR * SerializeBuffer::steelBuffer() {
 194   UCHAR *rt=start;
 195   owning=false;
 196   autoincrease=false;
 197   return rt;
 198 }
 199
 200 int Serializable::getSerializedStringLen(const char * str) {
 201   int rt=4;
 202   if (str) rt+=strlen(str)+1;
 203   return rt;
 204 }
 205
 206 USHORT Serializable::getVersion() {
 207   return version;
 208 }
 209
 210
 211 Serializable::Serializable() {
 212   version=1;
 213 }
 214 Serializable::~Serializable(){}
 215
 216 int Serializable::getSerializedLen() {
 217   //2version+4len
 218   return 6 + getSerializedLenImpl();
 219 }
 220 int Serializable::serialize(SerializeBuffer *b) {
 221   UCHAR *ptr=b->getCurrent();
 222   if (b->encodeShort(version) != 0) return -1;
 223   if (b->encodeLong(0) != 0) return -1; //dummy len
 224   if (serializeImpl(b) != 0) return -1;
 225   UCHAR *ep=b->getCurrent();
 226   //now write the len
 227   int len=ep-ptr-6;
 228   if (len < 0) return -1 ; //internal error
 229   b->seek(ptr-ep+2); //to len field
 230   if (b->encodeLong(len) != 0) return -1;
 231   b->seek(ep-b->getCurrent()); //back to end
 232   return 0;
 233 }
 234
 235 int Serializable::deserialize(SerializeBuffer *b) {
 236   USHORT vers=0;
 237   if (b->decodeShort(vers) != 0) return -1;
 238   ULONG len=0;
 239   if (b->decodeLong(len) != 0) return -1;
 240   UCHAR *data=b->getCurrent();
 241   if (data+len > b->getEnd()) return -1;
 242   //TODO: set end temp. to current+len
 243   //for better error handling in deserializeImpl
 244   if (deserializeImpl(b) != 0) return -1;
 245   //ensure we go to end of this element regardless of the things we know
 246   b->seek(data+len-b->getCurrent());
 247   return 0;
 248 }
 249
 250 SerializableList::SerializableList() {
 251   version=1;
 252   encodeOnly=false;
 253 }
 254 SerializableList::~SerializableList(){}
 255
 256 int SerializableList::addParam(Serializable *p,USHORT v) {
 257   if (v < version || p == NULL) return -1;
 258   Pentry entry;
 259   entry.ptype=TSER;
 260   entry.ptr.pser=p;
 261   entry.version=v;
 262   list.push_back(entry);
 263   version=v;
 264   return 0;
 265 }
 266 int SerializableList::addParam(USHORT *p,USHORT v) {
 267   if (v < version || p == NULL) return -1;
 268   Pentry entry;
 269   entry.ptype=TUSHORT;
 270   entry.ptr.pshort=p;
 271   entry.version=v;
 272   list.push_back(entry);
 273   version=v;
 274   return 0;
 275 }
 276 int SerializableList::addParam(ULONG *p,USHORT v) {
 277   if (v < version || p == NULL) return -1;
 278   Pentry entry;
 279   entry.ptype=TULONG;
 280   entry.ptr.plong=p;
 281   entry.version=v;
 282   list.push_back(entry);
 283   version=v;
 284   return 0;
 285 }
 286 int SerializableList::addParam(ULLONG *p,USHORT v) {
 287   if (v < version || p == NULL) return -1;
 288   Pentry entry;
 289   entry.ptype=TULLONG;
 290   entry.ptr.pllong=p;
 291   entry.version=v;
 292   list.push_back(entry);
 293   version=v;
 294   return 0;
 295 }
 296 int SerializableList::addParam(char **p,USHORT v) {
 297   if (v < version || p == NULL) return -1;
 298   Pentry entry;
 299   entry.ptype=TCHAR;
 300   entry.ptr.pchar=p;
 301   entry.version=v;
 302   list.push_back(entry);
 303   version=v;
 304   return 0;
 305 }
 306
 307 bool SerializableList::Pentry::isEqual(void *p,SerializableList::Ptypes t) {
 308   void *cmp=NULL;
 309   switch(t) {
 310     case TUSHORT:
 311       cmp=(void *)ptr.pshort;
 312       break;
 313     case TULONG:
 314       cmp=(void *)ptr.plong;
 315       break;
 316     case TULLONG:
 317       cmp=(void *)ptr.pllong;
 318       break;
 319     case TSER:
 320       cmp=(void *)ptr.pser;
 321       break;
 322     case TCHAR:
 323       cmp=(void *)ptr.pchar;
 324       break;
 325     case TUNKNOWN:
 326       break;
 327   }
 328   return p==cmp;
 329 }
 330
 331 SerializableList::Pentry *SerializableList::findEntry(void *p,SerializableList::Ptypes t) {
 332   for (vector<Pentry>::iterator it=list.begin();it<list.end();it++) {
 333     if ( (*it).isEqual(p,t)) return &(*it);
 334   }
 335   return NULL;
 336 }
 337 bool SerializableList::isDeserialized(Serializable *p){
 338   SerializableList::Pentry *e=findEntry(p,TSER);
 339   if (!e) return false;
 340   return e->isDeserialized;
 341 }
 342 bool SerializableList::isDeserialized(USHORT *p){
 343   SerializableList::Pentry *e=findEntry(p,TUSHORT);
 344   if (!e) return false;
 345   return e->isDeserialized;
 346 }
 347 bool SerializableList::isDeserialized(ULONG *p){
 348   SerializableList::Pentry *e=findEntry(p,TULONG);
 349   if (!e) return false;
 350   return e->isDeserialized;
 351 }
 352
 353 bool SerializableList::isDeserialized(ULLONG *p){
 354   SerializableList::Pentry *e=findEntry(p,TULLONG);
 355   if (!e) return false;
 356   return e->isDeserialized;
 357 }
 358
 359 bool SerializableList::isDeserialized(char **p){
 360   SerializableList::Pentry *e=findEntry(p,TCHAR);
 361   if (!e) return false;
 362   return e->isDeserialized;
 363 }
 364
 365 int SerializableList::getSerializedLenImpl(){
 366   int rt=0;
 367   for (vector<Pentry>::iterator it=list.begin();it<list.end();it++) {
 368     switch((*it).ptype){
 369       case TUSHORT:
 370         rt+=sizeof(USHORT);
 371         break;
 372       case TULONG:
 373         rt+=sizeof(ULONG);
 374         break;
 375       case TULLONG:
 376         rt+=sizeof(ULLONG);
 377         break;
 378       case TCHAR:
 379         rt+=getSerializedStringLen(*((*it).ptr.pchar));
 380         break;
 381       case TSER:
 382         rt+=(*it).ptr.pser->getSerializedLen();
 383         break;
 384       case TUNKNOWN:
 385         break;
 386     }
 387   }
 388   return rt;
 389 }
 390
 391 int SerializableList::serializeImpl(SerializeBuffer *b){
 392   for (vector<Pentry>::iterator it=list.begin();it<list.end();it++) {
 393     switch((*it).ptype){
 394       case TUSHORT:
 395         if (b->encodeShort(*(*it).ptr.pshort) != 0) return -1;
 396         break;
 397       case TULONG:
 398         if (b->encodeLong(*(*it).ptr.plong) != 0) return -1;
 399         break;
 400       case TULLONG:
 401         if (b->encodeLongLong(*(*it).ptr.pllong) != 0) return -1;
 402         break;
 403       case TCHAR:
 404         if (b->encodeString(*(*it).ptr.pchar) != 0) return -1;
 405         break;
 406       case TSER:
 407         if ((*it).ptr.pser->serialize(b) != 0) return -1;
 408         break;
 409       case TUNKNOWN:
 410         break;
 411     }
 412   }
 413   return 0;
 414 }
 415
 416 int SerializableList::deserializeImpl(SerializeBuffer *b){
 417   ULONG dlen=0;
 418   for (vector<Pentry>::iterator it=list.begin();it<list.end();it++) {
 419     if ((*it).version > version) {
 420       //OK - we received an older version - stop here
 421       break;
 422     }
 423     switch((*it).ptype){
 424       case TUSHORT:
 425         if (b->decodeShort(*(*it).ptr.pshort) != 0) return -1;
 426         break;
 427       case TULONG:
 428         if (b->decodeLong(*(*it).ptr.plong) != 0) return -1;
 429         break;
 430       case TULLONG:
 431         if (b->decodeLongLong(*(*it).ptr.pllong) != 0) return -1;
 432         break;
 433       case TCHAR:
 434         if (b->decodeString(dlen,*(*it).ptr.pchar) != 0) return -1;
 435         break;
 436       case TSER:
 437         if ((*it).ptr.pser->deserialize(b) != 0) return -1;
 438         break;
 439       case TUNKNOWN:
 440         break;
 441     }
 442     (*it).isDeserialized=true;
 443   }
 444   return 0;
 445 }
 446
 447