Perl/Math::Bezier ... plotting a bezier curve given some control points

doesn't actually draw anything - just gets the data points necessary to plot one. I did this because I needed a series of 22 numbers starting with 0.0125 that gradually ramped up to 7.4 with step getting larger for each iteration.

#!/usr/local/bin/perl -w

use strict;
use Math::Bezier;

my $MAXX = 22.0;
my $MAXY = 7.4;

my $x0 = 0;
my $y0 = 0.0125;
my $x1 = $MAXX*0.5;
my $y1 = 0.0000;
my $x2 = $MAXX;
my $y2 = $MAXY;

my @control = ( $x0, $y0, $x1, $y1, $x2, $y2 );


my $bezier = Math::Bezier->new(@control);

for ( my $i = 0; $i < ($MAXX+1); $i++) {

    my $divisor = $i / $MAXX;
    my ( $x, $y )  = $bezier->point($divisor);
    printf "divisor=%8.4f x=%8.4f y=%8.4f\n", $divisor, $x, $y;

}



unix:~ 1607 $ ./bezier.pl 
divisor=  0.0000 x=  0.0000 y=  0.0125
divisor=  0.0455 x=  1.0000 y=  0.0267
divisor=  0.0909 x=  2.0000 y=  0.0715
divisor=  0.1364 x=  3.0000 y=  0.1469
divisor=  0.1818 x=  4.0000 y=  0.2530
divisor=  0.2273 x=  5.0000 y=  0.3897
divisor=  0.2727 x=  6.0000 y=  0.5570
divisor=  0.3182 x=  7.0000 y=  0.7550
divisor=  0.3636 x=  8.0000 y=  0.9836
divisor=  0.4091 x=  9.0000 y=  1.2428
divisor=  0.4545 x= 10.0000 y=  1.5326
divisor=  0.5000 x= 11.0000 y=  1.8531
divisor=  0.5455 x= 12.0000 y=  2.2042
divisor=  0.5909 x= 13.0000 y=  2.5860
divisor=  0.6364 x= 14.0000 y=  2.9983
divisor=  0.6818 x= 15.0000 y=  3.4413
divisor=  0.7273 x= 16.0000 y=  3.9150
divisor=  0.7727 x= 17.0000 y=  4.4192
divisor=  0.8182 x= 18.0000 y=  4.9541
divisor=  0.8636 x= 19.0000 y=  5.5197
divisor=  0.9091 x= 20.0000 y=  6.1158
divisor=  0.9545 x= 21.0000 y=  6.7426
divisor=  1.0000 x= 22.0000 y=  7.4000

Perl get SSL certificate subject alternative names (aka aliases)

#!/usr/local/bin/perl -w

use strict;

my $website = $ARGV[0] || '';

die "usage: $0 <website:sslport>\n" if (($website eq '') || ($website !~ m!^\S+:\d+$!o));

my $openssl = '/usr/local/bin/openssl';

die "openssl binary not found at $openssl\n" if ( ! -x $openssl );

my $s_client_output = qx{ echo | $openssl s_client -connect $website 2> /dev/null };

my $certcount = 0;

while ($s_client_output =~ m!(-----BEGIN CERTIFICATE-----.*?-----END CERTIFICATE-----).*?!smg) {
    my $cert_text = $1;
    my $x509_out = qx{ echo '$cert_text' | $openssl x509 -noout -text 2> /dev/null };
    while ($x509_out =~ m!DNS:([\w\-\.\*]+).*?!smg) {
        my $alias = $1;
        printf "alias for %s (%d) == %s\n", $website, $certcount, $alias;
    }
    $certcount++;
}

Blender/Python: Plot stars from the HYG data

Plots stars on the inside of a sphere using three different types of solids. Most stars are tetrahedrons, brighter stars are octahedrons and the brightest stars are plotted as dodecahedrons. ps. feel free to use this however you want but please don't republish the code as I don't want multiple copies all over the internet as I am likely to update this script every now and then... oh and if you make a million dollars out of it somehow, be sure to donate some of that money to the needy. If I ever find a file hosting service that I like, I'll post the completed .blend file there to save the trouble of running it seeing how the whole catalog can take six or more hours to run...

