www.ifconfig.se

Gör Vim ännu trevligare med ~/.vimrc

2011-04-19T21:42:00+02:00

Jag har använt Vim som min primära text-editor de senaste 8-10 åren och skulle nog finna det väldigt svårt att byta till något annat. Trots detta så känner jag mig halvt handikappad då jag använder vanliga standard vi i t.ex FreeBSD eller ArchLinux. Detta beror på att jag förväntar mig att saker som att kunna flytta markören med piltangenterna inte fungerar i insert-mode utan diverse ändringar i min ~/.vimrc.

Många finner det svårt att förstå hur folk kan använda Vim då de är vana att kunna markera, klippa ut och flytta markören med mus-pekaren pga editorer så som notepad och Word. Faktum är att du blir betydligt mer produktiv om du tar som vana att endast använda tangentbordet.

Jag föredrar att vim har diverse simpla funktioner som syntax highlighting, att vim kommer ihåg vart i filen jag senast var, automatiskt intenderar kod (tips: :set paste), att vim konverterar text från ISO till UTF-8 on-the-fly, osv. För att få detta beteende, spara min ~/.vimrc och lägg den i din hemma-mapp.

" #####
" #
" # File:   /usr/local/share/vim/vimrc, $HOME/.vimrc
" # Author: Jesper Wallin (jesper@ifconfig.se)
" # Date:   22-09-2011
" #

" ###################
" # VIM default
" ###################
set nocompatible

" ###################
" # Fix backspace
" ###################
set bs=2

" ###################
" # Auto-indenting
" ###################
set ai

" ###################
" # Hilight searches
" ###################
set hlsearch

" ###################
" # Use .viminfo
" ###################
set viminfo='20,\"500

" ###################
" # Command history
" ###################
set history=50

" ###################
" # Show cursor
" ###################
set ruler

" ###################
" # Disable modeline
" ###################
set nomodeline

" ###################
" # Encode UTF-8
" ###################
if v:lang =~ "utf8$" || v:lang =~ "UTF-8$"
  set fileencodings=utf-8,latin1
endif

" ###################
" # Don't use Ex mode, use Q for formatting
" ###################
map Q gq

" ###################
" # Syntax Highlighting
" ###################
syntax on

" ###################
" # Tweaks for xterm
" ###################
if &term=="xterm"
  set t_RV=          " don't check terminal version
  set t_Co=8
  set t_Sb=^[4%dm
  set t_Sf=^[3%dm
endif

" ###################
" # Move to last position
" ###################
au BufReadPost * if line("'\"") > 0 && line("'\"") <= line("$") |
                         \ exe "normal g'\"" | endif

" ###################
" # Remove trailing whitespaces on PHP files.
" ###################
autocmd BufWritePre *.php :%s/\s\+$//e

Uppdatering: Har lagt till highlight på sök samt att den tar bort mellanslag i slutet på alla rader i PHP-filer.

För att få denna konfiguration att fungera system-wide, döp om filen till vimrc, utan punkten innan. Därefter flyttar du filen till /etc (se man vim för mer information om detta)

Kommentera gärna och berätta vilken editor som är din favorit och varför. Om det råkar vara vim, vad för konfiguration använder du? :-)

Hämta filer parallellt med PHP och libcurl

2011-01-03T08:05:00+01:00

Varför hämta filer parallellt?

I normala fall när du surfar runt på webben så hanterar webbläsaren alla nerladdningar. Alla moderna webbläsare hämtar de filer (CSS, JavaScript, osv) som finns på en webbplats parallellt. Dvs, alla filer hämtas samtidigt istället för att nerladdningarna ska behöva vänta på varandra innan de kan börja.

Låt säga att du hämtar information från andra webbplatser för att lagra och sedan presentera den på din egna webbplats. Ett exempel kan vara affiliatenätverk, som ofta erbjuder information om produkter via XML-filer. Här kan det vara trevligt att hämta all data parallellt för att snabba upp processen.

Ett annat exempel kan vara en robot som vill hämta tusentals dokument för att sedan indexera. Om detta inte skulle ske parallellt så skulle detta ta enormt mycket längre tid.

PHP och libcurl

PHP (och många andra språk) har stöd för biblioteket libcurl. Med libcurl är det väldigt enkelt att hämta filer genom olika protokoll samtidigt som det är riktigt kraftfullt och flexibelt eftersom du kan konfigurera det på så många olika sätt.

Normalt när du hämtar en fil med libcurl använder du följande:

<?php

// initiate libcurl.
if ($ch = curl_init('http://www.ifconfig.se/'))
{
  // configure libcurl.
  curl_setopt($ch, CURLOPT_AUTOREFERER, 1);
  curl_setopt($ch, CURLOPT_FOLLOWLOCATION, 1);
  curl_setopt($ch, CURLOPT_MAXREDIRS, 32);
  curl_setopt($ch, CURLOPT_HEADER, 0);
  curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1);

  // execute libcurl.
  $body = curl_exec($ch);

  // close nicely.
  curl_close($ch);
}

