首先要在Ubuntu中安装python-libpcap，

sudo apt-get install python-libpcap

通过ifconfig命令看看你电脑的网卡标识符是什么，比如我的以太网卡是eth0,无线网卡是wlan0，然后修改./LAB/IFMAP文件，如下：

1|eth0

其中eth0是你要连接电脑的网卡。

最后修改./LAB/NETMAP文件，如下：

1:0/0 2:0/0
1:3/0 3:3/0
2:0/1 3:0/1
1:1/3 2:1/3 3:1/3 1023:1

主要看最后一行，1023:1代表的是你的电脑的网卡eth0，整句话的含义就是将router 1,2,3的以太网口1/3都连接在你电脑网卡的eth0上。

现在到router 1上配置一下e1/3的ip地址，可以设置与你电脑的eth0地址在一个网段，设置好以后你就可以ping通eth0了。

This guide provides explanations to a script called iou2net.pl (script is at the end of the article), which allows you to attach IOU instances to real network (interfaces). In its functionality, its similar to what the ioulive tool does. For more information about IOU or ioulive, ask your Cisco SE/AM that provided you with your copy of IOU, or check out the IOU FAQ from evilrouters.net.

Why another script that does nearly the same thing as ioulive? While playing around with IOU, i tried to come up with a way to attach IOU instances to dynamips directly. I managed to get this working for single instances, but came to the conclusion that its best to integrate such functionality in dynagen directly. Unfortunately, Im not a good programmer and have no experience with python, nor the time to dig through the dynagen sources and extend the code. This script is a byproduct of this work, where i tried to document the packet format that IOU uses to communicate between instances. For now, the script allows to attach to real network adapters and tap interfaces, and to communicate through UDP “links” as known from dynamips and qemu.
Contents

1 Installation
    1.1 Dependencies
2 Usage
    2.1 NETMAP
    2.2 Mode of operation / interfaces
      2.2.1 PCAP mode
      2.2.2 TAP mode
      2.2.3 UDP mode
    2.3 Other Options
      2.3.1 Packet Capture
      2.3.2 Logging and Debugging
3 Limitations
4 What works
5 IOU communication
    5.1 General
    5.2 IOU header
    5.3 Interface MAC addresses
6 Script

Installation

The program is written in perl and can be copied directly from the source listing (end of the article) to a file. Make the file executeable with

chmod +x ./iou2net.pl

Dependencies

iou2net depends on some perl modules. Most of them should come with your default perl distribution. Best case, the extra installation of Net::Pcap should do the trick to satisfy dependencies. On Ubuntu and Debian systems, this is provided with the “libnet-pcap-perl” package. Of course, beside the perl package, you need libpcap too.

sudo apt-get install libnet-pcap-perl libpcap0.8

For systems that dont pack the perl module, use CPAN to install it:

perl -MCPAN -e 'install Net::Pcap'

Now try to start the script, it should start without any module warnings, printing the help screen:

./iou2net.pl

Other dependencies may arise if you do not have tunctl or brctl commands. You can resolve this with the following:

sudo apt-get install uml-utilities bridge-utils

Usage

NETMAP

iou2net will forward frames between a IOU instance and a (real) network adapter. IOU needs a special mapping in its NETMAP file. The interface of the IOU instance you want to forward from has to be listed as a source entry, with a “@<hostname>” suffix at the end. The destination of the mapping will be a pseudo IOU instance number, with a pseudo interface number. iou2net.pl will use this pseudo IOU instance ID to connect to the real IOU instance, and do its frame relaying.

Example NETMAP file:

10:1/1				11:1/0
10:1/2				12:1/0
10:1/0@iou-test		        20:0/0@iou-test

The first two mappings are normal connections between IOU instances at the same host (R10, 1/1 <-> R11, 1/0 and R10, 1/2 <-> R12, 1/0). The last one connects interface 1/0 of R10 to pseudo router (instance) 20, interface 0/0.

You can choose any ID (<1024), as long as its not used by any real IOU instance. Specify this ID with the option “-p” when launching the script. Dont use this arbitrary ID for anything else in your mappings/topology. iou2net will need to read through this NETMAP file, to determine the correct mapping. By default, it looks in the current directory for the file NETMAP. If you want to use a file in a different directory (and/or with a different name), use the “-n” option.

Mode of operation / interfaces

You must specify where the frames should be forwarded to/received from. The script can operate in either of the 3 modes:

• PCAP (-i), attaching to real network interfaces
• TAP (-t), for a Layer 2 point-to-point connection to a tapX interface
• UDP (-u), sending and receving frames over UDP links as seen in dynamips and qemu

At least pcap and tap mode require super user privileges, so run the script with sudo.

PCAP mode

PCAP mode is the preferred method when dealing with traffic from real network interfaces. Just specify the real network interface with the -i option. iou2net.pl will put this interface into promiscuous mode.

$ sudo ./iou2net.pl -i eth0 -p 20

TAP mode

This is a point-to-point interface type, usually found in Linux and *BSD (tap is for L2, tun is for L3 connections). Its useful especially in bridging configurations. Specify the tap interface with the -t option (full name, like “tap3″). If the tap interface does not exist already, the script will create it for you.

$ sudo ./iou2net.pl -t tap0 -p 99

In any case, you are responsible to bring the tap interface “up”. If desired, you also need to deal with further bridging configuration.

For example, the following setup allows IOU to talk to the local machine and to communicate with the real network attached to eth0. A bridge br0 is created, bridging traffic between eth0 and tap0. Traffic from the host itself lands on br0 and gets forwarded to the bridge member interfaces accordingly.

tunctl -t tap0
ifconfig eth0 0.0.0.0 promisc up
ifconfig tap0 0.0.0.0 promisc up
brctl addbr br0
brctl stp br0 off
brctl setfd br0 1
brctl sethello br0 1
brctl addif br0 eth0
brctl addif br0 tap0
ifconfig br0 <your host ip settings>
(launch IOU)
iou2net.pl -t tap0 -p 111

UDP mode

For communication with other programs that provide UDP connectors (like dynamips NIO_udp), use this mode. The argument -u requires a port mapping format. It can be just “source-port:remote-port” for links that are local to the host that runs both applications.

It also can be of “source-port:remote-host:remote-port”, if communication between applications on different hosts, across a network, is desired. remote-host must be an IP address or a resolveable hostname/FQDN.

$ sudo ./iou2net.pl -u 23001:192.0.2.20:23000 -p 12

Note that the port scheme is always as seen by IOU. In the remote application, you have to specify the ports in reverse meaning – spt:23000 and dpt:23001 from the example above.

Other Options

Packet Capture

With -f <capture file>, the script will write any frame received by IOU and the external connector to a capture file. This file can be opened by wireshark/tshark, even if the script is still running. If the file already exists, it will be overwritten without any warning.

Logging and Debugging

Mainly for troubleshooting purposes, the switches -v and -d will turn on chitchat mode. -v will provide some information during the setup phase of the script. When setup is done and the script is ready to do frame forwarding, no further messages will appear.

