1.4 之前的

 public static String removeSpaces(String s) {
  StringTokenizer st = new StringTokenizer(s," ",false);
  String t="";
  while (st.hasMoreElements()) t += st.nextElement();
  return t;
}

1.4之后的

 public static String ltrim(String source) {
        return source.replaceAll(" ", "");
    }

使用正则

 public static String ltrim(String source) {
        return source.replaceAll("\\s", "");
    }

echo -e "SMS-TEST FROM Lenovo" | gnokii --sendsms 1581XXXX
自己做的安装脚本
cp -f ./gnokii /usr/local/bin/
chmod a+x /usr/local/bin/gnokii
cp -f ./lib*  /usr/local/lib/
cp -f ./.gnokiirc /root

3． 编译Libcurl：
        下载curl源代码，当前版本是curl-7.17.1
        解压
       运行： ""C:\Program Files\Microsoft Visual Studio 8\VC\vcvarsall.bat""
       运行
       set OPENSSL_PATH=c:\openssl-0.9.8k
       curl目录中
       运行 nmake vc-ssl' 生成 curl.exe
           'nmake vc-ssl-dll' 需要libeay32.dll ssleay32.dll

Ubuntu支持GBK，.
      修改/var/lib/locales/supported.d/local文件,在文件中添加
      zh_CN.GBK GBK
      zh_CN.GB2312 GB2312
      sudo dpkg-reconfigure --force locales
      输出

      zh_CN.GB2312 done
      zh_CN.GBK done  

设置eclipse。
  首先Windows->Preferences, 然后选择General下面的Workspace. Text file encoding选择Other GBK， 如果没有GBK的选项，  直接输入GBK，点击 Apply， OK。

public class h {
  public static void main(String[] args) {
    try { 

      SSLServerSocket sslSocket;
      SSLServerSocketFactory sslSrvFact =
        (SSLServerSocketFactory)
          SSLServerSocketFactory.getDefault();
      sslSocket =(SSLServerSocket)sslSrvFact.createServerSocket(8181);
      int port = sslSocket.getLocalPort();

      String [] cipherSuites = sslSocket.getEnabledCipherSuites();
      for(int i = 0; i < cipherSuites.length; i++){
        System.out.println("Cipher Suite " + i +" = " + cipherSuites[i]);
      }
      sslSocket.close();
    } catch (Exception e) {
      System.out.println("Exception" + e);
    }
  }
}
运行结果如果显示２５６的字样就成功了。
Cipher Suite 0 = SSL_RSA_WITH_RC4_128_MD5
Cipher Suite 1 = SSL_RSA_WITH_RC4_128_SHA
Cipher Suite 2 = TLS_RSA_WITH_AES_128_CBC_SHA
Cipher Suite 3 = TLS_RSA_WITH_AES_256_CBC_SHA
Cipher Suite 4 = TLS_DHE_RSA_WITH_AES_128_CBC_SHA
Cipher Suite 5 = TLS_DHE_RSA_WITH_AES_256_CBC_SHA
Cipher Suite 6 = TLS_DHE_DSS_WITH_AES_128_CBC_SHA
Cipher Suite 7 = TLS_DHE_DSS_WITH_AES_256_CBC_SHA
Cipher Suite 8 = SSL_RSA_WITH_3DES_EDE_CBC_SHA
Cipher Suite 9 = SSL_DHE_RSA_WITH_3DES_EDE_CBC_SHA
Cipher Suite 10 = SSL_DHE_DSS_WITH_3DES_EDE_CBC_SHA
Cipher Suite 11 = SSL_RSA_WITH_DES_CBC_SHA
Cipher Suite 12 = SSL_DHE_RSA_WITH_DES_CBC_SHA
Cipher Suite 13 = SSL_DHE_DSS_WITH_DES_CBC_SHA
Cipher Suite 14 = SSL_RSA_EXPORT_WITH_RC4_40_MD5
Cipher Suite 15 = SSL_RSA_EXPORT_WITH_DES40_CBC_SHA
Cipher Suite 16 = SSL_DHE_RSA_EXPORT_WITH_DES40_CBC_SHA
Cipher Suite 17 = SSL_DHE_DSS_EXPORT_WITH_DES40_CBC_SHA

运行openssl找出高强度加密方式对应的java ciphers
openssl ciphers -v 'HIGH:!SSLv2:!ADH:!aNULL:!eNULL:!NULL'
DHE-RSA-AES256-SHA        SSLv3 Kx=DH       Au=RSA  Enc=AES(256)  Mac=SHA1
DHE-DSS-AES256-SHA        SSLv3 Kx=DH       Au=DSS  Enc=AES(256)  Mac=SHA1
AES256-SHA                        SSLv3 Kx=RSA      Au=RSA  Enc=AES(256)  Mac=SHA1
KRB5-DES-CBC3-MD5          SSLv3 Kx=KRB5     Au=KRB5 Enc=3DES(168) Mac=MD5
KRB5-DES-CBC3-SHA          SSLv3 Kx=KRB5     Au=KRB5 Enc=3DES(168) Mac=SHA1
EDH-RSA-DES-CBC3-SHA    SSLv3 Kx=DH       Au=RSA  Enc=3DES(168) Mac=SHA1
EDH-DSS-DES-CBC3-SHA    SSLv3 Kx=DH       Au=DSS  Enc=3DES(168) Mac=SHA1
DES-CBC3-SHA                    SSLv3 Kx=RSA      Au=RSA  Enc=3DES(168) Mac=SHA1

