1. Active
In this case the station nodes send out probe requests to see if any access points respond during a timeout period

2. Passive
In this case the station nodes just sit and listen over a timeout period to see if any aps send out beacons.

In either case, according to the standard, the station node is supposed to rank the APs according to received signal strength (RSS). While this is recognized as a bad method for various reasons – it is a simple and quick way to select an AP.

In NS3 (3.16), as far as I can tell, there is no measure of RSS. The station node simply associates with the first AP that it receives either a probe response or beacon from (depending on active or passive). Usually this ends up being the closest AP to the user station because it has the lowest propagation delay due to the lower distance. However, depending on when the stations start up, a farther station is sometimes selected – at least initially until enough beacons are missed that an AP disassociation occurs, and the process starts over with the closer AP being selected.

In NS 3.16, the code which controls AP association is located in src/wifi/model/sta-wifi-mac.cc.

Looking at the code details, and confirming with some extra logging I added – a Wi-Fi station when starting, broadcasts a probe request (in active probing mode). It then waits for a probe response.

If you look in the “StaWifiMac::Receive (Ptr packet, const WifiMacHeader *hdr)” function, you can see that immediately when it receives one of these responses, it sends an association request to the AP. This is one place where changes must occur if one wishes to make a smarter decision for selecting an AP. In my case, instead of immediately sending an association request, I record the probe response and continue to wait for more until the probe timeout occurs.

If you look at “StaWifiMac::ProbeRequestTimeout (void)” you can see this is where you can now implement the association decision. After the timeout has occured, we now have a list of all of the received probe packets and can make the decision and associate like before.

So anyway, I have completed the document and after several rounds of edits with my advisor it is ready and off to the committee. Here’s hoping I’ll make it to the exam stage this time and pass quickly so I can move on with the real work!

Stay tuned for some posts that are more technical instead of these boring updates on my progress. Now that things are moving along I think I’ll actually have something to post

However, as you can imagine with the home machine in particular the IP is prone to change occasionally since it is given from the ISP using DHCP. So I searched around for some script to be able to change the zone file in Hostmonster since this controls the IP addresses of all my subdomains.

** Of course the obvious and easy way to do this is with some kind of dyndns account, but I’m picky and like to have everything working under my own domain

I was looking for some type of SSH script way to do it, but it looks like there is no easy way to do this, but I found a ruby script here: http://deathwarrior.wordpress.com/ which allows me to do what I want. Unfortunately the script was written a little while ago and some of it needs to be changed a bit to work.

The first part is the required libraries that must be installed. This has changed because the ruby-mechanize library does not seem to be found in the Ubuntu 12.04 repos. This should do the trick though:

sudo apt-get install libwww-mechanize-ruby ruby-json ruby

The other problem is in the ruby script itself. It seems verify_mode does not exist anymore, so just comment that line out. Another problem is the user-agent which does not seem to be found in the version I was using with Ubuntu. So you can change that to “Windows IE 7″ and it should fix it. Here is the code with the changes:

#!/usr/bin/env ruby

require 'mechanize'
require 'json'

USERNAME  = 'MY_USERNAME'
PASSWORD  = 'MY_PASSWD'
DOMAIN    = 'positrones.net'
SUBDOMAIN  = 'my_subdomain'
ADDRESS    = '0.0.0.0' # If nil then try to get automagicaly

URLS = {
      'login'    => 'https://login.hostmonster.com/?',
      'drecords'  => 'https://my.hostmonster.com/cgi/dm/zoneedit/ajax'
    }

USER_AGENT = 'Windows IE 7'

m = Mechanize.new do |a|
  #a.verify_mode = OpenSSL::SSL::VERIFY_NONE
  a.user_agent_alias = USER_AGENT
end

def get_ip
  r = Net::HTTP.get('jasonernst.com', '/ip.php')
  ip = r.match(/\d{1,4}\.\d{1,4}\.\d{1,4}\.\d{1,4}/)

  ip[0].to_s
end

# Do the login stuff
print "Checking user and password... "
page = m.get( URLS['login'] );
form = page.form_with( :name => 'theform' )
form['login'] = USERNAME
form['password'] = PASSWORD
send_button = form.button_with(:value => 'Login')
form.click_button(send_button)
page = page.links[0].click
puts "done!"

# Edit the DNS Zone
page = page.link_with(:text => 'DNS Zone Editor').click
print "Getting old zone records... "
json = JSON.parse( m.post( URLS['drecords'], {'op' => 'getzonerecords', 'domain' => DOMAIN} ).body )
puts "done!"