-d will do the same as -v, but print the frame header of any received and sent frame during runtime.

Limitations

• This is only tested with Linux so far. Im sure it will run at other modern Unices, too. From perl perspective, porting this to windows is a possible, yet a pointless approach, because there is no IO_W_ (afaik).
• The script focusses on Ethernet connectivity. Bridging together Serial interfaces works for udp links. The packet capture and the debug output are not useable without additional translation, because the interpretation of the header format is not aware of serial encapsulation protocols.
• With the current implementation, TAP mode will not work on *BSD
• For the NETMAP mapping line that is related with iou2net.pl pseudo ID, you must use id:x/y interface notation and not the “compressed” id:z format. Its just a matter of implementation in the script, im too lazy to add this.
• There is not much sanity checking. The last occurence of a line that contains the pseudo ID as a destination is used, no matter how many other mappings with this ID exist before in the NETMAP file. These are typos anyway (see next limitation).
• A single instance of this script will handle one IOU <-> network mapping. If you, for example, have multiple NICs in your systems and therefore want multiple IOU interfaces to be forwarded, you must launch multiple instances of the script. Every mapping must get a unique pseudo ID as the destination, and every instance of the script must be started by adding this unique ID.

Example:

$ cat NETMAP

10:1/0@iou-test		20:0/0@iou-test
10:1/1@iou-test		21:0/0@iou-test
11:1/0@iou-test		22:0/0@iou-test
[...]

$ sudo ./iou2net.pl -i eth0 -p 20 &
[...]
$ sudo ./iou2net.pl -i eth1 -p 21 &
[...]
$ sudo ./iou2net.pl -u 12001:12000 -p 22 &
[...]

• Run all your IOU instances as the same user, otherwise you end up with different “netio” subdirectories in /tmp, and your IOU instances cannot talk to each other. The script needs to know the real uid of the user, therefore you should invoke iou2net.pl with sudo, from the same user that runs the IOU instances.

What works

I’ve done some quick tests with a local IOU instance, one Ethernet interface bridged to a real network where a c1841 is located

• Basic communication at layer 2 and 3 (Ethernet), up to MTU of 1500
• OSPF adjacency over Broadcast segment (multicast)
• ISIS adjacency
• LDP adjacency
• MPLS encapsulation over Ethernet (@1500 byte [MPLS] MTU, no baby giant/jumbo frame support)
• IPv6 auto discovery
• various connectivity tests toward v4 and v6 Internet
• attaching IOU to dynamips
• using a bridge configuration on Linux with tap interfaces, to talk to the host that serves IOU
• communication between dynamips and IOU running at different hosts, with UDP connectors

IOU communication

General

In this chapter, i will outline the packet format and methods IOU uses when communicating outside of an IOU instance.

Inter-instance communication is done through UNIX domain sockets. These are created in the subdirectory “/tmp/netio<uid>”, with a numeric filename that corresponds to <instance ID>. You can sniff this traffic with strace, like

$ strace -e sendto,recvfrom -xx -o capturefile.txt <your IOU command line>

IOU header

When sending frames, IOU will submit the entire L2 frame, prepended with a IOU proprietary header. This header is required at the receiving instance, to make the distinction to which local interface the frame is destined to. This is important, because the sockets are per instance (router) and have no way to decide to which internal interface to forward to (whithout extra logic that looks at MAC addresses etc.).

Furthermore, IOU does sanity checks with this header. When receiving a frame, the source information (sending ID, sending interface) is checked against the mappings that were read from the NETMAP file. It is not possible to send frames to an instance with valid destination ID and interface numbers and faked/unknown source information; the source ID and interface numbers have to match also.

The header format is described in the script. I cannot say if the last two bytes are really a delimiter that is always 0×0100, or if these fields serve a different purpose.

The script walks through the NETMAP file and determines the correct mapping, extracts the source IOU instance ID and its interface numbers. As discussed above, this is important for constructing the IOU header. Then it creates a socket $iou_pseudo_sock for out IOU pseudo ID (the destination), the real IOU instance (the source) will send its frames to this socket. This socket will be read- and writeable by anyone, since this script runs as root, where you usually run IOU as a normal user. Furthermore, we bind to the socket of the source IOU instance ($iou_router_sock). The IOU header that is used when sending frames to the real IOU instance is now prebuild, all the required information is available. Next, the mode of operation is determined and sender/receiver logic is invoked.

For every frame sent by the source IOU instance, we strip off the first 8 bytes (the IOU header), and transmit the frame.

When receiving a frame from the external network, the precomputed IOU header will be prepended, and the resulting frame is sent to the socket of the source IOU instance.

[edit]Interface MAC addresses

IOU uses self-gererated MAC addresses for its interfaces. If an interface maps only to other IOU instances at the local host, it will have an OID of AA:BB:CC. Whether communication is internal or not is determined through the mappings in the NETMAP file. Any mapping that does not have a “@…” suffix is considered internal.

For interfaces that require external communication – mappings that have a “@…” suffix in the NETMAP file – a different interface MAC address is generated by IOU. The format is documented in the script. The script caclulates the MAC address of the source IOU instance and its interface, to generate a capture filter in PCAP mode. Because the real network interface card is put into promiscuous mode, this filter ensures that only useful traffic is seen by IOU (unicasts destined to its MAC, broadcasts, multicasts).

This MAC addresses generation has another implication. If you run the same IOU instance ID at different hosts, and you bridge the same interfaces together, you end up with duplicated MAC addresses (assuming both users running IOU use the same UID). Even if you use different IOU interfaces for external bridging, you may end up with odd results, because IOU may consider the MAC from the remote instance to be local (same IOU instance ID). Therefore, make IOU instance IDs unique across all your installations.

Script

#!/usr/bin/perl

use strict;
use warnings;
use Getopt::Long;
use Net::Pcap;
use IO::Select;
use IO::Socket;
use IO::File;
use Time::HiRes qw(gettimeofday);

my $version      = "v0.4";
my $version_date = "22-Apr-2011";

###################################################################################
# CHANGES
# =======
#
# v0.4, 22-Apr-2011
# -----------------
# - for frame read, switched from fork to select
# - added bridging via udp links and tap interfaces
# - encoding issues hopefully fixed
# - more sane construction of IOU header and MAC address
# - verbose output
# - packet trace output (MAC headers)
# - writing traffic to pcap file
#
# v0.31, 28-Jan-2011
# -----------------
# - MAC address is now in "ether" format (bytes separated with ":") for building
#   the capture filter
#
# v0.3, 27-Jan-2011
# -----------------
# - better capture filter handling, after understanding how IOU generates
#   MAC addresses (related code is still ugly)
# - hostnames with hyphen are now accepted
#
# v0.21, 26-Jan-2011
# -----------------
# - changed socket_base handling after receiving hint that "1000" is the uid
#   that IOU is started with