#!/usr/local/bin/python
#
# $Header: /home/zero/Blender/SOL-Centered-Starsphere-solid/RCS/starsphere-sol-solid-010.py,v 1.21 2015/01/31 03:35:33 zero Exp zero $
#
# PURPOSE:
#
# Script to build up a starfield using the data from the HYG catalogue
#
# DATA SOURCE:
#
# http://astronexus.com/node/34
#
# GET data file from http://astronexus.com/files/downloads/hygxyz.csv.gz
#
# DESCRIPTION:
#
# Stars are plotted on the "inside" of an imaginary sphere. Most stars
# are plotted as tetrahedrons , brighter stars as octahedrons and brightest
# stars as dodecahedrons. Stars are plotted according to their spectral type
# with each spectral type being a seperate object
#
# USAGE:
#
# I run this on my FreeBSD machine with 
#
# unix:~ $ blender -noaudio -P starsphere-sol-solid.py >& OUT < /dev/null &
#
# then once it has finished, (it can take many hours to run) I save the whole
# thing as a .blend file and then I *append* it into Blender via the
# "Shift-F1" feature (Menu: File->Append)
#
# I see no reason why this wouldn't run on other Unix variants, but if you are 
# going to use this on Windows then I've got no idea if it will work for you!
#
# NOTE that blender seems to take quite a while to exit after generating
# the field
import os  
import sys
from mathutils import *; from math import *
import re
import bpy
import traceback

#----------------------------------------------------------------------------
#
# Alter this to point to where you have put your downloaded copy of the Gzipped data
#
hygxyz_file = '/home/zero/Downloads/hygxyz.csv.gz'

#
# full path name of the appropriate unzipper to decompress the data file
#
dezipper = '/usr/bin/gzcat'

#----------------------------------------------------------------------------
# turn on debugging output
debug = 1

# anything fainter than this is skipped completely 
# this is used in the main loop and has no effect on the star size
# NOTE: any value above 20 will give you to *whole* 120,000+ stars
# from the HYG catalog and will take something like six hours to run.
# for testing it out, set the value to 5.0 or so and that will only plot
# the brightest stars
# skip_mag = 5.0 # Takes about twenty seconds
# skip_mag = 8.0 # Takes about thirty-five minutes
skip_mag = 8.0

# "base" minimum star brightness, this is used for size of star calculations.
# set to 20 to as brown dwarf stars tend to be this bright (absolute magnitude)
faintest = 20

# Plot all stars in a sphere so all stars are the same distance away
# from the camera, requires use of Visual magnitude
use_sphere = 1

# Stars will be plotted on the inside "surface" of an imarginary sphere
# with a radius this big
sphere_size = 2000

#----------------------------------------------------------------------------
# create mesh using visual magnitude
def create_star_solid(mesh,mag):
    # A tetrahedron
    # adjust for Sirius (the brightest star) it will be factor=0
    factor = mag + 1.44
    # now reverse the scale of size, Sirius will be of factor=2.2
    factor = (faintest - factor) / 10
    # now exaggerate the difference
    # TODO (should be the 2.5 times brighter for each magnitude)
    factor = factor * factor * factor

    # most stars will be a tetrahedron
    if   mag > 6: verts, faces = calculate_tetrahedron(factor)
    # brighter stars will be a octahedron
    elif mag > 3: verts, faces = calculate_octahedron(factor)
    # brightest stars will be a dodecahedron
    else:         verts, faces = calculate_dodecahedron(factor)

    mesh.from_pydata(verts, [], faces)
    mesh.update()

    return

# solid calculations are based on bits of code from blender itself. 
# under FreeBSD the file is located here...
# /usr/local/share/blender/scripts/addons/add_mesh_extra_objects/add_mesh_solid.py
def calculate_tetrahedron(factor):
    s = (sqrt(2)/3.0) * factor
    t = (-1/3) * factor
    u = (sqrt(6)/3) * factor
    v = 1 * factor
    verts = [(0,0,v),(2*s,0,t),(-s,u,t),(-s,-u,t)]
    faces = [[0,1,2],[0,2,3],[0,3,1],[1,3,2]]
    return verts, faces

def calculate_octahedron(factor):
    v = 1 * factor
    verts = [(v,0,0),(-v,0,0),(0,v,0),(0,-v,0),(0,0,v),(0,0,-v)]
    faces = [[4,0,2],[4,2,1],[4,1,3],[4,3,0],[5,2,0],[5,1,2],[5,3,1],[5,0,3]]
    return verts, faces

