00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023
00024
00025
00026
00027
00028
00029
00030
00031
00032
00033
00034
00035
00036
00037
00038
00039
00040
00041
00042
00043
00044
00045
00046
00047
00048
00049
00050
00051
00052
00053
00054
00055
00056
00057
00058 #ifndef sr_hdr_h
00059 #define sr_hdr_h
00060
00061 #include <assert.h>
00062
00063 #include <packet.h>
00064
00065 #define SR_HDR_SZ 4 // size of constant part of hdr
00066
00067 #define MAX_SR_LEN 16 // longest source route we can handle
00068 #define MAX_ROUTE_ERRORS 3 // how many route errors can fit in one pkt?
00069
00070 struct sr_addr {
00071 int addr_type;
00072 nsaddr_t addr;
00073
00074
00075
00076
00077 double Pt_;
00078 };
00079
00080 struct link_down {
00081 int addr_type;
00082 nsaddr_t tell_addr;
00083 nsaddr_t from_addr;
00084 nsaddr_t to_addr;
00085 };
00086
00087
00088
00089
00090
00091 struct route_request {
00092 int req_valid_;
00093 int req_id_;
00094 int req_ttl_;
00095 };
00096
00097 struct route_reply {
00098 int rep_valid_;
00099 int rep_rtlen_;
00100 struct sr_addr rep_addrs_[MAX_SR_LEN];
00101 };
00102
00103 struct route_error {
00104 int err_valid_;
00105 int err_count_;
00106 struct link_down err_links_[MAX_ROUTE_ERRORS];
00107 };
00108
00109
00110
00111
00112
00113 struct flow_error {
00114 nsaddr_t flow_src;
00115 nsaddr_t flow_dst;
00116 u_int16_t flow_id;
00117 };
00118
00119 struct flow_header {
00120 int flow_valid_;
00121 int hopCount_;
00122 unsigned short flow_id_;
00123 };
00124
00125 struct flow_timeout {
00126 int flow_timeout_valid_;
00127 unsigned long timeout_;
00128 };
00129
00130 struct flow_unknown {
00131 int flow_unknown_valid_;
00132 int err_count_;
00133 struct flow_error err_flows_[MAX_ROUTE_ERRORS];
00134 };
00135
00136
00137 struct flow_default_err {
00138 int flow_default_valid_;
00139 int err_count_;
00140 struct flow_error err_flows_[MAX_ROUTE_ERRORS];
00141 };
00142
00143
00144
00145
00146 class hdr_sr {
00147 private:
00148 int valid_;
00149
00150 int salvaged_;
00151
00152 int num_addrs_;
00153 int cur_addr_;
00154 struct sr_addr addrs_[MAX_SR_LEN];
00155
00156 struct route_request sr_request_;
00157 struct route_reply sr_reply_;
00158 struct route_error sr_error_;
00159
00160 struct flow_header sr_flow_;
00161 struct flow_timeout sr_ftime_;
00162 struct flow_unknown sr_funk_;
00163 struct flow_default_err sr_fdef_unk;
00164
00165 public:
00166 static int offset_;
00167 inline int& offset() { return offset_; }
00168 inline static hdr_sr* access(const Packet* p) {
00169 return (hdr_sr*)p->access(offset_);
00170 }
00171 inline int& valid() { return valid_; }
00172 inline int& salvaged() { return salvaged_; }
00173 inline int& num_addrs() { return num_addrs_; }
00174 inline int& cur_addr() { return cur_addr_; }
00175
00176 inline int valid() const { return valid_; }
00177 inline int salvaged() const { return salvaged_; }
00178 inline int num_addrs() const { return num_addrs_; }
00179 inline int cur_addr() const { return cur_addr_; }
00180 inline struct sr_addr* addrs() { return addrs_; }
00181
00182 inline int& route_request() {return sr_request_.req_valid_; }
00183 inline int& rtreq_seq() {return sr_request_.req_id_; }
00184 inline int& max_propagation() {return sr_request_.req_ttl_; }
00185
00186 inline int& route_reply() {return sr_reply_.rep_valid_; }
00187 inline int& route_reply_len() {return sr_reply_.rep_rtlen_; }
00188 inline struct sr_addr* reply_addrs() {return sr_reply_.rep_addrs_; }
00189
00190 inline int& route_error() {return sr_error_.err_valid_; }
00191 inline int& num_route_errors() {return sr_error_.err_count_; }
00192 inline struct link_down* down_links() {return sr_error_.err_links_; }
00193
00194
00195 inline int &flow_header() { return sr_flow_.flow_valid_; }
00196 inline u_int16_t &flow_id() { return sr_flow_.flow_id_; }
00197 inline int &hopCount() { return sr_flow_.hopCount_; }
00198
00199 inline int &flow_timeout() { return sr_ftime_.flow_timeout_valid_; }
00200 inline unsigned long &flow_timeout_time() { return sr_ftime_.timeout_; }
00201
00202 inline int &flow_unknown() { return sr_funk_.flow_unknown_valid_; }
00203 inline int &num_flow_unknown() { return sr_funk_.err_count_; }
00204 inline struct flow_error *unknown_flows() { return sr_funk_.err_flows_; }
00205
00206 inline int &flow_default_unknown() { return sr_fdef_unk.flow_default_valid_; }
00207 inline int &num_default_unknown() { return sr_fdef_unk.err_count_; }
00208 inline struct flow_error *unknown_defaults() { return sr_fdef_unk.err_flows_; }
00209
00210 inline int size() {
00211 int sz = 0;
00212 if (num_addrs_ || route_request() ||
00213 route_reply() || route_error() ||
00214 flow_timeout() || flow_unknown() || flow_default_unknown())
00215 sz += SR_HDR_SZ;
00216
00217 if (num_addrs_) sz += 4 * (num_addrs_ - 1);
00218 if (route_reply()) sz += 5 + 4 * route_reply_len();
00219 if (route_request()) sz += 8;
00220 if (route_error()) sz += 16 * num_route_errors();
00221 if (flow_timeout()) sz += 4;
00222 if (flow_unknown()) sz += 14 * num_flow_unknown();
00223 if (flow_default_unknown()) sz += 12 * num_default_unknown();
00224
00225 if (flow_header()) sz += 4;
00226
00227 sz = ((sz+3)&(~3));
00228 assert(sz >= 0);
00229 #if 0
00230 printf("Size: %d (%d %d %d %d %d %d %d %d %d)\n", sz,
00231 (num_addrs_ || route_request() ||
00232 route_reply() || route_error() ||
00233 flow_timeout() || flow_unknown() ||
00234 flow_default_unknown()) ? SR_HDR_SZ : 0,
00235 num_addrs_ ? 4 * (num_addrs_ - 1) : 0,
00236 route_reply() ? 5 + 4 * route_reply_len() : 0,
00237 route_request() ? 8 : 0,
00238 route_error() ? 16 * num_route_errors() : 0,
00239 flow_timeout() ? 4 : 0,
00240 flow_unknown() ? 14 * num_flow_unknown() : 0,
00241 flow_default_unknown() ? 12 * num_default_unknown() : 0,
00242 flow_header() ? 4 : 0);
00243 #endif
00244
00245 return sz;
00246 }
00247
00248
00249
00250 inline nsaddr_t& get_next_addr() {
00251 assert(cur_addr_ < num_addrs_);
00252 return (addrs_[cur_addr_ + 1].addr);
00253 }
00254
00255 inline int& get_next_type() {
00256 assert(cur_addr_ < num_addrs_);
00257 return (addrs_[cur_addr_ + 1].addr_type);
00258 }
00259
00260 inline void append_addr(nsaddr_t a, int type) {
00261 assert(num_addrs_ < MAX_SR_LEN-1);
00262 addrs_[num_addrs_].addr_type = type;
00263 addrs_[num_addrs_++].addr = a;
00264 }
00265
00266 inline void init() {
00267 valid_ = 1;
00268 salvaged_ = 0;
00269 num_addrs_ = 0;
00270 cur_addr_ = 0;
00271
00272 route_request() = 0;
00273 route_reply() = 0;
00274 route_reply_len() = 0;
00275 route_error() = 0;
00276 num_route_errors() = 0;
00277
00278 flow_timeout() = 0;
00279 flow_unknown() = 0;
00280 flow_default_unknown() = 0;
00281 flow_header() = 0;
00282 }
00283
00284 #if 0
00285 #ifdef DSR_CONST_HDR_SZ
00286
00287
00288 inline int size() {
00289 return SR_HDR_SZ;
00290 }
00291 #else
00292 inline int size() {
00293 int sz = SR_HDR_SZ +
00294 4 * (num_addrs_ - 1) +
00295 4 * (route_reply() ? route_reply_len() : 0) +
00296 8 * (route_error() ? num_route_errors() : 0);
00297 assert(sz >= 0);
00298 return sz;
00299 }
00300 #endif // DSR_CONST_HDR_SZ
00301 #endif // 0
00302
00303 void dump(char *);
00304 char* dump();
00305 };
00306
00307
00308 #endif // sr_hdr_h