#
# v0.2, 24-Jan-2011
# -----------------
# - added pcap filter to allow for better performance on busy nics
#
# v0.1, 23-Jan-2011
# -----------------
# - first release
#
###################################################################################

my $help = <<EOF;

iou2net.pl: bridge between iou and real networks (IOUlive replacement)

usage:
iou2net.pl 	[-vd] [-f capture file] [-i interface]  [-n netmapfile]
		[-p instance ID] [-t interface] [-u portmap]

NOTE:	-> You _must_ launch IOU before starting this script.
	-> -i, -t  or -u, and -p are required as a bare minimum.
	-> Most operation require super user privileges; use sudo or run as
	   root.

-v
	Optional, provides verbose output

-d
	Optional, provides debug output (verbose + prints frame headers)

-f
	optional, write frames to a capture file that can be opened with
	wireshark

-i interface (PCAP mode)
	Specify the interface you want to bridge to. This makes the script
	to run in PCAP mode.

-n NETMAP file
	Optional. Per default, the script tries to open ./NETMAP. If you
	want to use a NETMAP file located elsewhere, use this argument.

-p instance ID
	IOU requires a pseudo instance. When bridging your IOU router
	interface, specify an unused ID as the target in your NETMAP file,
	like

	1:2/1\@hostname    666:1/0\@hostname

	666 is the pseudo IOU instance ID, hostname is the host where IOU
	and the script runs at. When starting the script, use -p 666 then.
	After launching the IOU router instance #1, use interface 2/1 for
	external connectivity. The Interface 1/0 at the pseudo instance
	does not have any practical meaning for router configuration.

-t interface (TAP mode)
	Specify the tap interface you want to attach to. This makes the script
	to run in TAP mode. If the interface does not exist, the script will
	create it, otherwise it will attach to it. You are responsible to
	have the interface in an "up" state and for any additional bridging
	that may be required.

-u portmap (UDP mode)
	Will establish communication through UDP links (dynamips, qemu).
	Portmap has the following format:

	(1) source-port:dest-port	or
	(2) source-port:remote_host:dest-port

	The first variant is used for UDP communication at the local host
	only (target runs at the same host).
	The second variant allows to communicate with a target that runs at
	a remote system. <remote_host> must be an IP address or a resolveable
	hostname/FQDN.
	Port numbers are always from a local (IOU) perspective, therefore
	they are the reverse of what gets defined at the target system.

CAVEATS: For now, you need to use x/y interface format in the NETMAP file, at
least for the mapping this script requires. Also, for bridging multiple router
interfaces, separate instances of this script must be launched, and you need
an unique pseudo IOU ID per instance.

EOF

my $err;
my $verbose;
my $debug;
my $pcap_recv_data;
my $iou_recv_data;
my $iou_header;
my $iface;
my $netmap_file = "./NETMAP";
my $netmap_handle;
my $uid;
my $socket_base;
my $iou_pseudo_sock;
my $iou_router_sock;
my $pseudo_instance;
my $pseudo_instance_interface_major;
my $pseudo_instance_interface_minor;
my $iou_instance;
my $iou_interface_major;
my $iou_interface_minor;
my $select_handle;
my $pcap;
my $pcap_filter;
my $udp_conn;
my $udp_shost;
my $udp_dhost;
my $udp_spt;
my $udp_dpt;
my $udp_listener;
my $tap;
my $tap_handle;
my $cap_file;
my $cap_handle;
my $cap_dumper;

GetOptions(
    'help' => sub { print "$help"; exit(0); },
    'v+'   => \$verbose,
    'd+'   => \$debug,
    'i=s'  => \$iface,
    'n=s'  => \$netmap_file,
    'p=i'  => \$pseudo_instance,
    'u=s'  => \$udp_conn,
    't=s'  => \$tap,
    'f=s'  => \$cap_file
);

print "iou2net.pl, Version $version, $version_date.\n";

die "\nPlease provide -i, -t or -u, and -p!\n$help"
  unless ( ( $iface || $udp_conn || $tap ) && $pseudo_instance );

$verbose = 1 if $debug;

# socket directory is a directory below $TMPDIR (/tmp), composed of "netio" plus
# uid of the user that runs the iou binary
# since we assume this script gets invoked with sudo by most people:
# try to be smart about getting real UID, $< does not (always?) return real uid when using sudo

$uid         = $ENV{SUDO_UID};
$uid         = $< unless ( defined $uid );    # apparently not started with sudo
$socket_base = "/tmp/netio$uid";
print "UID: $uid\n"                           if $verbose;
print "Socket base directory: $socket_base\n" if $verbose;

open( netmap_handle, $netmap_file )
  or die "Can't open netmap file $netmap_file\n";

