00001 #include "KeySerialize.h"
00002
00003 namespace oasys {
00004
00006 KeyMarshal::KeyMarshal(ExpandableBuffer* buf,
00007 const char* border)
00008 : SerializeAction(Serialize::MARSHAL, Serialize::CONTEXT_LOCAL),
00009 buf_(buf),
00010 border_(border)
00011 {}
00012
00014 void
00015 KeyMarshal::process(const char* name,
00016 u_int32_t* i)
00017 {
00018 (void)name;
00019 process_int(*i, 8, "%08x");
00020 border();
00021 }
00022
00024 void
00025 KeyMarshal::process(const char* name,
00026 u_int16_t* i)
00027 {
00028 (void)name;
00029 process_int(*i, 4, "%04x");
00030 border();
00031 }
00032
00034 void
00035 KeyMarshal::process(const char* name,
00036 u_int8_t* i)
00037 {
00038 (void)name;
00039 process_int(*i, 2, "%02x");
00040 border();
00041 }
00042
00044 void
00045 KeyMarshal::process(const char* name,
00046 bool* b)
00047 {
00048 (void)name;
00049 process_int( (*b) ? 1 : 0, 1, "%1u");
00050 border();
00051 }
00052
00054 void
00055 KeyMarshal::process(const char* name,
00056 u_char* bp,
00057 size_t len)
00058 {
00059 (void)name;
00060 if (error())
00061 return;
00062
00063 buf_->reserve(buf_->len() + len);
00064 memcpy(buf_->end(), bp, len);
00065 buf_->set_len(buf_->len() + len);
00066 border();
00067 }
00068
00070 void
00071 KeyMarshal::process(const char* name,
00072 u_char** bp,
00073 size_t* lenp,
00074 int flags)
00075 {
00076 (void)name;
00077 if (error())
00078 return;
00079
00080 ASSERT(! (lenp == 0 && ! (flags & Serialize::NULL_TERMINATED)));
00081
00082 size_t len;
00083 if (flags & Serialize::NULL_TERMINATED) {
00084 len = strlen(reinterpret_cast<char*>(*bp));
00085 } else {
00086 len = *lenp;
00087 }
00088
00089 process_int(len, 8, "%08x");
00090
00091 buf_->reserve(buf_->len() + len);
00092 memcpy(buf_->end(), *bp, len);
00093 buf_->set_len(buf_->len() + len);
00094 border();
00095 }
00096
00098 void
00099 KeyMarshal::process(const char* name,
00100 std::string* s)
00101 {
00102 (void)name;
00103 if (error())
00104 return;
00105
00106 process_int(s->length(), 8, "%08x");
00107 buf_->reserve(buf_->len() + s->size());
00108 memcpy(buf_->end(), s->c_str(), s->size());
00109 buf_->set_len(buf_->len() + s->size());
00110 border();
00111 }
00112
00114 void
00115 KeyMarshal::process(const char* name,
00116 SerializableObject* object)
00117 {
00118 (void)name;
00119 if (error())
00120 return;
00121
00122 int err = action(object);
00123 if (err != 0) {
00124 signal_error();
00125 }
00126 border();
00127 }
00128
00130 void
00131 KeyMarshal::end_action()
00132 {
00133 buf_->reserve(1);
00134 *(buf_->end()) = '\0';
00135 }
00136
00138 void
00139 KeyMarshal::process_int(u_int32_t i, size_t size, const char* format)
00140 {
00141 if (error())
00142 return;
00143
00144 buf_->reserve(buf_->len() + size + 1);
00145 int cc = snprintf(buf_->end(), size + 1, format, i);
00146 ASSERT(cc == (int)size);
00147 buf_->set_len(buf_->len() + size);
00148 }
00149
00150 void
00151 KeyMarshal::border()
00152 {
00153 if (error() || border_ == 0) {
00154 return;
00155 }
00156
00157 size_t border_len = strlen(border_);
00158 buf_->reserve(border_len);
00159 memcpy(buf_->end(), border_, border_len);
00160 buf_->set_len(buf_->len() + border_len);
00161 }
00162
00164 KeyUnmarshal::KeyUnmarshal(const char* buf,
00165 size_t buf_len,
00166 const char* border)
00167 : SerializeAction(Serialize::UNMARSHAL, Serialize::CONTEXT_LOCAL),
00168 buf_(buf),
00169 buf_len_(buf_len),
00170 border_len_( (border == 0) ? 0 : strlen(border)),
00171 cur_(0)
00172 {}
00173
00175 void
00176 KeyUnmarshal::process(const char* name, u_int32_t* i)
00177 {
00178 (void)name;
00179 u_int32_t val = process_int(8);
00180 if (! error()) {
00181 *i = val;
00182 }
00183 border();
00184 }
00185
00187 void
00188 KeyUnmarshal::process(const char* name, u_int16_t* i)
00189 {
00190 (void)name;
00191 u_int16_t val = static_cast<u_int16_t>(process_int(4));
00192 if (! error()) {
00193 *i = val;
00194 }
00195 border();
00196 }
00197
00199 void
00200 KeyUnmarshal::process(const char* name, u_int8_t* i)
00201 {
00202 (void)name;
00203 u_int8_t val = static_cast<u_int8_t>(process_int(2));
00204 if (! error()) {
00205 *i = val;
00206 }
00207 border();
00208 }
00209
00211 void
00212 KeyUnmarshal::process(const char* name, bool* b)
00213 {
00214 (void)name;
00215 if (error()) {
00216 return;
00217 }
00218
00219 if (cur_ + 1 > buf_len_) {
00220 signal_error();
00221 return;
00222 }
00223
00224 *b = (buf_[cur_] == '1') ? true : false;
00225 cur_ += 1;
00226 border();
00227 }
00228
00230 void
00231 KeyUnmarshal::process(const char* name, u_char* bp, size_t len)
00232 {
00233 (void)name;
00234 if (error()) {
00235 return;
00236 }
00237
00238 if (cur_ + len > buf_len_) {
00239 signal_error();
00240 return;
00241 }
00242
00243 memcpy(bp, &buf_[cur_], len);
00244 cur_ += len;
00245 border();
00246 }
00247
00249 void
00250 KeyUnmarshal::process(const char* name, u_char** bp,
00251 size_t* lenp, int flags)
00252 {
00253 (void)name;
00254 if (error()) {
00255 return;
00256 }
00257
00258 size_t len = process_int(8);
00259 if (error()) {
00260 return;
00261 }
00262
00263 if (flags & Serialize::ALLOC_MEM) {
00264 size_t malloc_len = (flags & Serialize::NULL_TERMINATED) ?
00265 len + 1 : len;
00266 *bp = static_cast<u_char*>(malloc(malloc_len));
00267 if (*bp == 0) {
00268 signal_error();
00269 return;
00270 }
00271 }
00272
00273 ASSERT(*bp);
00274 if (lenp) {
00275 *lenp = len;
00276 }
00277
00278 if (cur_ + len > buf_len_) {
00279 signal_error();
00280 return;
00281 }
00282
00283 if (flags & Serialize::NULL_TERMINATED) {
00284 memcpy(*bp, &buf_[cur_], len);
00285 (*bp)[len] = '\0';
00286 } else {
00287 memcpy(*bp, &buf_[cur_], len);
00288 }
00289
00290 cur_ += len;
00291 border();
00292 }
00293
00295 void
00296 KeyUnmarshal::process(const char* name, std::string* s)
00297 {
00298 (void)name;
00299 if (error()) {
00300 return;
00301 }
00302
00303 size_t len = process_int(8);
00304 if (error()) {
00305 return;
00306 }
00307
00308 s->assign(&buf_[cur_], len);
00309 cur_ += len;
00310 border();
00311 }
00312
00314 void
00315 KeyUnmarshal::process(const char* name, SerializableObject* object)
00316 {
00317 (void)name;
00318 if (error()) {
00319 return;
00320 }
00321
00322 if (action(object) != 0) {
00323 signal_error();
00324 }
00325 border();
00326 }
00327
00329 u_int32_t
00330 KeyUnmarshal::process_int(size_t size)
00331 {
00332 char buf[9];
00333
00334 if (cur_ + size > buf_len_) {
00335 signal_error();
00336 return 0;
00337 }
00338
00339 memset(buf, 0, 9);
00340 memcpy(buf, &buf_[cur_], size);
00341
00342 char* endptr;
00343 u_int32_t val = strtoul(buf, &endptr, 16);
00344
00345 if (endptr == &buf_[cur_]) {
00346 signal_error();
00347 return 0;
00348 }
00349
00350 cur_ += size;
00351
00352 return val;
00353 }
00354
00356 void
00357 KeyUnmarshal::border()
00358 {
00359 cur_ += border_len_;
00360 }
00361
00362 }