Hacklog » 编程 http://ihacklog.com 荒野无灯weblog Sat, 04 Feb 2012 12:30:34 +0000 en hourly 1 http://wordpress.org/?v=3.3.1 数学常数E的含义[转] http://ihacklog.com/programming/math/an-intuitive-guide-to-exponential-functions-e.html http://ihacklog.com/programming/math/an-intuitive-guide-to-exponential-functions-e.html#comments Sun, 18 Dec 2011 01:17:19 +0000 荒野无灯 http://ihacklog.com/?p=5137 很少转载文章的，这次看到这个东西，觉得非常有必要转一下。（PS:我写的Hacklog Remote Image Autosave，这次终于自己用上了~~ :arrow: ）

1.

e是一个重要的常数，但是我一直不知道，它的真正含义是什么。

它不像π。大家都知道，π代表了圆的周长与直径之比3.14159，可是如果我问你，e代表了什么。你能回答吗？

维基百科说：

“e是自然对数的底数。”

但是，你去看“自然对数”，得到的解释却是：

“自然对数是以e为底的对数函数，e是一个无理数，约等于2.718281828。”

这就构成了循环定义，完全没有说e是什么。数学家选择这样一个无理数作为底数，还号称这种对数很”自然”，这难道不是很奇怪的事情吗？

2.

昨天我读到一篇好文章，它把这个问题解释得非常清楚，而且一看就懂。

它说，什么是e？简单说，e就是增长的极限。

下面就是它的解释。

3.

假定有一种单细胞生物，它每过24小时分裂一次。

那么很显然，这种生物的数量，每天都会翻一倍。今天是1个，明天就是2个，后天就是4个。我们可以写出一个增长数量的公式：

上式中的x就表示天数。这种生物在x天的总数，就是2的x次方。这个式子可以被改成下面这样：

其中，1表示原有数量，100%表示单位时间内的增长率。

4.

我们继续假定：每过12个小时，也就是分裂进行到一半的时候，新产生的那半个细胞已经可以再次分裂了。

因此，一天24个小时可以分成两个阶段，每一个阶段都在前一个阶段的基础上增长50%。

当这一天结束的时候，我们一共得到了2.25个细胞。其中，1个是原有的，1个是新生的，另外的0.25个是新生细胞分裂到一半的。

如果我们继续修改假设，这种细胞每过8小时就具备独立分裂的能力，也就是将1天分成3个阶段。

那么，最后我们就可以得到大约2.37个细胞。

很自然地，如果我们进一步设想，这种分裂是连续不断进行的，新生细胞每分每秒都具备继续分裂的能力，那么一天最多可以得到多少个细胞呢？

当n趋向无限时，这个式子的极值等于2.718281828…。

因此，当增长率为100%保持不变时，我们在单位时间内最多只能得到2.71828个细胞。数学家把这个数就称为e，它的含义是单位时间内，持续的翻倍增长所能达到的极限值。

这个值是自然增长的极限，因此以e为底的对数，就叫做自然对数。

5.

有了这个值以后，计算银行的复利就非常容易。

假定有一家银行，每年的复利是100%，请问存入100元，一年后可以拿多少钱？

回答就是271.828元，等于100个e。

但是，实际生活中，银行的利息没有这么高，如果利息率只有5%，那么100元存一年可以拿到多少钱呢？

为了便于思考，我们取n等于50：

我们知道，在100%利息率的情况下，n=1000所得到的值非常接近e：

因此，5%利息率就相当于e的20分之一次方：

20分之一正好等于5%的利率率，所以我们可以把公式改写成：

上式的rate就代表增长率。这说明e可以用于任何增长率的计算，前提是它必须是持续不断的复合式增长。

6.

再考虑时间因素，如果把钱在银行里存2年，可以得到多少钱？

在时间t的情况下，通用公式就是：

上式就是计算增长量的万能公式，可以适用于任何时间、任何增长率。

7.

回到上面的例子，如果银行的利息率是5%的复利，请问100元存款翻倍需要多少时间？

计算结果是13.86年：

上式最后一个等号，表明用72除以增长率，可以得到翻倍的大致时间，这就是72法则的来源。

（完）

文档信息

喜欢这篇文章吗?

请订阅本站 RSS feed 或填写您的邮件地址，订阅我们的精彩内容：

随机日志

]]> http://ihacklog.com/programming/math/an-intuitive-guide-to-exponential-functions-e.html/feed 4 BlowFish 加密算法Bcrypt http://ihacklog.com/programming/c/blowfish-cipher.html http://ihacklog.com/programming/c/blowfish-cipher.html#comments Fri, 14 Oct 2011 14:56:57 +0000 荒野无灯 http://ihacklog.com/?p=4939

Blowfish是1993年布鲁斯·施奈尔(Bruce Schneier)开发的对称密钥区块加密算法，区块长为64位，密钥为1至448位的可变长度。与DES等算法相比，其处理速度较快。因为其无须授权即可使用，作为一种自由授权的加密方式在SSH、文件加密软件等被广泛地使用。

关于此算法的发明者：

布鲁斯·施奈尔 （Bruce Schneier，1963年1月15日－）是一位美国的密码学学者、信息安全专家与作家。他撰写了数本信息安全与密码学相关的书籍，并且创办了BT公司并担任其首席技术官(CTO)。

分组密码(Block cypher)

分组密码（Block cypher，又称分块密码），是一种对称密钥密码。它的特点是将明文分成多个等长的组，并用相同的密码算法和密钥对每组分别进行加密和解密。其中典型的如DES和AES作为美国政府核定的标准加密算法，应用领域从电子邮件加密到银行交易转帐，非常广泛。
blowfish属于分组密码中的一种。

要了解blowfish加密算法，也许我们应该先了解一下Feistel 密码,因为blowfish加密算法也是feistel密码算法中的一种：
假设F是轮函数，然后K0到Kn作为0到n轮的sub-keys,
基本的操作如下：

把明文分为相等的两块：L0和R0,
对于每一轮i=0,1,2,…,n 进行如下运算：
Li+1 = Ri
Ri+1 = Li ^ F(Ri,Ki)
最后得到密文(Rn+1,Ln+1)
解密(Rn+1,Ln+1)是通过如下步骤来完成的：
令i=n,n-1,…,0
Ri = Li+1
Li = Ri+1 ^ F(Li+1,Ki)
最后又得到原来的(L0,R0)了

这么说可能不好理解，看下图（来自wikipedia)就清楚了：
feistel cypher
简单地说：
就是一种分组密码，一般分为64位一组，一组分左右部分，进行一般为16轮的迭代运算，每次迭代完后交换左右位置，可以自己进行设计的有:
分组大小
密钥长度
轮次数
子密钥生成
轮函数

然后应该了解一下块密码的工作模式：
from wikipedia:

密码学中，块密码的工作模式允许使用同一个块密码密钥对多于一块的数据进行加密，并保证其安全性。[1][2] 块密码自身只能加密长度等于密码块长度的单块数据，若要加密变长数据，则数据必须先被划分为一些单独的密码块。通常而言，最后一块数据也需要使用合适填充方式将数据扩展到符合密码块大小的长度。一种工作模式描述了加密每一数据块的过程，并常常使用基于一个通常称为初始化向量的附加输入值以进行随机化，以保证安全[1]。

工作模式主要用来进行加密和认证。[1][3] 对加密模式的研究曾经包含数据的完整性保护，即在某些数据被修改后的情况下密码的误差传播特性。后来的研究则将完整性保护作为另一个完全不同的，与加密无关的密码学目标。部分现代的工作模式用有效的方法将加密和认证结合起来，称为认证加密模式。[2]

虽然工作模式通常应用于对称加密[2]，它亦可以应用于公钥加密，例如在原理上对RSA进行处理，但在实用中，公钥密码学通常不用于加密较长的信息，而是使用混合加密方案

一般来说常用的加密模式有这么几种：

电子密码本（ECB）
密码块链接（CBC）：在CBC模式中，每个平文块先与前一个密文块进行异或后，再进行加密。在这种方法中，每个密文块都依赖于它前面的所有平文块。同时，为了保证每条消息的唯一性，在第一个块中需要使用初始化向量。
填充密码块链接（PCBC）
密文反馈（CFB）
输出反馈（OFB）
计数器模式（CTR）

初始化向量（IV）

初始化向量（IV，Initialization Vector）是许多工作模式中用于随机化加密的一块数据，因此可以由相同的明文，相同的密钥产生不同的密文，而无需重新产生密钥，避免了通常相当复杂的这一过程。

初始化向量与密钥相比有不同的安全性需求，因此IV通常无须保密，然而在大多数情况中，不应当在使用同一密钥的情况下两次使用同一个IV。对于CBC和CFB，重用IV会导致泄露平文首个块的某些信息，亦包括两个不同消息中相同的前缀。对于OFB和CTR而言，重用IV会导致完全失去安全性。另外，在CBC模式中，IV在加密时必须是无法预测的；特别的，在许多实现中使用的产生IV的方法，例如SSL2.0使用的，即采用上一个消息的最后一块密文作为下一个消息的IV，是不安全的[12]。

填充

块密码只能对确定长度的数据块进行处理，而消息的长度通常是可变的。因此部分模式（即ECB和CBC）需要最后一块在加密前进行填充。有数种填充方法，其中最简单的一种是在平文的最后填充空字符以使其长度为块长度的整数倍，但必须保证可以恢复平文的原始长度；例如，若平文是C语言风格的字符串，则只有串尾会有空字符。稍微复杂一点的方法则是原始的DES使用的方法，即在数据后添加一个1位，再添加足够的0位直到满足块长度的要求；若消息长度刚好符合块长度，则添加一个填充块。最复杂的则是针对CBC的方法，例如密文窃取，残块终结等，不会产生额外的密文，但会增加一些复杂度。布鲁斯·施奈尔和尼尔斯·弗格森提出了两种简单的可能性：添加一个值为128的字节（十六进制的80），再以0字节填满最后一个块；或向最后一个块填充n个值均为n的字节[13]。

CFB，OFB和CTR模式不需要对长度不为密码块大小整数倍的消息进行特别的处理。因为这些模式是通过对块密码的输出与平文进行异或工作的。最后一个平文块（可能是不完整的）与密钥流块的前几个字节异或后，产生了与该平文块大小相同的密文块。流密码的这个特性使得它们可以应用在需要密文和平文数据长度严格相等的场合，也可以应用在以流形式传输数据而不便于进行填充的场合。

另外在mcrypt的man文档里也找到了加密模式的介绍：

加密模式

modes of encryption:
ECB: The Electronic CodeBook mode. It is the simplest mode to use with a block cipher. Encrypts each block independently.

CBC: The Cipher Block Chaining mode. It is better than ECB since the plaintext is XOR’ed with the previous ciphertext. A random block is placed as the first block so the same block or messages always encrypt to something different. (This is the default mode)

CFB: The Cipher-Feedback Mode (in 8bit). This is a self-synchronizing stream cipher implemented from a block cipher.

OFB: The Output-Feedback Mode (in 8bit). This is a synchronous stream cipher implemented from a block cipher. It is intended for use in noisy lines, because corrupted ciphertext blocks do not corrupt the plaintext blocks that follow. Insecure (because used in 8bit mode) so I recommend against using it. Added just for completeness.

nOFB: The Output-Feedback Mode (in nbit). n Is the size of the block of the algorithm. This is a synchronous stream cipher implemented from a block cipher. It is intended for use in noisy lines, because corrupted ciphertext blocks do not corrupt the plaintext blocks that follow.

via http://mcrypt.hellug.gr/mcrypt/mcrypt.1.html
BTW,The author of mcrypt and libmcrypt is Nikos Mavroyanopoulos.

分块大小

Block size

现代加密算法中，对称密钥算法通常被分为stream ciphers和block ciphers。分块密码处理固定长度的字符串位数(bit)。这个比特字符串的长度必须和分块大小一样长。输入（明文）和输出（密文）都是同样长度的。输出不能比输入短——这是遵循Pigeonhole principle（鸽巢原理，又名狄利克雷抽屉原理、鸽笼原理）和密码必须是可逆的事实——然而，输出比输入更长又是不可取的。

鸽巢原理：

其中一种简单的表述法为：
若有n个笼子和n+1只鸽子，所有的鸽子都被关在鸽笼里，那么至少有一个笼子有至少2只鸽子。
另一种为：
若有n个笼子和kn+1只鸽子，所有的鸽子都被关在鸽笼里，那么至少有一个笼子有至少k+1只鸽子。
拉姆齐定理是此原理的推广。

通俗点说：
10只鸽子放进9个鸽笼，那么一定有一个鸽笼放进了至少两只鸽子。

S-box (Substitution-box,替换盒)
在分块密码中，S-box通常被用来掩盖密钥和密文之间的关系。

In general, an S-Box takes some number of input bits, m, and transforms them into some number of output bits, n: an m×n S-Box can be implemented as a lookup table with 2m words of n bits each. Fixed tables are normally used, as in the Data Encryption Standard (DES), but in some ciphers the tables are generated dynamically from the key; e.g. the Blowfish and the Twofish encryption algorithms. Bruce Schneier describes IDEA’s modular multiplication step as a key-dependent S-Box.

IDEA(International Data Encryption Algorithm)

Rijndael S-box

算法说明：
BlowFish 使用了两个box,除了著名的S-box，还有一个p-box
pbox有18个unsigned long元素
sbox有4×256个unsigned long元素
BlowFish算法中，有一个核心加密函数，该函数输入64位信息，运算后， 以64位密文的形式输出。 用BlowFish算法加密信息，需要两个过程：
这里我看的源码是Paul Kocher的C语言版本。
源码下载地址：http://www.schneier.com/blowfish-download.html

1.密钥预处理
2.信息加密

结构体定义：

