killianfaughnan.com

If you miss the notification that used to be in the 8.10 notification area telling you new updates are available you can get it back by quite easily by issuing the following command.

gconftool -s --type bool /apps/update-notifier/auto_launch false

Then you just kill and restart update-notifier and you will have your icon for update-notifier back (to check it straight away, run: sudo apt-get update).

Note: This will also stop the update manager window from automatically popping up every time you run apt-get update which is reason enough to do it on its own.

linux linux, ubuntu

Yet another pet hate of mine is things capitalised incorrectly. For me things like tags need to be either first letter uppercased of lowercases, and definitely not a mix of both. The problem with Wordpress is that you unfortunately cannot change the case of a tag once it’s been used. This is because all your tags are put into a table the first time you use them, and from then on no matter what case you type a tag in, it will default to the capitalisation that is used in this table. The offending table is the wp-terms table.

This table contains a list of names and slugs (url friendly names) for all your tags. If you want to change the case of one of your tags you will need to do it here, either via console or phpMyAdmin or something else. Myself I went and just set all the names equal to the slug, and then changed the one or two tags I had with spaces in them back to something more rational. Whether you want to do it the same way as myself or not is up to you. Though if you want to you will merely need to run and update something like: UPDATE wp-terms set `name` = `slug`.

php mysql, wordpress

This is one of those things that tends to get under my skin. Web sites with long pages showing far too much information on the front page. Realistically I think the best approach is to give users access to plenty of information, but not necessarily having them bombarded with it. For the Wordpress Default theme (the one based on Kubrick) this is done by showing only post excerpts as opposed to the entire thing.. You can follow the steps below to this affect:

1. Open up the index.php page of the theme. You can do this one of two ways.
   1. Manually: locate the folder wp-content/themes/default and open the index.php file
   2. Wordpress Admin: look under the Appearance menu and select Themes. Once here select the Main Index Template page from the list on the right hand side of the editor.
2. On the 20th line (or thereabouts) you will find the text: < ?php the_content(‘Read the rest of this entry »’); ?>
3. Replace this text with the text <?php the_excerpt(); ?>

That’s it. One note though, I would always comment out any changes I have made so that should something go wrong I can always switch back. If you want to comment it out instead of replacing it then you would use < ?php //the_content(‘Read the rest of this entry »’); ?>

php blog, frontpage, php, ubuntu, web, wordpress

This is just a quick look at cleaning up an Ubuntu system. This is all documented elsewhere by an abundance of people, some of whom I no doubt took this off in the past and have forgotten where now (If you’re that person, then thanks very much, this stff has been coming in handy for me for a few years now).

Removing Residual Configs

The first step is to remove all of the residual configs lying about your system. These are configs which, as the name suggests, have been left behind by removed programs. To do so the we need to open Synaptic. You can find that in the System menu:

System > Administration > Synaptic Package Manager

Once we are in Synaptic we can click on the status button down the bottom left. This will separate your packages into sections based on their status. The one we are looking for will have the words “residual config” in the name. Select all these packages and right click on them. In the menu that appears choose “Mark For Complete Removal“. You can then click “Apply” at the top of the screen.

That’s it. You have now removed all your residual configs.

Removing Partial Packages

You will need to open a terminal for this one. To do so hold down “Alt+F2“. A box should appear, into which you can type “gnome-terminal” to open a new terminal. In the terminal you simply need to type the following to remove these partial packages:

sudo apt-get autoclean

Once you’ve put in your password etc that’s it. All gone.

Removing Unnecessary Locale Data

Theres a nice little app called localepurge that will get rid of all the locale data that you don’t need. This can amount to quite a substantial amount of space. THe first step is to install localepurge. In your terminal type:

sudo apt-get install localepurge

