Przydatne skrypty

[ubuproblem]

ubuntu.pl prezentuje:

dobry pomysł z wyłączaniem Compiza przed włączeniem gry
Można to też zastosowania do Wine, chociaż z drugiej strony, jak ktoś włączy mały programik przez Wine, to bez potrzeby będzie musiał czekać na restart Compiza

[mk_cafe]

Potrzebowalem czegos, co szybko przekonwertuje mp3 do slabszej jakosci, zeby zrzucic je potem na mp3 player, wiec zmienilem troche skrypt wrzucony wczesniej przez Rupka, zeby nie pytal sie o bitrate itd. tylko od razu konwertowal do ustalonej wartosci (aktualnie VBR 5, mono) i wrzucal plik z mozliwie taka sama nazwa do katalogu mp3conv na pulpicie, przywracajac tagi przy uzyciu id3ed.

#!/bin/bash
#Autor:  Rupek (male zmiany: mk_cafe)


############################### FUNKCJE #####################################################
jeden ()
{
    wej=`zenity --file-selection --title="Wybierz plik mp3 do konwersji"`

        if [ "$?" = 1 ] ; then
            exit 
        fi
    temp=`echo "$wej" | sed 's/ /_/g'`
    temp=`basename $temp`
    temp=`echo "$temp" | sed 's/_/ /g'`
    wyj="$HOME/Desktop/mp3conv/$temp"
    lame --mp3input -m m -V 5 "$wej" "$wyj" | zenity --progress --auto-close --text="Proszę czekać 
    Trwa konwersja plików"
    
    #przywracamy tagi
    artist=`id3ed -i "$wej" | grep artist | sed 's/artist: //'`
    songname=`id3ed -i "$wej" | grep songname | sed 's/songname: //'`
    album=`id3ed -i "$wej" | grep album | sed 's/album: //'`
    year=`id3ed -i "$wej" | grep year | sed 's/year: //'`
    comment=`id3ed -i "$wej" | grep comment | sed 's/comment: //'`
    tracknum=`id3ed -i "$wej" | grep tracknum | sed 's/tracknum: //'`
    genre=`id3ed -i "$wej" | grep genre | sed 's/genre: //'`    
    genre=`echo "$genre" | sed 's/(.*)//'` #wywalamy nawias z numerem gatunku

    id3ed -s "$songname" -n "$artist" -a "$album" -y "$year" -c "$comment" -k "$tracknum" -g "$genre" -q "$wyj"    

    zenity --info --text="Konwersja zakończona pomyślnie."
}

wszystkie ()
{
    dir=`zenity --file-selection --directory --title="Wybierz folder z mp3 do konwersji"`

    for i in "$dir/"*.mp3
        do    temp=`echo "$i" | sed 's/ /_/g'`
            temp=`basename $temp`
            temp=`echo "$temp" | sed 's/_/ /g'` 
            wyj="$HOME/Desktop/mp3conv/$temp"
            lame --mp3input -m m -V 5 "$i" "$wyj"

            artist=`id3ed -i "$i" | grep artist | sed 's/artist: //'`
            songname=`id3ed -i "$i" | grep songname | sed 's/songname: //'`
            album=`id3ed -i "$i" | grep album | sed 's/album: //'`
            year=`id3ed -i "$i" | grep year | sed 's/year: //'`
            comment=`id3ed -i "$i" | grep comment | sed 's/comment: //'`
            tracknum=`id3ed -i "$i" | grep tracknum | sed 's/tracknum: //'`
            genre=`id3ed -i "$i" | grep genre | sed 's/genre: //'`    
            genre=`echo "$genre" | sed 's/(.*)//'`
            
            id3ed -s "$songname" -n "$artist" -a "$album" -y "$year" -c "$comment" -k "$tracknum" -g "$genre" -q "$wyj"    

    done | zenity --progress --auto-close --text="Proszę czekać 
    Trwa konwersja plików"
    
    zenity --info --text="Konwersja zakończona pomyślnie."
}

############################################################################################

##################################### OKNO GŁÓWNE #########################################
if [ -x /usr/bin/lame ]
    then
        zenity --info --text="Program wykorzystuje do konwersji program Lame "
else
    zenity --error --text="Nie masz zainstalowanego programu Lame
Użyj programu synaptic, apt-get lub innego menagera plików do jego zainstalowania"
exit
fi

wybor=`zenity --list --title "Wybór rodzaju konwersji" --text "Poniżej masz listę dostępnych
rodzajów konwersji" --radiolist --column "" --column "Dostępny bitrate" FALSE "Pojedyńczy plik mp3" FALSE "Wszystkie pliki mp3 w folderze" TRUE "Zakończ działanie programu"`

mkdir ~/Desktop/mp3conv #tworzy katalog, w ktorym znajda sie skompresowane pliki

case "$wybor" in
    "Pojedyńczy plik mp3")                        jeden       ;;
    "Wszystkie pliki mp3 w folderze")                wszystkie ;;
    "Zakończ działanie programu")                    exit      ;;
    *) zenity --error --text "Nic nie wybrałeś. Spróbuj ponownie"
esac

Pozdr.

[ubuproblem]

