TechnoBabel

technobabel::Stupid ssh tricks

Since this months’ issue revolves around security I thought it a wise idea to discuss some tips and tricks that are security related. To that end I hope to explore some of the common useful options for ssh. First we will examine TCP port redirection using the ssh client, which can generally only be accomplished via root level privileges.

Since we are not going to alter the sshd_config to allow ALL users on the system the redirection privilege I am assuming that you have a working system where you hold the proverbial keys to the kingdom. If I am mistaken then perhaps you should download an ISO of your favorite BSD or even a live DVD like RoFreesbie so that you can play along.

First I would like to discuss why one might consider creating a ssh TCP tunnel. Let us decide that you are visiting a new client for the first time and have not had a chance to setup your normal exclusionary firewall rules, and further that this client’s network is one you do not entirely trust as of yet. However you need to access data on the intranet back at your office. This could be some files, or your client database, or even you jabber server. While there are numerous methods available to facilitate this sort of action we are going to tunnel some TCP via an ssh connection.

There for in this example let’s expect that you need to access your MySql database securely form outside of your home network. As previously mentioned we will assume that you have root level access on the source system, which is most likely you personal laptop.

Reading the ssh man page you will note the -L [bind_address:]port:host:hostport which may seem cryptic at first however we will deconstruct the command one parameter at a time. First consideration is the bind_address, this is only an issue if your system has multiple address and you wish to specify which one to use for the outgoing connection. This is the only optional parameter in the statement one that we can safely ignore. The port refers to the port on your local machine at this end of the tunnel, in other words the port that you wish to map the service on target machine to. The host refers to the address of the host on the remote side of the tunnel. This host may the the target machine itself or another machine available on the same LAN as the the target. Finally the hostport is the TCP port that you wish to connect to.

In this exercise we will be connecting to our database server OSIRIS.olivent.com via another server PTAH.olivent.com. These machines have appropriate DNS entries so as to ensure that I can always connect to them by their proper name. From here after I’ll simplify things by only referring to them by their short names in all capital letters for clarity.

In the following example I will be opening a connection to the target machine ptah as the user sysmgr.

# ssh -N -f -L 4406:OSIRIS:3306 sysmgr@PTAH

As you can see that did not really do very much, now on my local machine I can direct my MySql client to connect as follows.

PTAH> mysql -h 120.0.0.1 -P 4406 -u dbadmin -p
Enter password:
Welcome to the MySQL monitor. Commands end with ; or \g.
Your MySQL connection id is 26621
Server version: 5.0.67-log Source distribution

Type ‘help;’ or ‘\h’ for help. Type ‘\c’ to clear the buffer.

mysql>

To summarize what thus far we have successfully established an ssh tunnel to our target and told ssh that no CLI access is needed as well as to send the connection to the background. We were then able to connect to the MySql database pretty much as we would if we were sitting at the console of the server in question, by simply adding the appropriate host and port switches as demonstrated above. Refer to Figure 1 below for more detail. Refer to Figure 1 below for more detail.

Suppose however you manage a site and need to allow a vendor to access and troubleshoot a server but do not wish to grant this vendor full access to the entire network. How do you allow them to complete their work without being able to peruse your entire network? The answer is called a rendezvous point.

In order to facilitate rendezvous point you need three machines. The server, the client, and the way station. The server and client are fairly obvious but the way station is the meeting point in this case we will call that machine HORUS. HORUS lives on the DMZ and exists solely for the purpose of facilitating these sorts of connections. It’s firewall rule prohibit more external access excluding ssh of course.

In the following example first the database server OSIRIS is connected to the way station HORUS.

OSIRIS# ssh -N -f -R 4406:127.0.0.1:3306 sysmgr@HORUS

Then the vendor on PTAH connects to the way station as shown.

PTAH# ssh -N -f -L 5506:127.0.0.1:4406 sysmgr@HORUS

Finally the vendor opens their database utility connecting to the newly bound 5506 port on their local IP address.
PTAH> mysql -h 120.0.0.1 -P 5506 -u dbadmin -p
Enter password:
Welcome to the MySQL monitor. Commands end with ; or \g.
Your MySQL connection id is 26626
Server version: 5.0.67-log Source distribution

Type ‘help;’ or ‘\h’ for help. Type ‘\c’ to clear the buffer.

mysql>

As you can see from the demonstration above the vendor is able to access the database and perform what ever maintenance is required within the limitations of their database utilities. To further secure this method one could issue a ssh key pair so that no passwords need to be exchanged in the first place. What is nice about this later step is that once the maintenance has been completed simply revoke the vendor’s key at the way point HORUS and terminate the tunnel from OSIRIS to HORUS.