def calculate_dodecahedron(factor):
    s = 1/sqrt(3) * factor
    t = sqrt((3-sqrt(5))/6) * factor
    u = sqrt((3+sqrt(5))/6) * factor
    verts = [(s,s,s),(s,s,-s),(s,-s,s),(s,-s,-s),(-s,s,s),(-s,s,-s),(-s,-s,s),(-s,-s,-s),
         (t,u,0),(-t,u,0),(t,-u,0),(-t,-u,0),(u,0,t),(u,0,-t),(-u,0,t),(-u,0,-t),(0,t,u),
         (0,-t,u),(0,t,-u),(0,-t,-u)]
    faces = [[0,8,9,4,16],[0,12,13,1,8],[0,16,17,2,12],[8,1,18,5,9],[12,2,10,3,13],
             [16,4,14,6,17],[9,5,15,14,4],[6,11,10,2,17],[3,19,18,1,13],[7,15,5,18,19],
             [7,11,6,14,15],[7,19,3,10,11]]
    return verts, faces

#----------------------------------------------------------------------------
# extract the first thing that looks like a spectral type,
# ie. for stars that have multiple spectral types listed, the first is used
def get_spectral_type(spectrum):
    m = spectrum_regex.match(spectrum)
    if m:
        spectral_type = m.group(1)
    else:
        if debug > 1: print('unhandled spectral type "{}"'.format(spectrum))
        # if we can't make sense of the spectral type we are given, then
        # set the colour to be white instead of discarding it as unclassified
        spectral_type = 'A0'
    return spectral_type

#----------------------------------------------------------------------------
# create object under a parent
def create_star_object(parent,spectral_type,mag,x,y,z,RA,DEC):

    # create a mesh for this star
    star_mesh = bpy.data.meshes.new(spectral_type+'Mesh')
    # now create a new object for that mesh
    star_object = bpy.data.objects.new(spectral_type, star_mesh)

    # assign the parent
    star_object.parent = parent

    # set location
    star_object.location = (x, y, z)

    # link object to the scene
    bpy.context.scene.objects.link(star_object)

    # create less complex objects for dimmer stars
    create_star_solid(star_mesh, mag)

    # set the object origin, assumes the cursor is at 0,0,0
    bpy.ops.object.origin_set(type='ORIGIN_CURSOR')

    # point the Z axis at origin - this is done so that the tetrahedron
    # has the maximum area pointing at the origin so that the surface
    # area is the same no matter where the star was plotted. If this wasn't
    # done, half of the tetrahedron stars would be "side-on" and would appear
    # slightly dimmer than they should be
    star_object.matrix_world *= Matrix.Rotation(radians(RA*15), 4, "Z")
    star_object.matrix_world *= Matrix.Rotation(radians((DEC+90)*-1), 4, "Y")

    spectral_type_material = bpy.data.materials.get(spectral_type)

    # Set object material
    if spectral_type_material is None:
        spectral_type_material = bpy.data.materials.new(spectral_type)
        star_object.data.materials.append(spectral_type_material)

        # Extract the spectral Letter and Number
        m = spectral_type_regex.match(spectral_type)

        # spectral Letter
        s_l = m.group(1)
        # spectral Number
        s_n = m.group(2)

        if debug > 5: print('s_l={} s_n={}'.format(s_l, s_n))

        # bit of a dogdy algorithm to set the colour but it's good enough for now
        if   m_regex.search(s_l): diffuse = ( 1.00, 0.00 + (int(s_n) / 20.0), 0.00 ) 
        elif k_regex.search(s_l): diffuse = ( 1.00, 0.50 + (int(s_n) / 20.0), 0.00 )
        elif g_regex.search(s_l): diffuse = ( 1.00, 1.00, 0.00 + (int(s_n) / 20.0) )
        elif f_regex.search(s_l): diffuse = ( 1.00, 1.00, 0.50 + (int(s_n) / 20.0) )
        elif a_regex.search(s_l): diffuse = ( 1.00 - (int(s_n) / 40.0), 1.00 - (int(s_n) / 40.0), 1.00 )
        elif b_regex.search(s_l): diffuse = ( 0.75 - (int(s_n) / 40.0), 0.75 - (int(s_n) / 40.0), 1.00 )
        elif o_regex.search(s_l): diffuse = ( 0.50 - (int(s_n) / 80.0), 0.50 - (int(s_n) / 80.0), 1.00 )
        else: diffuse = ( 1.00, 1.00, 1.00 )

        # use the colour we established above
        spectral_type_material.diffuse_color = diffuse
        # specular colour isn't used but set it anyway
        spectral_type_material.specular_color = diffuse

        # turn on emit
        spectral_type_material.emit = 1

        # set various material properties that we aren't really interested
        # in ie. we don't have want to use the specular and we also
        # don't want these stars to be casting shadows, nor receiving them
        spectral_type_material.specular_intensity = 0
        spectral_type_material.ambient = 0
        spectral_type_material.use_shadows = 0
        #not sure about this one#spectral_type_material.use_raytrace = 0
        spectral_type_material.use_ray_shadow_bias = 0
        spectral_type_material.use_mist = 0
        spectral_type_material.use_cast_approximate = 0
        spectral_type_material.use_cast_buffer_shadows = 0
        spectral_type_material.use_cast_shadows = 0
    else:
        star_object.data.materials.append(spectral_type_material)

    # If this is a subsequent star in a spectral type, join it to the first.
    # All master star objects will be two characters long G0 B6 K4 etc etc
    # Subsequent star objects will be A0.001 B6.001 etc etc so only the first
    # star created in a spectral type will have a two character name
    if len(star_object.name) != 2:
        # deselect all
        bpy.ops.object.select_all(action='DESELECT')

        # Select the current star
        star_object.select = True

        # Select the master star object
        bpy.data.objects[spectral_type].select = True

        # Make the master star the active object
        bpy.context.scene.objects.active = bpy.data.objects[spectral_type]

        # now join them
        bpy.ops.object.join()

    return