1
2
3
4
typedef struct {
  unsigned long P[16 + 2];
  unsigned long S[4][256];
} BLOWFISH_CTX;

1.密钥预处理
BlowFish算法的源密钥——pbox和sbox是固定的。此pbox和sbox的值来自PI的十六进制数字值，使用这些数的原因是这些数看不出有什么明显的规律。(PI)
这里摘取1-500位：

3.243F6A8885 A308D31319 8A2E037073 44A4093822 299F31D008
  2EFA98EC4E 6C89452821 E638D01377 BE5466CF34 E90C6CC0AC
  29B7C97C50 DD3F84D5B5 B547091792 16D5D98979 FB1BD1310B
  A698DFB5AC 2FFD72DBD0 1ADFB7B8E1 AFED6A267E 96BA7C9045
  F12C7F9924 A19947B391 6CF70801F2 E2858EFC16 636920D871
  574E69A458 FEA3F4933D 7E0D95748F 728EB65871 8BCD588215
  4AEE7B54A4 1DC25A59B5 9C30D5392A F26013C5D1 B023286085
  F0CA417918 B8DB38EF8E 79DCB0603A 180E6C9E0E 8BB01E8A3E
  D71577C1BD 314B2778AF 2FDA55605C 60E65525F3 AA55AB9457
  48986263E8 144055CA39 6A2AAB10B6 B4CC5C3411 41E8CEA154
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
void Blowfish_Init(BLOWFISH_CTX *ctx, unsigned char *key, int keyLen) {
  int i, j, k;
  unsigned long data, datal, datar;

  for (i = 0; i < 4; i++) {
    for (j = 0; j < 256; j++)
      ctx->S[i][j] = ORIG_S[i][j];
  }

  j = 0;
  for (i = 0; i < N + 2; ++i) {
    data = 0x00000000;
    for (k = 0; k < 4; ++k) {
      data = (data << 8) | key[j];
      j = j + 1;
      if (j >= keyLen)
        j = 0;
    }
    ctx->P[i] = ORIG_P[i] ^ data;
  }

  datal = 0x00000000;
  datar = 0x00000000;

  for (i = 0; i < N + 2; i += 2) {
    Blowfish_Encrypt(ctx, &datal, &datar);
    ctx->P[i] = datal;
    ctx->P[i + 1] = datar;
  }

  for (i = 0; i < 4; ++i) {
    for (j = 0; j < 256; j += 2) {
      Blowfish_Encrypt(ctx, &datal, &datar);
      ctx->S[i][j] = datal;
      ctx->S[i][j + 1] = datar;
    }
  }
}

我们要加密一个信息，
需要自己选择一个key，用这个key对pbox和sbox进行变换，得到下一步信息加密
所要用的pbox和sbox。
具体的变化算法如下：
用原sbox: ORIG_S 填充 sbox

然后，每次取key与data进行运算，运算后的结果送给pbox
运算过程是这样的：
进行N+2次运算（N=16),
令 32位无符号data为0,由于Key是unsigned char类型的，每次对data左移8位(一个字节)之后与
相应的key相或（即相加），当key长度小于4时，循环使用Key。

接下来，用bf_encypt加密一个全0的64位信息（分为datal和datar,各32位）
用输出的结果datal和datar分别替换pbox[0]和pbox[1]
然后，继续加密datal和datar,用输出结果替换pbox[2]和pbox[3]
……
这样循环18次，把pbox全部替换完成。

接下来是对sbox的替换了。
这次总共是循环4×256次，每次循环的过程与上面的一样。
不过这里用的datal和datar就是上面运算过后的datal和datar.

2.信息加密
接下来看这个加密函数，上面的初始化过程已经用到它了。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
void Blowfish_Encrypt(BLOWFISH_CTX *ctx, unsigned long *xl, unsigned long *xr){
  unsigned long  Xl;
  unsigned long  Xr;
  unsigned long  temp;
  short       i;

  Xl = *xl;
  Xr = *xr;

  for (i = 0; i < N; ++i) {
    Xl = Xl ^ ctx->P[i];
    Xr = F(ctx, Xl) ^ Xr;

    temp = Xl;
    Xl = Xr;
    Xr = temp;
  }

  temp = Xl;
  Xl = Xr;
  Xr = temp;

  Xr = Xr ^ ctx->P[N];
  Xl = Xl ^ ctx->P[N + 1];

  *xl = Xl;
  *xr = Xr;
}

与上面说的Feistel 密码的运算过程是一样的：
把64位的明文分为l和r
进行16轮运算：
令i=0,1,2,3,…,N-1
Xl = Xl ^ ctx->P[i];
Xr = F(ctx, Xl) ^ Xr;
若i<N,交换Xl和Xr的值继续做上述运算。
16轮运算完了之后，再做一次Xl与Xr的交换，因为第16次运算完了之后，实际上
没有再做运算了，但是Xl与Xr还是交换了，因此，得换回来。

然后，Xr = Xr ^ ctx->P[N];
Xl = Xl ^ ctx->P[N + 1];
现在的Xl和Xr就是加密后的数据了。
加密过程图解：
blowfish encryption

这加密过程中用到了F变换：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
static unsigned long F(BLOWFISH_CTX *ctx, unsigned long x) {
   unsigned short a, b, c, d;
   unsigned long  y;

   d = (unsigned short)(x & 0xFF);
   x >>= 8;
   c = (unsigned short)(x & 0xFF);
   x >>= 8;
   b = (unsigned short)(x & 0xFF);
   x >>= 8;
   a = (unsigned short)(x & 0xFF);
   y = ctx->S[0][a] + ctx->S[1][b];
   y = y ^ ctx->S[2][c];
   y = y + ctx->S[3][d];

   return y;
}

这个变换是这样的：
它接收一个32位的数据，然后从高位到低位分为四段，每段8位，依次给
a,b,c,d
取sbox[0][a]+sbox[1][b]，相加后的结果再与sbox[2][c]做异或运算，
得出的结果再加上sbox[3][d]
由于sbox的元素都是32位的，因此，F变换后的输出也是32位的。
轮函数图解：
blowfish F function

解密函数：
可以看到解密函数与加密函数非常的相似，只是把p0,p1,…,p17 逆序使用：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
void Blowfish_Decrypt(BLOWFISH_CTX *ctx, unsigned long *xl, unsigned long *xr){
  unsigned long  Xl;
  unsigned long  Xr;
  unsigned long  temp;
  short       i;

  Xl = *xl;
  Xr = *xr;

  for (i = N + 1; i > 1; --i) {
    Xl = Xl ^ ctx->P[i];
    Xr = F(ctx, Xl) ^ Xr;

    /* Exchange Xl and Xr */
    temp = Xl;
    Xl = Xr;
    Xr = temp;
  }

  /* Exchange Xl and Xr */
  temp = Xl;
  Xl = Xr;
  Xr = temp;

  Xr = Xr ^ ctx->P[1];
  Xl = Xl ^ ctx->P[0];

  *xl = Xl;
  *xr = Xr;
}

