KeySerialize.cc

Go to the documentation of this file.
00001 /*
00002  *    Copyright 2006 Intel Corporation
00003  * 
00004  *    Licensed under the Apache License, Version 2.0 (the "License");
00005  *    you may not use this file except in compliance with the License.
00006  *    You may obtain a copy of the License at
00007  * 
00008  *        http://www.apache.org/licenses/LICENSE-2.0
00009  * 
00010  *    Unless required by applicable law or agreed to in writing, software
00011  *    distributed under the License is distributed on an "AS IS" BASIS,
00012  *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
00013  *    See the License for the specific language governing permissions and
00014  *    limitations under the License.
00015  */
00016 
00017 #include "KeySerialize.h"
00018 
00019 namespace oasys {
00020 
00022 KeyMarshal::KeyMarshal(ExpandableBuffer* buf,
00023                        const char*       border)
00024     : SerializeAction(Serialize::MARSHAL, Serialize::CONTEXT_LOCAL),
00025       buf_(buf),
00026       border_(border)
00027 {}
00028     
00030 void 
00031 KeyMarshal::process(const char* name,
00032                     u_int64_t*  i)
00033 {
00034     (void)name;
00035     process_int64(*i, 16, "%16x");
00036     border();
00037 }
00038 
00040 void 
00041 KeyMarshal::process(const char* name,
00042                     u_int32_t*  i)
00043 {
00044     (void)name;
00045     process_int(*i, 8, "%08x");
00046     border();
00047 }
00048 
00050 void 
00051 KeyMarshal::process(const char* name,
00052                     u_int16_t*  i)
00053 {
00054     (void)name;
00055     process_int(*i, 4, "%04x");
00056     border();
00057 }
00058 
00060 void 
00061 KeyMarshal::process(const char* name,
00062                     u_int8_t*   i)
00063 {
00064     (void)name;
00065     process_int(*i, 2, "%02x");
00066     border();
00067 }
00068 
00070 void 
00071 KeyMarshal::process(const char* name,
00072                     bool*       b)
00073 {
00074     (void)name;
00075     process_int( (*b) ? 1 : 0, 1, "%1u");
00076     border();
00077 }
00078 
00080 void 
00081 KeyMarshal::process(const char* name,
00082                     u_char*     bp,
00083                     u_int32_t   len)
00084 {
00085     (void)name;
00086     if (error()) 
00087         return;
00088 
00089     buf_->reserve(buf_->len() + len);
00090     memcpy(buf_->end(), bp, len);
00091     buf_->set_len(buf_->len() + len);
00092     border();
00093 }
00094 
00096 void 
00097 KeyMarshal::process(const char* name,
00098                     u_char**    bp,
00099                     u_int32_t*  lenp,
00100                     int         flags)
00101 {
00102     (void)name;
00103     if (error()) 
00104         return;
00105 
00106     ASSERT(! (lenp == 0 && ! (flags & Serialize::NULL_TERMINATED)));
00107 
00108     u_int32_t len;
00109     if (flags & Serialize::NULL_TERMINATED) {
00110         len = strlen(reinterpret_cast<char*>(*bp));
00111     } else {
00112         len = *lenp;
00113     }
00114 
00115     process_int(len, 8, "%08x");
00116 
00117     buf_->reserve(buf_->len() + len);
00118     memcpy(buf_->end(), *bp, len);
00119     buf_->set_len(buf_->len() + len);
00120     border();
00121 }
00122 
00124 void 
00125 KeyMarshal::process(const char*  name,
00126                     std::string* s)
00127 {
00128     (void)name;
00129     if (error()) 
00130         return;
00131 
00132     process_int(s->length(), 8, "%08x");
00133     buf_->reserve(buf_->len() + s->size());
00134     memcpy(buf_->end(), s->c_str(), s->size());
00135     buf_->set_len(buf_->len() + s->size());
00136     border();
00137 }
00138 
00140 void 
00141 KeyMarshal::process(const char*         name,
00142                     SerializableObject* object)
00143 {
00144     (void)name;
00145     if (error()) 
00146         return;
00147 
00148     int err = action(object);
00149     if (err != 0) {
00150         signal_error();
00151     }
00152     border();
00153 }
00154 
00156 void
00157 KeyMarshal::end_action()
00158 {
00159     buf_->reserve(1);
00160     *(buf_->end()) = '\0';
00161 }
00162 
00164 void
00165 KeyMarshal::process_int(u_int32_t i, u_int32_t size, const char* format)
00166 {
00167     if (error()) 
00168         return;
00169 
00170     buf_->reserve(buf_->len() + size + 1);
00171     int cc = snprintf(buf_->end(), size + 1, format, i);
00172     ASSERT(cc == (int)size);
00173     buf_->set_len(buf_->len() + size);
00174 }
00175 
00177 void
00178 KeyMarshal::process_int64(u_int64_t i, u_int32_t size, const char* format)
00179 {
00180     if (error()) 
00181         return;
00182 
00183     buf_->reserve(buf_->len() + size + 1);
00184     int cc = snprintf(buf_->end(), size + 1, format, i);
00185     ASSERT(cc == (int)size);
00186     buf_->set_len(buf_->len() + size);
00187 }
00188 
00190 void
00191 KeyMarshal::border()
00192 {
00193     if (error() || border_ == 0) {
00194         return;
00195     }
00196 
00197     u_int32_t border_len = strlen(border_);
00198     buf_->reserve(border_len);
00199     memcpy(buf_->end(), border_, border_len);
00200     buf_->set_len(buf_->len() + border_len);
00201 }
00202 
00204 KeyUnmarshal::KeyUnmarshal(const char* buf,
00205                            u_int32_t   buf_len,
00206                            const char* border)
00207     : SerializeAction(Serialize::UNMARSHAL, Serialize::CONTEXT_LOCAL),
00208       buf_(buf),
00209       buf_len_(buf_len),
00210       border_len_( (border == 0) ? 0 : strlen(border)),
00211       cur_(0)
00212 {}
00213 
00215 void 
00216 KeyUnmarshal::process(const char* name, u_int64_t* i)
00217 {
00218     (void)name;
00219     u_int64_t val = process_int64();
00220     if (! error()) {
00221         *i = val;
00222     }
00223     border();
00224 }
00225 
00227 void 
00228 KeyUnmarshal::process(const char* name, u_int32_t* i)
00229 {
00230     (void)name;
00231     u_int32_t val = process_int(8);
00232     if (! error()) {
00233         *i = val;
00234     }
00235     border();
00236 }
00237 
00239 void 
00240 KeyUnmarshal::process(const char* name, u_int16_t* i)
00241 {
00242     (void)name;
00243     u_int16_t val = static_cast<u_int16_t>(process_int(4));
00244     if (! error()) {
00245         *i = val;
00246     }
00247     border();
00248 }
00249 
00251 void 
00252 KeyUnmarshal::process(const char* name, u_int8_t* i)
00253 {
00254     (void)name;
00255     u_int8_t val = static_cast<u_int8_t>(process_int(2));
00256     if (! error()) {
00257         *i = val;
00258     }
00259     border();
00260 }
00261 
00263 void 
00264 KeyUnmarshal::process(const char* name, bool* b)
00265 {
00266     (void)name;
00267     if (error()) {
00268         return;
00269     }
00270 
00271     if (cur_ + 1 > buf_len_) {
00272         signal_error();
00273         return;
00274     }
00275     
00276     *b = (buf_[cur_] == '1') ? true : false;
00277     cur_ += 1;
00278     border();
00279 }
00280 
00282 void 
00283 KeyUnmarshal::process(const char* name, u_char* bp, u_int32_t len)
00284 {
00285     (void)name;
00286     if (error()) {
00287         return;
00288     }
00289 
00290     if (cur_ + len > buf_len_) {
00291         signal_error();
00292         return;
00293     }
00294 
00295     memcpy(bp, &buf_[cur_], len);
00296     cur_ += len;
00297     border();
00298 }
00299 
00301 void 
00302 KeyUnmarshal::process(const char* name, u_char** bp, 
00303                       u_int32_t* lenp, int flags)
00304 {
00305     (void)name;
00306     if (error()) {
00307         return;
00308     }
00309 
00310     u_int32_t len = process_int(8);
00311     if (error()) {
00312         return;
00313     }
00314     
00315     if (flags & Serialize::ALLOC_MEM) {
00316         u_int32_t malloc_len = (flags & Serialize::NULL_TERMINATED) ? 
00317                             len + 1 : len;
00318         *bp = static_cast<u_char*>(malloc(malloc_len));
00319         if (*bp == 0) {
00320             signal_error();
00321             return;
00322         }
00323     }
00324 
00325     ASSERT(*bp);
00326     if (lenp) {
00327         *lenp = len;
00328     }
00329     
00330     if (cur_ + len > buf_len_) {
00331         signal_error();
00332         return;
00333     }
00334 
00335     if (flags & Serialize::NULL_TERMINATED) {
00336         memcpy(*bp, &buf_[cur_], len);
00337         (*bp)[len] = '\0';
00338     } else {
00339         memcpy(*bp, &buf_[cur_], len);
00340     }
00341     
00342     cur_ += len;
00343     border();
00344 }
00345 
00347 void 
00348 KeyUnmarshal::process(const char* name, std::string* s) 
00349 {
00350     (void)name;
00351     if (error()) {
00352         return;
00353     }
00354 
00355     u_int32_t len = process_int(8);
00356     if (error()) {
00357         return;
00358     }
00359 
00360     s->assign(&buf_[cur_], len);
00361     cur_ += len;
00362     border();
00363 }
00364 
00366 void 
00367 KeyUnmarshal::process(const char* name, SerializableObject* object)
00368 {
00369     (void)name;
00370     if (error()) {
00371         return;
00372     }
00373 
00374     if (action(object) != 0) {
00375         signal_error();
00376     }
00377     border();
00378 }
00379 
00381 u_int32_t
00382 KeyUnmarshal::process_int(u_int32_t size)
00383 {
00384     char buf[9];
00385 
00386     if (cur_ + size > buf_len_) {
00387         signal_error();
00388         return 0;
00389     }
00390 
00391     memset(buf, 0, 9);
00392     memcpy(buf, &buf_[cur_], size);
00393     
00394     char* endptr;
00395     u_int32_t val = strtoul(buf, &endptr, 16);
00396     
00397     if (endptr == &buf_[cur_]) {
00398         signal_error();
00399         return 0;
00400     }
00401 
00402     cur_ += size;
00403 
00404     return val;
00405 }
00406 
00408 u_int64_t
00409 KeyUnmarshal::process_int64()
00410 {
00411     u_int32_t size = 16;
00412     char buf[32];
00413 
00414     if (cur_ + size > buf_len_) {
00415         signal_error();
00416         return 0;
00417     }
00418 
00419     memset(buf, 0, 32);
00420     memcpy(buf, &buf_[cur_], size);
00421     
00422     char* endptr;
00423     u_int64_t val = strtoull(buf, &endptr, 16);
00424     
00425     if (endptr == &buf_[cur_]) {
00426         signal_error();
00427         return 0;
00428     }
00429 
00430     cur_ += size;
00431 
00432     return val;
00433 }
00434 
00436 void
00437 KeyUnmarshal::border()
00438 {
00439     cur_ += border_len_;
00440 }
00441 
00442 } // namespace oasys

Generated on Thu Jun 7 16:56:50 2007 for DTN Reference Implementation by  doxygen 1.5.1