#-------------------------------------------------------------------
# calculate X Y Z co-ordinates on the inside "surface" of a sphere
# algorithm from http://www.projectrho.com/public_html/starmaps/trigonometry.php
def plot_star_on_sphere(starfield_parent, spectral_type, mag, RA, DEC):
    PHI = radians(RA * 15)
    THETA = radians(DEC)
    RHO = sphere_size

    if debug > 4:
        print('RHO={} THETA={} PHI={} Mag={} Spectrum={} RA={} DEC={}'.format(
            RHO, THETA, PHI, mag, spectrum, RA, DEC))

    RVECT = RHO * cos(THETA)
    x = RVECT * cos(PHI)
    y = RVECT * sin(PHI)
    z = RHO * sin(THETA)

    # Add the star solid
    create_star_object(starfield_parent, spectral_type, mag, x, y, z, RA, DEC)

    return


#-------------------------------------------------------------------------------
#---------------main------------------------------------------------------------
#-------------------------------------------------------------------------------
#
# Compile up the regexes (avoids compiling the regexes for each star plotted)
#
m_regex = re.compile('^[mM]')
k_regex = re.compile('^[kK]')
g_regex = re.compile('^[gG]')
f_regex = re.compile('^[fF]')
a_regex = re.compile('^[aA]')
b_regex = re.compile('^[bB]')
o_regex = re.compile('^[oO]')
spectrum_regex = re.compile("([OBAFGKM]\d)")
spectral_type_regex = re.compile("([OBAFGKM])(\d)")

# Delete the default objects
# deselect all
bpy.ops.object.select_all(action='DESELECT')
# select all the default objects
bpy.data.objects['Cube'].select = True
bpy.data.objects['Lamp'].select = True
bpy.data.objects['Camera'].select = True
# and delete them
bpy.ops.object.delete()

# Make sky completely black
bpy.data.worlds['World'].horizon_color = ( 0, 0, 0 )

#-------------------------------------------------------------------------------
# Add our own camera
bpy.ops.object.camera_add(view_align=False, location=(0, 0, 0), rotation=(radians(78), 0, 0))
# get the camera object
starcam = bpy.context.object
# set the camera object name
starcam.name = "STARCAM"
# set the camera clip to be far, far away
bpy.data.cameras[-1].clip_end=9999
# set the size of the camera to be really wide
bpy.data.cameras[-1].lens=22

#-------------------------------------------------------------------------------
# Add the Star objects' parent
bpy.ops.object.add(type='EMPTY')
# set object mode
bpy.ops.object.mode_set(mode='OBJECT')
# get object
starfield_parent = bpy.context.object
# set object name
starfield_parent.name = "StarSphere"

