Co-Create Developers Portal - 杨红的 Blog

Plone 升级到 2.5.2

2007-02-01T15:41:41+00:00

仍然使用 zope 2.8.8，第一次升级由于没有更新 Five (1.2.5)，导至升级后无法访问首页（所有 catalog 中内容丢失？），更新 Five 到 1.2.6 后，重新进行升级过程，没有任何问题就完成了。

Five 下载址： http://codespeak.net/z3/five/

呆会儿还要装个投票系统。

http://plone.org/products/plone-survey

PloneSurvey is a simple product written to collect data from people
- feedback on a course, survey, simple data collection etc.

非常强大！

共创开源产品改进与完善客户问卷调查表

http://www.opendesktop.net/development/survey/ccoss-products-survey

客户那边吃食堂

2006-08-26T09:08:32+00:00

食堂更好，可是这帮大爷们居然吃那么少，而且吃的奇快，我才还没吃完呢，人家已经要撤退了

为 Blog 添加中文名 URL 支持

2006-08-17T19:14:22+00:00

中文-> zhongwen

Plone 2.1 + ZopeChinaPack 0.8+ 早已经支持创建的文档自动生成标题对应的 ID（URL 中的部分），当然，中文文字被转换成拼音做为 ID。

我们使用的 Quills 0.9.1 则使用了自己的过滤函数来处理标题并设置为 blogentry 的 ID，从而不支持中文转换为拼音导致如下问题：

输入标题："升级 python doctutils"

自动生成的 ID: "-python-docutils"

其中的中文没了。

我修改了生成 id 的部分，这样 blogentry 和 topic 都可以自动转换为拼音了。

补丁如下：

--- QuillsTool.py.orig  2006-08-17 19:10:03.661645184 +0800
+++ QuillsTool.py       2006-08-17 19:11:06.882034224 +0800
@@ -24,6 +24,7 @@
 from Products.CMFCore.utils import UniqueObject
 from Products.CMFCore.utils import getToolByName
 from AccessControl import ClassSecurityInfo
+from Products.Archetypes.utils import shasattr
 from OFS.SimpleItem import SimpleItem
 from Globals import InitializeClass
 import re
