ลูกน้องเอาธัมบ์ไดรฟ์มาให้หาไวรัส
ผลปรากฎว่าพบไฟล์ที่เป็นนามสกุล exe เป็นจำนวนมากภายใต้ไดเรกทอรี่ย่อยเป็นร้อย
ทางแก้คือสแกนแล้วเก็บชื่อไฟล์ไว้ ตัวอย่างของเนื้อไฟล์ที่ถูกสแกนเก็บไว้ เช่น

PhotoShop 7.0/• วิธีทำตัวเยลลลี่ •_files/• วิธีทำตัวเยลลลี่ •_files.exe: W32.Autoit.Obfus FOUND
PhotoShop 7.0/• วิธีทำตัวหนังสือชอล์ค •_files/truehitsstat_files/truehitsstat_files.exe: W32.Autoit.Obfus FOUND
...

จะเห็นว่ามีรูปแบบที่เราจะตัดโดยใช้คำสั่ง cut ได้คือตั้งแต่เครื่องหมาย : เป็นต้นไป
คำสั่งที่ใช้คือ

cut -d: -f1

-d: คือใช้ : เป็นตัวแบ่ง
-f1 คื่อเมื่อแบ่งแล้ว เราจะเอาสดมถ์ที่ 1 มาใช้งาน

แต่เราจะแก้ไขเนื้อไฟล์ให้เหมาะสมเล็กน้อย คือตัดท่อนล่างของไฟล์ออก ให้เหลือเฉพาะชื่อไฟล์ที่ติดไวรัส
แล้วจึงเอาเนื้อไฟล์นั้นมาเป็นข้อมูลเข้า เพื่อจะมาลบไฟล์ที่ติดไวรัสจริง ๆ

แต่มีปัญหาเพิ่มคือ ชื่อไฟล์ประกอบด้วยช่องว่างจำนวนมาก ไม่สามารถใช้คำสั่ง for i in `cat file` ได้
ค้นกูเกิลดู พบว่าเขาใช้คำสั่ง while read VARIABLE

สรุปคำสั่งทั้งหมดมาเป็นขั้นตอนดังนี้
สมมุติว่าค้นหาไวรัสในธัมบ์ไดรฟ์ในไดเรกทอรี่ /media/disk

ไปที่ที่ทำงาน

$ cd /media/disk

สแกนไวรัส แล้วเก็บผลไว้ที่ ~/virus.txt

$ clamscan -i -r * > ~/virus.txt

-i คือให้แสดงเฉพาะไฟล์ที่ติดไวรัส
-r คือให้ขุดลึกลงไปในไดเรกทอรี่ย่อยด้วย

แก้ไขไฟล์เล็กน้อย โดยตัดรายงานส่วนท้ายออก
ยกตัวอย่างส่วนที่ตัดออกคือ

$ vi ~/virus.txt

----------- SCAN SUMMARY -----------
Known viruses: 203664
Engine version: 0.92
Scanned directories: 97
Scanned files: 1234
Infected files: 252
Data scanned: 378.68 MB
Time: 130.603 sec (2 m 10 s)

ทีนี้ก็ถึงเวลาลบจริง ๆ แล้ว ***ใช้ด้วยความระมัดระวังนะครับ***
ถ้ายังไม่แน่ใจ อาจแทนที่คำสั่ง rm ด้วยคำสั่ง ls ลองดูก่อน

$ cat ~/virus.txt | cut -d: -f1 | while read FILE; do rm "$FILE"; done

เสร็จแล้วครับ

หมายเหตุ

• ต้องติดตั้ง clamscan ไว้ก่อน ถ้ายัง ติดตั้งด้วยคำสั่ง
  

  $ sudo aptitude install clamav
  $ sudo freshclam

• ปกติการเมานต์ธัมบ์ไดรฟ์ที่เป็นระบบไฟล์ vfat เขาจะเมานต์ด้วยค่าปริยายด้วยรหัสอักขระภาษาอังกฤษ ทำให้อ่านชื่อไฟล์ภาษาไทยไม่รู้เรื่อง ซึ่งจริง ๆ แล้วต้องตั้งค่ารหัสอักขระเป็น utf-8
  เราสามารถบังคับด้วยการเมานต์ใหม่ หรือตั้งค่ารหัสอักขระถาวร ดูวิธีการได้ที่ th.gnome.org: เกร็ดการแก้รหัสอักขระ usb drive
• ถ้ามีไฟล์ชื่อ runauto.. เราจะลบไฟล์นี้ตรง ๆ ไม่ได้ ต้องใช้คำสั่งว่า
  $ rm runaut~1 -rf
  ถึงจะลบออก

ที่มา

• macgeekery: Handling Filenames with Spaces in Bash
• Damned runauto..

มีงานต้องเก็บแผ่นซีดีธรรมะลงไว้ในฮาร์ดดิสก์เป็นจำนวนมาก
เพื่อให้สะดวก จึงทำเป็นสคริปต์ให้ใช้งานได้สะดวก
ลักษณะของโปรแกรมคือ เมื่อเราใส่แผ่นแล้วสั่งรันโปรแกรม เขาจะถอดไฟล์เสียงทั้งหมดมาเป็นไฟล์ mp3 ที่ไดเรกทอรี่ปัจจุบัน โดยเอาข้อมูลชื่อเพลงจากแผ่นมาเป็นชื่อไฟล์ ก่อนอื่นติดตั้งแพกเกจที่จำเป็นก่อน
$ sudo aptitude install lame cdda2wav สคริปต์มีดังนี้
$ sudo vi /usr/local/bin/d.audio2mp3