?>

Detta är ganska så mycket kod för något som file_get_contents() kan göra på en rad. Dock kräver file_get_contents() att allow_url_fopen är aktiverat i php.ini, vilket enligt mig är en säkerhetsrisk. Dessutom får du betydligt mer kontroll med libcurl och du kan även konfigurera libcurl att hämta komprimerade filer, vilket i sig spar bandbredd.

Att hämta filer parallellt med libcurl

För att hämta filer parallellt måste man först initiera ett objekt, som vi sedan kan lägga till vanliga curl objekt till. När vi lagt till alla objekt så använder vi oss av curl_multi_exec() för att hämta alla filerna samtidigt.

<?php

// urls to fetch.
$urls = array(
  'http://www.ifconfig.se/',
  'http://www.facebook.com/',
  'http://www.twitter.com/',
  'http://www.youtube.com/',
  'http://www.google.com/'
);
$total = count($urls);

// initiate the multi-handler.
$cm = curl_multi_init();

// loop through all urls and initiate all objects.
for($i=0;$i<$total;$i++)
{
  // initiate a libcurl object for each url.
  $ch[$i] = curl_init($urls[$i]);

  // configure each object.
  curl_setopt($ch[$i], CURLOPT_AUTOREFERER, 1);
  curl_setopt($ch[$i], CURLOPT_FOLLOWLOCATION, 1);
  curl_setopt($ch[$i], CURLOPT_MAXREDIRS, 32);
  curl_setopt($ch[$i], CURLOPT_HEADER, 0);
  curl_setopt($ch[$i], CURLOPT_RETURNTRANSFER, 1);

  // add this object to the multi-handler.
  curl_multi_add_handle($cm, $ch[$i]);
}

// execute the multi-handler.
while(!isset($threads) || $threads > 0)
{
  curl_multi_exec($cm, $threads);
}

// loop through the result and close nicely.
for($i=0;$i<$total;$i++)
{
  // get the result and some useful information.
  $body = curl_multi_getcontent($ch[$i]);
  $info = curl_getinfo($ch[$i]);

  // remove the handler and close it.
  curl_multi_remove_handle($cm, $ch[$i]);
  curl_close($ch[$i]);

  // print some information/statistics.
  printf("%s: %s (%ssec, %sKB, %s redirects)\n",
    $info['http_code'],
    $info['url'],
    round($info['total_time'], 2),
    round($info['size_download'] / 1024, 2),
    $info['redirect_count']
  );
}

// close the multi-handler.
curl_multi_close($cm);

?>

Detta script kommer köra alla 5 förfrågningar samtidigt och därefter skriva ut lite information om varje URL. Med funktionen curl_getinfo() får vi ut användbar information om själva förfrågan till servern samt lite meta-data så som storlek, kodning, osv. Om du har PHP installerat för CLI, så kan du köra det direkt i shellet.

php ./curl-multi.php
200: http://www.ifconfig.se/ (0.48sec, 56.07KB, 0 redirects)
200: http://www.facebook.com/common/browser.php (1.08sec, 11.24KB, 1 redirects)
200: http://twitter.com/ (1.9sec, 43.29KB, 1 redirects)
200: http://www.youtube.com/ (0.62sec, 79.82KB, 0 redirects)
200: http://www.google.se/ (0.62sec, 10.54KB, 1 redirects)

Avslut

Att använda libcurl gör att man får enormt mycket kontroll över själva filhämtningen samtidigt som det är smidigt att konfigurera. Det stödjer dessutom enormt många protokoll så som HTTP, FTP, SSH/SCP, IMAP, POP3, m.fl.

En annan smidig funktion med libcurl är att oavsett om du hämtar en fil som är komprimerad (gzip, deflate, etc), så kommer alla cURL-funktioner ändå returnera den okomprimerade filen. Detta gör att man enkelt kan ignorera hela processen med att kontrollera om filen är komprimerad eller inte.