print "Trying to get subdomain old info... "
json['data'].each do |r|
  if r['name'] == SUBDOMAIN
    print "done!\nSaving new address[#{r['address']} => #{ADDRESS||get_ip}]... "
    json = m.post( URLS['drecords'], {'op'    => 'editzonerecord',
                  'domain'    => DOMAIN,
                  'name'      => SUBDOMAIN,
                  'orig__name'  => SUBDOMAIN,
                  'address'    => ADDRESS||get_ip,
                  'orig__adress'  => r['address'],
                  'ttl'      => r['ttl'],
                  'orig__ttl'    => r['ttl'],
                  'Line'      => r['Line'],
                  'type'      => r['type']}
      )
    json = JSON.parse(json.body)

    if( json['result'] == 1 )
      puts "done!\nAddress changed succesfully!"
      Kernel::exit(0)
    else
      puts "\nAn error has ocurred trying to save new address :("
      Kernel::exit(1)
    end
  end
end

puts "The subdomain #{SUBDOMAIN} cannot be found!"
Kernel::exit(1)

The last thing that should be done is a server page somewhere for this code to find out it’s own IP address. All the page should return is the IP address itself, not any HTML. You can leave the default in the script which will use my IP script, or you can make your own. It’s as simple as this:

<? echo $_SERVER['REMOTE_ADDR']; ?>

And one more thing, if you are so inclined is to add the script as a chronjob. I have mine set to run every hour, but you can do it more or less often according to your preferences.

crontab -e

I named put my script in a /scripts/ folder I made and named it “hostmonster-auto-ip.sh”

So the crontab entry is:

@hourly /scripts/hostmonster-auto-ip.sh

Here are the visits in the last three years (74,000 hits)

And in just the last year (30,000 hits)

The average time on the site remained about the same when looking back one or three years and in both cases is about two minutes.

Here is a world map showing the countries where most of the traffic comes from. The top three were US, India and Canada. The darkest colour represents almost 6000 hits.

The most popular browser with visitors of my site is Firefox, followed by Chrome, IE and Safari. I was a bit surprised that Safari did more poorly than IE, but I guess it can be expected when you see the next figure with OS’s.

The most popular OS’s for my site: Windows, Linux, Mac. This makes me a little sad that Linux wasn’t the highest proportion, given the content of my site…but it was at least respectable.

Lastly, here is the posting frequency. There have been 83 posts total according to the wordpress admin page.

Compared to the rest of the group in the twitter convo, I am probably the most junior being a grad student still (the others are librarians and professors in various stages). The general consensus seems to be that while a forward facing department may consider a blog in their criteria, there are not clear cut rules to support blogs in the process and most people would not include it.

When I get to that stage in my career, however, I’ll try my best to shoehorn it in somehow. I’m of the opinion that any modern academic department should be considering blogs and even social media accounts in the T&P process. These types of things show how engaged an academic is with the public. We need more engaged professors and research students. The general public pays for our work (for the most part) and we should make them aware of what they are paying for.

As mentioned in the twitter conversation, the benefits of blogging and social media alone in terms of connections and collaborations with other researchers end up showing up on the resume anyways with publications and projects. However, I think there is also value in the quality of a blog itself.

As for the less professional posts, I think these also have some value. As long as they aren’t the type someone should be embarrassed about, I think they also still add value. They humanize the professor for the students and the general public and make the professor more approachable. Sometimes its also nice to read these peoples’ opinions on issues outside of their expertise.

My blog has been going for about three or four years now, and while I think the quality of the posts are not as good as the others in the Twitter conversation, it has some value since it has documented some of the journey through grad school, some of the work I’ve done and some of my thoughts that would otherwise just disappeared into the ether. Clearly this is something people are interested in since I regularly get around 2500 hits per month on the site. These types of statistics may be the type of thing to include in T&P files. The number of hits, followers on twitter, retweets, “klout” – all show the level of engagement of the professor. On the other hand, this could just lead to a race to the bottom of constant meaningless social engagement, but I’d still prefer a prof who tweets too much to one who is alone in their bubble.

I’ve had a couple of job interviews with tech companies in California, attended a BB10Jam, released a couple of playbook apps, started on some side research projects at school. So this post is all about talking a bit about each of those things.

