| /* -*- c++ -*- */ |
| /* |
| * @file |
| * @author Piotr Krysik <ptrkrysik@gmail.com> |
| * @section LICENSE |
| * |
| * Gr-gsm is free software; you can redistribute it and/or modify |
| * it under the terms of the GNU General Public License as published by |
| * the Free Software Foundation; either version 3, or (at your option) |
| * any later version. |
| * |
| * Gr-gsm is distributed in the hope that it will be useful, |
| * but WITHOUT ANY WARRANTY; without even the implied warranty of |
| * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
| * GNU General Public License for more details. |
| * |
| * You should have received a copy of the GNU General Public License |
| * along with gr-gsm; see the file COPYING. If not, write to |
| * the Free Software Foundation, Inc., 51 Franklin Street, |
| * Boston, MA 02110-1301, USA. |
| */ |
| |
| #ifdef HAVE_CONFIG_H |
| #include "config.h" |
| #endif |
| |
| #include <gnuradio/io_signature.h> |
| #include <grgsm/gsmtap.h> |
| #include <unistd.h> |
| #include <map> |
| #include <iterator> |
| #include <algorithm> |
| #include <iostream> |
| #include <endian.h> |
| #include <boost/foreach.hpp> |
| |
| #include "extract_system_info_impl.h" |
| |
| namespace gr { |
| namespace gsm { |
| boost::mutex extract_mutex; |
| void extract_system_info_impl::process_bursts(pmt::pmt_t msg) |
| { |
| pmt::pmt_t burst_plus_header_blob = pmt::cdr(msg); |
| gsmtap_hdr * header = (gsmtap_hdr *)pmt::blob_data(burst_plus_header_blob); |
| |
| chan_info info; |
| info.id = be16toh(header->arfcn); |
| info.pwr_db = header->signal_dbm; |
| |
| boost::mutex::scoped_lock lock(extract_mutex); |
| |
| if(d_c0_channels.find(info.id) != d_c0_channels.end()){ |
| d_c0_channels[info.id].copy_nonzero_elements(info); |
| } else { |
| d_c0_channels[info.id] = info; |
| } |
| } |
| |
| void extract_system_info_impl::process_sysinfo(pmt::pmt_t msg){ |
| pmt::pmt_t message_plus_header_blob = pmt::cdr(msg); |
| uint8_t * message_plus_header = (uint8_t *)pmt::blob_data(message_plus_header_blob); |
| gsmtap_hdr * header = (gsmtap_hdr *)message_plus_header; |
| uint8_t * msg_elements = (uint8_t *)(message_plus_header+sizeof(gsmtap_hdr)); |
| |
| if(msg_elements[2]==0x1b){ |
| chan_info info; |
| info.id = be16toh(header->arfcn); //take arfcn |
| info.pwr_db = header->signal_dbm; |
| info.cell_id = (msg_elements[3]<<8)+msg_elements[4]; //take cell id |
| info.lac = (msg_elements[8]<<8)+msg_elements[9]; //take lac |
| info.mnc = (msg_elements[7]>>4); //take mnc |
| boost::mutex::scoped_lock lock(extract_mutex); |
| if(d_c0_channels.find(info.id) != d_c0_channels.end()){ |
| d_c0_channels[info.id].copy_nonzero_elements(info); |
| } else { |
| d_c0_channels[info.id] = info; |
| } |
| } |
| else if(msg_elements[2]==0x1c){ |
| chan_info info; |
| info.id = be16toh(header->arfcn); //take arfcn |
| info.pwr_db = header->signal_dbm; |
| info.lac = (msg_elements[6]<<8)+msg_elements[7]; //take lac |
| info.mnc = (msg_elements[5]>>4); //take mnc |
| |
| boost::mutex::scoped_lock lock(extract_mutex); |
| if(d_c0_channels.find(info.id) != d_c0_channels.end()){ |
| d_c0_channels[info.id].copy_nonzero_elements(info); |
| } else { |
| d_c0_channels[info.id] = info; |
| } |
| } else if(msg_elements[2]==0x1a){ //System Information Type 2 |
| chan_info info; |
| info.id = be16toh(header->arfcn); //take arfcn |
| info.pwr_db = header->signal_dbm; |
| boost::mutex::scoped_lock lock(extract_mutex); |
| //read neighbour cells |
| decode_neighbour_cells(msg_elements, 3, info.id); |
| // unsigned int byte_nr, arfcn, bit; |
| // arfcn=124; |
| // bit=4; |
| // for (byte_nr = 0; byte_nr <= 15; byte_nr++) { |
| // while (bit-- != 0) { |
| // if (((msg_elements[byte_nr+3] >> bit) & 1) == 1){ |
| // d_c0_channels[info.id].neighbour_cells.insert(arfcn); |
| // } |
| // arfcn--; |
| // } |
| // bit=8; |
| // } |
| |
| if(d_c0_channels.find(info.id) != d_c0_channels.end()){ |
| d_c0_channels[info.id].copy_nonzero_elements(info); |
| } else { |
| d_c0_channels[info.id] = info; |
| } |
| } |
| } |
| |
| void extract_system_info_impl::decode_neighbour_cells(uint8_t * data, unsigned int offset, unsigned int chan_id) |
| { |
| unsigned int curr_offset, byte, bit, arfcn, format; |
| uint8_t oct; |
| curr_offset = offset; |
| format = data[curr_offset]; |
| |
| if ((format & 0xc0) == 0x00) |
| { |
| /* bit map 0 */ |
| bit = 4; |
| arfcn = 125; |
| for (byte = 0; byte <= 15; byte++) |
| { |
| oct = data[curr_offset]; |
| while (bit-- != 0) |
| { |
| arfcn--; |
| if (((oct >> bit) & 1) == 1) |
| { |
| d_c0_channels[chan_id].neighbour_cells.insert(arfcn); |
| } |
| } |
| bit = 8; |
| curr_offset++; |
| } |
| } |
| else if ((format & 0xc8) == 0x80) |
| { |
| /* 1024 range */ |
| // dissect_channel_list_n_range(tvb, tree, pinfo, curr_offset, len, 1024); |
| } |
| else if ((format & 0xce) == 0x88) |
| { |
| /* 512 range */ |
| // dissect_channel_list_n_range(tvb, tree, pinfo, curr_offset, len, 512); |
| } |
| else if ((format & 0xce) == 0x8a) |
| { |
| /* 256 range */ |
| // dissect_channel_list_n_range(tvb, tree, pinfo, curr_offset, len, 256); |
| } |
| else if ((format & 0xce) == 0x8c) |
| { |
| /* 128 range */ |
| // dissect_channel_list_n_range(tvb, tree, pinfo, curr_offset, len, 128); |
| } |
| else if ((format & 0xce) == 0x8e) |
| { |
| /* variable bit map */ |
| arfcn = ((format & 0x01) << 9) | (data[curr_offset+1] << 1) | ((data[curr_offset+2] & 0x80) >> 7); |
| curr_offset = curr_offset + 2; |
| bit = 7; |
| for(byte = 0; byte <= (15-2); byte++){ |
| oct = data[curr_offset]; |
| while (bit-- != 0){ |
| arfcn++; |
| if (((oct >> bit) & 1) == 1){ |
| d_c0_channels[chan_id].neighbour_cells.insert(arfcn); |
| } |
| } |
| bit = 8; |
| curr_offset++; |
| } |
| } |
| |
| return; |
| } |
| |
| // void extract_system_info_impl::dissect_channel_list_n_range(guint32 offset, guint len, gint range) |
| // { |
| // int curr_offset = offset, bit_offset, f0, arfcn_orig, w[64], wsize, i; |
| // int octet, nwi = 1, jwi=0, imax, iused, arfcn; |
| // uint8_t list[1024]; |
| |
| // memset((void*)list,0,sizeof(list)); |
| |
| //// subtree = proto_tree_add_subtree_format(tree,tvb, curr_offset, len, |
| //// ett_gsm_rr_elem[DE_RR_NEIGH_CELL_DESC], NULL, "Range %d format", range); |
| |
| // octet = data[curr_offset]; |
| // if (range == 1024) { |
| // f0 = (octet>>2)&1; |
| // if (f0) |
| // list[0] = 1; |
| // arfcn_orig = 0; |
| // wsize = 10; |
| // imax = 16; |
| // bit_offset = curr_offset*8 + 6; |
| // } |
| // else { |
| // bit_offset = curr_offset*8 + 7; |
| // arfcn_orig = (gint) tvb_get_bits(tvb, bit_offset, 10, FALSE); |
| //// proto_tree_add_bits_item(subtree, hf_n_range_orig_arfcn, tvb, bit_offset, 10, ENC_BIG_ENDIAN); |
| // bit_offset+=10; |
| |
| // list[arfcn_orig] = 1; |
| |
| // switch (range) { |
| // case 512: |
| // wsize=9; |
| // imax = 17; |
| // break; |
| // case 256: |
| // wsize=8; |
| // imax = 21; |
| // break; |
| // case 128: |
| // wsize=7; |
| // imax = 28; |
| // break; |
| // default: |
| //// DISSECTOR_ASSERT_NOT_REACHED(); |
| // } |
| // } |
| // iused = imax; /* in case the list is actually full */ |
| |
| // /* extract the variable size w[] elements */ |
| // for (i=1; i<=imax; i++) { |
| // w[i] = (gint) tvb_get_bits(tvb, bit_offset, wsize, FALSE); |
| //// proto_tree_add_text(subtree, tvb, bit_offset>>3, ((bit_offset+wsize-1)>>3) - (bit_offset>>3) + 1 , "%s %s(%d): %d", |
| //// decode_bits_in_field(bit_offset, wsize, w[i]), |
| //// "W", |
| //// i, |
| //// w[i]); |
| // bit_offset += wsize; |
| // curr_offset = bit_offset>>3; |
| |
| // if ((iused == imax) && (w[i] == 0) ) { |
| // iused = i - 1; |
| // } |
| // if ((curr_offset-offset)>len) { |
| // iused = i - 1; |
| // break; |
| // } |
| // if (++jwi == nwi) { /* check if the number of wi at this wsize has been extracted */ |
| // jwi = 0; /* reset the count of wi at this size */ |
| // nwi <<= 1; /* get twice as many of the next size */ |
| // wsize--; /* make the next size 1 bit smaller */ |
| // } |
| // } |
| |
| // for (i=1; i<=iused; i++) { |
| // arfcn = (f_k(i, w, range) + arfcn_orig)%1024; |
| // list[arfcn] = 1; |
| // } |
| |
| //// display_channel_list(list, tvb, tree, offset, curr_offset-offset); |
| |
| // return; |
| // } |
| |
| std::vector<int> extract_system_info_impl::get_chans() |
| { |
| std::vector<int> chans_ids; |
| BOOST_FOREACH(chan_info_map::value_type &i, d_c0_channels){ |
| chans_ids.push_back(i.second.id); |
| } |
| return chans_ids; |
| } |
| |
| std::vector<int> extract_system_info_impl::get_lac() |
| { |
| std::vector<int> lacs; |
| BOOST_FOREACH(chan_info_map::value_type &i, d_c0_channels){ |
| lacs.push_back(i.second.lac); |
| } |
| return lacs; |
| } |
| |
| std::vector<int> extract_system_info_impl::get_mnc() |
| { |
| std::vector<int> mncs; |
| BOOST_FOREACH(chan_info_map::value_type &i, d_c0_channels){ |
| mncs.push_back(i.second.mnc); |
| } |
| return mncs; |
| } |
| |
| std::vector<int> extract_system_info_impl::get_cell_id() |
| { |
| std::vector<int> cell_ids; |
| BOOST_FOREACH(chan_info_map::value_type &i, d_c0_channels){ |
| cell_ids.push_back(i.second.cell_id); |
| } |
| return cell_ids; |
| } |
| |
| std::vector<int> extract_system_info_impl::get_pwrs() |
| { |
| std::vector<int> pwrs; |
| BOOST_FOREACH(chan_info_map::value_type &i, d_c0_channels){ |
| pwrs.push_back(i.second.pwr_db); |
| } |
| return pwrs; |
| } |
| std::vector<int> extract_system_info_impl::get_neighbours(int chan_id) |
| { |
| std::vector<int> neighbour_cells; |
| BOOST_FOREACH(int n, d_c0_channels[chan_id].neighbour_cells){ |
| neighbour_cells.push_back(n); |
| } |
| return neighbour_cells; |
| } |
| |
| void extract_system_info_impl::reset() |
| { |
| d_c0_channels.clear(); |
| if(!empty_p(pmt::mp("bursts"))){ |
| delete_head_blocking(pmt::mp("bursts")); |
| } |
| if(!empty_p(pmt::mp("msgs"))){ |
| delete_head_blocking(pmt::mp("msgs")); |
| } |
| } |
| |
| extract_system_info::sptr |
| extract_system_info::make() |
| { |
| return gnuradio::get_initial_sptr |
| (new extract_system_info_impl()); |
| } |
| |
| /* |
| * The private constructor |
| */ |
| extract_system_info_impl::extract_system_info_impl() |
| : gr::block("extract_system_info", |
| gr::io_signature::make(0, 0, 0), |
| gr::io_signature::make(0, 0, 0)), |
| after_reset(false) |
| { |
| message_port_register_in(pmt::mp("bursts")); |
| set_msg_handler(pmt::mp("bursts"), boost::bind(&extract_system_info_impl::process_bursts, this, _1)); |
| message_port_register_in(pmt::mp("msgs")); |
| set_msg_handler(pmt::mp("msgs"), boost::bind(&extract_system_info_impl::process_sysinfo, this, _1)); |
| } |
| |
| /* |
| * Our virtual destructor. |
| */ |
| extract_system_info_impl::~extract_system_info_impl() |
| { |
| } |
| |
| |
| } /* namespace gsm */ |
| } /* namespace gr */ |
| |