In addition if the vendor’s account is compromised in anyway the only access will be granted to HORUS which knows absolutely nothing about your internal network. In fact other than being a basic BSD server it should know nothing about databases, DNS, mail or anything other how to connect to the internet. Obviously it adds a layer of complexity to the whole process, as well as yet another server to maintain, but in the end is you have a large installation of vendor supported equipment and loath the idea of letting them run amuck about your network it certainly is viable option.

Combining PDf files into a single document

While there are numerous ways to slice this tomato my situation was particularly unique and required an equally unique solution. As many of the long time readers are already aware I spend considerable amounts of tie traveling abroad on business. As exciting as my adventures may sound they do come at a price in the form of the dreaded corporate expense report.

For those of you who have never experienced the pleasure of completing a travel expense report let me step off on this tangent for a moment. In my personal opinion a home root canal performed with a soup spoon would less painful than completing one of these reports.

Imagine if you will being on the road for six weeks or more having to not only log but scan a copy of every receipt for every transaction. To make matters a little more difficult I frequently travel to countries where receipts are an exception. What I mean is if you do not ask for one then you will not get one. In fact more often than not the establishment may not even have the ability to furnish a receipt at all but that is a topic for another time.

At the end of this trip I had hundreds of receipts for things like hotels, meals, taxis, restrooms even clothing. All of these were scanned in during the course of the journey so as to prevent accidental loss. The big problem with this is the bean counters want everything in one complete PDF. This is not without it’s trouble because the corporate email system has a bizarre limit of 5MB for message plus attachments. Even with the receipts squeezed tightly into many pages the size begins to add up.

So my problem was how to combine all of the individual PDF documents into one file without having Adobe Accrobat Professional on my laptop. I of course googled the subject and found numerous other PDF manipulation applications but all of them were immediately rejected as a result of very suspect websites. In addition many of these applications included a hefty price tag which I really wanted to avoid. Finally I decided to try pdftk from PDFLabs via the MacPorts. Unfortunately to do this you need to be ready to jump into the command line vie the Terminal app. I am going to assume that you are and we will skip directly to the good stuff.

The first step I was to combine all of the individual PDF scans into one document which I did using the following syntax:

> pdftk Receipts-1.pdf Receipts-2.pdf Receipts-3.pdf output Receipts.pdf compress

The above example joins all of the PDF files together into one file and compresses the output. Each source PDF document can contain anywhere from one to many pages and they are concatenated in the order listed on the command line. Since I have 30 plus files each with multiple pages I found it easiest to write a short shell script to handle this for me.

The next problem I had to tackle was how to get the size of the file down below 5MB. My document was 11.7MB which was more than twice the size allowed by the mail server. So taking a less than elegant approach I used the burst functionality to basically explode all of the pages form this new document into separate files again. I know this may sound counter intuitive but I had a reason for doing this which I shall explain after the command line example of the burst operation.

> pdftk Receipts.pdf burst output Receipts-pg%20.pdf

In this example I have now take the new expenses document and exploded each page out into it’s own file. I did this so that I could use the built-in Mac app Preview to view each page separately and attempt to re-save as a black & white PDF. By doing this I was able to reduce the size of a given page to 50KB from 800KB. The reason I did this on a page by page basis because some of the pages became illegible or even completely blank. The afforded me the option of using the new black & white page or keeping the original.

Now that I had all of my pages converted as appropriate I culled the good discarding the cruft and modified my combination script. The combination of these new PDFs was relatively simple and followed the first example.

> pdftk Receipts-pg01.pdf Receipts-pg02-bw.pdf Receipts-pg03.pdf output Expenses.pdf compress

When I had finished I had a single PDF containing all of my receipts that was 4.5MB. Actually I got quite lucky with the sizing of this document as it turned out to be blind luck that i achieved this size. All that was left form me to do was to complete the Expense report documenting each transaction as well as convert foreign currencies to USD which I also noted on the actual receipt using Previews’ annotation tool. I even included the line item number from the expense report spreadsheet on the receipt just to help the bean counters follow along. Yes I am shall we say thorough.

All that aside I do understand that the command line is a rather scary place for most users. I decided to write the article to demonstrate how useful it can be and that it is not so scary of a place after all. Another reason I decided to write this is to demonstrate how easy it is to find and build useful applications from open source tools. There are thousands of applications available if you are willing to learn a few commands. If your Mac does not have the MacPorts installed they have a nice how to on their site that will walk you through the process.