Hur använder du själv cURL och framför allt, i vilket språk använder du det i? Personligen har jag främst använt cURL ihop med PHP, då många av de andra språken jag använder har egna funktioner för just det jag behöver.

Att skriva script-taggar med JavaScript

2011-01-02T01:47:00+01:00

Introduktion

För en tid sedan kom jag i kontakt med ett ganska så ovanligt problem. Jag skulle ladda ett JavaScript i en lightbox, som i sin tur laddades av ett JavaScript. Dvs, jag skulle skriva ut en <script>-tag med hjälp av JavaScript.

Både Chrome och Firefox slutade att läsa mitt JavaScript så fort jag skrev ut en </script>-tag, då båda webbläsarna helt korrekt antog att JavaScriptet var slut.

<script type="text/javascript">
$(document).ready(function(){
  $.lightbox('<script type="text/javascript" src="/some/file.js"></script>');
});
</script>

Koden ovan kommer sluta läsas av webbläsaren efter den första </script>-taggen och därmed tolka scriptet som felaktigt, då det avbryts mitt i en funktion.

Lösningen på problemet

Jag har tidigare sett denna lösning användas på många webbplatser, men jag har alltid varit övertygad om att det har varit ett annonsnätverk eller liknande som försöker rundgå plugins så som AdBlock, NoScript, osv.

<script type="text/javascript">
$(document).ready(function(){
  $.lightbox('<scr' + 'ipt type="text/javascript" src="/some/file.js"></scri' + 'pt>');
});
</script>

Genom att helt enkelt bara dela taggen </script> till två strängar och sen sätta ihop dem med hjälp av JavaScriptet, så tolkar webbläsaren det som </scri och pt> istället för </script> och avslutar därmed inte scriptet.

Som en liten notering kan det väl vara värt att nämna att ett JavaScript i en lightbox inte kommer köras oavsett och nu i efterhand kan jag väl lugnt säga att det var en ganska så kass approach på det hela. ;-)

Google tar hårdare tag mot Cloaking

2010-12-30T03:42:00+01:00

Vad är Cloaking?

Cloaking är det begrepp Google använder när man inte presenterar samma innehåll till Google som till övriga användare. Google ser allvarligt på detta och du riskerar att bli borttagen helt ur SERP:en om du använder dig av cloaking.

Om du inte vill att Google ska besöka eller indexera vissa delar av din webbplats, så rekommenderar jag istället att du använder dig av robots.txt eller en robots meta-tag.

Hårdare tag mot Cloaking i början av 2011

Google kommer, enligt Matt Cutts, att ta hårdare tag mot cloaking i början av 2011.

För att kontrollera om man behandlar Googlebot annorlunda på något sätt så kommer man nu även granska alla headers och redirects på webbplatsen. Min gissning är också att denna ändring kommer vara bestående om den fungerar bra.

Personligen ser jag inte varför man skulle behöva hantera Googlebot på något annorlunda sätt jämfört med vanliga användare. Om detta är ett måste så kanske det är dags att se över vilka metoder man använder för att få sin sida indexerad. ;-)

Fulltext sök med PostgreSQL

2010-12-26T22:13:00+01:00

Vad är Fulltext sök?

Fulltext sök är en funktion som erbjuder möjligheten att söka i en tabell och hitta de rader som matchar en specifik fråga. Fulltext låter dig även ranka resultatet efter vilket relevans och likhet frågan har till texten man söker i.

Fulltext sök låter dig göra en mer fördjupad sökning än vanliga funktioner så som LIKE, som enbart söker efter ett ord eller en fras i texten. LIKE är dessutom väldigt prestandakrävande eftersom den inte använder något index, utan måste gå igenom alla rader i tabellen vid varje sökning.

Så som PostgreSQL har implementerat Fulltext, så tar den även hänsyn till vilket språk som används och kan därför också ta hänsyn till hur olika ord är böjda (ringa vs ringer vs ringde). Den ignorerar även så kallade stopwords, ord som används för ofta för att vara användbara vid en sökning (och, är, har, osv). Den klarar även av att hantera synonymer (glad vs lycklig) vilket man också kan använda för att korrigera vanligt förekommande stavfel.

Datatyper och normalisering

PostgreSQL använder datatyperna tsvector och tsquery för att hantera den data som används när du utför en sökning. Typen tsvector innehåller den representation av texten som man ska söka i, medan tsquery innehåller motsvarande data för frågan.

to_tsvector()