关于BlowFish 密码，个人认为可以把它理解为一种复杂的异或密码,异或运算的规律：

A ^ 0 = A
A ^ A = 0
(A ^ B) ^ C = A ^ (B ^ C)
(B ^ A) ^ A = B ^ 0 = B

按这种逻辑，文本序列的每个字符可以通过与给定的密钥进行按位异或运算来加密。如果要解密，只需要将加密後的结果与密钥再次进行按位异或运算即可。

喜欢这篇文章吗?

请订阅本站 RSS feed 或填写您的邮件地址，订阅我们的精彩内容：

随机日志

]]> http://ihacklog.com/programming/c/blowfish-cipher.html/feed 2 MIT & Stanford CS 公开课视频 http://ihacklog.com/programming/mit-stanford-cs-open-cource.html http://ihacklog.com/programming/mit-stanford-cs-open-cource.html#comments Sat, 08 Oct 2011 19:08:10 +0000 荒野无灯 http://ihacklog.com/?p=4928 入门级别：
斯坦福大学公开课：编程方法学 语言：JAVA
DEMO: 第5集：变量

麻省理工学院公开课：计算机科学及编程导论 语言：Python
DEMO: [第1集] 课程目标，数据类型，运算，变量

进阶：
麻省理工学院公开课：算法导论
DEMO: [第1集]课程简介及算法分析

下载：http://www.verycd.com/topics/87348/

喜欢这篇文章吗?

请订阅本站 RSS feed 或填写您的邮件地址，订阅我们的精彩内容：

随机日志

]]> http://ihacklog.com/programming/mit-stanford-cs-open-cource.html/feed 1 Java学习之利用yahoo weather api 获取天气预报 http://ihacklog.com/programming/java/learning-java-get-weather-report-via-yahoo-weather-api.html http://ihacklog.com/programming/java/learning-java-get-weather-report-via-yahoo-weather-api.html#comments Sun, 24 Jul 2011 07:57:44 +0000 荒野无灯 http://ihacklog.com/?p=4684 在cnblogs看到 狼の禅 写的Java获取yahoo天气预报一文，于是有了这篇文章。
狼の禅 是将<地点代码,地名> 对用HashMap 来保存在类中的，发现手动查找地点代码然后要一个个加进去还真麻烦，于是想下有没有偷懒的办法。果然，在雅虎 geoplanet 找到了答案。
最简单的办法是申请一个yahoo dev 的key ,然后就可以通过 GeoPlanet api 来查询相应地点的WOEID了。
狼の禅 用的是旧的p 参数传递地点代码，不过最新的api文档里面只对w参数作了说明，因此这里我就用WOEID了。
不想注册申请key,还是自己折腾吧。
下载最新的 GeoPlanet Data ,解压出来有这些个文件：

The zip file below contains a license file, a readme file, and three data files in tab-delineated, Unicode (UTF-8) format:
geoplanet_places_[version].tsv: the WOEID, the placename, and the WOEID of its parent entity
geoplanet_aliases_[version].tsv: alternate names in multiple languages indexed against the WOEID
geoplanet_adjacencies_[version].tsv: the entities neighboring each WOEID
geoplanet_changes_[version].tsv: the list of removed WOEIDs and their replacement WOEID mappings

这里我只取 geoplanet_places_7.6.0.tsv ，用EmEditor 打开，把 中国 地区的 COPY 出到另外一个文件
Chinaplaces.tsv .
这个tsv 文件是用tab分隔字段的，places文件的字段有：

WOE_ID ISO Name Language PlaceType Parent_ID

直接解析这个tsv文件不怎么方便，还是用MySQL来搞定它吧。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
CREATE USER 'geoplanet'@'localhost' IDENTIFIED BY 'geoplanet';

GRANT USAGE ON * . * TO 'geoplanet'@'localhost' IDENTIFIED BY 'geoplanet' WITH MAX_QUERIES_PER_HOUR 0 MAX_CONNECTIONS_PER_HOUR 0 MAX_UPDATES_PER_HOUR 0 MAX_USER_CONNECTIONS 0 ;

CREATE DATABASE IF NOT EXISTS `geoplanet` ;

ALTER DATABASE `geoplanet` DEFAULT CHARACTER SET utf8 COLLATE utf8_general_ci;

GRANT ALL PRIVILEGES ON `geoplanet` . * TO 'geoplanet'@'localhost';

FLUSH PRIVILEGES;

CREATE TABLE IF NOT EXISTS `places` (
  `woe_id` varchar(15) NOT NULL,
  `iso` varchar(6) NOT NULL,
  `name` text NOT NULL,
  `language` varchar(6) NOT NULL,
  `placetype` varchar(15) NOT NULL,
  `parent__id` varchar(15) NOT NULL,
  PRIMARY KEY (`woe_id`)
) ENGINE=MyISAM DEFAULT CHARSET=utf8;

然后，导入之( geoplanet 为数据库名)：

1
mysqlimport --ignore-lines=1 --fields-optionally-enclosed-by='"' --fields-terminated-by="\t"  --user="root" --password --local geoplanet places.tsv

或者直接进mysql:

1
2
use geoplanet;
LOAD DATA LOCAL INFILE 'D:\\code\\java\\geoplanet_data_7.6.0\\Chinaplaces.tsv' INTO TABLE `places` FIELDS TERMINATED BY '\t' ENCLOSED BY '"' ESCAPED BY '\' LINES TERMINATED BY '\n' IGNORE 1 LINES;
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
mysql> use geoplanet
Database changed
mysql> show tables;
+---------------------+
| Tables_in_geoplanet |
+---------------------+
| places              |
+---------------------+
1 row in set (0.00 sec)

mysql> LOAD DATA LOCAL INFILE 'D:\\code\\java\\geoplanet_data_7.6.0\\Chinaplaces
.tsv' INTO TABLE `places` FIELDS TERMINATED BY '\t' ENCLOSED BY '"' ESCAPED BY '
\' LINES TERMINATED BY '\n' IGNORE 1 LINES;
Query OK, 10519 rows affected (0.26 sec)
Records: 10519  Deleted: 0  Skipped: 0  Warnings: 0

然后就是连接mysql啦(java目前我也就写过一个hello world, class写得勉强，见笑了 :smile: )：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
package com.ihacklog.java.learn;

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;
import java.sql.Statement;
import java.sql.ResultSet;

/**
 * MySQL辅助类
 * @author HuangYe <荒野无灯>
 * @URL http://ihacklog.com
 * @see http://dev.mysql.com/doc/refman/5.5/en/connector-j.html
 */

public class mysql {
    private String server = "localhost";
    private String port = "3306";
    private String user = "geoplanet";
    private String password = "geoplanet";
    private String database = "geoplanet";
    private static Connection conn = null;
    private String query = null;