I hope that you have enjoyed this short walk through the command line and thirty thousand foot view of the MacPorts. It is really a great system derived from the FreeBSD ports which is where the most of the UNIX core of Mac OS X came form in the first place.

ABOUT THE AUTHOR: Mikel King has been a leader in the Information Technology Services field for over 20 years. He is currently the CEO of Olivent Technologies, a professional creative services partnership in NY. Additionally he is currently serving as the Secretary of the BSD Certification group as well as a Senior Editor for the BSD News Network.

release::Blib 1.1 and the diskcheck utility

Blib 1.1 has been released and I would like to take a moment to discuss some of the enhancements as well as detail one application that I built using the library. I think the easiest way to accomplish this would be to include an excerpt form the release note in the package and then discuss the diskcheck utility I wrote based on blib.

Release the bash library a.k.a blib version 1.1
License: modified BSD license (re-licensing is strictly prohibited and the entire library plus all original documentation must be distributed intact.)

Currently the library contains the following four files;

base.blib
debug.blib
std.blib
string.blib

Each bash library file has been crafted for a specific purpose and as the library grows these files will be expanded.

The main library file std.blib sets the foundation for the subsequent libraries thus is required for any of their usage. It is important to properly source this into the head of your script prior to accessing any of the other libraries. I hope to expand this file’s usage at some point as well as make it easier to implement further enhancements.

The base.blib file contains a handful of useful generic functions which over time could be branched out into their own repository. I am working to limit such branching but keep in mind that this is always a possibility. For instance the outputMsg and logOutput functions are prime candidates for relocation as well as anything tide to these methods.

String manipulation has been a goal and I have worked to include functions that I use for this purpose some are just encapsulations of bash built in constructs. I am still working on cleaning this library up and really could use some assistance with streamlining this file.

New in this build is the debug library which contains two functions I created to help me troubleshoot new scripts. Primarily I use the setCheckPoint function and only included the setBreakPoint function for the sake of completeness. I am sure over time this library will be enhanced but as of right now this is what I have.

Most of the funcitons in the library have been commented with phpdoc style comment markers. However there are several that I made up for the sake of clarity. Hopefully someone will consider creating a bashdoc utility that can parse these into some sort of useful documentation. As always I have included my usual commentary which sometimes explains what I was thinking when I wrote a particular block of code. This is especially true if I feel that I’ve take a short route that I just couldn’t riddle out a better way. The comments are there to remind me of this and hopefully spark some sort of epiphany at some later date.

So this naturally leads to the diskcheck utility which is a simplistic script that parse the output of a df report and then compares the usage percentages to preset values. If one of these usage exceeds the threshold then we throw an ‘err’ exception to syslog. The following is the entire script:

#!/usr/bin/env bash ############ # diskcheck - A simplistic disk usage threshold checker # # installation- Although I may include an install script, basically the application is installed as follows: # # run file- /usr/local/bin # blib files- /usr/local/lib # config files- /usr/local/etc # # @author Mikel King # @copyright 2010 Olivent Technologies, llc # @package diskcheck # @dependency blib version 1.1 # @version 1.0 # @license http://opensource.org/licenses/bsd-license.php New/ Simplified BSD License # Default threshold levels
Warning=70 Error=80 Critical=90 CertainDoom=110
LogFacility="err"

. /usr/local/lib/blib/std.blib

require ${BlibPath}base.blib
require ${BlibPath}string.blib

getMyProcessName
TmpFile=/tmp/${MyName}

# include diskcheck.conf
include ${ConfPath}${MyName}.conf

# Store df output in temp file
df -PH >${TmpFile}

# Remember to set the four threshold variables in your source or config file before running this. # # @method setDiskErrMsgs # @descr a local wrapper for encapsulating the four error message functions. # @param string $MSG
function setDiskErrMsgs() {
	setDoomMsg "You face certain DOOM as the free disk space threshold ${CertainDoom}% exceeded on ${Mount} only ${Avail} of ${Size} remaining, resulting in a Resume generating event."
	setCriticalMsg "Critical: Free disk space threshold ${Critical}% exceeded on ${Mount} only ${Avail} of ${Size} remaining."
	setErrorMsg "Error: Free disk space threshold ${Error}% exceeded on ${Mount} only ${Avail} of ${Size} remaining."
	setWarningMsg "Warning: Free disk space threshold ${Warning}% exceeded on ${Mount} only ${Avail} of ${Size} remaining."
}