基本匹配的就三个：
TLS_DHE_RSA_WITH_AES_256_CBC_SHA,TLS_DHE_DSS_WITH_AES_256_CBC_SHA,TLS_RSA_WITH_AES_256_CBC_SHA
　　3. Resin3.1.9的配置：
        <http port="443">
          <jsse-ssl>
            <key-store-type>jks</key-store-type>
            <key-store-file>mykey.key</key-store-file>
            <password>mykey</password>
            <cipher-suites>TLS_DHE_RSA_WITH_AES_256_CBC_SHA,TLS_DHE_DSS_WITH_AES_256_CBC_SHA,TLS_RSA_WITH_AES_256_CBC_SHA</cipher-suites>
          </jsse-ssl>
        </http>

要了解SSL协议，首先要了解：加密算法、消息摘要算法（又称为哈希算法Hash），数字签名等概念。这些技术每个都可以写出一整本的书，它们结合在一起，提供了保密性、完整性和身份验证的功能。

设想：ALICE想发消息给她的银行要汇出一笔款。ALICE希望这些消息是保密的，因为这里面包括她的帐户资料和汇款金额。一种办法是使用加密算法，这种技术将她要传递的消息变成经过加密的密文，直接银行解密才可以被读取。 如果采用这种形式，消息只能被一个密钥所加密。没有这个密钥，消息就是无用的。一个良好的加密算法，可以使入侵者面临无法克服困难来解密原文。

有两种加密算法系列：传统加密算法（对称加密）和公钥加密算法（非对称加密）

也称为对称加密，需要发送者和接收者共享一个密钥：同时用于加密和解密的信息。 只要密钥是保密的，除了收件人和发件人外没有人可以阅读该消息。如果Alice和银行知道这个密钥，那么他们可以给对方发送的经过此密钥加密的消息。这种算法的主要任务在于发送者和接收者如何共享一个密钥，同时确保没有第三方知道这个密钥，如果多人之间传递消息，如何保证这么多密钥的安全，就是一个棘手的问题。

也被称为非对称加密技术，通过使用2个密钥（其中一个可以解密另外一个加密的消息），解决了加密密钥交换的问题。 如果用其中的一个密钥用于加密信息，必须使用另外一个密钥来解密。这样就有可能获得简单地发布一个密钥（公钥），并使用未发布的密钥（私钥）来接受经过公钥加密的消息。

任何人都可以使用公共密钥加密消息，但只有私钥拥有者将能够读取它。这样，ALICE可以在发送需要保密的汇款消息给银行的时候，可以使用银行的密钥对中的公钥来对这个消息进行加密，而只有银行可以使用他们自己保管的私钥来进行解密。

虽然ALICE可以加密她的消息，但仍然有一个问题，就是有人可能会修改她发给银行的消息，并将ALICE的钱转移到自己的帐户上。为了保证ALICE消息在传递过程中没有被人篡改，可以让她创建一个消息的摘要和加密的消息一起寄到银行，银行收到消息后，将消息和消息的摘要做一个比较，如果消息内容和摘要匹配，则就可以证明消息传递过程中，没有别人篡改。

像这样的摘要被称为消息摘要， 单向函数或哈希函数 。消息摘要用于创建一个简短的固定长度，或可变长度的消息。消息摘要算法被设计成为每个消息产生一条独立的信息摘要。消息摘要算法的目的，就是让人无法为两条不同的消息找到相同的消息摘要，从而消除了使用一条摘要相同的消息替换另外一条消息的可能性。

另一个爱丽丝面临的挑战是找到一种方法，即使安全地将消息摘要发送到银行;如果消息摘要发送过程不安全，银行将无法判断消息是否就是来自ALICE。只有在消息摘要能安全地发送，才能够使消息的完整性被确定。

一个安全发送消息摘要的方式是使用数字签名。

当Alice将消息发送给银行，银行需要确保消息真正地是从她这里发出的，以确保入侵者不能使用她的帐户进行交易。 签名就是由ALICE为实现这一目的而创建的一个专门消息。

数字签名主要使用私钥来加密消息摘要和其他信息，譬如一个序列号,虽然任何人都可以使用公钥解密数字签名，只有发送方知道私钥。这意味着，只有发件人可以签署了该消息。包含了信息摘要的签名表示这个签名只对这个消息有效，而且它确保了消息的完整性，即这个消息的发送过程中没人可以改变摘要并另外对它做签名。

为了防止入侵者拦截，并在以后再次使用这个签名，签名包含一个唯一的序列号。 这样可以保证ALICE无法否认她曾经发送过这条消息，因为只有她可以签名这条消息（不可抵赖性）。

虽然ALICE给银行发出一条经过她个人私钥签名的消息，并且可以确保她发送的消息是真实可靠的，但她依然要确保她的确是和银行在通信。这意味着她必须确保她使用的公钥是银行密钥对中的公钥，而不是入侵者的。同样道理，银行业也需要核实用于签名该消息的私钥是属于ALICE的。如何使银行和ALICE能否核实对方的身份呢？

如果每个人的证书都由一个大家都信任的机构签名，那么每个人都可以验证其他有该证书的人的身份。这种被大家都信任的机构，称为认证中心（CA)，他们负责认证证书。

证书内容包括：公钥和真实身份识别信息，包括个人，服务器或其他实体。如表1所示，主题信息包括身份识别信息（DN）和公钥。它还包括认证和签发的CA签发这个证书的有效期，还可能有一些其他的信息（或者成为扩展信息），一般由CA自行定义使用的管理信息，譬如序列号等。

识别名DN是用来提供对某个特定背景下的身份，例如：某个人作为公司的一个雇员而拥有一个证书。识别名DN有X.509标准定义，包括它的字段，字段名和相应的缩写表示。（如表2所示）

证书颁发机构可以定义一个策略，指明哪些识别名字段名是可选的，哪些是必需的。很多证书还对某些字段的内容做出要求。例如，Netsacpe浏览器要求一个服务器证书的CN能够匹配通配符样式的域名，例如：*.snakeoil.com。