Ja zrobiłem skrypcik do szybkiego montowania ISO:

#!/bin/bash

cd ~
if [ -e ./ISO ]
then
	echo -n
else
	mkdir ./ISO
fi

sciezka="`pwd`/ISO"

if [ -e "$1" ]
then
	echo "#!/bin/sh
mount -o loop \"$1\" \"$sciezka\"" > tmp
	gksu sh tmp
	rm tmp
else
	plik=`zenity --title "Wybierz plik do zamontowania." --file-selection`
	echo "#!/bin/sh
mount -o loop \"$plik\" \"$sciezka\"" > tmp
	gksudo sh tmp
	rm tmp
fi

Użycie:
stworzyć plik giso, najlepiej w folderze domowym
nadać mu prawa do wykonywalności:

chmod +x giso

skopiować plik do /usr/bin

cp ./giso /usr/bin/giso

W nautilusie kliknąć prawym na obraz ISO, wybrać otwórz za pomocą...innej aplikacji rozwinąć wpisz własne, wpisać giso dać ok i już.
Później dwuklik na obraz spowoduje od razu zamontowanie obrazu (oczywiście pojawi się jeszcze proźba o podanie hasła). Można też wpisać poprostu giso w terminalu. Wtedy pojawi się okno wyboru pliku do zamontowania.

Piszcie, jak się komuś przyda, to zrobię też dla KDE

[tydell]

a czy mógłby ktoś zamieścić raz jeszcze skrypt z radiami internetowymi (ostatnią wersję) gdyż link autora jest nie działający

[ubuproblem]

Napisałem jeszcze jedną ciekawostkę, tutaj, bardziej przydatne.
Skrypt odlicz czas i po odliczeniu wykonuje czynność, którą sobie zażyczymy. W menu głównym programu wszystko można sobie ustawić

#!/bin/bash

clear

echo "Witaj w tekstowym wyłączniku."
echo "Wprowadź liczbę minut do odliczenia."
echo -n "> "
read ileminut

ilesekund=$[$ileminut*60]

echo "Odliczanie będzie trwało $ilesekund sekund."

function list
{
	case "$1" in
	a)
		clear
		echo "1) Czas: $ilesekund sek. ($ileminut min.) - zmień."
		echo "2) Po zakończeniu: $pozak"
		echo "3) Rozpocznij odliczanie."
		echo "4) Zakończ"
		
		echo -n "> "
		read menu
		case "$menu" in
		1)
			echo
			echo "Wprowadź nowy czas"
			echo -n
			read ileminut
			ilesekund=$[$ileminut*60]
			list a
			;;
		2)
			list b
			list a
			;;
		3)
			dodaj
			list a
			;;
		4)
			clear
			exit 0
			;;
		*)
			clear
			echo "Błędny wybór..."
			sleep 2
			list a
		esac
		;;
	b)
		echo "1) Wyłącz komputer"
		echo "2) Uruchom ponownie"
		echo "3) Wykonaj polecenie"
		echo
		echo -n "> "
		echo
		read poz
		case "$poz" in
		1)
			pozak1="shutdown -h now"
			pozak="Wyłączenie komputera"
			;;
		2)
			pozak1="shutdown -r now"
			pozak="Ponowne uruchomienie komputera"
			;;
		3)	
			echo "Wprowadź dowolne polecenie systemowe."
			echo -n "> "
			read pozak1
			pozak="Polecenie systemowe: $pozak1"
			;;
		esac
		;;
	esac
}

function pokaz
{
	clear
	echo "Pozostało odliczania: $ilesekteraz sek. / $ilesekund sek. ($ileminut min.)"
	dodaj
}

function dodaj
{
	if [ "$ilesekteraz" = "$ilesekund" ]
	then
		$pozak1
	else
		if [ "$juz" = "tak" ]
		then
			sleep 1
			ilesekteraz1=$[$ilesekteraz+1]
			ilesekteraz=$ilesekteraz1
			pokaz
		else
			juz=tak
			pokaz
		fi
	fi
}

list a

[youlleck]

skrypt playlog.sh logujacy do pliku playlog.txt utwory odtwarzane w mocpie (odpalam go w conkym co 5s)

