node-netbios-name

A utility module for working with NetBIOS names as defined in RFC1001, RFC1002, and RFC883.

Example

var NBName = require('netbios-name');

// The following two statements are equivalent
var nbname = new NBName({fqdn: 'foobar.example.com', suffix: 0x20});
var nbname = new NBName({name: 'foobar', scopeId: 'example.com',
                         suffix: 0x20});

if (nbname.error) {
  throw nbname.error;
}

nbname.name === 'foobar';                           // true
nbname.paddedName === 'foobar         ';            // true
nbname.scopeId === 'example.com';                   // true
nbname.fqdn === 'foobar.example.com';               // true
nbname.suffix === 0x20;                             // true
nbname.usage === 'File Server Service';             // true
nbname.toString() === 'foobar<20>.example.com';     // true

var buf = new Buffer(128);

var res = nbname.write(buf, 0, {});
if (res.error) {
  throw res.error;
}

var nbname2 = NBName.fromBuffer(buf, 0);
if (nbname2.error) {
  throw nbname2.error;
}

nbname2.bytesRead === res.bytesWritten;             // true
nbname2.name === nbname.name;                       // true
nbname2.scopeId === nbname.scopeId;                 // true
nbname2.fqdn === nbname.fqdn;                       // true
nbname2.suffix === nbname.suffix;                   // true
nbname2.usage === nbname.usage;                     // true

Class: NetbiosName

This class represents the name of a single NetBIOS node or service. It consists of the following properties:

• name {String} The short NetBIOS name. This is equivalent to the first label in a fully qualified domain name. The NetBIOS name is restricted to a maximum length of 15 characters.
• scopeId {String} The scope identifier or domain name that the node belongs to. For example, if the fully qualified domain name is host.example.com, then the scopeId property will be example.com and the name property above will be host.
• suffix {Number} The trailing suffix byte that combines with the NetBIOS name above to create a 16-byte fixed width field. Microsoft popularized the use of this byte for indicating the type or usage of the node. Typically suffix byte values will be defined and displayed in hex; e.g. 0x00 for workstations or 0x20 for file servers.

In addition to the basic properties, the class also derives the following values as a convenience:

• paddedName {String} The same as the name field space padded out to 15 characters.
• fqdn {String} The combination of the name field and the scopeId field.
• usage {Sring} A human readable string describing the typical usage for the given suffix byte. If the suffix does not match a typical value, then usage will be set to 'unknown'. These usage values are taken from the Microsoft NetBIOS Suffixes knowledge base article.

Finally, instances of NetbiosName can also have additional properties based on how the object was created:

• error {Error Object} This property will be set if the constructor or fromBuffer() method encounter an error while creating the NetbiosName object. This property should always be checked before using the instance or any of its other properties.
• bytesRead {Number} This property indicates how many bytes were read from the buffer passed to fromBuffer() in order to create this instance.

Note, all properties are set in the constructor or the fromBuffer() factory method. If you write to one of the properties, don't expect any other values to get updated to reflect the change.

new NetbiosName(opts)

Construct a new NetbiosName instance for a given name and suffix.

• opts {Object} A hash of named parameters. Accepted options are:
  • fqdn {String} The fully qualified domain name to use.
  • name {String} The short NetBIOS name to use. This is only referenced if fqdn is not present.
  • scopeId {String} The trailing domain name to be combined with the name property. This should not include a leading dot. This is only referenced if fqdn is not present.
  • suffix {Number} The suffix byte value to use. If this is not present then the suffix defaults to 0x00 which typically represents a workstation service.
• Returns a new NetbiosName instance. Note that if there are any problems the error property of the NetbiosName object will be set. Typically errors only occur if a name is not provided or if its illegal due to length, etc.

NetbiosName.fromBuffer(buf, offset)

Construct a new NetbiosName object from a binary buffer.

• buf {Buffer Object} The buffer to read the name from. Note, if this name is being read from a message that uses name pointers, the first byte of the buffer must correspond to the start of the message. So don't just slice() to the start of the name since the pointer offsets will be meaningless.
• offset {Number} The offset from the start of the buffer indicating where to begin reading.
• Returns a new NetbiosName object instance. Make sure to check the error property on the returned object before using any other properties. Also, see the bytesRead property to determine how much of the buffer was processed by this method.

nbname.write(buf, offset, nameMap)

Write the NetbiosName object instance out to the given buffer.

• buf {Buffer Object} The buffer to write the name to. Again, if name pointers are going to be used, the start of the buffer must match the start of the overall NetBIOS message.
• offset {Number} Where to begin writing the name within the buffer.
• nameMap {Object | null} If provided the location of the name within the buffer will be stored in the nameMap. If the same nameMap is used to write the same name again or a portion of the name, then a name pointer will used to compress the name within the buffer. Passing null will disable the use of name pointers.
• Returns an Object containing two properties.
  • error {Error Object} If an error occurred during writing this property will be set. The buffer may have been partially modified even if an error occurs.
  • bytesWritten {Number} The number of bytes written to the buffer.

nbname.toString()

Return a string representation of the NetBIOS name. The format matches the style used by wireshark. For example, a name of foobar, a scope ID of example.com, and suffix of 0x20 would be returned as the string 'foobar<20>.example.com'.

The string returned contains all of the unique information in the name, so it can be reasonably used as the key for a hash.