证书的二进制格式是使用了ASN.1（抽象语法标记）定义[X208] [ PKCS]。 这种表示法定义了如何指定编码规则的内容和如何将信息转换成二进制形式。证书的二进制编码使用了区分编码规则Distinguished Encoding Rules (DER)，它是基本编码规则Basic Encoding Rules (BER)的一个子集。对于那些不能采用二进制的信息传递，二进制形式可以转化为一个ASCII形式使用Base64编码[MIME]。当证书放置在Begin和End分割线中的时候，这种编码被称为增强型安全私人邮件格式(PEM -"Privacy Enhanced Mail") 编码的证书。

Example of a PEM-encoded certificate (snakeoil.crt)
-----BEGIN CERTIFICATE-----
MIIC7jCCAlegAwIBAgIBATANBgkqhkiG9w0BAQQFADCBqTELMAkGA1UEBhMCWFkx
FTATBgNVBAgTDFNuYWtlIERlc2VydDETMBEGA1UEBxMKU25ha2UgVG93bjEXMBUG
A1UEChMOU25ha2UgT2lsLCBMdGQxHjAcBgNVBAsTFUNlcnRpZmljYXRlIEF1dGhv
cml0eTEVMBMGA1UEAxMMU25ha2UgT2lsIENBMR4wHAYJKoZIhvcNAQkBFg9jYUBz
bmFrZW9pbC5kb20wHhcNOTgxMDIxMDg1ODM2WhcNOTkxMDIxMDg1ODM2WjCBpzEL
MAkGA1UEBhMCWFkxFTATBgNVBAgTDFNuYWtlIERlc2VydDETMBEGA1UEBxMKU25h
a2UgVG93bjEXMBUGA1UEChMOU25ha2UgT2lsLCBMdGQxFzAVBgNVBAsTDldlYnNl
cnZlciBUZWFtMRkwFwYDVQQDExB3d3cuc25ha2VvaWwuZG9tMR8wHQYJKoZIhvcN
AQkBFhB3d3dAc25ha2VvaWwuZG9tMIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKB
gQDH9Ge/s2zcH+da+rPTx/DPRp3xGjHZ4GG6pCmvADIEtBtKBFAcZ64n+Dy7Np8b
vKR+yy5DGQiijsH1D/j8HlGE+q4TZ8OFk7BNBFazHxFbYI4OKMiCxdKzdif1yfaa
lWoANFlAzlSdbxeGVHoT0K+gT5w3UxwZKv2DLbCTzLZyPwIDAQABoyYwJDAPBgNV
HRMECDAGAQH/AgEAMBEGCWCGSAGG+EIBAQQEAwIAQDANBgkqhkiG9w0BAQQFAAOB
gQAZUIHAL4D09oE6Lv2k56Gp38OBDuILvwLg1v1KL8mQR+KFjghCrtpqaztZqcDt
2q2QoyulCgSzHbEGmi0EsdkPfg6mp0penssIFePYNI+/8u9HT4LuKMJX15hxBam7
dUHzICxBVC1lnHyYGjDuAMhe396lYAn8bCld1/L4NMGBCQ==
-----END CERTIFICATE-----

通过在批准证书之前核实证书请求中的信息，CA可以保证密钥对的私钥所有人的身份。举例，如果Alice请求一个个人证书，证书颁发机构必须首先核实ALICE在证书申请中所提交的个人信息和资料。

CA机构有时也会为另外一家CA机构颁发证书。当检查证书的时候，ALICE可能需要检查每一级证书的父亲证书，一直找到一个她所能信任的证书为止。为了降低她在检查证书链中遇到一个“坏”证书的风险，ALICE可能会设定可信证书链的深度。

如前所述，每个证书需要发行者来声明证书拥有者身份的有效性，一直到最顶层CA。 这就产生了一个问题：谁来保证最顶层CA的权威性，而这个CA是没有发行者。在这个独特的情况下，证书采用一种“自签名”的方式，所以证书的发行者就是证书拥有者自己。浏览器会将一些知名的CA配置成可信，将他们的根证书安装到自己的受信根证书列表中，但如果要自己添加信任的自签名证书，就需要特别当心。

• 验证证书请求
• 处理证书申请
• 发行和管理证书

建立一个证书机构需要有坚实的行政，技术和管理框架。证书颁发机构不仅颁发证书，他们还要管理好证书，也就是说，他们确定证书在多久的时间内仍然有效，他们有一个列表，里面列举了过去颁发的，但已经不再有效的证书，并且不断更新这个列表（证书吊销清单，或CRL）。

例如：ALICE曾经作为公司的雇员获得一个证书，但她现在已经离开公司了，她的证书就需要被吊销。由于证书只在审核完当事人身份后被签发，并且被传递给需要和当事人沟通的同事，从证书本身告诉去告知它已经被吊销了是不可能的。因此要检查一个证书是否有效，就必须联系CA机构获取证书吊销清单CRL，而这通常是无法自动完成的。

注意：
如果你需要使用一个不是浏览器缺省信任的CA机构，就必须将这个CA的根证书装入浏览器的可信根证书列表，使浏览器可以识别这个CA颁发的服务器证书，但这样做是非常危险的，因为一旦加载了这个CA的根证书，浏览器将接受所有由这个根证书签发的服务器证书。

SSL是工作在面对连接网络层（如TCP层）和应用层（HTTP层）之间的协议层。SSL层协议通过为客户端和服务器提供双向认证，对隐私数据的加密，和用数字签名来保证数据完整性，从而提供了一个安全的通信通道。

本协议被设计为支持一系列制定的算法用于加密，数据摘要和签名。这允许对特定服务器的算法选择建立在法律、出口和其他问题的基础上，并且使协议能够利用新的算法。在客户机和服务器试图建立一个对话的时候，会协商算法。