After installing localepurge will require that you configure it with the locale’s you want to keep. It will present you with a list of abbreviations from which you can choose. Scroll down to the one that suits you best (i.e. for myself I kept en_IE, en_IE@euro and en_IE.UTF-8.

That’s it. It will run automatically after each install and remove unnecessary locale data.

Removing Orphaned Packages

The app deborphan can grab all your orphaned packages and be used to remove them (be a bit careful with this one as sometimes it can remove something you need – it hasn’t happened to myself but I have heard of it happening). So to install the package, in your terminal type:

sudo apt-get install deborphan

To run the app you just need to type this at your terminal:

deborphan | xargs sudo apt-get -y remove --purge

This will remove all the orphaned packages on your system.

That’s it then, you should have free’d up a good bit of space on your system now and it should be a little tidyer than before!

linux cleanup, linux, maintenance, space, ubuntu

I finally got around to writing a script to rename all my music files to the same convention. That being either <track>-<song>.mp3 or <song>.mp3 with no spaces (I prefer underscores instead) and all lowercase. I know, it looks so simple! But the problem is all those occasions where you have something like <track>_-_<SONG>_-_(<remix by>).mp3 which just looks horrible! What this script does could be done in a lot less lines than I have here, but I thought it might be a good way for someone who is unsure of regular expressions to get a grasp on the topic.

So heres the script:

#!/usr/bin/perl -w
use strict;

# Open 'find' process to list files recursively with paths
open(FIND, "find |");
while(<FIND>) {
 # remove leading / trailing whitespace
 chomp; 

 # Don't rename ourself
 next if $_ eq $0;       

 # create temp file (windows wont allow to rename in place from uppercase to lowercase)
 my $name = $_;
 my $tmp = $_.'~';
 rename($name, $tmp);

 # make lowercase
 $name = lc($name);
 rename($tmp, $name);

 my $newname = $name;
 # remove apostrophes
 $newname =~ s/[\']//g;
 # remove round brackets and replace with hyphens
 $newname =~ s/[\(\)]/-/g;
 # remove spaces and replace with underscores
 $newname =~ s/ /_/g;
 # remove where in sequence there is underscore, hyphen, underscore and replace with a hyphen
 $newname =~ s/_-/-/g;
 $newname =~ s/-_/-/g;
 # where there are one or more digits followed by an underscore change the underscore to a hyphen
 $newname =~ s/(\d+)_/$1-/g;
 # remove all ampersands and replace them with '_and_'
 $newname =~ s/\&/_and_/g;
 # remove underscores where there are 2 or more, and replace with a single underscore
 $newname =~ s/_{2,}/_/g;

 # write out the changes
 rename($name,$newname);

}
close(FIND);

perl file, perl, regexp, regular expression, rename

“GNS3 is a graphical network simulator that allows simulation of complex networks.”

I was recently pointed in the direction of this app as a pretty nice graphical interface to the Dynamips / Dynagen router simulation. It still uses Dynamips / Dynagen underneath, along with Pemu (a Cisco PIX firewall emulator based on Qemu), but allows you to do graphically what you normally have to do using textual config files.

The interface is really nice and you can drag and drop in routers, create links between them, and start and stop them through the GUI. Theres no real difference from what I can see in performance etc, so many people would just turn a blind eye and figure, “Why bother, the config files are handy enough”, but it does mean you don’t have to bother with the configuration for the most part, and can just concentrate on the actual task at hand.

And the best news is it’s packaged for Ubuntu! I’m sure this is the case for other distro’s too but I haven’t checked. So all you need to do is:

sudo apt-get install gns3

You can check the documentation etc out at: http://www.gns3.net/

linux, networking cisco, dynagen, dynamips, ios, linux, networking, ubuntu

This is a slimmed down version of a combination of the Dynamips / Dynagen Tutorial and a few other Ubuntu specific sources. In fact, you could call it a quick and dirty guide to get you up and running. I reccommend using the Dynamips / Dynagen Tutorial once you have finished here picking up at the Running Sample Lab #1 section. I couldn’t write this better than it is there.

Installation

Dynamips and Dynagen are both in the Ubuntu repository so installation is as simple as an apt-get install. To this end run the following:

sudo apt-get install dynamips dynagen

Congratulations. That’s it for installation.

IOS Image

You’ll need to get yourself a Cisco IOS image for use with the emulator. Once you have one it’s generally a good idea to uncompress the image before using it as it will speed up the boot process. Use this command to do so:

unzip -p c7200-jk9s-mz.124-13b.bin > c7200-jk9s-mz.124-13b.image

Note that this will throw an error but you can safely ignore it.

Configuring Your Telnet Client

Your telnet client should be correctly configured upon install. You can find the config file for this in /etc/dynagen.ini if your curious. You’ll find a line like the below uncommented which is your telnet configuration.

telnet = xterm -T %d -e telnet %h %p > /dev/null 2>&1 &

Configuration File

You will need a configuration file for your router(s). You can find an example one (we’ll use this example config for the rest of this guide) in /usr/share/doc/dynagen/examples/sample_labs/simple1/. We’ll use the sample1.net file from here for this guide so copy this file to wherever you have your “working directory”.

The .net file will look like this:

[localhost]
    [[7200]]
    image = /opt/7200-images/c7200-jk9o3s-mz.124-7a.image
    npe = npe-400
    ram = 160
    [[ROUTER R1]]
    s1/0 = R2 s1/0
    [[router R2]]
    # No need to specify an adapter here, it is taken care of
    # by the interface specification under Router R1

So, according to the config we are running this router instance on localhost, and defines all the defaults that will be applied to any 7200 router instance we create. This makes things easy, by allowing us to specify common things like RAM size and IOS image only once.

Each of our router instances is going use an NPE-400, and be allocated 160 MB of RAM .
We are defining a virtual router instance with the ROUTER keyword. The string following this keyword is the name we are assigning to this router, in this case “R1”. This name is just the name that is used by Dynamips / Dynagen. It has nothing to do with the hostname that you assign in IOS to the router.

The s1/0 = R2 s1/0 line states that we are going to take R1’s Serial 1/0 interface, and connect it to R2’s Serial 1/0 interface (via virtual back-to-back serial cable). Dynagen automatically “installs” a PA-8T adapter in Port 1 to accommodate this connection on both R1 and R2.

We also create a 2^nd router named R2. This is the same R2 that is referenced in the line above that connects R1 and R2’s serial interfaces. As the comment says we don’t need to specify an adapter here as it is taken care of by the interface specification under Router R1.

The only change we need to make to the .net file above is to change the value of “image=” to the path of your IOS image. For instance:

image = /home/$USER/ios/7200/c7200-jk9s-mz.124-13b.image

That’s all the configuration we’ll need for the moment.

Starting The Server And Management Console

Before you start the server cd into your working directory where you plan to store the information about your router(s). There are a lot of files created when starting both the server (dynamips) and console (dynagen) so best to be aware of this as they will be created in your working directory wherever you are.

To run the server (-H 7200 means on port 7200) in the background use:

dynamips –H 7200 &

You can now start your console with the command:

dynagen sample.net

Using The Console

At this point you are best of continuing from the Running Simple Lab #1 section of the Dynamips / Dynagen Tutorial. Good luck!

linux, networking cisco, dynagen, dynamips, ios, linux, networking, ubuntu

I’ve often found that I can’t delete items I’ve copied from a CD or DVD using the GUI Trash folder. In fact, this can happen with a variety of files from a variety of places but, to be honest, I have a habit of not correcting the permissions on these files before blindly hitting delete. Sometimes you just forget these things.

In any case this can be extremely infuriating, and inevitably results in looking around your /home directory running something like…

find /home/$USER/ -name ‘Trash’

…which will find what your looking for pretty quickly. But in case you’re feeling especially lazy here’s the directories you’re looking for. You’re going to need remove files from the two directories listed, just to keep it all clean.

/home/$USER/.local/share/Trash/files

/home/$USER/.local/share/Trash/info

linux bin, linux, terminal, trash, ubuntu

Vim is what is known as a modal editor. While using it becomes very easy over time, learning it initially can be confusing and pretty irritating. This tutorial aims to give a basic run through of the most commonly used commands in Vim,

Opening A File And Inserting Text

The first step in vim is to use it to open a file or create a new one. To do so you just do the following at your terminal:

$ vim test.txt

This will open a file for you to write to. When you open vim you are immediately placed in command mode, so if you want to insert some new text you will need to enter Insert Mode. To enter insert mode you just hit the letter i. After this if you at any point want to return to command mode just hit the escape key. There are several more modes available to you but we’ll stick with the basics here.

After entering command mode again you can enter replace mode by hitting the R key. You can also insert text after the cursor (as i inserts it at the cursor) by hitting a (append), or open a new line by hitting o.

Navigating

The historical navigation keys in vim are h,l,j, and k. These are to move left, right, down and up respectively. Since Vi became Vim (Vi IMproved) however you can also just use the arrow keys. It is good to take note of these keys though as some default installs of Vim will actually be Vi (or at least use the old style navigation keys from Vi). Also, remember you need to be in command mode for navigation otherwise you will just be typing in the letters h,j,l and k!

You can move forward a word using w or back a work using b. You can use ^ to move to the start of a line and $ to move to the end of one. gg will bring you to the top of a document and G to the bottom of one.

Deleting Text

I say delete but that is not entirely true. When you use the delete commands below the deleted text is actually kept in a register (the equivalent of a clipboard in Windows). This means you can paste the deleted text somewhere else once you haven’t deleted anything else since. So delete is closer to a cut than an actual delete.

Anyway, you can “delete” the character under the cursor by hitting the x key. dw will delete the word the cursor is currently over, d$ will delete text from the cursor to the end of the line, d^ to the start of the line, and dd will delete the whole line. You can also use :d$ to delete to the end of the document.

In all the above you can also add in a numerical argument to change how many letters/words/lines etc you want to delete. i.e. d2w would delete two words, and d2d would delete two lines

Copying (Yanking) Text

You can yank a piece of text to copy it from one place to another. The syntax is exactly the same as delete, with all the same options. So for example yw would yank a word, y5w would yank 5 words, yy would yank a whole line and so on.

Pasting Text

I’m only going to cover the basic paste command here. While in command mode you can just hit the p key to paste. Of course you must have something to paste first, either through having deleted text or copied text.

Search and Replace

To search the document you just use the good old unix search method /. That is to say, enter command mode, hit the / key and type what you are looking for. For example, if you we’re looking for the word Dublin in a document you would hit Esc (for command mode), then type /Dublin and vim will find the text for you. If you use a ? instead of a / vim will search in reverse.

You can also replace text in Vim. In fact you can do so using regular expressions but I won’t cover that here as it is far too large an area. If you are interested though look up “Mastering Regular Expressions” written by Jeffrey E. F. Friedl, and printed by O’Reilly. Regular expressions are a great thing to know.

Anyway, to replace text use the following in command mode:

:%s/find/replace/g

The : occurs quite often in Vim and is used to issue commands not covered by key shortcuts. You then type in the %s at the prompt followed by a / the phrase you are looking for, another /, what you want to replace the phrase with, and a g. The g makes the replacement global. As an example of this I’ll use the line:

John went to the shop this afternoon.

Now we try a string replacement

:%s/shop/park/g

Which will change all occurrences of the word shop to park.

John went to the park this afternoon.

Saving And Exiting Vim

Now we come to saving and exiting vim. To save a document we just use the :w command (think of it as write) in command mode. To quit without saving we will just use the :q command. If we have unsaved changes this will prompt us to save them before quitting. We can save and quit at the same time using :wq, or save discarding changes using :q! which will not prompt us to save before quitting.

Further Commands

For further knowledge of Vim I would recommend using the Vim tutor. This is installed with Vims common files and can be started using the vimtutor command in your terminal, as below:

$ vimtutor

linux commands, editors, linux, text, tutorial, vim

The below is a simple program to add, subtract, multiply and divide integer numbers. It’s the first program I wrote in C++ as a tester and most of the basic concepts are covered so I’ll go through them here in case they’re of help to someone else! I’ll admit the explainations below are a bit patchy, but this is more aimed at someone with previous programming experience who is looking to try out C++.

To start off we have to include our basic input and output bit’s and pieces and to declare we’re using the standard namespace. To do so stick in the following in the first two lines of your program. We won’t worry about these too much for now.

#include <iostream>
using namespace std;

Now we’ll get into some basic subroutine (or function) for adding and subtracting etc. We’ll start with an addition function.

int sum(int x,int y)
{
    return x+y;
}

So first we declare the subroutine as an int (as our calculator is only going to deal with int’s). So we begin with an int sum. This is telling the compiler that the return value from this subroutine will be an integer value. It is also naming the subroutine as sum which is what we will use to call it later. We then tell the compiler that this subroutine will take in two parameters, both ints and call them x and y respectively.

Once the function has been called with the correct number of arguments it will add the values together and return the result. That’s it for addition. Subtraction and multiplication are exactly the same except for the obvious difference of using a – or * instead of a +. As below.

int difference(int x,int y)
{
    return x - y;
}
int product(int x,int y)
{
    return x * y;
}

Division is a little different. This is because if someone running the program tries to divide by zero the program will throw a big dirty error. The way to get around this is to check if the unputted value is a zero is quite simple. So we start off with the same construct as before, but mix up the inner workings a little.

int quotient(int x,int y)
{
    if( x != 0 && y != 0 )
    {
        return x / y;
    }
    else{
        cout << "\nCannot divide by zero!\n" << endl;
        return false;
    }
}

In the above we simply take in the x and y as normal, but this time instead of simply dividing them, we check their value first using an if statement. So inside the subrouting we will start off with:

int quotient(int x,int y)
{
    if( x != 0 && y != 0 )
    {
        return x / y;
    }
}

This means that we are saying that if x is not equal (!=) to zero, and (&&) if y is not equal (!=) to zero then go ahead and divide them. That’s all well and good, but what if one of our values is a zero? Do we just ignore it? No, we have to inform the user of the error. SO now we add in an else statement.

int quotient(int x,int y)
{
    if( x != 0 && y != 0 )
    {
        return x / y;
    }
    else{
        cout << "\nCannot divide by zero!\n" << endl;
        return false;
    }
}

Our else statement will now output the text “Cannot divide by zero!” if we find that one of the inputted integers is a zero, and return a value of false. That’s the main functionality of a calculator covered there now. The following two subroutines are just for printing out a semi-acceptable menu and giving the user the option of the different functions and exiting when required.

This is the menu function:

void menu(){
    cout << "** Menu **" << endl;
    for(int i=0;i<20;i++){
        cout << "-";
    }
    cout << "\n1. Sum" << endl;
    cout << "2. Difference" << endl;
    cout << "3. Product" << endl;
    cout << "4. Quotient" << endl;
    cout << "5. Exit" << endl;
}

This is the prompt for accepting input from the user:

void prompt(int* p_x,int* p_y){
    cout << "\nEnter first integer: ";
    cin >> *p_x;
    cout << "Enter second integer: ";
    cin >> *p_y;
}

This is the main function which is called by the program when run. In it we declare our variables and get ready to accept whatever input the user enters.

int main()
{
    int x;
    int y;
    int option;
    int answer;

    while(5!=option)
    {
        menu();
        cout << "Please enter choice: ";
        cin >> option;
        if(1==option)
        {
            prompt(&x,&y);
            answer = sum(x,y);
        }
        else if(2==option)
        {
            prompt(&x,&y);
            answer = difference(x,y);
        }
        else if(3==option)
        {
            prompt(&x,&y);
            answer = product(x,y);
        }
        else if(4==option)
        {
            prompt(&x,&y);
            answer = quotient(x,y);
        }
        if(5!=option && answer != false){
            cout << "\nAnswer is: " << answer << "\n" << endl;
        }
    }

    return 0;
}

c++ c++, calculator