00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022 #ifndef WIFI_FRAME_FILTER_ANON_POLICIES_HXX_
00023 # define WIFI_FRAME_FILTER_ANON_POLICIES_HXX_
00024
00025 # include <cstdlib>
00026 # include <memory>
00027
00028 # include <boost/foreach.hpp>
00029 # include <boost/tuple/tuple.hpp>
00030
00031 # include <wipal/wifi/frame/filter/anon_policies.hh>
00032
00033 namespace wifi
00034 {
00035
00036 namespace frame
00037 {
00038
00039 namespace anon
00040 {
00041
00042 namespace internals
00043 {
00044
00045
00046
00047
00048
00049 inline
00050 addr
00051 ppmp_mapping_factory::new_value(const addr& a,
00052 const mac_map& )
00053 {
00054 addr r (a);
00055
00056 if (a != addr::null() and a != addr::broadcast())
00057 {
00058 do
00059 {
00060 for (unsigned i = 3; i < 6; ++i)
00061 r[i] = rand();
00062 }
00063 while (values_.count(r));
00064 }
00065
00066 values_.insert(r);
00067 return r;
00068 }
00069
00070 inline
00071 void
00072 ppmp_mapping_factory::value_loaded(const addr& ,
00073 const addr& a,
00074 const mac_map& )
00075 {
00076 values_.insert(a);
00077 }
00078
00079
00080
00081
00082
00083 inline
00084 ppep_mapping_factory::ppep_mapping_factory(): root_ (new node)
00085 {
00086 }
00087
00088 inline
00089 essid
00090 ppep_mapping_factory::new_value(const essid& e,
00091 const essid_map& )
00092 {
00093 using boost::ref;
00094
00095 std::string r;
00096 node* n;
00097
00098 make_tuple(ref(r), ref(n)) = longest_anonymized_prefix(e);
00099
00100 assert(r.size() <= e.size());
00101 for (size_t i = r.size(); i < e.size(); ++i)
00102 {
00103 char c;
00104
00105 make_tuple(ref(c), ref(n)) = n->add_valued_child(e[i]);
00106 r.push_back(c);
00107 }
00108 return r;
00109 }
00110
00111 inline
00112 void
00113 ppep_mapping_factory::value_loaded(const essid& from,
00114 const essid& to,
00115 const essid_map& )
00116 {
00117 if (from.size() != to.size())
00118 throw std::invalid_argument ("Invalid ESSID mapping");
00119
00120 node* n = root_.get();
00121
00122 for (size_t i = 0; i < from.size(); ++i)
00123 {
00124 assert(n);
00125
00126 const char& c = from[i];
00127 node* const t = n->child(c);
00128
00129 n = t? t: n->add_valued_child(c, to[i]);
00130 }
00131 }
00132
00133 inline
00134 std::pair<std::string, ppep_mapping_factory::node*>
00135 ppep_mapping_factory::
00136 longest_anonymized_prefix(const essid& orig_essid)
00137 {
00138 node* n = root_.get();
00139 std::string r;
00140
00141 BOOST_FOREACH(char c, orig_essid)
00142 {
00143 assert(n);
00144
00145 node* t = n->child(c);
00146
00147 if (not t)
00148 break;
00149 {
00150 const valued_node* const v =
00151 dynamic_cast<const valued_node*>(t);
00152
00153 assert(v);
00154 r.push_back(v->value);
00155 }
00156 n = t;
00157 }
00158 return std::make_pair(r, n);
00159 }
00160
00161 inline
00162 ppep_mapping_factory::node*
00163 ppep_mapping_factory::node::child(unsigned char c)
00164 {
00165 return children_[c].get();
00166 }
00167
00168 inline
00169 std::pair<char, ppep_mapping_factory::node*>
00170 ppep_mapping_factory::node::add_valued_child(unsigned char c)
00171 {
00172 assert(not child(c));
00173
00174 char new_c;
00175
00176 do
00177 new_c = rand_same_class(c);
00178 while (children_values_.count(new_c));
00179
00180 children_[c].reset(new valued_node (new_c));
00181 children_values_.insert(new_c);
00182 return std::make_pair(new_c, child(c));
00183 }
00184
00185 inline
00186 ppep_mapping_factory::node*
00187 ppep_mapping_factory::node::add_valued_child(unsigned char c,
00188 unsigned char v)
00189 {
00190 assert(not child(c));
00191 assert(not children_values_.count(v));
00192
00193 children_[c].reset(new valued_node (v));
00194 children_values_.insert(v);
00195 return child(c);
00196 }
00197
00198 inline
00199 ppep_mapping_factory::node::~node()
00200 {
00201 }
00202
00203 inline
00204 unsigned char
00205 ppep_mapping_factory::node::rand_extended()
00206 {
00207 unsigned char r;
00208
00209 do
00210 r = rand();
00211 while (r < 128);
00212 return r;
00213 }
00214
00215 inline
00216 unsigned char
00217 ppep_mapping_factory::node::rand_alnum()
00218 {
00219 unsigned char r;
00220
00221 do
00222 r = rand();
00223 while (r > 127 or not std::isalnum(r));
00224 return r;
00225 }
00226
00227 inline
00228 unsigned char
00229 ppep_mapping_factory::node::rand_print()
00230 {
00231 unsigned char r;
00232
00233 do
00234 r = rand();
00235 while (r > 127 or std::isalnum(r) or not std::isprint(r));
00236 return r;
00237 }
00238
00239 inline
00240 unsigned char
00241 ppep_mapping_factory::node::rand_other()
00242 {
00243 unsigned char r;
00244
00245 do
00246 r = rand();
00247 while (r > 127 or std::isprint(r));
00248 return r;
00249 }
00250
00251 inline
00252 unsigned char
00253 ppep_mapping_factory::node::rand_same_class(unsigned char c)
00254 {
00255 if (c > 127)
00256 return rand_extended();
00257 if (std::isalnum(c))
00258 return rand_alnum();
00259 if (std::isprint(c))
00260 return rand_print();
00261 return rand_other();
00262 }
00263
00264 inline
00265 ppep_mapping_factory::
00266 valued_node::valued_node(char value): value (value)
00267 {
00268 }
00269
00270 }
00271
00272 }
00273
00274 }
00275
00276 }
00277
00278 #endif // ! WIFI_FRAME_FILTER_ANON_POLICIES_HXX_