00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022 #ifdef HAVE_CONFIG_H
00023 # include <dtn-config.h>
00024 #endif
00025
00026 #include <oasys/debug/Log.h>
00027
00028 #include "MetadataBlock.h"
00029 #include "MetadataBlockProcessor.h"
00030
00031 namespace dtn {
00032
00033 unsigned int MetadataBlock::index_ = 0;
00034
00035
00036 MetadataBlock::MetadataBlock(u_int64_t type, u_char* buf, u_int32_t len):
00037 lock_("MetadataBlock"), id_(MetadataBlock::get_next_index()),
00038 block_(NULL), generated_(true), error_(false),
00039 source_id_(0), source_(false), flags_(0),
00040 ontology_(type), metadata_(NULL), metadata_len_(0)
00041 {
00042 if (len > 0) {
00043 ASSERT(buf != NULL);
00044 metadata_ = new u_char[len];
00045 memcpy(metadata_, buf, len);
00046 metadata_len_ = len;
00047 }
00048 }
00049
00050
00051 MetadataBlock::MetadataBlock(unsigned int source_id, u_int64_t type,
00052 u_char* buf, u_int32_t len):
00053 lock_("MetadataBlock"), id_(MetadataBlock::get_next_index()),
00054 block_(NULL), generated_(true), error_(false),
00055 source_id_(source_id), source_(true), flags_(0),
00056 ontology_(type), metadata_(NULL), metadata_len_(0)
00057 {
00058 if (len > 0) {
00059 ASSERT(buf != NULL);
00060 metadata_ = new u_char[len];
00061 memcpy(metadata_, buf, len);
00062 metadata_len_ = len;
00063 }
00064 }
00065
00066
00067 MetadataBlock::MetadataBlock(const MetadataBlock& copy):
00068 BP_Local(copy),
00069 oasys::SerializableObject(copy),
00070 lock_("MetadataBlock"), id_(copy.id_), block_(copy.block_),
00071 generated_(copy.generated_), error_(copy.error_),
00072 source_id_(copy.source_id_), source_(copy.source_),
00073 ontology_(copy.ontology_), metadata_(NULL),
00074 metadata_len_(0)
00075 {
00076 if (copy.generated_ && (copy.metadata_len_ > 0)) {
00077 ASSERT(copy.metadata_ != NULL);
00078 metadata_ = new u_char[copy.metadata_len_];
00079 memcpy(metadata_, copy.metadata_, copy.metadata_len_);
00080 metadata_len_ = copy.metadata_len_;
00081
00082 } else {
00083 metadata_ = copy.metadata_;
00084 metadata_len_ = copy.metadata_len_;
00085 }
00086 }
00087
00088
00089 MetadataBlock::~MetadataBlock()
00090 {
00091 outgoing_metadata_.clear();
00092 if (generated_ && (metadata_ != NULL)) {
00093 delete[] metadata_;
00094 metadata_ = NULL;
00095 metadata_len_ = 0;
00096 }
00097 }
00098
00099
00100 void
00101 MetadataBlock::set_flags(u_int64_t flags)
00102 {
00103 ASSERT(generated_);
00104 flags_ = flags;
00105 }
00106
00107
00108 void
00109 MetadataBlock::set_metadata(u_char *buf, u_int32_t len)
00110 {
00111 ASSERT(!generated_);
00112
00113 if (len > 0) {
00114 ASSERT(buf != NULL);
00115 metadata_ = buf;
00116 metadata_len_ = len;
00117 } else {
00118 metadata_ = NULL;
00119 metadata_len_ = 0;
00120 }
00121 }
00122
00123
00124 bool
00125 MetadataBlock::remove_outgoing_metadata(const LinkRef& link)
00126 {
00127 static const char* log = "/dtn/bundle/protocol";
00128
00129 if (has_outgoing_metadata(link)) {
00130 log_err_p(log, "MetadataBlock::remove_outgoing_metadata: "
00131 "outgoing metadata already exists for link");
00132 return false;
00133 }
00134
00135 outgoing_metadata_.push_back(OutgoingMetadata(link));
00136 return true;
00137 }
00138
00139
00140 bool
00141 MetadataBlock::modify_outgoing_metadata(const LinkRef& link,
00142 u_char* buf, u_int32_t len)
00143 {
00144 static const char* log = "/dtn/bundle/protocol";
00145
00146 if (has_outgoing_metadata(link)) {
00147 log_err_p(log, "MetadataBlock::modify_outgoing_metadata: "
00148 "outgoing metadata already exists for link");
00149 return false;
00150 }
00151
00152 outgoing_metadata_.push_back(OutgoingMetadata(link, buf, len));
00153 return true;
00154 }
00155
00156
00157 bool
00158 MetadataBlock::metadata_removed(const LinkRef& link)
00159 {
00160 OutgoingMetadata* metadata = find_outgoing_metadata(link);
00161 if (metadata == NULL) {
00162 return false;
00163 }
00164
00165 return (metadata->remove());
00166 }
00167
00168
00169 bool
00170 MetadataBlock::metadata_modified(const LinkRef& link)
00171 {
00172 OutgoingMetadata* metadata = find_outgoing_metadata(link);
00173 if ((metadata == NULL) || metadata->remove()) {
00174 return false;
00175 }
00176 return true;
00177 }
00178
00179
00180 bool
00181 MetadataBlock::metadata_modified(const LinkRef& link,
00182 u_char** buf, u_int32_t& len)
00183 {
00184 OutgoingMetadata* outgoing = find_outgoing_metadata(link);
00185 if ((outgoing == NULL) || outgoing->remove()) {
00186 return false;
00187 }
00188
00189 *buf = outgoing->metadata();
00190 len = outgoing->metadata_len();
00191 return true;
00192 }
00193
00194
00195 void
00196 MetadataBlock::delete_outgoing_metadata(const LinkRef& link)
00197 {
00198 std::vector<OutgoingMetadata>::iterator iter = outgoing_metadata_.begin();
00199 for ( ; iter != outgoing_metadata_.end(); ++iter) {
00200 if (iter->link() == link) {
00201 outgoing_metadata_.erase(iter);
00202 return;
00203 }
00204 }
00205 }
00206
00207
00208 void
00209 MetadataBlock::operator=(const MetadataBlock& copy)
00210 {
00211 if (© == this) {
00212 return;
00213 }
00214
00215 outgoing_metadata_.clear();
00216 if (generated_ && (metadata_ != NULL)) {
00217 delete[] metadata_;
00218 metadata_ = NULL;
00219 metadata_len_ = 0;
00220 }
00221
00222 id_ = copy.id_;
00223 block_ = copy.block_;
00224 generated_ = copy.generated_;
00225 error_ = copy.error_;
00226 ontology_ = copy.ontology_;
00227
00228 if (copy.generated_ && (copy.metadata_len_ > 0)) {
00229 ASSERT(copy.metadata_ != NULL);
00230 metadata_ = new u_char[copy.metadata_len_];
00231 memcpy(metadata_, copy.metadata_, copy.metadata_len_);
00232 metadata_len_ = copy.metadata_len_;
00233
00234 } else {
00235 metadata_ = copy.metadata_;
00236 metadata_len_ = copy.metadata_len_;
00237 }
00238 }
00239
00240
00241 MetadataBlock::OutgoingMetadata *
00242 MetadataBlock::find_outgoing_metadata(const LinkRef& link)
00243 {
00244 std::vector<OutgoingMetadata>::iterator iter = outgoing_metadata_.begin();
00245 for ( ; iter != outgoing_metadata_.end(); ++iter) {
00246 if (iter->link() == link) {
00247 return &*iter;
00248 }
00249 }
00250 return NULL;
00251 }
00252
00253
00254 MetadataBlock::OutgoingMetadata::OutgoingMetadata(
00255 const LinkRef& link, u_char* buf, u_int32_t len):
00256 link_(link.object(), "OutgoingMetadata"), remove_(false),
00257 metadata_(NULL), metadata_len_(0)
00258 {
00259 if (len > 0) {
00260 ASSERT(buf != NULL);
00261 metadata_ = new u_char[len];
00262 memcpy(metadata_, buf, len);
00263 metadata_len_ = len;
00264 }
00265 }
00266
00267
00268 MetadataBlock::OutgoingMetadata::OutgoingMetadata(const OutgoingMetadata& copy):
00269 link_(copy.link_.object(), "OutgoingMetadata"), remove_(copy.remove_),
00270 metadata_(NULL), metadata_len_(0)
00271 {
00272 if (copy.metadata_len_ > 0) {
00273 ASSERT(copy.metadata_ != NULL);
00274 metadata_ = new u_char[copy.metadata_len_];
00275 memcpy(metadata_, copy.metadata_, copy.metadata_len_);
00276 metadata_len_ = copy.metadata_len_;
00277 }
00278 }
00279
00280
00281 MetadataBlock::OutgoingMetadata::~OutgoingMetadata()
00282 {
00283 if (metadata_ != NULL) {
00284 delete[] metadata_;
00285 metadata_ = NULL;
00286 metadata_len_ = 0;
00287 }
00288 }
00289
00290
00291 void
00292 MetadataBlock::OutgoingMetadata::operator=(const OutgoingMetadata& copy)
00293 {
00294 if (© == this) {
00295 return;
00296 }
00297
00298 if (metadata_ != NULL) {
00299 delete[] metadata_;
00300 metadata_ = NULL;
00301 metadata_len_ = 0;
00302 }
00303
00304 link_ = copy.link_;
00305 remove_ = copy.remove_;
00306
00307 if (copy.metadata_len_ > 0) {
00308 ASSERT(copy.metadata_ != NULL);
00309 metadata_ = new u_char[copy.metadata_len_];
00310 memcpy(metadata_, copy.metadata_, copy.metadata_len_);
00311 metadata_len_ = copy.metadata_len_;
00312 }
00313 }
00314
00315
00316 LinkMetadataSet::Entry::Entry(const LinkRef& link):
00317 blocks_(NULL), link_(link.object(), "LinkMetadataSet::Entry")
00318 {
00319 }
00320
00321
00322 LinkMetadataSet::~LinkMetadataSet()
00323 {
00324 for (iterator iter = entries_.begin(); iter != entries_.end(); ++iter) {
00325 delete iter->blocks_;
00326 iter->blocks_ = NULL;
00327 }
00328 }
00329
00330
00331 MetadataVec*
00332 LinkMetadataSet::create_blocks(const LinkRef& link)
00333 {
00334 ASSERT(find_blocks(link) == NULL);
00335 entries_.push_back(Entry(link));
00336 entries_.back().blocks_ =
00337 new MetadataVec(std::string("metadata for link ") +
00338 ((link == NULL) ? "(null link)" : link->name()));
00339 return entries_.back().blocks_;
00340 }
00341
00342
00343 MetadataVec*
00344 LinkMetadataSet::find_blocks(const LinkRef& link) const
00345 {
00346 for (const_iterator iter = entries_.begin();
00347 iter != entries_.end(); ++iter) {
00348 if (iter->link_ == link) {
00349 return iter->blocks_;
00350 }
00351 }
00352 return NULL;
00353 }
00354
00355
00356 void
00357 LinkMetadataSet::delete_blocks(const LinkRef& link)
00358 {
00359 for (iterator iter = entries_.begin(); iter != entries_.end(); ++iter) {
00360 if (iter->link_ == link) {
00361 delete iter->blocks_;
00362 iter->blocks_ = NULL;
00363 entries_.erase(iter);
00364 return;
00365 }
00366 }
00367 }
00368
00369 }