z=`mocp --info | grep File:`
z=${z#File:\ }

sleep 5

y=`mocp --info | grep File:`
y=${y#File:\ }

if [ "$z" != "$y" ]; then
echo "`date +'%D %T'` $y" >> playlog.txt
fi

[Procek]

msgat - skrypt do wysyłania powiadomień o określonym czasie lub za określony odstęp czasu. Wymaga zainstalowanej biblioteki libnotify (sudo apt-get install libnotify). Powiadomienia są ważne tylko na czas trwania bieżącej sesji.

Powiadomienia w środowisku Gnome wyglądają tak:

a wysyłać można je na kilka sposobów, np. dwa różne polecenia:

msgat 2h55m bardzo ważna wiadomość
msgat 3h-5m "bardzo ważna wiadomość"

dadzą taki sam efekt, wyświetlą chmurkę w narożniku ekranu za 2 godziny i 55 minut (lub inaczej 3 godziny odjąć 5 minut). Rozpoznawane jednostki czasu to: w d h m - week, day, hour, minute.

Można również określić czas wprost, np. te dwa polecenia:

msgat 20:45 31.07.08 'treść wiadomości'
msgat 2008-07-31 20:45 treść wiadomości

również dają ten sam efekt. W przypadku pominięcia jednego z parametrów daty lub czasu, przyjmowana jest aktualna data lub godzina.

#!/bin/bash
#program: msgat v0.2
#author: Tomek Bekas
#email: procek <at> <no spam> gmail.com
#licence: GPL v3.0
#notes: the program sends a message to the user at a specific time or a 
#specified interval of time, uses the program at and the library libnotify;
#notifications are active only during the current session;
#all error messages are routed from stderr to /dev/null, because almost 
#all of them are warning messages sent to stderr even if everything works 
#well, but if you want to review them, change the contents of ERRLOG variable
#usage examples:
#msgat 2009-01-31 20:45 content  #these two different commands will give
#msgat 20:45 31.01.09 content    #the same effect
#msgat 1w2d23h30m part1 part2    #and these two also give the same effect
#msgat 1w3d-30m "part1 part2"    #

TFS=':' #time field separator, default is colon
DFS='.-' #date field separator, default is dot and dash
NFS='0123456789-' #numeric field separator, default is all digits and minus
DIFS="$IFS"

BU="minute" #basic unit, default is minute
TU=(w d h m) #time units, default is w d h m (weeks, days, hours, minutes)
UV=(7 24 60 1) #relative unit values

TIFS=$(echo ${TU[*]} | tr -d "${IFS:0:1}") #time interval field separator, default is 'wdhm'
ERRLOG="/dev/null" #error log file, default /dev/null :)

#set -x

function exitSuccess {  
  echo -en "message: $@\nwill be sent at: "
  if [ "$interval" ] ; then
    date -d"+$interval $BU" +"%a %d %b, %R"
  else
    date -d"$date $time" +"%a %d %b, %R"
  fi
  
  exit 0
}

function exitUsage {
  echo -e "usage: \n$0 [time] [date] <message>\n$0 [interval] <message>"
  exit 1
}

function checkLibnotify {
  if [ ! -x /usr/bin/notify-send ] ; then
    echo "you need to have libnotify installed to run this script"
    exit 1
  fi
}

function absUnitValue 
(
  result=1
  for (( i=$[ ${#UV[*]} - 1 ] ; i >= 0 ; i-- )) ; do
    result=$[ $result * ${UV[i]} ]
    [ "$1" = "${TU[i]}" ] && { echo $result ; exit 0 ; }
  done
  echo 0 #if unit not found in array
  exit 1
)

function getTime
(
  arg=$1
  IFS=$TFS
  set $1
  IFS=$DIFS
  [ $# -ne 2 ] && exit 1
  arg=`date -d"${1}:${2}" +%R` || exit 1 #generates errors to stderr
  echo $arg
  exit 0
)

function getDate
(
  arg=$1
  IFS=$DFS
  set $1
  IFS=$DIFS
  [ $# -ne 3 ] && exit 1
  arg=`date -d"${3}-${2}-${1}" +%F` || #generates errors to stderr
  arg=`date -d"${1}-${2}-${3}" +%F` || exit 1 #generates errors to stderr
  echo $arg
  exit 0
)

function getInterval
(
  arg=$1
  IFS=$NFS
  set $arg
  units=$@ #units used in arg
  IFS=$TIFS
  set $arg
  IFS=$DIFS
  
  for i in $units ; do
    sum=$[ $sum + $1 * $(absUnitValue $i) ] || exit 1 #generates errors to stderr
    shift
  done 
  echo $sum
  exit 0
)

function sendMsg
(
  if [ "$interval" ] ; then
    #generates errors to stderr
    at "now + $interval $BU" << EOT
    notify-send -t 0 "$@"
EOT
    (( $? )) && exit 1
  else
    #generates errors to stderr
    #at "${time:=$(date +%R)} ${date:=$(date +%F)}" << EOT
    at "$time $date" << EOT
    notify-send -t 0 "$@"
EOT
    (( $? )) && exit 1
  fi
  exit 0
)

function main {
  checkLibnotify
  [ $# -lt 2 ] && exitUsage #requires at least two arguments
  date=''
  time=''
  interval=''
  for i ; do
    #if interval and date and time are empty
    if [ -z "$interval" -a -z "$date" -a -z "$time" ] ; then
      interval=`getInterval $1` || #the only proper order is interval, time, date
      time=`getTime $1` ||
      date=`getDate $1` || exitUsage
      shift
    #if only date and interval are empty (time has some value)
    elif [ -z "$date" -a -z "$interval" ] ; then
      date=`getDate $1` && shift || date=`date +%F`
      sendMsg $@ && exitSuccess $@ || exitUsage
    #if only time and interval are empty (date has some value)
    elif [ -z "$time" -a -z "$interval" ] ; then
      time=`getTime $1` && shift || time=`date +%R`
      sendMsg $@ && exitSuccess $@ || exitUsage
    #if only time and date are empty (interval has some value)
    else #equal to: if [ -z "$time" -a -z "$date" ] ; then
      sendMsg $@ && exitSuccess $@ || exitUsage
    fi
  done
}

main $@  2> $ERRLOG #stderr > /dev/null

[dawidgarus]

zmiana fps napisów.

changefps:

#!/usr/bin/php5
<?php

if (!($f = $_SERVER['argv'][1])) $f = 23.976;
if (!($t = $_SERVER['argv'][2])) $t = 25;

$fp = fopen("php://stdin", "r") or die("can't read stdin");
while (!feof($fp)) {
        $line = fgets($fp);
        preg_match_all('/\{([0-9]+)\}/', $line, $matches);
        for ($i=0; $i<2; $i++) {
                $line = str_replace($matches[0][$i], '{'.floor($matches[1][$i]*$f/$t).'}', $line);
        }
        echo $line;
}

?>

użycie:

changefps [początkowy fps] [fps po zmianie] < przed.txt > po.txt

gchangefps (graficzna nakładka, używająca zenity):

#!/bin/bash
f=`zenity --scale --value 24 --min-value 10 --max-value 30 --text "Subtitle FPS"`
t=`zenity --scale --value 25 --min-value 10 --max-value 30 --text "Movie FPS"`
changefps $f $t < "$1" > "$1.new"
mv "$1.new" "$1"

użycie:

gchangefps <ścieżka do pliku z napisami>

[xc1256]

Hasła - generowanie.
Dla tych co muszą zmieniać hasła np. co tydzień ( tak sobie ustawiłem w całej sieci) aby się nie męczyć prostą komendą, napisałem takie proste

#!/usr/bin/perl -w
system "clear";
use Term::ANSIColor;
print color("blue"),"Hmm wymyślę hasła ..:)\n", color("reset");
print color("green"),"Podaj długość hasła (cyfrą) ",color("reset");
$li = <STDIN>;
if ($li lt "1")
{ print color("red"),"nic nie wprowadzono...!,kończe program\n", color("reset");exit}
print color("green"),"Podaj ilość haseł (cyfrą) ",color("reset");
$powt =<STDIN>;
if ($powt lt "1")
{ print color("red"),"brak wszystkich danych...!, kończe program.\n",color("reset");exit}
print "Ok, rozpoczynam generowanie haseł\n";
$ile = $powt;
for (1 ..$powt)
{
{ @lines = `pwgen -s -y $li`;print color("white"),"hasło..     ",color("reset");}foreach (@lines)
{print;}
}

przy podaniu długości hasła np 20-znaków mamy już niezłą mieszankę

[lukskrodz]

Mój skrypt do aktualizacji danych w DynDNS.org:
http://www.howto.yoyo.pl/?p=27

[anemus]

Dla użytkowników gnome prościutki ale użyteczny skrypt do ~/.gnome2/nautilus-scripts, znaczy do menu kontekstowego umożliwiający szybkie edytowanie różnych plików bez przebijanie się przez uruchom za pomocą innej aplikacji gdy nie jest to plik rozpoznawany jako tekstowy, nawet gdy potrzeba uprawnień roota:

#!/bin/bash
in_file=$1
if [ -w $in_file ]
  then
    if [ -f $in_file ]
      then
        gedit $in_file
    else
        gedit 
    fi
  else
    if [ -f $in_file ]
      then
        gksu gedit $in_file
      else
        gksu gedit 
    fi
fi

Takie małe coś dla klikaczy lubiących psuć swój system

[Cyryllo]

haha fajne skrypty niektóre

[daris]

Skrypt pokazujący zużycie transferu (prędkość) przez aktualnie uruchomione aplikacje/usługi itp

#!/bin/bash
max_chars=100 # maksymalna liczba znaków na konsoli (dlugosc paska wykresu)
max_down_speed=65536 # maksymalna prędkość pobierania w bajtach (tutaj 65536 B = 64 KB = 512Mb)

function get_speed()
{
	speed=`cat /proc/net/dev | grep eth0`
	if [ "$1" == 'up' ]; then
		speed=`echo $speed | awk '{print $9}'`
		last=$last_upl
		last_upl=$speed
	else
		speed=`echo $speed | awk '{print $1}' | awk -F":" '{print $2}'`
		last=$last_down
		last_down=$speed
	fi
	speed=$[ $speed - $last ]
}

function kb()
{
	bytes=$[$1 * 100 / 1024]
	val=`echo $bytes | sed 's/\([[:digit:]]*\)\([[:digit:]]\{2\}\)/\1.\2/g'`
	if [ `echo $val | wc -m` == 4 ]; then
		val="0$val"
	elif [ `echo $val | wc -m` == 3 ]; then
		val="0.$val"
	elif [ `echo $val | wc -m` == 2 ]; then
		val="0.0$val"
	fi
}

function wykres()
{
	perc=$[$1 * 100 / $max_down_speed]
	print_chars=$[$perc/ (100 / $max_chars)]
	str='['
	for s in `seq 0 $max_chars`
	do
		if [ $s -lt $print_chars ]; then
			str+='#'
		else
			str+='-'
		fi
	done
	str+=']'
}

last_upl=`cat /proc/net/dev | grep eth0 | awk '{print $9}'`
last_down=`cat /proc/net/dev | grep eth0 | awk '{print $1}' | awk -F":" '{print $2}'`
sleep 1
echo -e "\n"
i=1

while [ true ]
do
	get_speed 'up'
	kb $speed
	upl_speed=$val
	
	get_speed 'down'
	wykres $speed
	wykres=$str
	down_sum=$[$down_sum + $speed]
	kb $speed
	down_speed=$val
	
	down_avg=$[$down_sum/$i]
	kb $down_avg
	down_avg=$val
	
	echo -e "\e[2A$wykres"
	echo -e "Download: $down_speed KB/s\e[K\tUpload: $upl_speed KB/s\e[K\tDownload Avg: $down_avg KB/s"
	i=$[$i+1]
	sleep 1
done

A tak to wygląda

darek:~/skrypty/netstat$ ./netstat
[########---------------------------------------------------------------------------------------------]
Download: 5.55 KB/s     Upload: 0.77 KB/s       Download Avg: 5.24 KB/s

(skopiowane stąd)

[outslider]

Dość często korzystam ze słowników pol-ang i ang-pol w Sieci i szczególnie upodobałem sobie angool.com. Nie chce mi się jednak za każdym razem otwierać nowej karty albo szukać już otwartej, do tego jeszcze na stronie źle działa wpisywanie polskich znaków, dlatego też napisałem skrypcik, który wywołany z poszukiwanym słowem łączy się ze stroną i wyświetla wyniki. Skrypt:

#!/bin/bash

word=""
au=`echo "ą"|head -c2|tail -c1`
ci=`echo "ć"|head -c2|tail -c1`
eu=`echo "ę"|head -c2|tail -c1`
wo=`echo "ł"|head -c2|tail -c1`
ni=`echo "ń"|head -c2|tail -c1`
oo=`echo "ó"|head -c2|tail -c1`
si=`echo "ś"|head -c2|tail -c1`
zi=`echo "ź"|head -c2|tail -c1`
rz=`echo "ż"|head -c2|tail -c1`

if [ "$1" = "" ]; then
  echo "Nie podales zadnego slowa"
  echo "Skladnia: platon <slowo>"
  exit 1
fi

echo "Platon 0.1, szukanie: $1"

letters=`echo $1|wc -c` #ilosc bajtow slowa

Li=1
until [ "$Li" = "$letters" ]; do
  sign[$Li]=`echo $1|head -c$Li|tail -c1`
  Li=$[$Li+1]
done

Li=1; mod=0; hol=$letters
until [ "$Li" = "$letters" ]; do


  case "${sign[$Li]}" in
      "$au") mod=$[$mod+1]
             sign[$Li]="a"
             urllet[$Li]="%B1"
             hol=$[$hol-1];;
      "$ci") mod=$[$mod+1]
             sign[$Li]="c"
             urllet[$Li]="%E6"
             hol=$[$hol-1];;
      "$eu") mod=$[$mod+1]
             sign[$Li]="e"
             urllet[$Li]="%EA"
             hol=$[$hol-1];;
      "$wo") mod=$[$mod+1]
             sign[$Li]="l"
             urllet[$Li]="%B3"
             hol=$[$hol-1];;
      "$ni") mod=$[$mod+1]
             sign[$Li]="n"
             urllet[$Li]="%F1"
             hol=$[$hol-1];;
      "$oo") mod=$[$mod+1]
             sign[$Li]="o"
             urllet[$Li]="%F3"
             hol=$[$hol-1];;
      "$si") mod=$[$mod+1]
             sign[$Li]="s"
             urllet[$Li]="%B6"
             hol=$[$hol-1];;
      "$zi") mod=$[$mod+1]
             sign[$Li]="z"
             urllet[$Li]="%BC"
             hol=$[$hol-1];;
      "$rz") mod=$[$mod+1]
             sign[$Li]="z"
             urllet[$Li]="%BF"
             hol=$[$hol-1];;
          *) urllet[$Li]="${sign[$Li]}";;
  esac
  pos=$[$Li-$mod]
  letter[$pos]="${sign[$Li]}"
  urllet[$pos]="${urllet[$Li]}"
  Li=$[$Li+1]