    public mysql(String server, String port, String user, String password,
            String database) {
        super();
        this.server = server;
        this.port = port;
        this.user = user;
        this.password = password;
        this.database = database;

        try {
            // The newInstance() call is a work around for some
            // broken Java implementations

            Class.forName("com.mysql.jdbc.Driver").newInstance();
            this.connect();
        } catch (Exception ex) {
            // handle the error
        }

    }

    /**
     * create JDBC connection
     *
     * @return Connection
     */
    public Connection connect() {
        if (null == mysql.conn) {
            try {
                mysql.conn = DriverManager.getConnection("jdbc:mysql://"
                        + this.server + ":" + this.port + "/" + this.database
                        + "?" + "user=" + this.user + "&password="
                        + this.password + "&characterEncoding=utf8");

            } catch (SQLException ex) {
                // handle any errors
                System.out.println("SQLException: " + ex.getMessage());
                System.out.println("SQLState: " + ex.getSQLState());
                System.out.println("VendorError: " + ex.getErrorCode());
            }
        }
        return mysql.conn;
    }


    public String getOneCol(String query,String columnName)
    {
        Statement stmt = null;
        ResultSet rs = null;
        String colString ="";
        this.query = query;
        try{
        stmt = mysql.conn.createStatement();
        rs = stmt.executeQuery(this.query);
        while(rs.next()) {
            colString = rs.getString(columnName);
        }
        }
         catch (SQLException sqlEx) {
            } // ignore

        finally {

            if (rs != null) {
                try {
                    rs.close();
                } catch (SQLException ex) {
                    // ignore
                }
            }

            if (stmt != null) {
                try {
                    stmt.close();
                } catch (SQLException ex) {
                    // ignore
                }
            }
        }
         return colString;
    }
}

然后是天气信息查询类：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
package com.ihacklog.java.learn;
//For saving XML file
/*import java.io.File;
import java.io.FileOutputStream;*/
import java.io.IOException;
import java.io.InputStream;
import java.net.URL;
import java.net.URLConnection;
import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
//For saving XML file
/*import javax.xml.transform.Transformer;
import javax.xml.transform.TransformerFactory;
import javax.xml.transform.dom.DOMSource;
import javax.xml.transform.stream.StreamResult;*/
import org.w3c.dom.Document;
import org.w3c.dom.NamedNodeMap;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;
import com.ihacklog.java.learn.mysql;

/**
 * @author 狼の禅 [http://www.cnblogs.com/kingwolfofsky], HuangYe <荒野无灯>
 *
 */
class GetWeatherInfo {
    private static mysql db= null;
    /**
     * 天气信息代码
     * @see http://developer.yahoo.com/weather/#codes
     */
    private final String[] dictionaryStrings = { "龙卷风", "热带风暴", "飓风", "强雷阵雨",
            "雷阵雨", "小雨加雪", "雨加冰雹", "雪加冰雹", "冰雨", "毛毛雨", "冻雨", "阵雨", "阵雨", "小雪",
            "零星小雪", "高吹雪", "雪", "冰雹", "雨夹雪", "尘", "雾", "薄雾", "多烟的", "大风", "有风",
            "寒冷", "阴天", "夜间阴天", "白天阴天", "夜间多云", "白天多云", "夜间清亮", "晴朗", "转晴",
            "转晴", "雨夹冰雹", "热", "雷阵雨", "雷阵雨", "雷阵雨", "雷阵雨", "大雪", "阵雪", "大雪",
            "多云", "雷", "阵雪", "雷雨" };
    public GetWeatherInfo() {
        GetWeatherInfo.db=new mysql("localhost", "3306", "geoplanet", "geoplanet", "geoplanet");
    }
 
    private String getCityWOEID(String cityName)
    {
        String woeid = null;
        woeid=GetWeatherInfo.db.getOneCol("SELECT woe_id FROM places WHERE name='"+ cityName + "'","woe_id");
        return woeid;
    }
    /**
     * modified by 荒野无灯
     * @see http://developer.yahoo.com/weather/
     * @see http://en.wikipedia.org/wiki/WOEID
     * @see http://developer.yahoo.com/geo/geoplanet/
     * @see http://developer.yahoo.com/geo/geoplanet/data/
     * @param cityCode
     * @return  Document
     * @throws IOException
     */
    private Document getWeatherXML(String cityCode) throws IOException {
        URL url = new URL("http://weather.yahooapis.com/forecastrss?w=" + cityCode + "&u=c");
        URLConnection connection = url.openConnection();
        Document Doc = stringToElement(connection.getInputStream());
        return Doc;
    }
    /* 保存获取的天气信息XML文档 */
/*    private void saveXML(Document Doc, String Path) {
        TransformerFactory transFactory = TransformerFactory.newInstance();
        Transformer transformer;
        try {
            transformer = transFactory.newTransformer();
            DOMSource domSource = new DOMSource(Doc);
            File file = new File(Path);
            FileOutputStream out = new FileOutputStream(file);
            StreamResult xmlResult = new StreamResult(out);
            transformer.transform(domSource, xmlResult);
        } catch (Exception e) {
            System.out.println("保存文件出错！");
        }
    }*/
    /* 获取天气信息 */
    public String getWeather(String city) {
        String result = null;
        try {
            String cityWOEID =getCityWOEID(city);
            if( null == cityWOEID )
                return null;
           
            Document doc = getWeatherXML( cityWOEID );
            NodeList nodeList = doc.getElementsByTagName("channel");
            for (int i = 0; i < nodeList.getLength(); i++) {
                Node node = nodeList.item(i);
                NodeList nodeList1 = node.getChildNodes();
                for (int j = 0; j < nodeList1.getLength(); j++) {
                    Node node1 = nodeList1.item(j);
                    if (node1.getNodeName().equalsIgnoreCase("item")) {
                        NodeList nodeList2 = node1.getChildNodes();
                        for (int k = 0; k < nodeList2.getLength(); k++) {
                            Node node2 = nodeList2.item(k);
                            if (node2.getNodeName().equalsIgnoreCase(
                                    "yweather:forecast")) {
                                NamedNodeMap nodeMap = node2.getAttributes();
                                Node lowNode = nodeMap.getNamedItem("low");
                                Node highNode = nodeMap.getNamedItem("high");
                                Node codeNode = nodeMap.getNamedItem("code");
                                String day = "\n明天";
                                if (result == null) {
                                    result = "城市：" + city ;
                                    day = "\n今天";
                                } else {
                                    day = "\n明天";
                                }
                                result = result
                                        + day
                                        + " "
                                        + dictionaryStrings[Integer
                                                .parseInt(codeNode
                                                        .getNodeValue())]
                                        + "\t最低温度：" + lowNode.getNodeValue()
                                        + "℃ \t最高温度：" + highNode.getNodeValue()
                                        + "℃ ";
                            }
                        }
                    }
                }
            }
            //save file JUST for DEBUG
//            saveXML(doc, "D:\\tmp\\Weather.xml");
        } catch (Exception e) {
            e.printStackTrace();
        }
        return result;
    }
    public Document stringToElement(InputStream input) {
        try {
            DocumentBuilder db = DocumentBuilderFactory.newInstance()
                    .newDocumentBuilder();
            Document doc = db.parse(input);
            return doc;
        } catch (Exception e) {
            return null;
        }
    }
}