#-MAIN-LOOP---------------------------------------------------------------------
# StarID,HIP,HD,HR,Gliese,BayerFlamsteed,ProperName,RA,DEC,Distance,PMRA,PMDEC,RV,Mag,AbsMag,Spectrum,ColorIndex,X,Y,Z,VX,VY,VZ
# read data file
for myline in os.popen(dezipper + ' ' + hygxyz_file):
    if debug > 8:
        sys.stdout.write(myline)

    # split the line into an array 'f' on the ',' field seperator
    f = myline.split(',')

    # apparently this is how you do things in python
    # this will attempt to parse the line
    # if for some reason it fails, it goes down to the bottom
    try:
        propername = str(f[6])
        # Skip the title record
        if propername == 'ProperName': continue
        # Skip the sun, it's supposed to be in the middle anyway
        if propername == 'Sol': continue
        bayerflamsteed = str(f[5])
        RA = float(f[7])
        DEC = float(f[8])

        mag = float(f[13])

        absmag = float(f[14])

        # skip out if the star isn't very bright (for debugging)
        #if debug > 5 and mag > 1.0: continue
        if mag > skip_mag: continue
        spectrum = f[15]

        spectral_type = get_spectral_type(spectrum)

        # skip out if we don't have a type - shouldn't happen, probably dud data
        if spectral_type == '': continue

        x = float(f[17])
        y = float(f[18])
        z = float(f[19])

        if use_sphere > 0: plot_star_on_sphere(starfield_parent, spectral_type, mag, RA, DEC)
        else:
            if debug > 1:
                print('Star rejected ProperName={} Mag={} AbsMag={} Spectrum={} x={} y={} z={}'.format(
                    propername, mag, absmag, spectrum, x, y, z))


        pass
    # this is called when the line is a dud
    except:
        if debug: print("something failed: input line was ", myline)
        traceback.print_exc()
        # Print some debugging info upon uncontrolled exit
        for i in bpy.data.meshes: print("MeshName=="+i.name)
        # exit completely if the debug setting is high
        if debug > 5: sys.exit()
        else: continue

# set object mode again
bpy.ops.object.mode_set(mode='OBJECT')

Blender/Python: creating a tetrahedron

creating a tetrahedron in Python for blender (Code extracted from larger code available all over the interwebs ie. it is hard to give an actual source)

import math
import bpy


s = math.sqrt(2)/3.0
t = -1/3
u = math.sqrt(6)/3

# create tetrahedron with centre of mass being at Z=0
verts = [(0,0,1),
         (2*s,0,t),
         (-s,u,t),
         (-s,-u,t)]
faces = [[0,1,2],[0,2,3],[0,3,1],[1,3,2]]

# create another one where the base is at Z=0
#verts = [( 0.0, -1.0 / math.sqrt(3),       0.0),
#         ( 0.5,  1.0 / (2.0 * math.sqrt(3)), 0.0),
#         (-0.5,  1.0 / (2.0 * math.sqrt(3)), 0.0),
#         ( 0.0,  0.0, math.sqrt(2 / 3))]
#faces = [[0, 1, 2], [0, 1, 3], [1, 2, 3], [2, 0, 3]]

mesh = bpy.data.meshes.new("Tetrahedron")
mesh.from_pydata(verts, [], faces)
mesh.update()
obj = bpy.data.objects.new("Tetrahedron", mesh)
bpy.context.scene.objects.link(obj)

WHOIS caching proxy in perl

#!/usr/bin/perl
#
# $Header: /usr/local/etc/RCS/whois-proxy.pl,v 1.8 2014/11/04 22:47:28 mwd Exp $
#
# WHOIS caching proxy
#
#-----------------------------------------------------------------------
my $VERSION = substr( q$Revision: 1.8 $, 10 );