done

Li=1
until [ "$Li" = "$hol" ]; do
  word+=${letter[Li]}
  urlend+=${urllet[$Li]}
  Li=$[$Li+1]
done

echo "Laczenie z http://angool.com/search/index.php?query=$urlend"
echo
echo "------------"
links -dump http://angool.com/search/index.php?query=$urlend|grep $word
echo "------------"

exit 0

#Platon 0.1 - Pawel Tokarz, 2008

Lwia część, jak widać, dotyczy polskich znaków. Działa w miarę, trzeba jeszcze dopracować parę rzeczy, ale na szybko starczy.

[qbsiu]

Rapidshare + ADSL Pentagram Cerberus, czyli jak pobierać linki, iść na piwo - w trakcie pobierania resetuje się neo więc nie czekamy 15 minut, tylko 2-3 minuty.
Skrypcik znaleziony na necie, jest główny autor i pomysłodawca tego, jednak coś mi się w nim nie podobało, więc to przebudowałem i dodałem funkcję do resetowania neo. Od razu mówię, że skrypt przerabiałem pod KDE.

#!/bin/bash
#
# Autor: Piotr Jachacy <jachacy@gmail.com>
# Modyfikował: Łukasz Kubsz <qbsiu@o2.pl>
#
# ostatnia modyfikacja: 28.12.2008
#
# /* This program is free software. It comes without any warranty, to
# * the extent permitted by applicable law. You can redistribute it
# * and/or modify it under the terms of the Do What The Fuck You Want
# * To Public License, Version 2, as published by Sam Hocevar. See
# * http://sam.zoy.org/wtfpl/COPYING for more details. */ 
#
# kolorki
clear
red="\e[1;31m"
zaden="\033[0m"
green="\e[1;92m"
white="\e[1;37m"

