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/

You can apply this to the wlan interface to put it directly into monitor mode and avoid using the airmon-ng tool altogether if you wish. You may also be able to apply this to the mon0 interface created by the airmon-ng tool as well, however I have not tried it yet.

The bulk of the problem is just the order in which monitor mode and channel are enabled, it must follow the order as follows:
ifconfig $IFACE down
iwconfig $IFACE mode managed
ifconfig $IFACE up
iwconfig $IFACE channel $@
ifconfig $IFACE down
iwconfig $IFACE mode monitor
ifconfig $IFACE up

Hope this solves some problems…

Officially the topic is “Radio Resource Management for Quality of Service in Heterogeneous Wireless Networks”. This is quite the mouthful, I know. Really what it boils down to is: Making various wireless technologies (Bluetooth, WiFi, WiMAX, 3G, 4G, … , etc) seamlessly work together. Many devices are capable of connecting to many of these radio access technologies (RATs), but often it is not seamless. What do I mean by this? Well suppose I am inside a university building, deep in the basement (where they tend to put CS students ) where there is no mobile reception (3G, 4G etc.). I start downloading a large file, or call someone via wifi. Now I want to walk to my car because it’s time to go home for the day. Many networks now are not able to handle this, and it is interrupted after you change networks. Furthermore, you often have to manually tell the device you want to leave one network and join another. Seamless means this should all happen without you noticing. This is the focus of my research.

The biggest problem that I am concerned with is called handoff or handover. This is when the switch between RATs occurs. Traditionally, this also occurs when a mobile device switches from one tower to another, and it usually involved predicting the motion of the device along with some other factors for Quality of Service (QoS). For a vertical handover, we may or may not need to predict motion. If the heterogeneous wireless network (HWN) is densely covered, many RATs are available throughout the coverage region (as opposed to a sparsely covered where a given location may have access to one technology at once). In a dense HWN, the problem becomes a multi-criteria question.

1. Which network is most economical for me to connect to?
2. Which configuration of (network, client) pairs is most profitable for the operator?
3. Which network is able to provide me with the required QoS?

More technical details to follow…

The Atria plan used large WiFi cells, with very expensive antennas (see the apartment building near University Plaza, which I believe was one of them).

Many other cities (much larger ones) have been very successful in providing blanket WiFi, using a completing different coverage model and cost model. The best example is San Francisco where a company named Meraki provides free wifi for over 100,000 people using their Mesh Router devices. These devices cost between $399 and $1500 each, which is still expensive, but likely much cheaper than anything used by Atria. These devices likely have much lower range and handle dense areas compared with the atria cells which seem to be designed for large areas, and require many people to subscribe to pay for their costs. The argument in the article that WiFi coverage in metropolitan areas is difficult seems like a terrible attitude to have for an area that has a reputation as a high tech leader. San Francisco likely has much greater challenges in this regard compared to our tiny city.

Example coverage map in San Francisco

Instead of using these expensive devices, much cheaper devices such as linksys wrt routers could be used. These routers support linux, and because of this much customization is possible such as mesh networking. While these devices are less reliable than the previous more expensive solutions, it may be a good way to at least get the network started cheaply. Additionally, areas which are not used by as many people could be covered with cheaper routers, while areas with more dense traffic may be covered by expensive ones.

The argument in the article that WiFi networks are unnecessary because of cellular networks is ludicrous! If that is the case, why are every smartphone and other device including WiFi radios in them? It’s because data on cellular networks is way to expensive. Any place where a device can get free or low cost WiFi should be used instead of the cellular network. One large problem with this at the moment, however is that it is not seamless to go from a cellular network to a wifi network. For example, it is often not possible to carry on a phone call while switching networks, or continue downloading or steaming without interruption. This will change with much of the research in heterogeneous networks.

One potential model that hasn’t been explored much is community wireless networks. In this case, devices could be provided to anyone willing to provide access to their own home network for the community. The incentive could be either donations from users, or a very small fee (2 – 5 dollars per month) which is distributed to providers. Additionally, anyone who provides a part of the network is able to get on free to other parts of the network. Of course, there’s nothing to stop the larger companies like Rogers and Bell from creating the same type of value added service. Since so many people already have wireless in their home using Rogers and Bell, they could create some type of login where you take your bandwidth quota with you and have access to anyone else’s network who is also participating. This way, you are not using their bandwidth cap (only their “speed” – which may introduce a whole other range of problems )

Windows Disk Management Tool, used for setting active partition

Unfortunately, none of these options worked. It turns out, it is a simple fix (at least for me). In start menu, type “disk management” into the search, and click on “create and format hard disk partitions”. Right click on the partition that has Windows7 (likely the largest NTFS partition [don't select the recovery partition] if you have a setup like mine) and click “Mark Partition as Active”. Then try to install SP1 again, and it should work fine.

I’ve recently become annoyed that ushare hasn’t been autostarting in Ubuntu 11.04. I suspect it may have something to do with the fact that I am using the same machine to host vpn so I have a bridged connection br0 as my main connection. The default script in /etc/init.d/ushare should be able to autostart, and I have tried adding it to rc.d using variation of this command “sudo update-rc.d ushare defaults 80″, however it fails to start. I have no trouble running it manually with the “/etc/init.d/ushare start” command however. So I’m guessing it is just trying to start before the network interfaces come up and failing. The workaround I found tries to solve this by explicitly running after the interface is up. The way to do it, is to add it to the “/etc/network/interfaces” file using something called “post-up”. Since I wanted to have ushare run after my br0 interface is brought up, I added it like at the bottom of the br0 section, see below:

iface br0 inet static
  address 192.168.0.198
  netmask 255.255.255.0
  gateway 192.168.0.1
  bridge_ports eth1
  post-up /etc/init.d/ushare start

# Disable reading by anonymous users
# See: http://www.mediawiki.org/wiki/Manual:Preventing_access#Restrict_viewing_of_all_pages
$wgGroupPermissions['*']['read'] = false;

# But allow them to access the login page or else there will be no way to log in!
# NOTE: You also need to provide access here to the .css and .js files that the
# allowed pages attempt to load; otherwise, users will get errors on the page
# when they attempt to load it (IE will complain about the errors;
# FF will show them in its error console)
# [You also might want to add access to "Main Page", "Wikipedia:Help", etc.)
$wgWhitelistRead = array ("Special:Userlogin", "MediaWiki:Common.css",
"MediaWiki:Common.js", "MediaWiki:Monobook.css", "MediaWiki:Monobook.js", "-");

# Disable anonymous editing
$wgGroupPermissions['*']['edit'] = false;

# Prevent new user registrations except by sysops
$wgGroupPermissions['*']['createaccount'] = false;