package Whois {
    use strict;
    use warnings;
    use POSIX qw( strftime );

    use parent 'Net::Server::PreFork';

    use Net::Whois::Proxy;
    use Cache::FileCache;
    use Net::IP::Match::XS;
    use Net::CIDR;

    my $debug = 1;

    logstderr("starting $0 ( v$VERSION)") if ($debug);

    sub whois_query {

        my $request = shift;
        my $expires = '';
        my $created = '';

        # default the lookup key to the original request, that way
        # if we can't find a proper key to use, we fall back to
        # the original request just so we don't waste the lookup.
        # ie. at the very least, if we lookup this address again,
        # it will be cached using itself as a key
        my $key = $request;
        my $whois_body_cache =
          new Cache::FileCache(
                                {'namespace'          => 'WHOIS_cache',
                                 'default_expires_in' => '7 days'} );

        foreach my $cache_key ( $whois_body_cache->get_keys() ) {
            logstderr("cache_key==$cache_key") if ( $debug > 5 );
            if ( my $match_key = match_ip( $request, $cache_key ) ) {
                logstderr("using MATCHED KEY $cache_key for $request") if ( $debug > 1 );
                $key = $cache_key;
            } else {
                logstderr("$request did NOT match $cache_key") if ( $debug > 4 );
            }
        }

        # Get the body based on the original IP address we were given
        my $body = $whois_body_cache->get($key);

        # Didn't get a cache hit? do the WHOIS lookup from scratch
        if ( not defined $body ) {
            my $whois = Net::Whois::Proxy->new( debug => 0, stacked_results => 1, clean_stack => 1 );

            logstderr("looking up $request from remote WHOIS databases") if ($debug);
            $body = $whois->whois($request);

            if ( !$body ) {
                $body = $whois->errstr;
            } else {

                my $netaddresses = '';
                my %CIDRs        = ();

                # Step thru and extract all things that look like a CIDR or a NETRANGE
                # and then see which one is the best match for the requested IP address
                # BEST MATCH will most likely be the CIDR/mask where the mask is the largest
                # integer that still matches that subnet
                # 161.143.0.0 - 161.143.255.255
                # 18.0.0.0/8
                # 14.0.0/8
                # 10.0/8
                # 55/8 # Hopefully we  don't get these
                while ( $body =~
m!(\d+\.\d+\.\d+\.\d+\s+\-\s+\d+\.\d+\.\d+\.\d+)|(\d+\.\d+\.\d+\.\d+/\d+)|(\d+\.\d+\.\d+/\d+)|(\d+\.\d+/\d+)|(\d+/\d+)!osmg
                  ) {
                    my ( $netrange, $full_cidr, $ctype_cidr, $btype_cidr, $atype_cidr ) =
                      ( $1, $2, $3, $4 );

                    if ( defined $netrange ) {
                        logstderr("FOUND NETRANGE $netrange");

                        # convert NETRANGE to CIDR
                        foreach my $range_cidr ( Net::CIDR::range2cidr($netrange) ) {
                            if ( $range_cidr =~ m!(\d+\.\d+\.\d+\.\d+)/(\d+)!o ) {
                                logstderr("FOUND FULL CIDR FROM NETRANGE $range_cidr");
                                my ( $full, $mask ) = ( $1, $2 );
                                $full_cidr = "$full/$mask";
                                $CIDRs{$full_cidr} = $mask;
                            }
                        }
                    } elsif ( defined $full_cidr ) {
                        logstderr("FOUND FULL CIDR $full_cidr");
                        if ( $full_cidr =~ m!(\d+\.\d+\.\d+\.\d+)/(\d+)!o ) {
                            my ( $full, $mask ) = ( $1, $2 );
                            $full_cidr = "$full/$mask";
                            $CIDRs{$full_cidr} = $mask;
                        }
                    } elsif ( defined $ctype_cidr ) {
                        logstderr("FOUND CTYPE CIDR $ctype_cidr");
                        if ( $ctype_cidr =~ m!(\d+\.\d+\.\d+)/(\d+)!o ) {
                            my ( $c, $mask ) = ( $1, $2 );
                            $ctype_cidr = "$c.0/$mask";
                            $CIDRs{$ctype_cidr} = $mask;
                        }
                    } elsif ( defined $btype_cidr ) {
                        logstderr("FOUND BTYPE CIDR $btype_cidr");
                        if ( $btype_cidr =~ m!(\d+\.\d+)/(\d+)!o ) {
                            my ( $b, $mask ) = ( $1, $2 );
                            $btype_cidr = "$b.0.0/$mask";
                            $CIDRs{$btype_cidr} = $mask;
                        }
                    } elsif ( defined $atype_cidr ) {
                        logstderr("FOUND ATYPE CIDR $atype_cidr");
                        if ( $atype_cidr =~ m!(\d+)/(\d+)!o ) {
                            my ( $a, $mask ) = ( $1, $2 );
                            $atype_cidr = "$a.0.0.0/$mask";
                            $CIDRs{$atype_cidr} = $mask;
                        }
                    }
                } ## end while ( $body =~ ...)

                # Step thru all the CIDRs sorting by highest bit mask first.
                # the address we want as a key, will be the CIDR that first
                # matches the highest netmask
                foreach my $cidr_key ( sort { $CIDRs{$b} <=> $CIDRs{$a} } keys %CIDRs ) {

                    # if the bitmask is greater than 32 we bail out - no CIDR bit masks are greater
                    # than 32 - at least in IPv4 and we only handle IPv4 so....
                    next if ( $CIDRs{$cidr_key} > 32 );

                    $netaddresses .= "$cidr_key, ";

                    logstderr("$cidr_key==$CIDRs{$cidr_key}") if ( $debug > 2 );

                    # if we get a match, set the key to this CIDR and skip the rest of the foreach loop
                    if ( my $match_key = match_ip( $request, $cidr_key ) ) {
                        logstderr("setting key for $request as $cidr_key");
                        $key = $cidr_key;

                        # BAIL out of the loop, we found what we are looking for...
                        last;
                    }

                } ## end foreach my $cidr_key ( sort...)

                # Chop off the final ", "
                $netaddresses =~ s!,\s+$!!soig;
                ##die $netaddresses;

            } ## end else [ if ( !$body ) ]

            $whois_body_cache->set( $key, $body );
        } else {
            logstderr("serving up cached request for $request with $key") if ($debug);
        }

        my $object = $whois_body_cache->get_object($key);
        $expires = $object->get_expires_at();
        $created = $object->get_created_at();

        return ( $body, $key, $expires || '', $created || '' );

    } ## end sub whois_query

    sub process_request {
        ( my $request = <> ) =~ s/[.]([^.]+)\x{0d}\x{0a}/.$1/;
        my ( $mybody, $mykey, $myexpires, $mycreated ) = whois_query($request);

       #print "pid=$$ request=$request key=$mykey expires=$myexpires created=$mycreated\r\n$mybody\r\n";
        printf "pid=%d request=%s key=%s expires=%s created=%s\r\n%s\r\n",
          $$, $request, $mykey, fmttime($myexpires), fmttime($mycreated), $mybody;
    }

    sub fmttime {
        my $thistime = shift;
        return ( strftime "%Y/%m/%d-%H:%M:%S", localtime($thistime) );
    }

    sub logstderr {
        my $msg = shift;

        #my $timestring = strftime "%Y/%m/%d-%H:%M:%S", localtime;
        printf STDERR "%s %s\n", fmttime( time() ), $msg;
    }

} ## end package Whois