liczba=0


function restart
{

GATEIP="192.168.0.1"
LINK="http://$GATEIP/doc/index.htm?WINDWEB_URL=/doc/adsltop.htm&ADSL_Action=0"
USER="admin"
PASS="haselko_nasze"
wget --quiet --http-user=$USER --http-password=$PASS ${LINK} -O /tmp/wget_router
rm -f /tmp/wget_router
rm -rf .ip
mkdir .ip
cd .ip
while [ 1 ]; do
ip=`wget --quiet http://checkip.dyndns.org/index.html && cat index.html | cut -d ' ' -f 6 | cut -d '<' -f 1`
sleep 1
if [ -n "$ip" ]; then
        break
fi
done
cd ..
rm -rf .ip
}
function odliczanie
{
	x=$1
	while [ $x -ge 1 ]; do
		printf "\r%-5s" $x"s"
		x=$[x -1]
		sleep "1"
	done
	printf "\r%-5s" ""
}
function pobierz
{
	link=$1
	sciezka=$2

	link=$(wget "$link" -q -O - | grep 'form id="ff"' | sed -e 's/.*action="\(.*\)"\s.*/\1/')

	if [ -n "$link" ]; then
		link=$(wget --post-data "dl.start=Free" $link -q -O -)


		if [  -n "$(echo "$link" | grep "Please wait until the download is completed")" ]; then
			echo -e ''$red'Sciągasz inne pliki!'$zaden''
			exit
		elif [  -n "$(echo "$link" | grep "You have reached the download limit for free-users. Would you like more?")" ]; then
			echo -e ''$green'Trwa resetowanie Twojego rutera'$zaden''
			restart
			pobierz $1 $sciezka
		else
			czas=$(echo "$link" | grep "var c" | sed -e "s/var c=\([0-9]*\);.*/\1/")
			echo -e ''$green'Trwa odliczanie'$zaden''
			odliczanie $czas
			echo -e ''
			echo -e ''$red'----------------------------------------------------------'$zaden''
			echo -e ''$red''$liczba'/'$ilosc''$green' Trwa pobieranie: '$1''$zaden''
			link=$(echo "$link" | grep 'form name="dlf"'| sed -e 's/.*action="\(.*\)"\s.*/\1/')
			wget --post-data "mirror=on" "$link" -P "$sciezka"
			if [ "$?" == "0" ]; then
				kdialog --passivepopup "Pobrano $link"
			else
				kdialog --passivepopup "Nie udało się pobrać pliku: $link"
				
			fi
			echo -e ''$red'----------------------------------------------------------'$zaden''
		fi	
					
	else
		echo -e ''$red'Nie udało się pobrać pliku: '$green''$1''$zaden''
	fi
}

