IBR-DTNSuite  0.12
NodeHandshake.cpp
Go to the documentation of this file.
1 /*
2  * NodeHandshake.cpp
3  *
4  * Copyright (C) 2011 IBR, TU Braunschweig
5  *
6  * Written-by: Johannes Morgenroth <morgenroth@ibr.cs.tu-bs.de>
7  *
8  * Licensed under the Apache License, Version 2.0 (the "License");
9  * you may not use this file except in compliance with the License.
10  * You may obtain a copy of the License at
11  *
12  * http://www.apache.org/licenses/LICENSE-2.0
13  *
14  * Unless required by applicable law or agreed to in writing, software
15  * distributed under the License is distributed on an "AS IS" BASIS,
16  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
17  * See the License for the specific language governing permissions and
18  * limitations under the License.
19  *
20  */
21 
22 #include "routing/NodeHandshake.h"
23 
24 namespace dtn
25 {
26  namespace routing
27  {
28  NodeHandshake::NodeHandshake()
29  : _type((size_t)HANDSHAKE_INVALID), _lifetime(0)
30  {
31  }
32 
33  NodeHandshake::NodeHandshake(MESSAGE_TYPE type, const dtn::data::Number &lifetime)
34  : _type((size_t)type), _lifetime(lifetime)
35  {
36  }
37 
38  NodeHandshake::~NodeHandshake()
39  {
40  clear();
41  }
42 
43  void NodeHandshake::clear()
44  {
45  for (item_set::const_iterator iter = _items.begin(); iter != _items.end(); ++iter)
46  {
47  delete (*iter);
48  }
49 
50  // clear raw items too
51  _raw_items.clear();
52  }
53 
54  void NodeHandshake::addRequest(const dtn::data::Number &identifier)
55  {
56  _requests.insert(identifier);
57  }
58 
59  bool NodeHandshake::hasRequest(const dtn::data::Number &identifier) const
60  {
61  return (_requests.find(identifier) != _requests.end());
62  }
63 
64  void NodeHandshake::addItem(NodeHandshakeItem *item)
65  {
66  _items.push_back(item);
67  }
68 
69  bool NodeHandshake::hasItem(const dtn::data::Number &identifier) const
70  {
71  for (item_set::const_iterator iter = _items.begin(); iter != _items.end(); ++iter)
72  {
73  const NodeHandshakeItem &item = (**iter);
74  if (item.getIdentifier() == identifier) return true;
75  }
76 
77  return false;
78  }
79 
80  NodeHandshakeItem* NodeHandshake::getItem(const dtn::data::Number &identifier) const
81  {
82  for (item_set::const_iterator iter = _items.begin(); iter != _items.end(); ++iter)
83  {
84  NodeHandshakeItem *item = (*iter);
85  if (item->getIdentifier() == identifier) return item;
86  }
87 
88  return NULL;
89  }
90 
91  NodeHandshake::MESSAGE_TYPE NodeHandshake::getType() const
92  {
93  return NodeHandshake::MESSAGE_TYPE(_type.get<size_t>());
94  }
95 
96  const dtn::data::Number& NodeHandshake::getLifetime() const
97  {
98  return _lifetime;
99  }
100 
101  const std::string NodeHandshake::toString() const
102  {
103  std::stringstream ss;
104 
105  switch (getType()) {
106  case HANDSHAKE_INVALID:
107  ss << "HANDSHAKE_INVALID";
108  break;
109 
110  case HANDSHAKE_REQUEST:
111  ss << "HANDSHAKE_REQUEST";
112  break;
113 
114  case HANDSHAKE_RESPONSE:
115  ss << "HANDSHAKE_RESPONSE";
116  break;
117 
118  default:
119  ss << "HANDSHAKE";
120  break;
121  }
122 
123  ss << "[ttl: " << getLifetime().toString() << ",";
124 
125  if (getType() == NodeHandshake::HANDSHAKE_REQUEST)
126  {
127  for (request_set::const_iterator iter = _requests.begin(); iter != _requests.end(); ++iter)
128  {
129  const dtn::data::Number &item = (*iter);
130  ss << " " << item.toString();
131  }
132  }
133  else if (getType() == NodeHandshake::HANDSHAKE_RESPONSE)
134  {
135  for (item_set::const_iterator iter = _items.begin(); iter != _items.end(); ++iter)
136  {
137  const NodeHandshakeItem &item (**iter);
138  ss << " " << item.getIdentifier().toString();
139  }
140  }
141 
142  ss << "]";
143 
144  return ss.str();
145  }
146 
147  std::ostream& operator<<(std::ostream &stream, const NodeHandshake &hs)
148  {
149  // first the type as SDNV
150  stream << hs._type;
151 
152  if (hs.getType() == NodeHandshake::HANDSHAKE_REQUEST)
153  {
154  // then the number of request items
155  dtn::data::Number number_of_items(hs._requests.size());
156  stream << number_of_items;
157 
158  for (NodeHandshake::request_set::const_iterator iter = hs._requests.begin(); iter != hs._requests.end(); ++iter)
159  {
160  dtn::data::Number req(*iter);
161  stream << req;
162  }
163  }
164  else if (hs.getType() == NodeHandshake::HANDSHAKE_RESPONSE)
165  {
166  // then the lifetime of this data
167  stream << hs._lifetime;
168 
169  // then the number of request items
170  dtn::data::Number number_of_items(hs._items.size());
171  stream << number_of_items;
172 
173  for (NodeHandshake::item_set::const_iterator iter = hs._items.begin(); iter != hs._items.end(); ++iter)
174  {
175  const NodeHandshakeItem &item = (**iter);
176 
177  // first the identifier of the item
178  dtn::data::Number id(item.getIdentifier());
179  stream << id;
180 
181  // then the length of the payload
182  dtn::data::Number len(item.getLength());
183  stream << len;
184 
185  item.serialize(stream);
186  }
187  }
188 
189  return stream;
190  }
191 
192  std::istream& operator>>(std::istream &stream, NodeHandshake &hs)
193  {
194  // clear the node handshake object
195  hs.clear();
196 
197  // first the type as SDNV
198  stream >> hs._type;
199 
200  if (hs.getType() == NodeHandshake::HANDSHAKE_REQUEST)
201  {
202  // then the number of request items
203  dtn::data::Number number_of_items;
204  stream >> number_of_items;
205 
206  for (size_t i = 0; number_of_items > i; ++i)
207  {
208  dtn::data::Number req;
209  stream >> req;
210  hs._requests.insert(req);
211  }
212  }
213  else if (hs.getType() == NodeHandshake::HANDSHAKE_RESPONSE)
214  {
215  // then the lifetime of this data
216  stream >> hs._lifetime;
217 
218  // then the number of request items
219  dtn::data::Number number_of_items;
220  stream >> number_of_items;
221 
222  for (size_t i = 0; number_of_items > i; ++i)
223  {
224  // first the identifier of the item
225  dtn::data::Number id;
226  stream >> id;
227 
228  // then the length of the payload
229  dtn::data::Number len;
230  stream >> len;
231 
232  // add to raw map and create data container
233  //std::stringstream *data = new std::stringstream();
234  std::stringstream &data = hs._raw_items.get(id);
235 
236  // copy data to stringstream
237  ibrcommon::BLOB::copy(data, stream, len.get<std::streamsize>());
238  }
239  }
240 
241  return stream;
242  }
243 
244  NodeHandshake::StreamMap::StreamMap()
245  {
246  }
247 
248  NodeHandshake::StreamMap::~StreamMap()
249  {
250  clear();
251  }
252 
253  bool NodeHandshake::StreamMap::has(const dtn::data::Number &identifier)
254  {
255  stream_map::iterator i = _map.find(identifier);
256  return (i != _map.end());
257  }
258 
259  std::stringstream& NodeHandshake::StreamMap::get(const dtn::data::Number &identifier)
260  {
261  stream_map::iterator i = _map.find(identifier);
262 
263  if (i == _map.end())
264  {
265  std::pair<stream_map::iterator, bool> p =
266  _map.insert(std::pair<dtn::data::Number, std::stringstream* >(identifier, new stringstream()));
267  i = p.first;
268  }
269 
270  return (*(*i).second);
271  }
272 
273  void NodeHandshake::StreamMap::remove(const dtn::data::Number &identifier)
274  {
275  stream_map::iterator i = _map.find(identifier);
276 
277  if (i != _map.end())
278  {
279  delete (*i).second;
280  _map.erase(identifier);
281  }
282  }
283 
284  void NodeHandshake::StreamMap::clear()
285  {
286  for (stream_map::iterator iter = _map.begin(); iter != _map.end(); ++iter)
287  {
288  delete (*iter).second;
289  }
290  _map.clear();
291  }
292 
293  BloomFilterSummaryVector::BloomFilterSummaryVector(const dtn::data::BundleSet &vector)
294  : _vector(vector)
295  {
296  }
297 
298  BloomFilterSummaryVector::BloomFilterSummaryVector()
299  {
300  }
301 
302  BloomFilterSummaryVector::~BloomFilterSummaryVector()
303  {
304  }
305 
306  const dtn::data::Number& BloomFilterSummaryVector::getIdentifier() const
307  {
308  return identifier;
309  }
310 
311  dtn::data::Length BloomFilterSummaryVector::getLength() const
312  {
313  return _vector.getLength();
314  }
315 
316  const dtn::data::BundleSet& BloomFilterSummaryVector::getVector() const
317  {
318  return _vector;
319  }
320 
321  std::ostream& BloomFilterSummaryVector::serialize(std::ostream &stream) const
322  {
323  stream << _vector;
324  return stream;
325  }
326 
327  std::istream& BloomFilterSummaryVector::deserialize(std::istream &stream)
328  {
329  stream >> _vector;
330  return stream;
331  }
332 
333  const dtn::data::Number BloomFilterSummaryVector::identifier = NodeHandshakeItem::BLOOM_FILTER_SUMMARY_VECTOR;
334 
335  BloomFilterPurgeVector::BloomFilterPurgeVector(const dtn::data::BundleSet &vector)
336  : _vector(vector)
337  {
338  }
339 
340  BloomFilterPurgeVector::BloomFilterPurgeVector()
341  {
342  }
343 
344  BloomFilterPurgeVector::~BloomFilterPurgeVector()
345  {
346  }
347 
348  const dtn::data::Number& BloomFilterPurgeVector::getIdentifier() const
349  {
350  return identifier;
351  }
352 
353  dtn::data::Length BloomFilterPurgeVector::getLength() const
354  {
355  return _vector.getLength();
356  }
357 
358  const dtn::data::BundleSet& BloomFilterPurgeVector::getVector() const
359  {
360  return _vector;
361  }
362 
363  std::ostream& BloomFilterPurgeVector::serialize(std::ostream &stream) const
364  {
365  stream << _vector;
366  return stream;
367  }
368 
369  std::istream& BloomFilterPurgeVector::deserialize(std::istream &stream)
370  {
371  stream >> _vector;
372  return stream;
373  }
374 
375  const dtn::data::Number BloomFilterPurgeVector::identifier = NodeHandshakeItem::BLOOM_FILTER_PURGE_VECTOR;
376 
377  } /* namespace routing */
378 } /* namespace dtn */