% pkg install gnome

Or

% pkg remove hugin

Or

% pkg verify firefox

Or

% pkg list

I mean.… Why not Sun?

(And what about my cat?)

No related posts.

So, this howto shows you how to run Opera Mini on Linux in glorious 1440x900.… and take advantage of the speed increase.

Requirements

The Linux distribution I run is Debian, but this HOWTO will apply to any distribution really. In fact it should work on Windows as well. All you need initially is a running version of Java. However the complete list is:
Java 6
Micro Emulator
Opera Mini

Installing Java

On Debian I just do the usual installation process:

root@localhost % apt-get install sun-java6-bin sun-java6-jre

That’s it for java.

Installing MicroEmulator

Now for MicroEmulator. Fetch whatever the latest release is . I used 2.0.2 for this setup.

Extract the tarball to somewhere. Doesn’t matter where. I put it under $HOME/lib

mick@localhost [~/lib] # tar zxvf microemulator-2.0.2.tar.gz

I put in a symlink so that I can reference different version if need be. But you can skip this step if you want.

mick@localhost [~/lib] # ln -s microemulator-2.0.2 microemulator

Now, fire up java and point it to the microemulator jar file.

mick@localhost [~/lib] # java -jar $HOME/lib/microemulator/microemulator.jar

This window will now pop-up.

Now Click on ‘Options’, and then ‘Select device’. There’s nothing stopping you from running Opera in this virtual device. But remember you want to run it in a big window, right!

The window below will pop-up.

Click on Add… You want to traverse to your {directory where you installed the microemulator}/devices/, and select the microemu-device-resizable.jar file.

It will now appear in your virtual devices list. Click on ‘Set as default’ to use it every time you start it up.

The MicroEmulator window will change to a ‘not as snazzy’ window like this:

That’s it for the microemulator.

Installing Opera Mini

Installing Opera Mini is easy too. There’s two ways to do it.
Click here , and here and save somewhere.

Or follow these instructions, (I’ve put them here, because, as you know, links change on the internet, and I hate 404s).

Just fetch the latest version from Opera. There’s 4 steps to download:
1. Select ‘Download to PC’.
2. Select ‘Generic version’.
3. Select ‘Advanced MIDP 2′
4. Select you preferred language, and download the JAD and JAR files.

I placed these two files under $HOME/lib/opera. You will have to create a symlink so that the version you have downloaded will be used properly.

mick@localhost [~/lib/opera] # ln -s opera-mini-latest-advanced-int.jar opera-mini-4.1.11355-advanced-int.jar

Your version may/will vary. You’ll need to symlink, (or rename), the file for it to work, though.

Now you want to open the Opera Mini JAD file you just downloaded.

Find it and open it.

Now you will see it in the list of applications that can be launched by Micro Emulator.

Now just double click on it.

Hooley Dooley Batman! It works! Cool!

Either use your mouse and click, or you can use up/down/left/right keys and enter to traverse web pages.

One last thing

I created the following script to make it easier for me to startup, and called it ‘operamini’.

#!/bin/bash

exec >& /tmp/operamini.log

java -jar $HOME/lib/microemulator/microemulator.jar $HOME/lib/opera/opera-mini-latest-advanced-int.jad

Now I have my super fast GPRS internet connection. Also, a side benefit is that all my bookmarks are synced up to my phone.

No related posts.

OK, it doesn’t actually boot from SD, but uses a snazzy Linux trick called pivot_root. Which switches over one root with another. This, IMHO, is probably the best way of doing it apart from actually directly booting from SD. Although, I’ve only tried this on a 38xx based iPAQ it should work for all handhelds based on familiar. Heck, it should work for anything really.

Preface

The general idea is to boot up Linux from the internal flash of the iPAQ to just before it runs the environment. Check the SD slot for a loopfs file, if one is there, then mount it up, switch roots, and continue to boot.

Why?

There’s several benefits to doing it this way:

1. Backups — Since you have a copy of the root filesystem on SD, you can back it up very easily. Every PC these days has a SD slot. Just whack it in and copy the file across, you don’t even need Linux to do it either.
2. Choices — You can startup either environment GPE or OPIE, just by changing SD cards. (Further updates to setMMCroot will allow selecting environment by buttons.
3. Saving files — regardless of what environment you run, you can still save the files directly to the SD card. If you need them elsewhere, turn off the iPAQ, pop the SD card out and chuck it into a PC and read them. Easy!
4. Dead SD — If your SD card dies, you can still run with a basic environment that is already loaded up on your iPAQ. With other methods, if your SD dies that’s it. Things start going wierdo.

Pre-requisites

You’re going to need several things to do this:

1. Linux based PC, any dist will do.
2. An iPAQ — with familiar Linux already loaded up on to it, (doesn’t matter what environment).
3. A copy of familiar Linux , with either the GPE or OPIE will do. I used version 0.8.4 for this HOWTO. You will need the tarballs from here and not the jffs files, (IE either of the *.rootfs.tar.bz2 files).
4. Any SD, MMC, or CF card formatted with FAT16, (if you just bought it you don’t need to do anything as all flash cards are formatted these days).

Step 1 — Create root filesystem.

First we’ll need to create the filesystem that gets mounted up I’m creating a 1G filesystem, because I tend to load up a lot of applications onto my iPAQs. Since I also have a 2G SD card, I will be able to store both the GPE and OPIE environments on it.

dd if=/dev/zero of=loopfs-gpe bs=1024 count=991680

Note the size is just under 1G? This is because a 1G filesystem on an SD card will consume slightly more than 1G. So, I’ve allowed for that. I can fit two filesystems on that card this way. Adjust the “count” to whatever size you want or care for.

Now, you’ll need to setup the filesystem.

mkfs.ext2 loopfs-gpe

This will create a Linux ext2 filesystem. You can really use any filesystem, but you don’t want to use a journelling filesystem like ext3, reiserfs, xfs, as flash memory can’t stand too many writes to it. Journelling filesystem tend to write a lot of data even when not being used, (from a flash point of view).

Mount up the filesystem on your Linux box, (requires root).

mkdir loopfs-gpe.mount
mount -o rw,loop loopfs-gpe loopfs-gpe.mount

Extract the environment tarball into the loopback mount point.

cd loopfs-gpe.mount
tar jxf ../gpe-image-v0.8.4-h3600.rootfs.tar.bz2

You will need to edit /etc/passwd and change the root password to something sensible if you want to login, the following entry will set the password to ‘root’.

root:dquXGWQyEH.uI:0:0:root:/home/root:/bin/sh

Unmount the loopfs filesystem.

umount loopfs-gpe.mount

You now have a brand spanking new filesystem that will be used on your iPAQ.

Step 2 — Prepare your SD.

There are a number of files that need to be created and copied over to your SD card. These are all required.

• Your root filesystem that you just created, ensure it is called either loopfs-opie or loopfs-gpe.
• The setMMCroot script , which does all the work.
• Create a file called loopfs.boot on the SD card with the full path of the loopfs file you created. For example: /media/card/loopfs-gpe, or /media/card/loopfs-opie, or /media/card/i.like/it.here

Remove the SD card and plonk it into your iPAQ.

Step 3 — Prepare your iPAQ.

Fire up your favourite serial port communication program, (I use minicom), to connect to your iPAQ, which should be connected to your PC by now. If you can’t do this, or don’t want to, then you can run these commands from within a console on your iPAQ, (under the Applications tab). The preferred option is to run the ppp daemon from your Linux box and ‘ssh 20.0.0.1′ into your iPAQ, using the following command, (needs root on your PC):

/usr/sbin/pppd /dev/ttyS0 230400 20.0.0.5:20.0.0.1 nodetach local noauth nocrtscts lock user ppp connect "/usr/sbin/chat -v -t3 ogin--ogin: ppp"

Run the following commands in a shell on your iPAQ.

ln -s /etc/init.d/setMMCroot /etc/rc5.d/S01setMMCroot
ln -s /etc/init.d/setMMCroot etc/rc2.d/S01setMMCroot
cp /media/card/setMMCroot /etc/init.d/setMMCroot

I had suggested using the ppp daemon because then the next part becomes easy. You ned to install the extra packages on your iPAQ. e2fsprogs, e2fsprogs-e2fsck, kernel-module-loop-2.4, and kernel-module-ext2-2.4. Run this on your iPAQ, or use the package manager to do it.

ipkg install e2fsprogs e2fsprogs-e2fsck kernel-module-loop-2.4 kernel-module-ext2-2.4

Holy toledo batman! You’re almost there!

Step 4 — Reboot your iPAQ.

Reboot your iPAQ, via Start -> Settings -> Shutdown.

When you reboot you should see the following appear just underneath the Linux penguin logo.

#### 1. Checking MMC: #
Found MMC!
Using loopfs: /media/card/loopfs-gpe
#### 2. FSCK filesystem:
/media/card/loopfs-gpe has gone 48850 days without being checked, check forced.
/media/card/loopfs-gpe: 2817/124160 files (0.1% non-contiguous), 12110/247900 blocks
#### 3. Setting up loopback FS:
Using /lib/modules/2.4.19-rmk6-pxa1-hh42/kernel/drivers/block/loop.o
#### 4. Mounting:
#### 5. Ballet:
#### 6. Tidying up:
killall: Xfbdev: no process killed
#### 7. Handover:

The script will wait for 16 seconds for an SD card to be inserted, (a hash will appear every second), else it will just boot up straight from the internal flash. This allows you to just run with whatever is there already, if need be.

Depending on what environment you have running will change some of the messages between each stage. I’ll see if I can take a photo of the bootup stage and chuck it on here. (EDIT: I’ve put up some bloody horrible images of the iPAQ booting, taken with my mobile.)

Boot loader screen.

FSCKing the filesystem.

Ballet school

From there onwards, it’s just the normal boot procedure.

Step 5 — Final install.

Because this is a ‘fresh’ install you will be asked all the questions you would have been asked when you did the initial install of familiar on your iPAQ. If you get to this stage you’ve done it! Congratulations!

Once you have gone through the final install procedure, if you open up a console session and type ‘df’ , you’ll see what the setMMCroot script does. /mnt/realroot points to your iPAQ flash filesystem, and / is the SD filesystem. Cool eh?!

root@h3600:~# df
Filesystem 1k-blocks Used Available Use% Mounted on
/dev/root 976056 387164 539308 42% /
tmpfs 31676 40 31636 0% /mnt/realroot/var
tmpfs 31676 0 31676 0% /mnt/realroot/media/ram
/dev/mmc/part1 1983360 991712 991648 50% /mnt/realroot/media/card
/dev/loop/0 976056 387164 539308 42% /

No related posts.

Work In Progress, (sorry it’s a bit sparse and hurried, but it’ll give you the general idea).

I haven’t used this method for a while, but just started playing with my iPAQ again, somewhere between then and now it stopped working. Apparently Telstra have made some changes to their APNs. So I’ve updated this page to reflect the changes.

1. Create/modify a couple of files.

Note: Telstra have changed their APN, (Access Point Number), since I last tried this.

File: /etc/ppp/peers/gprs

nodetach
defaultroute
nocrtscts
lock
noauth
# lcp-echo-interval 5
# lcp-echo-failure 3
usepeerdns
230400
local
asyncmap 0
connect /etc/ppp/peers/gprs.chat.connect
disconnect /etc/ppp/peers/gprs.chat.disconnect

File: /etc/ppp/peers/gprs.connect

#!/bin/sh
exec chat TIMEOUT 5 \
ECHO ON \
ABORT 'nBUSYr' \
ABORT 'nERRORr' \
ABORT 'nNO ANSWERr' \
ABORT 'nNO CARRIERr' \
ABORT 'nNO DIALTONEr' \
ABORT 'nRINGINGrnrnRINGINGr' \
'' \
rAT TIMEOUT 12 OK \
ATH OK \
'ATDT+cgdcont=2,"IP,"telstra.internet"\n' '' \
AT OK \
'ATDT*99#' TIMEOUT 22 CONNECT \
"" SAY " - Connected."

File: /etc/ppp/peers/gprs.disconnect

#!/bin/sh

exec /usr/sbin/chat -V -s -S \
ABORT "BUSY" \
ABORT "ERROR" \
ABORT "NO DIALTONE" \
"" "K" "" "K" "" "K" "" "+++ATH" "" "+++ATH" "" "+++ATH"

File: /etc/bluetooth/givepin

#!/bin/sh
echo 'PIN:2222'

File: /etc/bluetooth/hcid.conf

options {
        autoinit yes;
        security auto;
        pairing multi;
        pin_helper /etc/bluetooth/givepin
}

device {
        name "iPAQ";
        class 0x120112;
        lm accept;
        iscan enable;pscan enable;
        lp rswitch,hold,sniff,park;
        encrypt enable;
}

2. Pair the phones together.

Get the Nokia to scan for bluetooth devices, and use the PIN that you used in the givepin file to pair the iPAQ found to your Nokia.

3. Create the GPRS connection.

From your iPAQ you can access your phone and connect to GPRS using the following:

dund --nodetach --encrypt --connect 42:42:42:42:42:42 --channel 3 call gprs

Replace 42:42:42:42:42:42 with your mobile phone’s address. To find this you can use hcitool to scan for it.

root@nowhere % hcitool scan
Scanning ...
        00:42:A0:42:26:42  Nokia N70
        00:16:42:DC:42:B8 AUSYDN000649
        42:42:42:42:42:42  I'm right behind you
        00:15:42:DB:42:24  n/a

No related posts.

Choices:

To virtualize an instance of a Linux server you have many choices, so I won’t go into them in detail but roughly.

• VMWare:
  The king of the virtual world on PCs.

  - Provides a fairly fast HAL, (Hardware Abstraction Layer), for devices.

  - Direct device access, and emulated devices, (USB, SCSI, IDE, etc, etc).

  - Supports pretty much every O/S that you can run natively on a PC, but virtually.

  - Snapshots, rollbacks — it does it all.

  - Downside — it costs a lot, and is a bit of overkill.

• Linux Vserver:

  - Only supports Linux — not an issue for me.

  - No disk pre-allocation — uses native Linux filesystem.

  - 32bit/64bit independence — because I have x86 and AMD64 machines running on the same network.

  - Non-distribution specific — RedHat, Suse, Gentoo, etc — you can do it all.

  - Security — all the specific 2.4.19 kernel security mods are present and so lends itself to true isolation.

  - Resource sharing — No special daemons need to be running. It all shares local resources, (like Solaris zones).

  - Fast — runs the same kernel as the base O/S, (like Solaris zones).

• Xen:
  Very similar to VMWare, (but this one is GPLd). There’s a lot of noise about Xen at the moment. Sun, Novell, and HP are using Xen in their O/S. It’s fast becoming the choice VM to use. But for me — too much overhead.

  - Requires the O/S to be modified to support it, (although this isn’t the case now with 3.0).

  - No support for APM, or ACPI — I need it!

  - Very similar to VMWare.

• UML — User Mode Linux:
  This method actually runs a modified kernel as an application, and this acts as a ‘HAL’.

  - It’s standalone — you can run any distro you want.

  - Slower than vserver, as it runs another instance of a kernel, (and support programs).

  - Can access a local filesystem, but the norm is to provide a disk file for booting.

• Plex86:
  
  Similar to vserver & UML.

  - Requires modification of the kernel, (similar to Xen).

  - Very lightweight.

• BOCHS:
  
  A fully fledged emulator. NOTE: The word emulator and NOT virtualizer. There’s a difference and it’s mainly with speed, but it runs almost anything, (like vmware). It’ll be slow on my PCs, and it’s too bloaty. Not what I want.

There are others, but I didn’t bother investigating those. I eventually settled on vserver. Why? Well, that’s easy.

• It handles very much like Solaris zones — more familiar ground for me.

• It can be transported between PCs — just do an rsync of the /etc/vservers/funky.homenet & /etc/vservers/.defaults/vdirbase/funky.homenet directories and start up.

• I can choose my distro — I can run sid in a vserver if I want to.however, it has to be noted that vserver shares the kernel, (similar to Solaris zones), so it’s probably better to keep to the same distro and release. In my case I will be.

• The fastest method for virtualizing — it’s faster than plex86, and UML, and not as bloaty as Xen and VMWare.

Stage 1 — the kernel:

I tend to avoid modifying my kernel as much as possible for several reasons, the most important being time — I just want to be able to do an ‘apt-get update && apt-get upgrade’ for security patches. However, vserver requires a modification to the kernel. Oh well. The benefits of vserver outweigh my desire for consistancy.

UPDATE: With Etch, (October 2006), you can just pick your kernel. Etch now has many kernels to choose from ranging from 486, bigmem, vserver, xen, etc. Just choose one of them.

   % apt-get install linux-image-2.6.17-2-vserver-686 util-vserver vtun

If you want to pick up some pre-built kernel packages go here. You’ll find a stock 2.6.12 kernel with the latest vserver utils package. Just add the following to your /etc/apt/sources.list, update and install.

deb http://matvey.org.ru/pub/debian/ stable main

 % apt-get install kernel-image-2.6.12lvs util-vserver vtun

Stage 2 — create the vserver:

Once you’ve rebooted your box with the vserver enabled kernel, you can start creating your vserver. This is all pretty trivial.

 % vserver funky.homenet build -n funky.homenet --hostname funky.homenet \
--interface eth0:10.0.0.1/8 -m debootstrap -- -d sarge -m http://software/debian/sarge/i386/ 

What this does is:

• Create a virtual server called funky.homenet

• FQDN is funky.homenet.

• IP is 10.0.0.1 using eth0.

• Use sarge.

• Use the server ‘software’ as the sarge mirror, (my own local mirror).

This will create a /etc/vservers/funky.homenet, and a /etc/vservers/.defaults/vdirbase/funky.homenet directory the last directory will contain the complete root of the vserver. So if you want to put it elsewhere the easiest way is to repoint the symlink /etc/vservers/.defaults/vdirbase somewhere else.

Stage 3 — start the vserver:

Once it’s finished creating, (around 160Mbytes, and 8 minutes later — on my 330MHz box), you can start the server.

 % vserver funky.homenet start Starting system log daemon: syslogd. Starting kernel log daemon: klogd. Starting MTA: exim4. Starting internet superserver: inetd. Starting OpenBSD Secure Shell server: sshd. Starting deferred execution scheduler: atd. Starting periodic command scheduler: cron. 

Once started login to the ‘console’, (similar to Sun’s ‘zlogin’).

   % vserver funky.homenet enter funky:/#

Stage 4 — configure the vserver:

Now that you have created and logged in to your vserver, there’s a few more steps left. The first one is pretty normal for a fresh Debian install. Edit your /etc/apt/sources.list to point at the mirror of your choice, (heck even point it at sid!), Then do the usual apt-get update & apt-get upgrade or apt-get install. Whatever.Don’t forget to change your timezone, as this will be set to the default UTC.

The next thing is to do with networking. The basic vserver install here will set the IP address to be 10.0.0.1. The local PC will more than likely be on the same subnet, but doesn’t have to be. Either way you’re going to have to stop the local PC from accepting packets for connection requests for things like SSH, inetd, etc. This is one downside — vserver won’t redirect traffic destined for a virtual server. So, for example, if you don’t stop ssh from binding to 0.0.0.0, then when you SSH into your vserver all you’ll do is login to your local PC. Bummer eh.

So, best practice is to reduce all the listening ports and/or bind them to the local PC’s IP instead of anonymous binding.

Also, one last thing. Make sure that you chmod 000 the parent to the vserver root. This will enable the anti-getting-out-of-chroot-jail mods that were introduced in the kernel.

Stage 5 — enjoy yourself:

As I mentioned before, the reason I wanted to set up a vserver was for flexibility. I can transport the vserver over to another PC, I can run multiple vservers, test out an upgrade before releasing it on the ‘production’ server. What you can do is limited only by your imagination.

No related posts.

First up

For various reasons I decided to not run Linux in full blown userspace 64bit mode. Therefore, building the vmware modules for networking, etc wasn’t straightforward and was the main cause of my troubles. So I adopted a chroot/install/build/copy approach. This has worked for me not only for cross-compiling, but also running different Linux distros natively under Debian.

Pre-requisites

• One stock Debian Sarge install.
• % apt-get install cdebootstrap debootstrap

Setup chroot’ed 64bit Debian

This was pretty basic. Once you have installed debootstrap, then just run:

% cdebootstrap --arch amd64 sarge /STUFF/CHROOT64/ http://public.planetmirror.com/pub/debian-amd64/debian/

You will have to select a Debian 64 mirror closest to you, and also choose an alternative base directory, (I set mine to /STUFF/CHROOT64/).

You will see Debian installing under your chroot directory, it’ll take a while. It took around 3 minutes for me, your mileage may vary.

Configure chroot’ed base

Once you’ve finished installing, you’ll need to configure it all up. I did so with the following:

% cp /etc/hostname /etc/resolv.conf /etc/mtab /etc/fstab /STUFF/CHROOT64/etc
% cp /etc/network/interfaces /STUFF/CHROOT64/etc/network

You’ll also need to setup your apt-get repository. Copy the following into your /STUFF/CHROOT64/etc/apt/sources.list file, and modify for your own mirror.

deb http://public.planetmirror.com/pub/debian-amd64/debian/ sarge main contrib non-free
deb-src http://public.planetmirror.com/pub/debian-amd64/debian/ sarge main contrib non-free
# deb http://security.debian.org/ stable/updates main contrib non-free

Then enter your chroot and finish the configure.

% chroot /STUFF/CHROOT64
% mount /proc
% base-config
% dpkg-reconfigure -plow console-data

The ‘base-config’ will take a while and ask the usual setup questions. Just answer them to mirror your base Debian install.

Setup build env. for vmware

Now you have a fully working 64bit userpsace chroot env. You’ll need a few more tools apart from the base install:

% apt-get update
% apt-get install gcc-3.4
% rm /usr/bin/gcc
% ln -s /usr/bin/gcc-3.4 /usr/bin/gcc

NOTE: VMWare will want to use gcc-3.4 to build the kernel modules as opposed to using gcc-3.3, which is the reason for re-symlinking /usr/bin/gcc.

Install the all-important kernel headers:

% apt-get install kernel-headers-2.6-amd64-generic

Install vmware

Now, untar the vmware install file. Run the vmware-install.pl script. Answer all those questions as you would normally. Everything should compile and install OK. The final restart of the kernel modules won’t. You’ll get some error that you can safely ignore.

Don’t worry, you won’t actually be running vmware from this environment, just building the kernel modules.

Copy VMware install into base install

Now copy all the vmware install files into the base Debian installation:

% cd /STUFF/CHROOT64
% tar -cf - usr/lib/vmware etc/vmware usr/share/doc/vmware usr/bin/vmware* lib/modules/2.6.8-11-amd64-generic/misc etc/init.d/vmware etc/rc?.d/*vmware | (cd /; tar xvf -)
% rm /etc/vmware/not_configured
% rsync -HvaxP dev/vm* /dev

NOTE: The removal of the /etc/vmware/not_configured file is important. Otherwise you won’t be able to start the vmware modules.

Startup vmware modules

Just run the rc script.

% /etc/init.d/vmware restart

That’s it! Happy vmware-ing!

No related posts.