# walk through NETMAP file and try to determine the source IOU instance
while (<netmap_handle>) {

    # stop when there is a match for our pseudo instance ID as the destination
    next
      if !(
              $_ =~
m/^\d+:\d+\/\d+@[\w-]+[ \t]+$pseudo_instance:\d+\/\d+@[\w-]+(\s|\t)*$/
      );
    my $inputline = $_;
    chomp($inputline);

    print "Found valid mapping line in NETMAP: $inputline\n" if $verbose;

    # ignore any hostname statements
    $inputline =~ s/\@[\w-]+//g;

    my @connline = split( /[ \t]+/, $inputline );
    $connline[0] =~ s/(\s\t)*//g;
    $connline[1] =~ s/(\s\t)*//g;
    my @iou_src = split( /:/, $connline[0] );
    my @iou_dst = split( /:/, $connline[1] );
    $iou_instance = $iou_src[0];
    ( $iou_interface_major, $iou_interface_minor ) = split( /\//, $iou_src[1] );
    ( $pseudo_instance_interface_major, $pseudo_instance_interface_minor ) =
      split( /\//, $iou_dst[1] );
}
close(netmap_handle);
print
"Using pseudoinstance $pseudo_instance, interface $pseudo_instance_interface_major/$pseudo_instance_interface_minor\n"
  if $verbose;

die
"Could not find any valid mapping for IOU pseudo instance $pseudo_instance in NETMAP file"
  unless ( ( defined $iou_instance )
    && ( defined $iou_interface_major )
    && ( defined $iou_interface_minor )
    && ( defined $pseudo_instance_interface_major )
    && ( defined $pseudo_instance_interface_minor ) );

# unlink socket for IOU pseudo instance
unlink "$socket_base/$pseudo_instance";

# create socket for IOU pseudo instance
$iou_pseudo_sock = IO::Socket::UNIX->new(
    Type     => SOCK_DGRAM,
    Listen   => 5,
    Local    => "$socket_base/$pseudo_instance"
) or die "Can't create IOU pseudo socket\n";

# availability to read shall be queried through select()
$select_handle = IO::Select->new();
$select_handle->add($iou_pseudo_sock);

# allow anyone to read and write
chmod 0666, "$socket_base/$pseudo_instance";

print "Created pseudo IOU socket at $socket_base/$pseudo_instance\n"
  if $verbose;

# attach to real IOU instance
$iou_router_sock = IO::Socket::UNIX->new(
    Type => SOCK_DGRAM,
    Peer => "$socket_base/$iou_instance"
) or die "Can't connect to IOU socket at $socket_base/$iou_instance\n";
print "Attached to real IOU socket at $socket_base/$iou_instance\n" if $verbose;

# precompute IOU header
# IOU header format
# Pos (byte)    value
# ==============================================================
# 00 - 01       destination (receiving) IOU instance ID
# 02 - 03       source (sending) IOU instance ID
# 04            receiving interface ID
# 05            sending interface ID
# 06 - 07       fixed delimiter, looks like its always 0x01 0x00
#
#               interface ID = <major int number> + (<minor int number> * 16)

$iou_header = pack( "nnCCH4",
    $iou_instance,
    $pseudo_instance,
    ( $iou_interface_minor << 4 ) | $iou_interface_major,
    ( $pseudo_instance_interface_minor << 4 ) |
      $pseudo_instance_interface_major,
    "0100" );

print "Precomputed IOU Header: ", unpack( "H*", $iou_header ), "\n" if $verbose;

# provide a clean exit
$SIG{INT} = \&caught_sigint;

# Open capture file
if ( defined $cap_file ) {
    $cap_handle = Net::Pcap::pcap_open_dead( DLT_EN10MB, 1500 );
    $cap_dumper = Net::Pcap::pcap_dump_open( $cap_handle, $cap_file )
      or die "Cant open capture file: $!";
    print "Opened file $cap_file for packet dump.\n" if $verbose;
}

# Determine Mode and setup sender and receiver logic
if ( defined $iface ) {
    print "Working in pcap mode.\n" if $verbose;

    # construction of IOU MAC address for external connectivity
    # Pos (byte)            value
    # ==============================================================
    # 0 (high nibble)       from IOU instance ID (2 bytes, only 10 bits used),
    #                       the two least significant bits from the high byte
    #                       are taken and shifted one bit left
    # 0 (low nibble)        always 0xE
    # 1 - 3                 UID of the user that runs the IOU instance
    # 4                     low byte of the IOU instance ID
    # 5                     interface ID
    #
    # for x64 systems, binary math works well, like
    # $mac = (((($iou_instance & 0x0300) << 1 ) << 36 ) + 0xE0000000000 );
    # $mac += $uid << 16;
    # $mac += ($iou_instance & 0xFF) << 8;
    # $mac += ($iou_interface_minor << 4) + $iou_interface_major;

    my $macstring;
    $macstring = pack( "CH6CC",
        ( ( $iou_instance >> 7 & 6 ) << 8 ) + 0xE,
        unpack( "xH6", pack( "N", 0xFF000000 ^ $uid ) ),
        $iou_instance & 0xFF,
        ( $iou_interface_minor << 4 ) | $iou_interface_major );

    $macstring = uc( join( ":", unpack( "(H2)*", $macstring ) ) );

    print "Using MAC $macstring.\n" if $verbose;

    # bind to network interface, promiscuous mode
    $pcap = Net::Pcap::open_live( $iface, 1522, 1, 1, \$err );
    die "pcap: can't open device $iface: $err (are you root?)\n"
      unless ( defined $pcap );

    # build a capture filter for IOU interface MAC address
    # this will match only what is destined to $macstring, plus multicasts
    # and broadcasts
    Net::Pcap::compile( $pcap, \$pcap_filter,
        '(ether[0] & 1 = 1) or (ether dst ' . $macstring . ')',
        0, 0xFFFFFFFF )
      && die 'Unable to compile capture filter';
    Net::Pcap::setfilter( $pcap, $pcap_filter )
      && die 'Unable to assign capture filter';
    print "Capture filter set: (ether[0] & 1 = 1) or (ether dst '"
      . $macstring . "')\n"
      if $verbose;

    print
"Forwarding frames between interface $iface and IOU instance $iou_instance, int $iou_interface_major/$iou_interface_minor (MAC: $macstring) -  press ^C to exit\n";

    while (1) {

        if ( grep { $_ eq $iou_pseudo_sock } $select_handle->can_read(0.001) ) {

            # IOU frame received via pseudo ID socket
            $iou_pseudo_sock->recv( $iou_recv_data, 1522 );
            log_iou_frame( "R:I->P", $iou_recv_data ) if $debug;

            $iou_recv_data = unpack( "x8a*", $iou_recv_data );

            # send IOU generated frame to real network
            Net::Pcap::sendpacket( $pcap, $iou_recv_data );
            write_pcap_dump($iou_recv_data) if $cap_dumper;
            log_frame( "S:I->P", $iou_recv_data ) if $debug;
        }
        else {

            my %pcap_hdr;
            my $return =
              Net::Pcap::pcap_next_ex( $pcap, \%pcap_hdr, \$pcap_recv_data );
            if ( $return eq 1 ) {
                write_pcap_dump($pcap_recv_data) if $cap_dumper;
                log_frame( "R:P->I", $pcap_recv_data ) if $debug;

                # add IOU header in front of the received frame
                # and send frame to IOU socket
                $iou_router_sock->send(
                    pack( "a*a*", $iou_header, $pcap_recv_data ) );
                log_iou_frame( "S:P->I",
                    pack( "a*a*", $iou_header, $pcap_recv_data ) )
                  if $debug;

            }
        }
    }
}
elsif ( defined $udp_conn ) {

    # accept localport:remotehost:remoteport, or localport:remoteport
    if ( $udp_conn =~ m/^\d+:\d+$/ ) {
        ( $udp_spt, $udp_dpt ) = split( /:/, $udp_conn );
        $udp_shost = $udp_dhost = "127.0.0.1";
    }
    elsif ( $udp_conn =~ m/^\d+:[\w\.]+:\d+$/ ) {
        ( $udp_spt, $udp_dhost, $udp_dpt ) = split( /:/, $udp_conn );
        $udp_shost = "";
    }
    else {
        die "UDP port format doesnt match";
    }

    print "Working in UDP mode.\n" if $verbose;

    # bind to udp port
    $udp_listener = IO::Socket::INET->new(
        Proto     => "udp",
        LocalPort => $udp_spt,
        LocalAddr => $udp_shost,
        PeerPort  => $udp_dpt,
        PeerAddr  => $udp_dhost
    ) or die "Can't bind to UDP port.\n";

    print
"Forwarding frames between UDP ports local:$udp_spt, $udp_dhost:$udp_dpt and IOU instance $iou_instance, int $iou_interface_major/$iou_interface_minor -  press ^C to exit\n";

    $select_handle->add($udp_listener);

    while (1) {
        my ($readable) =
          IO::Select->select( $select_handle, undef, undef, 0.001 );

        foreach my $socket (@$readable) {
            if ( $socket == $iou_pseudo_sock ) {

                # IOU frame received via pseudo ID socket
                $iou_pseudo_sock->recv( $iou_recv_data, 1522 );
                log_iou_frame( "R:I->U", $iou_recv_data ) if $debug;

                $iou_recv_data = unpack( "x8a*", $iou_recv_data );

                # send IOU generated frame via udp
                $udp_listener->send($iou_recv_data);
                write_pcap_dump($iou_recv_data) if $cap_dumper;
                log_frame( "S:I->U", $iou_recv_data ) if $debug;
            }
            else {
                $udp_listener->recv( $iou_recv_data, 1522 );
                write_pcap_dump($iou_recv_data) if $cap_dumper;
                log_frame( "R:U->I", $iou_recv_data ) if $debug;

                $iou_router_sock->send(
                    pack( "a*a*", $iou_header, $iou_recv_data ) );
                log_iou_frame( "S:U->I",
                    pack( "a*a*", $iou_header, $iou_recv_data ) )
                  if $debug;
            }
        }
    }
}
elsif ( defined $tap ) {

    print "Working in TAP mode.\n" if $verbose;

    # get file handle
    $tap_handle = IO::File->new( "/dev/net/tun", O_RDWR )
      or die "Cannot open /dev/net/tun";

    # make it tap (not tun)
    my $ifr = pack( 'Z16s', $tap, 0x1002 );
    ioctl $tap_handle, 0x400454ca, $ifr
      or die "Can't ioctl() on device $tap: $!";

    print
"Forwarding frames between TAP interface $tap and IOU instance $iou_instance, int $iou_interface_major/$iou_interface_minor -  press ^C to exit\n";

    $select_handle->add($tap_handle);

    while (1) {
        my ($readable) =
          IO::Select->select( $select_handle, undef, undef, 0.001 );

        foreach my $socket (@$readable) {
            if ( $socket == $iou_pseudo_sock ) {

                # IOU frame received via pseudo ID socket
                $iou_pseudo_sock->recv( $iou_recv_data, 1522 );
                log_iou_frame( "R:I->T", $iou_recv_data ) if $debug;

                $iou_recv_data = unpack( "x8a*", $iou_recv_data );

                # send IOU generated frame via udp
                $tap_handle->syswrite($iou_recv_data);

                write_pcap_dump($iou_recv_data) if $cap_dumper;
                log_frame( "S:I->T", $iou_recv_data ) if $debug;
            }
            else {
                $tap_handle->sysread( $iou_recv_data, 1522 );
                write_pcap_dump($iou_recv_data) if $cap_dumper;
                log_frame( "R:T->I", $iou_recv_data ) if $debug;

                $iou_router_sock->send(
                    pack( "a*a*", $iou_header, $iou_recv_data ) );
                log_iou_frame( "S:T->I",
                    pack( "a*a*", $iou_header, $iou_recv_data ) )
                  if $debug;
            }
        }
    }

}
else {

    # catchall, we really shouldnt land here
    print "No valid mode of operation selected.\n\n$help";
    caught_sigint();
}

sub caught_sigint {
    print "\n...stopped.\n";
    print "Cleaning up.\n";
    $select_handle->remove( $select_handle->handles );

    if ( defined $pcap ) {
        Net::Pcap::breakloop($pcap);
        Net::Pcap::close($pcap);
        print "Closed pcap receiver loop.\n" if $verbose;
    }
    if ( defined $udp_listener ) {
        $udp_listener->close;
        print "Closed udp listener.\n" if $verbose;
    }
    if ($tap_handle) {
        $tap_handle->close;
        print "Closed tap handle.\n" if $verbose;
    }
    if ($cap_handle) {
        Net::Pcap::pcap_dump_flush($cap_dumper);
        Net::Pcap::pcap_dump_close($cap_dumper);
        print "Closed dump file.\n" if $verbose;
    }

    $iou_pseudo_sock->close;
    $iou_router_sock->close;

    exit(0);
}

sub log_frame {
    my ( $direction, $frame ) = @_;
    return if ( length($frame) < 14 );

    # Print direction, source mac, destination mac and ethertype
    print "$direction                      S ",
      join( ":", unpack( "x6(H2)6", $frame ) ),
      " D ",
      join( ":", unpack( "(H2)6", $frame ) ),
      " T ",
      unpack( "x12H4", $frame ),
      "\n";
}

sub log_iou_frame {
    my ( $direction, $frame ) = @_;
    return if ( length($frame) < 22 );

    # Print direction, IOU header, source mac, destination mac and ethertype
    print "$direction IOU ",
      unpack( "H16", $frame ),
      " S ",
      join( ":", unpack( "x14(H2)6", $frame ) ),
      " D ",
      join( ":", unpack( "x8(H2)6", $frame ) ),
      " T ",
      unpack( "x20H4", $frame ),
      "\n";
}

sub write_pcap_dump {
    my $frame = shift @_;
    my %header;
    $header{len} = $header{caplen} = length($frame);
    ( $header{tv_sec}, $header{tv_usec} ) = gettimeofday();
    Net::Pcap::pcap_dump( $cap_dumper, \%header, $frame );
    Net::Pcap::pcap_dump_flush($cap_dumper);
}

一、     IOU简介

Cisco IOU （Cisco IOS On Unix），IOU基于unix/linux环境，比之GNS3、小凡都要节省不少系统资源。

IOU包括以下文件：

i86bi_linux-adventerprisek9-ms                  // 带有IOS高级特性的IOU

i86bi_linux-ipbase-ms                          // 带有基本的IP路由功能的IOU

i86bi_linux-tpgen+ipbase-ms.PAGENT.4.7.0         // 带有基本的IP路由功能和流量生成工具的IOU

i86bi_linuxl2-upk9-ms.M                       // 带layer 2功能的IOU，

iourc                                       // license文件

NETMAP                                     // topology文件

wrapper-linux                                // IOU的管理控制器

二、     IOU的使用方法

1. 1.   wrapper-linux的使用：

./wrapper-linux [-v] –m<image name> -p<port number> — <iou options> <router id>

where <port number> is in the range <1024-65550>

all options after the ‘–’ are passed to iou

[-v] : display version;

-m：指定IOU镜像

-p：指定用于telnet的端口，范围是1024-65550；

–：用于传递iou的参数。

1. 2.    IOU用法：

以i86bi开头的文件都能使用一下参数

Usage:<image> [options] <application> id

<image>: unix-js-m | unix-is-m | unix-i-m | …

<application id>: instance identifier (0 < id <= 1024)

Options:

-e <n>     number of Ethernet interface (default 2)  // 指定etherne的模块数量

-s <n>     number of Serial interface (default 2)    // 指定serial的模块数量

-n <n>     Size of nvram in kb (default 16kb)    // 指定nvram的大小，默认16kb

-b <string>  IOS debug string

-c <name>  Configureation file name

-d          Generate debug information

-t          Netio message trace

-q          Supperss informational messages

-h          Display this help

-C         Turn off use of the host clock

-m <n>     Megabytes of router memory (default 128MB)  // 指定路由器的内存，默认128M。

-L         Disable local console,use remote console  // 关闭本地console，开启远程console。

-u<n>      UDP port base for distributed networks   // 基于分布式网络的UDP端口。

-R         Ignore options from the IOURC file     // 忽略IOURC文件

-U         Disable unix: file system location

-W         Dsiable watchdog timer

-N         Ingnore the NETMAP file             // 忽略NETMAP文件

IOU举例：

./ i86bi_linux-adventerprisek9-ms  -p 2000 –  -e 4 –s 4 1

-e 4  // 配置4个Ethernet接口模块，每个模块4个接口，0-3；

-s 4  // 配置4个serial 接口模块，每个模块4个接口，0-3；

1  // 路由器的进程名

Serial为Ethernet+1

在此列中：

Ethernet 16个，e0/0 —- e3/3；

Serial 16个， s4/0 —- s7/3。

wrapper-linux使用举例：

./wrapper-linux –m  ./ i86bi_linux-adventerprisek9-ms  -p 2000  –  -e 4 –s 4 1  &

三、     用NETMAP建立网络拓扑

NETMAP文件的书写格式：

路由器实例名：插槽号/该插槽上的接口号

 分布式书写格式：

路由器实例名：插槽号/该插槽上的接口号@IP_Add | Hostname

NETMAP实例：

1:0/0  2:0/0

1:0/1  3:0/0

1:0/2  4:0/0

1:4/0@192.168.1.1 2:4/0@192.168.1.2

1:4/1@wesley.org  3:4/1@linux.com

解析：1:0/0表示第一台路由器ethernet接口，第一个模块的第一个接口，即 e0/0；

1:4/0 表示第一台路由器serial接口，第一个模块的第一个接口，即s4/0。

四、     迁移&互通

网上很多IOU基本都是使用cdlinux或者andlinux作为载体的，不是很方便更改top，局限性比较大，况且自己动手丰衣足食嘛。

系统环境：VMware WorkStation 7.14

Red Hat Enterprise Linux 6.1

*Python-2.6

Openssl-0.9.8

IOU文件：L3&L2 IOU

（NETMAP、iourc 、i86bi_linux-adventerprisek9-ms、i86bi_linuxl2-upk9-ms.M 、wrapper-linux、crack.py（破解L2IOU<达人作品，不知何人！>））

  1、迁移

  >>>在RHEL 6.1的root下创建目录：

[root@wesleyou ~]#mkdir cisco_iou

>>>copy IOU文件至cisoc_iou目录：

[root@wesleyou cisco_iou]#cp i86b*  wrap-linux NETMAP iourc cisco_iou

  *>>>编译安装python-2.6：

[root@wesleyou python2.6]#./configure

[root@wesleyou python2.6]#make & make install

[root@wesleyou python2.6]#make clean

*>>>添加PATH：

[root@wesleyou python2.6]#export PATH=/usr/local/bin/python2.6:$PATH

注：带*的是指如果服务器python低于2.6的情况下，当然除此之外还有yum、rpm等方法。

>>>安装openssl：

[root@wesleyou python2.6]# cd ~

[root@wesleyou ~]# rpm –ivh openssl-0.9.8-*.rpm

>>>连接lib库

[root@wesleyou ~]# ln –s /usr/lib/libcrypto.so.0.9.8e libcrypto.so.4

注：./wrapper-linux 会调用这个库文件，如果没有就会报错。在这很感谢撒加大神提供的解决思路和方法。

  >>>设置IOU运行级别

[root@wesleyou cisco_iou]# chmod 777 *       // 偷懒的做法

     >>>破解license

[root@wesleyou cisco_iou]# python ./crack.py

注：此处很重要，该程序是为了获取license，L3&L2 IOU都能使用。此程序为互联网上流出，何人所写，不清楚，感谢作者的无私奉献。

     >>>修改iourc

[root@wesleyou cisco_iou]# vi iourc

License格式：

hostname  = license_number;

准备工作基本上都做完了，至此可以测试一下L3&L2 IOU。测试命令参见上文。

  2、搭建拓扑

说明：路由器使用L3IOU来模拟，而交换机则都通过L2IOU来模拟，至于PC可以使用L3IOU或者L2IOU皆可。

    >>>创建一个放置拓扑文件和启动脚本的目录：

[root@wesley cisco_ou]# mkdir lab01

[root@wesley cisco_ou]# mv NETMAP lab01

[root@wesley cisco_ou]# cd lab01

>>>创建拓扑文件

[root@wesley lab01]# vi NETMAP

# ! /bin/bash

# written by wesley

# date:2011/6/17

1:0/0  2:0/0

1:0/1  3:0/0

2:0/1  4:0/0

3:0/1  4:0/1

3:0/2  4:0/2

3:0/3  5:0/0

4:03  6:0/0

>>>创建启动脚本：

[root@wesley lab01]# vi start

# !/bin/bash

# written by Wesley

# and thanks for 撒加、flyxj、残泪、棕鹰、骁鹰…

# anyone who is help me to improve !!!

export  NETMAP=../lab01/NETMAP           // 设置NEMAP的变量，将其添加至环境中

port=2000                                 // 设置端口变量

for ((i=1;i<7;i++));do

dport=‘expr $port + $i’

../wrapper-linux –m ./ i86bi_linux-adventerprisek9-ms –p $dport — -e 2 –s 2 –R –U $i &

if (($i>2));then

../wrapper-linux –m ./ i86bi_linuxl2-upk9-ms.M –p $dport — -e 4 –R –U　$i  &

fi

sleep 2

done

unset NETMAP                       // 将NETMAP从环境变量中取消

     >>>创建关闭IOU的stop：

[root@wesleyou cisco_iou]# vi stop

# ！/bin/bash

# written by Wesley

# and thanks for 撒加、flyxj、残泪、棕鹰、骁鹰…

# anyone who is help me to improve !!!

kill –HUP ` ps –a | grep wrapper-linux | awk ‘{print $1}’`    // 退出IOU

注：很多朋友都用的killall，但是我发现使用killall后并不能得到完全释放，当想再次试验的时候会提示地址已被使用。

最后再次感谢撒加大神、flyxj，残泪、骁鹰、棕鹰等网友的帮助，还要感谢我的领导spy在linux方面对我的指导。

另：恭喜flyxj一次pass IE。

你偶尔还会用MS-DOS吧？在XP/Win7下，他叫cmd。现在除了技术人员，一般人也最多在重装系统时见到这个东东吧，哦还有 ping 网站啥的。

尽管现在图形界面已经横行，不过还是怀念当年对着单色显示器敲着键盘通宵打游戏的感觉。  包括当年的经典游戏，俄罗斯方块、战斧、三国演义、Doom等等，还记得94年左右小谭同学花了1800元买了一批国外的游戏软件，寄来的是20~30张5寸软盘，那在当年绝对是有钱人的行为，令人羡慕啊。

 

MSDOS wiki

1980年，西雅图電腦产品公司（Seattle Computer Products）的一名24岁的程序员蒂姆·帕特森（Tim Paterson）花费了四个月时间编写出了86-DOS操作系统。1981年7月，微软以五萬美元的代價向西雅图公司购得本產品的全部版权，并将它更名为MS-DOS。它成功地成为IBM PC采用的操作系统。

西雅图電腦产品公司后来曾将微软告上法庭，指控微软在购买86-DOS版权时，并未透露IBM是其客户。微软在1986年向西雅图计算机产品公司又支付了100万美元，了结了双方之间的纠纷。

一、设置新的密码

主机用网线连接e8网关，拔掉电话线；

在浏览器打开【http://192.168.1.1】；

输入用户名【telecomadmin】，输入密码【nE7jA%5m】；

进入login页面后，点击【管理】，设置新的密码，并确定。我们将用这个新密码替换超级用户的密码。

二、开启e8网关的TELNET的访问控制

从IE地址栏进入【http://192.168.1.1/scsrvcntr.cmd?action=view】

勾选表格中【LAN】对应的【TELNET】项，保存并应用。（在完成以下操作后，应将此项还原）

三、修改e8网关的配置

在华军下载软件TFTPD32，并打开TFTPD32。这时，可以在TFTPD32的窗口看到自己的IP地址 192.168.1.x ；

从开始菜单运行『命令提示符』 ；

输入 TELNET 192.168.1.1

login: 输入admin

password:输入admin（这里是不显示密码的）；

出现“>”提示符后输入：

tftp -p -f cfg.xml -tc 192.168.1.x （这里的IP地址就是在TFTPD32窗口看到的）。

稍候，点击TFTPD32窗口的[Show Dir]按钮，可以看到TFTPD32目录中的cfg.xml文件。

下载一个UltraEdit32 来打开cfg.xml文件。

在cfg.xml文件中的<SystemInfo>下方，可以看到：

。。。。。。

<sysUserName value=”admin”/>      —— 这是刚才TELNET时所用到的用户名

<tr69c state=”enable”  。。。。。。  —— TRC069远程议管理协议

。。。。。。

<sysPassword value=”YWRtaW4=”/>    —— 这是刚才TELNET时所用到的加密后的密码

<sptPassword value=”c3VwcG9ydA==”/>

<usrUserName value=”useradmin”/>       —— 这是e8网关底部标签上的用户名

<usrPassword value=”xxxxxxxxxxxxx”/> —— 这是我们在第一步修改后的加密密码

<ctUserName value=”telecomadmin”/>     —— 这是web界面的超级用户名

<ctPassword value=”bkU3akElNW0=”/>     —— 这是web界面的超级用户的加密密码：nE7jA%5m

修改用户名和超级用户密码

修改用户名”useradmin”；

修改超级用户名”telecomadmin” ————这两个不要使用相同的用户名。

将修改后的加密密码”xxxxxxxxxxxxx”，替换掉超级用户的加密密码”bkU3akElNW0=”；

如果在<SystemInfo>段没有超级用户的设置参数，可以参照上面的格式添加。

禁用电信TRC069远程管理

将<tr69c state=”enable” 中的enable替换为disable。目的是禁止远程控制恢复到原来的统一标识。

修改完全属于自己的无线网络名称（SSID）

在cfg.xml文件中开始处的<WirelessCfg>部分，找到：

<wlMssidEntry enblSsId=”1″ ssId=”ChinaNet-rMd4″。。。。。。，

将引号中的ChinaNet-rMd4，修改为自己的无线网络名。

修改完成后，存盘。

上传修改后的配置文件

在命令行输入：

TELNET 192.168.1.1

login: admin

password:admin

出现“>”提示符，输入：

tftp -g -f cfg.xml -tc 192.168.1.x  (与上面IP相同)

完成后回车，稍候e8网关会重新启动，至此，e8网关的超级用户名和密码等等，完全是自己的了。

以后需要设置e8无线网关时，拔掉电话线，在web用自己的超级用户名和密码登陆，然后在地址栏输入：http://192.168.1.1/index.html，并回车，既可进入完全的设置界面了。

我想用我所理解的系统概念为各位稍微的介绍一下在Mac上的驱动程序概念，基本上，Mac OS X Tiger是一个UNIX架构的核心的系统，所以如果有一些UNIX系统概念其实在底层的架构会很容易了解，系统核心，通常会有包含了硬件支持的程序在内，也就是说有一些需要在系统核心启动就跟着支持的基础硬件组件（例如CPU 指令集支持、内存管理…），大多放在核心中，不过Mac是一种经由APPLE公司自行订制化的核心，基础的硬件支持大多也以APPLE计算机为主，但是，并不会把所有的驱动程序都放在核心中，通常只有『必要的』才会放在核心，不然核心可能会过度肥大，整个系统执行效率就更差。

那么还有许多硬件驱动怎么办呢？通常会把他作成模块程序，然后在核心本身支持模块加载功能，在Linux 中叫做 Kernel Loadable Modules(KLM) 的架构，而在Mac OS X 中，称为 Mac OS X Kernel Extension，其实就把他想成是『驱动程序』就可以了，也就是Mac OS X系统中许许多多的 .kext 文件名的程序集，大多放在 /System/Library/Extensions/ 中，当核心有需要就去找到相应的设备ID然后叫起那个程序来支持硬件。

而现在的MAC OSX86 中其实问题比较多就是在硬件没有驱动支持，也就是没有相应的驱动程序可以使用，相关的HCL (硬件兼容列表）可以到 http://wiki.osx86project.org/wiki/index.php/HCL 下找到，进而可以找到相应可使用的驱动程序。

看了第一部分，假设您已经有简单的概念后，我们知道，其实Mac的驱动程序就是 Kernel Extension，也就是硬件相对应的 .kext 档案，我无法告诉妳哪里一定找的到兼容的kext可以用，但是可以提供个下载驱动的地址http://www.weiphone.com/thread-1918-1-1.html
因为，kext 档案不一定每一种硬件都有人为他制作驱动，所以还是请您自己去查 相关的HCL (硬件兼容列表），先确定有支持，如果不在内建的系统中，应该都有下载kext的连结和说明，所以以下程序我都假设已经找到了kext的档案，

二、实例：安装T43网卡：

我当初找到了 T43 用的 Broadcomd 5751 的kext档案 AppleBCM5751Ethernet.kext
我以他为例安装入系统内的步骤如下：

1. 打开终端：
打开终端，执行：

sudo -s

然后键入你的密码，做好切换管理员的动作。
PS. sudo 是一个安全为考虑的执行管理指令的方法，这边不多做介绍。

2. 复制kext 到相应目录：
相应目录是 ” /System/Library/Extensions/ ” ，
只要把你找到的驱动 .kext 档案复制到 /System/Library/Extensions/ 中，
方法一：直接进入” /System/Library/Extensions/ “目录中，将自己的驱动 .kext 档案复制到里面，中途可能要输入密码；
方法二：假设你的驱动叫AppleBCM5751Ethernet.kext，并放在桌面的，
指令如下：

cp ~/Desktop/AppleBCM5751Ethernet.kext /System/Library/Extensions/

3. 更改文件权限：
文件权限是UNIX系统中蛮重要的一个观念，在Unix为基础的Mac OS X中也一样，就是要把这些复制到系统内的文件的权限切换成系统（管理员）拥有与使用，指令如下：

sudo chown -R root:wheel /System/Library/Extensions/AppleBCM5751Ethernet.kext
sudo chmod -R 755 /System/Library/Extensions/AppleBCM5751Ethernet.kext

4. 清除 kext 的快取：
要清除已经安装并制作快取的kext 快取内容，不然可能下次重启之后系统还是去读取快取，就不会读到新放进去kext 驱动
指令如下：

rm /System/Library/Extensions.kextcache
rm /System/Library/Extensions.mkext
kextcache -k /System/Library/Extensions

5. 系统重启：
硬件驱动后基本上是需要重启才会加载，可以点选右上角的苹果点选重启系统，或是使用指令 reboot 重启，接下来就是祈祷重启后系统一切正常，硬件支持良好啦！

　依次单击“开始”→“设置”→“控制面板”，在控制面板窗口依次双击“管理工具”→“本地安全策略”。
　　在“ 本地安全策略”窗口左边选择“软件限制策略”，依次单击“操作”→“创建新策略”。然后在“其他规则”上单击鼠标右键选择“新路径规则”，在弹出窗口中单击“浏览”按钮，选择“C:\Program Files\AntiVir PersonalEdition Classic\avnotify.dll”，在“安全级别”下拉列表中选择“不允许”（表示不让这个dll文件执行，1，“应用”并“确定”。
　　按照Step2的操作，在“软件限制策略”中将“C:\Program Files\AntiVirPersonalEdition Classic\avnotify.exe”的安全级别设置为“不允许”。全部设置后之后，在“本地安全策略”可以看到两个新增的软件限制策略，确定无误即可。
　　这样设置以后，AntiVir就再不会弹出烦人的广告窗口了，我们就可以安静地使用小红伞了。

二、去小红伞启动画面。。。

编辑注册表：

找到HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows\CurrentVersion\Run

在右边的avgnt项目中编辑：

原值是： 小红伞安装路径\avgnt.exe” /min

现在在/min后加个 /nosplash

成为： 小红伞安装路径\avgnt.exe” /min /nosplash

这样，下次启动不会出现了

1，进入安装界面后到选择驱动器面板时，点击 高级选项，随便设置大小
2，保留那个100m分区，删除100M分区下面的那个新建区
3，鼠标点击100M分区后，选择扩展此分区，大小设置成C盘的大小。
4，你就可以正常安装win7了，你安装完后看看，是不是没有这个分区了。

这种方式在我的Dell Vostro 220s上是不成功的，如果只有一个系统分区的情况下，系统安装会终止在completing installation，然后死机，偶尔成功安装但是也会时常报错，所以不建议这种安装方式。
能否在已经安装了Win 7后删除这个分区呢？网上收集以下两种方法：

方法一：
以下文章摘自：http://www.webjx.com/os/windows-15363.html
如何删除Win7创建的200M隐藏分区?
　　答：安装完Windows 7的网友会发现，系统会自动划出一个分区，大小为200MB左右。这是个隐藏的分区，要删除它是比较麻烦的，如果贸然使用DM等分区工具来删除，会损坏硬盘的分区表，导致其他分区消失(不显示盘符了)。即使是使用Windows 7自带的工具来删除，也会导致硬盘分区表处于错误状态，出现丢失文件的问题。
　　要想删除这个200MB的隐藏分区，正确的做法，请按照下面的步骤：
　　1、使用带有分区工具的WinPE启动系统，一定要使用光盘或U盘上的WinPE启动，不要使用安装在硬盘的WinPE启动。
　　2、使用分区工具如WINPM，将200MB的隐藏分区删除，然后将这个删除的分区合并到别的分区去。接着把Windows 7所在的安装分区如C盘设置为活动分区。
　　3、单击“开始”菜单，选“程序→命令提示符”，输入“c:\windows\system32>bcdboot c:\windows /s c:”并回车，修复Windows 7的引导启动。
　　4、重新启动电脑进入Windows 7，问题已经解决了。
　　提示：在安装Windows 7时不要删除硬盘已有的分区，也不要创建新的分区，一定要选择现有的分区来安装，只有这样才能避免Windows 7自动创建的200M隐藏分区。如果是新硬盘，可以使用别的Windows系统或分区工具来把硬盘分好区。最好使用别的Windows系统安装分区，分好区后就可以退出安装并重新启动，转而使用Windows 7启动安装。

方法二：
1、在Windows 7环境下，使用diskpart先把隐藏分区设置为非活动状态inactive
2、然后把Windows 7的系统盘（一般是C盘）激活active，
3、再运行C:\windows\system32\bcdboot.exe C:\windows /s C:命令，该命令目的是重新修复C盘的引导记录和相关文件，生成boot目录及语言包、BCD等文件和根目录下的bootmgr启动文件
4、然后删除隐藏分区。

我试过第二种方法，貌似可以正常工作，不过由于浪费了100M的硬件空间，无法实现合并空间，有些可惜，这种方法不太实用。

在WordPress系统中，默认的首页和目录页使用的书全文输出，这对于文章内容较长的博客来说很不方便，下面介绍这个方法，可以实现在WordPress首页和目录页显示摘要而非全文。

1、使用the_excerpt标签

优点：一劳永逸直接把想要的部分来做摘要
缺点：需要改动模版，而且显示的是纯文本。

使用方法：

首先找到wp-content/themes下你使用的模板目录，查找目录中的文件，如果有home.php则修改home.php，没有的话就修改index.php文件(即wp-contant/themes/你的模版/index.php 或者home.php) 。

找到类似

<?php the_content(__('(more…)')); ?>

或

<?php the_content(); ?>

像在我的模板中index.php文件中找到

<?php the_content(__('Read more...', 'elegantbox')); ?>

我把这行修改为:

<?php if(!is_single()) { the_excerpt(); } else {
     the_content(__('Read more...', 'elegantbox'));} ?>

现在你的wordpress，除非打开单个post，其他情况下都是显示摘要。

2、使用more标签

优点：方法比较正规不需要改动模版

缺点：每次都要加一下这个东西，不灵活只能一刀切。

在你需要截断的地方(就是你的编辑框)加上<!–more–>标志

使用效果：

第一种方法确实简单有效，不过在首页的显示结果里只有摘要内容，而且没有“Read More”的提示，我觉得有点不大习惯，对于阅读者来说如果没有“Read More”提示的话，可能不知道文章是否还有更详细的内容，所以我又改回使用themes原版的index.php文件，采用第二种方式，就是在日志内容中添加<!–more–>标志，这样相对灵活一些，萝卜青菜各有所爱，就看你自已喜欢哪种方式了。