测试：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
package com.ihacklog.java.learn;
import com.ihacklog.java.learn.GetWeatherInfo;


/**
 * @author HuangYe <荒野无灯>
 * @URL http://ihacklog.com
 */
public class getWeather {
    public static void main(String arg[]) {
       
        //OK,let's begin the test.
        //Have fun!
        GetWeatherInfo info = new GetWeatherInfo();
        String weather = info.getWeather("岳阳市");
        System.out.println(weather);
       
        weather = info.getWeather("哈尔滨");
        System.out.println(weather);
       
        weather = info.getWeather("海口市");
        System.out.println(weather);
       
        weather = info.getWeather("长沙市");
        System.out.println(weather);
       
        weather = info.getWeather("武汉市");
        System.out.println(weather);
    }
}

本文参考文档：
Importing GeoPlanet data into MySQL
Java获取yahoo天气预报
JDBC and MySQL: Run the Programs
Yahoo! GeoPlanet Guide

Yahoo! GeoPlanet™ Data

Yahoo! Weather RSS Feed docs

喜欢这篇文章吗?

请订阅本站 RSS feed 或填写您的邮件地址，订阅我们的精彩内容：

随机日志

]]> http://ihacklog.com/programming/java/learning-java-get-weather-report-via-yahoo-weather-api.html/feed 7 关于C语言的char类型是有符号还是无符号 http://ihacklog.com/programming/c/char-is-signed-or-unsigned-by-default.html http://ihacklog.com/programming/c/char-is-signed-or-unsigned-by-default.html#comments Fri, 24 Jun 2011 07:53:04 +0000 荒野无灯 http://ihacklog.com/?p=4579 这是C语言里面比较纠结的一个问题。
有时候这个问题和平台或者编译器有关。
貌似gcc和 Ms cl 都默认是signed

1
2
3
4
5
6
7
8
9
#include    <stdio.h>
#include    <limits.h>

int
main()
{
        printf("%d\n",CHAR_MIN);
        return 0;
}

输出是 -128 .

其实C标准并没有规定char 应该是unsigned 还是 signed
事实上标准定义了三种类型：char, signed char 和unsigned char
#include 然后检查CHAR_MIN 的值就知道默认的是有符号还是无符号。
若等于0 ，则说明是无符号的，否则，它就是等于SCHAR_MIN (一般是-128）。
我们查看下/usr/include/limits.h
可以发现如下定义：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
/* Number of bits in a `char'.  */
#  define CHAR_BIT  8

/* Minimum and maximum values a `signed char' can hold.  */
#  define SCHAR_MIN (-128)
#  define SCHAR_MAX 127

/* Maximum value an `unsigned char' can hold.  (Minimum is 0.)  */
#  define UCHAR_MAX 255

/* Minimum and maximum values a `char' can hold.  */
#  ifdef __CHAR_UNSIGNED__
#   define CHAR_MIN 0
#   define CHAR_MAX UCHAR_MAX
#  else
#   define CHAR_MIN SCHAR_MIN
#   define CHAR_MAX SCHAR_MAX
#  endif

当然，这个默认行为也是可以通过编译器来改变的，如gcc可通过加-funsigned-char
来指定其默认为无符号型。
MSVC 可以用/J来指定char 默认为无符号型。

本文参考：
c – char is signed or unsigned by default – Stack Overflow

喜欢这篇文章吗?

请订阅本站 RSS feed 或填写您的邮件地址，订阅我们的精彩内容：

相关日志

]]> http://ihacklog.com/programming/c/char-is-signed-or-unsigned-by-default.html/feed 0 Linux中gotoxy函数的一个实现 http://ihacklog.com/programming/c/gotoxy-in-linux.html http://ihacklog.com/programming/c/gotoxy-in-linux.html#comments Thu, 02 Jun 2011 16:19:08 +0000 荒野无灯 http://www.ihacklog.com/programming/c/gotoxy-in-linux.html 摘自：Linux: gotoxy() – C

Linux中要移动光标一般要用到ncurses库中的move函数，这里找到一个纯C实现的gotoxy函数：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
#include <stdio.h>
#include <string.h>

void clrscr(void) {
    int i;

    for (i = 0; i < 100; i++)
        // A bunch of new lines for now. It's blank, hey!
        putchar('\n');
}

int gotoxy(int x, int y) {
    char essq[100];     // String variable to hold the escape sequence
    char xstr[100];     // Strings to hold the x and y coordinates
    char ystr[100];     // Escape sequences must be built with characters

    /*
    ** Convert the screen coordinates to strings
    */
    sprintf(xstr, "%d", x);
    sprintf(ystr, "%d", y);

    /*
    ** Build the escape sequence (vertical move)
    */
    essq[0] = '\0';
    strcat(essq, "\033[");
    strcat(essq, ystr);

    /*
    ** Described in man terminfo as vpa=\E[%p1%dd
    ** Vertical position absolute
    */
    strcat(essq, "d");
   
    /*
    ** Horizontal move
    ** Horizontal position absolute
    */
    strcat(essq, "\033[");
    strcat(essq, xstr);
    // Described in man terminfo as hpa=\E[%p1%dG
    strcat(essq, "G");

    /*
    ** Execute the escape sequence
    ** This will move the cursor to x, y
    */
    printf("%s", essq);

    return 0;
}

/*
** Example
*/
int main () {
    clrscr();
    gotoxy(2, 0);
    printf("Coordinates: x = 2; y = 0;\n");
    gotoxy(5, 5);
    printf("Coordinates: x = 5; y = 5;\n");

    return 0;
}

喜欢这篇文章吗?

请订阅本站 RSS feed 或填写您的邮件地址，订阅我们的精彩内容：

相关日志

]]> http://ihacklog.com/programming/c/gotoxy-in-linux.html/feed 0 文本文件批量合并小工具 http://ihacklog.com/programming/c/filecombine.html http://ihacklog.com/programming/c/filecombine.html#comments Fri, 18 Mar 2011 08:52:55 +0000 荒野无灯 http://www.ihacklog.com/?p=4317 在深圳时，奔爷有一小说要合并，win下用批处理貌似不好办，Linux下的shell 命令我也不是很熟悉，还是用C语言写一个吧，于是操刀(VIM)开工。因此有了这篇文章。程序很简单，没啥技术含量，拿出来与大家分享。有兴趣的童鞋可以一起来修改它。

Usage:./filecombine prefix start end [combine_name] [fileext]

Description:此程序用来合并命名有规律的txt文件为一个文件,
如foo1.txt , foo2.txt ,foo3.txt …… foo199.txt , foo200.txt
参数解释：
prefix: 文件共同的前缀(比如上面的 foo)
start: 要合并的文件的开始数字(如1)
end: 要合并的文件的结束数字(如200)
combine_name: 合并后的文件名称(可选)
fileext: 文件后缀(默认为.txt,可选)