function getDiskStats(){
while read Partition Size Used Avail Percent Mount;
	do
		case ${Partition} in
			Filesystem)
			;;
			cdrom)
			;;
			tmpfs)
			;;
			devfs)
			;;
			procfs)
			;;
			map)
			;;
			*)
				setDiskErrMsgs
				checkThreshold ${Percent}
			;;
			esac
	done<${TmpFile}
}

setLogTag ${MyName}

setLogFac ${LogFacility}

setLogOptions

getDiskStats

# CleanUp your toys!
rm ${TmpFile}

As you can see it’s rather simple in design. I have taken the liberty of wrapping the lines and colorizing the output to make for easier viewing. At the top of this script we define some default values which can be overridden in the associated config file.

At this point you may wonder why we need all those log tags and facility settings. The simple fact is that as useful as running this on the command line would be you could just run df -Ph yourself and figure it out. I wrote this script to monitor the disk usage levels and send a notice to syslog if a threshold was exceeded. This is particularly handy if you are sending your syslog messages to a remote host. So running diskcheck at the command line will just return an empty command prompt.

In reality it has done so much more as it performed all of the level checks and should something be amiss it is reported to syslog. On my machine I set the following entry in /etc/sysog.conf:

*.err                                           @192.168.106.128

The machine on 192.168.106.128 is a virtual server running rsyslog that I setup to receive inbound syslog traffic on the default syslog UDP port 514. So on my machine I run diskcheck and the following appears in /var/log/messages on the remote syslog server:

2011-02-24T23:02:45+08:00 thoth diskcheck [21163]: Warning:
Free disk space threshold 30% exceeded on / only 317G of 500G remaining.

As you can see this is not a particularly difficult script to create and I could have written everything from scratch without using the bash library (blib). However since I have completed this one I wrote a similar script to check load averages in about 2 hours using this one as a guide and blib as the foundation. Honestly this is exactly what prompted me to create blib in the first place.

I’ve been creating scripts for a very long time and I’ve always used bash or php-cli to do this. I know both of these tend to make people shutter in disbelief but if I am creating a script that I wish to run on both the web and cli then php will always be my language of choice. However that is a discussion for another day. I cobbled blib together after years of writing scripts and thought that there has to be a better way to reuse what I’ve already built.

Eventually through much trial and error, yes mostly error, I created a library the library I released in the article introducing Blib the bash library project. Eventually I will move the project into either git or svn and publish access to it via that method.I find that I am writing more scripts in bash again and honestly I believe it is because the library has made it not only easier but kind of fun to do. I hope that you give it a try as I really look forward to see what innovations other people come up with.

Until next time happy scripting…

~~Download the current copy of blib: https://www.jafdip.net/downloads/blib-1_1.tbz~~

Blib has been moved to GitHub as blp, so check it out here.

Something I said…;-S

Apparently one of the many articles and editorials I published over the last few days really upset someone. As there have been numerous juvenile attempts to bring down the system. Looking into the phenomenon I discovered that this individual has reminded me that I left phpMyAdmin installed and running on this system. Yes please feel free to scold me now.

Be that as is may the would-be hacker attempted to negotiate an exploit in pma that allows manipulation of the file system. What they had done is effectively try to write a new .htaccess file in the system that would redirect each page to this site http://84f6a4eef61784b33e4acbd32c8fdd72.com.

Fortunately this attempt was only partially successful in that the files were written into the web file system but not fully functional. After spending some quality time with Google and believe it or not Yahoo, I found the best solution to the following apache (WordPress) error message;

.htaccess: RewriteEngine not allowed here, referer:

The above error message refers to the fact that the .htaccess file isn’t really allowed to run where it was found. Worse yet this file contained some garbage and the easiest option is to find and remove all of them, but how does that help you in the future? Frankly it does not, and that whole sifting through each directory can be rather time consuming. Therefore let’s think about this programmatically for a moment.

Suppose we could execute a command that would search the path and locate all of the offending files for us? Suppose we named that command something like find? Oh wait there already is a command called find and it does exactly that.

sudo find SiteName -name ".htaccess"

In fact if you were to execute the above replacing SiteName with the path to you web tree it will traverse the file system returning all of the files located. While this may be all fine and dandy it really does not solve any of the problems other than aide in generating a list of files to work on. Without some further programming we have basically created a check list to manually correct the errors. Since we are not into manual labor, for if we were then we wouldn’t have become programmers or sysadmins we must consider expanding the process.