För att kunna använda den oformaterade texten i en vanlig kolumn så finns funktionen to_tsvector() som konverterar text till datatypen tsvector. En tsvector innehåller en sorterad lista med alla unika lexemer och vilken position i texten ordet har. Lexemer är normaliserade ord där alla stopwords blivit borttagna och synonymer samt böjelser har blivit sammanslagna.

SELECT to_tsvector('swedish', 'Sex laxar i en vaxad laxask');
               to_tsvector                
------------------------------------------
 'ask':6 'e':4 'lax':2,6 'sex':1 'vaxa':5

to_tsquery()

Funktionen to_tsquery() används för att skapa en lista av de lexemer som man ska söka efter i en tsvector. Denna listan är också sorterad efter & (AND), | (OR) och ! (NOT) som används för att matcha fler/färre rader. Det går även att gruppera dessa operatorer med hjälp av parenteser.

SELECT to_tsquery('swedish', 'laxarna & vaxar & asken');
         to_tsquery
-----------------------
 'lax' & 'vax' & 'ask'

Man kan även använda funktionen plainto_tsquery() som konverterar oformaterad text till en tsquery, dock kan man inte använda sig av & (AND), | (OR) eller ! (NOT) här.

SELECT plainto_tsquery('swedish', 'laxarna vaxar asken');
    plainto_tsquery
-----------------------
 'lax' & 'vax' & 'ask'

Gemensamt för funktionerna ovan är att det första argumentet anger vilken konfiguration man ska använda. Du kan lista alla standardkonfigurationerna genom att skriva \dF[+] i psql. Beroende på vilken konfiguration du använder så normaliseras texten olika.

Att utföra en sökning

För att göra en sökning så använder man operatorn @@ och jämför tsvector med tsquery och får då tillbaks true eller false beroende på om dom matchar eller inte.

SELECT to_tsvector('swedish', 'Sex laxar i en vaxad laxask') @@
    plainto_tsquery('swedish', 'laxar') AS result;
 result 
--------
 t

Åter igen så hanterar hanterar Fulltext olika böjelser av orden:

SELECT to_tsvector('swedish', 'Sex laxar i en vaxad laxask') @@
    plainto_tsquery('swedish', 'laxarna vaxar asken') AS result;
 result 
--------
 t

För att söka i en kolumn, t.ex posts, så anger man helt enkelt kolumnen:

SELECT to_tsvector('swedish', posts) @@
    plainto_tsquery('swedish', 'sökord') AS result;
 result 
--------
 t

Ranka resultatet

När man söker och matchar flera hundra eller tusen rader så kan det vara smidigt att sortera efter relevans. För att göra detta använder man funktionerna ts_rank() och ts_rank_cd().

SELECT title, ts_rank_cd(to_tsvector('swedish', content), query, 16) AS rank 
   FROM posts, to_tsquery('swedish', 'FreeBSD') query
   WHERE query @@ to_tsvector('swedish', content) ORDER BY rank DESC;

                 title                  |   rank    
----------------------------------------+-----------
 Virtualisera med KVM i Ubuntu 9.10     | 0.0887506
 Ports i FreeBSD                        | 0.0729145
 FreeBSD 8.0 och rc.conf                | 0.0132641

Båda funktionerna tar hänsyn till hur ofta ordet nämns i texten, textens storlek samt även hur viktig delen av texten är där ordet förekommer. Det som skiljer de båda funktionerna åt, är att ts_rank_cd() även tar hänsyn till hur många ord som finns mellan varje sökord, dvs, hur hög densitet texten har. (cd = cover density)

Du kan även ange hur viktig olika delar av texten du söker i är, samt ange hur längden på texten ska påverka rankingen. För mer information om detta, läs dokumentationen.

Markera sökord i resultatet

Något som sökmotorer ofta gör är att presentera sökresultat där man markerar sökorden med fet stil eller liknande. På så sätt kan man enkelt se hur frågan man ställt är relaterad till texten den matchat. Funktionen ts_headline() gör just detta:

SELECT ts_headline('swedish',title, query), rank FROM
  (SELECT title, query, ts_rank_cd(to_tsvector('swedish', title), query, 16) AS rank 
   FROM posts, to_tsquery('swedish', 'FreeBSD | rc.conf') query
   WHERE query @@ to_tsvector('swedish', title) ORDER BY rank DESC) AS foo;

              ts_headline              |   rank   
