Kommie P: le blog

Resolving host names on Windows, Linux and Mac

2011-08-17T00:00:00-07:00

Resolving host names on Windows, Linux and Mac

Here is the setup. We have a Windows-based network with AD, DHCP, WINS and DNS servers. We have Windows, Linux and Mac hosts on wired and wireless networks. The hosts acquire IP addresses using DHCP.

The task. Be able to ping all hosts using host name.

When Windows hosts acquire IP address using DHCP, a record for the host is created in the DNS. So from any host we can do nslookup mywindowshost and it works, and so ping works too. Note, these Windows hosts are joined into the domain so that may have some bearing on this, don't know.

The problem is with the Linux and Mac hosts. By default when these get IP address from DHCP server they don't get the DNS record created for them. As a consequence, if I do nslookup ubuntuhost or nslookup machost I get back nothing. Also, by default we can't ping those from Windows machines either.

It is possible to use bonjour to resolve the Linux and Mac hosts but this does not work between wireless and wired hosts because I think those two networks are joined by switches and I guess bonjour only works on the same segment? I don't know much about this though, I may be wrong. Another problem with bonjour is that by default it's not present on Windows hosts.

So here is the summary:

Source host     Target host     Command            Status
---------------------------------------------------------
Windows         Windows         ping host          OK
Windows         Windows         ping host.local    XX 

Ubuntu          Windows         ping host          OK
Ubuntu          Windows         ping host.local    XX

Ubuntu          Ubuntu          ping host          XX
Ubuntu (wired)  Ubuntu (wired)  ping host.local    OK
Ubuntu (wired)  Ubuntu (wi-fi)  ping host.local    XX

Mac             Mac             ping host          XX
Mac (wired)     Mac (wired)     ping host.local    OK
Mac (wired)     Mac (wi-fi)     ping host.local    XX

Ubuntu          Mac             ping host          XX
Mac             Ubuntu          ping host          XX
Ubuntu (wired)  Mac    (wired)  ping host.local    OK
Mac    (wired)  Ubuntu (wired)  ping host.local    OK
Ubuntu (wired)  Mac    (wi-fi)  ping host.local    XX
Mac    (wired)  Ubuntu (wi-fi)  ping host.local    XX
---------------------------------------------------------
NOTE: host.local means using bonjour protocol

The picture is quite patchy, and I want to fix this.

The idea is to use NetBIOS-to-IP name resolution and the task consists of two parts:

Make host pingable using NetBIOS name from Windows.
Make Linux and Mac hosts ping other hosts using NetBIOS.

Interestingly, the job turned out much easier on Ubuntu than on a Mac.

Linux (Ubuntu)

First, make the Linux host pingable from Windows. Simply install samba package. It will install nmbd daemon which seems to be the one that makes this work.

# get samba
sudo apt-get install samba

# verify the thing is running
ps -ef | grep nmbd

Now doing ping ubuntuhost from Windows should work. But this is not sufficient to make ping work on Linux. The second step is required.

Second step is to install a WINS resolution thing which is provided by winbind package and bit of config file fiddling. Just follow these steps:

# install winbind
sudo apt-get install winbind

# verify the winbindd daemon is running
ps -ef | grep winbindd

# add WINS to the list of resolves in /etc/nsswitch.conf file
# here is the line to modify, simply add "wins" to the end.
hosts:          files mdns4_minimal [NOTFOUND=return] dns mdns4 wins

# now we should be able to ping using NetBIOS name:
ping netbioshost

After installing winbind I can now ping Linux host which have samba installed on them, or Mac hosts which have the same.

Mac OS X Snow Leopard

This is surprising hard to get the same thing working on Mac. The first step is easy and the second step, well, I still don't have a solution.

First, to make a Mac host pingable using NetBIOS name, I had to enable file sharing and tick the "SMB" option. Here is exactly what I did:

1. Open System Preferences
2. Click "Sharing"
3. Enable "File Sharing" by ticking the checkbox
4. Click "Options" button there, and
5. Make sure the "Share files and folders using SMB (Windows)" is ticked.

Now you should have nmbd daemon running. Verify this by opening terminal and:

ps -ef | grep nmbd

After this I can ping my Mac host from Windows and Linux which has samba installed.

Now to be able to ping hosts using NetBIOS name from Mac -- that's a completely different story. Basically, there is no /etc/nsswitch.conf file. And there is no winbindd daemon running (even though it's there). I don't have sufficient knowledge of OS X to get winbindd start at boot, but even starting manually I got some weird errors (which I fixed) but then there is no /etc/nsswitch.conf file so the ping still didn't work. But anyway here is what I did:

# first set the file permissions, as otherwise things don't work
sudo chmod 750 /private/var/samba/winbindd_privileged

# start winbindd without becoming a daemon and with output to terminal
sudo winbindd -i

# try ping my ubuntu host, doesn't work!
ping ubuntuhost

I have spent some time to try and find what's going on with the nsswitch.conf file and how to add wins to the resolvers on Snow Leopard and couldn't find anything. The only thing I can think of is use nmblookup to get the IP address and then use IP address, e.g.:

nmblookup ubuntuhost

If anyone knows how to get this working properly, drop me a line.

Summary

On Linux, install samba and winbind packages, then edit /etc/nsswitch.conf file. This will make the host pingable using NetBIOS names and also it will be possible to ping other NetBIOS hosts.

# get packages
sudo apt-get install samba
sudo apt-get install winbind

# add wins to the /etc/nsswitch.conf
hosts:          files mdns4_minimal [NOTFOUND=return] dns mdns4 wins

On Mac, make the host pingable by enabling file sharing for Windows clients. This will start nmbd daemon. I couldn't figure out what needs to be done to ping from Mac using NetBIOS. Still work in progress.

Here is the summary of the achievement:

Source host     Target host     Command            Status
---------------------------------------------------------
Windows         Windows         ping host          OK
Windows         Ubuntu          ping host          OK
Windows         Mac             ping host          OK

Ubuntu          Ubuntu          ping host          OK
Ubuntu          Windows         ping host          OK
Ubuntu          Mac             ping host          OK

Mac             Ubuntu          ping host          XX
Mac             Mac             ping host          XX
Mac             Windows         ping host          OK
---------------------------------------------------------
NOTE: I didn't include bonjour here, as there is no point
NOTE: Assume that Windows hosts are resolved by nslookup

If you know how to get this completed on a Mac, drop me a line at ppanyukov at googlemail.com.

Le C# Grit

2011-07-14T00:00:00-07:00

Le C# Grit

This is a growing list of my annoyances with C# which emerged after my exploration of other languages, in particular F#.

Functions are not first class citizens

There are many, many times when I want to have a nice function which does something but I need or want to break it into several smaller functions. In C# it often goes like this:

class Foo_Traditional
{
    public object GetStuff(object input)
    {
        object temp_A = this.GetStuff_Helper_A(input);
        object temp_B = this.GetStuff_Helper_B(temp_A);
        return temp_B;
    }

    private object GetStuff_Helper_A(object input)
    {
        return input.ToString() + "/GetStuff_Helper_A";
    }

    private object GetStuff_Helper_B(object input)
    {
        return input.ToString() + "/GetStuff_Helper_B";
    }
}

This is not nice because GetStuff_Helper_A and GetStuff_Helper_B are used only by one method but are now exposed as the class-level methods. What I want is to make those helper methods private to the implementation of GetStuff.

OK, let's rewrite this as lambdas.

class Foo_Lambdas_attempt_1
{
    public object GetStuff(object input)
    {
        // Error here: can't declare variable "input" as it's already declared!
        Func<object, object> get_stuff_helper_a = (input) =>
            {
                return input.ToString() + "/GetStuff_Helper_A (lambda)";
            };

        // Error here: can't declare variable "input" as it's already declared!
        Func<object, object> get_stuff_helper_b = (input) =>
        {
            return input.ToString() + "/GetStuff_Helper_B (lambda)";
        };

        object temp_A = get_stuff_helper_a(input);
        object temp_B = get_stuff_helper_b(temp_A);
        return temp_B;
    }
}

Two things to notice here:

It's not just a matter of copy/paste of class-level members. We must do some work to convert them to lambdas. And this involves declaring things like Func<object,object>.
We can't use the same variable name input as the parameter for the lambda because it's already delcared in outer scope. But what do we do? What if it makes perfect sense to call that variable input?

There are two solutions to the latter, none of which make things any easier:

Rename input to something else like input1; or
Remove the parameter from the lambda and use the one that's already declared. This will mean re-writing the Func<object,object> declaration into Fun<object> and removing the parameters. More work!

OK, I prefer to rename the parameters and end up with this:

class Foo_Lambdas_attempt_2_which_compiles
{
    public object GetStuff(object input)
    {
        // OK now, renamed input to input2
        Func<object, object> get_stuff_helper_a = (input2) =>
        {
            return input2.ToString() + "/GetStuff_Helper_A (lambda)";
        };

        // OK now, renamed input to input2
        Func<object, object> get_stuff_helper_b = (input2) =>
        {
            return input2.ToString() + "/GetStuff_Helper_B (lambda)";
        };

        object temp_A = get_stuff_helper_a(input);
        object temp_B = get_stuff_helper_b(temp_A);
        return temp_B;
    }
}