Job Interviews in Grad School
If you are like me and don’t like to say no to anything, you’ll probably go along with the whole interview process – just to see where it takes you. Also if you are like me and a busy grad student – you probably will not have time to prepare properly for the interviews. This is probably a big mistake (or maybe not). From my perspective, the technical questions in the interviews went pretty well when they were directly in my areas of expertise. As soon as they meandered to peripheral areas, things got a little ugly. Worse still was the coding questions. While I do try to keep up my skills in this area, grad students (particularly PhD) students in comp sci aren’t always well known for being code monkeys. We spend most of our time reading papers, proposing algorithms and mechanisms for solving problems. We then either 1) Hire an undergraduate student for the programming or 2) Make use of as many open source tools as possible and “macgyver” them into suiting our needs. In the extreme case we may code some specialized tool for what we need as well. So as you can guess, my coding skills were rusty. If I were to prepare in the future, I’d focus on this for as much time as I could before starting the interview processes. But since these interviews all contacted me first, that wasn’t an option.

BB10Jam
Despite all the doom and gloom in Waterloo these days about RIM, I still like to develop apps for the Playbook for a few reasons. 1) RIM lives where I live. 2) I got a free Playbook at a conference. 3) The AppWorld is not saturated with a million of the same type of app yet.

So after developing a couple of apps I noticed they were having a BB10Jam here in Waterloo and went. The event was really good. The people were friendly and nice, and it was much less stuffy than some of the previous RIM events I have attended. Maybe it is a sign things are starting to reverse. Beyond just that though, the platform looks pretty good. I also got a developer device and am working on some apps for it now. The biggest selling point in developing for them right now for BB10 is the $10,000 reward for any app that can make $1,000 in the first year. Also at the event there were many stats showing increasing numbers of developers and apps in the store which all sounds good. Another interesting bit of info was that BB users are more likely to pay for their apps compared to other platforms. All of this makes it increasingly attractive to develop for the platform. So at the end of the BB10Jam I came away pretty excited to get at it. Just need to find the time now!

BB Playbook Apps
If you have read this blog previously, you may noticed something about one of my apps. The first one I made was a telnet application. I had the intention to also include ssh, but have not had the time to include this bit of code yet. The biggest challenge with that app was developing a console library for displaying the text. At the time Cascades was not available yet, and this type of thing was a bit tricky. There’s more info on it here: http://www.jasonernst.com/2012/01/24/opengl-console-library-for-blackberry-native-sdk-playbook/. The app is available here for free on the appworld: http://appworld.blackberry.com/webstore/content/77778/?lang=en

The second app I created is a web server. The inspiration for this was that I wanted to be able to serve images from the camera onto a website hosted on the playbook. This way you can leave your playbook setup as a sort of security camera. So the first step was creating the web-server to serve the content. Right now it just supports serving static content – no php, perl, python etc, but maybe in the future. The next step will be to hook into the camera and serve up a continuously changing image that is polled from the camera regularly. The app is available here: http://appworld.blackberry.com/webstore/content/124979/?lang=en

Side Research Projects
The last thing is the side research projects I have taken on in the past couple of months. I have been collaborating with researchers in the math department on two projects. First is a cognitive agent project. In this project we are interested in the intelligence required for a creature to cross a busy street. The first creatures are oblivious to the conditions in which danger may exist so they cross the road. As some of them are hit, the creatures which follow can observe the conditions and avoid crossing. Eventually they start to learn when it is safe to cross. The focus of the work is the underlying learning mechanisms for this problem.

The second project I am involved in is a vehicular traffic simulation tool. An existing tool was developed several years ago, however there were some shortcomings in the model. The model is based on the Nagel-Schreckenberg traffic model, however the ramps on the highway were only one cell. Because of this limitation, it becomes difficult to properly simulate certain highway configurations such as clover-leaf ramps. My recent work on this project has extended the model to address this limitation.

Another problem may be a lack of co-ordination between radio access technologies (RATs). For instance, while Bluetooth supports adaptive frequency hopping (AFH) to try to avoid the same channels Wi-Fi is being used on, this may not be enough to ensure interference between the technologies is avoided. What happens when you are in a dense area where Wi-Fi is being used across all channels, or there are many devices? (Apartment buildings, dense cities etc.)

As you may know, lots of wireless research is done using simulation because in many cases it is faster and cheaper. Many simulation tools support interference within a particular technology (ie Wi-Fi nodes interfering with other Wi-Fi nodes) but not many support interference between technologies (ie Wi-Fi nodes interfering with Bluetooth nodes). The paper I presented at ICC tries to understand how much of an impact this makes.

I’ll spare most of the details since they are in the paper, but essentially the findings are that Wi-Fi -> Bluetooth interference causes a drop in around 10-15kbps of the total 50kpbs Bluetooth was able to achieve in our lab setup (About 30% drop).

In the other direction, the interference was mostly insignificant. However, this was expected since the setup used close ranges (Wi-Fi power is much greater than that of Bluetooth).