---------------------------------------+----------
 <b>FreeBSD</b> 8.0 och <b>rc.conf</b> |      0.1
 Ports i <b>FreeBSD</b>                | 0.063093
 <b>FreeBSD</b> 8.0 och sysctl.conf    |     0.05

Anledningen till att man använder en sub-query här är för att ts_headline() självklart måste använda original texten för att markera de ord man söker efter. Om du inte använder en sub-query måste detta göras på alla rader i tabellen, vilket är väldigt prestandakrävande beroende på hur mycket data du har.

Hur texten ska markeras och antalet ord som ska finnas med före och efter sökordet går att konfigurera på en mängd olika sätt, jag kan även här rekommendera att du läser igenom dokumentationen.

Begränsningar

Även om denna implementation av PostgreSQL är riktigt kraftfull så har den självklart en del begränsningar. Något som jag rent spontant kan sakna, är möjligheten att söka på exakta fraser. Man kan självklart använda & (AND), men detta betyder ju inte att orden står i följd. Det andra är mer tekniska begränsningar som har med storlek att göra:

Storleken på varje lexem får max vara 2KB
Storleken på tsvector (alla lexemer och dess position i texten) får max vara 1MB
Max antal lexemer måste vara mindre än 2⁶⁴
Positionen på en laxem måste vara högre än 0 och mindre än 16,383
Max antalet position en lexem kan ha är 256
Antalet noder (lexermer och operatorer) i en tsquery 32,768

Avslut

Jag är personligen kär i hur PostgreSQL har implementerat ett Fulltext sök. Den är oerhört snabb, skalar enormt bra, väldigt kraftfull och går att konfigurera på en mängd olika sätt. Jag använder just denna implementation av Fulltext sök för att hitta relaterade artiklar på inlägg/artiklar jag gör här på bloggen. På så sätt uppdateras det automatiskt och jag får faktiskt artiklar som är relaterade på riktigt och inte som många WordPress plugin gör och använder kommentarer(!?) ihop med kategorier/taggar för att avgöra om innehållet är relaterat eller inte.

Ett annat tips är att skapa en kolumn med datatypen tsvector och köra to_tsvector() vid INSERT och UPDATE istället. På så sätt har du redan normaliserat texten och slipper därför göra detta varje gång du ska söka i tabellen. Du bör även skapa ett GIN-index om du har mycket data för att maximera prestandan.

Notera också att jag har ändrat mina Fulltext konfigurationer en aning, så resultaten ovan kan skilja lite från standardinställningarna i PostgreSQL.

Prestanda och ORDER BY RAND()

2010-12-23T22:05:00+01:00

Använd inte ORDER BY RAND() om du har många rader i tabellen

För att få ut 10 rader i slumpad ordning från en tabell i MySQL så använder man väldigt ofta funktionen ORDER BY RAND() ihop med LIMIT:

SELECT uid, username, passwd FROM users ORDER BY RAND() LIMIT 10;

Detta är ingen fara så länge det handlar om mindre data (~250 rader) men vad händer om du ställer samma fråga till en tabell med 25000 rader? Då kommer MySQL generera 25000 slumpade tal, vilket är ganska så tungt ur prestandasynpunkt. Därefter behöver MySQL sortera dessa 25000 tal för att veta vilket tal som är lägst, vilket också är tungt då MySQL skapar temporära tabeller för detta.

Något som kan vara värt att poängtera är att om uid, username och passwd har en fast längd (varchar, int, date, etc) så går det snabbare att sortera. Om den har en rörlig längd (text) måste MySQL även gå igenom alla rader innan för att veta hur mycket minne som behöver allokeras för den temporära tabellen som kommer skapas.

En av många lösningar på detta problem

Lösningen på detta problem är långt ifrån enkel och förmodligen inte heller optimal. Istället för att sortera all data i MySQL och för att slippa hämta all data och sortera den i applikationen, så hämtar vi bara det högsta och lägsta uid.

SELECT MIN(uid) AS min, MAX(uid) AS max FROM users;

Därefter använder vi PHP för att slumpa 10 tal mellan min och max. Funktionen IN() i MySQL gör det dessutom enkelt att endast hämta de 10 rader vi slumpat fram utan att behöva använda en massa AND. Detta gör att vi inte behöver använda ORDER BY RAND() alls.

<?php

// get the first/last row of the table.
$sql = "SELECT MIN(uid) AS min, MAX(uid) AS max FROM users";
$res = mysql_query($sql);
$row = mysql_fetch_object($res);

