这种需求似乎很常见。而简单的方法往往不尽人意，比如如果我们简单地使用一个普通文件作为“锁介质”的话，如果程序因为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.

    早就听说，有一本叫<<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>>，再看这个。因为它对一些内核的基础设施的介绍并不完整。关于驱动那一块，是我见过的讲的最详细的材料了。

    Xnest是一个有意思的东东。它可以在运行中的X会话中，再启动一个X服务器。当然这个“X服务器”同时也是真实X服务器的一个客户端。除去好玩来说，单就调试一些特殊X程序和X本身而言，它的意义是非常明显的。

下面介绍一种运行Xnest的方法。

    首先需要安装xorg-x11-Xnest和xorg-x11-xauth。这个两个包，在默认共创linux 2005 SP1应该没有。需要另行安装。OK，安装好它们后。需要执行以下命令：

    1、 xauth add :1 . `mcookie`

    为新的X服务器的xauth配置增加配置项。

    2、Xnest :1 &
 
    在:1的DISPLAY上运行Xnest服务器。

    3、执行其它客户端程序。例如

    DISPLAY=:1 gnome-terminal
    DISPLAY=:1 nautilus
    DISPLAY=:1 metacity

    等等。但gnome-session不能通过这种方式运行。
   
    可以用这样的环境试验其它窗口管理器，例如Xfce, enligntenment应该是个挺爽的事情。我运行一个E16，还不错，呵呵，以后准备再试试E17。




   
  

    popen返回值是一个FILE*，一直以为它只是一个普通的管道描述符而已，昨天才清楚有一个pclose的C库函数，关闭它可以获得子进程的返回值！试验了一下，fclose()也可以哦：

#include <stdio.h>
 
int
main()
{
        FILE *o;
        char buf[100];
 
        o = popen("../../Python/exit2.sh", "w");
        fread(buf, 100, 1, o);
        printf("%s\n", buf);
        printf("%d\n", fclose(o));
}


    如果使用python，直接使用file对象的close方法也可以达到相同效果。
#! /usr/bin/python
 
import popen2
import fcntl
import os
import errno
 
o,i = popen2.popen4('./exit1.sh; ./exit2.sh')
flags = fcntl.fcntl(o, fcntl.F_GETFL)
fcntl.fcntl(o.fileno(), fcntl.F_SETFL, flags | os.O_NONBLOCK)
buf=""
this=""
while True:
        try:
                 this = o.read()
        except IOError, msg:
                if errno.EAGAIN == msg[0]:
                        continue
        else:
                if not this:
                        break
                buf+=this
print buf
print o.close()

其中，exit?.sh以exit 1之类的语句结束。