Now lets say I need a helper function which returns a IEnumerable<T>. I go an try to enhance my function with this helper lambda:

class Foo_with_enumerables
{
    public object GetStuff(object input)
    {
        Func<IEnumerable<string>> get_stuff_helper_c = () =>
            {
                // ERROR! Only methods, operators and accessors could contain 'yield' statement.
                yield return "this sucks";
            };

        ...
    }
}

And why the hell can't I have the lambda which returns an IEnumerable<T>??? What do I do now? Back to the class-level method I guess.

THIS SUCKS.

The F# way

Here is the same starting point, with main function and helpers being separate:

// Starting point
let get_stuff_helper_a input = 
    input.ToString() + "/GetStuff_Helper_A (F#)"

let get_stuff_helper_b input = 
    input.ToString() + "/GetStuff_Helper_A (F#)"

let DoStuff input = 
    let temp_A = get_stuff_helper_a input
    let temp_B = get_stuff_helper_b temp_A
    temp_B

Notice one thing immediately: there is much less clutter to start with.

Now let's hide those helper functions.

// Hide the helper functions
let DoStuff input = 
    let get_stuff_helper_a input = 
        input.ToString() + "/GetStuff_Helper_A (F#)"

    let get_stuff_helper_b input = 
        input.ToString() + "/GetStuff_Helper_A (F#)"

    let temp_A = get_stuff_helper_a input
    let temp_B = get_stuff_helper_b temp_A
    temp_B

Wow, just cut and paste them to be inside DoStuff, no change required!

And now lets see if we can add helper function which returns IEnumerable<T>.

// Add helper function returning IEnumerable<T>
let DoStuff input = 
    let get_stuff_helper_a input = 
        input.ToString() + "/GetStuff_Helper_A (F#)"

    let get_stuff_helper_b input = 
        input.ToString() + "/GetStuff_Helper_A (F#)"

    let get_stuff_helper_c () = seq {
        yield "this rocks!"
    }

    let temp_A = get_stuff_helper_a input
    let temp_B = get_stuff_helper_b temp_A
    temp_B

It works! And, incidentally, the function DoStuff is automatically generic:

'a -> string

which translates in C# terms as

string GetStuff<T>(T input)

In C# I would have to explicitly make the function generic (which is another story).

Lets summarise. In F# we have:

Cut/paste functions without changes. No can do in C#.
Re-bind different value to same name (aka no need to rename parameter). No can do in C#.
Can have any function within function, including those returning IEnumuerable<T>. No can do in C#.
Functions are generic by default. Not in C#.
Code seems to be much more concise and readable. C# has too much clutter, it's too verbose.

Can't assign lambdas to implicit variables

Scanario. I want to write something like this:

// C# -- This doesn't work
var someFun = (x) => 
{
    if (x > 0)
        return true;
    else
        return false;
};

No can do! Gives me a compiler error: error CS0815: Cannot assign lambda expression to an implicitly-typed local variable.

Instead I have to do the full type specification:

// C# -- This works
Func<int,bool> somFun = (x) =>
{
    if (x > 0)
        return true;
    else
        return false;
};

It might be OK if the types in use are simple like above, but what if they are not? For example:

// C# -- really bad
Fun<Map<string,DisposableWrapper<_MailItem>>, Tuple<DisposableWrapper<_MailItem>>> someFun2 = (stuffIn) =>
{
    ...
}

THIS SUCKS.

The F# way

And here is F#:

// F# -- this works
let someFun x = 
    if x > 0 then 
        true 
    else 
        false

Burning DVD images from AVI files

2011-07-11T00:00:00-07:00

Burning DVD images from AVI files

General sequence

My understanding is that the general sequence is like this:

AVI -> MPEG2 -> DVD File System -> DVD ISO -> DVD Disk

In order to do all this, we need:

tools to do each of the steps;
codecs to encode/decode video and audio embedded in the AVI/MPEG2 files.

This may not be so easy, especially on Windows, but is manageable on Linux.

On Windows

So you are on Windows and want to burn that AVI files your friends gave you to a DVD and watch it on telly. From what I remember, this is all very painful. The problems generally are:

The AVI files may use codecs which you don't have;
The players you use (e.g. Windows Media Player) doesn't tell you which codecs you need, it just refuses to play the stuff.
No idea where to take those codecs even if you knew which ones you need.
Even if you have the codecs, you still need the software to create the DVD! And they are not free and all of those I used were beyond crap.

What to do? Here is a quick solution:

Get yourself Oracle VirtualBox.
Get yourself a distribution of Linux. Ubuntu
Install it and follow instructions for Linux. Easy!