如表4所示，有多个SSL协议的版本，其中SSL3.0的一个优势就是它增加了对证书链加载的支持。这项功能使服务器可以将自己的服务器证书和发行者的证书一起传给浏览器。证书链的加载，使得客户机即使没有安装过服务器的中间证书，也可以来验证服务器证书的有效性，因为服务器的中间证书被放在证书链中一起发送给了客户机。SSL 3.0是安全传输层TLS协议的基础，这项协议正由IETF负责制订开发。

建立会话

客户机和服务器同构一种“握手”次序来建立SSL会话，如图1.这个握手次序可能会有所不同，这取决于服务器是否配置成提供服务器证书，或者需要客户机提供客户证书。虽然在其他情况下存在因对密码管理要求不同而不同的“握手”步骤，详见各种SSL协议规范，但本文总结了一个基本的握手次序。

注意：
服务器为每个SSL会话分配一个唯一的会话标识符并缓存在服务器和客户端（直到会话标识符过期），使客户在下次连接的时候减少了握手的时间。

1. 协商数据传输中使用的加密套接字。
2. 在客户机和服务器中建立并共享一个会话密钥。
3. 可选的服务器端身份认证
4. 可选的客户端身份认证

• 密钥交换方法
• 数据加密传输
• 创建消息认证码（MAC）的消息摘要

密钥交换方法定义在客户端和服务器之间共享双方都同意的，被用于应用数据传输的对称加密的密钥。SSL2.0协议只适用RSA密钥交换方式，而SSL3.0不仅支持RSA密钥交换（在使用证书的情况下），还支持Diffie-Hellman密钥交换（在没有使用证书或者没有客户端和服务器之间通信密钥之前的情况下。）

在决定密钥交换方式中的变量是选择是否需要数字签名和使用什么样的签名。使用私钥签名可以防止在交换共享密钥的时候，遭受中间人攻击。

SSL在加密会话中的消息时采用传统的对称加密方法，有9种加密方式可以选择，包括也可以选择不加密。

• No encryption
• Stream Ciphers
  • RC4 with 40-bit keys
  • RC4 with 128-bit keys
• CBC Block Ciphers
  • RC2 with 40 bit key
  • DES with 40 bit key
  • DES with 56 bit key
  • Triple-DES with 168 bit key
  • Idea (128 bit key)
  • Fortezza (96 bit key)

“CBC” 是Cipher Block Chaining的缩写，意思为密码分组链接，表示前一段加密后的密文被用当前段的加密中使用。

"DES" 是指Data Encryption Standard，有一系列不同的变量。包括DES40和3DES_EDE

"Idea" 是目前最好的，也是加密强度最高的算法。

"RC2" 是RSA DSI专用的算法。

对信息摘要函数的选择决定了如何从一个记录单元创建一个摘要。SSL支持以下模式：

• 无摘要
• 128位哈希的MD5
• 160位的安全哈希算法（SHA - 1）

消息摘要是用来创建一个消息认证码（MAC），MAC是与消息加密，来核实消息的完整性和保护消息不受回放式攻击。

握手次序使用三个协议：

• SSL Handshake Protocol. SSL握手协议执行客户端和服务器SSL会话的建立过程。
• SSL Change Cipher Spec Protocol .SSL更改密码协议负责协商会话用的密码套接字。
• SSL Alert Protocol.SSL告警协议负责在客户端和服务器间传递SSL错误信息。

这些协议以及应用协议数据，都被SSL记录协议封装，如图2所示。封装好的数据被不检查数据的低一层的协议传递。下一层的协议对封装协议来说是未知的。

SSL控制协议对记录协议的封装，使一个正在进行的会话在需要重新协商时，控制协议能够被安全地传输。如果没有前一个会话，则使用空的密码套接字，也就是说，在会话建立以前，不会使用密码也没有验证完整性的消息摘要。

SSL记录协议,如图3所示 , 用于在客户端和服务器之间传递SSL控制协议和应用层数据，必需将这些数据分割成较小的单元，或者将多个较高层协议数据合并为一个单元。它可能会在将这些数据传递到下一层可靠的传递协议前将这些数据压缩、加密和附加一个摘要签名。（注：目前主流的SSL都没有对压缩的支持）。

安全HTTP通信

SSL最常见的一项用途就是在浏览器和WEB服务器之间加密安全的WEB HTTP通信。使用加密的HTTP（称为HTTPS），即在SSL协议上使用HTTP协议，并没有排除HTTP协议，不过在URL地址中使用HTTPS来替换原来的HTTP，并使用另外一个服务器端口（HTTPS缺省使用443，HTTP使用80）。

下载 openvpn-2.1.1.tar.gz
rpmbuild -tb openvpn-2.1.1.tar.gz
rpm -ivh  /usr/src/redhat/RPMS/i386/openvpn-2.1.1-1.i386.rpm

(2)安装Tomcat Native，这个项目可以让 Tomcat 使用 Apache 的 apr 包来处理包括文件和网络IO操作，以提升性能。

(3)安装tomcat为系统服务

(4)优化tomcat的jvm内存池

(5)修改tomcat的并发连接数

一、安装apr

(1)安装apr

# tar zxvf apr-1.4.2.tar.gz

# cd apr-1.4.2

# ./configure --prefix=/usr/local/www/apr

# make

# make install

(2)安装apr-iconv

# tar -zxvf apr-iconv-1.2.1.tar.gz

# cd apr-iconv-1.2.1

# ./configure --prefix=/usr/local/www/apr-iconv --with-apr=/usr/local/www/apr

# make

# make install

(3)安装apr-util

# tar zxvf apr-util-1.3.9.tar.gz

# cd apr-util-1.3.9

