Talk is cheap. Show me the code.: 2013

WebOS Exchange ActiveSync User Agent

Changing of Exchange ActiveSync User Agent string on HP Palm devices is done by editing /usr/share/dbus-1/system-services/com.palm.eas.service file:

[D-BUS Service]
Name=com.palm.eas
Exec=/usr/bin/mojomail-eas -c {...} Palm Palm/1.0.1

The last two strings stand for Device Type and User Agent.

In some cases changing of Device ID may by required as well which can be achieved using Impostash application (Device Profile -> nduId).

List of observed Device Type and User Agent strings can be obtained from Exchange server reports.

Git Basic Setup

Set user and email for commits and enable colorized output:

git config --global user.name "John Doe"
git config --global user.email john.doe@foo.com
git config --global --add color.ui true

Optionally add couple of helpful Git aliases into your shell profile (~/.bashrc in case of using Bash):

alias ga='git add'
alias gai='git add -i'
alias gc='git commit'
alias gd='git diff'
alias gdc='git diff --cached'
alias gm='git merge --no-ff'
alias gst='git status -s'

SOA Checking

	#!/bin/sh
	# Verify existence of SOA records for device's domain and its IP subnets

	NAME=$(basename $0)
	[ $# -ne 1 ] && echo "Usage: $NAME <hostname>" && exit

	HOSTNAME="$1"
	[ -z "$HOSTNAME" ] && echo "Hostname cannot be empty!" && exit

	DOMAIN=$(echo "$HOSTNAME" \| sed 's/^[^.]*\.//')
	[ -z "$DOMAIN" -o "$DOMAIN" == "$HOSTNAME" ] && echo "Hostname without a valid domain!" \
	&& exit

	IP=$(dig +short "$HOSTNAME" \| tail -n1)
	[ -z "$IP" ] && echo "Hostname without a valid IP!" && exit

	dig SOA "$DOMAIN" \| grep '^;; ANSWER SECTION:' > /dev/null \
	&& echo "SOA record exists for domain \"$DOMAIN\"" \
	\|\| echo "No SOA record for for domain \"$DOMAIN\"!"

	SUBNET="$IP"

	for NETMASK in 24 16 8; do
	SUBNET=$(echo "$SUBNET" \| sed 's/\.[^.]*$//')
	SUFFIX="$SUFFIX.0"
	dig SOA -x "$SUBNET" 2> /dev/null \| grep '^;; ANSWER SECTION:' > /dev/null \
	&& echo "SOA record exists for subnet \"${SUBNET}${SUFFIX}/$NETMASK\"" \
	&& exit
	done

	echo "No SOA record for any of \"$IP\" subnets!"

view raw soa-checker.sh hosted with ❤ by GitHub

	#!/usr/bin/env perl
	# Verify existence of SOA records for device's domain and its IP subnets
	use strict;
	use warnings;
	use File::Basename;
	use Net::DNS;
	use Socket;

	die 'Usage: ', basename($0), " <hostname>\n"
	unless scalar @ARGV == 1;
	die "Hostname cannot be empty!\n"
	unless length( my $hostname = $ARGV[0] );
	die "Hostname without a valid domain!\n"
	unless ( $hostname =~ /^[^.]\.(.)/ && length( my $domain = $1 ) );
	die "Hostname without a valid IP!\n"
	unless my $ip = inet_aton $hostname;
	$ip = inet_ntoa $ip;

	my $res = Net::DNS::Resolver->new;
	if ( $res->query( $domain, 'SOA' ) ) {
	print "SOA record exists for domain \"$domain\"\n";
	}
	else {
	print "No SOA record for for domain \"$domain\"\n";
	}

	my @rsubnet = reverse split '\.', $ip;
	my $suffix = '';
	for my $netmask ( 24, 16, 8 ) {
	shift @rsubnet;
	$suffix .= '.0';
	if ( $res->query( join( '.', @rsubnet ) . '.in-addr.arpa', 'SOA' ) ) {
	my $subnet = join('.', reverse @rsubnet );
	die "SOA record exists for subnet \"$subnet$suffix/$netmask\"\n";
	}
	}

	print "No SOA record for any of \"$ip\" subnets!\n";

view raw soap-checker.pl hosted with ❤ by GitHub

	#!/usr/bin/env php
	<?php
	// Verify existence of SOA records for device's domain and its IP subnets

	if ( count($argv) != 2 ) {
	exit('Usage: ' . basename($argv[0]) . " <hostname>\n");
	}

	if ( strlen($hostname = $argv[1]) <= 0 ) {
	exit("Hostname cannot be empty!\n");
	}

	preg_match('/^[^.]\.(.)/', $hostname, $matches);
	if ( count($matches) != 2 \|\| strlen($domain = $matches[1]) <= 0 ) {
	exit("Hostname without a valid domain!\n");
	}

	if ( strlen($ip = gethostbyname($hostname)) <= 0 \|\| $ip == $hostname ) {
	exit("Hostname without a valid IP!\n");
	}

	$soa = dns_get_record($domain, DNS_SOA);
	if ( count($soa) == 1 && $soa[0]['type'] == 'SOA' ) {
	echo "SOA record exists for domain \"$domain\"\n";
	} else {
	echo "No SOA record for for domain \"$domain\"\n";
	}

	$rsubnet = array_reverse(explode('.', $ip));
	$suffix = '';
	foreach( array(24, 16, 8) as $netmask ) {
	array_shift($rsubnet);
	$suffix .= '.0';
	$soa = dns_get_record(implode('.', $rsubnet) . '.in-addr.arpa', DNS_SOA);
	if ( count($soa) == 1 && $soa[0]['type'] == 'SOA' ) {
	$subnet = implode('.', array_reverse($rsubnet));
	exit("SOA record exists for subnet \"$subnet$suffix/$netmask\"\n");
	}
	}

	echo "No SOA record for any of \"$ip\" subnets!\n";

view raw soap-checker.php hosted with ❤ by GitHub

RHEL Subscription

subscription-manager register
subscription-manager subscribe --auto
subscription-manager repos --enable=rhel-6-server-optional-rpms

Non-root Process Listening on Priviledged Ports

Allow a user application to bind to a port below 1024 using POSIX File Capabilities:

setcap cap_net_bind_service=+eip /path/to/the/executable

Disabling CPU Cores

Disable all CPU cores except the first one which does not honor online attribute:

for i in /sys/devices/system/cpu/cpu*/online; do echo 0 > $i; done

There Are Too Many Ways To Do It

Benchmark of Perl text replacing subroutines as taken from There are too many ways to do it presentation:

	#!/usr/bin/env perl
	# Taken from "There are too many ways to do it" presentation
	# http://www.shlomifish.org/lecture/Perl/Lightning/Too-Many-Ways/slides/
	#
	# The problem
	#
	# <sniperd> looking to write a regex that strips out all periods, except for
	# the last one. ie, i have a string named perl.is.the.best.txt and I just
	# want perlisthebest.txt
	#
	# - Freenode's #perl.
	#
	use strict;
	use warnings;
	use Benchmark 'cmpthese';

	sub test {
	$_[0]->('hello.world.txt');
	$_[0]->('hello-there');
	$_[0]->('hello..too.pl');
	$_[0]->('magna..carta');
	$_[0]->('the-more-the-merrier.jpg');
	$_[0]->('hello.');
	$_[0]->('perl.txt.');
	$_[0]->('.yes');
	$_[0]->('.yes.txt');
	}

	sub via_split {
	my $s = shift;
	my @components = split /\./, $s, -1;

	return $s if @components == 1;

	my $last = pop @components;
	return join( '', @components ) . '.' . $last;
	}

	sub sexeger {
	my $s = shift;
	$s = reverse $s;

	my $c = 0;
	$s =~ s!\.!($c++)?'':'.'!ge;

	return reverse $s;
	}

	sub two_parts {
	my $s = shift;
	if ( $s =~ /^(.)\.([^\.])$/ ) {
	my ( $l, $r ) = ( $1, $2 );
	$l =~ tr/.//d;
	return "$l.$r";
	}
	else {
	return $s;
	}
	}

	sub look_ahead {
	my $s = shift;
	$s =~ s/\.(?=.*\.)//g;
	return $s;
	}

	sub count_and_replace {
	my $s = shift;
	my $count = ( my @a = ($s =~ /\./g) );
	$s =~ s/\./(--$count)?'':'.'/ge;
	return $s;
	}

	sub elim_last {
	my $s = shift;
	my $non_occur = "\x{1}" . ( "\0" x length $s ) . "\x{1}";
	$s =~ s/\.([^\.]*)$/$non_occur$1/;
	$s =~ tr/.//d;
	$s =~ s!$non_occur!.!;
	return $s;
	}

	sub rindex01 {
	my $s = shift;
	substr( $s, 0, rindex( $s, '.' ) ) =~ tr/.//d;
	return $s;
	}

	sub recursive_perl {
	my @chars = split //, shift;

	my $recurse;
	$recurse = sub {
	return '', 0 unless scalar @_;

	my $head = shift @_;
	my ( $processed_string, $was_period_found ) = $recurse->( @_ );
	if ( $was_period_found ) {
	return ( $head eq '.' ? '' : $head ) . $processed_string, 1;
	}
	else {
	return $head . $processed_string, $head eq '.';
	}
	};

	return ( $recurse->( @chars ) )[0];
	}

	sub delpoint1 {
	local $_ = shift;

	my $old = $_;
	while ( /\./ ) {
	$old = $_;
	s/\.//;
	}

	return $old;
	}

	sub delpoint2 {
	local $_ = shift;
	while ( s/\.(.*\.)/$1/ ) {}
	return $_;
	}

	sub delpoint8 {
	local $_ = shift;

	my @parts = split /(\.)/;
	my %hash;
	for my $i ( 0..$#parts ) {
	push @{ $hash{$parts[$i]} }, $i;
	}

	if ( exists $hash{'.'} ) {
	$hash{'.'} = [ @{ $hash{'.'} }[-1] ];
	}

	my %sort;
	for my $key ( %hash ) {
	for my $number ( @{$hash{$key}} ) {
	$sort{$number} = $key;
	}
	}

	$_ = '';
	for my $number ( sort { $a <=> $b } keys %sort ) {
	$_ .= $sort{$number};
	}

	return $_;
	}

	sub pack01 {
	my @c = unpack 'c*', $_[0];
	my @p = grep( $c[$_] == 46, 0..$#c );
	pop @p;
	while ( defined ( my $c = pop @p ) ) {
	splice @c, $c, 1;
	}
	return pack 'c*', @c;
	}

	cmpthese( 1000000, {
	'via_split' => sub { test( \&via_split ) },
	'sexeger' => sub { test( \&sexeger ) },
	'two_parts' => sub { test( \&two_parts ) },
	'look_ahead' => sub { test( \&look_ahead ) },
	'count_and_replace' => sub { test( \&count_and_replace ) },
	'elim_last' => sub { test( \&elim_last ) },
	'rindex01' => sub { test( \&rindex01 ) },
	# Recursive would eat all the memory and would be the slowest one anyway.
	# Trust me on this ;)
	#'recursive_perl' => sub { test( \&recursive_perl ) },
	'delpoint1' => sub { test( \&delpoint1 ) },
	'delpoint2' => sub { test( \&delpoint2 ) },
	'delpoint8' => sub { test( \&delpoint8 ) },
	'pack01' => sub { test( \&pack01 ) },
	});

view raw too-many-ways.pl hosted with ❤ by GitHub

My own results (the table is split for better readability):

                      Rate delpoint8 elim_last pack01 count_and_replace sexeger
delpoint8           9237/s        --      -58%   -73%              -82%    -86%
elim_last          22232/s      141%        --   -36%              -58%    -67%
pack01             34855/s      277%       57%     --              -34%    -49%
count_and_replace  52466/s      468%      136%    51%                --    -23%
sexeger            68259/s      639%      207%    96%               30%      --
two_parts          72359/s      683%      225%   108%               38%      6%
delpoint2          80775/s      774%      263%   132%               54%     18%
via_split          90009/s      874%      305%   158%               72%     32%
delpoint1         101626/s     1000%      357%   192%               94%     49%
rindex01          145985/s     1480%      557%   319%              178%    114%
look_ahead        163399/s     1669%      635%   369%              211%    139%

                      Rate two_parts delpoint2 via_split delpoint1 rindex01 look_ahead
delpoint8           9237/s      -87%      -89%      -90%      -91%     -94%       -94%
elim_last          22232/s      -69%      -72%      -75%      -78%     -85%       -86%
pack01             34855/s      -52%      -57%      -61%      -66%     -76%       -79%
count_and_replace  52466/s      -27%      -35%      -42%      -48%     -64%       -68%
sexeger            68259/s       -6%      -15%      -24%      -33%     -53%       -58%
two_parts          72359/s        --      -10%      -20%      -29%     -50%       -56%
delpoint2          80775/s       12%        --      -10%      -21%     -45%       -51%
via_split          90009/s       24%       11%        --      -11%     -38%       -45%
delpoint1         101626/s       40%       26%       13%        --     -30%       -38%
rindex01          145985/s      102%       81%       62%       44%       --       -11%
look_ahead        163399/s      126%      102%       82%       61%      12%         --