The future work includes looking at varying distances (It seems like it will be interesting when we use a range that makes the Wi-Fi and Bluetooth powers similar). Eventually the goal is to create an interference model that can be used in simulation. If you want more details – see the attached paper and slides.

icc2012 (slides pptx)
icc20122 (paper pdf)

http://askubuntu.com/questions/106568/my-wireless-has-suddenly-became-disabled-by-hardware-switch-bios-rfkill-fnf8

However, for the look I wanted, I wanted to maximize the screen space for the console application to show as much text as possible and worked off the hello world example on the SDK webpage. Essentially, the simple “library” (note: library is used very loosely here) initializes the display, shows the keyboard and supports some simple output using putch and puts functions that I implemented. It can also show a blinking cursor and user input at a prompt. In case someone else can use the code I have made it available. Check back soon to see the source for the telnet portion of the app I made as well or look for it on the App World.

Simple Telnet – Example Application using the conosole library

In order to use the library, you need to make use of the bbutil.c and bbutil.h files that are included in many of the examples provided by RIM. I have provided them here alongside my own code so that it is easier to follow along. I also provide two more files: glconsole.c and glconsole.h. You just need to #include “glconsole.h” in your source in order to use the library. All of the functions available to you are listed in the “glconsole.h” file as well. I will go over the important ones in this article.

First is gl_init(). This function initializes the library, the screen, font etc. This function should be called before using anything else in the library. Similarly, gl_cleanup() is used to free memory and should be called before your app is terminated.

After initialization, you may now use the puts and putch functions to display characters to the screen. gl_putch(char c) takes a single character and displays it onto the screen. It can handle newlines which are represented as ‘\n’ and tabs which are represented as ‘\t’. Backspaces by user input is handled as a ‘\b’ character. This is similar to how people on The osdev.rg website often handle character output in their custom operating systems. I’m not sure how it relates with normal c standards, but I imagine it is similar. Eventually I hope to implement a printf() type of function, but at the moment the putch() and puts() functions serve what I am doing well enough. Note: puts() is the same as putch() but instead takes a (char *) ie) a string. The string should also be null-terminated, or it will just continue until it hits a null character. The characters are automatically scrolled when the bottom of the screen is reached.

The only other really important function is gl_render(). This function is what should be called everytime the screen needs to be refreshed. This is usually in a for loop within your main() function in your app.

It is also possible to resize the screen using the gl_resize() function. By default the screen starts at 80X29 which is the maximum size with no virtualkeyboard showing, at the font size I selected. When the keyboard shows up, it fits 80×14. In some sample code I’ll also show how keyboard input can be handled, how to blink the cursor and how to detect when the keyboard is shown or hidden.

For the rest of this guide, I’ll assume you are using the QNX Momentix IDE available from RIM’s developer website. To start, create a new project by going to File->New Blackberry Tablet OS C/C++ Project. Name it whatever you like, click next. Then choose the C language, and empty Application Project. You can now drag the gl_console.c, glconsole.h, bbutil.c and bbutil.h files into the src folder within the IDE to include them. You will probably want to copy the files and not link them when it asks. Before compiling, there are several libaries which must be linked to the project. You can do this by right clicking your project, going to properties. Then go to C/C++ General->Paths and Symbols->Libraries. Here you can add libraries. Each time you add one, be sure to check “add to all Configurations” so that you don’t need to do this again if you change from a device-debug to device-release build. The following libraries should be included:

• bps
• EGL
• GLESv1_CM
• freetype
• png

Now that all this is setup, it is possible to start you main() function and use the library. If you like you can right click on your src folder and click “new file” and create a main.c file or whatever you like to name it. While this isn’t the typical way you would include a library into a project, this way lets you edit the library source to your liking in case you want to further extend it.

The following example shows a skeleton of what is required to get the code to display some text:

#include <stdlib.h>               /* EXIT_FAILURE */
#include <stddef.h>              /* NULL */
#include <bps/bps.h>           /* BPS_SUCCESS */
#include <bps/screen.h>      /* screen_event_get_event() */
#include <bps/navigator.h>  /* NAVIGATOR_EXIT */
#include "glconsole.h"

void handleScreenEvent(bps_event_t *event);

int main(int argc, char * argv[])
{
  int exit_application = 0;

  if(EXIT_SUCCESS != gl_init())
  {
    fprintf(stderr, "error init\n");
    return 0;
  }

  gl_puts("Hello gl console world!\n");

  for(;;)
  {
    bps_event_t *event = NULL;
    if (bps_get_event(&event, 0) != BPS_SUCCESS)
      return EXIT_FAILURE;

    if (event)
    {
      int domain = bps_event_get_domain(event);

      if (domain == screen_get_domain())
        handleScreenEvent(event);
      else if ((domain == navigator_get_domain()) && (NAVIGATOR_EXIT == bps_event_get_code(event)))
        exit_application = 1;

      if (exit_application)
        break;
    }
    gl_render();
  }

  gl_cleanup();
  return 0;
}