# ./configure --prefix=/usr/local/www/apr-util --with-apr=/usr/local/www/apr --with-apr-iconv=/usr/local/www/apr-iconv/bin/apriconv

# make

# make install

二、安装tomcat和tomcat-native

(1)JDK安装

# chmod a+x jdk-6u18-linux-i586-rpm.bin

# ./jdk-6u7-linux-i586-rpm.bin

# ln -s /usr/java/jdk1.6.0_18 /usr/local/java

设置环境变量

# vi /etc/profile

末尾增加如下内容

JAVA_HOME=/usr/local/java

CLASSPATH=/usr/local/java/lib/dt.jar:/usr/local/java/lib/tools.jar

PATH=/usr/local/java/bin:$PATH

export PATH JAVA_HOME CLASSPATH

# source /etc/profile

# java –version

查看java版本，如果是1.6的，就是说明安装成功了。

(2)安装Tomcat

# tar -zxvf apache-tomcat-6.0.26.tar.gz

# mv apache-tomcat-6.0.26 /usr/local/www/tomcat

# vi /usr/local/www/tomcat/bin/catalina.sh

加入一行：

JAVA_HOME=/usr/local/java

# /usr/local/www/tomcat/bin/startup.sh

(3)安装tomcat-native

# cp tomcat-native-1.1.20-src.tar.gz /usr/local/www/tomcat/bin/

# cd /usr/local/www/tomcat/bin  

# tar zxvf tomcat-native-1.1.20-src.tar.gz

# cd tomcat-native-1.1.20-src/jni/native  

# ./configure --with-apr=/usr/local/www/apr --with-java-home=/usr/local/java

# make

# make install

(4)设置 apr 的环境变量：

# vi /etc/profile  

后面添加以下内容  

export LD_LIBRARY_PATH=$LD_LIBRARY_PATH:/usr/local/apr/lib  

# source /etc/profile

启动 tomcat 后， 看日志：

# more /usr/local/www/tomcat/logs/catalina.out

Dec 5, 2009 3:25:39 PM org.apache.catalina.core.AprLifecycleListener init

INFO: Loaded APR based Apache Tomcat Native library 1.1.20

#ifdef Linux
#include <sys/ioctl.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <linux/if.h>
#endif

#ifdef HPUX
#include <netio.h>
#endif

#ifdef AIX
#include <sys/ndd_var.h>
#include <sys/kinfo.h>
#endif

long mac_addr_sys ( u_char *addr)
{
/* implementation for Linux */
#ifdef Linux
    struct ifreq ifr;
    struct ifreq *IFR;
    struct ifconf ifc;
    char buf[1024];
    int s, i;
    int ok = 0;

    s = socket(AF_INET, SOCK_DGRAM, 0);
    if (s==-1) {
        return -1;
    }

    ifc.ifc_len = sizeof(buf);
    ifc.ifc_buf = buf;
    ioctl(s, SIOCGIFCONF, &ifc);

    IFR = ifc.ifc_req;
    for (i = ifc.ifc_len / sizeof(struct ifreq); --i >= 0; IFR++) {

        strcpy(ifr.ifr_name, IFR->ifr_name);
        if (ioctl(s, SIOCGIFFLAGS, &ifr) == 0) {
            if (! (ifr.ifr_flags & IFF_LOOPBACK)) {
                if (ioctl(s, SIOCGIFHWADDR, &ifr) == 0) {
                    ok = 1;
                    break;
                }
            }
        }
    }

    close(s);
    if (ok) {
        bcopy( ifr.ifr_hwaddr.sa_data, addr, 6);
    }
    else {
        return -1;
    }
    return 0;
#endif

/* implementation for HP-UX */
#ifdef HPUX

#define LAN_DEV0 "/dev/lan0"

    intfd;
    struct fisiocnt_block;
    inti;
    charnet_buf[sizeof(LAN_DEV0)+1];
    char*p;

    (void)sprintf(net_buf, "%s", LAN_DEV0);
    p = net_buf + strlen(net_buf) - 1;

    /*
     * Get 802.3 address from card by opening the driver and interrogating it.
     */
    for (i = 0; i < 10; i++, (*p)++) {
        if ((fd = open (net_buf, O_RDONLY)) != -1) {
iocnt_block.reqtype = LOCAL_ADDRESS;
ioctl (fd, NETSTAT, &iocnt_block);
close (fd);

            if (iocnt_block.vtype == 6)
                break;
        }
    }

    if (fd == -1 || iocnt_block.vtype != 6) {
        return -1;
    }

bcopy( &iocnt_block.value.s[0], addr, 6);
return 0;

#endif /* HPUX */

/* implementation for AIX */
#ifdef AIX

    int size;
    struct kinfo_ndd *nddp;

    size = getkerninfo(KINFO_NDD, 0, 0, 0);
    if (size <= 0) {
        return -1;
    }
    nddp = (struct kinfo_ndd *)malloc(size);

    if (!nddp) {
        return -1;
    }
    if (getkerninfo(KINFO_NDD, nddp, &size, 0) < 0) {
        free(nddp);
        return -1;
    }
    bcopy(nddp->ndd_addr, addr, 6);
    free(nddp);
    return 0;
#endif

/* Not implemented platforms */
return -1;
}

/***********************************************************************/
/*
 * Main (only for testing)
 */
#ifdef MAIN
int main( int argc, char **argv)
{
    long stat;
    int i;
    u_char addr[6];

    stat = mac_addr_sys( addr);
    if (0 == stat) {
        printf( "MAC address = ");
        for (i=0; i<6; ++i) {
            printf("%2.2x", addr[i]);
        }
        printf( "\n");
    }
    else {
        fprintf( stderr, "can't get MAC address\n");
        exit( 1);
    }
    return 0;
}
#endif

E.g you want to use on Linux, save it as file.c simply compile like this:
   gcc -O2 -DMAIN -DLinux file.c -o file

