磨刀不误砍柴工

partition table与parted程序

2011-01-28T19:21:00.000-08:00

N多LUN(iscsi盘）需要分区，手动太痛苦了。只能找non-interaction型的分区工具，比如parted这个程序。
在分区之前有一个概念需要先明白的：partition table, 也叫disklabel

之所以使用parted才需要注意到partition table，是因为我们常常使用的fdisk已经帮我们选择了msdos类型的partition table。所以从fdisk转到parted后，会有点小疑问。

平时我们印象中：一个硬盘只能有4个主分区，或者3个主分区1个扩展分区。
这其实只是`msdos` partition table的限制。GPT就没有这种问题：http://en.wikipedia.org/wiki/GUID_Partition_Table

msdos partition table这个名词是从parted程序引用的:
[liangqingxi@hotspare ~]$ sudo /sbin/parted /dev/sdc print
Error: Unable to open /dev/sdc - unrecognised disk label.

[jessinio@niowork ~]$ sudo parted /dev/sda print
[sudo] password for jessinio:

Model: ATA ST3250310AS (scsi)
Disk /dev/sda: 250GB
Sector size (logical/physical): 512B/512B
Partition Table: msdos

但是从wikipedia里查的信息表明, 这与BIOS被广泛使用有着很大的关系(比如,BIOS的引导过程)
感觉上，称为｀PC compatibles｀更好一点：

信息1. In the world of IBM PC compatibles, disks are usually partitioned using the PC BIOS's MBR Partition Table scheme instead
信息2. The role of the BIOS has changed over time; today BIOS is a legacy system, superseded by the more complex EFI (EFI), but BIOS remains in widespread use, and EFI booting has only been supported in Microsoft OS products supporting GPT and Linux Kernels 2.6.1 and greater builds

当硬盘没有、或者程序无法认别partition table时会有如下信息：
[liangqingxi@hotspare ~]$ sudo /sbin/fdisk -l /dev/sdc

Disk /dev/sdc: 1000.2 GB, 1000204886016 bytes
255 heads, 63 sectors/track, 121601 cylinders
Units = cylinders of 16065 * 512 = 8225280 bytes

Disk /dev/sdc doesn't contain a valid partition table

在fdisk的手册中有这样的记载：fdisk doesn’t understand GUID Partition Table (GPT)

在知道partition table这一概念后, 使用parted命令将是非常容易的. 就不记录了.

gpg使用

2011-01-28T00:21:00.000-08:00

I. 基本概念
1. key、public key、private key
文档： http://en.wikipedia.org/wiki/Public-key_cryptography
gpg使用--gen-key 命令生成的key种类有：
(1) DSA and Elgamal (default)
(2) DSA (sign only)
(5) RSA (sign only)
DSA and Elgamal支持加密和签名
单独的DSA、RSA只支持签名
2. 加密与签名
关于签名与加密这两个概念需要明白：

Use of these keys allows protection of the authenticity of a message by creating a digital signature of a message using the private key, which can be verified using the public key. It also allows protection of the confidentiality and integrity of a message, by public key encryption, encrypting the message using the public key, which can only be decrypted using the private key.
private key 加密， public key解密，称为签名
public key 加密， private key解密，称为加密
II. key管理
1. 查看
分为public key的查看和private key的查看：
[jessinio@niowork ~]$ gpg --list-keys
/home/jessinio/.gnupg/pubring.gpg
---------------------------------
pub 1024D/140A3126 2011-01-26
uid jessinio.liang (liang qingxi)
sub 2048g/94134411 2011-01-26
[jessinio@niowork ~]$ gpg --list-secret-keys
/home/jessinio/.gnupg/secring.gpg
---------------------------------
sec 1024D/140A3126 2011-01-26
uid jessinio.liang (liang qingxi)
ssb 2048g/94134411 2011-01-26
2. 导出/导入/删除
也分为private key和public key:
[jessinio@niowork ~]$ gpg --armor --export 140A3126
[jessinio@niowork ~]$ gpg --armor --export-secret-key 140A3126
同理，删除是使用--delete-key和--delete-secret-key子命令完成。
II. key使用
1. 签名
使用jessinio@gmail.com的private key签名
$ gpg --output doc.sig --sign doc
用户jessinio测试数据：
[jessinio@niowork ~]$ gpg --verify doc.gpg
gpg: Signature made Fri 28 Jan 2011 02:31:06 PM CST using DSA key ID 140A3126
gpg: Good signature from "jessinio.liang (liang qingxi) "
用户jessinio解开签名数据：
[jessinio@niowork ~]$ gpg --output doc --decrypt doc.gpg
1.1 detach sign
签名后的数据在没有解开的情况下是无法使用的，所以有时为了方便数据的查看，会把签名与数据分开，这种叫detach sign
2. 加密/解密
使用jessinio@gmail.com的public key加密
＄ gpg --output doc.gpg --encrypt --recipient jessinio@gmail.com doc
解密与解开签名了的数据是一样行为。
3. 对称加密
[jessinio@niowork tmp]$ gpg --output 11 -c testfile.tar.gz
[jessinio@niowork tmp]$ file 11
11: DOS executable (COM)
[jessinio@niowork tmp]$ diff testfile.tar.gz 11
Binary files testfile.tar.gz and 11 differ
[jessinio@niowork tmp]$ gpg --output 11.tar.gz -d 11
gpg: CAST5 encrypted data
gpg: encrypted with 1 passphrase
gpg: WARNING: message was not integrity protected
[jessinio@niowork tmp]$ diff 11.tar.gz testfile.tar.gz
[jessinio@niowork tmp]$

gpg的完整使用手册： http://www.gnupg.org/gph/en/manual.html

硬盘, 接口, RAID

2011-01-08T06:07:00.001-08:00

本文不想记录关于RAID的种类和它的安装之类的，只是想写关于RAID与它背后的硬盘的一些简单信息。
这样有利于SA了解自己管理的硬件的一些具体情况，及正确地使用相应的工具。

我之所以会去了解这些信息，主要是因为：
* 我无法正确了解到在RAID背后的硬盘的信息（如健康情况、容量、型号）
作为SA就基本要清楚自己管理的硬件情况。

接口

开始前，也回顾一下硬件接口的变迁
我们平时常常会看到这样的一些名词：
* SCSI. SAS
* ATA. IDE. SATA. eSTAT
* iSCSI

发展过程: AT -> ATA -> IDE

The current Parallel ATA standard is the result of a long history of incremental technical development, which began with the original AT Attachment interface, developed for use in early PC AT equipment. The ATA interface itself evolved in several stages from Western Digital's original Integrated Drive Electronics (IDE) interface.

上面的ATA都是并口(parallel)的。然后发展为串口 serial ATA。也就是SATA

至于SCSI，和ATA的发展有很大的相似度。 SCSI (Small Computer System Interface)也是一种接口技术，然后发现到了串口的SAS(Serial Attached SCSI).

上面是平时常使用的硬盘接口的两大类的历史。

在了解上面的接口历史好。先来小试牛力: 使用smartctl的'-d'参数：

-d TYPE, --device=TYPE
Specifies the type of the device. The valid arguments to this option are ata, scsi, sat, marvell, 3ware,N, and hpt,L/M, cciss,N or hpt,L/M/N.

了解上面的接口，就可以大概知道怎么选择这个参数了。
* 对于marvell接口，我从来就接触过，所以不说它了。

但是，还有一个很有意思的类型： sat

关于 SAT描述如下 :

The ´sat´ device type is for ATA disks that have a SCSI to ATA Translation (SAT) Layer (SATL) between the disk and the operating system.

为中间产物，也就是可以让SATA接口硬盘接收SCSI的指令集。

至于为什么Linux会把SATA硬盘命名成sdx，是不是因为这个原因我无法查询到相关信息。

RAID

在开始RAID硬件前，还有几个名词要知道：
1. host adapter, 具体请见： http://en.wikipedia.org/wiki/Host_adapter
2. RAID controller, 具体请见： http://en.wikipedia.org/wiki/Disk_array_controller

上面的两个名词和平时所讲的“RAID card“是指同一种设备。

由于RAID把背后的硬盘情况隐藏了，所以SA要取得硬盘的信息就成问题。

从smartctl工具的文档：

http://sourceforge.net/apps/trac/smartmontools/wiki/Supported_RAID-Controllers

可以看出：要得到RAID卡后面硬盘的情况，SA首先从众多的型号中找出满足自己的RAID

至于世界上还有多少还没有RAID卡（芯片）生产商是smartctl目前为止还没有支持的，我也无法查询到

还是，可以肯定的是： SA可以借助生产商自己开发的RAID硬件支持工具。比如这个URL：

http://www.lsi.com/storage_home/products_home/internal_raid/megaraid_scsi/megaraid_scsi_3200/index.html#Miscellaneous

linux kernel and modules

2011-01-04T06:03:00.001-08:00

本文主要是回顾linux modules这部分的管理.

system administrator 使用的模块处理CLI命令主要是如下的工具包:
$ dpkg -S $(which modprobe)
module-init-tools: /sbin/modprobe

kernel module编译

这一篇文章: http://www.cyberciti.biz/tips/compiling-linux-kernel-module.html
讲述了如何编译自己的写的module, 相当不错.
但是少了点"为什么要这样做"的解释

看URL里写的Makefile里的这句话:
make -C /lib/modules/$(KVERSION)/build M=$(PWD) modules

参数M是什么? 参数modules又是什么? gcc怎么没有调用? 为什么可以简单的一行命令可以完成编译?

带着问题去找答案:
$ ls -ld /lib/modules/$(uname -r)/build
lrwxrwxrwx 1 root root 40 2010-03-31 09:43 /lib/modules/2.6.31-21-generic/build -> /usr/src/linux-headers-2.6.31-21-generic

ubuntu下的/usr/src/linux-headers-2.6.31-21-generic目录下的Makefile其实就是kernel代码下的Makefile文件。所以上面的make命令中的modules参数与在kernel代码目录里的modules参数是一致的。

参数"-C"表示进入此目录, 目录下有另一个Makefile文件(/lib/modules/2.6.31-21-generic/build/Makefile), 此Makefile内的一小段代码:

62 # Use make M=dir to specify directory of external module to build
63 # Old syntax make ... SUBDIRS=$PWD is still supported
64 # Setting the environment variable KBUILD_EXTMOD take precedence
65 ifdef SUBDIRS
66 KBUILD_EXTMOD ?= $(SUBDIRS)
67 endif
68
69 ifeq ("$(origin M)", "command line")
70 KBUILD_EXTMOD := $(M)
71 endif

这已经可以解决疑问:
自己写的模块编译Makefile文件只是为/lib/modules/2.6.31-21-generic/build/Makefile 提供两个参数:

directory of external module
"modules"

找个复杂的驱动试试是否为这样, 于是从intel官网下载了e1000e-1.2.20.tar.gz代码

234 ifeq ($(KOBJ),$(KSRC))
235     $(MAKE) -C $(KSRC) SUBDIRS=$(shell pwd) modules
236 else
237     $(MAKE) -C $(KSRC) O=$(KOBJ) SUBDIRS=$(shell pwd) modules
238 endif
239 endif
.......(还有很多不显示).......
274 default:
275     $(MAKE)

下面是编译的具体过程:
jessinio@jessinio-laptop:/tmp/e1000e-1.2.20/src$ make
make -C /lib/modules/2.6.31-21-generic/build SUBDIRS=/tmp/e1000e-1.2.20/src modules
make[1]: Entering directory `/usr/src/linux-headers-2.6.31-21-generic'
CC [M] /tmp/e1000e-1.2.20/src/netdev.o
CC [M] /tmp/e1000e-1.2.20/src/ethtool.o
CC [M] /tmp/e1000e-1.2.20/src/param.o
CC [M] /tmp/e1000e-1.2.20/src/e1000_82571.o
CC [M] /tmp/e1000e-1.2.20/src/e1000_ich8lan.o
CC [M] /tmp/e1000e-1.2.20/src/e1000_80003es2lan.o
CC [M] /tmp/e1000e-1.2.20/src/e1000_mac.o
CC [M] /tmp/e1000e-1.2.20/src/e1000_nvm.o
CC [M] /tmp/e1000e-1.2.20/src/e1000_phy.o
CC [M] /tmp/e1000e-1.2.20/src/e1000_manage.o
CC [M] /tmp/e1000e-1.2.20/src/kcompat.o
LD [M] /tmp/e1000e-1.2.20/src/e1000e.o
Building modules, stage 2.
MODPOST 1 modules
CC      /tmp/e1000e-1.2.20/src/e1000e.mod.o
LD [M] /tmp/e1000e-1.2.20/src/e1000e.ko
make[1]: Leaving directory `/usr/src/linux-headers-2.6.31-21-generic'
jessinio@jessinio-laptop:/tmp/e1000e-1.2.20/src$ lsmod|grep e1000e
jessinio@jessinio-laptop:/tmp/e1000e-1.2.20/src$ sudo insmod e1000e.ko

编译与加载一路通!

insmod和rmmod组合与modprobe的区别

其实大家都知道: modprobe解决module的依赖问题. insmod和rmode不会处理这种依赖问题.

依赖的依据是: `代码中使用的module名`

CLI下可以这样查看:
$ modinfo iptable_filter|grep depends
depends:        ip_tables
被依赖的ip_tables可能又依赖于其它module, 不断的向下查找. 直到depends为NULL.

depmod为处理这种问题的工具:modprobe expects an up-to-date modules.dep file, as generated by depmod
可以看出modprobe和depmod工具的关系.

使用modprobe查看依赖树:
$ modprobe --show-depends iptable_filter
insmod /lib/modules/2.6.31-21-generic/kernel/net/netfilter/x_tables.ko
insmod /lib/modules/2.6.31-21-generic/kernel/net/ipv4/netfilter/ip_tables.ko
insmod /lib/modules/2.6.31-21-generic/kernel/net/ipv4/netfilter/iptable_filter.ko

上面出现的insmod是有先后顺序的.

因为modprobe是使用了modules.dep文件, 所以面对没有放在/lib/modules下或者没有调用depmod命令去更新modules.dep文件, modprobe是无法加载模块的:
# modprobe hello
FATAL: Module hello not found.
# insmod hello.ko
# rmmod hello

modprobe除了可以方便insert和remove模块外, 还有这样一些方便的功能:
1. option
2. alias
这是通过modprobe读取/etc/modprobe.conf( /etc/modprobe.d) 文件完成.

alias主是是用于调用modprobe工具时使用管理者喜欢的模块名代替实现的module名(编译后的模块名)
* alias不会影响 lsmod 命令列出的模块名. lsmod是列出真实的模块名

module有哪些option呢?

$ /sbin/modinfo bnx2|grep parm
parm:           disable_msi:Disable Message Signaled Interrupt (MSI) (int)
parm:           enable_entropy:Allow bnx2 to populate the /dev/random entropy pool (int)

上面列出指定的bnx2网卡module的参数.

kernel编译

jessinio@jessinio-laptop:~/linux-2.6.36.2$ make help|grep oldconfig
oldconfig - Update current config utilising a provided .config as base
silentoldconfig - Same as oldconfig, but quietly, additionally update deps
oldnoconfig - Same as silentoldconfig but set new symbols to n (unset)

这三个参数都是利用旧kernel的configure文件. 例如:
jessinio@jessinio-laptop:~/linux-2.6.36.2$ cp /boot/config-2.6.31-21-generic ./.config

ip route

2010-12-14T07:58:00.001-08:00

笔记
route是什么意思?
这个词的字面意思一直不知道是什么意思。其实这不是一个汉语词汇。汉语词汇里只有一个“路由单” ，为一名词。路由(route)有两种意思：
1. 选择某路线
2. 与"路由单"的意思一致: 指旅途所经历的地名单

选择路线的依据是"目的地".

In the common case, route selection is based completely on the destination address. Conventional (as opposed to policy-based) IP networking relies on only the destination address to select a route for a packet.

但是随着发展, 仅仅是destination方式的route方式不能满足要求:

With the prevalence of low cost bandwidth, easily configured VPN tunnels, and increasing reliance on networks, the technique of selecting a route based solely on the destination IP address range no longer suffices for all situations.

linux对应这种发展的具体落实：

Since kernel 2.2, linux has supported policy based routing through the use of multiple routing tables and the routing policy database (RPDB). Together, they allow a network administrator to conﬁgure a machine select different routing tables and routes based on a number of criteria.

意思大概是如下两件事物:
1. linux支持多routing tables. routing policy database (RPDB)
2. 每张表有独立的规则. policy based routing

平时使用的路由都是由destination成唯一条件(比如使用route命令打印的結果). 那么policy based routing有什么重要呢?

In fact, advanced routing could more accurately be called policy-based networking.

下面的一段话, 描述了linux在路由数据包时, policy based routing使用的多种实现方法

Selectors available for use in policy-based routing are attributes of a packet passing through the linux routing code. The source address of a packet, the ToS ﬂags, an fwmark (a mark carried through the kernel in the data structure representing the packet), and the interface name on which the packet was received are attributes which can be used as selectors. By selecting a routing table based on packet attributes, an administrator can have granular control over the network path of any packet.

selector确定使用那张routing table.

使用人类文字描述Linux选择线路不是很容易理解, 如下一段伪代码比较好：
if packet.routeCacheLookupKey in routeCache :
   route = routeCache[ packet.routeCacheLookupKey ]
else
   for rule in rpdb :
       if packet.rpdbLookupKey in rule : (rule为下表的RPDB对象)
           routeTable = rule[ lookupTable ] (routeTable为下表的route table对象)
           if packet.routeLookupKey in routeTable :
                route = route_table[ packet.routeLookup_key ]

把rpdb为routing table, 规则(rule)都在DB中，每条rule有不同的属性(这里的属性包括上面提到的attributes).

伪代码中的LookupKey是代表下表中具体的一条属性. 所以, 其实上面的伪代码是很N多if语句的.

* 斜体字的属性是可选的. 如果存在就判断, 不存在不判断.

从上面的可以知道, route table起到:
1. 组织rule的作用
2. 同类的rule会拥有一组属性.

从上面的表中可以知道, 每个packet的destination和source是必定被用于路由, 但是不唯一确定条件.

linux system administrator查看上面的三种数据的方法:
1. route cache 表: ip route show cache
2. 每张RPDB表: ip rule list table 表名
3. 列出全部route table: ip rule show

ethernet

2010-12-12T20:01:00.001-08:00

开始

以太网层本时很少关注. 最近一次关注是理解LVS时. 最近在看<<Guide to IP Layer Network
Administration with Linux>>, 做做笔记, 随便动动手. 加深记忆.

被操作的机器上只有网关的物理地址:
$ arp -n
Address                  HWtype HWaddress           Flags Mask            Iface
10.20.129.1              ether   00:0F:E2:D3:BE:B8   C                     eth0

进行如下动作:
$ ping 10.20.129.32

把ping动作发出的包抓下来

$ sudo tcpdump -ent -i eth0 arp or icmp

....(截掉).....
00:23:ae:93:d9:26 > Broadcast, ethertype ARP (0x0806), length 42: arp who-has 10.20.129.32 tell 10.20.129.19
00:1e:4f:ad:41:58 > 00:23:ae:93:d9:26, ethertype ARP (0x0806), length 60: arp reply 10.20.129.32 is-at 00:1e:4f:ad:41:58
00:23:ae:93:d9:26 > 00:1e:4f:ad:41:58, ethertype IPv4 (0x0800), length 98: 10.20.129.19 > 10.20.129.32: ICMP echo request, id 26119, seq 1, length 64
00:1e:4f:ad:41:58 > 00:23:ae:93:d9:26, ethertype IPv4 (0x0800), length 98: 10.20.129.32 > 10.20.129.19: ICMP echo reply, id 26119, seq 1, length 64
....(截掉).....

ICMP包在ethernet层之上, 需要使用ethernet发数据, 需要物理地址. 为了得到物理地址使用到ARP协议.

ARP过程与如下命令一致: $ sudo arping -I eth0 10.20.129.32这一条命令表示向网段内查询某IP对应的MAC地址.
查看ARP表:
$ arp -n
Address                  HWtype HWaddress           Flags Mask            Iface
10.20.129.1              ether   00:0F:E2:D3:BE:B8   C                     eth0
10.20.129.32             ether   00:1E:4F:AD:41:58   C                     eth0
增加了一个记录

arping命令 -A 参数: ARP announcement, 也称为gratuitous ARP

$ sudo arping -A -c 3 -I eth0 10.20.129.19
tcpdump的抓包结果:
00:23:ae:93:d9:26 > Broadcast, ethertype ARP (0x0806), length 42: arp reply 10.20.129.19 is-at 00:23:ae:93:d9:26
00:23:ae:93:d9:26 > Broadcast, ethertype ARP (0x0806), length 42: arp reply 10.20.129.19 is-at 00:23:ae:93:d9:26
00:23:ae:93:d9:26 > Broadcast, ethertype ARP (0x0806), length 42: arp reply 10.20.129.19 is-at 00:23:ae:93:d9:26

从上面的信息看出, -A是向整个网段通知自己的IP. 默认情况下, linux 不会接受这样的包.
由arp_accept选项控制, 如下文档:

arp_accept - BOOLEAN
    Define behavior for gratuitous ARP frames who's IP is not
    already present in the ARP table:
    0 - don't create new entries in the ARP table
    1 - create new entries in the ARP table

如果看知道 gratuitous ARP 包的具体用法，可以移步到： http://wiki.wireshark.org/Gratuitous_ARP

arping命令 -D 参数: Duplicate address detection mode (DAD)

这个参数相当有用: 用于排除网段中有IP冲突. 来个实例:

root@jessinio-laptop:~# ifconfig wlan0 |head -n 2
wlan0 Link encap:Ethernet HWaddr 00:16:cf:68:5b:a7
inet addr:192.168.0.106 Bcast:192.168.0.255 Mask:255.255.255.0

root@jessinio-laptop:~# arping -D -I wlan0 192.168.0.106
ARPING 192.168.0.106 from 0.0.0.0 wlan0
Unicast reply from 192.168.0.106 [00:18:41:FE:26:5F] 90.390ms
Sent 1 probes (1 broadcast(s))
Received 1 response(s)

可以看出, 192.168.0.106 被两台机器使用, 一台是本志的00:16:cf:68:5b:a7 , 另一台是00:18:41:FE:26:5F.

抓包信息:
00:16:cf:68:5b:a7 > ff:ff:ff:ff:ff:ff, ethertype ARP (0x0806), length 42: Request who-has 192.168.0.106 (ff:ff:ff:ff:ff:ff) tell 0.0.0.0, length 28
00:18:41:fe:26:5f > 00:16:cf:68:5b:a7, ethertype ARP (0x0806), length 42: Reply 192.168.0.106 is-at 00:18:41:fe:26:5f, length 28

结束

以一个问题为结束: 使用ICMP协议能否得知网段中有其它机器使用自己的IP呢? 比如, ping自己的IP.

答案是不可以的. 因为ICMP包基本没有发出来. 回流了. 例如:

$ ping 10.20.129.19
产生的数据包不会流过ethernet卡, 从route表就可以知道:

$ ip route list table local
broadcast 127.255.255.255 dev lo proto kernel scope link src 127.0.0.1
broadcast 10.20.129.0 dev eth0 proto kernel scope link src 10.20.129.19
local 10.20.129.19 dev eth0 proto kernel scope host src 10.20.129.19
broadcast 10.20.129.127 dev eth0 proto kernel scope link src 10.20.129.19
broadcast 127.0.0.0 dev lo proto kernel scope link src 127.0.0.1
local 127.0.0.1 dev lo proto kernel scope host src 127.0.0.1
local 127.0.0.0/8 dev lo proto kernel scope host src 127.0.0.1

iptables与流量统计

2010-11-26T23:29:00.001-08:00

要对机房某台机器进行临时性的内、外网流量统计分开。这种事最好不要放到应用层统计，因为效率很成问题。第一时间想到处于网络二、三层的工具，效率不会被过多影响。如ntop之类使用libpcap库的工具。
其实iptables也是有包统计。因为每个包都经过它。而且不用安装任何工具。

加入两条规则：
jessinio@jessinio-laptop:~$ sudo iptables -t filter -A INPUT -p all -s 174.121.79.132 -j ACCEPT
jessinio@jessinio-laptop:~$ sudo iptables -t filter -A OUTPUT -p all -d 174.121.79.132 -j ACCEPT

情况：
jessinio@jessinio-laptop:~$ sudo iptables -L
Chain INPUT (policy ACCEPT)
target     prot opt source               destination
ACCEPT     all -- web124.webfaction.com anywhere

Chain FORWARD (policy ACCEPT)
target     prot opt source               destination

Chain OUTPUT (policy ACCEPT)
target     prot opt source               destination
ACCEPT     all -- anywhere             web124.webfaction.com

結果：
jessinio@jessinio-laptop:~$ sudo iptables -L -n -v
Chain INPUT (policy ACCEPT 11M packets, 5033M bytes)
pkts bytes target     prot opt in     out     source               destination
   10 2088 ACCEPT     all -- *      *       174.121.79.132       0.0.0.0/0

Chain FORWARD (policy ACCEPT 0 packets, 0 bytes)
pkts bytes target     prot opt in     out     source               destination

Chain OUTPUT (policy ACCEPT 14M packets, 14G bytes)
pkts bytes target     prot opt in     out     source               destination
   48 25152 ACCEPT     all -- *      *       0.0.0.0/0            174.121.79.132

seteuid

2010-11-18T22:00:00.001-08:00

# ps axjf|grep -v grep|grep ftp
    1 13871 13871 13871 ?           -1 Ss       0   0:00 /usr/sbin/vsftpd /etc/vsftpd/vsftpd.conf
13871 14146 14146 14146 ?           -1 Ss      99   0:00 \_ /usr/sbin/vsftpd /etc/vsftpd/vsftpd.conf
14146 14148 14146 14146 ?           -1 S      509   0:00      \_ /usr/sbin/vsftpd /etc/vsftpd/vsftpd.conf

id是99进程可以产生id为509的进程，原来fork后，子进程还是可以调用seteuid切到其它uid的，这之前还不知道。如下测试代码：

#!/usr/bin/python
#coding:utf-8

import os
import time

# 同一进程可以从0转成其它的
os.seteuid(99)
os.seteuid(0)

os.seteuid(99)
pid = os.fork()
# child
if pid == 0:
    # 子进程还是可以使用seteuid回到0的
    os.seteuid(0)
    time.sleep(10)
else:
    print pid
    time.sleep(10)

运行结果：

[jessinio@niowork tmp]$ ps axuf|grep root.py
nobody   28559 0.0 0.0 74192 2912 pts/11   T    13:56   0:00 |   \_ python root.py
root     28560 0.0 0.0 74188 1756 pts/11   T    13:56   0:00 |   |        \_ python root.py

使用strace找出问题根本点

2010-11-04T20:19:00.001-07:00

今天想备份一个svn仓库。但是碰到“鬼”了。如下：
$ sudo -u daemon HOME=/tmp /usr/local/subversion/bin/svnsync sync file:///data/repos/xxoo
svnsync: Revprop change blocked by pre-revprop-change hook (exit code 255) with no output.

看上去是svn的pre-revprop-change hook出了问题。但是无论我怎么折腾pre-revprop-change hook代码都不给力。

又怀疑是环境变量，连sudo的-E都使用上了还是一个屁用。

无奈下只能使用strace看看：
$ sudo -u daemon HOME=/tmp strace -f /usr/local/subversion/bin/svnsync sync file:///data/repos/xxoo 2>&1 |less

一定要使用-f，因为svnsync产生了子进程，这样可以连子进程都可以被trace。

看到一句相当可疑的trace条目：
[pid 6548] chdir(".") = -1 EACCES (Permission denied)

呃。。。。。细节。原来work directory是~, 切换成daemon运行的svnsync没有权限。。。。。

这样就没有问题了：
$ cd / && sudo -u daemon HOME=/tmp /usr/local/subversion/bin/svnsync sync file:///data/repos/xxoo

真是细节。

devfs与udev

2010-10-14T19:36:00.001-07:00

/dev 目录disk-based还是kernel-based的文件系统?
这个问题一直没有分开.
从自己的实践和<<Linux操作系统之奥秘>>一书, 明显/dev是disk-based的. 本人没有使用过devfs

linux2.4 kernel时代使用devfs文件系统. linux 2.6 kernel已经去掉devfs代码了.

想查查devfs的文档都不容易, 它的作者旧blog上的文章都找不到了.

google到
* http://www.linuxjournal.com/article/6035
* http://www.ibm.com/developerworks/linux/library/l-devfs.html
从时间上看很老的, 为了确认年代, 查看了kernel的timeline, 可以确认这是"同一时代"的产物:
* http://en.wikipedia.org/wiki/Linux_kernel#Timeline

没有用过devfs. 为了求真相, 问朋友借了个redhat8环境的linux, 结果devfs没有被默认编入kernel:
# cat /boot/config-2.4.18-14 |grep DEVFS
# CONFIG_DEVFS_FS is not set

但是redhat8下的/dev的确有18 thousand entries (比较惊人)
/dev 目录disk-based还是kernel-based的文件系统? 这个问题没有环境都没法亲眼看到. 主能找到的文档里找, 有些文件是使用pseudo filesystem称呼devfs的(例如这篇: http://www.linux.org/docs/ldp/howto/SCSI-2.4-HOWTO/devfs.html)

在 http://www.linuxjournal.com/article/6035 一文中, 描述了使用devfs的好处:
1. 系统自动管理/dev下的文件
2. 可以被read only 的方法mount到系统和/dev创建在non-unix file system上

文档特殊提到了non-unix file system. 因为dev entry是还有一些额外的信息. 下面在fat32文件系统上创建一个dev entry:

[jessinio@niowork NO_NAME]$ sudo mknod dev_entry c 240 1
mknod: `dev_entry': Operation not permitted

可以确定devfs一个存在于内存的文件系统.

devfs已经被淘汰, 被udev取代. udev比devfs带来什么好处?
如果想仔细了解有什么优点, 请阅读udev作者写的文章: http://www.kernel.org/pub/linux/utils/kernel/hotplug/udev_vs_devfs

比较深刻的是两条:
1. 可以随意命名设备文件在/dev下的entry名
2. allow everyone to not care about major/minor numbers

到这里, 又需要把视线转移到sysfs上面了.

足够数目的getdents调用与文件数目引发的问题

2010-10-11T00:05:00.001-07:00

网站的速度很慢。要求给个理由。于是登机top了一把。如下

PID USER      PR NI VIRT RES SHR S %CPU %MEM    TIME+ COMMAND
29131 liangqin 16   0 15068 3444 816 R 11.7 0.0   0:00.72 top
16371 kmmaster 16   0 181m 8484 3128 D 5.2 0.1   0:01.20 httpd
5726 kmmaster 15   0 182m 9352 3564 S 3.9 0.1   0:02.24 httpd
32548 kmmaster 16   0 183m 9.8m 3348 D 3.9 0.1   0:06.16 httpd
6199 kmmaster 16   0 183m 9444 3452 D 2.6 0.1   0:01.89 httpd
7697 kmmaster 16   0 182m 8848 3184 D 2.6 0.1   0:01.94 httpd
10536 kmmaster 16   0 181m 8692 3332 D 2.6 0.1   0:01.93 httpd
15102 kmmaster 16   0 181m 8420 3060 D 2.6 0.1   0:01.37 httpd
17993 kmmaster 16   0 181m 8708 3292 D 2.6 0.1   0:04.16 httpd
23185 kmmaster 16   0 182m 9420 3428 D 2.6 0.1   0:00.61 httpd
30189 kmmaster 16   0 181m 8724 3308 D 2.6 0.1   0:05.91 httpd
30337 kmmaster 16   0 183m 9.9m 3448 D 2.6 0.1   0:02.71 httpd

使用strace命令查看D状态的httpd, 都是调用getdents, stat, unlink等IO函数，如：
stat("/tmp/sess_bc45d5d1dd8739acceff8a3e0fec0585", {st_mode=S_IFREG|0600, st_size=0, ...}) = 0

使用ls， find之类的工具都无法对此目录(指/tmp)进行数据查看。行为freeze。也是进入D状态。

本想使用python的os.listdir函数的。但这个函数是读完目录的entry后才返回list的。也是要慢很长时间。

于是使用下面的C代码：
#include <sys/types.h>
#include <dirent.h>
#include <stdio.h>

int main(int argc, char * argv[])
{
        DIR *dirp = opendir("/tmp");
        struct dirent *retval;
        long long int t;
        for(; ; ){
                retval = readdir(dirp);
                if (retval == NULL) {break;}
                else {printf("%s\n", retval->d_name); t++;}
        }
        printf("%lld\n", t);
}
可以知道目录文件总数是 221346

httpd的进程数有3K！每个需要session的进程都要读/tmp目录下的entry，这个行为会对3K数目的httpd进程有很大的影响吗？

于是自己写了个测试代码，目的就是测试众多的readdir函数是否对进程有影响：
#coding:utf-8
import time
import os

for i in range(300):
    pid = os.fork()
    if pid > 0:
        break

for r in range(30):
    time.sleep(0.1)
    os.listdir("/tmp")

代码很简单，但是对于200K条目的directory来说，很给力！！出现大量的D状态进程：
(........被截去......)
905       7072 0.1 0.0 84244 11628 pts/2    D+   14:45   0:00 python listdir.py
905       7073 0.1 0.1 85136 12448 pts/2    D+   14:45   0:00 python listdir.py
905       7074 0.1 0.1 85136 12628 pts/2    D+   14:45   0:00 python listdir.py
905       7075 0.1 0.1 86304 13588 pts/2    D+   14:45   0:00 python listdir.py
905       7076 0.1 0.0 84764 12264 pts/2    D+   14:45   0:00 python listdir.py
905       7077 0.1 0.0 84504 12036 pts/2    D+   14:45   0:00 python listdir.py
905       7078 0.1 0.1 85136 12672 pts/2    D+   14:45   0:00 python listdir.py
905       7079 0.1 0.1 85916 13360 pts/2    D+   14:45   0:00 python listdir.py
905       7080 0.1 0.1 85916 13448 pts/2    D+   14:45   0:00 python listdir.py
905       7081 0.2 0.1 89728 16964 pts/2    D+   14:45   0:00 python listdir.py
905       7082 0.2 0.1 88268 15776 pts/2    D+   14:45   0:00 python listdir.py
905       7083 0.2 0.1 88268 15596 pts/2    D+   14:45   0:00 python listdir.py
905       7084 0.2 0.1 87344 14820 pts/2    D+   14:45   0:00 python listdir.py
905       7085 0.1 0.1 85136 12628 pts/2    D+   14:45   0:00 python listdir.py
905       7086 0.2 0.1 86304 13812 pts/2    D+   14:45   0:00 python listdir.py
(......被截去.......)

机器的内存使用量快速上升。

broadcast

2010-10-06T00:38:00.001-07:00

很少使用UDP协议和原始数据包，所以对broadcast这种特殊地址使用不多。
知识总是关联在一起的。今天在看LVS-DR模式的配置时，发现对下面的配置有些不理解：

# ifconfig lo:0 IP_Adress broadcast IP_Adress netmask 255.255.255.255 up
# route add -host IP_Adress dev lo:0
* IP_Adress为IP地址。

如果只是为了配置LVS的话，就不需要理会上面的语句背后的原理，但作为技术控，很希望可以知道它背后后原理。

結果发现背后是好大一个坑，最经典的问题就是LVS的ARP问题：
* http://www.austintek.com/LVS/LVS-HOWTO/HOWTO/LVS-HOWTO.arp_problem.html
都与broadcast有关系. 先对broadcast下手:

为什么 broadcast与IP_Adress相同，而不是常用的172.16.2.255这种特殊IP？
首先， broadcast有如下几种：
1. layer 2 broadcast
2. layer 3 broadcast
3. unicast
4. multicast

要知道broadcast的作用是"一对多", 一台机器发出的数据多台机器有兴趣接收. 这种特点是TCP协议没有的.
下面使用UDP协议来举个layer 3的例子:
接收端(调用bind函数), 这一端的机器可以多台:
import socket
import sys
x = ('<broadcast>', 51423)

s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
s.setsockopt(socket.SOL_SOCKET, socket.SO_BROADCAST, 1)
s.bind(x)
(buf, address) = s.recvfrom(2048)
s.sendto("Hi", address)

发送端(调用send函数):
import socket
import sys
x = ('<broadcast>', 51423)

s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
s.setsockopt(socket.SOL_SOCKET, socket.SO_BROADCAST, 1)
s.sendto("Hi", x)
(buf, address) = s.recvfrom(2048)
print "Received from %s: %s" % (address, buf)

send端使用的'<broadcast>' 很另类: 不是使用具体的IP地址, 而是使用代名词.
回到上面的ifconfig例子, 这个'<broadcast>' 其实就是NIC里的broadcast参数.
如果NIC的参数不同, '<broadcast>' 代表的意义就不同.
从发送端看:
send函数发出的数据包里的destination地址为'<broadcast>'
从接收端看:
recvfrom函数只接收destination地址为NIC里'<broadcast>' 参数的广播包.

所以, 上面的ifconfig设置明显是不想服务器接收layer 3的广播信息( 例如destination为192.168.0.255这种数据包)

从netmask的角度可以这样思考:
ifconfig lo:0 192.168.0.10 broadcast 192.168.0.10 netmask 255.255.255.255可以变形成ifconfig lo:0 192.168.0.10 netmask 255.255.255.255
它们与
ifconfig lo:0 192.168.0.10 netmask 255.255.255.0
是属于不同的subnet, 所以192.168.0.0/24的信息对于网段192.168.0.0/32是不会接收的

这种单一的广播地址被称为 unicast
broadcast还有layer 2的. 典型的例子就是arp协议. 使用的以太网广播地址: FF.FF.FF.FF.FF.FF 作为destination

linux下没有CLI接口的命令可以发出arp请求包. 因为arp功能放在kernel中(可以看手册man 7 arp), layer 3的数据压到layer 2时kernel为自动调用arp请求包(如果是需求的话).
如果要手动发出这种请求也是可以的, 比如这段代码: http://svn.pythonfr.org/public/pythonfr/utils/network/arp-flood.py

当ping一个IP时, 系统的arp表示里没有与IP对应的条目时kernel是会发出arp请求包的, 所以为了测试, 可以在清除arp条目的情况下,在两机之间ping对方.
如下代码:
import socket
soc = socket.socket(socket.PF_PACKET, socket.SOCK_RAW) #create the raw-socket
soc.bind(("wlan0",0x0806)) # ether type for ARP
data = soc.recv(1024)

程序属于接收端, 程序运行后会一直block, 直到接收到一个arp请求. 向子网的所有机器询问的MAC, 所以是"一对多", 这时就需要使用到广播地址, layer 2的广播地址为FF.FF.FF.FF.FF.FF.

与layer 3相比, layer 2的广播地址不是在NIC上配置的, 但是LVS-DR模式又希望real server不要响应和发出arp请求, 于是, LVS-DR的arp问题就产生了. 也就是文章开头的route add命令的原理. 至于这个原理这里就不写了. 认真阅读下面的文章即可, 下面的文章涉及了linux kernel的多个版本, 如2.0.x, 2.2.x, 2.6.x.
http://www.austintek.com/LVS/LVS-HOWTO/HOWTO/LVS-HOWTO.arp_problem.html

route table

2010-10-04T23:43:00.001-07:00

平时在了解系统的route表和配置系统的route表时, 都是比较喜欢使用route这个命令的. 但是, 本人感觉到此命令输出的結果与一些讲解系统网络的资料对不上号的, 例如:

在Routing Decision处就和route命令的输出結果对不上号:
jessinio@jessinio-laptop:~$ route -n
Kernel IP routing table
Destination     Gateway         Genmask         Flags Metric Ref    Use Iface
192.168.0.0     0.0.0.0         255.255.255.0   U     2      0        0 wlan0
169.254.0.0     0.0.0.0         255.255.0.0     U     1000   0        0 wlan0
0.0.0.0         192.168.0.1     0.0.0.0         UG    0      0        0 wlan0

結果很明显, route输出的結果只是系统发向外面的数据包的routing, 没有陈述数据包进入系统的routing.

这种感觉待续了很久一段时间. 今天看到这样一段话:

Linux has a different approach for routing than other UNIX. The way things are implemented on Linux is more flexible and powerful than traditional ways. Legacy utilities such as ifconfig and route are still valid, but incomplete. This is because they do not give access to the advanced routing layer present on Linux. The utility ip (part of iproute2) is the current tool for networking related stuff under Linux. This tool will be the focus of this section.

文字中提到了,route命令得到的其实是不完全的数据. 在Linux下, 最本地化的应该是ip命令.
google找到一份很老的文档： http://linux-ip.net/html/routing-tables.html 上面写得很清楚了, 如下一小段：

The routing table manipulated by the conventional route command is the main routing table. Additionally, the use of both ip address and ifconfig will cause the kernel to alter the local routing table (and usually the main routing table). For further documentation on how to manipulate the other routing tables, see the command description of ip route.

route命令得到和设置的仅仅是冰山一角。

iproute2工具集手册：http://www.policyrouting.org/iproute2.doc.html

block size

2010-09-11T23:43:00.001-07:00

多处都存在block size，概念同名但是意义不同，相当迷惑
这哥们就是一个被迷惑的人： http://www.linuxforums.org/forum/misc/5654-linux-disk-block-size-help-please.html

上面的URL列出了如下几种block:
1. Hardware block size, "sector size"
2. Filesystem block size, "block size"
3. Kernel buffer cache block size, "block size"
4. Partition table block size, "cylinder size"

我对fdisk打印的blocks一栏很不解. 需要dig一下.
先来看看fdisk打印出来的block：

jessinio@jessinio-laptop:/ $ sudo fdisk -l
Disk /dev/sda: 250.1 GB, 250059350016 bytes
255 heads, 63 sectors/track, 30401 cylinders
Units = cylinders of 16065 * 512 = 8225280 bytes
Disk identifier: 0x00038329

   Device Boot      Start         End      Blocks   Id System
/dev/sda1   *           1         100      803218+ 83 Linux
/dev/sda2             101       30401   243392782+ 8e Linux LVM

上面的内容和下面的是一致的：
jessinio@jessinio-laptop:/media/82d236f2-3592-4040-801c-3c2049ddfb95$ sudo fdisk -b 512 -l
Warning: the -b (set sector size) option should be used with one specified device
Disk /dev/sda: 250.1 GB, 250059350016 bytes
255 heads, 63 sectors/track, 30401 cylinders
Units = cylinders of 16065 * 512 = 8225280 bytes
Disk identifier: 0x00038329

   Device Boot      Start         End      Blocks   Id System
/dev/sda1   *           1         100      803218+ 83 Linux
/dev/sda2             101       30401   243392782+ 8e Linux LVM

但是下面的就比较奇怪了：
jessinio@jessinio-laptop:/media/82d236f2-3592-4040-801c-3c2049ddfb95$ sudo fdisk -b 1024 -l
Warning: the -b (set sector size) option should be used with one specified device
Disk /dev/sda: 250.1 GB, 250059350016 bytes
255 heads, 63 sectors/track, 15200 cylinders
Units = cylinders of 16065 * 1024 = 16450560 bytes
Disk identifier: 0x00038329

   Device Boot      Start         End      Blocks   Id System
/dev/sda1   *           1         100     1606437   83 Linux
/dev/sda2             101       30401   486785565   8e Linux LVM

指定更大的硬件sector size反而block增加, 这是为什么呢?。下面是fdisk的相关代码：
sector_size变量的来源：
759 static void
760 get_sectorsize(int fd) {
761 #if defined(BLKSSZGET)
762     if (!user_set_sector_size &&
763         linux_version_code() >= MAKE_VERSION(2,3,3)) {
764         int arg;
765         if (ioctl(fd, BLKSSZGET, &arg) == 0)
766             sector_size = arg;
767         if (sector_size != DEFAULT_SECTOR_SIZE)
768             printf(_("Note: sector size is %d (not %d)\n"),
769                    sector_size, DEFAULT_SECTOR_SIZE);
770     }
771 #else
772     /* maybe the user specified it; and otherwise we still
773        have the DEFAULT_SECTOR_SIZE default */
774 #endif
775 }
DEFAULT_SECTOR_SIZE 在fdisk.h中定义是
#define DEFAULT_SECTOR_SIZE     512

或者是用户指定的user_set_sector_size：sector_size = atoi(optarg);

打印时使用的代码是：
1731             unsigned int psects = get_nr_sects(p);
1732             unsigned int pblocks = psects;
1733             unsigned int podd = 0;
1734
1735             if (sector_size < 1024) {
1736                 pblocks /= (1024 / sector_size);
1737                 podd = psects % (1024 / sector_size);
1738             }
1739             if (sector_size > 1024)
1740                 pblocks *= (sector_size / 1024);
1741                         printf(
1742                 "%s %c %11lu %11lu %11lu%c %2x %s\n",
1743             partname(disk_device, i+1, w+2),
1744 /* boot flag */     !p->boot_ind ? ' ' : p->boot_ind == ACTIVE_FLAG
1745             ? '*' : '?',
1746 /* start */     (unsigned long) cround(get_partition_start(pe)),
1747 /* end */       (unsigned long) cround(get_partition_start(pe) + psects
1748                 - (psects ? 1 : 0)),
1749 /* odd flag on end */   (unsigned long) pblocks, podd ? '+' : ' ',
1750 /* type id */       p->sys_ind,
1751 /* type name */     (type = partition_type(p->sys_ind)) ?
1752             type : _("Unknown"));
1753             check_consistency(p, i);

1. 当sector_size刚好等于1024时，打印出的正好是sector的数目。也是partition的大小(同size概念)
2. 当sector_size不等于1024时，把sector数目和sector_size结合起来換算成大小(同size概念)

可见， fdisk打印的Blocks一栏其实是partition的大小。下面测试一下：

$ sudo mount /dev/sda1 /media/disk/
$ df /media/disk/
Filesystem           1K-blocks      Used Available Use% Mounted on
/dev/sda1               790556     48176    702220   7% /media/disk
790556 是文件系统总大小。
上面的fdisk -b 1024 -l 命令得到的1606437是sector的数目。这样计算：

1606437 * 512 / 1024 =803218 是约等于790556 的。partition的大小是比file system大是因为file system需要存放一些信息.

总

1. 要想得到一个partition占有用多少个sector的话, 可以使用fdisk -b 1024这种方式得到
2. 不加-b参数的fdisk命令打印的Blocks一栏其实是表示partition的大小(以K为单位)
3. 还没有能力找出Kernel buffer cache block size, "block size" 这一条的实际代码

pkg-config

2010-09-08T22:23:00.001-07:00

感觉centOS上的fuse版本太低，还是从源代码安装。

简单编译后：
./configure --prefix=/usr/local/fuse

fuse-python-binding就无法安装。问题是fuse-python-binding的setup.py需要使用pkg-config取得编译参数。

pkg-config --list-all |grep fuse
无法找到pkg-config需要的*.pc metainfornation文件。

可以手工增加：

$ PKG_CONFIG_PATH=/usr/local/fuse/lib/pkgconfig/ pkg-config --list-all |grep fuse
fuse fuse - Filesystem in Userspace

所以，下面的方法可以安装：
$ sudo PKG_CONFIG_PATH=/usr/local/fuse/lib/pkgconfig/ python setup.py install

[jessinio@niowork site-packages]$ /usr/local/python2.6/bin/python -c "import fuse"
Traceback (most recent call last):
File "<string>", line 1, in <module>
File "fuse.py", line 27, in <module>
from fuseparts._fuse import main, FuseGetContext, FuseInvalidate
ImportError: libfuse.so.2: cannot open shared object file: No such file or directory

需要增加lib路径：
$ sudo sh -c "echo /usr/local/fuse/lib >> /etc/ld.so.conf.d/fuse.conf "
$ sudo ldconfig

prefork服务器方式

2010-09-04T01:37:00.001-07:00

WEB服务器一般都有两种模式处理动态服务:
1. prefork
2. thread

一种是使用多进程, 另一种是使用多线程. 它们的具体的实现方式自己其实并不清楚.
最近公司的python WEB服务使用较多的内存. 为了清楚其中的问题. 需要学习flup(django需要此库)代码. ( 人家写的代码实在好看 )

很多软件都有prefork方式, 下面是prefork模型:

每个nginx子进程都分别调用accept得到用户发来的80端口请求.
之所以每个子进程都可以调用accept得到同一个socket的请求, 是因为fork出的子进程的file descriptor是指向同一个实体.

这样实现了多进程竟争得到socket请求.

每个子进程又可以使用epoll, 线程等方式并发处理众多来自80端口的请求. fast cgi server也是类似的方法.
nginx与fast cgi server之间使用socket通信, 使用fast cgi协议.

每个flup work某一时刻只服务一个页面请求. 完成请求后可以重新接受请求.

使用prefork模型的方式。所以在PreforkServer类中。

父进程的主体是一个loop:

119         # Main loop.
120         while self._keepGoing:
121             # Maintain minimum number of children.
122             while len(self._children) < self._maxSpare:
123                 if not self._spawnChild(sock): break

可以看出，父进程是永远期待子进程的数目为一个数值的。这个数值为maxSpare
粗粗看上去，有些野。但是父进程是有回收子进程的策略的，如下：

169             # See who and how many children are available.
170             availList = filter(lambda x: x[1]['avail'],
self._children.items())
171             avail = len(availList)

上面的代码可以知道，父进程会一直收集可用的子进程。所谓可用是没有在工作
的子进程，可以从子进程的代码中看出, 如下：
370             # Notify parent we're no longer available.
371             self._notifyParent(parent, '\x00')
372
373             # Do the job.
374             self._jobClass(clientSock, addr, *self._jobArgs).run()

上面的代码是子进程在调用jobClass.run之前，通知父进程自己是 no longer
available的。

父进程维护着“可用的子进程“数目是为了可以了解负载情况，判断是否需要产生
更多的子进程，如下：
172
173             if avail < self._minSpare:
174                 # Need to spawn more children.
175                 while avail < self._minSpare and \
176                       len(self._children) < self._maxChildren:
177                     if not self._spawnChild(sock): break
178                     avail += 1

上面的代码使用了两个数据： minSpare和maxChildren。

minSpare是表示最少“可用子进程“数
maxChildren是表示最大“子进程”数，是空闲与工作的子进程总数

如果“可用子进程”数还剩一定数据，会被回收，如下：

179             elif avail > self._maxSpare:
180                 # Too many spares, kill off the extras.
181                 pids = [x[0] for x in availList]
182                 pids.sort()
183                 pids = pids[self._maxSpare:]
184                 for pid in pids:
185                     d = self._children[pid]
186                     d['file'].close()
187                     d['file'] = None
188                     d['avail'] = False

从上面的代码可以看到， fast cgi在启动时的使用到的三个参数的作用应该是：
minspare: 最小“空闲进程数“
maxspare: 常规进程数，即fast cgi启动后， fastcgi进程数是大于等于此值
maxChildren: 最大进程数，此值主要是用于防止内存被使用完的。

父类方法使用子类的方法与数据

2010-09-03T21:55:00.001-07:00

对OO其实是不懂, 只是会一个class( 模式说白了不会. 接口是学了go语言才知道是什么. (-_-)! )

今天在看flup项目的代码时, 有一段发码看不懂. 其实是自己对OO的不懂:

1 #coding:utf-8
2
3 class Parent(object):
4     def __init__(self, name):
5         self._name = "\t父类: %s" % name
6     def whoami(self):
7         print self._name
8         print "在父类方面中调用子类的方法:"
9         self._print()
10
11
12 class Child(Parent):
13     def __init__(self, name):
14         self._nickname = "\t子类：%s" % name
15         Parent.__init__(self, "大明")
16
17     def _print(self):
18         print self._nickname
19
20     def run(self):
21         # 下面的两种调用方法是一样的
22         print "使用Parent.method(self)的方法调用父类方法"
23         Parent.whoami(self)
24         print "使用self.method()的方法调用父类方法"
25         self.whoami()
26
27
28
29 if __name__ == "__main__":
30     c = Child("小明")
31     c.run()

平时一般都是使用self.whoami(), 自为发父方法无法使用子类的东西. 但是如果使用Parent.whoami(self) 的方式, 就会明白自己的理解其实是错的.

基本问题是自己没有对书中的Parent.__init__(self, "大明") 一句理解到位

嗯.... 自己的水平太差了.

python2.4与2.5的异常基类变化

2010-08-15T22:55:00.001-07:00

工作中，有一服务需要从freeBSD迁移到centOS上。其中有一python脚本有些鬼异。
在freeBSD上可以正常，在centOS上不能正常。最后目标定位在脚本最后的代码上，大概如下：

try:
    if 测试条件:
       do_someting()
       sys.exit(0)
   else:
       sys.exit(1)
except Exception:
        sys.exit(1)

centOS上， python的版本是2.4的。 freeBSD下安装的是2.5.
旧版本的Exception是基类：因此在2.4上脚本永远是返回1的。
到了新的版本BaseException才是基类：因此SystemExit和Exception是同一级。脚本可以返回0

这是迁移后的主要问题。其实，应该是作者不知道sys.exit的后果。作者把sys.exit当成os._exit了。
如下是APUE里的一幅图：

标准C里的exit函数在调用后，不是马上退出程序，而是运行一些收尾工作。比如把buffer里的数据flush到磁盘等等工作。然后才是调用真正的退出函数：_exit

python的sys.exit是抛出一个异常：SystemExit， python会默认会catch这个异常，大意为：

try:
我们的python代码
exception SystemExit:
做一些收尾工作，如flush之类的

递归, 循环, 迭代

2010-08-15T09:35:00.001-07:00

工作中, 需要有历遍目录进行一些操作. python自带的os.walk很强大, 但是没有maxdepth这种层数参数.

os.walk是原本是一个递归. 下面是它的代码:
273     try:
274         # Note that listdir and error are globals in this module due
275         # to earlier import-*.
276         names = listdir(top)
277     except error, err:
278         if onerror is not None:
279             onerror(err)
280         return
281
282     dirs, nondirs = [], []
283     for name in names:
284         if isdir(join(top, name)):
285             dirs.append(name)
286         else:
287             nondirs.append(name)
288
289     if topdown:
290         yield top, dirs, nondirs
291     for name in dirs:
292         path = join(top, name)
293         if followlinks or not islink(path):
294             for x in walk(path, topdown, onerror, followlinks):
295                 yield x
296     if not topdown:
297         yield top, dirs, nondirs

BTW:: 这里需要注意*nux的ENAMETOOLONG 错误.

递归无法按"层"历遍目录. 它只能一条一条路径走尽.

朋友说使用循环也可以实现递归, 这种代码从来没有写过. 也一直在迷惑。
但是受 http://www.devshed.com/c/a/Python/Basic-Threading-in-Python/2/ 的启发.
突然明白循环是怎么做到递归的。于是自己使用循环自己写了一个历遍的函数:

def loop_walk(top, n):
    stack = Queue.Queue()
    sub_stack = Queue.Queue()
    dirs = []
    files = []
    error = None
    stack.put([top])

    while True:
        if stack.empty():
            # stack被取完了，下一层队列
            stack, sub_stack = sub_stack, stack
            if n <= 1:
                yield [], [], None
                return
            else:
                n -= 1
            continue
        else:
            try:
                top_list = stack.get(False)
            except Queue.Empty:
                yield [], [], None
                return

        for top in top_list:
            try:
                for item in os.listdir(top):
                    item = os.path.join(top, item)
                    if os.path.isdir(item):
                        dirs.append(item)
                    else:
                        files.append(item)
            except:
                # 出错，比如没有权限
                #traceback.print_exc()
                error = top
            yield dirs, files, error
            if dirs:
                sub_stack.put(dirs)
            dirs = []
            files = []
            error = None

代码长度double了.........

IO笔记3

2010-07-18T01:31:00.001-07:00

read(2)和write(2)都有一个特点: 期待被处理的数据与已经被处理的数据量可以不一致.
比如:
char buffer[5000];
size_t count = read(1, buffer, 4096);

调用read读4096个bytes, 但是是不是真的已经读了4096个bytes, 这是没有必然要求的.

socket的I/O是最明显的.

如果不一致, 就要求程序员去处理. 不过, 这都是常事了, 都有满足这样需求的函数.

但是, 这就需要程序员可以自己分清这两种情况的函数.

不要认为sys.stdin.read(4096)和os.read(sys.stdin.fileno(), 4096)是一样的.

$ (echo -e "12345\n"; sleep 10) | python -c '
import sys
print sys.stdin.read(4096)'

上面的python程序是被block了10秒才运行print的. 但是下面的是马上收到数据的:
$ (echo -e "12345\n"; sleep 10) | python -c '
import sys
import os
print os.read(sys.stdin.fileno(), 4096)'

C的standard I/O是一组保证可以返回指定数据(量)的函数

standard I/O增加了buffer, 以减少read, write的次数. 原则就是每次调用read的时候读入BUF_SIZE的数据到buffer空间中, 下面是read函数的原型:

ssize_t read(int fd, void *buf, size_t count);

count是会根据file descriptor的不同变化, 如:
1. terminate device时为1024
2. 不是terminate device时为是page size, 或者程序员使用setvbuf指定

standard I/O有三个种非格式化函数:
1. character-at-a-time I/O
2. line-at-a-time I/O
3. direct I/O

无论使用哪种函数, 它都是如下的方式:

read(fd, buffer_ptr, BUF_SIZE);

那怕你只是想使用fgetc得到一个字符. 都是调用上面的函数. 一般情况BUF_SIZE >= 1024.

standard I/O除了缓存外. 还保证了返回的数据是想得到的, 如:
1. character-at-a-time I/O时, 保证返回一个字符
2. line-at-a-time I/O时, 保证返回一行数据, 以NULL结尾.
3. direct I/O时, 保证返回指定的数据结构.

否则, 会多次调用上面的read函数, 直到取得的数据满足要求, 过程中会出来下面的情况:
1. block;
2. EOF;
3. Error

IO笔记2

2010-07-16T19:00:00.001-07:00

两层buffer的存在

23 #include <stdio.h>
24
25 int main(int argc, char *argv[]){
26     int retval ;
27     while(1){
28         char c[BUFSIZ];
29         retval = read(0, c, 1);
30         printf("%c\n", *c);
31     }
32     return 0;
33 }

上面的代码，用户输入一次， read函数被调用N次(数据的长度)。也就是说用户输入的数据已经被缓存了。
再如下：

23 #include <stdio.h>
24
25 int main(int argc, char *argv[]){
26     int retval ;
27     int i;
28     int c;
29     printf("%d\n", BUFSIZ);
30     for(i = 0; i < BUFSIZ / 2; i++){
31         c = fgetc(stdin);
32     }
33     return 0;
34 }

上面的代码fgetc被调用N次(数据的长度), 但是read的调用情况如下:
1. 当stdin不是terminate device时, 被调用一次, read的count参数为4096
2. 当stdin是terminate device时, 被调用两次, read的count参数为1024
* 至少怎么得到这种数据, 答案是使用strace凶器。

libc会根据stdin是什么使用setvbuf对FILE对象设置buffer.

从上面两个例子可以知道：
1. 使用standard I/O从terminate device读数据时，其实经过了两个buffer机制。
2. standard I/O读不同file descriptor时的buffer大小会变化。加上从APUE中知道的，情况会是这样
* 当stdin, stdout是terminate device时， standard I/O会使用行缓存， buffer大小为1024.
* 当stdin, stdout不是terminate device时， standard I/O会使用full buffer, buffer大小为4096.

好，知道这两种buffer机制与buffer大小了，移步看这一篇文章会有很好的收获：
* http://www.pixelbeat.org/programming/stdio_buffering/

这文章从一个例子开始, 如下:
# tail -f access.log | cut -d' '|uniq
为什么上面的命令没有输出? 呵呵, 其中就是IO缓存的机制.

预读数据, 减少read, write

使用standard I/O都是会预读一定数量的数据, 用于减少调用read, write的次数.
使用standard I/O的好处就是程序员无需操心这个预读数据的大小, 只需要知道它是预读的即可.
如果不知道会预读的话, 上面的URL的例子就无法明白.

IO笔记

2010-07-11T03:49:00.001-07:00

IO部分总是很乱。不知道是因为API多还是其它原因：
0. 阻塞的存在
1. glibc的section3手册和linux的section2有同名函数。
2. posix, ISO都有要求
3. terminal IO与其它IO有不同的表现
4. IO缓存的机制
5. 还有众多古老的名词....

EOF
EOF是什么? 什么时候才会产生? 还是和ctrl_c一样是signal ?

如下代码的运行結果是 -1
19 #include <stdio.h>
20
21 int
22 main(int argc, char *argv[])
23 {
24     printf("%d\n", EOF);
25     return 0;
26
27 }

表示EOF是 -1 ?

当某一次使用 ssize_t read(int fd, void *buf, size_t count); 函数从一个file descriptor中读数据时(count>0), 函数得到0个字节表示读到文件的尾部了. 这时read函数返回0.

可读端的pipe关闭后，只读端pipe在读完后会产生EOF：
2 import os
3 import sys
4 import time
5
6 read_end, write_end = os.pipe()
7
8 pid = os.fork()
9 if pid < 0:
10     print "Error"
11     sys.exit(1)
12 if pid == 0:
13     # parent
14     os.close(write_end)
15     try_time = 1
16     # 因为无法得到child process会发多少数据，只能使用死循环去读数据
17     while True:
18         print "%s time(s) call read" % try_time
19         content = os.read(read_end, 1)
20         if not content:
21             break
22         os.write(1, content)
23         try_time += 1
24     sys.exit(0)
25
26 else:
27     # child
28     os.close(read_end)
29     os.write(write_end, "#" * 100)
30     # 关了parent就能读到EOF
31     os.close(write_end)
32     sys.exit(0)

文件系统中的文件是有固定大小(某一状态), 但是在terminal IO里，是没有一个固定的尾部的, 需要输入者指定什么时候才是end-of-file, 所以, ctrl_D出现了. ctrl_D是一个特殊控制符。被tty的驱动处理(默认情况下用户程序不能从read函数得到，除非要求tty不处理)

在了解ctrl_D前, 应该先要了解IO的缓存机制.

standard IO缓存与底层IO缓存
在此这前, 我对getchar这个函数不解, 其实就是不解如下的代码:
19 #include <stdio.h>
20
21 int main(int argc, char *argv[]){
22     char c ;
23     while(c = getchar() ){
24        printf("%c\n", c);
25     }
26 }

不要以为简单调用getchar函数可以实现vim这种交互.
当调用read去读stdin的数据时, 是行缓存的.上面的代码在第一次调用getchar时把一行的数据读到buffer里(回车键返回), 下次再调用getchar时会从buffer里取. buffer没有数据后再等待用户输入.

标准IO与系统底层IO这两套IO需要分开. 不然会出现事与愿违的情况, 如:
使用setbuf对FILE对象进行了设置后, 然后使用调用printf操作. 結果没有出现想要的设置效果。例如：

23 #include <stdio.h>
24 #include <string.h>
25 #include <unistd.h>
26
27
28 int main(int argc, char *argv[]){
29     //
30     FILE *input = fdopen(1, "r");
31     FILE *output = fdopen(1, "w");
32     setbuf(input, NULL);
33     setbuf(output, NULL);
34     char c ;
35
36     printf("Hello World");
37     sleep(10);
38 }

上面的printf的内容是过了10秒后才打印的，明显， setbuf没有起作用。但是如果修改为如下就不同了：
23 #include <stdio.h>
24 #include <string.h>
25 #include <unistd.h>
26
27
28 int main(int argc, char *argv[]){
29     //
30     FILE *input = fdopen(1, "r");
31     FILE *output = fdopen(1, "w");
32     setbuf(input, NULL);
33     setbuf(output, NULL);
34     char c ;
35
36     fprintf(output, "Hello World");
37     sleep(10);
38 }
上面代码的区别在于：printf使用了stdin这个FILE对象(默认是line buffer)， fprintf使用了指定的FILE对象。standard IO的缓存是通过修改FILE对象实现的。

read和write会不会缓存，缓存机制是什么？这与read, write操作的对象有很大的关系，例如：

28 int main(int argc, char *argv[]){
29
30     while(1){
31         char c;
32         (void *)read(0, &c, 1);
33         (void *)write(1, &c, 1);
34     }
35 }
上面虽然使用了read, write，还是用户输入还是行缓存的，无法像vim一样交互操作。这时要想非行缓存，需要操作到tty的缓存机制。如下的一段python代码设置了tty的缓存方式：

1 #coding:utf-8
2 import os
3 import sys
4 import termios
5
6 STDIN_FILENO = sys.stdin.fileno()
7
8 old_attr = termios.tcgetattr(STDIN_FILENO)
9 new_attr = termios.tcgetattr(STDIN_FILENO)
10
11 new_attr[3] &= ~ (termios.ICANON | termios.ECHO)
12 termios.tcsetattr(STDIN_FILENO, termios.TCSADRAIN, new_attr)
13 try:
14     print '请使用vim的移动键'
15     while True:
16         c= os.read(STDIN_FILENO, 1)
17         if c == 'j':
18             print "下"
19         elif c == 'k':
20             print "上"
21         elif c == 'h':
22             print '左'
23         elif c == 'l':
24             print '右'
25 except KeyboardInterrupt, e:
26     termios.tcsetattr(STDIN_FILENO, termios.TCSADRAIN, old_attr)

回到ctrl_D的问题
在terminal IO里, 因为默认是使用缓存的, 赋于ctrl_D两种功能:
1. 相当于flush操作. 即时把输入的数据返回给read函数，不用等待'\n'的出现。
2. 让tty返回0字节给read函数. 表示EOF。在单独输入ctrl_D后产生这种效果

控制符
控制符都是tty驱动提供的一种方便功能，有少量的控制符会产生signal的：
^Z和^C
还有少量的是无法修改的：
\r和\n

如下代码把“a“作为backspace功能：

1 #coding:utf-8
2 import os
3 import sys
4 import termios
5
6 STDIN_FILENO = sys.stdin.fileno()
7
8 old_attr = termios.tcgetattr(STDIN_FILENO)
9 new_attr = termios.tcgetattr(STDIN_FILENO)
10
11 new_attr[6][termios.VERASE] = 0x61
12 termios.tcsetattr(STDIN_FILENO, termios.TCSADRAIN, new_attr)
13 try:
14     print "请使用a键删除数据"
15     os.read(0,100)
16 except KeyboardInterrupt, e:
17     termios.tcsetattr(STDIN_FILENO, termios.TCSADRAIN, old_attr)

无线网络配置

2010-06-23T10:56:00.001-07:00

总是有一种怪感觉：不能太依赖GUI程序。

在我的记忆中，还是存在着一种场面：系统无法正常进入X而无法正常使用linux的痛苦记忆。总是感觉GUI是学习使用linux的拦路虎。

所以一般情况下，我都是CLI程序行先的。这也是防止出现我很不喜欢的感觉。

网络照样是CLI行先。之前我的router是配置成WEP的，都是使用wireless-tools工具集可以很好处理。但是慢慢地，这种加密网络已经被淘汰了。 WEP逐渐出的时， WPA流行起来，同时linux也产生了新的一套wireless配置机制：nl80211. 这是为什么wireless-tools工具集无法使用WPA网络的原因

* 关于wireless-tools使用的WE： http://linuxwireless.org/en/developers/Documentation/Wireless-Extensions

使用WPA无线现在一般是使用wpa_supplicant工具

* 关于nl80211的： http://linuxwireless.org/en/developers/Documentation/nl80211

使用CLI工具最烦就是需要多手动。复杂的工具还需要配置文件。

其实这都是一次性的，因为有脚本的存在。

我也是一个懒人～～～谁都不想每次都搞十几钟才上得了网。命令还是比较好办，就麻烦的是配置文件， wpa_supplicant的配置文件也不是省油的。

特别是在没网络，不能google的时候更是无奈。对！这种“无奈”是我最不喜欢看到的！我很讨厌这种感觉。

相信解决的方法是一定会存在的～～～～

“就地出材”是一条出路，即：不联网也可配置wpa_supplicant！

copy是方法， How ? 从wpa_supplicant的man里copy出可使用的配置文件来。

在man 5 wpa_supplicant里看到： Catch all example that allows more or less all configuration modes.

这个问题已经解决了，不存在是否有google。也不存在是否有Networking-manager。（可以直奔可爱的gentoo世界）
把配置copy出来，按实现情况修改，去掉不用的， psk使用wpa_passphrase得到。一切都是没有问题的

* 如果这一步无法做到，还是去使用GUI吧，或者是思考一下问题出在哪里。

============= 华丽的分隔线 ===================

下面是N久在docs里存放的文字，随便一起放出：

计算机的网络是最常见的配置了。来到北京这边。朋友的宿舍里的网络和广东的不一样：

1. 一个宿舍只有几台计算机上网。

2. 可以上网的机器都被登记MAC地址。

3. 可以上网的机器都分有固定的IP， netmask, DNS, gateway

4. 需要web登陆认证方可使用网络。

5. WEP方式

其实就是MAC的限制＋ web登陆认证。

还是很管用的。至少市场卖的路由没有针对这一系统的web登陆。

为了自己的机器可以上网。只需要满足上面的条件即可。

针对于有线的情况：

ifconfig eth1 hw ether 00:1e:65:18:e2:a8

ifconfig eth1 10.3.52.132 netmask 255.255.255.0

route add default gw 10.3.52.1

然后使用browser访问web认证即可。

有线的倒很清楚怎么解决它。无线呢？也很简单

针对于无线的情况（是WEP网络）：

$ sudo ifconfig wlan0 hw ether xxxxxxxx

$ sudo iwlist wlan0 scan

可以得到ssid名～～

$ sudo iwconfig wlan0 ssid 'who' key 'password'

$ sudo route add default gw 10.3.52.1

由setrlimit引发的学习

2010-06-21T21:04:00.001-07:00

POSIX标准中有这样一个函数: sysconf(3). 自己写了小段代码：

19 #include <unistd.h>
20 #include <stdio.h>
21
22 int main(int argc, char *argv[]){
23 int fd_max_number = sysconf(_SC_OPEN_MAX);
24 printf("%d\n", fd_max_number);
25
26 }

使用strace可以知道它其实是调用了getrlimit(2),
什么limit? 全称为 resource limit. 这是kernel分给每个进程独立的一组数据。代表了进程可以使用的最大resource上限。具体有哪些，可以见getrlimit(2)的manual

kernel也有一堆limit参数，使用sysctl(2)来修改， kernel的limit应该被称为"limit of limits"。

下面的有关于文件描述符的limit:
* http://www.karakas-online.de/forum/viewtopic.php?t=9834
* 其中提到一点很有意义：file descriptor与open file

在了解setrlimit(2)配置file descriptor时，有一个文件引起了我的高度注意：
/etc/security/limits.conf

疑问：
1. setrlimit是system call，为什么会使用这样一个配置文件的？
2. limits.conf是pam_limits module的配置文件，如果用户不加载此module时，kernel的setrlimit又是处理的？

不解的情况下，在kernel的源代码堆里纠结时，发现了一个常常会看到的一个词：SELinux
FAQ了一把，得知SELinux是在kernel里加入复杂的access control。比如role-based access control

疑问又来了： Linux是一个可高度裁剪(scale)的系统，如何做到去掉Linux Security Modules可以不影响现有的system call的呢？

这其中的机制比较吸引我。 google了一把，得到一篇好文，分享：
* http://www.ibm.com/developerworks/linux/library/l-selinux/

系统里的hostname

2010-06-09T20:31:00.001-07:00

1. 修改host name需要reboot吗？
2. host name与/etc/hosts有什么关系呢？
3. gethostname为什么不受/etc/nsswitch.conf的配置？

这三个问题在不了解host name是什么的时候, 比较纠结.

是否要reboot这个问题是最直接让我产生dig这个host name的动力, 还有就是工作中, 碰到一台机器无法使用sudo命令, 于是花时间学习学习.

平时看hostname(3)时, 发现hostname(3)与/etc/nsswitch.conf扯在一起, 这使host name与DNS中的记录纠结在一起. 更是希望了解之间的关系

在找资料的过程中, 本人发现了一个很有意思的方法:
* Linux kernel与GNU分开.
什么意思呢? 分界是为了把不同时期的产物, 概念之类的分开. 比如: 当你认host name是kernel的一个变量时, 那么它就与DNS中的记录有明显的不同.

gethostname是system call, 它不是glibc的东西, 所以它与glibc中的DNS查询机制(/etc/nsswitch.conf)是扯不上关系的. gethostbyname, gethostbyaddr都是glibc的东西

就算没有glibc的存在, kernel中的host name照样存在!

按上面的方法, 已经可以很清楚地知道host name与/etc/hosts, /etc/nsswitch.conf是没有关系的.

linux kernel提供了实时修改kernel参数的方法, 是无需要reboot内核就可以生效的. 如sysctl(2), 也有CLI的sysctl(3). 也可以修改/proc/sys/kernel下的文件.

在实际中, GNU软件又常常会使用到host name!

在工作中碰到一个这样的问题: 每当运行sudo时shell就hang住!
它被block了吗?
于是使用strace一查, sudo是在等socket的IO. 发现这台机器的DNS請求是发不出去的

为什么sudo需要使用网络呢?
这其实就是程序期望得到FQDN格式的host name的結果.
得到FQDN格式的host name就使得host name与DNS查询纠结在一起.

通过学习hostname命令的代码, 可以得到hostname -f其实是等同于下面的代码
#include <unistd.h>
#include <stdio.h>
#include <netdb.h>

int main(int argc, char *argv[]){
    char hostname[64];
    if ( gethostname( hostname, sizeof(hostname) ) != 0){
        perror("1");
    }
    struct hostent * host_struct;
    if ( (host_struct = gethostbyname( hostname )) == NULL ){
        perror("2");
    }
    printf("%s\n", host_struct->h_name);

}

可以得到这样的信息: 得到FQDN格式的host name, 是需要使用到
1. host name
2. DNS
这就与linux下DNS查询顺序策略有关系(/etc/nsswitch.conf)

python里有一段很明了的代码(来自socket.py):
def getfqdn(name=''):
    """Get fully qualified domain name from name.

    An empty argument is interpreted as meaning the local host.

    First the hostname returned by gethostbyaddr() is checked, then
    possibly existing aliases. In case no FQDN is available, hostname
    from gethostname() is returned.
    """
    name = name.strip()
    if not name or name == '0.0.0.0':
        name = gethostname()
    try:
        hostname, aliases, ipaddrs = gethostbyaddr(name)
    except error:
        pass
    else:
        aliases.insert(0, hostname)
        for name in aliases:
            if '.' in name:
                break
        else:
            name = hostname
    return name

这样还可以解开一个疑问: 为什么/etc/hosts里常常会出现hostname和它的FQDN记录
增加这样的信息在这里, 查hostname的FQDN时就无须通过网络得到, 当然, 的确有需求的话, 也是可以的, 如果牛B的话, 就每台机器有一个全球唯一的域名也没有人说

帐号

2010-05-30T07:16:00.001-07:00

1. 问题的来源
一直以来, 都有一种错误的认为: 使用useradd增加帐号和配置好ssh-key就可以使用此帐号登陆 .
实现上不如此. 这是需要usePAM的支持. PAM日后再细细学习, 现在先学习学习一般认证

于是, 把login和su命令的代码翻出来看看. 它们都使用如下的方式:

login(不扯PAM)的代码:
798     pp = getpass(_("Password: "));
799
800 # ifdef CRYPTOCARD
801     if (strncmp(pp, "CRYPTO", 6) == 0) {
802         if (pwd && cryptocard()) break;
803     }
804 # endif /* CRYPTOCARD */
805
806     p = crypt(pp, salt);
807     setpriority(PRIO_PROCESS, 0, 0);
.......
835     if (pwd && !strcmp(p, pwd->pw_passwd))
836       break;
837
838     printf(_("Login incorrect\n"));

su的代码:
265   unencrypted = getpass (_("Password:"));
266   if (!unencrypted)
267     {
268       error (0, 0, _("getpass: cannot open /dev/tty"));
269       return false;
270     }
271   encrypted = crypt (unencrypted, correct);
272   memset (unencrypted, 0, strlen (unencrypted));
273   return STREQ (encrypted, correct);
274 }

都是:
1. 使用了crypt函数
2. 最后都是字符串比较
3. 需要/etc/shadow里的加密后字符串
* 比红色部分可以看出getpass是在stdin被定重向后会报错(hard wire型的程序), 因为它使用了不回显功能(只有tty才有, pipe没有)

在python官网里看到可爱的python代码是这样的:

crypt.crypt(cleartext, cryptedpasswd) == cryptedpasswd

* 可以知道crypt函数的第二个参数可以是salt, 也可以不是salt, 而是加密后的字符串
* 自来http://docs.python.org/library/crypt.html?highlight=crypt#crypt.crypt

2. Lock 与 Unlock 是怎么一个概念?

在man 5 shadow得到的信息：

If the password field contains some string that is not valid result of crypt(3), for instance ! or *, the user will not be able to use a unix password to log in, subject to pam(7).

从上面的C代码和crypt函数的特性可以猜测: Lock无疑就是让方程两边永远不相等, 代码没有其它测试的必要!

具体到ssh的实例, 当使用一指定用户登陆ssh server时, server并不去分别Lock与不Lock的帐号,
虽然没有看过sshd的代码, 但是从表现上: 不会马上打印: Lock user或者马上disconnect, 如使用全世界都公认的halt默认帐号也是提示输入密码:
$ ssh halt@localhost
halt@localhost's password:

3. 其它
su切换用户
FAIL : 以为切换什么用户都是输入root密码
大概看了一把su的代码, 才知道不是这样的~~~~
知道了下面的真相:
1. 需要输入切换到用户的密码
2. restricted shell : 凡不在/etc/shells里登陆的shell都是受限shell. 为了安全的

nologin
平时nologin默认打印信息是: This account is currently not available.
你也是可以修改的: /etc/nologin.txt, 例如下面的例子:

$ sudo su rpc
我顶～乱来~ 去问你妈要密码, 不然见一次骂一次
* 这个例子有点geek~

虚假终端: pseudo-terminal

2010-05-28T10:01:00.001-07:00

之前只听前pseudo terminal, 但是没有理会. 前段时间在写脚本时受点一点限制

1. 为什么使用subprocess无法与子进程多次通信?

2. 像su这种为什么使用subprocess无法调用? ( 这种软件有一个词来描述: hard wire , 表示需要terminal, 代码中使用了istty函数检测到 )

3. vim这种软件的交互是怎么实现的?

subprocess的communicate函数是代码是这样的:

if self.stdin:

if input:

self.stdin.write(input)

self.stdin.close()

这里为什么需要self.stdin.close()呢? 这就是subprocess无法与子进程多次通信的地方.

在不明白为什么需要close的情况下, 自己写的一段fork功能的代码, 結果: 当父进程在读子进程的stdout时被block了. 其实, 这时父进程和子进程都是block的, 这被称为"死锁". 这就是为什么subprocess里需要close

那么, 我的需求:

1. 在调用外部进程的情况下, 如何多次父-子进程通信?

2. 如何调用hard wire的程序?

种种问题的浮现让sysadmin岗位的本人不爽. 至少不方便工作....

例子:

1. passwd的调用

passwd是一典型的hard wire程序, 下面的方式调用是不行的:

$ echo "new password" | passwd

比较有意思的是passwd在不同的系统或者是distro下都是不同的.

* freeBSD下有参数控制(具体的忘了, 也没有环境回顾), 成为batch mode

* redhat系使用"--stdin"控制

* ubuntu下没有batch mode参数

2. su -c "my command"的调用

使用在系统上使用su ( 我不得不说, 没有sudo使用~~~), 这将是一个很大的麻烦~~

后知后觉, 发现了pseudo terminal这一概念. 它的应用很广泛, 比如提供network login的sshd就使用到此概念

* http://en.wikipedia.org/wiki/Pseudo_terminal

在朋友(mrluanma (AT) gmail.com)的帮忙下, 找到pexpect程序(http://www.noah.org/wiki/Pexpect). 提供了一个很好的学习模板.

刚接触pseudo terminal很头大的, 还好APUE一书中有这部分和关于terminal I/O的资料, 下面是一个很清晰的图:

本人写了两个简单的例子:

1. 使用pty.fork()函数产生子进程, 子进程与父进程的controlling terminal是不同的.

代码地址: http://svn.lvscar.info/jessinio_repos/learn_pty.py

帐号与密码都是svn

2. 使用pty实现调用passwd这种hard wire外部程序

代码地址: http://svn.lvscar.info/jessinio_repos/use_pty_call_passwd.py

帐号与密码都是svn

记一次开源软件原理追查

2010-05-24T01:40:00.001-07:00

有这种dig行为，主要是本人想写完一篇笔记，是关于xxx.pid文件与锁的文章。
在实际和自己了解的情况中，掌握的东西不够多，所以就dig下去了。

在shell中，如果要得到文件锁，在debian系的distro下可以使用这个包: lockfile-progs

ubuntu下已经预装
http://packages.qa.debian.org/l/lockfile-progs.html

因为一直对lock file 和 file lock这两个名词纠结不清, 所以就下载源代码（还好，很简短）来看

发现使用了liblockfile库, 视线被转到这一个library上, 首先想到的是找这个库的文档

dpkg -l|grep lockfile
得到：
liblockfile1

dpkg -L liblockfile1
只有一份man手册，是关于随liblockfile1包发布的dotlockfile程序的说明。

嗯, 至少比没有好吧.....man之

不过很有意思的是从这份手册里看到一点线索：
The above mentioned lockfile_create(3) manpage is present in the liblockfile-dev package.

呵呵， lockfile_create 这个API的手册在dev包里，马上apt-get安装

lockfile_create API手册里有一节叫ALGORITHM的。其实这一节已经说明了原理和流程了（从man手册里的文字转成流程还是需要很细心地阅读）
我对其它的 "A check is made to see if the existing lockfile is a valid one" 不是很明白，所以找了lockfile_check函数的代码看，这里就不贴代码了（还是wordpress写blog好呀～～）
代码可以出下面的地址得到：
* http://liblockfile.sourcearchive.com/documentation/1.06.1/lockfile_8c-source.html

lockfile_check函数的判断有两个：
1. lock file中保存PID号代表的进程是否还存在，通过kill函数得到。（用法与xxx.pid文件类似，关于xxx.pid用法，本人别起笔记）
2. 如果lock file 中保存的pid号为0，则与5分钟为lock file生命期。

xxx.pid文件与lock file

2010-05-24T01:32:00.001-07:00

linux下， xxx.pid这类文件还是很常见的，特别是在/var/run目录下， APUE一书都是推介在这里创建pid文件。
pid文件到底有什么作用呢？用法是如何的呢？种种疑问让我产生了dig的冲动。

先看看实现生活中碰到的：

1. init.d脚本使用到pid文件

/etc/init.d目录下存放了众多daemon程序的控制脚本，这类脚本一般有几个参数：

start
retstart
stop
强大的专业服务端还有gracestop之类的参数

这类脚本的这些参数功能的实现是使用到了linux的signal机制，无疑需要daemon进程的pid

2. lock

lock主要是协调，操作atomic时使用的一种方式。
举个实际中的例子：
系统需要一个定时任务，要求每分钟对系统N多状态收集（如硬盘，CPU，网络等等），收集过程中不断有日志产生。

这个例子会有两个问题：

运行间隔为每分钟，可能会定时任务某次运行时长长于1分钟。
如果出现1的情况会对日志产生影响

lock主要是用于证实有进程在处理。

linux系统本身有锁的机制，如flock和fcntl函数。这种锁称为file lock，文件锁
linux下的文件锁可以对一个文件的一个区域进行锁定。

现在，本笔记不想扯上这种强大功能，只是谈论上面举的例子：怎么让进程得到一个結果：能否处理

完成这需求，只需要一个标志，这个标志需要进程在得到时是atomic性的。

可以通过两种方法得这种标志：

指定文件已经存在，表示有进程在处理. 这种方式称为lock file
使用系统本身的file lock机制，如果open的file descriptor有锁，表示有进程在处理

使用linux的flock函数得到file lock，这里有一个python的例子：
http://svn.lvscar.info/jessinio_repos/flock_example.py
* 帐号与密码都是svn

lock file 和 file lock 的区别

lock file是利用系统本身的open, link, stat这样的函数, 实现文件创建的atomic性. 成功被创建的文件作为atomic的标志

file lock是利用系统本身的fcntl或者flock函数对某一的文件进行锁定, 将能否成功锁定文件作为atomic的标志

无论是lock file 还是 file lock都是需要文件这一角色的. 但是这一文件起的作用不同.

本文主要是想扯lock file与xxx.pid文件的关系. 不想扯file lock和lock file

仅仅需要可以标志行为的atomic性的话, lock file是最好的方法:
1. NFS上可以使用(flock函数在旧版本的NFS上不起作用)
2. shell脚本可用. 因为是shell脚本是CLI, 时刻都是新的进程在处理, 不方便使用flock(这样需要一个daemon在保持file lock的存在
* 关于 lock file可以移步: http://en.wikipedia.org/wiki/File_locking#Lock_files

使用lock file需要解决的问题

当使用lock file作为atomic的标志时, 有一种情况是需要解决的: 持锁者是否还存在, 例如:

当一个进程成功创建了lock file后, 在不明异常的情况终止了, 后面的进程怎么判断刚才被创建的lock file是被进程使用的? ( 使用file lock就没有这种问题, 得到锁的进程终止后锁会被释放, 新的进程可以得到)

具体处理方式可以参考liblockfile的原代码:
* http://liblockfile.sourcearchive.com/documentation/1.06.1/lockfile_8c-source.html

在它的lockfile_check函数里, 使用到了kill函数. 这个kill函数需要的pid就是xxx.pid文件的pid

因此:

xxx.pid有两种作用:
1. 方便daemon被控制(通过signal)
2. 可以用于实现lock file

利用了1不一定利用2, 但是作用了2一定需要利用1

另外

除了利用kill给指定的pid发signal的方式去判断某进程是否存在的方式后, 还可以使用如下URL提到的方法:
http://stackoverflow.com/questions/2735926/how-to-capture-pid-of-a-linux-daemon-run-from-init-d

利用/proc/NamePID/exe得到的字符串是否为先前在进行的进程名. 这种方法需要知道进程的名称.

疑问

是否会出现pid号的进程存在, 但不是自己期望的进程呢?
查阅了APUE也没有明确, 只知道是有一定的算法去reuse 进程号的.

在这方面, 还是flock方便, 不过此函数不是所有地方都可以使用的, 纠结`~~

exec*族函数的好玩参数

2010-05-20T07:00:00.001-07:00

一直以来，感觉exec*族函数都是比较乱的。查查手册就可以知道分来如下几类:
l: stands for list
v: stands for vector , 类似于main中的argv，表示数组。
p: path
e: environment

本blog不是想写上面的内容的。

本人是对execl*都第二个参数， execv*第二个参数的第一个成员感兴趣。

很早之前就对这个参数不懂。例如：

os.execlp("sleep", 'sleep', '10')
当同于:
os.execvp("sleep", ['sleep', '10])

看上去感觉不是很好, 第二个参数用来干嘛的？为什么要重复写出来？

主要是在不知道那个参数是干什么的情况下, 写得和第一个参数相同, 所以就有这种重复的感觉.

起什么作用的呢? 看下面吧:

jessinio@jessinio-laptop:/proc/7345$ sleep 10 &
[1] 7594
jessinio@jessinio-laptop:/proc/7345$ ps x|grep sleep
7594 pts/10   S      0:00 sleep 10
jessinio@jessinio-laptop:/proc/7345$ /bin/sleep 10 &
[2] 7597
jessinio@jessinio-laptop:/proc/7345$ ps x|grep sleep
7597 pts/10   S      0:00 /bin/sleep 10

* 相同颜色部分的关系: 相同的
* 此字符串来自/proc/*/cmdline 文件内的信息

exec*族的第二个参数(对于v类是第二个参数的第一个成员)是起到显示的作用, 如:

import os
import sys

if __name__ == "__main__":
    pid = os.fork()
    if pid == 0:
        child = ['i love linux', '10']
        os.execv('/bin/sleep', child)
    else:
        print "%s" % pid
        os._exit(0)

运行得到:
jessinio@jessinio-laptop:/tmp$ python exec_bin.py
7892
jessinio@jessinio-laptop:/tmp$ ps aux|grep 7892
jessinio 7892 0.0 0.0   2956   628 pts/9    S    21:55   0:00 i love linux 10

有点与众不同的玩法~~

进程成为daemonize需要fork两次吗?

2010-05-17T05:54:00.001-07:00

成为一个daemonize，其实网上有很多例子，也是可以使用的，正如：
http://code.activestate.com/recipes/278731-creating-a-daemon-the-python-way/
里给出的例子。

但是，我无法明白为什么要fork两次！，下面是我的测试：

jessinio@jessinio-laptop:/tmp$ ps axj|head -n 1
PPID PID PGID SID TTY TPGID STAT UID TIME COMMAND
jessinio@jessinio-laptop:/tmp$ ps axj|grep apache
1 1820 1820 1820 ? -1 Ss 0 0:10
/usr/sbin/apache2 -k start
1820 16100 1820 1820 ? -1 S 1000 0:00
/usr/sbin/apache2 -k start
1820 16101 1820 1820 ? -1 Sl 1000 0:00
/usr/sbin/apache2 -k start
1820 16129 1820 1820 ? -1 Sl 1000 0:00
/usr/sbin/apache2 -k start

可以中从得到这样的信息：
daemonize进程的PPID==1, PID==PGID==SID, 没有tty（为？）

如果这就是daemonize进程的要求的话，请看我自己写的python代码：

if __name__ == "__main__":
pid = os.fork()
# child process
if pid == 0:
os.setsid()
time.sleep(10)
else:
print 'parent %s, child %s' % (os.getpid(), pid)
os._exit(0)

其中只是调用了一次fork函数。下面是它的运行結果：

jessinio@jessinio-laptop:/tmp$ ps axj|head -n 1
PPID PID PGID SID TTY TPGID STAT UID TIME COMMAND
jessinio@jessinio-laptop:/tmp$ python process.py
parent 26117, child 26118
jessinio@jessinio-laptop:/tmp$ ps axj|grep process
1 26118 26118 26118 ? -1 Ss 1000 0:00 python process.py

可以看到， PPID==1, PID==PGID==SID, 没有tty

这是否可以认为：只fork一次，然后调用setsid就可以成为daemonize进程了呢？

在众多不解的情况下, 决定好好看看圣经: APUE 一书.

也很高兴, 从中找到了一点信息:

under system v-based systems, some people recommend calling fork again at this point and having the parent terminate, the second child continues as the daemon, This guarantees that the daemon is not a session leader , which prevents it from acquiring a controlling terminal under the system v rules. alternatively, to avoid acquiring a controlling terminal, be sure to specify O_NOCTTY whenever opening a terminal device.

fork第二次是防止被在打开一个terminal device时被系统分配到controlling terminal

只要不乱open(或者使用O_NOCTTY是不需要fork第二次的.

话又说回来, linux是怎么分配controlling terminal的呢?

APUE在这里没有提到linux, 只是提到了BSD和system-V的不同. 搜了一下, linux和BSD是一样的, 使用ioctl得到controlling terminal, URL: http://linux.die.net/man/4/tty_ioctl
如下引用:

TIOCSCTTY int arg Make the given tty the controlling tty of the current process.

办公机器安装centOS

2010-04-25T00:44:00.001-07:00

为了方便工作，决定把分配的工作机安装centOS环境.
虽然是不会在自己的desktop上安装centOS这种环境, 但是这样做,至于可以使自己对生产系统环境常有接触吧.

1. firefox (centOS 5.4默认的firefox版本太低，无法安装vimperator。只能下载最新版本的firefox
下载的firefox都是一堆bin，可以方便使用(顶多就是一个LD_LIBRARY_PATH的问题),可以使用firefox配带的启动脚本,把
MOZ_APPRUNNER_NAME="./mozilla-bin"
修改为:
MOZ_APPRUNNER_NAME="./firefox-bin"

安装常用的插件:
* vimperator
* tree style
* foxproxy

2. 安装字体:wenquanyi
从官网下载:http://wenq.org/enindex.cgi
安装方法参照安装包里的INSTALL内Manual Installation with tgz package一节
其中提到的:
FontPath /usr/share/fonts/wenquanyi/wqy-zenhei
应该是在Files一节中,例如:

Section "Files"
    RgbPath      "/usr/share/X11/rgb"
    ModulePath   "/usr/lib64/xorg/modules"
    FontPath     "unix/:7100"
    FontPath     "/usr/share/fonts/wenquanyi/wqy-zenhei"
    FontPath     "built-ins"
EndSection

注意:
2.1. 修改xorg.conf前最好是备份
2.2. 使用Xorg -configure可以产生一份测试过的xorg.conf配置文件

3. 安装scim输入法
这里不选择ibus主要是centOS下的python版本也是很低的(2.4), 本人还想折腾升级python, 所以先使用上scim再说吧.
使用yum安装.至于scim需要的几个环境变量,本人也是上官网找的.
* 现在firefox中还是打不了中文~~~郁闷. 先这样吧~~~

run scim daemon: scim -f socket -c socket -d

ext2文件系统

2010-03-30T04:17:00.001-07:00

为什么要了解ext2文件系统?

因为想知道quota的工作原理

为什么不是ext3或者是ext4？

相比之下，ext2入门比较简单

ext2的结构

首先碰到两个概念：

1. block

在ext2的逻辑上， block是最小单位。大小是512*N(N>2)。512是现在常用硬盘的扇区大小。这个大小可以通过mkfs.ext2的-b参数指定。

其实，现在已经有扇区大小为4K的硬盘了，见DBA notes的blog: http://www.dbanotes.net/review/hard_drive_4k_sector.html

2. block group

ext2把N多的block划分成group处理，称为block group。这个数目可以通过mkfs.ext2的-G参数指定.

block group的具体细节

从图中可以看出, 每个block group有六部分. 其中有二部分是每个block group都是相同的:

1. super block:

主要存放文件系统整体情况信息, 如

...(被截断)...

340 __le32 s_inodes_count; /* Inodes count */

341 __le32 s_blocks_count; /* Blocks count */

342 __le32 s_r_blocks_count; /* Reserved blocks count */

343 __le32 s_free_blocks_count; /* Free blocks count */

344 __le32 s_free_inodes_count; /* Free inodes count */

345 __le32 s_first_data_block; /* First Data Block */

346 __le32 s_log_block_size; /* Block size */

347 __le32 s_log_frag_size; /* Fragment size */

348 __le32 s_blocks_per_group; /* # Blocks per group */

349 __le32 s_frags_per_group; /* # Fragments per group */

350 __le32 s_inodes_per_group; /* # Inodes per group */

...(被裁断)...

block group数目 = s_blocks_count / s_blocks_per_group
每个block group的开始block位置 = ((group_number - 1)* blocks_per_group)
* 这里的开始block位置不是物理地址! 相当于block的编号

2. group descriptor

这里保存了每个block group的一些重要信息:

106 struct ext2_group_desc

107 {

108 __le32 bg_block_bitmap; /* Blocks bitmap block */

109 __le32 bg_inode_bitmap; /* Inodes bitmap block */

110 __le32 bg_inode_table; /* Inodes table block */

111 __le16 bg_free_blocks_count; /* Free blocks count */

112 __le16 bg_free_inodes_count; /* Free inodes count */

113 __le16 bg_used_dirs_count; /* Directories count */

114 __le16 bg_pad;

115 __le32 bg_reserved[3];

116 };

可以看group descriptor保存了每个block group的使用信息.

group descriptor共使用的block数目 = (sizeof(struct ext2_group_desc) * block group数目) / s_blocks_count

* 存在余数还要加1, 文档里只是这样说的: rounded up if necessary, 见文档

下面部分是每个block group不同的:

3. block bitmap: 记录当前block group的block使用情况, 每个bit表示一个block是否被使用, 1表示被使用, 0表示没有被使用

4. inode bitmap: 和block bitmap的作用一样.

5. inode table: 存放struct ext2_inode数据结构, 每一个struct ext2_inode结构表示一个文件. 文件的属性都存放于这个struct里.

6. data blocks: 主要是存放数据的block.

每个struct ext2_inode是怎么编号, 每个block是怎么对应上物理地址?

上面的信息中, 还有两个问题:

1. 没有提到inode统一分配, 如: block group 2有哪些inode?

2. 没有提到物理地址. 如怎么得到block 1000的4K bytes?

实现上, 这两种信息都是通过计算得到的. 基于两个前提:

1. 逻辑分区的扇区是连续的. 也就是说, block都是连续的. 如: block 1, block 2, ...

2. block group也是连续的. 如: block group 1, block group 2, ...

知道block号码求得block的位置:

The block in that group (offset in blocks) = block_number %s_blocks_per_group

知道inode号码求得inode的位置:
The inode in that group (offset in blocks) = inode_number % s_inodes_per_group

这样就可以知道每个block group有哪些inode, 每个struct ext2_inode结构表示inode

从位置如果得到物理地址?

block group 1的开始物理地址(也是block 1)是可以直接寻址:
The starting point for the file system is the superblock and is always located at an offset of 1024 bytes from the start of the file system.
* 文件系统前1024bytes不使用.

这样就可以计算出每个block group的地址, 然后再求得组出的block的物理地址.

总:

声明: 仅仅是个人的解理, 后果自负

vsftpd的文件名编码

2010-03-29T04:20:00.003-07:00

问题的来由

前几天，朋友被这一个需求烦着：希望freeBSD下的vsftpd不把用户(windows环境)上传的文件名保存为UTF－8，即希望是GBK编码。
在vsftpd的配置文件里，没有提到这样的配置项。
于是，兴趣一上，自己就去看vsftpd的代码了。都是找了一圈，根本没有找到vsftpd是如何转编码的代码。(linux下的软件不都是使用libc的iconv函数的吗？)
于是想了一下，这种编码转换不是由vsftpd处理的，而是由用户端软件处理的，也就是说ftp协议本身有这样的定义。

理由：
1. server端根本不知道client系统是使用什么编码的
2. 在vsftpd的代码没有看到一点编码转换的代码。

在这两种情况下，只能在通信中指定编码的类型。协议中应该有这样的定义。

查到的文档

于是，去查看RFC文档： http://filezilla-project.org/specs/rfc2640.txt

FTP对FEAT命令的要求：

3.3 Clients compliance
   - Clients MUST support the FEAT command and recognize the "UTF8"
     feature (defined in 3.2 above) to determine if a server supports
     UTF-8 encoding.

* 注意其中的MUST单词。
* client端是一定可以知道服务端是否支持UTF-8的

上面可以看到： client端是一定可以知道服务端是否支持UTF-8的

使用wireshark分析

监听网络是最方便判断这个问题的方法。
如果是client传送了UTF-8字节流, 在client发出的通信数据中, 一定是UTF-8的.如下是使用wireshark监听到的client請求:
7 18.059426 192.168.0.102 192.168.0.102 FTP Request: MKD \346\226\260\346\226\207\344\273\266\345\244\271 (7)
看到得到一串bytes, 这串bytes就是UTF-8数据:
print(unicode("\346\226\260\346\226\207\344\273\266\345\244\271","utf-8"))
新文件夹

测试FEAT和OPTS命令

关系feat和opts命令，可以从这里得到信息：http://www.networksorcery.com/enp/rfc/rfc2389.txt

The File Transfer Protocol is, from time to time, extended with new
commands, or facilities. Implementations of the FTP protocol cannot
be assumed to all immediately implement all newly defined mechanisms.
This document provides a mechanism by which clients of the FTP
protocol can discover which new features are supported by a
particular FTP server.

feat和opts不是user interface，它是FTP协议的命令，就如HTTP中的session和host一样
所以使用客户端是无法看到的，比如lftp或者ftp
好在ftp协议是本文协议，可以使用telnet看清楚。
$ telnet 192.168.0.102 21
Trying 192.168.0.102...
Connected to 192.168.0.102.
Escape character is '^]'.
220 (vsFTPd 2.2.2)
user jessinio
331 Please specify the password.
password
530 Please login with USER and PASS.
feat
211-Features:
EPRT
EPSV
MDTM
PASV
REST STREAM
SIZE
TVFS
UTF8
211 End

可以看到支持UTF-8功能。

opts命令是为实现ftp日益增加的命令而存在的。下面测试opts命令：
$ telnet 192.168.0.102 21
Trying 192.168.0.102...
Connected to 192.168.0.102.
Escape character is '^]'.
220 (vsFTPd 2.2.2)
user jessinio
331 Please specify the password.
ivwsydfku
530 Please login with USER and PASS.
opts utf on
501 Option not understood.
opts utf8 on
200 Always in UTF8 mode.

手工禁止vsftpd的功能

现在把vsftpd代码里的feat命令和对opts命令返回信息做一下修改.

把features.c文件中的
vsf_cmdio_write_raw(p_sess, " UTF8\r\n");
去掉
把opts.c文件的handle_opts函数修改成如下:
14 void
15 handle_opts(struct vsf_session* p_sess)
16 {
17   str_upper(&p_sess->ftp_arg_str);
18   //if (str_equal_text(&p_sess->ftp_arg_str, "UTF8 ON"))
19   //{
20   // vsf_cmdio_write(p_sess, FTP_OPTSOK, "Always in UTF8 mode.");
21   //}
22   //else
23   //{
24     vsf_cmdio_write(p_sess, FTP_BADOPTS, "Option not understood.");
25   //}
26 }

自己的域名与Blogger

2010-03-10T08:19:00.001-08:00

通过自己的域名（如本人使用blog.jessinio.info）去访问自己的Blogger内容，早就是这样使用的了。

但是没有理会其中的具体细节。

今天在看DNS方面的知识时，突然就对这个问题感兴趣了。提出这一个问题：为什么使用blog.jessinio.info可以访问blogger的内容？

下面做一下测试，随便玩一下。

本人的blog.jessinio.info通过browser是可以访问的。这也是Blogger的内容。看一下是什么：

jessinio@jessinio-laptop:~$ ping blog.jessinio.info

PING ghs.you8g.com (69.164.192.240) 56(84) bytes of data.

64 bytes from li107-240.members.linode.com (69.164.192.240): icmp_seq=1 ttl=49 time=303 ms

64 bytes from li107-240.members.linode.com (69.164.192.240): icmp_seq=2 ttl=49 time=304 ms

网络是通的，也很正常，就是对应着一个IP地址。但是一个很神奇的事情：在browser的地址栏中直接访问上面的IP地址是得不到blogger的内容的：

Not Found
The requested URL / was not found on this server.

* 可以亲自试一试： http://69.164.192.240/

先看一下ping命令的結果是什么意思：

0. blog.jessinio.info，本人创建的一个CNAME记录

1. ghs.you8g.com，也是一个CNAME记录，指向的ANAME记录

2. li107-240.members.linode.com，所谓的正规主机名，也为ANAME

* http://tools.ietf.org/html/rfc1034并没有明文规定禁止CNAME指向CNAME。只是建议避免这种情况

这是为什么直指访问IP地址得不到blogger的内容呢？难道是因为blog.jessinio.info是一个CNAME的问题？其实这一想法是被pass掉的。browser发出的請求怎么可能包括CNAME之类的信息的嘛

browser的请求明显还包括一个信息： Host

为了求证这一点，自己写了段请求代码，因为为了看清請求的具体情况，代码是直接使用socket写的：

import socket

import re

import os

import sys

if __name__ == "__main__":

blog_ip = socket.gethostbyname("blog.jessinio.info")

s = socket.socket()

s.connect((blog_ip,80))

s.sendall("""GET / HTTP/1.1

Host: blog.jessinio.info

User-Agent: Mozilla/5.0 (X11; U; Linux i686; en-US; rv:1.9.1.8) Gecko/20100214 Ubuntu/9.10 (karmic) Firefox/3.5.8

Accept: text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8

Accept-Language: en-us,en;q=0.5

Accept-Encoding: gzip,deflate

Accept-Charset: ISO-8859-1,utf-8;q=0.7,*;q=0.7

""")

data = ''

while True:

retval = s.recv(1024)

if not retval: break

data += retval

s.close()

# 第一个空行开始的内容都是browser需要的内容

d = re.search(r'(\r\n|\n)\1(.*)', data, re.S).group(2)

f = open("/tmp/blog.gz", "w")

f.write(d)

f.close()

* 得到的"/tmp/blog.gz"是一个gzip文件, 可以使用gunzip解压一看就明白

从代码可以看到，访问IP之所以不行，是因为ghs.google.com需要得到請求中Host参数

注意: 要想使用自己的域名去访问blogger是需要在blogger后台里配置的, 这一配置才能使ghs.google.com根据不同的Host值得到不出的blogger帐号

数字签名和数据加密

2010-02-26T00:45:00.001-08:00

北京这两天的雾特别大，去逛有些不爽，加上这几天都有出去逛，干脆休息一天，坐着看看文档

好久没有怎么看文档了。

一沉下去，就被"数字签名"这一概念搞得了点乱：

1. 首先是android手机上的不同程序要想为同一个user ID, 一定需要程序的数字签名相同

2. 然后是ubuntu upgrade时出现PGP error。

都是与“签名”这一概念扯上关系的。

沉就沉下去吧。花点时间搞明白。

自己所知道

初见PGP时，大约还是学生時期，那时只知道有PGP这个“东西“，大概了解PGP的用途：保护个人隐私，数据安全。但是中国的一般计算机用户基本就不会理会这种事。

再说, 那时还算是个小小白. 戴着windows的链锁在跳舞。

工作后碰到ssh的，会碰到“公钥“与”私钥“这两个概念。关于这方面的理论就不说了，搜一下就一堆信息出来。

PGP与RSA，DSA的关系

Pretty Good Privacy (PGP) is a computer program that provides cryptographic privacy and authentication. PGP is often used for signing, encrypting and decrypting e-mails to increase the security of e-mail communications. It was created by Philip Zimmermann in 1991.

可以看到， PGP就是一种软件。它利用了“公钥”体系理论。

RSA， DSA为“公钥”体系的一种具体方式。

PGP和GPG

从名字看上去很纠结，它们都是类似的东西

PGP： http://en.wikipedia.org/wiki/Pretty_Good_Privacy

GPG： http://en.wikipedia.org/wiki/GNU_Privacy_Guard

“公钥”体系的加密与解密

RSA（Rivest-Shamir-Adleman）算法是一种基于大数不可能质因数分解假设的公匙体系。简单地说就是找两个很大的质数，一个公开即公钥，另一个不告诉任何人，即私钥。这两个密匙是互补的，就是说用公匙加密的密文可以用私匙解密，反过来也一样

证书与公钥的关系

http://en.wikipedia.org/wiki/X.509 页面可以看到：

In cryptography, X.509 is an ITU-T standard for a public key infrastructure (PKI) for single sign-on (SSO) and Privilege Management Infrastructure (PMI). X.509 specifies, amongst other things, standard formats for public key certificates, certificate revocation lists, attribute certificates, and a certification path validation algorithm.

X.509是证书统一的格式标准

从http://en.wikipedia.org/wiki/Public_key_certificate 看到:

In cryptography, a public key certificate (also known as a digital certificate or identity certificate) is an electronic document which uses a digital signature to bind together a public key with an identity — information such as the name of a person or an organization, their address, and so forth. The certificate can be used to verify that a public key belongs to an individual.

我们平时说的"数字证书"就是这样的一种东西: public key再加上一堆信息按照X.509的格式组成的文件。

申请证书的过程

用户首先产生自己的密钥对，并将公共密钥及部分个人身份信息传送给认证中心。认证中心在核实身份后，将执行一些必要的步骤，以确信请求确实由用户发送而来，然后，认证中心将发给用户一个数字证书，该证书内包含用户的个人信息和他的公钥信息，同时还附有认证中心的签名信息。数字证书由独立的证书发行机构发布。数字证书各不相同，每种证书可提供不同级别的可信度。可以从证书发行机构获得您自己的数字证书。

所谓的签名

从wikipedia里找到一幅很好的图片:

图中说明了签名和认证的过程. 但是有一点没有说明的: 认证签名时怎么确认使用certificate(也就是public key)就是发出者的呢?, 需要实现这种认证, 要有第三方认证机构的存在

* certificate可能会和数据文件一起发出, 也有可能不一起发出.

自签名与第三方认证机构

为了做到证明某一个certificate就是发出者的证书, 出现了第三方认证机构.

说到这里, 已经不是技术问题了. 认证机构比的就是信用. 使用者使用前需要认同的一点: 认证机构上的证书都是可信的.

认证机构有两种性质的:

1. 商业

2. 非商业

注: 不同的认证机构不一定形网络. 有些认证机构是独立的.

利用“公钥”体系对数据进行加密

上面一节: “公钥”体系的加密与解密已经说到了“公钥”体系是可以把数据进行加密的。但是存在一个问题： “公钥“体系的加密与解密速度是很慢的。

在这点上， “公钥”体系远远比不上对称加密方法快。

PGP类型软件则结合了“公钥”体系和对称加密方法。它除了签名功能外，还提供了一种功能：对数据进行加密，实现数据在传输过程中安全性。

实现方法：每次使用PGP软件时，PGP都随机产生一个128位的IDEA会话密钥，用IDEA密钥来加密需要传输的数据（对称加密）。然后使用公钥对IDEA密钥加密，这两次加密的数据被一并传输。通过这种方法间接地保护需要传输的数据内容

**作为C函数参数(2)

2010-01-21T02:44:00.001-08:00

之前写了一篇<<**作为C函数参数>>的文章。今天又看到这个样的代码。不过，比之前的多一点需要注意的地方
在glibc/login/login.c代码里：
static int
tty_name (int fd, char **tty, size_t buf_len)
{
.....((被切掉).....

if (rv == 0)
    /*
      这里 *tty = buf已经修改了tty这个变量指向的空间.
      为什么不在改变前把传入的空间free掉呢?如:
      如果不free掉, 使用这个函数前需要有另外一个变量引用这块空间
      不用调用free, 是因为login里, _tty是一个局部变量, 会在函数退出后自己释放
    */
    *tty = buf;   /* Return buffer to the user. */
else if (buf != *tty)
    free (buf);   /* Free what we malloced when returning an error. */

return rv;
}

作者还是清楚的:
#ifdef PATH_MAX
char _tty[PATH_MAX + UT_LINESIZE];
#else
char _tty[512 + UT_LINESIZE];
#endif
char *tty = _tty;
.....
found_tty = tty_name (STDIN_FILENO, &tty, sizeof (_tty));

看出, 有两个变量指向那块空间. 还是数组, 安全得很呢.

因此, 如果**作为参数时:
1. 如果在函数内, 改变了**指向的内存, 这时, **不是指向通过malloc得到的内存是安全的
2. 否则, 请确保还有其它变量引用之

如:

int len = 100;
char *name = (char *)malloc( len );
char * other = name;
tty_name (1, &name, len)

或者是:

char name[100];
char *new = name;
tty_name (1, &new, sizeof( name ));

这种做法:
char name[100];

char *new = name;

可以像malloc一样得到内存, 但是它比较安全: 会自动根据变量的作用范围释放使用的内存.

这种细节, 处理又麻烦, 不处理又不对. 纠结.... 需要长期的code能力.

man手册里的section 2和section 3

2010-01-20T22:19:00.001-08:00

一直对section 2 和 section 3两个段的API分得不是很开.

section 2和3的说明:
       2   System calls (functions provided by the kernel)
       3   Library calls (functions within program libraries)

当然, 本人是分得到system calls和library calls的.

只是这两者的API有部分是一样的.

可以man 2 setgid和man 3 setgid. 可以发现, 差不多是一个屁样了.

3的存在, 是因为glibc需要有posix标准的一套API. 如glibc的setgid函数其实就是调用了system call的setgid API.

往往对section 2和3的API出现混淆. 举个例子吧:

#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <stdio.h>

int main()
{
int fd = open("/tmp", O_DIRECTORY|O_RDONLY);
if(fd >=0)
    printf("sucess\n");
else
    printf("no sucess\n");
}
编译时使用: gcc /tmp/c2.c -D _GNU_SOURCE -o /tmp/a.out
这时的open是使用system call的open, 可以打开一个文件夹的, 手册是man 2 open里说的内容.

如果不用_GNU_SOURCE这个宏的话, 就是man 3 open里说的内容

对特同名这种函数, 使用了宏去控制

取大文件最后N行数据

2010-01-20T09:00:00.001-08:00

取大文件最后N行数据, 这个问题, 如果是我想的话, 就直接往'\n'字符里去想了:
1. 使用seek, 从后面读一块数据出.
2. 数'\n'的个数.

看到人家这样做:

import os

def tail (name, n_line):
    lines = []
    f = file (name)
    n = 1
    while len(lines) <= n_line:
        try:
            // -n_line * 80 是一个大概猜测的一块数据长度

            f.seek (-n_line * 80 * n, os.SEEK_END)

            // 当 len( lines ) > n_line 才跳出循环, 其中, lines[0]行的数据不一定是完整的
            // 这代码的好处就是当最小条件跳出循环时, len( lines ) ==4 . 就算lines[0]是不完整的数据也没有关系. 因为只想取len(lines) - 1 行的数据.

           lines = f.readlines()

            n = n + 1
        except:
            lines = f.seek (0, os.SEEK_SET)
            lines = f.readlines ()
            break
    return lines[-n_line:]

[] 操作符用于函数参数

2010-01-20T02:48:00.001-08:00

glibc/locale/setlocale.c文件里

113 /* Construct a new composite name. */
114 static char *
115 new_composite_name (int category, const char *newnames[__LC_LAST])

这种代码奶奶的还真没有看过. 一般都是直接使用指针做参数的. 这里使用了 数组的形式 做参数. 有什么好处呢?

朋友给出了一个简单的例子说明了道理:
#include <stdio.h>
void test(char *p[2])
{
puts(p[1]);
}

int main()
{
char *p[2] = {"hello\0","world\0"};
test(p);
}
输出为:
world

之所以使用数组的形式传参, 主要是为了方便地址偏移方便. 如果不是这样的话, 偏移时需要计算一下, 自己的例子说明:

void test(char **p)
{
   puts(*(p + 1));
}

int main()
{
   char *p[2] = {"hello\0","world\0"};
   test(p);
}

重点被颜色的文字标出

顺便来一个整数偏移:

void test(char **p)
{
   // convert pointer to int
   int number = (int )p;
   // convert int to pointer
   // 可以看出, 指针变量加1是偏移4bytes, 如果使用整数的话, 还需要自己计算
   p = (char **) (number + 4);
   puts(*(p));
}

int main()
{
   char *p[2] = {"hello\0","world\0"};
   test(p);
}

**作为C函数参数

2010-01-20T01:33:00.001-08:00

C的指针一旦多层. 读代码是相当难理解.

glibc/string/argz-ctsep.c里:

26 error_t
27 __argz_create_sep (const char *string, int delim, char **argz, size_t *len)

这个参数有一个char **argz, 很难理解是什么意思.

后面想通了这种做法意义.

1. 指针: 期待函数可以对指向的内存进行修改, 从而得到返回值. (除指针使用const修饰)
2. 指针的指针: 期待函数返回指向一块内存的地址.

举个例子
指针的情况:
extern int change( char *buffer);
char *buffer = (char *)malloc(100);
change(buffer);
* change函数会修改buffer内存

指针的指针的情况:
extern int change( char **buffer);

char *buffer = NULL;

change( &buffer );
* change函数会返回一块已经被修改的内存.

再看一组函数:
1. char *ttyname(int fd);
2. int ttyname_r(int fd, char *buf, size_t buflen);

参数是char *buf。可以猜测。 ttyname_r会对一块已经申请的内存进行修改。因为内存在函数体里无法知道长度，所以就有size_t buflen参数。因此使用时是这样的：

size_t buflen = 100;
char *buffer = (char *) malloc( buflen ); #这是一定事先申请的
if ( ttyname_r ( 1, buffer, buflen ) ){
...do_you_want....
}

如果 glibc是提供了一个这样的函数: int ttyname_r(int fd, char **buf);

那么使用时就可以:
char *buffer=NULL;
if ( ttyname_r ( 1, &buffer ) ){

...do_you_want....

}

这样感觉传少了参数, 还少打代码.

但是用法没有绝对的! 这样总结只是为了看代码是容易有方法

string.h里的函数的maxlen限制

2010-01-17T01:21:00.001-08:00

maxlen是指最大长度。第一次注意到maxlen这个参数是在：
size_t __strnlen (const char *str, size_t maxlen)

C里，对内存的操作常常是一个循环，针对于字符串的话，循环的退出条件常常是: 一个特定的字符

1. 如'\0'
2. strchr的第二个参数

这样, 在历遍这块内存时, 需要程序员明白一点: 自己是否确认1和2的字符串在你操作的内存中?

否则, 这将是很危险的. 举个例子:

void main(int argc, char *argv){
char a[10], b[10];
memset(a, 'b', 10);
a[5] = '\0';
//这里证明a的址址比b的高
printf("a - b = %d\n", (int)(a - b));
//b长度就会有问题
printf("strlen(a): %d, strlen(b): %d\n", strlen(a), strlen(b));
//应该使用strnlen函数!, strlen和strnlen的区别就在于maxlen
printf("strnlen(a): %d, strnlen(b): %d\n", strnlen(a, sizeof(a)), strnlen(b, sizeof(b)));
}
输出:
a - b = 10
strlen(a): 5, strlen(b): 15
strnlen(a): 5, strnlen(b): 10

如果在使用strlen的同时, 使用memset函数, 将会是灾难性的

按照这一种考虑, 把glibc/string下的函数分成如下

	no maxlen	optimize	maxlen	optimize	information
copy
	strcpy	No	strncpy	Yes	strncpy(s1, s2, maxlen) 如果maxlen > strlen(s2), 那么剩下的都用'\0'填充. 使用strcpy最后一个也为'\0'
			memset	Yes
			memcpy	Yes
			memccpy	No	memccpy(dest, src, '\0', maxlen)与strncp差不多,但是最后只有一个'\0'
			mempcpy	Yes	与memcpy相似
duplicate
	strdup	Yes	strndup		两者的区别是调用strlen或者调用strnlen 最后都调用 memcpy 最后byte为'\0'
find
	strchr	Yes	memchr	Yes
	strrchr	Yes	memrchr	Yes	strrchr调用strchr
	strchrnull	Yes
	strstr	Yes	memmem	Yes	using a linear algorithm with a smaller coefficient.
	strcasestr	Yes
length
	strlen	Yes	strnlen	Yes
compare
	strcmp	No	strncmp	Yes
			memcmp	Yes
	strcasecmp	No	strncase	No

concatenate
	strcat	No	strncat	Yes
move
			memmove
set
	strspn
	strcspn
other
	strfry
			strxfrm

* optimize的意思是被多个字节一起操作, 或者可以被compiler优化

PS:: 为了安全, 还是有mexlen参数的函数靠谱, 再者, 有maxlen的函数会快

NULL, 0x00, '\0'怎么看都是一个东西

2010-01-15T22:30:00.001-08:00

void main(int argc, char *argv){
char a = '\0';
char b = (char ) 0x00;
char c = (char )NULL;
if ( a == b) printf("OK\n");
if ( a == c) printf("OK\n");
}

输出結果为：
OK
OK

只是NULL对compiler来说，会测试变量的类型，如：
char c = NULL;
会报： warning: initialization makes integer from pointer without a cast

如果不信息(char )NULL和 NULL是相同的数值的话，可以使用：
grep -r "define NULL"
可以看到：
define NULL (0)
define NULL 0
define NULL ((void*)0)

数组的长度

2010-01-15T20:06:00.001-08:00

用高级语言用惯了，想到得长度时，一般有函数可以得到。对于C的数组，我也是这样想的。至少还有一个sizeof

晚上和网友聊C的时候，他贴了不少自己的笔记，其中有这样一段：
* 在函数参数中，array和*是一回事

从文字中, 我很明白它说的是什么意思. 但是很深的一层, 我还不了解数组, 连sizeof都不了解.

后面. 我在分析glibc/string/strlen.c的代码时, 这个问题让我重新深刻了解

在使用malloc分配空间时, 程序员是应该确切了解空间长度的. 否则后果严重.

那么, 数组的长度呢? 如:
void main(int argc, char *argv[])
{
char s[10];
printf("%d\n", sizeof(s));
}
输出为10

这个sizeof就让本人感觉到: 数组的长度是随时都可以得到的. 真是这样吗?

strlen.c的代码就让我提出了这个疑問:
1. 在strlen.c的函数出, 根本就没有sizeof的出现. 它就一个死循环, 去测试第一个'\0'.
2. 如果在某种情况下, 不知道参数的长度, 只有一种結果: 非法引用. 关于Segmentation, 可见: http://en.wikipedia.org/wiki/Segmentation_fault
* 某种情况是指刚刚好一直找不到'\0'

在使用strlen.c得到Segmentation fault, 是相当crazy的事!

数组参数也一样有这个问题, 这不是strlen.c里不使用sizeof的问题. 是因为sizeof也无法知道! 来个例子:

void print_len(char *p){
printf("%d\n", sizeof(s));

}

void main(int argc, char *argv[])
{
char s[10];
print_len(s);
}

gcc直接就报错. 因为sizeof不能这样用. 可以大概猜出, sizeof的結果是编译器在编译时得到的值. 不是run time得到的.

可以猜出, 数组与malloc得到的连续空间的比较:
1. char a[10] 等于 char * const a = malloc(10);
2. 数组多一个在编译时得到长度的可行性
* char * const 和const char * 可是不同的哦

PS:
怪不得go lang的数组参数在调用时, 被要求测试数组的长度. 原来不是为了安全.
看来go lang像C一样强大, 又要比C安全, 是有道理的.

数另一种计算方法

2010-01-15T11:45:00.001-08:00

朋友说, 这种技术可以从这书中得到: www.hackersdelight.org

只是没有必要去看. 了解这种用法, 只是为了看懂glibc罢了. 没有它意.

得到负数的方法

C语言里的“位与”， “位或“， ”取反“，在数的计算中，相当活用。

void main(int argc, char *argv[])
{
printf("%x\n", 2);
printf("%x\n", -2);
printf("%x\n", ~2);
printf("%x\n", ~2 + 1);
}
输出結果：
2
fffffffe
fffffffd
fffffffe

可以得到 -2 == (~2 + 1)

实际上就是补码: http://baike.baidu.com/view/377340.htm

divmod的算术

在glibc/string/strncmp.c中, 可以看到divmod的方法:

size_t n4 = n >> 2; n4就是商

n &= 3; 就是除以4后的余数. 因为最后两位情况是0到3, 不可能被4除.

">>"和"<<"只合适乘以2^n和除以2^n

用"&"求余又要方便, 只合适求除以2^n后的余数.

余数的求法

和前面的divmod有关系, 都是余数的问题, 只是不够深刻, 来一个深刻一些的例子:

代码来自于glibc/string/strnlen.c

/* Handle the first few characters by reading one character at a time.
     Do this until CHAR_PTR is aligned on a longword boundary. */
for (char_ptr = str; ((unsigned long int) char_ptr
      & (sizeof (longword) - 1)) != 0;
       ++char_ptr)
    if (*char_ptr == '\0')
      {
if (char_ptr > end_ptr)
    char_ptr = end_ptr;
return char_ptr - str;
      }
longword其实就是long int , 等于本人的电脑等于4
上面蓝色的代码就是求除以 longword 后，余数是否为0

import只是一次

2010-01-07T22:56:00.001-08:00

下面是测试过程：

In [7]: import sys

In [8]: os
---------------------------------------------------------------------------
NameError Traceback (most recent call last)

/home/jessinio/data/workspace/project/<ipython console> in <module>()

NameError: name 'os' is not defined

In [9]: sys.getrefcount( sys.modules['os'] )
Out[9]: 58

In [10]: import os

In [11]: sys.getrefcount( sys.modules['os'] )
Out[11]: 59

In [12]: id( sys.modules['os'] )
Out[12]: 3078271308L

In [13]: id( os )
Out[13]: 3078271308L

golang中的迭代

2010-01-07T20:40:00.001-08:00

python中的这种功能：

for key, value in a.items(): print key, value

go language也有这种功能：

func main() {
    var infomation string = "中国比美国好多了.";
    fmt.Println( infomation );
    //是unicode吗? 答案:否
    fmt.Println( len( infomation ) );
    fmt.Printf("%c\n", infomation[0]);
    for index, value := range infomation {
        //%c与C中的%c不同      the character represented by the corresponding Unicode code point
        fmt.Printf("%d:%c ", index, value);
    }
}
输出結果：
中国比美国好多了.
25
ä
0:中 3:国 6:比 9:美 12:国 15:好 18:多 21:了 24:.

range一个string时，为unicode code point，而不是byte

golang中的字符串

2010-01-07T08:01:00.001-08:00

golang的String type与python的basestring实例差不多.

immutable

python里str的情况:
In [3]: name = str("abcde")
In [4]: name[1]
Out[4]: 'b'
In [5]: name[1] = "3"
TypeError: 'str' object does not support item assignment

python里unicode的情况:
In [6]: name = unicode("abcde")
In [7]: name[2]
Out[7]: u'c'
In [8]: name[2] = u'f'
TypeError: 'unicode' object does not support item assignment

golang中的string类型也是immutable的:

func main() {

    var name string = "abcd";
    fmt.Printf("%c\n", name[2]);
    //这种修改将会产出错
    name[1] = 'c';
    //只能得到string变量的开始地址.
    fmt.Printf("%p\n", &name);
    //下面会报错，因为不能求元素的地址!
    fmt.Prinft("%p\n", &name[2]);

}

string literals

在字符串上, golang使用三种符号:
1. 单引号: 与C一样, 表示是byte,
2. 双引号: 与C一样, 表示N种byte, 只是golang中不可以修改和求元素的地址.
3. 反引号: 不解释字符串的转义符.

python中也有这三种用法, 只是使用的表达方式:
1. 单(双)引号: 表示N种chr实例的集合
2. u开头的unicode string literals，还没有发现golang有unicode string literals
3. r开头的string literals:

In [10]: print r'a\nb'
a\nb

unicode问题

双引号得到的是不可修改的byte集. 不是unicode类型!

下面做一个测试, 先得到一个汉字的外码和unicode码:
In [14]: u'中'
Out[14]: u'\xe4\xb8\xad'
In [15]: unicode('中', "utf-8")
Out[15]: u'\u4e2d'

再看golang的代码:

func main() {
    var infomation string = "\u4e2d"; //使用unicode的标志法, 也无法改变string就是byte集的现实!
    fmt.Println( infomation );
    //是unicode吗? 答案:否
    fmt.Println( len( infomation ) );
    fmt.Printf("%x", infomation);
}

输出的結果是:
中
3
e4b8ad

golang中怎么样python一样，有unicode string literals呢？答案：没有！

只有使用函数得到。

golang中的slice

2010-01-07T06:57:00.001-08:00

slice 数据类型大概原理是这样的:

type Slice struct {
base *elem_type;
len int;
cap int;
}

最容易和数组乱的就是下面的这样声明：
var a []int;

空长度表示变量是一个slice type，不是空数组。

下面的使用方式：
var slice = []int{ 1,2,3,4,5 }; //这是产生一个数组, 然后产生一个slice
* 在这种背后创建了数组的情况, golang提供了reslice和cap函数功能

与下面的是不同的:
var ar = [...]int{ 1,2,3,4,5 };

golang中的slice与python中的list的slice是不同的.
1. [:8] 没有隐含的开始方式, 也没有隐含的结束方式
2. [1:999999999] 超出不等于到最后, 报错!
3. 没有负数的end, 报错.

func main() {
    //创建一个slice, 它是引用[8]int的
    ar := []int {0, 1, 2, 3, 4, 5, 6, 7};
    //slice类型支持reslice, 調整它的引用情况
    ar = ar[2:4];
    fmt.Printf("length: %d\n", len(ar));
    fmt.Println(ar[0]);

    //怎么重新引用[8]int的完整长度呢? 答案是否定的
    //提供了cap()函数
    ar = ar[0:cap(ar)];
    fmt.Printf("length: %d\n", len(ar));
    fmt.Println(ar[0]);
}

输出結果是:
length: 2
2
length: 6
2

reslice无法修改slice的起始地址. 只能修改结束地址. capacity的长度会保存不变(除非引用了其它数组)

一步产生数组和slice变量:

var a = &[100]int{};

但是这样是不行的:

var a = &[100]int;

还可以使用make()函数:
a := make([]int, 100);

make([]int) 是等于[]int , 为一个slice对象

new([]int) 返回 *[]int , 为指向slice的指针变量.

golang中的指针数组

2010-01-06T22:59:00.001-08:00

在golang的文档里没有看到怎么声明指针数组的例子（不知道是不是自己看漏了）

文档里本人只看到“指向数组的指针”的声明。如：
var p2array *[3]int;

不知道什么时候突然一个想法就出来了：
var pointers [3]*int;
这就是指针数组的声明。和文档里说的指向数组的指针的声明是不同的。

试了一下，还真的可以的，牛B！！

import "fmt"
func main() {

    var ar [3]*int;
    //这是真的吗?
    fmt.Println(len(ar));

    value := new(int);
    *value = 3;
    //存放指针
    ar[0] = value;
    fmt.Println(*(ar[0]));

}

amule下载完的文件名乱码问题

2010-01-05T06:59:00.001-08:00

最近使用amule的次数比较好, 发现amule像一个金矿, 里面太奶奶的多好货了.

当然, 也不是白取的, 从我notebook上upload的数据都有33G多了. 下载点也是正常的.

不过, 奶奶的, 今天在Incoming里找文件, 无法忍受amule下载的文件名是乱码一事~ 决定清理!

In [76]: f = os.listdir('.')

In [77]: for i in range(len(f)):
                   if f[i].startswith("LINUX"):
                           print i
Out[77]: 8
找出自己要试验的一条文件名

乱码, 一般都是gbk编码吧, 于是:
In [81]: print f[8].decode("gbk")
-------> print(f[8].decode("gbk"))
LINUX莽鲁禄莽禄聼莽庐隆莽聬聠忙聤聙忙聹炉忙聣聥氓聠聦茂录聢莽卢卢2莽聣聢茂录聣.pdf

顶~~~~~~ 屁都不是. 又试了几种编码都不行~~~~ 试多了几次, 发现一个现象:

In [87]: f[8].decode("utf-8")
Out[87]: u'LINUX\xe7\xb3\xbb\xe7\xbb\x9f\xe7\xae\xa1\xe7\x90\x86\xe6\x8a\x80\xe6\x9c\xaf\xe6\x89\x8b\xe5\x86\x8c\xef\xbc\x88\xe7\xac\xac2\xe7\x89\x88\xef\xbc\x89.pdf'

In [88]: print "\xe7\xb3\xbb"
-------> print("\xe7\xb3\xbb")
系

* 从上面取出的一段外码, 是可以正确显示的. 看来amule是把unicode的文件名直接给str()成raw string串了. 乱码就是这样产生的：

In [108]: c = u'梁'

In [109]: c
Out[109]: u'\xe6\xa2\x81'

In [110]: str(c)
Out[110]: '\xc3\xa6\xc2\xa2\xc2\x81'

In [111]: print str(c)
--------> print(str(c))
æ¢

现在的问题是怎么把上面一串为unicode的外码整成raw string呢?

现在的目标是把u'\xe7'转成'\xe7'，如下方法：
In [153]: chr(ord(u'\xe7'))
Out[153]: '\xe7'

OK，妈的。一个for处理完你～～～狗日的乱码

#!/usr/bin/env python
# coding: utf-8
import os

DIR="/home/jessinio/.aMule/Incoming"

for f in os.listdir( DIR ):
    print f
    retval = []
    for i in f.decode("utf-8"):
        # 文件名本身没有乱码的情况时，会是unicode, 这时ord的值为unicode的内码，超过256
        if ord(i) > 256:
            retval.append(i.encode("utf-8"))
        else:
            retval.append(chr(ord(i)))
    print ''.join(retval)
    os.rename( os.path.join(DIR, f), os.path.join( DIR, ''.join(retval) ) )

golang中的指针

2010-01-05T01:18:00.001-08:00

总结一下golang中的指针与C语言的指针的用法.

总体一致:
C的代码:
    int *number;
    number = (int *) malloc(sizeof(int));
    *number = 3;
    printf("%d\n", *number);

golang的代码:
    var pointer *int;
    pointer = new(int);
    *pointer = 3;
    fmt.Println(*pointer);

多重指针情况:
C的代码:
    int **outer;
    int *inter;
    inter = (int *) malloc(sizeof(int));

    *inter = 3;
    outer = &inter;
    //地址一样
    printf("%p\n", inter);
    printf("%p\n", *outer);
    //值一样
    printf("%d\n", *inter);
    printf("%d\n", **outer);

golang的代码:
    var outer **int;
    var inter *int;
    inter = new(int);
    *inter = 3;
    outer = &inter;
    //地址一样
    fmt.Println(inter);
    fmt.Println(*outer);
    //值一样
    fmt.Println(*inter);
    fmt.Println(**outer);

C语言的下面这种方式在golang里实现:
    int **outer;
    int *inter;
    inter = (int *) malloc(sizeof(int));
    outer = (int **) malloc(sizeof(int));

    *inter = 3;
    *outer = inter;
    //地址一样
    printf("%p\n", inter);
    printf("%p\n", *outer);
    //值一样
    printf("%d\n", *inter);
    printf("%d\n", **outer);

在golang中:
    var inter *int;
    var outer **int;
    inter = new(int);
    *inter = 3;
    outer = new(*int);
    *outer = inter;
    //地址一样
    fmt.Println(inter);
    fmt.Println(*outer);
    //值一样
    fmt.Println(*inter);
    fmt.Println(**outer);

上面都是在玩指针, 下面看看基本的数据结构

基本的数据结构有: 数组与结构体 (map和树之类的不在討論范围)

golang中的数组与C中的数组有很大的差别

golang中的数组是这样说的: Arrays are values, not implicit pointers as in C.

0. 数组做参数时, 需要被检查长度.
1. 变量名不等于数组开始指针!
2. 不支持C中的*(ar + sizeof(int))方式的指针移动. 需要使用到unsafe包
3. 如果p2array为指向数组的指针， *p2array不等于p2array[0]

例子0 数组做参数时, 需要被检查长度.

func use_array( args [4]int ){

    args[1] = 100;
}

func main() {
    var args = [5]int{1, 2, 3, 4, 5};
    use_array(args);
    fmt.Println(args);
}

编译出错: cannot use args (type [5]int) as type [4]int in function argument, 需要有长度上的检查

例子1 变量名不等于数组开始指针!

func use_array( args [4]int ){
    args[1] = 100;
}

func main() {
    var args = [5]int{1, 2, 3, 4, 5};
    use_array(args);
    fmt.Println(args);
}

输出結果是 [1 2 3 4], 没有保存結果, 数组名的用法与C的不一样. 在golang里是这样的:

// 又长度检查, 也为地址传参
func use_array( args *[4]int ){
    args[1] = 100; //但是使用还是和C一致, 不需要别加"*"操作符
}

func main() {
    var args = [4]int{1, 2, 3, 4};
    use_array(&args); //数组名已经不是表示地址了, 需要使用"&"得到地址
    fmt.Println(args);
}

例子2 如果p2array为指向数组的指针， *p2array不等于p2array[0]
对比一下C和golang在这方面的差别：
void main(int argc, char *argv[]){
    int *p2array;
    p2array = (int *) malloc(sizeof(int) * 3);
    //等于p2array[0]
    *p2array = 0;
    printf("%d\n", *p2array + 1);
}
* 输出为1

func main() {
    var p2array *[3]int ;
    p2array = new([3]int);
    fmt.Printf("%x\n", *p2array + 1); //不管p2array是指针变量还是数组变量, 都只能使用"[]"方式使用
}
* 报错.

golang中的结构体也与C中的有差别

下面的方式是相当一致的:
C版本的:
    typedef struct
    {
        int x;
        int y;
    } Point;

    Point p;
    p.x = 10;
    p.y = 20;

    //开始地址
    printf("%p\n", &p);
    //某元素地址
    printf("%p\n", &(p.x));

golang版本的:
    type Point struct{
        x int;
        y int;
    };

    var p Point;
    p.x = 10;
    p.y = 20;
    fmt.Printf("%p\n", &p);
    fmt.Printf("%p\n", &(p.x));

使用allocate的方式:
C代码:
    typedef struct
    {
        int x;
        int y;
    } Point;

    Point *p;
    p = (Point *) malloc(sizeof(Point));
    p->x = 10;
    p->y = 20;

    //开始地址
    printf("%p\n", p); //地址
    //某元素地址
    printf("%p\n", &(p->x));

golang代码:
    type Point struct{
        x int;
        y int;
    };

    var p *Point;
    p = new(Point);
    p.x = 10;
    p.y = 20;
    fmt.Printf("%p\n", p); //地址
    fmt.Printf("%p\n", &(p.x));

也可以说是一样的, 只不过在使用结构中的元素时没有了"->"操作符:
There is no -> notation for structure pointers. Go provides the indirection for you.

结构体的地址传参与数组的方式一样, 当然, 和C的风格也是一模一样的. 如下例子:

C代码:
#include <stdio.h>
#include <stdlib.h>
typedef struct
    {
        int x;
        int y;
    } Point;

void use_struct(Point *arg){
    arg->x = 100;
}

void main(int argc, char *argv[]){

    Point *p;
    p = (Point *) malloc(sizeof(Point));
    p->x = 10;
    p->y = 20;

    use_struct(p);
    printf("%d\n", p->x);

}

golang代码:
import "fmt"

type Point struct{
    x int;
    y int;
};

func use_sturct( p *Point ){
    p.x = 100;
}

func main() {

    var p *Point;
    p = new(Point);
    p.x = 10;
    p.y = 20;
    use_sturct(p);
    fmt.Printf("%d\n", p.x);
}

总的来说......

在传参方面, 大体上看与C的相同:

f(ar); // passes a copy of ar

fp(&ar); // passes a pointer to ar
* 只是变量名是不是表示首个地址有区别

"&" 与C语言一样是得到变量的指针. 与C有点不同，取golang中指针指针的内容的值是不需要使用"*"操作符的，但是指针的指针(或者继续多层时)需要显式使用"*"符号.
在http://golang.org/doc/go_spec.html#Selectors 一节中有描述。

* 三层以上的指针使用是比较少的. 两层还是常见, 如main函数的参数char * argv[]

man命令出现 ESC[ 控制符

2010-01-04T01:39:00.001-08:00

安装gentoo时，出现使用man查看手册时出现一堆 ESC[ 之类的字符。
这些字符是consolse下的颜色控制。

了解了一下。原来man命令也是调用外部程序来显示的。三个选项：
-P, -B, -H

然后对比一下ubuntu下的man和gentoo下的man，发现不同的man手册这方面已经变化。

下面是gentoo的(man version 1.6f)
       -P pager
              Specify which pager to use. This option overrides the MANPAGER environment variable,
              which in turn overrides the PAGER variable. By default, man uses /usr/bin/less -is.

下面是ubuntu9.10的(man 2.5.6)
       -P pager, --pager=pager
              Specify which output pager to use. By default, man uses pager -s. This option overrides the $MAN‐
              PAGER environment variable, which in turn overrides the $PAGER environment variable.   It is not
              used in conjunction with -f or -k.

调用的程序已经不同.

在不安装pager程序下, 可以使用less程序的-R参数

       -R or --RAW-CONTROL-CHARS
              Like -r, but only ANSI "color" escape sequences are output in "raw" form. Unlike -r, the
              screen appearance is maintained correctly in most cases. ANSI "color" escape sequences
              are sequences of the form:

所以, 让gentoo下的man不出现一堆 ESC[ , 可以:
export PAGER='less -R'

go语言的声明

2009-12-29T06:43:00.001-08:00

看go主页上的介绍时，有点给我还不解的做法：就是变量声明时的语法。

golang的声明语言如下：

keywork var_name type = value

1. keywork包括：var, const, type, func
2. var_name为变量名
3. type为变量的类型（与keywork中的type有区别）

看过的语言一就是没有类型，一就是把类型放在变量名前面：表示这个变量是什么类型。

感觉很自然。但是golang就反这个习惯。把类型的位置反过来了。

在golang的手册上给出了两个原因：

原因一: Also functions read better and are consistent with other declarations.

说是与函数形式一致

golang中的函数的定义方式：
func sum(a, b int) int { return a + b }

golang中的变量的定义方式：
var p, q *int

大概的意思是：
keywork var_name type
函数的声明关键字 函数名返回值类型

原因二: short declaration

golang中的变量声明有两种缩写方式：
var var_name = value
* 放在后面就方便缩写, 成为没有类型的写法?
* 不过看上去真的比较像javascript的声明

这时没有了类型，类型为根据value的类型决定

还有一种缩写：
var_name := value
* 这就像python的声明了

顺眼了~~~~

想了一下, 感觉还是不错的. 当我们想声明一个变量时:
1. 想到var ( 想到一个keywork, 因为它是语言的一部分 )
2. 想到变量的名称var_name
3. 想到变量的初始化. (1)这时的初始化golang是提供缩写方式的. 这就与平时的脚本一样. (2)当不想这时初始化时, 再定下这个变量的类型(毕竟golang是强类型语言)

也是很好的一种使用感觉.( 个人的感觉~~~~ )

BTW:: 其实上, golang在你没有初始化的情况下它会帮你初始化. 称为'zero value', 这个值会根据变量的类型变化. 如下:
The zero value depends on the type: integer 0, floating point 0.0, false, empty string, nil pointer, zeroed struct, etc.

安装golang玩玩

2009-12-28T10:11:00.001-08:00

make软件只有两种結果：
1. 通过
2. 不通过

-_- ! 等于没有说～～。其实我想说的是：
1. 通过：表示程序的源代码没有问题的情况。与用户的环境有没有配置好没有关系
2. 不通过：表示程序的源代码本身就有问题。

之前下载chromium下来make就有这样的问题：人家还在开发，刚好check out了一份有问题的版本下来make。那是浪费时间。
* 就算是ubuntu的daily build都不是每天都make得过的。

今天我取得的是changeset:   4476的代码。可以make得过。
顺便看看那个牛B人最新的提交：

changeset:   4398:683ed10f7832
user:        Ken Thompson <ken@golang.org>
date:        Sat Dec 12 14:36:52 2009 -0800
summary:     more on the optimizer

golang的主页上其实就写得很清楚了。只是有个容易出问题的地方： enviroment variable一节。

请老实把提到的每个环境变量都export一次。如果$GOBIN不是在PATH中的话，请：
export PATH=${PATH}:${GOBIN}/bin

其实只是这句需要注意的。

C中检测头文件的存在

2009-12-28T00:30:00.001-08:00

C中没有像python的try語句, 当需要引入系统的函数时会有个问题, 例子:

1. 使引入外部函数时更加友好

try:
    import lxml
except:
    print "no exist lxml module"
    sys.exit()

2. 根据情况使用不同的函数

try:
   import lxml
except:
    try:
   import xml
    except:
       print "no exist lxml and xml module
       sys.exit()

在看同事的代码分析后, 知道了C是怎么处理这种问题: 使用preprocessor处理:

# if ! defined _SYS_TYPES_H
you must include <sys/types.h> before including this file
# endif

这将会产生错误, 不被编译. 这就把问题放在一个宏中. 那么这个宏是怎么获得的呢?

这个问题抛给了GNU autoconf. 在autoconf产生的configure文件被运行后, 会产生一个叫config.h的头文件, 里面将会有系统所有的头文件的宏.

如果C程序需要安全地使用外部函数. 这种机制无疑可以使编译过程更加友好.

locale

2009-12-27T08:46:00.001-08:00

python这部分与libc的函数相似.

setlocale函数有两种用法:
1. 取得指定项的值: 第二个参数为None(Null)

In [5]: locale.setlocale(locale.LC_CTYPE,None)
Out[5]: 'en_US.UTF-8'

2. 设置locale
默认的locale都是C.
设置为指定的locale
In [6]: locale.setlocale(locale.LC_CTYPE, 'en_GB.UTF-8')
Out[6]: 'en_GB.UTF-8'

当setlocale的第二个参数为空字符串时, 使用父进程的locale
In [2]: locale.setlocale(locale.LC_CTYPE, None)
Out[2]: 'C'

In [3]: locale.setlocale(locale.LC_CTYPE, '')
Out[3]: 'en_US.UTF-8'

与locale有关的几个环境变量
LC_*
LC_ALL
LANG

当LANG被定义, LC_*又没有定义时, LC_*都使用LANG的值, 当LC_*单独定义时, 会覆盖LANG的值.
当LANG没有被定义时, LC_*都为"POSIX"
当LC_ALL被定义时, LC_*都被强制使用LC_ALL的值, 这是最高的策略.

还有一个GNU里定义的环境变量: LANGUAGE 它的作用与LC_MESSAGE的作用一致.

http://www.opengroup.org/onlinepubs/009695399/basedefs/xbd_chap08.html#tag_08_02

gcc的预处理选项

2009-12-27T08:37:00.001-08:00

C的预处理选项在代码里很常见. 对控制生成的目标代码有控制作用. 如:
int main()
{
     do_something();

#ifdef __DEBUG__
     printf("__DEBUG__ DEFINED\n");
     printf("%d\n",A);
#endif

    return 0;
}

可以通过__DEBUG__去控制是否加入测试代码. 现在就有个问题: 怎么在编译时改变这一个值? 如:
#if __DEBUG__ == 1

难道要去修改源文件? 显然这是不对的做法. gcc是有参数去处理这些东西:
-D name=definition

-U name

下面做做测试:
jessinio@jessinio-laptop:/tmp$ cat test.c

void *main(int argc, char *argv[]){

#ifdef __DEBUG__
    printf("%s\n", "debug info");
#endif

}

jessinio@jessinio-laptop:/tmp$ gcc -E test.c
# 1 "test.c"
# 1 "<built-in>"
# 1 "<command-line>"
# 1 "test.c"

void *main(int argc, char *argv[]){

}

可以看出, 因为没有那个__DEBUG__ 宏, 所以printf没有被加入代码中. 如下就可以:
jessinio@jessinio-laptop:/tmp$ gcc -E -D__DEBUG__ test.c
# 1 "test.c"
# 1 "<built-in>"
# 1 "<command-line>"
# 1 "test.c"

void *main(int argc, char *argv[]){

    printf("%s\n", "debug info");

}

不过这有个问题, 就是每次都是在gcc命令中这样的参数不是很难看? 环境是环境变量? 找个Makefile看一下就知道了
看到这句:
# Compiler options
OPT=        -DNDEBUG -g -fwrapv -O3 -Wall -Wstrict-prototypes

很明显, 是使用变量的方式. gcc怎么知道呢?
又看到这句话:
$(CC) $(OPT) $(LDFLAGS) $(PGENOBJS) $(LIBS) -o $(PGEN)

很明显, 就是在命令行中指定~~~~ (-_-)!