1
gcc -Wall -o filecombine -O3 filecombine.c

源码如下，可在WIN32或者Linux 32下编译运行。win下access函数是用头文件io.h，linux下没有这个文件，包含于unistd.h中。
附上源码包，里面包含WIN32和LINUX下的可执行文件：
注意：该页面嵌入了下载文件，请访问 该页面下载该文件。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
/*
 * =====================================================================================
 *
 *       Filename:  filecombine.c
 *
 *    Description: 此程序用来合并命名有规律的txt文件为一个文件，如foo1.txt , foo2.txt ,foo3.txt ...... foo199.txt , foo200.txt
 *      用法：filecombine.exe 文件共同的前缀(比如上面的 foo) 要合并的文件的开始数字(如1) 要合并的文件的结束数字(如200) [合并后的文件名称]
 *          (可选) [文件后缀](默认为.txt,可选)
 *        Version:  1.0
 *        Created:  2011年03月01日 21时52分28秒
 *       Revision:  none
 *       Compiler:  gcc
 *
 *         Author:  荒野无灯 (HuangYeWuDeng), admin#ihacklog.com
 *        Company:  hhtc edu
 *
 * =====================================================================================
 */
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>
#include <sys/types.h>
#include <sys/stat.h>

#if defined(WIN32)
#include <io.h>
#elif defined(__linux__)
#include <unistd.h>
#endif

#define CHUNK_SIZE 512

off_t filesize(char *);

int
main(int argc,char *argv[])
{
    printf("                   ************文本文件批量合并小工具************\n");
   
    if(argc<4)
    {
        printf("Error parameter!\n");
        printf("Usage:%s prefix start end [combine_name] [fileext]\n\n",*argv);
        printf("Description:此程序用来合并命名有规律的txt文件为一个文件,\n如foo1.txt , foo2.txt ,foo3.txt ...... foo199.txt , foo200.txt\n参数解释：\nprefix:        文件共同的前缀(比如上面的 foo) \nstart:         要合并的文件的开始数字(如1)\nend:           要合并的文件的结束数字(如200) \ncombine_name:  合并后的文件名称(可选) \nfileext:       文件后缀(默认为.txt,可选)\n\n");
        printf("--------------------------------------------------a small tool by 荒野无灯\n");
        printf("--------------------------------------------------http://www.ihacklog.com\n\n");
        return -1;
    }
   
    FILE *fp;
    FILE *fpw;
    char fileext[10];
    char combine_filename[200];
    char renamed_combine_filename[300];
    if(argc==6)
        sprintf(fileext,"%s",argv[5]);
    else
        strcpy(fileext,".txt");


    if(NULL !=argv[4])
    sprintf(combine_filename,"%s_combined%s",argv[4],fileext);
    else
    sprintf(combine_filename,"%s_combined%s",argv[1],fileext);

    if(!access(combine_filename,0x00))
    {
        char timebuf[100];
        time_t t;
        time (&t);
        strftime(timebuf, sizeof(timebuf),"%Y-%m-%d-%H%M%S", localtime(&t));

        sprintf(renamed_combine_filename,"%s_%s",timebuf,combine_filename);
        printf("注意：文件%s已经存在，合并后的文件名为：%s\n",combine_filename,renamed_combine_filename);

    }
    else
    {
        strcpy(renamed_combine_filename,combine_filename);
    }

    fpw=fopen(renamed_combine_filename,"ab");
    if(!fpw)
        {
            printf("create file %s failed!\n",renamed_combine_filename);
            return -1;
        }
        int i;

    int start_num=atoi(argv[2]);
    int end_num=atoi(argv[3])+1;
    for(i=start_num;i<end_num;i++)
    {
        char fname[200];
        strcpy(fname,argv[1]);
        char tmp[10];
        sprintf(tmp,"%d",i);
        strcat(fname,tmp);
        strcat(fname,fileext);
        fp=fopen(fname,"rb");
        if(!fp)
        {
            printf("Error:\nopen file %s failed!perhaps file does not exists.\n",fname);
            return -1;
        }
        else
        {
        printf("正在添加文件:  %s ......\n",fname);
            char data[CHUNK_SIZE+1];
            int file_size=filesize(fname);
            int toread;
            while(file_size>0 )
            {
            toread=( file_size>CHUNK_SIZE )?CHUNK_SIZE:file_size;
            fread(data,toread,1,fp);
            fwrite(data,toread,1,fpw);
            file_size-=toread;
            }
        }
        fclose(fp);
       
    }
        fclose(fpw);
        printf("文件合并成功！合并后的文件名为：%s\n",renamed_combine_filename);
    return 0;

}


off_t
filesize(char *filename)
{
    struct stat s;
    if(0 != stat(filename,&s))
            return -1;
    return s.st_size;

}

喜欢这篇文章吗?

请订阅本站 RSS feed 或填写您的邮件地址，订阅我们的精彩内容：

相关日志

]]> http://ihacklog.com/programming/c/filecombine.html/feed 15 删除.svn目录的方法 http://ihacklog.com/programming/remove-svn-folders.html http://ihacklog.com/programming/remove-svn-folders.html#comments Sat, 01 Jan 2011 09:49:44 +0000 荒野无灯 http://www.ihacklog.com/?p=4293 即.svn目录的删除。
1.Linux 平台

1
find . -type d -name ".svn"|xargs rm -rf

或者

1
find . -type d -iname ".svn" -exec rm -rf {} \;

2.Windows平台
Jon Galloway提供了一段注册表代码，可以将”Delete SVN Folders”命名增加到资源管理器的右键上，这样，鼠标点两下就能把选中目录下的所有.svn目录干掉了。Works just great!

1
2
3
4
5
6
7
Windows Registry Editor Version 5.00

[HKEY_LOCAL_MACHINE\SOFTWARE\Classes\Folder\shell\DeleteSVN]
@="Delete SVN Folders"

[HKEY_LOCAL_MACHINE\SOFTWARE\Classes\Folder\shell\DeleteSVN\command]
@="cmd.exe /c \"TITLE Removing SVN Folders in %1 && COLOR 9A && FOR /r \"%1\" %%f IN (.svn) DO RD /s /q \"%%f\" \""

喜欢这篇文章吗?

请订阅本站 RSS feed 或填写您的邮件地址，订阅我们的精彩内容：

随机日志

]]> http://ihacklog.com/programming/remove-svn-folders.html/feed 0 avast病毒库更新程序的改进 http://ihacklog.com/programming/c/avast-update-custom-written-in-c.html http://ihacklog.com/programming/c/avast-update-custom-written-in-c.html#comments Fri, 26 Nov 2010 01:12:26 +0000 荒野无灯 http://www.ihacklog.com/?p=4250 avast病毒库更新程序为avast-update ，这个东东实际上是调用了wget 来下载病毒库的，但是运行以后没有任何提示，病毒库到底有没有在下载呢？不清楚。于是写了个东东来以便可以直观的看到是否在下载以及下载速度的快慢（根据旋转速度）。
/opt/avast4workstation-1.3.0/bin/avast-update 是 avast-update 的路径。