// get 10 random rows and skip ORDER BY RAND() completely.
for ($i=0;$i<10;$i++)
{
    $users[$i] = rand($row->min, $row->max);
}

// fetch those 10 random rows.
$sql = sprintf("SELECT uid, username, passwd FROM users WHERE uid IN(%s)",
    implode(',', $users)
);
$res = mysql_query($sql);

Borttagna rader

Om du har raderat några rader ur tabellen och därför inte får ut alla 10 rader, då kan du enkelt slumpa fram fler tal med PHP och sedan använda LIMIT 10.

// get 100 random rows.
for ($i=0;$i<100;$i++)
{
    $users[$i] = rand($row->min, $row->max);
}

// fetch those 100 random rows, but limit the result to 10 rows.
$sql = sprintf("SELECT uid, username, passwd FROM users WHERE uid IN(%s) LIMIT 10",
    implode(',', $users)
);
$res = mysql_query($sql);

?>

Även om denna lösning kanske inte är helt optimalt så är den betydligt snabbare än att enbart använda ORDER BY RAND() LIMIT 10 om du har tiotusentals rader. En annan lösning är att skapa en till kolumn och fylla den med slumpade tal som man sedan sorterar efter när man läser ur tabellen. Dessvärre måste man generera om alla tal i denna kolumn varje gång man vill ändra ordningen på resultatet, vilket gör att jag personligen väljer bort den lösningen.

Har du någon bättre lösning eller tips på hur man kan lösa detta problem?

Ta vara på alla dina inlänkar

2010-12-19T20:12:00+01:00

Inlänkar och PageRank

Som du säkert redan vet är inlänkar en av de viktigaste faktorerna när det gäller att ranka bra i sökresultatet. Inlänkar är det som PageRank baserar sitt värde på och avgör hur viktig en webbplats är. Självklart är det flera hundra andra faktorer som också granskas när Google avgör vart din webbplats hamnar i sökresultetet.

Det är ingen nyhet för SEO-expeter att inlänkar med högre PR är bättre än inlänkar med låg PR. Dock så är ju en inlänk alltid en inlänk och det vore dumt att inte ta vara på den om den pekar till en sida som inte finns längre.

Hitta brutna inlänkar

Google's Webmasters Tools erbjuder möjligheten att hitta brutna inlänkar på din webbplats. Personligen tycker att Webmasters Tools fungerar relativt dåligt och visar ofta gammal data. Ett bättre alternativ för att just hitta brutna inlänkar är att analysera loggarna från din webbserver. Självklart kräver det att någon har försökt besöka den, men chansen är ganska stor att åtminstone en robot har försökt besöka sidan.

Med hjälp av grep, awk och sort kan vi enkelt få ut alla brutna länkar:

grep ' 404 ' /path/to/access.log | awk '{ if ($11 != "\"-\"") { print $7 } }' | sort -u
/verifiera-googlebot
/phpmyadmin2/config/config.inc.php?p=phpinfo();
/randomqb
/wp-signup.php
...

Nackdelen med din webbservers loggar är att du ser alla brutna länkar, eller rättare sagt, alla sidor som någon försökt besöka och som inte hittats på webbservern. Detta inkluderar alla länkar som vissa program försöker hitta när de letar efter webb-applikationer med kända säkerhetshål.

Ovan ser du t.ex en länk till phpMyAdmin och en länk till WordPress registrerings-formulär, två länkar som jag vet är felaktiga eftersom jag varken använder PHP eller MySQL på denna blogg. Däremot ser jag en bruten länk som förmodligen ska gå till min artikel om hur du identifierar en Googlebot.

Omdirigera och ta vara på dom brutna länkarna

Eftersom dessa inlänkar är brutna så får du självklart ingen PageRank från dem. För att ta vara på dessa länkar så kan du enkelt omdirigera trafiken till den sidan som känns mest korrekt. Om du är osäker på vilken sida som är mest korrekt, så omdirigera trafiken till startsidan bara.

Nedan är ett exempel på hur du kan använda Apache's mod_rewrite modul för att omdirigera trafik. Om det CMS du använder klarar av att göra detta, så kan du självklart använda det istället.

# Rewrite URL-typos
RewriteEngine On
RewriteRule ^/randomgb http://www.ifconfig.se/ [R=301,L]
RewriteRule ^/verifiera-googlebot http://www.ifconfig.se/identifiera-googlebot [R=301,L]
...