And besides, the benefit is learning Linux too.

Creating DVD images from AVI files on Linux

Tools

Tool      Step                          Apt-get package
---------------------------------------------------------
ffmpeg    (AVI -> MPEG2)                gstreamer0.10-*
dvdauthor (MPEG2 -> DVD File System)    dvdauthor
mkisofs   (DVD File System -> DVD ISO)  genisoimage
growisofs (DVD ISO -> DVD)              growisofs

To install these do from command line:

sudo apt-get install gstreamer0.10.-* dvdauthor genisoimage growisofs

Details

Export the video format as an environmental variable, otherwise there may be problems with the DVD file system.
```
export VIDEO_FORMAT=PAL
```

Encode AVI file into MPEG2. This will take a while!

ffmpeg -i <input_avi> -target pal-dvd -ps 2000000000 -aspect 16:9 output.mpg

Create a DVD file system from the MPEG2 file. (NOTE: delete the target directory first).

dvdauthor -o <output_dir> -t -v "PAL+16:9" -f output.mpg

(NOTE: I'm not sure this command line works properly, I think the
switch should be "-T" instead of "-t" but I haven't checked this yet.)

Create a DVD ISO image from the directory.
```
mkisofs -dvd-video -o dvd.iso dvd/
```

Burn the DVD ISO onto disk

growisofs -dvd-compat -Z /dev/dvd=dvd.iso

Retabbing files using VIM

2011-06-29T00:00:00-07:00

Retabbing files using VIM

Recently I've made a mistake of using 2 spaces to indent my F# program. After some thought I decided to stick to 4 spaces like everyone else does.

Here is how it looked:

module foomodule
  let foo = 
    let bar = 
      get_file_names()
      |> Seq.filter (f -> f.EndsWith(".cs")
    let bar2 = do_something_with_bar bar
    bar2

And here is how I wanted it to look

module foomodule
    let foo = 
        let bar = 
            get_file_names()
            |> Seq.filter (f -> f.EndsWith(".cs")
        let bar2 = do_something_with_bar bar
        bar2

What to do? This is not as trivial as it may look. But not if use use VIM!

Here is how to retab everything using VIM:

Step 0. (Optional) Tell VIM to show whitespace:

:set list

Step 1. Tell VIM what the the current tabsize is:

:set tabstop=2      " Tab size is 2 spaces

Step 2. Convert spaces to real tabs:

:set noexpandtab    " Use real tab instead of space
:retab!             " Replace all space-tabs with real tabs

Step 3. Convert real tabs back to spaces, using tabsize 4

:set expandtab      " User spaces instead ot tab
:set tabstop=4      " 4 spaces for each tab
:retab              " Reformat using new tabbing policy

It's possible to get all this on one line:

:set ts=2 noet | retab! | set et ts=4 | retab

Le Test

2011-06-11T00:00:00-07:00

Test

Sub-heading

Item 1
Item 2

Why is the code below highlighted as a comment?

using System;

class Program
{
    static void Main()
    {
        Console.WriteLine("Hello, World");
    }
}

Esoteric languages

2011-06-10T00:00:00-07:00

Esoteric languages

brainfuck

The following program prints "Hello World!" and a newline to the screen:

    +++++ +++++             initialize counter (cell #0) to 10
    [                       use loop to set the next four cells to 70/100/30/10
        > +++++ ++              add  7 to cell #1
        > +++++ +++++           add 10 to cell #2 
        > +++                   add  3 to cell #3
        > +                     add  1 to cell #4
        <<<< -                  decrement counter (cell #0)
    ]                   
    > ++ .                  print 'H'
    > + .                   print 'e'
    +++++ ++ .              print 'l'
    .                       print 'l'
    +++ .                   print 'o'
    > ++ .                  print ' '
    << +++++ +++++ +++++ .  print 'W'
    > .                     print 'o'
    +++ .                   print 'r'
    ----- - .               print 'l'
    ----- --- .             print 'd'
    > + .                   print '!'
    > .                     print '\n'

LOLCODE

Example 1

    HAI
    CAN HAS STDIO?
    VISIBLE "HAI WORLD!"
    KTHXBYE

Example 2

    HAI CAN HAS STDIO?
    PLZ OPEN FILE "LOLCATS.TXT"?
        AWSUM THX
            VISIBLE FILE
        O NOES
            INVISIBLE "ERROR!"
    KTHXBYE

Example 3

    HAI
    CAN HAS STDIO?
    I HAS A VAR
    IM IN YR LOOP
       UP VAR!!1
       VISIBLE VAR
       IZ VAR BIGGER THAN 10? KTHX
    IM OUTTA YR LOOP
    KTHXBYE