sciezka_zapisu=`kdialog --getexistingdirectory /`
typ=`kdialog --radiolist "Wybierz typ:" 1 "Wprowadź listę" on 2 "Wprowadź linki ręcznie" off`

if [ $typ == "1" ]; then
sciezka=`kdialog --getopenfilename ~`
	ilosc=`cat $sciezka |grep -E -v "^#|^$" | wc -l`
	for x in $(cat $sciezka)
	do
		if [ -n "$x" ]; then
			liczba=$(($liczba+1))
			pobierz "$x" "$sciezka_zapisu"
		fi
	done
elif [ $typ == "2" ]; then
	touch ~/tmp.rapid
	kdialog --textinputbox 'Podaj linki, <b>każdy link w osobnej linijce</b>' > ~/tmp.rapid
	ilosc=`cat ~/tmp.rapid | grep -E -v "^#|^$" | wc -l`
	for x in $(cat ~/tmp.rapid)
	do
		if [ -n "$x" ]; then
			liczba=$(($liczba+1))
			pobierz "$x" "$sciezka_zapisu"
		fi
	done
rm ~/tmp.rapid
fi

Oryginał: >>pobierz<<
Mój skrypt ma dużo błędów, w najbliższym czasie się pobawię.
Więcej moich skryptów znajdziesz tu: http://qbsiu.palarnia.org/Skrypty/

[RYNIEK]

Skrypt do pobierania informacji o ilości nowych wiadomości ze skrzynki WP.PL
[link]

W przypadku gdy link wygaśnie, zamieszczam poniżej archiwum.

Skrypt dodajemy do configa Conky np. tak:

${font}${color}${color burlywood}${font :size=10}Poczta@WP.PL: ${font :size=9}${execi 60 ~/Skrypty/pocztawp.py}${color burlywood}

a uruchamiamy tak:

python /home/user/Skrypty/pocztawppl.py

Nie wolno jednocześnie sprawdzać skryptem ilości nowych wiadomości oraz odczytywać za pomocą klienta e-mail, gdyż otrzymamy wyjątek. Do tego samego konta skrzynki wp.pl nie mogą mieć dostępu dwa programy/dwie osoby na raz. W GMailu nie ma takich problemów gdyż jest Atom.

[cichy_]

Tłumaczenie pol-ang

links -dump http://megaslownik.pl/slownik/polsko_angielski/$1 | grep "\[IMG\]>>" | sed -e 's/\[IMG\]//'

Tłumaczenie ang-pol

links -dump http://megaslownik.pl/slownik/angielsko_polski/$1 | grep "   >> "

[Adawo]

Skrypt pobierający angielskie słówko i idiom dnia z serwisu ang.pl

#!/bin/bash

#Skrypt pobierający słówko i idiom dnia z serwisu ang.pl
#stworzone przez SCT/Adawo <adawo.roag@gmail.com>
#na licencji GPL 

#Pobieramy slowko dnia...
wget "http://www.ang.pl/slowko_dnia.php?today=1&print=1" -q -O /tmp/slowko_dnia
#usuwamy tagi html | kodowanie z iso-8859-1 na iso-8859-2 | 
html2text -nobs /tmp/slowko_dnia | iconv -f iso-8859-2 | sed -e "s/\ \{2\,\}//g; s/\\[img[a-zA-Z0-9 ./\n:]*\]//g; s/\\[http[a-zA-Z0-9 ./\n:]*\]//g; s/\\[Unknow[a-zA-Z0-9 ./\n:]*\]//g;" > /tmp/slowko_tmp


#SŁÓWKO DNIA
word=$(echo `cat /tmp/slowko_tmp | head -n 22 | tail -n 1 | sed -e "s/\[[a-zA-Z\/]*//g"`) #Slowko dnia

def_start=$(echo `cat /tmp/slowko_tmp | grep -e "[ \t]*DEFIN*" -b | head -c 3`)
def_end=$(echo `cat /tmp/slowko_tmp | grep -e "[ \t]*EXAMPLE\:" -b | head -c 3`)
word_definiction=$(echo `cat /tmp/slowko_tmp | tr "\n" "  " | cut -b "$def_start-$def_end" | sed -e "s/DEFINITION: //g"`)

#wycinamy przykład
exa_end=$(echo `cat /tmp/slowko_tmp | grep -e "[ \t]*POLISH TRANS" -b | head -c 3`)
exa_start=$(echo `cat /tmp/slowko_tmp | grep -e "[ \t]*EXAMPLE\:" -b | head -c 3`)
word_example=$(echo `cat /tmp/slowko_tmp | tr "\n" "  " | cut -b "$exa_start-$exa_end" | sed -e "s/EXAMPLE: //g"`) 

#translacja
word_translation=$(echo `cat /tmp/slowko_tmp | grep -e "[ \t]*POLISH TRANSLATION: " | head -n 1 | sed -e "s/POLISH TRANSLATION: //g"`)

#IDIOM DNIA:
idiom_start=$(echo `cat /tmp/slowko_tmp | grep -e "IDIOM OF THE DAY" -n | head -c 2`) 
idiom=$(echo `cat /tmp/slowko_tmp | head -n $(expr $idiom_start + 2) | tail -n 1`)

exa_start=$(echo `cat /tmp/slowko_tmp | grep -e "[ \t]*EXAMPLE\:" -b | tail -n 1 | head -c 3`)
exa_end=$(echo `cat /tmp/slowko_tmp | grep -e "[ \t]*POLISH TRANS" -b | tail -n 1 | head -c 3`)
idiom_example=$(echo `cat /tmp/slowko_tmp | tr "\n" "  " | cut -b "$exa_start-$exa_end" | sed -e "s/EXAMPLE: //g"`) 

idiom_translation=$(echo `cat /tmp/slowko_tmp | grep -e "[ \t]*POLISH TRANSLATION: " | tail -n 1 | sed -e "s/POLISH TRANSLATION: //g"`)

#WYPISUJEMY:
echo -e "\033[0;31mSŁÓWKO DNIA:\033[0m $word"
echo -e "\033[0;31mDEFINICJA:\033[0m $word_definiction"
echo -e "\033[0;31mPRZYKŁAD:\033[0m $word_example"
echo -e "\033[0;31mTRANSLACJA:\033[0m $word_translation"
echo 
echo -e "\033[0;31mIDIOM:\033[0m $idiom"
echo -e "\033[0;31mPRZYKŁAD:\033[0m $idiom_example"
echo -e "\033[0;31mTRANSLACJA:\033[0m $idiom_translation"

#Sprzatamy po sobie śmeci...
rm /tmp/slowko_dnia /tmp/slowko_tmp