Whois->run( user              => "nobody",
            group             => "nobody",
            port              => 43,
            min_servers       => 1,              #min number of children
            max_servers       => 5,              #max number of children
            min_spare_servers => 1,              #fork if we don't have this many waiting
            max_spare_servers => 2,              #kill if we have this many waiting
            max_requests      => 10_000,         #num of requests before killing a child
            );

Sonic Wall Status - Nagios plugin

#!/usr/local/bin/perl -w

use strict;
use Getopt::Long;
use lib "/usr/local/libexec/nagios";
use utils qw(%ERRORS &print_revision &support &usage );

#-clean-environment---------------------------------------------------------

$ENV{'PATH'}     = '';
$ENV{'BASH_ENV'} = '';
$ENV{'ENV'}      = '';

#-globals-------------------------------------------------------------------

my $PROGNAME = $0;

my $SONICWALLBASEMIB = '.1.3.6.1.4.1.8741';

my $opt_snmpwalk = '/usr/local/bin/snmpwalk';

my $opt_community = 'public';
my $opt_hostname  = '';

my $opt_debug    = 0;
my $opt_help     = 0;
my $opt_version  = 0;
my $opt_warning  = 0;
my $opt_critical = 0;

my $msg         = '';
my $exit_status = $ERRORS{'OK'};

my $USAGE = qq{
Usage:

  $PROGNAME [-d] [-v] [-?] [-h hostname] [-s community]

};

#-options-processing--------------------------------------------------------

GetOptions( 'debug|d+'      => \$opt_debug,
            'help|?'        => \$opt_help,
            'v|version'     => \$opt_version,
            'w|warning=i'   => \$opt_warning,
            'c|critical=i'  => \$opt_critical,
            's|community=s' => \$opt_community,
            'h|hostname=s'  => \$opt_hostname, );

if ($opt_help) { print $USAGE; exit $ERRORS{'OK'}; }
if ($opt_version) { printf '%s: %s', $PROGNAME, '$Revision: 1.13 $'; exit $ERRORS{'OK'}; }

die "hostname parameter required:\n$USAGE" if ( $opt_hostname eq '' );

#---------------------------------------------------------------------------
## flogster:/ # snmpwalk -OnQ -v2c -c public sonicfirewall .1.3.6.1.4.1.8741
## .1.3.6.1.4.1.8741.1.3.1.1.0 = 131250
## .1.3.6.1.4.1.8741.1.3.1.2.0 = 17734
## .1.3.6.1.4.1.8741.1.3.1.3.0 = 14
## .1.3.6.1.4.1.8741.1.3.1.4.0 = 20
## .1.3.6.1.4.1.8741.2.1.1.1.0 = "NSA 3600"
## .1.3.6.1.4.1.8741.2.1.1.2.0 = "70CAD38EF8BA"
## .1.3.6.1.4.1.8741.2.1.1.3.0 = "SonicOS Enhanced 6.1.1.5-19n"
## .1.3.6.1.4.1.8741.2.1.1.4.0 = "5.4.1.0"

my $snmpwalk = "$opt_snmpwalk -OnQ -v2c -c $opt_community $opt_hostname $SONICWALLBASEMIB";

my %MIBs = ();

open( SNMPWALK, "$snmpwalk|" ) or die "$!: $snmpwalk";
while (<SNMPWALK>) {
    if (m!^(\S+)\s+=\s+(.*?)$!soig) {
        my ( $key, $value ) = ( $1, $2 );
        $value =~ s!"!!soig;        # we don't want them
        print "KEY=$key VALUE=$value\n" if ($opt_debug);
        $MIBs{$key} = $value;
    }
}