And run it
./file
MAC address = 0008c7e9e386

Compare with /sbin/ifconfig result:
/sbin/ifconfig eth0

更改/etc/timezone里面的内容为:Asia/Shanghai
#mv /etc/localtime /etc/localtime-2009
# cp /usr/share/zoneinfo/Asia/Shanghai /etc/localtime

再用命令date看一下，就是CST,

　读这本书前，和几个阿里的架构师聊天，讨论架构师最基本的素质，总结出两点，1是技术知识广度，2是业务行业深度。
自己细化后，和这本书的架构师的定义不谋而合。
1 架构师是技术领导。
架构师必须要有技术，而且还是领导。架构师要带领自己团队完成自己的任务，完全凭借自己的能力做事情，完全是匹夫之勇，根本不提倡。
2 架构师理解软件流程
架构师必须了解软件流程，否则无法驱动整个团队前进，如果一个架构师不熟悉开发流程，无法协调产品线相关人员进行高效工作，也无法指导团队成员完成自己的工作。所以来说架构师一般不是空降兵（除非是全新的部门），因为空降兵一般不会熟悉新公司的开发流程，即使是同一个行业的，各个公司的差别还是很大。所以说听说某某去某某公司做首席架构师或者首席科学家,一般是高风险的事情，即使他对这个行业很了解。
3 架构师必须熟悉业务领域
如果一个架构师不熟悉自己的行业，做的架构就是纸上谈兵，熟悉业务领域的架构师，才能很好的理解需求，做出合适的方案。互联网和网络安全是完全不同的两个方向，即使你熟悉里面的各种具体技术，但是以互联网的架构来做网络安全产品，肯定是100%的失败。
我做PKI的时候，项目最初的使用.net，使用微软的crytoAPI，开发的很顺利。后来来了一位新的架构师，觉得.net不能跨平台，决定使用java，做出产品后，发现找不到arm cpu的jdk，使用平台有限。再次决定使用openssl做，最后这个项目以失败而告终。后来我想过arm cpu都是嵌入式设备用的，根本没有任何嵌入式设备提供CA服务。

4 架构师必须要有广度的知识
架构师考虑的问题必须全面，必须了解的要广，具体的细节可以不关注，因为细节变化很快。很多具体技术人员出身的架构师，只关注于具体的细节，某些方面做的很好，整体的性能很差。
下面这个项目的成功可以理解为一个笑话。某公司的两个部门都做c程序的，A部门做的平台使用的x86和mips，B部门使用平台是x86和arm，后来A部门的一个模块要给B部门用，最后发现根本不能运行。最后A部门发现arm平台使用big endian模式，这样A部门的20多名员工，检查代码中所有非零整数，经过数个月苦战，才修改完毕。其实解决方法很简单，因B部门的代码也是首先在x86做的，做的时候他们考虑了cpu的endian模式。这并不能说B部门架构师很牛，从另一个方面说他的无知。因为板子有跳线，专门切换cpu的是big endian还是little endian，这样两个部门都可以不修改程序。
5 架构师必须是写程序的高手
架构师一般都是开发人员出身，一般都是团队的核心。优秀的架构师应该了解团队使用各种技术，有了这些知识，才能和开发人软进行有效沟通。
有一个项目架构使用xml做配置，因为病毒库很庞大，最后导致xml 达30多兆，服务端的java程序使用dom 进行过滤的时候，30兆xml加载很慢，频繁出现out of memory。这个项目后来搁浅。根据以前的经验发现 msxml加载30多M的xml 不过几秒，而且msxml的xpath速度很快，后来专门为此写了JNI处理xml的。
6架构师是优秀的沟通人员
架构师一定要会忽悠，至少要扯淡。架构师不但要指导本部门员工的工作，也要协调其他部门的资源，还要向用户收集需求，制定规格说明书，重要的把用户的不合理要求砍掉，合理需求遵循自己的思路。

import org.smslib.SMSLibException;
import org.smslib.Service;
import org.smslib.OutboundMessage;
import org.smslib.AGateway;
import org.smslib.modem.SerialModemGateway;

import java.io.IOException;

/**
 * Created by IntelliJ IDEA.
 * User: asiainfo
 * Date: 2010-5-10
 * Time: 16:14:30
 * To change this template use File | Settings | File Templates.
 */
public class SendMessage {
    public void doIt(String phone, String content) throws IOException,
            InterruptedException, SMSLibException {
        Service srv;
        OutboundMessage msg;
        srv = new Service();
        SerialModemGateway gateway = new SerialModemGateway("modem.ttyUSB0",
                "/dev/ttyUSB0", 9600, "WAVECOM MODEM", "W810");//采用Sony Ericsson的W810c手机发送
        gateway.setProtocol(AGateway.Protocols.PDU);
        gateway.setInbound(true);
        gateway.setOutbound(true);
        gateway.setSimPin("0000");
        srv.addGateway(gateway);
        srv.startService();
        System.out.println("Mobile Device Information: ");
        System.out.println(" Manufacturer : " + gateway.getManufacturer());
        System.out.println(" Model : " + gateway.getModel());
        System.out.println(" Serial No : " + gateway.getSerialNo());
        System.out.println(" IMSI : " + gateway.getImsi());
        System.out.println(" S/W Version : " + gateway.getSwVersion());
        System.out.println(" Battery Level : " + gateway.getBatteryLevel() + "%");
        System.out.println(" Signal Level : " + gateway.getSignalLevel() + "%");
        msg = new OutboundMessage(phone, content);
        srv.sendMessage(msg);

        srv.stopService();
    }

    public static void main(String args[]) throws IOException,
            InterruptedException, SMSLibException {
        SendMessage app = new SendMessage();

        app.doIt("136******", "Hello 邢红瑞");

    }
}