PS. Byłbym wdzięczny za uwagi w stosunku do kodu, bash nie jest moją mocą stroną...

[igotit4free]

Skrypt przydatny do konfiguracji Conky w sposób niezależny od nazwy wyświetlanej w punkcie montowania /media/NAZWA_USB.
W podanej formie odczytuje wartość z drugiej linii drugiej kolumny pliku:

domek@domek-desktop:~$ df -H /dev/sdb1
System plików             rozm.  użyte dost.  %uż. zamont. na
/dev/sdb1              2,1G   337M   1,8G  17% /media/PENNY

Skrypt:

    #!/bin/bash

    echo "$(df -H /dev/sdb1 | awk '{if(NR == 2){print $2}}')"

Manipulacja parametrem {print $X} pozwala na odczytanie pozostałych wartości.

Po utworzeniu skryptu o nazwie "NAZWA_XXX" w moim przypadku w katalogu domowym "conky" trzeba nadać prawa do wykonywania jako program:

cd conky && chmod a+x NAZWA_XXX

i odpalać w Conkym poleceniem:

${execi 3 ~/conky/NAZWA_XXX}

[witek23]

Nakładka na kompilator (c/c++).

Mój debiut w bash'u

#!/bin/bash

clear
echo -e "\t\t\t\t  ABC++ v0.1\n\n"
	if [ -d ~/abc++ ]
	then
	echo -e "Katalog abc++ istnieje\n"
	else
	mkdir ~/abc++/
	echo -e "Utworzono katalog 'abc++' w folderze domowym\n"
	fi
cd ~/abc++/
	if [ -e ~/abc++/conf.txt ]
	then
	d=`cat conf.txt| head -1`
	e=`cat conf.txt| head -2| tail -1`
	u=`cat conf.txt| tail -1`
	else
	d=$PWD
	e="cpp"
	u="c++"
	fi
cd $d
c=1
while [ $c==1 ]
do
echo -e "Kody zrodlowe musza byc umieszczone w tym folderze: $d\n"
echo -e "Domyslne rozszerzenie to: $e\n"
echo -e "Wlaczony kompilator to: $u\n--------------------------------------------------------------------------------"
echo -e "\n\t\t\t    1 - kompiluj nowy plk"
echo -e "\t\t\t    2 - kompiluj ponownie"
echo -e "\t\t\t    3 - edytuj kod źródłowy"
echo -e "\t\t\t    4 - ustawienia"
echo -e "\t\t\t    5 - wyjdz"
read b
  case $b in
    "1")echo -e "Podaj nazwę pliku do kompilacji:\n"
	read a
	clear
	if [ -e $d/$a.$e ]
	then
	$u $a.$e -Wall -o $a.o 2> $a.txt
		if [ -e $d/$a.txt ]
		then
 		mv  $d/$a.txt ~/abc++/logi
		fi
	export $a
	xterm -e "./$a.o; bash" 
	gedit $a.cpp
	else
	echo -e "\a   Plik o podanej nazwie nie istnieje, sprawdz rozszerzenia, oraz sciezke\n\t\tdo katalogu z kodami zrodlowymi - sprawdz ustawienia\n\n"
	fi;;
   "2") clear
	if [ -e $d/$a.$e ]
	then
	$u $a.$e -Wall -o $a.o 2>> $a.txt
		if [ -e $d/$a.txt ]
		then
 		mv  $d/$a.txt ~/abc++/logi
		fi
	export $a
	xterm -e "./$a.o; bash" 
	gedit $a.cpp;
	else
	echo -e "\a   Plik o podanej nazwie nie istnieje, sprawdz rozszerzenia, oraz sciezke\n\t\tdo katalogu z kodami zrodlowymi - sprawdz ustawienia\n\n"
	fi;;
   "3") gedit $a.cpp;;
   "4") clear
	echo 'Aktualne ustawienia:'
	echo -e "\nKody zrodlowe musza byc umieszczone w tym folderze: $d\n"
	echo -e "Domyslne rozszerzenie to: $e\n"
	echo -e "Wlaczony kompilator to: $u\n--------------------------------------------------------------------------------"
        echo -e "\t\t\t1 - zmien folder kodow zrodlowych"
	echo -e "\t\t\t2 - zmian domyslne rozszerzenie kodow zrodlowych"
	echo -e "\t\t\t3 - zmien kompilator"
	echo -e "\t\t\t4 - wyczysc logi"
	echo -e "\t\t\t5 - wyjdz"
	read c
		case $c in
    		"1")echo -e "Podaj domyslną sciezke do folderu z kodami zrodlowymi:\n"
		read d
		cd $d;;
		"2")echo -e "Podaj domyslną rozserzenie:\n"
		read e;;
		"3")echo -e "Podaj nazwe kompilatora: c - gcc, c++ - g++:\n"
		read u;;
		"4")cd ~/abc++/logi
		rm *.txt
		clear;;
		"5") clear;;
		*) echo "Nic nie wybrałeś";;
		esac;;
    "5") cd ~/abc++/
	echo $d > conf.txt 
	echo $e >> conf.txt 
	echo $u >> conf.txt 
	exit;;
    	*) echo "Nic nie wybrałeś";;
esac
done