yazzgoth.org

For any web page visibility on search engines is a vital.

So how does my blog is doing?

search phrase: yazzgoth
place: 3
(when I’ve chosen this nickname I didn’t know that “yazzgoth” is a name of heavy metal band - polish band btw )

search phrase: bartosz ptaszynski
place: 5
(small note here: the 1st place takes my LinkedIn profile :D)

search phrase: coder’s life
place: unknown (I didn’t find it on the first 10pages)
So I guess there’s a reason to change the blog’s name to something more informative… hmm but what?

So this is like the world looks like at 4am

After reading ZenHabits I’ve decided to convert myself from being a Night Owl into an Early Bird.
I’m rather extremist when it comes to changing something. I usually do things on one go when it comes to changes in my life, so instead of waking up every day 10 minutes earlier until I would reach the 4am target - I have set up my alarm to 4am

To be honest this is not my first attempt

Yesterday I’ve tried, but made a critical error of reasoning with myself to go to bed for just a bit more… and I’ve stayed in until 8am Well they have warned me not to reason with myself in the morning…

And again, Fridays are not the best time to change something in your life… but hey, had to start someday.

This little program is what I’ve mentioned earlier on my blog. It connects to all devices it can find in specified IP ranges via SMTP and gathers their MAC tables.
The plan is to keep this data in a DB and update it once in a while (20min would seem appropriate ). Then you can easily pin point what route do packets take on the L2 of the network and what Subscriber Module (SM) has a client using specific IP address/MAC.
This can be very useful in Motorola Canopy based networks with open architecture.

Package still under development.

Currently to make it work you need:

* Motorola Canopy based network
* Net-SNMP binaries (snmpwalk)
* Python 2.5
* SQLObject
* IPy
* SQLite

1) Download and install Net-SNMP binaries (or compile it if you wish) and make sure the executables are within PATH.

2) Install Python 2.5

3) To make your life easier download and run ez_setup.py to install latest distutils.

4) From the command line type: easy_install SQLObject
which should download and install SQLObject (and most likely SQLite as well - if not download SQLite and install it)

5) From the command line type: easy_install IPy

6) Now you can use following script

macsearch.py

#!/usr/bin/env python

#  Copyright (c) 2007, Bartosz Ptaszynski
#
#  macsearch.py 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 2 of the License, or
#  (at your option) any later version.

"""

@author: Bartosz Ptaszynski
@copyright: (C) 2007 Bartosz Ptaszynski
@license: GNU General Public License (GPL)
"""

# Standard Library imports
from os import popen
from sys import argv
from optparse import OptionParser
from datetime import datetime

# 3rd Party Library imports
from sqlobject import *
from IPy import IP

class MAC(SQLObject):
    ip = StringCol(length=16)
    mac = StringCol(length=18)
    device_type = StringCol(length=6)
    last_seen = DateTimeCol(default=datetime.now())
    site_name = StringCol(default="")

class Subnet(SQLObject):
    subnet = StringCol(length=20, alternateID=True)

class MACDiscoveryAgent(object):
    snmp_site_name = " SNMPv2-MIB::sysName.0"
    snmp_macs = " enterprises.161.19.3.3.4.1.1"
    snmp_device_type = " enterprises.161.19.3.3.1.7.0"

    def __init__(self, community="Canopy", snmp_version="2c", db_uri="sqlite:/:memory:"):
        self.community = community
        self.snmp_version = snmp_version
        self.snmpwalk = str("snmpwalk -c "+community+" -v "+snmp_version+" ")
        self.db_uri = db_uri
        self._db_connect()

    def _init_db(self):
        try:
            MAC.createTable()
            Subnet.createTable()
            return True
        except:
            return False

    def _db_connect(self):
        """ Connect to the Database
        """
        sqlhub.processConnection = connectionForURI(self.db_uri)
        self._init_db()

    def _db_addMAC(self, ip, mac, device_type, site_name):
        """ Add a MAC to the Database, refresh the last_seen if it already exists
        """
        oldmac = MAC.selectBy(mac=mac, ip=ip, device_type=device_type)

        try:
            if oldmac.last_seen:
                oldmac.last_seen = datetime.now()
        except AttributeError:
            m = MAC(ip=ip, mac=mac, device_type=device_type, site_name=site_name)
            #print m

    def _db_removeSubnet(self, subnet):
        """ Removes a subnet that the MAC lookup should sweep from the Database
        """
        pass

    def _db_removeMAC(self, mac):
        """ Completely removes a MAC address from the database
        """
        pass

    def _db_lookupMAC(self, mac):
        """ Looks up a MAC address in the Database
        """
        results = MAC.selectBy(mac=mac)
        return results

    def _normalizeMAC(self, mac):
        # TODO: use regexp here
        if "-" in mac:
            mac = mac.split("-")
        elif ":" in mac:
            mac = mac.split(":")
        elif " " in mac:
            mac = mac.split(" ")
        mac = ''.join(mac)
        mac = mac.upper()
        return mac

    def _getMACs(self, ip):
        """ Get all MAC addresses from the device
        """
        print ip
        device_type = popen( str(self.snmpwalk + ip + self.snmp_device_type) )
        device_type = device_type.read()
        device_type = device_type[52:-2] # TODO: I should use regexp here!
        macs = popen( str(self.snmpwalk + ip + self.snmp_macs) )
        macs = macs.readlines()
        site_name = popen( str(self.snmpwalk + ip + self.snmp_site_name) )
        site_name = site_name.read()
        for mac in macs:
            self._db_addMAC(ip=ip, mac=self._normalizeMAC(mac[-19:-2]), device_type=device_type, site_name=site_name[32:]) # TODO: use regexp!

    def addSubnet(self, subnet):
        """ Add a subnet that the MAC lookup should sweep to the Database
        """
        try:
            Subnet(subnet=subnet)
            return True
        except:
            return False

    def sweep(self):
        for subnet in Subnet.select():
            for ip in IP(subnet.subnet):
                self._getMACs(str(ip))

    def lookupMAC(self, mac):
        """ Lookup a MAC address in the Database

            If successful it returns IP address of the SM with provided MAC address.
            If not successful it returns a list with all APs and BHs that have provided MAC address.
            It's a list of dictionaries. This list has a format [ {'device_type': string, 'ip', string}, ... ]

        """
        mac = self._normalizeMAC(mac)
        results = self._db_lookupMAC(mac)
        for result in results:
            if "SM" in str(result.device_type):
                return result
        return results