Detta kommer skicka användaren (och Google) till den korrekta sidan och du får då några fler inlänkar till din webbplats och därmed lite mer PageRank. Du ska självklart inte omdirigera all trafik till sidor som inte finns, men om någon länkar till en sida som uppenbarligen inte finns, så kan det vara klokt att fixa detta.

Automatisera detta

Ett vanligt misstag när man länkar till andra sidor är att man missar en bokstav eller två av länken och därmed får en bruten länk av misstag. För att lösa detta har verktyg så som WordPress gjort så att man automatiskt söker efter en sida med liknande länk om du hamnar på en sida som inte finns.

Personligen gör jag precis samma sak på denna blogg, besöker du t.ex en halv adress så kommer du automatiskt skickas vidare till korrekt artikel om den hittas. Om den inte hittas så visas min vanliga 404-sida.

Hur hanterar du själv brutna inlänkar på din webbplats?

Överbelastningsattacker (del 1)

2010-12-15T23:22:00+01:00

Introduktion

Detta är den första delen i en artikelserie som kommer inrikta sig på överbelastningsattacker. Jag kommer gå igenom om hur du skyddar dig emot dessa och generell best practice när det gäller att konfigurera en brandvägg och filtrera trafik.

Den första artikeln kommer ta upp vilka typer av överbelastningsattacker som är vanligast, vad dessa attacker innehåller samt vilka svagheter dessa attacker utnyttjar.

Olika former av överbelastningsattacker

Ofta beskriver media alla former av överbelastningsattacker som DDoS-attacker, utan att dom egentligen vet vilken typ av attack det handlar om. De 3 vanligaste formerna av överbelastningsattacker är DoS, DDoS och DRDoS.

DoS – Denial of Service

En DoS-attack är när en angripare försöker göra en tjänst onåbar. Denna attack går oftast ut på att förbruka så mycket av offrets interna resurser som möjligt, så som minne och processorkraft. Eftersom en ensam angripare sällan har nog med bandbredd för att förbruka offrets bandbredd så försöker man istället utnyttja sårbarheter i mjukvara, konfiguration eller de protokoll som tjänsten använder.

DDoS – Distributed Denial of Service

DDoS eller Distributed Denial of Service som det betyder, är den typen av attack där flera datorer tillsammans angriper samma tjänst. Här är det vanligast att man försöker överbelasta nätverket och använda all tillgänglig bandbredd för att göra en tjänsten onåbar.

Den här typen av attacker sker oftast från vanliga hemma-datorer som infekterats med virus/trojaner för att skapa ett så kallat botnät. De individer som är seriösa med DDoS brukar även hacka diverse servrar, routrar och annan utrustning som ofta har tillgång till mängder med bandbredd, detta för att sedan använda dem i ett nätverk av DDoS-botar. Detta gör att en DDoS-attack är näst intill omöjligt att spåra.

DRDoS – Distributed Reflection Denial of Service

En DRDoS-attack är när en eller flera datorer utnyttjar en svaghet i en programvara eller ett protokoll för att förstärka effekten av en attack. Detta sker i kombination med att trafiken är spoofad så att det ser ut som att offrets dator är avsändaren.

Två protokoll som utnyttjats mycket för detta ändamål är SNMP och DNS, då de använder UDP utan att verifiera avsändaren innan de svarar. Detta tillåter en angripare att skicka massor med förfrågningar från offrets IP-adress varpå dessa tjänster svarar (oftast med betydligt mer trafik än förfrågan i sig) till offrets dator.

Vad innehåller en överbelastningsattack?

Metoderna ovan beskriver generellt hur en attack sker men inte vad en attack består av. Det finns flera olika typer av överbelastningsattacker, alla som tjänar sitt syfte bäst.

TCP eller SYN-flood

Den vanligaste typen av attack är en så kallad SYN-flood, där man skickar så många TCP-paket som möjligt med endast SYN-biten satt. Eftersom man inte är intresserad av svaret offrets dator skickar, så kan man utan problem spoofa trafiken från slumpmässigt valda IP-adresser. Detta får offrets system att allokera mängder med halv-öppna anslutningar som gör att vanlig trafik nekas då det inte finns några lediga resurser att hantera detta.

UDP eller ICMP flood

Denna attack används oftast med syfte att förbruka så mycket bandbredd som möjligt. Eftersom både UDP och ICMP är stateless och inte kräver någon anslutning innan data skickas, så är det enkelt att skicka väldigt stor mängd data. Vanligast är att man skickar ping-paket med hopp om att kunna förstärka attacken då offrets system svarar med ett pong-paket.