#!/bin/bash
# Rip audio disc to mp3
# 
# USAGE: $0 prefix
# exam1: $0 T2
#    -> T2-01-Title1.mp3
#       T2-02-Title2.mp3
#       ...
# in current dir
# 
# Requist: aptitude install lame cdda2wav

if [ $1 ]; then PREFIX="$1-"; fi

DEV='/dev/cdrom'
TMP="/tmp/$USER/`basename $0`_$RANDOM"

mkdir -p $TMP
pushd $TMP

#to wave
cdda2wav -L 1 -D $DEV -B

#to mp3
for i in *wav; do
    NUM=`echo ${i%.*} | cut -d_ -f 2`-
    TITLE=`grep 'Tracktitle=' ${i%.*}.inf | cut -d\'  -f2`
    lame -h -V 2 $i $PREFIX$NUM$TITLE.mp3
done

popd
mv $TMP/*mp3 .

rm -rf $TMP

ทำให้รันได้
$ sudo chmod 777 /usr/local/bin/d.audio2mp3 เสร็จแล้ว
การใช้งานคือ ใส่แผ่น audio แล้วสั่งรัน d.audio2mp3 จะได้ไฟล์ mp3 มาอยู่ในไดเรคทอรี่ปัจจุบัน การทำงานของสคริปต์คือ

• แปลงข้อมูลเสียงมาเป็นไฟล์ wav ด้วยโปรแกรม cdda2wav โดยนำไปใส่ในไดเรคทอรี่ชั่วคราวใน /tmp (เพื่อป้องกันผู้ใช้หลายคน จึงใส่ตัวแปร $USER ไว้ด้วย เพราะโค๊ดต้นฉบับ เขียนบนเซิร์ฟเวอร์ที่มีผู้ใช้หลายคน)
• แปลงไฟล์ wav ที่ได้มาเป็น mp3 โดยใช้โปรแกรม lame (ซึ่งอาจมีปัญหาว่าตอนนี้หา lame บน lenny กับ sid ไม่ได้แล้ว ให้ลองดูวิธีปรุงขึ้นมาเองได้ที่ วิธีปรุง lame โดยคุณโดม http://thisk.org/dr/node/32)
  โดยเอาข้อมูล Tracktitle จากไฟล์นามสกุล inf มาเป็นชื่อไฟล์ mp3 ที่ได้ รวมถึงใส่คำนำหน้า (ตัวแปร $PREFIX) ให้ด้วย

update

• 25570325: แพ็กเกจเปลี่ยน ไม่ต้องใช้สคริปต์แล้ว เพียงลงแพ็กเกจชื่อ icedax แล้วใช้คำสั่ง
  

  $ CDDA_DEVICE=/dev/sr0 cdda2mp3

มีโจทย์คือ ให้สร้างบัตรแบบเรียงเลขที่ ตั้งแต่ ๑ จนถึง ๕๐๐
ตัดสินใจใช้ bash + inkscape เพราะง่ายดี
โดยสมมุติว่าเราได้สร้างเอกสารเป็นไฟล์ inkscape ไว้แล้ว โดยให้ตัวเลขที่จะเรียงให้มีค่าเป็น XXXX เพื่อให้สะดวกในการใช้คำสั่ง grep โค๊ดที่สร้างขึ้น ทำแบบง่าย ๆ คือรันตัวเลขตั้งแต่ 1-500 แต่รุ่นนี้เป็นรุ่นทดสอบ ทำแค่ 1-10 พอ ขั้นตอนคือ

• แปลงตัวเลขเป็นเลขไทย ด้วยคำสั่ง awk
• นำไปแทนที่ในไฟล์ inkscape แล้วทำออกมาเป็นไฟล์ใหม่ ด้วยคำสั่ง sed
• แล้วสั่งส่งออกมาเป็นไฟล์นามสกุล png ด้วยคำสั่งแบบบรรทัดคำสั่งของ inkscape เอง ด้วยพารามิเตอร์ -e

โค๊ดมีดังนี้

$ vi runcard

#!/bin/bash

FILE='card.svg'
QUAN=10
MARKER='XXXX'

for i in $(seq 1 $QUAN); do
    TNUM=`echo $i | awk '{ gsub ("0","๐"); gsub ("1","๑"); gsub ("2","๒"); gsub ("3","๓"); gsub ("4","๔"); gsub ("5","๕"); gsub ("6","๖"); gsub ("7","๗"); gsub ("8","๘"); gsub ("9","๙"); print }'`
    sed -e "s/$MARKER/$TNUM/g" $FILE > tmp.svg
    inkscape -d 300 -e tmp$i.png tmp.svg
done

$ chmod 755 runcard

เวลาใช้งานก็สั่งรันชื่อไฟล์ runcard เฉย ๆ จะได้ไฟล์ tmp1.png จนถึง tmp10.png ก็สามารถนำไฟล์เหล่านี้ไปพิมพ์งานได้ตามต้องการ

ต้องการโอนข้อมูลผู้ใช้ไปเครื่องใหม่

ถ้าเราคัดลอกไฟล์ /etc/passwd /etc/shadow /etc/group /etc/gshadow ไปทับเครื่องใหม่แบบตรง ๆ จะเกิดปัญหาเรื่องผู้ใช้ของระบบจะติดไปด้วย ซึ่งอาจมีค่า UID และ GID ที่ไม่ตรงกัน

ค้นกูเกิลได้วิธีการจากที่นี่ครับ Move or migrate user accounts from old Linux server to a new Linux server

เขาใช้หลักการที่ว่า UID ของผู้ใช้ทั่วไป จะมีค่ามากกว่า 1000 (ของ RedHat คือ 500)
และใช้ awk เป็นตัวกรอง

--- ข้อเขียนต่อจากนี้ไป ควรทดสอบกับเครื่องทดสอบ ก่อนใช้งานจริง---

ขั้นตอนตามต้นฉบับก็ไม่มากเท่าไหร่ แต่กลัวว่าเวลาย้ายจริงจะพิมพ์พลาด เลยเอามาเขียนเป็นสคริปต์เพื่อช่วยลดความผิดพลาดตอนพิมพ์บนบรรทัดคำสั่ง รวมทั้งเป็นการศึกษาการเขียนสคริปต์ของ bash ร่วมกันแล้วกันนะครับ

ตั้งชื่อว่า d.migrate-groupuser ผมใส่ไว้ใน /root
(ห้ามใส่ในพาธการค้นหาของระบบเด็ดขาด เพราะต้องมีการแก้ไขค่าก่อนใช้งานจริง)

ตอนใช้งานก็เปลี่ยนค่าตัวแปร TARGETMACHINE ให้เป็นชื่อเครื่องใหม่ที่เราจะโอนไป แล้วก็สั่งรันได้เลย

โปรแกรมจะทำงานดังนี้

1. คัดลอกไฟล์ /etc/{passwd,shadow,group,gshadow} และบีบอัดไดเรกทอรี่ /home และ /var/spool/mail มาไว้ในไดเรกทอรี่ $MIGRATEDIR
2. ผลิตสคริปต์ชื่อ d.import-groupuser เอาไว้สั่งรันที่เครื่องใหม่ และ d.rollback-groupuser เอาไว้สั่งทำย้อนกลับที่เครื่องใหม่เช่นกัน
3. โอนไฟล์ทั้งหมดใน $MIGRATEDIR ไปยังเครื่องใหม่

หลังจากนั้น เราก็สั่งรันสคริปต์ d.import-groupuser ที่เครื่องใหม่ได้เลย

*** ใช้ด้วยความระมัดระวัง ***

เริ่มเลย
# vi /root/d.migrate-groupuser

#!/bin/bash
#PREREQUISITE:
#  1. INSTALL PACKAGE: openssh-client
#  2. EDIT THIS FILE, CHANGE VARIABLE "TARGETMACHINE" TO REAL TARGET 
#THEN RUN AS root

MIGRATEDIR="/root/migrategroupuser"    #MIGRATE DIR
UGIDLIMIT=1000    #UID&GID OF USER DATA: DEBIAN=1000, REDHAT=500

# EDIT TARGETMACHINE 
TARGETMACHINE="newserver"              #COPY TO THIS MACHINE
TARGETDIR="/root/importgroupuser"      #COPY DATA TO THIS DIR

if [ "$1" != "OK" ]; then
    PROG=`basename $0`
    cat << EOF

*** DON'T PLACE THIS SCRIPT IN SYSTEM SEARCH PATH
*** USE WITH CARE
*** EDIT TARGETMACHINE VARIABLE THEN RUN AS ROOT

Move or migrate user accounts from old Linux server to a new Linux server
FROM: http://www.cyberciti.biz/faq/howto-move-migrate-user-accounts-old-to-new-server/

USE WITH CARE, PLEASE BACKUP OLD DATA, RUN AS ROOT
- COPY FILTERED /etc/{passwd,group,shadow,gshadow} TO $MIGRATEDIR WITH EXT .mig 
- BACKUP /home, /var/spool/mail TO $MIGRATEDIR .tar.gz
- TRANSFER ALL FILES IN $MIGRATEDIR TO root@$TARGETMACHINE:$TARGETDIR WITH scp
 
USAGE:
    $PROG OK

('OK' is safety argument)
DON'T FORGET TO EDIT TARGETMACHINE VARIABLES

EOF
    exit 1
fi

if [ ! `which scp` ]; then
    echo "Please install 'openssh-client' first."
    exit 1
fi

mkdir -p $MIGRATEDIR

echo "
Copy /etc/{password,group,shadow,gshadow} to $MIGRATEDIR ..."
for i in /etc/{passwd,group,shadow,gshadow}; do
    j=`basename $i`
    awk -v LIMIT=$UGIDLIMIT -F: '($3>=LIMIT) && ($3!=65534)' $i > $MIGRATEDIR/$j.mig
done

echo "
gzip /home ..."
tar -zcpf $MIGRATEDIR/home.tar.gz /home/*

echo "
gzip /var/spool/mail ..."
tar -zcpf $MIGRATEDIR/mail.tar.gz /var/spool/mail/*

#------------------------------------------------

echo "
Generate import script ..."
IMPORTPROG="d.import-groupuser"
cat > $MIGRATEDIR/$IMPORTPROG << VIRTUAL_EOF
#!/bin/bash

IMPORTDIR="/root/importgroupuser"     #COPY DATA TO THIS DIR
BACKUPDIR="/root/backupgroupuser"     #BACKUP OLD DATA

if [ "\$1" != "OK" ]; then
    PROG=\`basename \$0\`
    cat << EOF

Move or migrate user accounts from old Linux server to a new Linux server
FROM: http://www.cyberciti.biz/faq/howto-move-migrate-user-accounts-old-to-new-server/

USE WITH CARE, PLEASE BACKUP OLD DATA, RUN AS ROOT
- BACKUP /etc/{passwd,group,shadow,gshadow} TO \$BACKUPDIR/etc
- BACKUP /home /var/spool/mail TO \$BACKUPDIR/tar 
- ADD NEW GROUP-USER DATA FROM \$IMPORTDIR TO /etc
- ADD NEW /home AND /var/spool/mail TO /
 
USAGE:
    \$PROG OK

('OK' is safety argument.)
    
EOF
    exit 1
fi


if [ ! -d \$IMPORTDIR ]; then
    echo "\$IMPORTDIR not exist, program aborted"
    exit 1
fi


echo "
Backup old data and add migrate data to /etc/{passwd,group,shadow,gshadow} ..."
mkdir -p \$BACKUPDIR
pushd \$BACKUPDIR
ls | while read FILE; do
    mv "\$FILE" "\$FILE.bak"
done
mkdir -p {etc,tar}
for i in {passwd,group,shadow,gshadow}; do
    cp /etc/\$i etc
    cat \$IMPORTDIR/\$i.mig >> /etc/\$i
done

echo "
Backup /home and /var/spool/mail in \$BACKUPDIR/tar ..."
tar -zcpf tar/home.tar.gz /home/*
tar -zcpf tar/mail.tar.gz /var/spool/mail/*
popd

echo "
Extract imported data in \$IMPORTDIR to /home and /var/spool/mail ..."
pushd /
echo "
gunzip \$IMPORTDIR/home.tar.gz to / ..." 
tar -zxf \$IMPORTDIR/home.tar.gz

echo "
gunzip \$IMPORTDIR/mail.tar.gz to / ..." 
tar -zxf \$IMPORTDIR/mail.tar.gz
popd

echo "
Import finished."
echo
echo "Please delete these files to finish the work:"
echo "  \$BACKUPDIR"
echo "  \$IMPORTDIR/d.import-groupuser"
echo "  \$IMPORTDIR/d.rollback-groupuser"
echo

VIRTUAL_EOF
chmod 700 $MIGRATEDIR/$IMPORTPROG
#------------------------------------------------

echo "Generate rollback script ..."
ROLLBACKPROG="d.rollback-groupuser"
cat > $MIGRATEDIR/$ROLLBACKPROG << VIRTUAL_EOF
#!/bin/bash

BACKUPDIR="/root/backupgroupuser"     #BACKUP OLD DATA

if [ "\$1" != "OK" ]; then
    PROG=\`basename $0\`
    cat << EOF

Move or migrate user accounts from old Linux server to a new Linux server
FROM: http://www.cyberciti.biz/faq/howto-move-migrate-user-accounts-old-to-new-server/

USE WITH CARE, PLEASE BACKUP OLD DATA, RUN AS ROOT, NO WARNING
- COPY BACKUP DATA IN \$BACKUPDIR/etc TO /etc
- *** REMOVE OLD /home AND /var/spool/mail ***
- COPY BACKUP DATA IN \$BACKUPDIR/tar TO /home and /var/spool/mail
- ROLLBACK \$BACKUPDIR/*.bak
 
USAGE:
    \$PROG OK

('OK' is safety argument.)

EOF
    exit 1
fi

if [ ! -d \$BACKUPDIR/etc ]; then
    echo "\$BACKUPDIR/etc not exist, program aborted"
    exit 1
fi
if [ ! -d \$BACKUPDIR/tar ]; then
    echo "\$BACKUPDIR/tar not exist, program aborted"
    exit 1
fi


echo "
Copy \$BACKUPDIR/etc to /etc ..."
pushd \$BACKUPDIR
cp etc/* /etc
popd


echo "
*** Remove /home and /var/spool/mail *** ..."
rm -rf /home /var/spool/mail

echo "
Copy \$BACKUPDIR/tar to /home and /var/spool/mail ..."
pushd /
tar -zxf \$BACKUPDIR/tar/home.tar.gz
tar -zxf \$BACKUPDIR/tar/mail.tar.gz
popd

echo "
Remove last rollback data ..."
pushd \$BACKUPDIR
rm -rf etc tar
for i in *.bak; do
    mv \$i \${i%.bak}
done

echo "
Rollback finished."

VIRTUAL_EOF
chmod 700 $MIGRATEDIR/$ROLLBACKPROG
#------------------------------------------------

echo "
Transfer data to root@$TARGETMACHINE:$TARGETDIR, enter $TARGETMACHINE root password:"
echo "COMMAND RUN: scp -r $MIGRATEDIR root@$TARGETMACHINE:$TARGETDIR"
scp -r $MIGRATEDIR/* root@$TARGETMACHINE:$TARGETDIR

echo "
Finished.

Next, run $MIGRATEDIR/$IMPORTPROG at $TARGETMACHINE
(*** Use $ROLLBACKPROG to undo the job, BUT DO USE WITH CARE ***)
"

เปลี่ยนสถานะให้รันได้
# chmod 700 /root/d.migrate-groupuser

ทดลองรัน
เริ่มที่เครื่องเก่า
# /root/d.migrate-groupuser OK

Copy /etc/{password,group,shadow,gshadow} to /root/migrategroupuser ...

gzip /home ...
tar: Removing leading `/' from member names

gzip /var/spool/mail ...
tar: Removing leading `/' from member names

Generate import script ...
Generate rollback script ...

Transfer data to root@newserver:/root/importgroupuser, enter newserver root password:
COMMAND RUN: scp -r /root/migrategroupuser root@newserver:/root/importgroupuser
root@newserver's password: <<<---NEWSERVER_ROOT_PASSWORD
d.import-groupuser                                            100% 1668     1.6KB/s   00:00    
d.rollback-groupuser                                          100% 1291     1.3KB/s   00:00    
group.mig                                                     100%   90     0.1KB/s   00:00    
gshadow.mig                                                   100%    0     0.0KB/s   00:00    
home.tar.gz                                                   100%   61MB  10.2MB/s   00:06    
mail.tar.gz                                                   100%   10KB  10.4KB/s   00:00    
passwd.mig                                                    100% 1287     1.3KB/s   00:00    
shadow.mig                                                    100% 2937     2.9KB/s   00:00    

Finished.

Next, run /root/migrategroupuser/d.import-groupuser at newserver
(*** Use d.rollback-groupuser to undo the job, BUT DO USE WITH CARE ***)

ย้ายไปทำที่เครื่อง newserver
# /root/importgroupuser/d.import-groupuser OK

Backup old data and add migrate data to /etc/{passwd,group,shadow,gshadow} ...
~/backupgroupuser ~

Backup /home and /var/spool/mail in /root/backupgroupuser/tar ...
tar: Removing leading `/' from member names
tar: Removing leading `/' from member names
~

Extract imported data in /root/importgroupuser to /home and /var/spool/mail ...
/ ~

gunzip /root/importgroupuser/home.tar.gz to / ...

gunzip /root/importgroupuser/mail.tar.gz to / ...
~

Import finished.

Please delete these files to finish the work:
  /root/backupgroupuser
  /root/importgroupuser/d.import-groupuser
  /root/importgroupuser/d.rollback-groupuser

เสร็จแล้ว เครื่องใหม่จะมีชื่อผู้ใช้งานและข้อมูลของผู้ใช้ครบตามเครื่องเก่าทุกประการ
หากสำเร็จเป็นที่พอใจแล้ว ควรลบไฟล์ต่าง ๆ ตามคำแนะนำนะครับ

แพกเกจ apt-proxy เป็นแพกเกจที่ใช้เป็นคลังเก็บแพกเกจที่เครือข่ายเราใช้ประจำ ใช้ง่ายและสะดวก แต่ชอบตายบ่อย จะเข้าไปรื้อดูการทำงาน ก็ยากเกินความสามารถ เลยลองเขียนเป็น cron แก้ปัญหาเฉพาะหน้าไปก่อน การทำงานของสคริปต์ก็ไม่มีอะไรมาก แค่ตรวจว่าการใช้คำสั่ง aptitude update นานเกิน 60 วินาทีหรือไม่ ถ้านานก็ให้เริ่ม apt-proxy ใหม่ แค่นี้เอง
(สามารถปรับช่วงเวลารอที่ตัวแปร TIME_WAIT ตามความเร็วของเน็ตที่มีอยู่จริง) # vi /usr/local/sbin/d.cron-check-apt-proxy

#!/bin/bash
TIME_WAIT='60'

function sub_wait() {
        sleep $TIME_WAIT 
        echo `date +%F-%R-%s`
}

function update_apt_proxy() {
        aptitude update
        echo `date +%F-%R-%s`
}

T1=`sub_wait` &
T2=`update_apt_proxy` &
wait
if [ "$T1" \< "$T2" ]; then
        echo "apt-proxy update longer than $TIME_WAIT seconds, restart apt-proxy." 
        /etc/init.d/apt-proxy restart
fi

# chmod 755 /usr/local/bin/d.cron-check-apt-proxy ตั้ง crontab ให้รันทุกชั่วโมง
# crontab -e

...
#CHECK apt-proxy EVERY 60 MIN
0 * * * *   /usr/local/sbin/d.cron-check-apt-proxy
...

เสร็จแล้ว ลองใช้ดูก่อน แล้วจะรายงานผลต่อไปตรับ update

• เจอสาเหตุแล้ว มาจากตั้ง squid3 เป็นแบบ transparent ไว้ ทางแก้คือ ยกเลิก transparent หรือไม่ก็ปรับ apt-proxy ให้ไปใช้ http_proxy ที่พอร์ต 8080 (หรือพอร์ตอื่นที่ตั้งไว้ใน squid) เรียบร้อยแล้ว - แต่สคริปต์นี้ก็ยังน่าใช้อยู่ดี อาจปรับเป็นทุก 3 ชั่วโมงก็ได้

สคริปต์คัดลอกผู้ใช้จากระบบปัจจุบันไปยังไดเรคทอรี่ที่ติดตั้งลินุกซ์อีกตัวหนึ่ง
มีประโยชน์สำหรับติดตั้งลินุกซ์หลายตัว และต้องการให้ผู้ใช้เหมือนกับระบบปัจจุบัน ตัวอย่างการใช้งานเช่น

• ติดตั้งลินุกซ์ผ่าน debootstrap
• ติดตั้งลินุกซ์โดยการเมานต์ live cd แล้วคัดลอก squashfs มาติดตั้งโดยตรง

ข้อกำหนดคือ

• ต้องใช้สิทธิ์ root ในการรัน
• ต้องเป็นลินุกซ์ที่มีการเก็บไฟล์ผู้ใช้แบบมาตรฐาน คือเก็บที่ไฟล์ /etc/passwd, /etc/group และ /etc/shadow

สคริปต์มีดังนี้

$ sudo vi /usr/local/sbin/transfer_users.sh

#!/bin/bash

function usage() {
    cat <<EOF
Usage: $0 DESTINATION
Transfer users from current linux system to DESTINATION directory that have another linux system.
Run as root.
EOF
    exit 1
}
    
DEST=$1

if [ ! "$UID" == "0" ]; then
    echo "Please run as root."
    usage
fi
if [ ! -d "$DEST" ]; then
    echo "DESTINATION directory not found."
    usage
fi
if [ ! -d "$DEST/etc" ]; then
    echo "DESTINATION/etc directory not found."
    usage
fi

US=`ls /home`
TMP=/tmp/${RANDOM}.txt

#SORT ON UID
for i in $US; do
    UUID=`grep ":/home/${i}:" /etc/passwd | cut -d: -f3`
    echo "${UUID}:${i}" >> $TMP
done

#PROCESS EACH USER
for i in `cat $TMP | sort`; do
    UUID=`echo $i | cut -d: -f1`
    U=`echo $i | cut -d: -f2`

    PASSWDLINE=`grep ":/home/${U}:" /etc/passwd`

    #/etc/group
    GNUM=`echo $PASSWDLINE | cut -d: -f4`
    GROUPLINE=`grep $GNUM /etc/group`
    GNAME=`echo $GROUPLINE | cut -d: -f1`
    OLDGROUP=`grep $GNAME $DEST/etc/group`
    if [ "$OLDGROUP" == "" ]; then
        echo $GROUPLINE >> $DEST/etc/group
    elif [ "$OLDGROUP" != "$GROUPLINE" ]; then
        sed -i "s/$OLDGROUP/$GROUPLINE/g" $DEST/etc/group
    fi

    #/etc/passwd
    OLDPASS=`grep ":/home/${U}:" $DEST/etc/passwd`
    if [ "$OLDPASS" == "" ]; then
        echo $PASSWDLINE >> $DEST/etc/passwd
    elif [ "$OLDPASS" != "$PASSWDLINE" ]; then
        sed -i "s/$OLDPASS/$PASSWDLINE/g" $DEST/etc/passwd
    fi

    #/etc/shadow
    SHADOWLINE=`grep "${U}:" /etc/shadow | grep -v '*'`
    OLDSHADOW=`grep "${U}:" $DEST/etc/shadow | grep -v '*'`
    if [ "$OLDSHADOW" == "" ]; then
        echo $SHADOWLINE >> $DEST/etc/shadow
    elif [ "$OLDSHADOW" != "$SHADOWLINE" ]; then
        sed -i "s#$OLDSHADOW#$SHADOWLINE#g" $DEST/etc/shadow
    fi

    #GROUP MEMBERS
    for j in `groups $U | cut -d: -f2`; do
        for k in `echo $j`; do
            if [ "$k" == "$GNAME" ]; then
                continue
            fi

            OLDLINE=`grep "${k}:" $DEST/etc/group`
            if ! echo $OLDLINE | grep $U ; then
                if [ "${OLDLINE: -1}" == ":" ]; then
                    sed -i "s/$OLDLINE/${OLDLINE}${U}/g" $DEST/etc/group
                else
                    sed -i "s/$OLDLINE/${OLDLINE},${U}/g" $DEST/etc/group
                fi
            fi
        done
    done
    
    #/HOME
    if [ ! -d "$DEST/home/$U" ]; then
        mkdir -p "$DEST/home/$U"
    fi
    chown -R ${U}:${GNAME} $DEST/home/$U
done

#for i in passwd group shadow; do
#    cp $DEST/etc/$i $DEST/etc/${i}-
#done
rm $TMP

ตัวอย่างเช่น เราติดตั้งลินุกซ์อีกอันไว้ที่ /dev/sdaXX

$ sudo mount /dev/sdaXX /mnt/tmp
$ sudo /usr/local/sbin/transfer_users.sh /mnt/tmp

ผู้ใช้ทั้งหมดใน /home/* จะถูกคัดลอกไปยัง /mnt/tmp/home/ ตามต้องการ

ทำสคริปต์บล๊อกผู้ใช้ Drupal จากบรรทัดคำสั่ง (bash)

$ vi drupal_blockuser.sh

#!/bin/bash

#FROM: https://drupal.org/node/118759

if [ "$#" == "0" ]; then
    echo "Script to block drupal users by uid"
    echo "Usage: $0 UID1 UID2 UID3 ..."
    exit 1
fi

SITE=http://www.example.com    #NO END SLASH
NAME=drupal_admin_user
PASS=drupal_admin_password

STATUS=0    #0:block,1:unblock
OPLOGIN="Log%20in"
OPSUBMIT="Save"
TMP=/tmp/$RANDOM.txt
COOKIES=/tmp/$RANDOM.txt

#LOGIN
wget -q -o /dev/null -O /dev/null \
    --keep-session-cookies --save-cookies $COOKIES --load-cookies $COOKIES \
    --post-data="name=${NAME}&pass=${PASS}&op=${OPLOGIN}&form_id=user_login" \
    "${SITE}/?q=user/login"

#DO BLOCK
while (( "$#" )); do
    ID=$1
    wget -q -o /dev/null -O $TMP \
        --keep-session-cookies --save-cookies $COOKIES --load-cookies $COOKIES \
        "${SITE}/?q=user/${ID}/edit"
    let "LINE=`grep -n 'value="user_profile_form"' $TMP | cut -d: -f1`-1"
    TOKEN=`sed -n -e "${LINE}p" $TMP | awk -F'value="' '{ print $2 }' | cut -d\" -f1`
    USER1=`grep 'id="edit-name"' $TMP | awk -F'value="' '{ print $2 }' | cut -d\" -f1`
    EMAIL=`grep 'id="edit-mail"' $TMP | awk -F'value="' '{ print $2 }' | cut -d\" -f1`
    wget -q -o /dev/null -O /dev/null \
        --keep-session-cookies --save-cookies $COOKIES --load-cookies $COOKIES \
        --post-data="status=${STATUS}&op=${OPSUBMIT}&name=${USER1}&mail=${EMAIL}&form_token=${TOKEN}&form_id=user_profile_form" \
        "${SITE}/?q=user/${ID}/edit"
    echo "USER:\"$USER1\" --- EMAIL:\"$EMAIL\" --- Blocked."

    shift
done

rm $TMP
rm $COOKIES

$ chmod 700 ./drupal_blockuser.sh

วิธีใช้งานก็สั่ง

$ ./drupal_blockuser.sh UID1 UID2 UID3 ...

อย่าลืมแก้ตัวแปร SITE, NAME, PASS ให้เข้ากับงานเรา

update 2556-12-03

ลองใช้สคริปต์กับพาร์ติชั่นที่ขนาดไม่เท่ากันแล้วปรากฎว่าใช้ไม่ได้ เพราะ NTFS เก็บข้อมูลหลายอย่างมากกว่าแค่จุดเริ่มต้นและขนาด (ดูที่ NTFS Partition Boot Sector)

วิธีที่ได้ผลกว่าคือ ฟอร์แมตไดร์ฟไว้ก่อน -> เก็บ boot sector ไว้ 72 ไบต์ -> ทำ ntfsclone -> เอา boot recort ที่เก็บไว้มาเขียนทับ

ตัวอย่างเช่น จะคัดลอก ไดร์ฟ /dev/sda1 ไปยัง /dev/sdb1 ขั้นตอนจะเป็นดังนี้

$ sudo mkfs.ntfs -f /dev/sdb1
$ sudo dd if=/dev/sdb1 of=sdb1.img bs=72 count=1
$ sudo ntfsclone -O /dev/sdb1 /dev/sda1
$ sudo dd if=sdb1.img of=/dev/sdb1

---

*** สคริปต์ด้านล่างนี้ ล้าสมัยแล้ว ***

แก้ปัญหาเวลาใช้ ntfsclone ในการ restore พาร์ติชั่น NTFS มาลงในฮาร์ดดิสก์ลูกใหม่ ซึ่งจุดเริ่มต้นและขนาดอาจไม่เท่าของเดิม

วิธีการคือใช้ข้อมูลจากตาราง Master Boot Record ปัจจุบัน มาเขียนทับ boot record ของพาร์ติชั่น NTFS ที่ต้องการ โดยใช้เชลล์สคริปต์

$ vi ntfs_fix_boot_sector.sh

#!/bin/bash

function usage() {
    cat <<EOF
Fix NTFS boot record:
Usage: $0 DEVICE
Example: $0 /dev/sda1
EOF
    exit 1
}

if [ ! "$1" ]; then
    usage
fi

PART=$1

if [ ! -b "$PART" ]; then
    echo -e "$PART not found. Exit.\n"
    usage
fi

BSF="`echo $PART | tr '/' '_'`.img"
BSFB=${BSF}.bak
BSFD="${BSF}_`date +%F`.bak"

function reverse_byte () {  #reverse_byte HEXSTR
    local S=$1  #HEXSTR
    local B
    local C
    while [ "$S" ]; do
        B=${S:(-2)}
        S=${S:0:-2}
        C="${C}\\x${B}"
    done
    echo $C
}

function replace_byte () {  #replace_byte OFFSET LENGTH NUMBER
    local O=$1  #OFFSET
    local L=$2  #LENGTH
    local N=$3  #NUMBER
    let NL=${L}*2
    XN=`printf "%0${NL}x" $N`
    RXN=`reverse_byte $XN`
    #echo "printf $RXN | dd of=$BSF bs=1 seek=$O count=$L conv=notrunc"
    printf $RXN | sudo dd of=$BSF bs=1 seek=$O count=$L conv=notrunc > /dev/null 2>&1
}

sudo dd if=$PART of=$BSF bs=512 count=1 > /dev/null 2>&1

TMP="/tmp/$0_${RANDOM}.txt"

HDD=$PART
while [ "`echo ${HDD:(-1)} | tr '0123456789' ' '`" == " " ]; do
    HDD=${HDD:0:-1}
done

sudo fdisk -l $HDD > $TMP

if ! cat $TMP | grep $PART | grep NTFS > /dev/null 2>&1; then
    echo -e "$PART is not NTFS partition. Exit.\n"
    sudo rm $TMP
    sudo rm $BSF
    usage
fi

if [ ! -f "$BSFB" ]; then
    cp $BSF $BSFB
else
    cp $BSF $BSFD
fi

echo "Fixing $PART ..."

HEADS=`cat $TMP | grep 'sectors/track' | cut -d, -f1 | cut -d\  -f1`
SECTORS=`cat $TMP | grep 'sectors/track' | cut -d, -f2 | cut -d\  -f2`
START=`cat $TMP | grep "${PART} " | awk -F' ' '{ print $2 }'`
END=`cat $TMP | grep "${PART} " | awk -F' ' '{ print $4 }'`
if [ "$START" == "*" ]; then
    START=`cat $TMP | grep "${PART} " | awk -F' ' '{ print $3 }'`
    END=`cat $TMP | grep "${PART} " | awk -F' ' '{ print $4 }'`
fi
let LENGTH=$END-$START

OFFSET_HEADS=26
OFFSET_SECTORS=24
OFFSET_START=28
OFFSET_LENGTH=40
LEN_HEADS=1
LEN_SECTORS=1
LEN_START=4
LEN_LENGTH=4

for i in HEADS SECTORS START LENGTH; do
    A="OFFSET_${i}"
    B="LEN_${i}"
    replace_byte ${!A} ${!B} ${!i}
done

echo "Fix with heads=$HEADS, sectors/track=$SECTORS, start=$START, length=$LENGTH"

sudo dd if=$BSF of=$PART > /dev/null 2>&1

sudo rm $TMP

cat <<EOF

Command used:
sudo dd if=$BSF of=$PART

Revert with command:
sudo dd if=$BSFB of=$PART
EOF

ตัวอย่าง สมมุติว่าพาร์ติชั่นที่ต้องการเป็น /dev/sda1 คำสั่งคือ

$ ntfs_fix_boot_record.sh /dev/sda1

ได้ผลลัพธ์คือ

Fixing /dev/sda1 ...
Fix with heads=255, sectors/track=63, start=2048, length=62914559

Command used:
sudo dd if=_dev_sda1.img of=/dev/sda1

Revert with command:
sudo dd if=_dev_sda1.img.bak of=/dev/sda1

ที่มา:

• Copying Windows to a New Hard Drive Using Linux

bash: เกร็ดคำสั่ง find

(ศึกษาเพราะต้องการเอาไฟล์ในคลังของ apt-proxy เฉพาะไฟล์ใหม่ ๆ เลยต้องการลบไฟล์เก่า ๆ ทิ้ง เพื่อให้ขนาดคลังแพ็กเกจเล็กลง)

เริ่มเลยครับ
ต้องการค้นหาไฟล์ชื่อ *Doc*
$ find /PATH/TO/FILE -name '*Doc*'

ค้นหาและลบไฟล์
$ find /PATH/TO/FILE -name '*Doc*' -exec rm {} \;

ค้นหาไฟล์ที่เก่ากว่า 5 วันลงไป
$ find /PATH/TO/FILE -mtime +5

ค้นหาไฟล์เก่าตั้งแต่ 5 วันขึ้นมา
$ find /PATH/TO/FILE -mtime -5

ค้นหาไฟล์เก่ากว่า 1 ปีลงไป และลบไฟล์เหล่านั้นทิ้ง
$ find /PATH/TO/FILE -mtime +365 -exec rm {} \;

ค้นหาไฟล์ที่มีขนาด 0 byte และลบไฟล์
$ find /PATH/TO/FILE -type f -size 0 -exec rm {} \;

*** ใช้ด้วยความระมัดระวังนะครับ ***

วันนี้แค่นี้ก่อนครับ

อ้างอิง

• Delete Files Older Than x Days on Linux
• Trying to Copy Files Changed Recently

ขออนุญาตเขียนแบบกองโจรนะครับ โดยมือใหม่ เพื่อมือใหม่ครับ

เอามาจาก tldp: BASH Programming - Introduction HOW-TO

ศึกษาเพิ่มเติมได้จาก tldp: Bash Guide for Beginners
และในเชิงลึก จาก tldp: Advanced Bash-Scripting Guide

ต้องการแปลงชื่อไฟล์เป็นตัวเล็ก ค้นไปค้นมาปรากฎว่ามีอยู่ในแพกเกจ bash-doc เป็นตัวอย่างอยู่แล้ว

ต้องติดตั้งก่อน
$ sudo aptitude install bash-doc

ขมายมาใช้
$ sudo cp /usr/share/doc/bash-doc/examples/scripts.v2/lowercase /usr/local/bin
$ sudo chmod 755 /usr/local/bin/lowercase

เรียกใช้ด้วยคำสั่ง lowercase $FILENAME

นอกจากตัวอย่างในการแปลงไฟล์แล้ว ยังมีโปรแกรมอรรถประโยชน์อีกเยอะแยะในแพกเกจนี้ หากสนใจสามารถติดตั้งและศึกษาดูได้ครับ

ถ้าจะแปลงเป็นตัวใหญ่ก็แค่กลับ จาก tr A-Z a-z ไปเป็น tr a-z A-Z ก็เสร็จแล้ว
ทำเป็นตัวอย่างคือ
$ sudo vi /usr/local/bin/uppercase

#! /bin/bash
#
# original from
# @(#) lowercase.ksh 1.0 92/10/08
# 92/10/08 john h. dubois iii (john@armory.com)
#
# conversion to bash v2 syntax done by Chet Ramey

Usage="Usage: $name file ..."
phelp()
{
echo "$name: change filenames to upper case.
$Usage
Each file is moved to a name with the same directory component, if any,
and with a filename component that is the same as the original but with
any lower case letters changed to upper case."
}

name=${0##*/}

while getopts "h" opt; do
    case "$opt" in
    h)  phelp; exit 0;;
    *)  echo "$Usage" 1>&2; exit 2;;
    esac
done

shift $((OPTIND - 1))

for file; do
    filename=${file##*/}
    case "$file" in
    */*)    dirname=${file%/*} ;;
    *)    dirname=. ;;
    esac
    nf=$(echo $filename | tr a-z A-Z)
    newname="${dirname}/${nf}"
    if [ "$nf" != "$filename" ]; then
    mv "$file" "$newname"
    echo "$0: $file -> $newname"
    else
    echo "$0: $file not changed."
    fi
done

$ sudo chmod 755 /usr/local/bin/uppercase

เสร็จแล้ว เรียกใช้ด้วยคำสัง uppercase $FILENAME