@@ -89,7 +90,13 @@
         """

         #  could use string.replace for the ''/- thing
-        id = re.sub('[^A-Za-z0-9_-]', '', re.sub(' ', '-', title)).lower()
+        plone_tool = getToolByName(self, 'plone_utils', None)
+        if plone_tool is None or not shasattr(plone_tool, 'normalizeString'):
+            # Plone tool is not available or too old
+            # XXX log?
+            id = re.sub('[^A-Za-z0-9_-]', '', re.sub(' ', '-', title)).lower()
+        else:
+            id = plone_tool.normalizeString(title)

         if not id:
             # We only do this for thingys in weblogs

参考：

在Plone脚本中进行汉字到拼音的转换

升级 python-docutils 0.4

2006-08-17T18:10:50+00:00

python-docutils 是用于处理 reStructured Text 的工具。

原来服务器上是 0.3.7, 0.4 对中文处理有很大的提高。希望可以解决在 Bug 跟踪系统提交 Bug 时的异常错误问题。

还升级了 ZopeChinaPack 0.8 -> 0.8.1

参考：

docutils/reStructuredText 0.4版本发布了

更新“产品”栏的功能

2006-08-15T10:23:21+00:00

升级及更新

升级了 PloneSoftwareCenter，使得“产品“栏更加易用。
1.0 beta7 -> 1.0 beta8, 重新安装并调用 migrate 方法。
更新了共创桌面 Linux 中的问题跟踪系统，按共创桌面 Linux 现有的主要功能添加不用的分类
更新现有 BUG 的分类，问题解释等。

为 “斑竹请进！关于免费帮贵公司测试BUGS问题。做好准备

今天挺忙，但是不能闲着，为什么来做这儿的人这么少

2006-08-06T15:59:44+00:00

想用王朔的的、刘一达的京片子口气写点儿什么东西，觉得这风格似乎不用学，学也学不来真谛，于是决定还是用我惯常的贫嘴口气，写点儿什么。

介个论坛说来开张也好长时间了，我曾经萌发吧自己的blog阵地转到这里边的念头，但是发现因为太过专业，我总是拉家常似的乱贫一气，就和非常serious的it氛围有点儿冲突的意思。

再者，这儿人这么少，就不能达到我很soso的博客访问量，没人访问的blog是很郁闷的，虽然大家都说blog不需要别人看。我在ck论坛弄的blog，都没有几个字儿，就100多访问量，已经很受宠若惊了。

打住吧，看我这儿拐哪儿了都，管理员同学又该埋怨我瞎说占空间了。言归正传，介尬达的人为啥那么少。按说了，放在网上的东西，而且是免费的技术的东西，总该有人访问的，而且这网站，说实话，也相当不错，管理员同学费了那么大功夫弄。

我已经呼吁很多次同学们来这个论坛，看看，说说，但是每人理会，看着这么好的网络资源没被利用，心理很有想法。但是有什么办法呢？

OpenDesktop 网站升级到 Plone 2.5

2006-08-02T19:11:52+00:00

升级过程中的主要问题还是基于 LDAP 的用户管理。

Plone 2.5 and OpenLDAP Integration for Users and Groups

参考了上面的文档。

Plone 2.5: Integrating with PAS and Zope 3 views.
Read more…

TODO：

1。装一个新的 skin
2。全站改版

软件政府采购不应“优先采购”

2006-07-28T08:44:26+00:00

出处：http://www.softdriver.org.cn/showNews.jsp?templateID=news&info_stamp=20060727_30480

软件政府采购不应“优先采购”

eNet硅谷动力

　　按照我国的《政府采购法》，软件政府采购应当采购本国软件和服务，但最近公布的《软件政府采购实施办法（征求意见稿）》（《办法》）的部分条款，如不加以修改，有可能为“优先采购”跨国公司软件敞开大门。

　　《办法》在软件政府采购中引入了一个新的类别，即“优先采购的非本国软件”。这样，《办法》就将软件分成三类：“本国软件”、“优先采购的非本国软件” 和“非本国软件”。但《政府采购法》只有“本国”和“非本国”之分，只有“应当采购”本国货物、工程和服务的规定，没有“优先采购”非本国货物、工程和服务的规定。因此，《办法》的“优先采购的非本国软件”类别缺乏法律依据，世界上其他国家的政府采购法中也没有类似的规定。

　　而且，《办法》关于界定“优先采购的非本国软件”的那些条件，即第十九条列出的三款条件，包括在中国境内投资的要求，在中国境内的研发投入、外包出口、纳税的要求，以及在中国境内设有软件研发机构，培养软件人才的要求，对跨国公司来说是很容易满足的，而其他中小软件企业却很难满足。如果按照这样的条件，“跨国公司软件”大多都可以界定为“优先采购的非本国软件”，从而使“优先采购的非本国软件”实际上变成“优先采购的跨国公司软件”。

　　世界各国的政府采购都是向中小企业倾斜的，因为中小企业最具创新活力，政府采购扶持中小企业有利于创新，有利于产业发展。但《办法》的“优先采购的非本国软件”类别及其界定条件却向跨国公司倾斜，这显然不符合国际惯例，不利于软件业的创新。

　　我们欢迎外国公司在中国境内投资，增加研发投入、外包出口、纳税，以及设软件研发机构，培养软件人才等等，但这一定是建立在互利的基础上，即既对中国有利，也对外国公司自身有利。不应将外国公司在中国的投入看成是某种“施舍”，而用政府采购市场去“答谢”。“市场换技术”已被实践证明是行不通的，想用政府采购市场去换取外资的投入，其结果将使本国企业丧失政府采购的支持，从而对我国软件产业的发展造成重大损失。

　　总之，《办法》引入“优先采购的非本国软件”的类别和界定条款，不符合《政府采购法》的精神，也不符合世界各国的政府采购向中小企业倾斜的惯例，希望能予修改，以使《政府采购法》得到真正贯彻。

sp2什么时候能出来，我们都关心呢

2006-07-12T07:07:29+00:00

能透露个消息么？

是不是可以把登陆计数器放出来,也把登陆信息调出来分析

2006-07-12T06:16:45+00:00

For such a new website,maybe adding a access counter is a good idea,especially when we could collect the information of the access.when we have it ,we could analyze the data and apply it to our future work.

实现“单身”程序

2006-05-30T14:30:23+00:00

就是同时只允许一个程序实例运行喽。提供可用于C和Python使用的代码片断。

这种需求似乎很常见。而简单的方法往往不尽人意，比如如果我们简单地使用一个普通文件作为“锁介质”的话，如果程序因为bug（我也不喜欢它，但这东东总是层出不穷，唉）什么的异常退出的话，如果不手动删除这个文件程序就永远也启动不起来了。虽然使用普通文件的方法有一些变通的技巧：比如定时写入一些数字，然后新程序启动时检查这种变化，如果没有这个数字变化，就说明原实例已经异常退出了，但这些技巧终究是难登大雅之堂的。

我的实现方法是基于unixdomain socket的，但第一发明都肯定不是俺了，俺最早就是发现thunderbird使用这个方式。前些天修改程序遇到了这样的需求，于是兴起实现了一个，代码如下：

/* oneinst.c */

#include <sys/socket.h>
#include <sys/un.h>
#include <time.h>
#include <unistd.h>
#include <string.h>
#include <stdlib.h>
#include <stdio.h>
#include <errno.h>
#include <sched.h>
#include <glib.h>

struct check_param {
    int singleton;
    char *lockname;
};

int
create_instance_lock(int *singleton, char *lockname)
{
    int unsock, connfd;
    struct sockaddr_un addr, cliaddr;
    int clilen;

    unlink(lockname);
    addr.sun_family = AF_LOCAL;
    strcpy(addr.sun_path, lockname);
    unsock = socket(AF_LOCAL, SOCK_STREAM, 0);
    if (unsock<0)    return -1;
    if (bind(unsock, (struct sockaddr*)&addr, sizeof(addr)) < 0)
        return -2;
    if (listen(unsock, 10)<0)
        return -3;
    fprintf(stderr, "I am running ...\n");
    *singleton = 0;
    for ( ; ; ) {
        clilen = sizeof(cliaddr);
        if ( (connfd = accept(unsock, (struct sockaddr*) &cliaddr, &clilen)) < 0) {
            continue;
        }
        close(connfd);
    }
    close(unsock);
    return 0;
}

/*
    there is other instance running, return value more than 0,
    elsewise I am first instance, return 0,
    return value less than 0, when any error occurs.
*/
int
query_existing_instance(int retried, char *lockname)
{
    int unsock;
    struct sockaddr_un addr;
    const struct timespec req = {0, 500000};
    struct timespec res;

    addr.sun_family = AF_LOCAL;
    strcpy(addr.sun_path, lockname);
    unsock = socket(AF_LOCAL, SOCK_STREAM, 0);
    if (!unsock)    return -1;
    if (retried <= 0)    retried = 5;
    while (retried--) {
        if (connect(unsock, (struct sockaddr*)&addr, sizeof(addr))<0 ) {
            if (errno == ECONNREFUSED) {
                perror("failed to connect other instance");
                nanosleep(&req, &res);
                continue;
            }
        } else {
            return 1;
        }
    }
    close(unsock);
    return 0;
}

gpointer
detect_other_instance(struct check_param *p)
{
    int ret;

    if (!p)    return NULL;
    ret = query_existing_instance(3, p->lockname);
    if (0 == ret) {
        create_instance_lock(&p->singleton, p->lockname);/* it should block */
        fprintf(stderr, "failed to create singleton lock.\n");
        p->singleton = -2;
        g_thread_exit(NULL);
    } else if (ret>0) {
        fprintf(stderr, "There is another instance running, quiting now.\n");
        p->singleton = 1;
        g_thread_exit(NULL);
    } else {
        p->singleton = -2;
        fprintf(stderr, "We failed on some errors.\n");
    }
    g_thread_exit(NULL);
}

int
other_instance_running(char *lockname)
{
    GThread *thread;
    GError *error=NULL;
    struct check_param parm;

    if (!g_thread_supported ())
        g_thread_init(NULL);
     parm.singleton = -1;
    parm.lockname = lockname;
    thread = g_thread_create_full((GThreadFunc)detect_other_instance,
                    &parm,
                    0,
                    FALSE,
                    TRUE,
                    G_THREAD_PRIORITY_LOW,
                    &error);
    if (!thread) {
        fprintf(stderr, "failed to create new gthread : %s\n", error->message);
        g_error_free(error);
        return -3;
    }
    while (parm.singleton == -1) sched_yield();
    return parm.singleton;
}

嗯，难度不大，是不是？我这是使用的GLIB线程库，如果你愿意当然可以改成pthread的什么的。

下面是可以让python程序也可以使用这个功能所需的代码：

/* oneinst.h */

#ifndef ONEINST_H__
#define ONEINST_H__
extern other_instance_running(char *lockname);
#endif

/* pyoneint.c */

#include <Python.h>
#include "oneinst.h"

static PyObject*
mice_other_instance_running(PyObject *self, PyObject *args)
{
    char *lockname;
    PyObject *retobj=NULL;
    int ret;

    if (!PyArg_ParseTuple(args, "s", &lockname))
    goto OUT;

    ret = other_instance_running(lockname);
    if (ret>=0)
        retobj = PyBool_FromLong(ret);
    else
        PyErr_SetString(PyExc_RuntimeError, "failed to check other instance");
OUT:
    return retobj;
}

static PyMethodDef PyMiceMethods[] = {
    {"other_instance_running", mice_other_instance_running, METH_VARARGS,
     ""},
    {NULL, NULL, 0, NULL}        /* Sentinel */
};

PyMODINIT_FUNC
initpyoneinst(void)
{
    Py_InitModule("pyoneinst", PyMiceMethods);
}

/* setup.py */

#! /usr/bin/python2

from distutils.core import setup, Extension
import pipes
import string

p1 = pipes.Template()
p1.prepend("pkg-config gthread-2.0 --cflags", ".-")
cflags = p1.open("/tmp/1", "r").read().strip()
p2 = pipes.Template()
p2.prepend("pkg-config gthread-2.0 --libs", ".-")
loptions = p2.open("/tmp/2", "r").read().strip()

def get_cflags_list(cflags):
        cflags_list = string.split(cflags, " ")
        ret = []
        for one_flag in cflags_list:
                ret.append(one_flag[2:])
        return ret

def get_linkflags_list(loptions):
    print loptions
        all_options = string.split(loptions, " ")
        libs = []
        lib_dirs = []
        for one_option in all_options:
                if not one_option:
                        continue
                if one_option.startswith("-L"):
                        lib_dirs.append(one_option[2:])
                elif one_option.startswith("-l"):
                        libs.append(one_option[2:])
        else:
                        libs.append(one_option[1:])
        return libs,lib_dirs

cflags_list = get_cflags_list(cflags)
cflags_list.append("../../..")
libs, lib_dirs = get_linkflags_list(loptions)
m = Extension('pyoneinst',
                include_dirs = cflags_list,
                libraries = libs,
                library_dirs = lib_dirs,
                sources = ['oneinst.c', 'pyoneinst.c'])

setup (name='pyoneinst', version='0.1', description='oneinst module', ext_modules=[m])

还有一个毛坯版的Makefile.am，如果你不知道Makefile.am是什么东西的话，就忽略它吧：

EXTRA_DIST = oneinst.c oneinst.h pyoneinst.c setup.py testoneinst.py

all-local:
    python setup.py build
    cp build/lib*/pyoneinst.so .
    rm build -fr

install-exec-local:
    install -m 644 pyoneinst.so ${pkgdatadir}/netconfpkg

CLEANFILES := $(notdir $(wildcard *~)) $(notdir $(wildcard *\#)) $(notdir $(wildcard \.\#*)) build

嘿！这下程序可以单身了! 不知你的程序会唱“单身情歌”否？嘿嘿

Enjoy it.

麦片和牛奶

2006-05-21T21:35:27+00:00

有次中午，我吃的就是这个，大家纷纷很奇怪的看着我，说这东西怎么能当正餐，还说是大补的东西，不利减肥。我笑笑，谁说减肥的人一定不能吃有营养的东西，谁说麦片和牛奶就比米饭炒菜要差，当然，午餐还是营养全面的好，但我就是好这口儿，没办法。

现在该干什么呢，有个步骤才能继续阿

2006-05-21T21:15:13+00:00

总觉得只要花上1个小时，可能半个小时就能搞明白我下一步的计划，只是自己头脑发晕，故意懒，不去思考这些，不行，该思考还是要继续的。

不说别的了，该开始就要开始啊，别拖着，已经让某人很辛苦了，不能再让人家百白辛苦哦

挺惭愧的，要把这个OD负责到底

2006-05-21T21:06:57+00:00

居然搁置了这么多天，再忙也不能做到一半就放手。

这几天的确忙，一到周末就不想干事情，但是也不能把作了一半的东西就这么放手，对不起别人，也对不起自己。

Understanding Linux Network Internals

2006-05-27T12:29:13+00:00

    早就听说，有一本叫<<Understanding Linux Network Internals>>的书。我非常想了解一下Linux是如何处理网络协议栈的，故而期待己久。这不，从eMule下载了好长时间才搞到。

    果然，这本书没有令我失望。

    (以下超链接的目标是无效的！它们是从CHM文件中复制出来的)

           Copyright
            Preface
                The Audience for This Book
                Background Information
                Organization of the Material
                Conventions Used in This Book
                Using Code Examples
                We'd Like to Hear from You
                Safari Enabled
                Acknowledgments
            Part I: General Background
                   Chapter 1. Introduction
                Section 1.1. Basic Terminology
                Section 1.2. Common Coding Patterns
                Section 1.3. User-Space Tools
                Section 1.4. Browsing the Source Code
                Section 1.5. When a Feature Is Offered as a Patch
                   Chapter 2. Critical Data Structures
                Section 2.1. The Socket Buffer: sk_buff Structure
                Section 2.2. net_device Structure
                Section 2.3. Files Mentioned in This Chapter
                   Chapter 3. User-Space-to-Kernel Interface
                Section 3.1. Overview
                Section 3.2. procfs Versus sysctl
                Section 3.3. ioctl
                Section 3.4. Netlink
                Section 3.5. Serializing Configuration Changes
            Part II: System Initialization
                   Chapter 4. Notification Chains
                Section 4.1. Reasons for Notification Chains
                Section 4.2. Overview
                Section 4.3. Defining a Chain
                Section 4.4. Registering with a Chain
                Section 4.5. Notifying Events on a Chain
                Section 4.6. Notification Chains for the Networking Subsystems
                Section 4.7. Tuning via /proc Filesystem
                Section 4.8. Functions and Variables Featured in This Chapter
                Section 4.9. Files and Directories Featured in This Chapter
                   Chapter 5. Network Device Initialization
                Section 5.1. System Initialization Overview
                Section 5.2. Device Registration and Initialization
                Section 5.3. Basic Goals of NIC Initialization
                Section 5.4. Interaction Between Devices and Kernel
                Section 5.5. Initialization Options
                Section 5.6. Module Options
                Section 5.7. Initializing the Device Handling Layer: net_dev_init
                Section 5.8. User-Space Helpers
                Section 5.9. Virtual Devices
                Section 5.10. Tuning via /proc Filesystem
                Section 5.11. Functions and Variables Featured in This Chapter
                Section 5.12. Files and Directories Featured in This Chapter
                   Chapter 6. The PCI Layer and Network Interface Cards
                Section 6.1. Data Structures Featured in This Chapter
                Section 6.2. Registering a PCI NIC Device Driver
                Section 6.3. Power Management and Wake-on-LAN
                Section 6.4. Example of PCI NIC Driver Registration
                Section 6.5. The Big Picture
                Section 6.6. Tuning via /proc Filesystem
                Section 6.7. Functions and Variables Featured in This Chapter
                Section 6.8. Files and Directories Featured in This Chapter
                   Chapter 7. Kernel Infrastructure for Component Initialization
                Section 7.1. Boot-Time Kernel Options
                Section 7.2. Module Initialization Code
                Section 7.3. Optimized Macro-Based Tagging
                Section 7.4. Boot-Time Initialization Routines
                Section 7.5. Memory Optimizations
                Section 7.6. Tuning via /proc Filesystem
                Section 7.7. Functions and Variables Featured in This Chapter
                Section 7.8. Files and Directories Featured in This Chapter
                   Chapter 8. Device Registration and Initialization
                Section 8.1. When a Device Is Registered
                Section 8.2. When a Device Is Unregistered
                Section 8.3. Allocating net_device Structures
                Section 8.4. Skeleton of NIC Registration and Unregistration
                Section 8.5. Device Initialization
                Section 8.6. Organization of net_device Structures
                Section 8.7. Device State
                Section 8.8. Registering and Unregistering Devices
                Section 8.9. Device Registration
                Section 8.10. Device Unregistration
                Section 8.11. Enabling and Disabling a Network Device
                Section 8.12. Updating the Device Queuing Discipline State
                Section 8.13. Configuring Device-Related Information from User Space
                Section 8.14. Virtual Devices
                Section 8.15. Locking
                Section 8.16. Tuning via /proc Filesystem
                Section 8.17. Functions and Variables Featured in This Chapter
                Section 8.18. Files and Directories Featured in This Chapter
            Part III: Transmission and Reception
                   Chapter 9. Interrupts and Network Drivers
                Section 9.1. Decisions and Traffic Direction
                Section 9.2. Notifying Drivers When Frames Are Received
                Section 9.3. Interrupt Handlers
                Section 9.4. softnet_data Structure
                   Chapter 10. Frame Reception
                Section 10.1. Interactions with Other Features
                Section 10.2. Enabling and Disabling a Device
                Section 10.3. Queues
                Section 10.4. Notifying the Kernel of Frame Reception: NAPI and netif_rx
                Section 10.5. Old Interface Between Device Drivers and Kernel: First Part of netif_rx
                Section 10.6. Congestion Management
                Section 10.7. Processing the NET_RX_SOFTIRQ: net_rx_action
                   Chapter 11. Frame Transmission
                Section 11.1. Enabling and Disabling Transmissions
                   Chapter 12. General and Reference Material About Interrupts
                Section 12.1. Statistics
                Section 12.2. Tuning via /proc and sysfs Filesystems
                Section 12.3. Functions and Variables Featured in This Part of the Book
                Section 12.4. Files and Directories Featured in This Part of the Book
                   Chapter 13. Protocol Handlers
                Section 13.1. Overview of Network Stack
                Section 13.2. Executing the Right Protocol Handler
                Section 13.3. Protocol Handler Organization
                Section 13.4. Protocol Handler Registration
                Section 13.5. Ethernet Versus IEEE 802.3 Frames
                Section 13.6. Tuning via /proc Filesystem
                Section 13.7. Functions and Variables Featured in This Chapter
                Section 13.8. Files and Directories Featured in This Chapter
            Part IV: Bridging
                   Chapter 14. Bridging: Concepts
                Section 14.1. Repeaters, Bridges, and Routers
                Section 14.2. Bridges Versus Switches
                Section 14.3. Hosts
                Section 14.4. Merging LANs with Bridges
                Section 14.5. Bridging Different LAN Technologies
                Section 14.6. Address Learning
                Section 14.7. Multiple Bridges
                   Chapter 15. Bridging: The Spanning Tree Protocol
                Section 15.1. Basic Terminology
                Section 15.2. Example of Hierarchical Switched L2 Topology
                Section 15.3. Basic Elements of the Spanning Tree Protocol
                Section 15.4. Bridge and Port IDs
                Section 15.5. Bridge Protocol Data Units (BPDUs)
                Section 15.6. Defining the Active Topology
                Section 15.7. Timers
                Section 15.8. Topology Changes
                Section 15.9. BPDU Encapsulation
                Section 15.10. Transmitting Configuration BPDUs
                Section 15.11. Processing Ingress Frames
                Section 15.12. Convergence Time
                Section 15.13. Overview of Newer Spanning Tree Protocols
                   Chapter 16. Bridging: Linux Implementation
                Section 16.1. Bridge Device Abstraction
                Section 16.2. Important Data Structures
                Section 16.3. Initialization of Bridging Code
                Section 16.4. Creating Bridge Devices and Bridge Ports
                Section 16.5. Creating a New Bridge Device
                Section 16.6. Bridge Device Setup Routine
                Section 16.7. Deleting a Bridge
                Section 16.8. Adding Ports to a Bridge
                Section 16.9. Enabling and Disabling a Bridge Device
                Section 16.10. Enabling and Disabling a Bridge Port
                Section 16.11. Changing State on a Bridge Port
                Section 16.12. The Big Picture
                Section 16.13. Forwarding Database
                Section 16.14. Handling Ingress Traffic
                Section 16.15. Transmitting on a Bridge Device
                Section 16.16. Spanning Tree Protocol (STP)
                Section 16.17. netdevice Notification Chain
                   Chapter 17. Bridging: Miscellaneous Topics
                Section 17.1. User-Space Configuration Tools
                Section 17.2. Tuning via /proc Filesystem
                Section 17.3. Tuning via /sys Filesystem
                Section 17.4. Statistics
                Section 17.5. Data Structures Featured in This Part of the Book
                Section 17.6. Functions and Variables Featured in This Part of the Book
                Section 17.7. Files and Directories Featured in This Part of the Book
            Part V: Internet Protocol Version 4 (IPv4)
                   Chapter 18. Internet Protocol Version 4 (IPv4): Concepts
                Section 18.1. IP Protocol: The Big Picture
                Section 18.2. IP Header
                Section 18.3. IP Options
                Section 18.4. Packet Fragmentation/Defragmentation
                Section 18.5. Checksums
                   Chapter 19. Internet Protocol Version 4 (IPv4): Linux Foundations and Features
                Section 19.1. Main IPv4 Data Structures
                Section 19.2. General Packet Handling
                Section 19.3. IP Options
                   Chapter 20. Internet Protocol Version 4 (IPv4): Forwarding and Local Delivery
                Section 20.1. Forwarding
                Section 20.2. Local Delivery
                   Chapter 21. Internet Protocol Version 4 (IPv4): Transmission
                Section 21.1. Key Functions That Perform Transmission
                Section 21.2. Interface to the Neighboring Subsystem
                   Chapter 22. Internet Protocol Version 4 (IPv4): Handling Fragmentation
                Section 22.1. IP Fragmentation
                Section 22.2. IP Defragmentation
                   Chapter 23. Internet Protocol Version 4 (IPv4): Miscellaneous Topics
                Section 23.1. Long-Living IP Peer Information
                Section 23.2. Selecting the IP Header's ID Field
                Section 23.3. IP Statistics
                Section 23.4. IP Configuration
                Section 23.5. IP-over-IP
                Section 23.6. IPv4: What's Wrong with It?
                Section 23.7. Tuning via /proc Filesystem
                Section 23.8. Data Structures Featured in This Part of the Book
                Section 23.9. Functions and Variables Featured in This Part of the Book
                Section 23.10. Files and Directories Featured in This Part of the Book
                   Chapter 24. Layer Four Protocol and Raw IP Handling
                Section 24.1. Available L4 Protocols
                Section 24.2. L4 Protocol Registration
                Section 24.3. L3 to L4 Delivery: ip_local_deliver_finish
                Section 24.4. IPv4 Versus IPv6
                Section 24.5. Tuning via /proc Filesystem
                Section 24.6. Functions and Variables Featured in This Chapter
                Section 24.7. Files and Directories Featured in This Chapter
                   Chapter 25. Internet Control Message Protocol (ICMPv4)
                Section 25.1. ICMP Header
                Section 25.2. ICMP Payload
                Section 25.3. ICMP Types
                Section 25.4. Applications of the ICMP Protocol
                Section 25.5. The Big Picture
                Section 25.6. Protocol Initialization
                Section 25.7. Data Structures Featured in This Chapter
                Section 25.8. Transmitting ICMP Messages
                Section 25.9. ICMP Statistics
                Section 25.10. Passing Error Notifications to the Transport Layer
                Section 25.11. Tuning via /proc Filesystem
                Section 25.12. Functions and Variables Featured in This Chapter
                Section 25.13. Files and Directories Featured in This Chapter
            Part VI: Neighboring Subsystem
                   Chapter 26. Neighboring Subsystem: Concepts
                Section 26.1. What Is a Neighbor?
                Section 26.2. Reasons That Neighboring Protocols Are Needed
                Section 26.3. Linux Implementation
                Section 26.4. Proxying the Neighboring Protocol
                Section 26.5. When Solicitation Requests Are Transmitted and Processed
                Section 26.6. Neighbor States and Network Unreachability Detection (NUD)
                   Chapter 27. Neighboring Subsystem: Infrastructure
                Section 27.1. Main Data Structures
                Section 27.2. Common Interface Between L3 Protocols and Neighboring Protocols
                Section 27.3. General Tasks of the Neighboring Infrastructure
                Section 27.4. Reference Counts on neighbour Structures
                Section 27.5. Creating a neighbour Entry
                Section 27.6. Neighbor Deletion
                Section 27.7. Acting As a Proxy
                Section 27.8. L2 Header Caching
                Section 27.9. Protocol Initialization and Cleanup
                Section 27.10. Interaction with Other Subsystems
                Section 27.11. Interaction Between Neighboring Protocols and L3 Transmission Functions
                Section 27.12. Queuing
                   Chapter 28. Neighboring Subsystem: Address Resolution Protocol (ARP)
                Section 28.1. ARP Packet Format
                Section 28.2. Example of an ARP Transaction
                Section 28.3. Gratuitous ARP
                Section 28.4. Responding from Multiple Interfaces
                Section 28.5. Tunable ARP Options
                Section 28.6. ARP Protocol Initialization
                Section 28.7. Initialization of a neighbour Structure
                Section 28.8. Transmitting and Receiving ARP Packets
                Section 28.9. Processing Ingress ARP Packets
                Section 28.10. Proxy ARP
                Section 28.11. Examples
                Section 28.12. External Events
                Section 28.13. ARPD
                Section 28.14. Reverse Address Resolution Protocol (RARP)
                Section 28.15. Improvements in ND (IPv6) over ARP (IPv4)
                   Chapter 29. Neighboring Subsystem: Miscellaneous Topics
                Section 29.1. System Administration of Neighbors
                Section 29.2. Tuning via /proc Filesystem
                Section 29.3. Data Structures Featured in This Part of the Book
                Section 29.4. Files and Directories Featured in This Part of the Book
            Part VII: Routing
                   Chapter 30. Routing: Concepts
                Section 30.1. Routers, Routes, and Routing Tables
                Section 30.2. Essential Elements of Routing
                Section 30.3. Routing Table
                Section 30.4. Lookups
                Section 30.5. Packet Reception Versus Packet Transmission
                   Chapter 31. Routing: Advanced
                Section 31.1. Concepts Behind Policy Routing
                Section 31.2. Concepts Behind Multipath Routing
                Section 31.3. Interactions with Other Kernel Subsystems
                Section 31.4. Routing Protocol Daemons
                Section 31.5. Verbose Monitoring
                Section 31.6. ICMP_REDIRECT Messages
                Section 31.7. Reverse Path Filtering
                   Chapter 32. Routing: Li nux Implementation
                Section 32.1. Kernel Options
                Section 32.2. Main Data Structures
                Section 32.3. Route and Address Scopes
                Section 32.4. Primary and Secondary IP Addresses
                Section 32.5. Generic Helper Routines and Macros
                Section 32.6. Global Locks
                Section 32.7. Routing Subsystem Initialization
                Section 32.8. External Events
                Section 32.9. Interactions with Other Subsystems
                   Chapter 33. Routing: The Routing Cache
                Section 33.1. Routing Cache Initialization
                Section 33.2. Hash Table Organization
                Section 33.3. Major Cache Operations
                Section 33.4. Multipath Caching
                Section 33.5. Interface Between the DST and Calling Protocols
                Section 33.6. Flushing the Routing Cache
                Section 33.7. Garbage Collection
                Section 33.8. Egress ICMP REDIRECT Rate Limiting
                   Chapter 34. Routing: Routing Tables
                Section 34.1. Organization of Routing Hash Tables
                Section 34.2. Routing Table Initialization
                Section 34.3. Adding and Removing Routes
                Section 34.4. Policy Routing and Its Effects on Routing Table Definitions
                   Chapter 35. Routing: Lookups
                Section 35.1. High-Level View of Lookup Functions
                Section 35.2. Helper Routines
                Section 35.3. The Table Lookup: fn_hash_lookup
                Section 35.4. fib_lookup Function
                Section 35.5. Setting Functions for Reception and Transmission
                Section 35.6. General Structure of the Input and Output Routing Routines
                Section 35.7. Input Routing
                Section 35.8. Output Routing
                Section 35.9. Effects of Multipath on Next Hop Selection
                Section 35.10. Policy Routing
                Section 35.11. Source Routing
                Section 35.12. Policy Routing and Routing Table Based Classifier
                   Chapter 36. Routing: Miscellaneous Topics
                Section 36.1. User-Space Configuration Tools
                Section 36.2. Statistics
                Section 36.3. Tuning via /proc Filesystem
                Section 36.4. Enabling and Disabling Forwarding
                Section 36.5. Data Structures Featured in This Part of the Book
                Section 36.6. Functions and Variables Featured in This Part of the Book
                Section 36.7. Files and Directories Featured in This Part of the Book
            About the Authors
            Colophon
            Index


    我已经看了20多个chapter，感觉这本书非常容易明白。相对于<<linux networking architecture>>，行文也易懂多了，而且内容也比较新。虽然书没讲是哪个2.6版本的内核，但从片言只语中也可以看出至少是2.6.8以后的版本，但是linux的变化如此之快，关于ingress queue的流量控制的介绍已经与最新的代码不同了。但是暇不掩玉。

    建议看完<<Understanding Linux Kernel>>和<<Linux Device Driver>>，再看这个。因为它对一些内核的基础设施的介绍并不完整。关于驱动那一块，是我见过的讲的最详细的材料了。