这个小程序主要用到了LINUX内核的 inotify 来监控文件变化。

TODO：
增加超时检测（超时自动退出）
增加更新完成后自动退出（这一点应该简单）

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
/*
 * =====================================================================================
 *
 *       Filename:  avast-watch.c
 *
 *    Description:  监视avast病毒库更新
 *
 *        Version:  1.0
 *        Created:  2010年10月13日 13时35分28秒
 *       Revision:  none
 *       Compiler:  gcc
 *
 *         Author:  荒野无灯 (HuangYeWuDeng), admin@ihacklog.com
 *        Company:  hhtc edu
 *
 * =====================================================================================
 */

#include <stdio.h>
#include <unistd.h>
#include <time.h>
#include <sys/inotify.h>
#define MAX_BUF_SIZE 4096



/*  
struct inotify_event {
int wd; // watch descriptor
uint32_t mask; // mask of events
uint32_t cookie; // unique cookie associating related events ( form rename(2) )
uint32_t len; // size of name field
char name[]; // optional null-terminated name
}
*/


int main()
{
    // fd : file discriptor
    // wp  watch discriptor
    int fd, wd;
    int len, index;
    char buffer[4096];
    struct inotify_event *event;
    char *path = "/home/hacklog/.avast";
    char *prog="/opt/avast4workstation-1.3.0/bin/avast-update";

    int progress = 0;
    char indicator[]="-\\|/";


    FILE *fp=popen(prog,"r");

    fd = inotify_init();
    if (fd < 0)
    {
        printf("Failed to initialize inotify.\n");
        return 1;
    }
    wd = inotify_add_watch(fd, path, IN_CLOSE_WRITE | IN_CREATE | IN_MODIFY| IN_DELETE );
    if (wd < 0)
    {
        printf("Can't add watch for %s", path);
        return 1;
    }
    // 当没有事件发生时，fd 处于阻塞状态，read阻塞直到有一个事件发生.
    time_t start_time;
    time_t end_time;
    while (len = read(fd, buffer, MAX_BUF_SIZE))
    {
        index = 0;
        while (index < len)
        {
       
            event = (struct inotify_event *) (buffer + index);
            // 如果不是我们添加的对.avast目录的监视，就继续 （因为我们可能添加了多个监视的，每个监视都有一个 wd (watch discriptor )
            if (event->wd != wd)
                continue;
           
//          if (event->mask & IN_OPEN)
//              printf("file %s is opened.\n", event->name);

           
            if (event->mask & IN_CREATE)
            {
                if( strcmp(event->name,"400.vps.new.md5") == 0 )
                {
                time(&start_time);
                }
                printf("file %s is created.\n", event->name);
            }
           
            if (event->mask & IN_MODIFY)
            {
//              printf("file %s is modified.\n", event->name);
                printf(" %c",indicator[progress]);
                fflush(stdout);
                printf("\b\b");
                progress=( progress + 1 )  % 4;
            }
           
            if (event->mask & IN_CLOSE_WRITE)
            {
                printf("file %s is closed for write.\n", event->name);
            }

            if (event->mask & IN_DELETE)
                printf("file %s is deleted.\n", event->name);

                        // sizeof(struct inotify_event)+len 为每个inotify_event 的长度
            index += sizeof(struct inotify_event) + event->len;
        }
    }
   

    return 0;
}

IBM DW：

参考文档：
inotify — Linux 2.6 内核中的文件系统变化通知机制
linux开发 — 文件监控 inotify
扩展阅读：
linux inotify+rsync+ssh数据时时同步

喜欢这篇文章吗?

请订阅本站 RSS feed 或填写您的邮件地址，订阅我们的精彩内容：

随机日志

]]> http://ihacklog.com/programming/c/avast-update-custom-written-in-c.html/feed 0 关于递归与迭代 http://ihacklog.com/programming/c/recursive-and-iterative.html http://ihacklog.com/programming/c/recursive-and-iterative.html#comments Wed, 24 Nov 2010 06:08:52 +0000 荒野无灯 http://www.ihacklog.com/?p=4240 这篇文章是由一道省二计算机等级考试的题目引发的。
那天寝室一同学的同学考省二，发短信过来求救，要我给他算一个题目。
题目简单描述如下：

f（0）=f（1）=1
f（2）=0
f(n)=f(n-1)-2*f(n-2)+f(n-3)
求当n<= 50 时 (n>2) f(n)的最大值是多少。

由于时间非常紧，那同学快下考了，首先我便用了简单的递归实现f(n)函数。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
#include <stdio.h>
int f(int n);
int main()
{


    int i;
    int max=0;
    for(i=3;i<51;i++)
    {
        //printf("now :%d\n",i);
        if(f(i) > max )
        {
            max=f(i);
        }

    }

        printf("max=%d\n",max );
return 0;

}

int f(int n)
{
    switch(n)
    {
    case 0:
    case 1:
        return 1;
        break;
    case 2:
        return 0;
        break;
    default:
        return f(n-1)-2*f(n-2)+f(n-3);
    }
}

一运行，发现老半天不出结果，调试一下发现，算到n等于30多的时候就变得非常慢了，CPU占用达50%以上。很明显，这个函数不能用递归来实现。因为递归实际上效率是非常低的，而且，就这个题目而言，运算量非常大。
于是赶紧修改了一下f(n) 函数，转而用迭代来实现。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
int f(int n)
{
    int a,b,c,d;
    a=b=1;
    c=0;

    switch(n)
    {
    case 0:
    case 1:
        return 1;
        break;
    case 2:
        return 0;
        break;
    default:
        int t=0;
        while(n>2)
        {
            // a b c d
            d=c-2*b + a;
            t=d-2*c+b;
            a=b;
            b=c;
            c=d;
            d=t;

            n--;
        }
        return d;
    }
   
}

这样再运行，结果马上出来了： 598325
速给那同学把答案发去了。

后来，又再网上找到另一种更简便的方法，用一个数组来存储每次运算的结果，这样，后面的运行就可以直接利用前面运算得出的结果，而不要重新计算。从效率来说，这个更高一些。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
#include <stdio.h>
int main()
{

    int arr[51],i,num_max=1;
    arr[0]=arr[1]=1;
    arr[2]=0;
    for(i=3;i<=50;i++)
    {
        arr[i]=arr[i-1]-2*arr[i-2]+arr[i-3];
        if(num_max<arr[i])
                num_max=arr[i];
    }
    printf("max=%d\n",num_max);
    return 0;
}

看来我还是把问题想复杂了，有时候，最简单的方法就是最好的方法。简单就是美。

喜欢这篇文章吗?

请订阅本站 RSS feed 或填写您的邮件地址，订阅我们的精彩内容：

随机日志

]]> http://ihacklog.com/programming/c/recursive-and-iterative.html/feed 5