运行: /usr/java/jre1.6.0_13/bin/java -Dsmslib.serial.polling -classpath  log4j-1.2.15.jar:smslib-3.4.6.jar test.SendMessage
出错: Exception in thread "main" java.lang.NoClassDefFoundDrror: SendMessage

后来终于找到原因: java加载了SendMessage.class以后，java就试图到CLASSPATH中找类SendMessage，CLASSPATH为：
$CLASSPATH=/usr/java/jre1.6.0_13/lib:/usr/java/jre1.6.0_13/jre/lib
java找不到SendMessage类的定义。windows包含了当前路径，但是linux和unix没有当前路径，必须手工添加
/usr/java/jre1.6.0_13/bin/java -Dsmslib.serial.polling -classpath  log4j-1.2.15.jar:smslib-3.4.6.jar:. test.SendMessage
注意最后加了一个冒号和点，冒号是linux下文件分割符。

jdk6
C:\jdk1.6.0_16\bin\keytool -importkeystore -srckeystore linai.pfx -destkeystore server.jks -srcstoretype pkcs12
验证
C:\jdk1.6.0_16\bin\keytool -list -v -keystore server.jks

其实java 可以查看ssl的输出信息

-Djavax.net.debug=ssl:record      enable per-record tracing

                      handshake    print each handshake message

-Djavax.net.debug=all     all            turn on all debugging
                          ssl            turn on ssl debugging

网上的例子

import java.io.BufferedReader;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.UnsupportedEncodingException;
import java.security.KeyStore;
import java.security.SecureRandom;

import javax.net.ssl.KeyManager;
import javax.net.ssl.KeyManagerFactory;
import javax.net.ssl.SSLContext;
import javax.net.ssl.SSLServerSocket;
import javax.net.ssl.SSLServerSocketFactory;
import javax.net.ssl.SSLSocket;
import javax.net.ssl.TrustManager;
import javax.net.ssl.TrustManagerFactory;

public class SSLServer {
    private static final int port = 8266;
    private static final String keyStore = "server.ks";
    private static final String trustStore = "server.ks";
    private static final String keyStoreType = "jks";
    private static final String trustStoreType = "jks";
    private static final String keyStorePassword = "123456";
    private static final String trustStorePassword = "123456";
    private static final String secureRandomAlgorithm = "SHA1PRNG";
    private static final String protocol = "TLSv1";

    private static KeyManager[] createKeyManagersAsArray() throws Exception {
        KeyStore ks = KeyStore.getInstance(keyStoreType);
        ks.load(new FileInputStream(keyStore), keyStorePassword.toCharArray());

        KeyManagerFactory tmf = KeyManagerFactory.getInstance(KeyManagerFactory
            .getDefaultAlgorithm());
        tmf.init(ks, keyStorePassword.toCharArray());
        return tmf.getKeyManagers();
    }

    private static TrustManager[] createTrustManagersAsArray() throws Exception {
        KeyStore ks = KeyStore.getInstance(trustStoreType);
        ks.load(new FileInputStream(trustStore), trustStorePassword
            .toCharArray());

        TrustManagerFactory tmf = TrustManagerFactory
            .getInstance(TrustManagerFactory.getDefaultAlgorithm());
        tmf.init(ks);
        return tmf.getTrustManagers();
    }

    private static SSLServerSocket getServerSocket(int thePort) {
        SSLServerSocket socket = null;
        try {
            SSLContext sslContext = SSLContext.getInstance(protocol);
            sslContext.init(createKeyManagersAsArray(),
                createTrustManagersAsArray(), SecureRandom
                    .getInstance(secureRandomAlgorithm));

            SSLServerSocketFactory factory = sslContext
                .getServerSocketFactory();
            socket = (SSLServerSocket) factory.createServerSocket(thePort);
            //socket.setNeedClientAuth(true);
        } catch (Exception e) {
            System.out.println(e);
        }
        return (socket);
    }

    public static void main(String args[]) throws IOException {
        SSLServerSocket server = getServerSocket(port);
        System.out.println("在" + port + "端口等待连接...");
        while (true) {
            final SSLSocket socket = (SSLSocket) server.accept();

            new Thread(new Runnable() {
                public void run() {
                    BufferedReader in;
                    try {
                        in = new BufferedReader(new InputStreamReader(socket
                            .getInputStream(), "gb2312"));
                        String msg = in.readLine();
                        System.out.println(msg);
                        socket.close();
                    } catch (UnsupportedEncodingException e) {
                        e.printStackTrace();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }

                }
            }).start();
        }
    }
}

以及SSLClient.java：
import java.io.PrintWriter;
import java.net.Socket;

import javax.net.ssl.SSLSocketFactory;

public class SSLClient {
    private static String addr = "192.168.80.86";

    public static void main(String args[]) {
        try {
            System.setProperty("javax.net.ssl.keyStore", "client.ks");
            System.setProperty("javax.net.ssl.keyStorePassword", "123456");
            System.setProperty("javax.net.ssl.keyStoreType", "jks");
            System.setProperty("javax.net.ssl.trustStore", "client.ks");
            System.setProperty("javax.net.ssl.trustStorePassword", "123456");
            System.setProperty("javax.net.ssl.trustStoreType", "jks");

            SSLSocketFactory factory = (SSLSocketFactory) SSLSocketFactory
                .getDefault();
            Socket socket = factory.createSocket(addr, 8266);
            PrintWriter out = new PrintWriter(socket.getOutputStream(), true);
            out.println("hello world!");
            out.close();
            socket.close();
        } catch (Exception e) {
            System.out.println(e);
        }
    }
}

package test;

/**
 * Created by IntelliJ IDEA.
 * User: asiainfo
 * Date: 2010-4-22
 * Time: 19:23:58
 * To change this template use File | Settings | File Templates.
 */
