1. Click on events
2. Click on the event you want to get rid of
3. In the guest list you’ll see yourself as well as your invited friends. There’s a cross beside your name. Click on it to remove yourself

BAM ! DONE !

Facebook : How to remove an event you’ve been invited to without responding is a post from: Tech@Sakana - A sysadmin's blog

Why an encrypted LVM ?

Why an encrypted LVM ? Well, we could have stopped at an encrypted partition but, once we get there, it’s not much harder to reap the benefits (in term of fexibility) of the added LVM layer.

So basically :

• Encryption for security : making sure the data will be accessible only by you
• LVM for flexibility : being able to allocate only portions of the encrypted volume at a time, growing them when needed, and so on.

We’ll follow a step by step procedure to get you through it, hopefully painlessly. In the end, you’ll have :

• a GPG password protected keyfile
• which will be required to access the encrypted disk partition
• on top of which will sit one or more LVM volumes

Setting up the encryption

We are going to use the cryptsetup tool to setup the encryption.

Generate a GPG password protected key

You could stick with a regular password keyfile, but it would mean that this file would be the only requirement to accessing your protected data. Adding GPG into the mix makes sure that an additional password (hopefully one only you know) will be required.

1
2
3
4

kattoo@roadrunner ~ % dd if=/dev/urandom count=1 | gpg --symmetric -a > key.gpg
1+0 records in
1+0 records out
512 bytes (512 B) copied, 0.000102417 s, 5.0 MB/s

You’ll then be prompted to enter a password. Choose it wisely because the safety of your data depends on it.

Keep that file preciously. If you lose it, there won’t be any way to access your data anymore.

Don’t let anyone access it.

Nuking previous content of the disk / partition

It is generally advised to randomize the disk data before setting up encryption. This serves a double purpose :

1. it ensures that no previous data will be available (better safe than sorry)
2. once the encryption is setup, it will make the actual data less easy to spot in the middle of the random noise (encrypted data will look like random bits in the middle of random bits)

There are many ways to randomize the harddisk content : we’ll create a temporary key, encrypt the volume with it, then fill it with encrypted zeroes.

I’ll just show the procedure below, if it doesn’t quite make sense right now just keep reading, I’ll detail the steps when we’ll do the permanent encryption.

1

root@roadrunner ~ # cd /tmp

Creating a temporary random key :

1
2
3
4

root@roadrunner tmp # dd if=/dev/urandom count=1 of=tmp_key
1+0 records in
1+0 records out
512 bytes (512 B) copied, 0.000112387 s, 4.6 MB/s

Using it to create / open the encrypted LUKS device from the partition. We’ll use the /dev/sdb1 device as an example. Pick yours carefully because all data stored on it will be nuked.

1
2

root@roadrunner tmp # cat /tmp/tmp_key | cryptsetup luksFormat /dev/sdb1
root@roadrunner tmp # cat /tmp/tmp_key | cryptsetup luksOpen /dev/sdb1 tmpVault

Filling that encrypted partition with encrypted zeroes :

1
2
3
4
5