my $connpercent = $MIBs{".1.3.6.1.4.1.8741.1.3.1.2.0"} / $MIBs{".1.3.6.1.4.1.8741.1.3.1.1.0"} * 100;
my $status      = 'OK';

# CRITICAL
if (    ( $MIBs{".1.3.6.1.4.1.8741.1.3.1.3.0"} > $opt_critical )
     || ( $MIBs{".1.3.6.1.4.1.8741.1.3.1.4.0"} > $opt_critical )
     || ( $connpercent > $opt_critical ) ) {

    $status = 'CRITICAL';
    $exit_status = $ERRORS{'CRITICAL'};

} elsif (    ( $MIBs{".1.3.6.1.4.1.8741.1.3.1.3.0"} > $opt_warning )
          || ( $MIBs{".1.3.6.1.4.1.8741.1.3.1.4.0"} > $opt_warning )
          || ( $connpercent > $opt_warning ) ) {

    $status = 'WARNING';
    $exit_status = $ERRORS{'WARNING'};

} else {

    $status = 'OK';
    $exit_status = $ERRORS{'OK'};

}

my $perfdata = sprintf "cpu=%d%%;;;; memory=%d%%;;;; currconn=%d;;;;%d",
  $MIBs{".1.3.6.1.4.1.8741.1.3.1.3.0"},
  $MIBs{".1.3.6.1.4.1.8741.1.3.1.4.0"},
  $MIBs{".1.3.6.1.4.1.8741.1.3.1.2.0"},
  $MIBs{".1.3.6.1.4.1.8741.1.3.1.1.0"};

printf "$status - CPU=%d%%, MEMORY=%d%%, CONNS=%d%%, model=%s, serial=%s, firmware=%s, rom=%s",
  $MIBs{".1.3.6.1.4.1.8741.1.3.1.3.0"},
  $MIBs{".1.3.6.1.4.1.8741.1.3.1.4.0"},
  $connpercent,
  $MIBs{".1.3.6.1.4.1.8741.2.1.1.1.0"},
  $MIBs{".1.3.6.1.4.1.8741.2.1.1.2.0"},
  $MIBs{".1.3.6.1.4.1.8741.2.1.1.3.0"},
  $MIBs{".1.3.6.1.4.1.8741.2.1.1.4.0"};

print '|' . $perfdata . "\n";

exit $exit_status;

__END__

basic .xsession ....

set -x

XLIB_SKIP_ARGB_VISUALS=1
export XLIB_SKIP_ARGB_VISUALS

# (sleep 300 && /usr/X11R6/bin/xset dpms 3600 4800 10800 ) &

# PATH=/usr/local/kde4/bin:$PATH
# export PATH

#---------------

/usr/local/bin/unclutter &
/usr/local/bin/xset r rate 750 &
# /usr/local/bin/xset dpms 3200 4800 6400 &
(sleep 300 && /usr/local/bin/xset dpms 3600 4800 10800 ) &
/usr/local/bin/xset b 5 &
/usr/local/bin/xset s 7200 &
/usr/local/bin/mouseclock -fn lucidasans-18 &
/usr/local/bin/redshift -m vidmode -l -33:153 &
/usr/local/bin/xrandr -o right
/usr/local/bin/synergys
# /usr/local/bin/firefox -splash &

/home/zero/bin/autocopy-mike-blender.sh > /home/zero/bin/autocopy-mike-blender.log 2>&1 &

xmodmap -e "keycode 223 = XF86Standby"
xmodmap -e "keycode 160 = XF86AudioMute"
xmodmap -e "keycode 174 = XF86AudioLowerVolume"
xmodmap -e "keycode 176 = XF86AudioRaiseVolume"
xmodmap -e "keycode 162 = XF86AudioPlay XF86AudioPause"
xmodmap -e "keycode 164 = XF86AudioStop"
xmodmap -e "keycode 144 = XF86AudioPrev"
xmodmap -e "keycode 153 = XF86AudioNext"
xmodmap -e "keycode 178 = XF86WWW"
xmodmap -e "keycode 236 = XF86Mail"
xmodmap -e "keycode 229 = XF86Search"
xmodmap -e "keycode 230 = XF86Go"

# sleep 60

mixer vol 66
# mixer igain 0
# mixer ogain 99
mixer mic 0
mixer rec 55

#---------------

# afterstep ||
startxfce4 ||
startkde ||
xterm