import java.util.jar.*;
import java.util.*;
import java.io.*;

public class PackageUtils {

 private static boolean debug = true;

 public static List getClasseNamesInPackage
     (String jarName, String packageName){
   ArrayList classes = new ArrayList ();

   packageName = packageName.replaceAll("\\." , "/");
   if (debug) System.out.println
        ("Jar " + jarName + " looking for " + packageName);
   try{
     JarInputStream jarFile = new JarInputStream
        (new FileInputStream (jarName));
     JarEntry jarEntry;

     while(true) {
       jarEntry=jarFile.getNextJarEntry ();
       if(jarEntry == null){
         break;
       }
       if((jarEntry.getName ().startsWith (packageName)) &&
            (jarEntry.getName ().endsWith (".class")) ) {
         if (debug) System.out.println
           ("Found " + jarEntry.getName().replaceAll("/", "\\."));
         classes.add (jarEntry.getName().replaceAll("/", "\\."));
       }
     }
   }
   catch( Exception e){
     e.printStackTrace ();
   }
   return classes;
}

/**
*
*/
  public static void main (String[] args){
   List list =  PackageUtils.getClasseNamesInPackage
        ("D:\\SSL VPN Proj\\bat\\Server.Box.jar", "cn");
   System.out.println(list);
  
  }
}

#include <unistd.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <sys/ioctl.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <netdb.h>
#include <errno.h>
#include <dlfcn.h>
#include <linux/netfilter_ipv4.h>

#define SD_BOTH 2
#define SOCKET int
#define INVALID_SOCKET (SOCKET)(~0)
#define SOCKET_ERROR (-1)

int main(void)
{
SOCKET listen_sock, new_sock;
struct sockaddr_in client;
struct sockaddr_in me;
struct sockaddr_in peer;

unsigned long sockmode = 0;
socklen_t SLen = sizeof(client);

if ((listen_sock = socket(AF_INET, SOCK_STREAM, 0))==
INVALID_SOCKET) {
exit(1);
}

/* Local address and port */
me.sin_family = AF_INET;
me.sin_port = htons(4321);
inet_aton("127.0.0.1", &me.sin_addr);

if (ioctl(listen_sock, FIONBIO, &sockmode) == SOCKET_ERROR) {
close(listen_sock);
exit(1);
}

if (bind(listen_sock, (struct sockaddr *)&me, sizeof(me)) ==
SOCKET_ERROR) {
close(listen_sock);
exit(1);
}

if (listen(listen_sock, SOMAXCONN) == SOCKET_ERROR) {
shutdown(listen_sock, SD_BOTH);
close(listen_sock);
exit(1);
}

while ((new_sock = accept(listen_sock, (struct sockaddr *)&client,
&SLen))
!= INVALID_SOCKET)
{
SLen = sizeof(peer);
memset(&peer, 0, SLen);
getsockopt(new_sock, SOL_IP, SO_ORIGINAL_DST, &peer, &SLen);
printf( "Client: %s:%hu\n", inet_ntoa(peer.sin_addr), ntohs(peer.sin_port));

if ( shutdown(new_sock, SD_BOTH) == SOCKET_ERROR ||
close(new_sock) == SOCKET_ERROR )
{
shutdown(listen_sock, SD_BOTH);
close(listen_sock);
exit(1);
}
}
if(new_sock == INVALID_SOCKET) {
shutdown(listen_sock, SD_BOTH);
close(listen_sock);
exit(1);
}

if (shutdown(listen_sock, SD_BOTH) == SOCKET_ERROR ||
close(listen_sock) == SOCKET_ERROR)
{
exit(1);
}

exit(0);
}
linux中输入
iptables -t nat -I OUTPUT -p tcp  -j REDIRECT --to 4321
iptables -t nat -I PREROUTING -p tcp -i eth0 --dport pop3 -j REDIRECT --to 4321
然后输入 telnet 后面是随意的ip地址就行。
java中的得不到socket的真实fd，感觉很诡异。

    /** {@inheritDoc} */
    ChannelListener.Setter<? extends TcpChannel> getReadSetter();

    /** {@inheritDoc} */
    ChannelListener.Setter<? extends TcpChannel> getWriteSetter();

    /** {@inheritDoc} */
    ChannelListener.Setter<? extends TcpChannel> getCloseSetter();
}
public interface ConnectedStreamChannel<A> extends StreamChannel, ConnectedChannel<A> {

    /** {@inheritDoc} */
    ChannelListener.Setter<? extends ConnectedStreamChannel<A>> getReadSetter();

    /** {@inheritDoc} */
    ChannelListener.Setter<? extends ConnectedStreamChannel<A>> getWriteSetter();

    /** {@inheritDoc} */
    ChannelListener.Setter<? extends ConnectedStreamChannel<A>> getCloseSetter();
}
出现不兼容，两者都有都定了getCloseSetter。
看了看java的代码，没有任何错误，想到xnio也是jboss的旗下的重要项目，不会出如此弱智的问题。
经过12月1日老兄的提示后，认为是javac的问题，使用oracle jrockit编译运行通过,估计ECJ (Eclipse Compiler for Java)也没有问题，安装了 JRE，也可以在 eclipse 中进行编译。
经过龙兄的指点，认为特别是有的包是在1.5或者在1.4下面编译过来的混在一起，容易有问题，除非你全部代码都是自己写，而且保证编译的包都是在1.6之上。
sun的bug http://bugs.sun.com/view_bug.do?bug_id=6294779
05年到10年 一直有这个bug。

在checked out创建一个a.bat

写入 FOR /F "tokens=*" %%G IN ('DIR /B /AD /S *.svn*') DO RMDIR /S /Q "%%G"

打开command prompt，执行a.bat