Smurf och Fraggle

Dessa två attacker utnyttjar broadcast-adressen genom att skicka ping-paket som ser ut att komma från offrets dator. Detta gör att övriga datorer på nätverket svarar med pong-paket. Dessa attacker fungerar sällan idag, då alla moderna system ignorerar ping till broadcast-adressen.

Teardrop, Ping of Death och Nuke

Teardrop utnyttjar en svaghet i TCP/IP-stacken på offret system. Teardrop innebär att man skickar fragmenterade paket som överlappar varandra, vilket äldre operativsystem inte klarade av att hantera utan krashade. Ping of Death och Nuke utnyttjade även de TCP/IP-stacken, då äldre operativsystem inte kunde hantera paket som var större än 64KB.

Avslut

Den andra delen i denna artikelserie kommer handla mer om hur du kan minska effekten av dessa attacker och hur du använder iptables för att konfigurera brandväggen i Linux.

Från YouTube till mp3

2010-12-13T08:09:00+01:00

Visst har vi alla fått ett YouTube-klipp länkat till oss med ruggigt bra musik som soundtrack. Helst skulle man vilja ha musiken som en fil för att kunna spela den i sin favoritspelare. Detta är självklart möjligt med lite hjälp av diverse verktyg.

För att först ladda hem filen från YouTube så kan du använda youtube-dl, vilket förmodligen finns tillgängligt via den pakethanterare din Linux-distribution erbjuder. Därefter använder vi oss utav FFmpeg för att hämta ut ljudspåret i filmen och spara om den som en mp3-fil.

youtube-dl http://www.youtube.com/watch?v=hKLpJtvzlEI
[youtube] Setting language
[youtube] hKLpJtvzlEI: Downloading video webpage
[youtube] hKLpJtvzlEI: Downloading video info webpage
[youtube] hKLpJtvzlEI: Extracting video information
[download] Destination: hKLpJtvzlEI.flv
[download] 100.0% of 7.79M at   34.77k/s ETA 00:00

ffmpeg -y -i hKLpJtvzlEI.flv -ab 128k 'Clint Mansell - Lux Aeterna.mp3' 2>/dev/null

Nu kan du spela mp3-filen i valfri mediaspelare. :-)

Identifiera en Googlebot

2010-12-12T12:55:00+01:00

Analysera User-Agent (fel sätt)

Av diverse olika anledningar vill man ibland skilja på riktiga besökare och robotar, så som Googlebot, Slurp och Bingbot. Det absolut vanligaste sättet är att man analyserar besökarens User-Agent-header och agerar olika beroende på om den innhåller t.ex Googlebot eller ej. Självklart ska man inte presentera olika innehåll för besökare eftersom man då riskerar att bli straffad för cloaking. Dock kan man ju agera olika internt, för saker som statistik eller liknande.

Skrämmande nog har jag dock sett ett flertal forum som även listar privata delar av webbplatsen för en besökare som har ordet Googlebot i sin User-Agent-header. Detta är inte rätt sätt att lösa det hela eftersom en besökare enkelt kan ändra sin User-Agent-header.

Analysera besökarens IP-adress (rätt sätt)

Googlebot ansluter alltid från en adress som slutar på *.googlebot.com. Denna adress pekar till en IP-adress som i sin tur pekar tillbaka till samma adress. Detta är värt att poängtera eftersom vem som helst som äger en IP-adress kan peka den till en googlebot.com-adress och låtsas vara en Googlebot.

Så för ta reda på om en besökare verkligen är en riktig Googlebot så börjar vi med att översätta IP-adressen till en host. Kontrollera att domänen för hosten är googlebot.com och därefter översätta hosten till en IP-adress igen, för att verifiera att det är samma IP-adress som besökaren ansluter ifrån. Här är en simpel PHP-funktion för just detta:

<?php

// is $ip really a Googlebot?
function is_googlebot($ip)
{
  // get the hostname
  $host = gethostbyaddr($ip);

  // if the hostname belongs to google, check for a reverse lookup.
  if (substr($host,-14) == '.googlebot.com' && gethostbyname($host) == $ip)
    return true;
  else
    return false;
}

?>

Yahoo! Slurp & Bingbot

Denna lösning fungerar även lika bra för Yahoo! Slurp och Bingbots robotar. Adresserna är uppbyggda på precis samma sätt och slutar på *.crawl.yahoo.net respektive *.search.msn.com. Notera dock att de har olika längd om du använder koden ovan.