00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
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 }