void handleScreenEvent(bps_event_t *event)
{
  /* do normal event handling here, see other bb examples */
}

The key parts are calling gl_init() which initializes the library. Then within the main loop, the gl_render() function should be called which will actually render the text. Finally gl_cleanup() should be called before termination to properly free memory.

In the near future I plan to add some support to handle ansi encoded text (specifically for my telnet application) so that it can display colours and move the cursor around the screen using this standard.

Here are the files:
glconsole.h
glconsole.c

It turns out what should be a simple process is a bit tricky in Ubuntu. You would expect to be able to create an IP access point fairly easily so that you can share your Internet connection to other devices using Bluetooth. (It turns out it may be possible with Blueman – http://blog.larsstrand.org/2009/04/sharing-internet-connection-over.html, but I’ve never had any luck with setting it up this way.) Here’s some of the steps and resources I used to get it to work. I am using one laptop with a generic usb dongle and another toshiba netbook with built-in Bluetooth for this.

Before anything is started, you need to make sure the devices are paired and trusted with one another. I found the easiest way to get this to work is with blueman (it is in the Ubuntu repos). Also it seems to work better if you initiate the pairing from the client (the computer not sharing the connection).

First, you need a bridge interface. This is easy enough in Ubuntu, by editing the /etc/network/interfaces file. If the interface you wish to share is eth0 (if you want to share a Wi-Fi connection instead, you could switch this with something like wlan0 or whatever your Wi-Fi interface is), you could add something like this:

auto br1
iface br1 inet dhcp
  bridge_ports eth0
  bridge_fd 9
  bridge_hello 2
  bridge_maxage 12
  bridge_stp off

Next you need to make sure both computers can see each other via Bluetooth. This requires enabling scanning and turning the NAP into a master and the client(s) into slaves. This can be done as follows:

sudo hciconfig hci0 piscan

sudo hciconfig hci0 lm MASTER,ACCEPT

sudo hciconfig hci0 lm SLAVE,ACCEPT

You can now check to see if each of the computers can see each other on bluetooth by running:

hcitool scan

Next you want to start the NAP server on the computer you wish to share the connection from. (This is the computer with the bridge device). This script, which is available on the git repository will allow you to start up the NAP server. (it may also be possible to use pand, but I haven’t had any luck yet with it)
This script is called test-nap. It takes a single argument, which is the name of the bridge device. So in our case we would first need to chmod +x the file (to make it executable), then run it like this:

./test-nap br1

#!/usr/bin/python

import sys
import time
import dbus
from optparse import OptionParser, make_option

bus = dbus.SystemBus()

manager = dbus.Interface(bus.get_object("org.bluez", "/"),
            "org.bluez.Manager")

option_list = [
    make_option("-i", "--device", action="store",
        type="string", dest="dev_id"),
    ]
parser = OptionParser(option_list=option_list)

(options, args) = parser.parse_args()

if options.dev_id:
  adapter_path = manager.FindAdapter(options.dev_id)
else:
  adapter_path = manager.DefaultAdapter()

server = dbus.Interface(bus.get_object("org.bluez", adapter_path),
            "org.bluez.NetworkServer")

service = "nap"

if (len(args) < 1):
  bridge = "tether"
else:
  bridge = args[0]

server.Register(service, bridge)

print "Server for %s registered for %s" % (service, bridge)

print "Press CTRL-C to disconnect"

try:
  time.sleep(1000)
  print "Terminating connection"
except:
  pass

server.Unregister(service)

After this, you can search from the client to see if the NAP service can be discovered with the command:

sdptool search NAP

The last thing to do is edit the /etc/network/interfaces file on the client side (the device which will connect to the Internet via Bluetooth. When pand connects, it uses a bnep0 interface. You need to add the following to your file:

iface bnep0 inet dhcp

Now we are ready to connect. This is how you connect:

pand -c <mac address of your server BT device>
sudo ifup bnep0

Links:

• http://global.hkepc.com/forum/redirect.php?tid=1710030&goto=lastpost
• https://www.linux.com/learn/tutorials/346552-personal-area-networking-with-bluetooth
• http://ubuntuforums.org/showthread.php?t=1632825
• http://forum.doozan.com/read.php?2,2698
• http://xn--9bi.net/2009/06/17/tethering-iphone-3-0-to-ubuntu-9-04/