# Example usage below...

m = MACDiscoveryAgent()
m.addSubnet("192.168.105.44/30")
print "Sweeping the network..."
m.sweep()
print "Sweeping completed."
print "Looking up the MAC address..."
res = m.lookupMAC('00 E0 4C A0 28 CC')
if type(res) is MAC:
    print "Found it:", res.device_type,":", res.ip, ":",res.site_name,": last seen:", res.last_seen
else:
    print "Couldn't find the SM, But found following items with this MAC in their MAC table"
    for i in res:
        print i.device_type, ":", i.ip, ":", i.site_name, ": last seen ", i.last_seen

My blog has moved to this page.

Well I was tempted to give the WordPress a ride for some time now. The thing that pushed me over the edge was the code syntax highlighting that I had some problems with on blogger.

I’m using SyntHihol with geishi and it’s working perfectly.

I’ve just stumbled upon Microsoft’s Photosynth. This astonishing technology takes hundreds pictures of the same place taken from a different angles and creates a 3D image…
I can imagine that if someone would take this technology, used the images from Google Images or Flickr and assigned them to a location and plugged that into Google Earth … the result would be just jaw dropping.

I have a feeling that in some time that someone will be Google

I’ve stumbled upon a great website on Lifehacking while reading Torley’s blog…

I find a lot of things mentioned there that I already do or figured out the hard way… but there’s so many things I can introduce to my life it makes me so excited that I think I’ll start straight away.

Having a good idea is easy. Executing the idea is where most people fail.

…as you can read here.
This is so true it just hurts… I have so many ideas, just making a decision on which to pursue first is the hard one, and often a fatal in this sense that it may lead to not doing anything at all!

Heh I still can’t get myself from the floor after reading this…

It seems that Microsoft has some weird way of checking if the Windows is genuine or not… I wonder what this will lead to as it may open doors for quite some interesting possibilities.

I’ve joined Twitter, let’s see what all the hype is about
My twitter is available here

Well it’s time for Linden Scripting Language quirks today.

Heh the LSL is one big quirk but that’s a different story.

What I found today the empirical way is that when you send a request to the dataserver, ie when querying with llRequestAgentData the event if fired up after the current function finishes.
This is very annoying when you want to query the dataserver wait for it’s results and process the data.
I’ve tried to llSleep for some time and also llSleep in while loop waiting for the dataserver to trigger the event and return data… but the dataserver never did that before the current function finished.

Example:

string born;
someFunction()
{
       llRequestAgentData(llGetOwner(), DATA_BORN);
       llSleep(10.0);
       llOwnerSay("You were born "+born);
}

default
{
       dataserver(key id, string data)
       {
          born = data;
       }
}

What will you get is:

Object: You were born

This example is easy to fix as there is only one query to the dataserver.
But in my case I’ve had a list of avatar keys which I wanted to query one by one and at the end send the results over the llHTTPRequest.
I couldn’t call llHTTPRequest every time I’ve did the query to the dataserver or I would trigger the throttling on the script…

The thing was that the dataserver event was designed to modify the original list with avatar keys and add the results just after corresponding key and I couldn’t proceed without having the events finished their job.

My solution to that was queuing up all the dataserver requests and using two global variables. First was holding the length of the list with avatar keys, the other was incremented from 0 every time the dataserver event fired up. At the end of each dataserver event I’ve called a function that compared the variable with length of the list with avatar keys with the counter on event calls.
When they’ve matched that indicated that the llRequestAgentData was executed on all avatars and I could proceed freely.

There’s something about Fridays that makes me feel great. I wonder if going on retirement feels like Friday multiplied by fifty.

Heh