Fortunately, it is rather simple to create a bash shell script to wipe out the contents of the offending files as well as sac (sac is an old main frame term for setting the access on a file or directory) the permissions. Consider for a moment the simple fixit script that I’ve written to handle the part of the process.

#!/usr/bin/env bash


echo >${1}
chmod 444 ${1}

No that we have a script that will enact the changes we want it is a matter of finding the necessary programmatic glue or magick to make this happen. Fortunately for us the if you examine the find man page, go ahead I’ll wait. Actually it’s rather simple because we already have a script and I have ensured that not only it is in the search path but that it is also executable.

All I need to do at this point is add the script execution to the find command we examined above. I assume you’ve already skimmed the man page and have rejoined the rest of the class so we shall proceed. Just as in the previous example you need to replace SiteName with the path of your site’s root. Examine the following code fragment;

sudo find SiteName -name ".htaccess" -exec fixit {} \;

Notice that I have included the fixit bash script in the command specification. Basically what happens here is that as find locates a file that meets the search specification it calls the command listed in the -exec parameter with that file name as it’s argument. I know what you are thinking that wow that saved a lot of work, whatever is my junior sysadmin going to do now?

One note of caution, since this will clobber every .htaccess file found in the path you may want to make a backup first to preserve the site as it is just in case something goes awry. Other than that I would like to wish you good luck and happy scripting.

Blib the bash library project

What is blib, you say?

Blib is a library of scripts that I developed to make my life as a sysadmin a little more pleasant. It is an collection of functions that have evolved of time into a set of libraries that I use as the basis of my server management scripts. It is my intention of sharing this work that other may find it inspirational and hopefully useful in their scripting endeavors. After years of script writing and not just in bash; in fact I’ve even dabbled with php cli scripts which to be truthful would be my first choice were it more prevalent in the command line environment. That however is a subject for yet another article.

Currently bash has enjoyed a resurgence of sorts after spending what seemed like a decade at version 2 we are up to version 4. This library has only been tested against version 3 but I assume it will work relatively well with 4 but not likely with the 2.x strain. Let me state however that not all is all right and rosy within the bash scripting world, for as soon as you need to do something sophisticated with your script you realize that bash is likely not the best language for the task.

Whether you use blib or not It is worth investigating as the library demonstrates some of the lesser leveraged capabilities of bash. Over the years I have examined numerous scripts and what always struck me as odd is that most scripters avoid defining functions. Instead I see a lot of code block duplication without much thought given to it’s longterm reusability. It almost seems that there is an unwritten rule among scripters that reads something like, “The moment you decide to define functions in bash is the same instant that you need to abandon it for another language.” I find this axiom a bit unsettling because for me the function is the basic block of advanced structured scripting.

So without further ado let’s take a look at blib to get and idea of what bash really can do. In this article we will examine one function from blib that I use in every script I write. In fact this function formed the based of my desire to create blib in the first place. Refer to the code segment below for the function throw.

# This encapsulates the exception handling into a fairly simple # and concise package. # It makes use of basic parameter passing and executes exception # processing based on predetermined action levels. # @method throw # @param string $1 # @global $EXCEPTION function throw(){ if [[ ${1+isset} = isset ]]; then EXCEPTION=${1} fi case ${EXCEPTION} in # Normal level [0]*) ;; # Critical error level exception [1]*) outputMsg exit ${EXCEPTION} ;; # Warning level exception [2]*) outputMsg ;; # Missing file specification [3]*) ouputMsg "Missing filename specification. " exit ${EXCEPTION} ;; # Required parameter is missing [4]*) outputMsg exit ${EXCEPTION} ;; # [5]*) ;; # [6]*) ;; # [7]*) ;; # [8]*) ;; # Oops level exception *) MSG="You know I've looked every where and what you have done has left me completely flummoxed. I honestly do not know what it is that you've done to receive this message, thus you win a prize. You can pick up your prize behind the Port Authority bus terminal at 0200 on the second Tuesday in January. In all likelyhood you have called throw without a parameter or neglected to properly set your EXCEPTION level." outputMsg exit ${EXCEPTION} ;; esac }

You will note that this function is relatively simple in what it does and honestly I believe that this should be the goal of any well design function. It should perform one task and perform that task well. Following this mantra makes it easy to break tasks down into reusable chunks. While I am sure there is a lot of room for improvement I have found that this meets the need rather well. For me the sign od a good program is the way it handle errors and using this construct allows me to trap and route them through my method.