root@roadrunner tmp # dd if=/dev/zero bs=1M of=/dev/mapper/tmpVault 
dd: writing `/dev/mapper/tmpVault': No space left on device
246+0 records in
245+0 records out
257393664 bytes (257 MB) copied, 22.5508 s, 11.4 MB/s

Closing the encrypted zero filled device :

1

root@roadrunner tmp # cryptsetup luksClose tmpVault

And finally, deleting the temporary key :

1

root@roadrunner tmp # rm tmp_key

The device is now left filled with random data.

Generate and encrypted LUKS device

We’ll use cryptsetup with LUKS extensions to deal with the encryption part. It’s pretty easy to use with the default options, but make sure to read the cryptsetup manpage for the fancy options and extra security.

From there on, you’ll need to be root.

We’ll use the /dev/sdb1 device as an example. Pick yours carefully because all data stored on it will be nuked.

1
2
3
4
5

root@roadrunner ~ # gpg -d ~kattoo/key.gpg | cryptsetup luksFormat /dev/sdb1
gpg: CAST5 encrypted data
gpg: encrypted with 1 passphrase
gpg: WARNING: message was not integrity protected
root@roadrunner ~ #

You’ll be prompted for the key password. This will then be fed to cryptsetup which will use it to create the encrypted partition.

Open the encrypted LUKS device

To make the encrypted LUKS device available to the system, you need to open it :

1
2
3
4
5

root@roadrunner ~ # gpg -d ~kattoo/key.gpg | cryptsetup luksOpen /dev/sdb1 vault
gpg: CAST5 encrypted data
gpg: encrypted with 1 passphrase
gpg: WARNING: message was not integrity protected
root@roadrunner ~ #

vault is a symbolic name, you can pick up what you like and it will help you identify the devices if you have more than one of them.

The encrypted block device will now show up into /dev/mapper :

1
2
3
4
5
6
7

root@roadrunner ~ # ls -l /dev/mapper/
total 0
crw------- 1 root root 10, 236 Apr 17 05:31 control
[...]
lrwxrwxrwx 1 root root       7 Apr 17 17:59 vault -> ../dm-5
[...]
root@roadrunner ~ #

This device is suitable for being used in LVM.

Setting up the volumes

It is really beyond this tutorial to give a full explanation of the Linux LVM, so if you are not familiar with the concepts, make sure you pick up one the the many tutorials you’ll find on the internet.

For this tutorial, we’ll create 2 volumes on that encrypted disk.

Let’s create the physical volume encapsulating the encrypted device :

1
2
3
4

root@roadrunner tmp # pvcreate /dev/mapper/vault
  Writing physical volume data to disk "/dev/mapper/vault"
  Physical volume "/dev/mapper/vault" successfully created
root@roadrunner tmp #

Let’s create the volume group containing that physical volume :

1
2
3

root@roadrunner tmp # vgcreate vg_vault /dev/mapper/vault 
  Volume group "vg_vault" successfully created
root@roadrunner tmp #

Now let’s create the logical volumes on top of that volume group. We’ll create 2 of them for the example :

1
2
3
4
5

root@roadrunner tmp # lvcreate -n lv_vault_01 -L 80M vg_vault
  Logical volume "lv_vault_01" created
root@roadrunner tmp # lvcreate -n lv_vault_02 -L 80M vg_vault
  Logical volume "lv_vault_02" created
root@roadrunner tmp #

Those 2 volumes will now show up in /dev/mapper as well as in /dev/vg_vault :

1
2
3
4
5
6
7
8
9
10
11
12
13

root@roadrunner tmp # ls -l /dev/mapper/
total 0
crw------- 1 root root 10, 236 Apr 17 05:31 control
[...]
lrwxrwxrwx 1 root root       7 Apr 17 21:40 vault -> ../dm-5
[...]
lrwxrwxrwx 1 root root       7 Apr 17 21:40 vg_vault-lv_vault_01 -> ../dm-6
lrwxrwxrwx 1 root root       7 Apr 17 21:40 vg_vault-lv_vault_02 -> ../dm-7
root@roadrunner tmp # ls -l /dev/vg_vault/
total 0
lrwxrwxrwx 1 root root 7 Apr 17 21:40 lv_vault_01 -> ../dm-6
lrwxrwxrwx 1 root root 7 Apr 17 21:40 lv_vault_02 -> ../dm-7
root@roadrunner tmp #

You can now proceed to create the filesystems on those logical volumes and mount them as usual.

Create the mount points :

1
2

root@roadrunner tmp # mkdir /mnt/vault01
root@roadrunner tmp # mkdir /mnt/vault02

Create the filesystems :

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41

root@roadrunner tmp # mkfs /dev/vg_vault/lv_vault_01 
mke2fs 1.42 (29-Nov-2011)
Filesystem label=
OS type: Linux
Block size=1024 (log=0)
Fragment size=1024 (log=0)
Stride=0 blocks, Stripe width=0 blocks
20480 inodes, 81920 blocks
4096 blocks (5.00%) reserved for the super user
First data block=1
Maximum filesystem blocks=67371008
10 block groups
8192 blocks per group, 8192 fragments per group
2048 inodes per group
Superblock backups stored on blocks: 
        8193, 24577, 40961, 57345, 73729
 
Allocating group tables: done                            
Writing inode tables: done                            
Writing superblocks and filesystem accounting information: done 
 
root@roadrunner tmp # mkfs /dev/vg_vault/lv_vault_02
mke2fs 1.42 (29-Nov-2011)
Filesystem label=
OS type: Linux
Block size=1024 (log=0)
Fragment size=1024 (log=0)
Stride=0 blocks, Stripe width=0 blocks
20480 inodes, 81920 blocks
4096 blocks (5.00%) reserved for the super user
First data block=1
Maximum filesystem blocks=67371008
10 block groups
8192 blocks per group, 8192 fragments per group
2048 inodes per group
Superblock backups stored on blocks: 
        8193, 24577, 40961, 57345, 73729
 
Allocating group tables: done                            
Writing inode tables: done                            
Writing superblocks and filesystem accounting information: done

Mount the filesystems into their mount points :

1
2

root@roadrunner tmp # mount /dev/vg_vault/lv_vault_01 /mnt/vault01
root@roadrunner tmp # mount /dev/vg_vault/lv_vault_02 /mnt/vault02

Let’s control that everything went fine :

1
2
3
4

root@roadrunner tmp # df -h /mnt/vault0*
Filesystem                        Size  Used Avail Use% Mounted on
/dev/mapper/vg_vault-lv_vault_01   78M  1.6M   72M   3% /mnt/vault01
/dev/mapper/vg_vault-lv_vault_02   78M  1.6M   72M   3% /mnt/vault02

Alright, everything you would put into /mnt/vault01 and /mnt/vault02 would be stored on the encrypted device.

A word of caution

This is nothing but a step in securing your data. For example, if you store your precious data onto such encrypted volume only to open it later with a software which will store temporary files on an un-encrypted /tmp, the whole setup doesn’t make much sense.

Common practice is to encrypt the swap spaces, as well as /tmp. Unfortunately, this gets really distro-specific and you’ll need to dig into the manual of your favorite Linux distribution.

I hope you’ll have fount this tutorial useful. Don’t hesitate to hit the comments if you see any omission or correction !

Linux : Encrypted LVM quick and easy howto is a post from: Tech@Sakana - A sysadmin's blog

fstab

1
2
3
4
5
6
7
8
9
10
11

$ cat /etc/fstab                                                               
/dev/wd0a / ffs ro,noatime,softdep 1 1
/dev/wd0d /mfs_backup ffs ro,nosuid,noatime,softdep 1 2
swap /dev mfs rw,nosuid,-P=/mfs_backup/dev,-i=128 0 0
swap /var mfs rw,nodev,nosuid,-P=/mfs_backup/var 0 0
swap /home mfs rw,nodev,nosuid,-P=/mfs_backup/home 0 0
swap /root mfs rw,nodev,nosuid,-P=/mfs_backup/root 0 0
swap /tmp mfs rw,nodev,nosuid 0 0
/dev/wd0f /files ffs rw,nodev,nosuid,noatime,softdep 1 2
/dev/wd0e /usr ffs ro,nodev,noatime,softdep 1 2
$

Sync script back MFS to CF

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

$ cat /bin/mfs-sync.sh                                                         
#! /bin/sh
 
RSYNC=/usr/local/bin/rsync
 
mount -o update,rw /mfs_backup
 
for i in var root home
do
        echo "Sync'ing " ${i}
        ${RSYNC} -a --delete /${i}/ /mfs_backup/${i}/
done
 
mount -o update,ro /mfs_backup
$

add this into /etc/rc.shutdown

1
2
3
4
5
6
7

[...]
# Add your local shutdown actions here.
 
echo "Sync'ing mfs to disk"
/bin/mfs-sync.sh
 
echo '.'

and into the root crontab :

1
2
3
4

[...]
# do daily/weekly/monthly maintenance
00      1       *       *       *       /bin/sh /bin/mfs-sync.sh
[...]

Well, I guess that’s about it !
 
 

OpenBSD : Read only Compact Flash installation is a post from: Tech@Sakana - A sysadmin's blog

Wildcards expansion is a feature of the shell which identifies files by a pattern instead of a comprehensive list. For example if you have a directory with the following 10 files all starting by the letter “a” and 10 files all starting by the letter “b” :

1
2
3
4

kattoo@roadrunner test % ls                                        
a01  a03  a05  a07  a09  b01  b03  b05  b07  b09
a02  a04  a06  a08  a10  b02  b04  b06  b08  b10
kattoo@roadrunner test %

and you want the detailed listing of only all of those starting with “a”.

You can do either :

1
2
3
4
5
6
7
8
9
10
11

kattoo@roadrunner test % ls -l a01 a02 a03 a04 a05 a06 a07 a08 a09 a10
-rw-r--r-- 1 kattoo kattoo 0 Jan 24 08:42 a01
-rw-r--r-- 1 kattoo kattoo 0 Jan 24 08:42 a02
-rw-r--r-- 1 kattoo kattoo 0 Jan 24 08:42 a03
-rw-r--r-- 1 kattoo kattoo 0 Jan 24 08:42 a04
-rw-r--r-- 1 kattoo kattoo 0 Jan 24 08:42 a05
-rw-r--r-- 1 kattoo kattoo 0 Jan 24 08:42 a06
-rw-r--r-- 1 kattoo kattoo 0 Jan 24 08:42 a07
-rw-r--r-- 1 kattoo kattoo 0 Jan 24 08:42 a08
-rw-r--r-- 1 kattoo kattoo 0 Jan 24 08:42 a09
-rw-r--r-- 1 kattoo kattoo 0 Jan 24 08:42 a10

or the much shorter :

1
2
3
4
5
6
7
8
9
10
11
12

kattoo@roadrunner test % ls -l a*                                     
-rw-r--r-- 1 kattoo kattoo 0 Jan 24 08:42 a01
-rw-r--r-- 1 kattoo kattoo 0 Jan 24 08:42 a02
-rw-r--r-- 1 kattoo kattoo 0 Jan 24 08:42 a03
-rw-r--r-- 1 kattoo kattoo 0 Jan 24 08:42 a04
-rw-r--r-- 1 kattoo kattoo 0 Jan 24 08:42 a05
-rw-r--r-- 1 kattoo kattoo 0 Jan 24 08:42 a06
-rw-r--r-- 1 kattoo kattoo 0 Jan 24 08:42 a07
-rw-r--r-- 1 kattoo kattoo 0 Jan 24 08:42 a08
-rw-r--r-- 1 kattoo kattoo 0 Jan 24 08:42 a09
-rw-r--r-- 1 kattoo kattoo 0 Jan 24 08:42 a10
kattoo@roadrunner test %

In the second form you ask the shell to identify all the files starting with an “a” followed by any character, and to provide them as arguments to the command ls. Both forms are equivalent.

Now, some tools are capable of interpreting patterns on their own. find or grep are such tools. In that situation, you do not want the shell to interpret the patterns and replace them by the matching files before providing them as command line arguments.

You do that by quoting the patterns, thus explicitly instructing the shell to leave the patterns alone and to provide the pattern (and not the matching files) directly as command line arguments to the command.

Example :

1
2
3

kattoo@roadrunner Downloads % find . -name "*.tar.gz" | egrep "open.*2"
./pyopencl-2011.2.tar.gz
kattoo@roadrunner Downloads %

Here the patterns are quoted so that the shell won’t try to replace them by matching files. find and grep will get the patterns as command line arguments directly and process them to respectively find the matching files and filter the matching lines.

Unix 101 : Shell wildcards expansion, to quote or not to quote is a post from: Tech@Sakana - A sysadmin's blog

Here’s a gross hack for whom is desperate to get it working on Gentoo.

Step 1 : Get the package

You can download the package from here.
Pick the package matching your own architecture.

Step 2 : Convert the DEB package and extract it

Install the package deb2targz if you don’t already have it.

The following command will create a tar.gz file from the .deb package :

1

deb2targz spotify-client-qt_0.6.2.291.gcccc1f5.116-1_amd64.deb

You can then extract that tar.gz file like below :

1

tar zxvf spotify-client-qt_0.6.2.291.gcccc1f5.116-1_amd64.tar.gz

This will create you a usr directory, containing spotify files.

Toss them at the appropriate places on your system :

1
2
3
4

cd usr
mv bin/spotify /usr/bin/
mv share/pixmaps/* /usr/share/pixmaps/
mv share/spotify/ /usr/share/

Step 3 : Fixing library issues

Now this is the ugly part. Spotify is linked against specific versions of some libraries (SSL 0.9.8 and Crypto 0.9.8). In order to make it work, you need to fake those versions by creating a symlink from the wanted version to the existing (you’ll need to figure this out) version in your system.

1
2
3

cd /usr/lib
ln -s libssl.so.1.0.0 libssl.so.0.9.8
ln -s libcrypto.so.1.0.0 libcrypto.so.0.9.8

Step 4 : Instructing firefox to open the spotify protocol with the Spotify application

You need to register the spotify protocol so that Firefox will know how to deal with those “spotify:” urls.

1. Open the about:config page
2. Create a boolean value by the name of network.protocol-handler.expose.spotify
3. Set its value to false
4. Click on a spotify link (for example a playlist link or such). A popup will open and ask you to pick an application. Use /usr/bin/spotify.

That’s it. All set.
I’m not proud of it…. but I wanted to use Spotify badly

Getting Spotify to run on Gentoo/Linux: A Gross and Cruel Hack is a post from: Tech@Sakana - A sysadmin's blog

1. The BLACKLIST function

Asterisk implements a BLACKLIST function which can be used to check whether a callerID is blacklisted or not, here is the synopsis (which you can get by connecting to thee asterisk server by issuing the asterisk -v command and then core show function BLACKLIST) :

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

spaghetti*CLI> core show function BLACKLIST
 
  -= Info about function 'BLACKLIST' =- 
 
[Synopsis]
Check if the callerid is on the blacklist. 
 
[Description]
Uses astdb to check if the Caller*ID is in family 'blacklist'. Returns '1'
or '0'.
 
[Syntax]
BLACKLIST()
 
[Arguments]
Not available
 
[See Also]
DB
spaghetti*CLI>

This is what we’re going to use for this example.

2. Managing the blacklist

You can add callerIDs to the blacklist with the following command :

1
2
3
4

spaghetti*CLI> database put blacklist 03001125000 "Mother-in-law from hell"
Updated database successfully
spaghetti*CLI> database put blacklist 03001125150 "FAX machine harassing me"
Updated database successfully

If later on you wish to remove an item from the blacklist (maybe the fax is not that bad after all !), use the following :

1
2

spaghetti*CLI> database del blacklist 03001125150 
Database entry removed.

And of course you can list the content of the current blacklist like that :

1
2
3
4

spaghetti*CLI> database show blacklist
/blacklist/03001125000                             : Mother-in-law from hell
1 results found.
spaghetti*CLI>

Use those commands to tailor the blacklist according to your needs.

3. Altering the dialplan to filter out the blacklisted numbers

Next you’ve got to update your incoming context to deal with blacklisted callerIDs. My incoming context is named “incoming-calls” but you might have to adjust that :

1
2
3
4
5
6
7
8
9
10

[incoming-calls] ; on declare le contexte de reception d'appels depuis freephonie
exten => s,1,GotoIf($["${CALLERID(NUM)}" = "anonymous"] ? 10) 
exten => s,2,GotoIf(${BLACKLIST()} ? 10)
exten => s,3,Dial(SIP/phone1&SIP/phone2,10)
exten => s,4,Congestion()
exten => s,5,Hangup()
exten => s,10,Answer
exten => s,11,Wait(1)
exten => s,12,MusicOnHold(default)
exten => s,13,Hangup

So here, the rules 1 and 2 are to send both anonymous callers (mostly telemarketers over here) and blacklisted callers to an infinite holding music (starting at line 10). The rules 3,4,5 are to deal with other calls and direct them to 2 SIP phones.

That’s it ! Feel free to ask if you need more details about this set up.

Asterisk 101 : How to get rid of your mother-in-law … is a post from: Tech@Sakana - A sysadmin's blog

So this post will document how to sign up for a GV account as well as how to use it with Asterisk afterwards, in the prospect of using it if you are not in the USA.

In order to be able to sign up for GV, you need to meet 2 prerequisites :

1. You need to have a US IP address
2. You need to have a US phone number, which will be used to validate your GV account

Step 1 is left as an exercise to the reader (“Good luck ! I’m behind 7 proxies !” ).

Step 2 is the one we’re going to describe here, as an example of what you can pull with simple Asterisk configurations.

1. Getting a US phone number

What you really need to find is a DID (Direct Inward Dialing aka DDI : Direct Dial-In) provider. It will provide you with a US phone number and will patch that call either to another phone number or to a SIP address.

GV will only forward calls to US phone numbers, so you need one of those. IPKall is such a free provider. They will provide you an American phone number and will forward it to any SIP or IAX2 address. Creating an account only takes a minute.

Nothing fancy here : Simply fill the SIP account into the SIP phone number field, and the SIP servername or IP into the SIP proxy field.

2. Setting up Asterisk

Now IPKall will gladly forward the calls to your SIP account. You can setup this SIP account as simply as below :

IPKall has a specificity we need to take care of : calls can originate from 2 different servers. We need to have calls coming from both servers to get into the same context. To avoid repeating twice the same configuration block (with just the IP address being different), we’ll use a template.

We’ll also define a SIP account for a SIP phone (or for a softphone).

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

[phone1]
type=friend
username=phone1
secret=SecretPassword
host=dynamic
context=myhouse
nat=yes ; if you need to connect from behind a nat
 
[ipkall](!) ; This section is only a template
type=peer
username=ipkall
context=ipkall-in
insecure=invite
 
[ipkall-01](ipkall) ; We import the previous template to setup calls from
host=66.54.140.46       ; the first IPKall server
 
[ipkall-02](ipkall) ; We import the previous template to setup calls from
host=66.54.140.47       ; the second IPKall server

I’ve setup an SIP “number” I’ve instructed IPKall to forward the calls to is “ipkall”. The configuration below must reflect this. Here, phone calls to the “ipkall” extension will be routed to the “phone1″ SIP phone.

1
2
3

[ipkall-in]
exten => ipkall,1,Dial(SIP/phone1)
exten => ipkall,n,Hangup()

3.Setup a softphone and finally your GV account

Now all you need is a softphone (I like sflphone for that purpose) or a SIP phone to be configured as “phone1″ (check your favorite softphone instructions to do so) and head back to GV to create your account.

GV will assign you a phone number and will ask you to which phone number to route the phone calls. That’s where you’ll specify your IPKall phone number.

GV will then ask you to validate this phone call by giving you a 2 digit number and calling you on your IPKall phone number. You’ll have to pick up the call on your softphone and dial the 2 digit number.

Voila, the account is created and validated !

Any call to your GV phone number will be routed to IPKall which will send it to your Asterisk installation, which will then ring your softphone or SIP phone.

Pretty nifty, heh ?

Asterisk 101 – Ghetto GoogleVoice : Signing up for / using GV even if you’re not in the USA using Asterisk is a post from: Tech@Sakana - A sysadmin's blog

If you need an easy way to confirm that a text file is DOS or UNIX formatted (they differ with respect to the end of line character(s) for example) or if you wish to display normally non-printing characters of a text file, you can use the -vET command line switches of the cat utility.

As explained in the man page :

• -v : will use the ^ and M- notation for control and multibytes characters
• -E : will make ends of lines visible
• -T : will make tabulations visible

For example :

1
2
3
4
5

% cat -vET test.txt
a test message for$
showing the^Iuse of   cat -vET$
^I$
that is all$

and compare it to the following plain cat output, without any command line option :

1
2
3
4
5

% cat test.txt     
a test message for
showing the     use of   cat -vET
 
that is all

You can easily tell what blank space is a space or actually a tabulation for example. If you’d happen to see ^M characters popping out at the end of the lines, then you this is actually a DOS text file (which you might need to convert to UNIX style end of lines with an utility such as dos2unix)

Unix 101 : Showing non-printing characters in text files (ex : DOS files) is a post from: Tech@Sakana - A sysadmin's blog

This snippet is to place into the extension.conf file :

1
2
3
4
5
6
7
8
9

[incoming] ; incoming calls
exten => s,1,GotoIf($["${CALLERID(NUM)}" = "anonymous"] ? 10) 
exten => s,2,Dial(SIP/phone1&SIP/phone2,10)
exten => s,3,Congestion()
exten => s,4,Hangup()
exten => s,10,Answer
exten => s,11,Wait(1)
exten => s,12,MusicOnHold(default)
exten => s,13,Hangup

This block will check for the NUMber information of the Caller ID and if it is “anonymous”, it will send it to the step 10 which will pick up the call and start the holding music. If the Caller ID is not “anonymous”, it will ring 2 SIP phones for 10 secs, and if no one picks those, send it to congestion mode.

That’s all !

Edit : On a second thought, I think I’ll change that to have Asterisk to pick up the call and let the caller leave a message. That’s still going to catch those telemarketers (waste time & money), while giving a chance to legit callers to speak their message.

Asterisk 101 : How to troll telemarketers (aka automatically send hidden Caller ID to a waiting music forever) is a post from: Tech@Sakana - A sysadmin's blog

Q: If I chmod 777 a file, can someone delete it ?
A: No. To explain that, let’s first talk about directories. You can imagine a directory as a special file which would have one line for each file contained in that directory. On each such line, there would be the inode number, and the name of the matching file.
Deleting a file would be like removing a line from that special directory file which means that you need write permission on the directory containing the file to do so.

Q: What about that 777 mode /tmp directory ? Won’t someone delete all my files then ?
A: No. /tmp ‘s permissions are not actually 777 but 1777. That “1″ is the sticky bit which materialize by the “t” flag showing up in “ls -l”. That sticky bit means that only the owner of the file is allowed to delete it.

1
2

kattoo@roadrunner ~ % ls -ld /tmp
drwxrwxrwt 10 root root 4096 Dec  8 21:53 /tmp/

Q: Knowing that bit about directories being special files, how would you implement a hard links ?
A: Simply have 2 “special file directories” having a line with the same inode number and different (or same !) file names. There you go, alternate filenames for the same on-disk content.

Q: But then, if I delete a file with a hardlink, the “other” filename will point to no data ?
A: No. The inode contains quite a few informations : dates, permissions, owner, group and such as well as the number of hardlinks. Every time you delete such a hardlink, this counter is decremented. Everytime you create a hardlink, the count is incremented. The actual content of the file is only actually deleted when the count reaches 0.

Q: How about soft links (aka symbolic links aka symlinks) ?
A: A symlink is yet another special kind of file. You can imagine that it’s a file which contains the name of another file. Anyone accessing the symlink will actually access the content of the file which name is in the symlink special file. This name resolution being done in-kernel, it’s mostly transparent for userland processes. Notice that you could place the name of a non-existing file in the symlink (dead link !), which is not possible with a hardlink.

Unix 101 : Filesystem basics & Special files is a post from: Tech@Sakana - A sysadmin's blog