The throw method also employs a second function call outputMsg which on the surface may seem superfluous however this encapsulation of the built-in echo allows me to control exactly how things are displayed. We will examine that a little later in the article, suffice to say that if output is enabled then we will see the appropriate message. To understand this let’s look at throw in action.

function pseudo() { if [[ ! ${1+isset} = isset ]]; then  Course=${1} change ${Course}  else
 MSG="${FUNCNAME}: Unable to change course at this time, I hope we don't run aground!"
 throw 4  fi echo ${Course} }

In the above pseudo function we check for a parameter passed when the function is called and the perform some operation on this data. The issue we run into is if the pseudo function is called without the passed parameter then we have no data on which to operate. This as you can imagine can have some unpredictable results later during the execution of the program. Thus in my opinion if it is a required piece data then we should toss an error and halt execution. On the other hand if the data is something that is nice to have but perhaps there is already a default value or maybe it is some intermittent state change we are checking for then perhaps it is better to note this and continue trudging onward.

Thus in the example above we have a critical piece of information that must be passed when the pseudo function is called. Failing to present this information must cause cause the program to do something drastic. Consider that I could write an if then type clause that handles this case and another the next time I need to handle a lesser error, but why should I? I mean isn’t the concept of programming supposed to make out lives easier? So as a programmer why not make my life easier and reduce multiple lines fo code down to a statement or two?

Therefore what I have done is simply wrap my error handling conditional algorithm into a function that I can pass the error level to. By setting the variable MSG immediately prior to calling throw allows me to set the error message on the fly as related to the function calling throw. If however I only needed a predefined message I could call throw with one of the other exception levels. Which you probably have already noticed I have not defined. It’s one of those things that haven’t gotten around to doing yet but it is still on my to do list.

So rather than detailing what outputMsg does let’s just discuss it for a second. When you look through the base.blib that contains the core functionality of blib you will note there are some other functions that set values for things like silent and quiet operation. Using these options to adjust what outputMsg actually displays and where. As I said earlier it is simply a wrapper for echo, but with some logic that determines when it is allowed to print.

The last thing I would like to discuss about blib today is the std.blib which is the root of the blib system. By simply sourcing in this library prior to any other you open up some of the power of blib. To do this you simply add something similar to the following near the top of your bash script depending upon where you installed blib. I am assuming that you installed it in the default location and if you did not then that may cause some unusual developments. Likely nothing will work as I have not evolved it to that point yet.

. /usr/local/lib/blib/std.blib

My goal for blib moving forward is to heavily rely on the two core functions include and require. Of course you are probably wondering why would I have gone to the trouble of writing wrapper functions for a built-in method. Why not just source in other code as we did with the std.blib example above? The reason is advanced logic necessary to check for the existence of the file to be sourced. I modeled the include and require method very loosely after the functions of the same name found in PHP.

The difference is that I use include for things that are nice to have but that will not break program execution. Namely I use this for config file sourcing where I have default values already set within the application I am writing and the config file would just override these values. That is why it only throws an exception level of 2 which would echo a warning of some sort but continue normal execution.

On the other hand I use require for things that must be present of the execution will stop. I built into the function logic to determine if the item being required is present before sourcing it in and if not then it throws an exception level 3 halting program execution.

I realize that this article has become rather lengthy but I believe that I have covered the important notes on working blib into your bash scripting repertoire. In the next article I plan on covering the basics of building an application on top of this for lack of a better term framework. Until then I hope that you consider downloading and experimenting with blib.

As with just about everything in programming there really is not right or wrong way to do something. Some may be more efficient than others but only you the developer can decide what works best for your purpose. My goal for blib is to create a set of libraries focused for certain tasks that make scripting easier for all. You will see that there are many tangent in the library some are dead ends others are new beginnings like the string.blib, therefore; if you develop a function and wish to include it please feel free to ping me. Hopefully with some community involvement this can grow this into something interesting.

This version of blib has been release under the New/Simplified BSD License (http://opensource.org/licenses/bsd-license.php) with the additional requirement that you notify the originator of your usage. The latter is just so I can track how it’s being used. Good luck and happy scripting.

Download a copy of blib from: https://www.jafdip.net/downloads/blib-1_0.tbz

Advanced Mac OS X Shell Scripting (jafdip.com)
Name Based Vhosting in Mac OS X Snow Leopard Server (jafdip.com)
Performing MacPorts Magick (jafdip.com)
Trolling For A Quality Operating System (jafdip.com)

TechnoBabel

.htaccess: RewriteEngine not allowed here, referer:

Related articles