引言：在以前，我总是习惯用 INT UNSIGNED 来存储一个转换成Unix时间戳的时间值，认为这样做从索引，比较等角度来讲，都会比较高效。现在我们来对比下 TIMESTAMP 和 INT UNSIGNED 以及 DATETIME 这3种类型到底谁更好。

1. 准备

创建一个测试表：

mysql> CREATE TABLE `t` (`d1` int(10) unsigned NOT NULL default '0',`d2` timestamp NOT NULL default CURRENT_TIMESTAMP,`d3` datetime NOT NULL,KEY `d2` (`d2`),KEY `d1` (`d1`),KEY `d3` (`d3`));

然后创建一个存储过程填充数据：

mysql> DELIMITER //CREATE PROCEDURE INS_T()BEGINSET @i=1;WHILE 0<1DOSET @i=@i+1;INSERT INTO i VALUES (1199116800+@i, FROM_UNIXTIME(1199116800+@i), FROM_UNIXTIME(1199116800+@i));END WHILE;END;//DELIMITER ;

时间戳 1199116800 表示 2008-01-01 这个时间点。然后运行存储过程，大概填充几十万条记录后，中止执行，因为上面的存储过程是个死循环，所以需要人工中止。
来看看到底有多少条记录了，以及索引情况：

mysql> select count(*) from t;+----------+| count(*) |+----------+|   924707 |+----------+mysql> analyze table t;+--------+---------+----------+-----------------------------+| Table  | Op      | Msg_type | Msg_text                    |+--------+---------+----------+-----------------------------+| test.t | analyze | status   | Table is already up to date |+--------+---------+----------+-----------------------------+mysql> show index from t;+-------+------------+----------+--------------+-------------+-----------+-------------+----------+--------+------+------------+---------+| Table | Non_unique | Key_name | Seq_in_index | Column_name | Collation | Cardinality | Sub_part | Packed | Null | Index_type | Comment |+-------+------------+----------+--------------+-------------+-----------+-------------+----------+--------+------+------------+---------+| t     |          1 | d2       |            1 | d2          | A         |      924707 |     NULL | NULL   |      | BTREE      |         || t     |          1 | d1       |            1 | d1          | A         |      924707 |     NULL | NULL   |      | BTREE      |         || t     |          1 | d3       |            1 | d3          | A         |      924707 |     NULL | NULL   |      | BTREE      |         |+-------+------------+----------+--------------+-------------+-----------+-------------+----------+--------+------+------------+---------+

2. 对比

2.1 只检索一条记录

mysql> explain select * from t where d1 = 1199579155;+----+-------------+-------+------+---------------+------+---------+-------+------+-------+| id | select_type | table | type | possible_keys | key  | key_len | ref   | rows | Extra |+----+-------------+-------+------+---------------+------+---------+-------+------+-------+|  1 | SIMPLE      | t     | ref  | d1            | d1   | 4       | const |    1 |       |+----+-------------+-------+------+---------------+------+---------+-------+------+-------+mysql> explain select * from t where d2 = '2008-01-06 08:25:55';+----+-------------+-------+------+---------------+------+---------+-------+------+-------+| id | select_type | table | type | possible_keys | key  | key_len | ref   | rows | Extra |+----+-------------+-------+------+---------------+------+---------+-------+------+-------+|  1 | SIMPLE      | t     | ref  | d2            | d2   | 4       | const |    1 |       |+----+-------------+-------+------+---------------+------+---------+-------+------+-------+mysql> explain select * from t where d3 = '2008-01-06 08:25:55';+----+-------------+-------+------+---------------+------+---------+-------+------+-------+| id | select_type | table | type | possible_keys | key  | key_len | ref   | rows | Extra |+----+-------------+-------+------+---------------+------+---------+-------+------+-------+|  1 | SIMPLE      | t     | ref  | d3            | d3   | 8       | const |    1 |       |+----+-------------+-------+------+---------------+------+---------+-------+------+-------+

2.2 范围检索

mysql> explain select * from t where d1 >= 1199894400;+----+-------------+-------+-------+---------------+------+---------+------+--------+-------------+| id | select_type | table | type  | possible_keys | key  | key_len | ref  | rows   | Extra       |+----+-------------+-------+-------+---------------+------+---------+------+--------+-------------+|  1 | SIMPLE      | t     | range | d1            | d1   | 4       | NULL | 121961 | Using where |+----+-------------+-------+-------+---------------+------+---------+------+--------+-------------+mysql> explain select * from t where d2 >= from_unixtime(1199894400);+----+-------------+-------+-------+---------------+------+---------+------+--------+-------------+| id | select_type | table | type  | possible_keys | key  | key_len | ref  | rows   | Extra       |+----+-------------+-------+-------+---------------+------+---------+------+--------+-------------+|  1 | SIMPLE      | t     | range | d2            | d2   | 4       | NULL | 121961 | Using where |+----+-------------+-------+-------+---------------+------+---------+------+--------+-------------+mysql> explain select * from t where d3 >= from_unixtime(1199894400);+----+-------------+-------+-------+---------------+------+---------+------+--------+-------------+| id | select_type | table | type  | possible_keys | key  | key_len | ref  | rows   | Extra       |+----+-------------+-------+-------+---------------+------+---------+------+--------+-------------+|  1 | SIMPLE      | t     | range | d3            | d3   | 8       | NULL | 120625 | Using where |+----+-------------+-------+-------+---------------+------+---------+------+--------+-------------+

http://hi.baidu.com/_green_hand_/blog/item/05ac3239879a9922b9998f32.html
http://hi.baidu.com/ufo008ahw
http://blog.csdn.net/whyangwanfu
http://hi.baidu.com/5l2_

一、预备知识—程序的内存分配
一个由c/C++编译的程序占用的内存分为以下几个部分
1、栈区（stack）— 由编译器自动分配释放 ，存放函数的参数值，局部变量的值等。其操作方式类似于数据结构中的栈。
2、堆区（heap） — 一般由程序员分配释放， 若程序员不释放，程序结束时可能由OS回收 。注意它与数据结构中的堆是两回事，分配方式倒是类似于链表，呵呵。
3、全局区（静态区）（static）—，全局变量和静态变量的存储是放在一块的，初始化的全局变量和静态变量在一块区域， 未初始化的全局变量和未初始化的静态变量在相邻的另一块区域。 – 程序结束后有系统释放
4、文字常量区 —常量字符串就是放在这里的。 程序结束后由系统释放
5、程序代码区—存放函数体的二进制代码。

二、例子程序
这是一个前辈写的，非常详细
//main.cpp
int a = 0; 全局初始化区
char *p1; 全局未初始化区
main()
{
int b; 栈
char s[] = “abc”; 栈
char *p2; 栈
char *p3 = “123456″; 1234560在常量区，p3在栈上。
static int c =0； 全局（静态）初始化区
p1 = (char *)malloc(10);
p2 = (char *)malloc(20);
分配得来得10和20字节的区域就在堆区。
strcpy(p1, “123456″); 1234560放在常量区，编译器可能会将它与p3所指向的”123456″优化成一个地方。
}  
二、堆和栈的理论知识
2.1申请方式
stack:
由系统自动分配。 例如，声明在函数中一个局部变量 int b; 系统自动在栈中为b开辟空间
heap:
需要程序员自己申请，并指明大小，在c中malloc函数
如p1 = (char *)malloc(10);
在C++中用new运算符
如p2 = (char *)malloc(10);
但是注意p1、p2本身是在栈中的。
2.2
申请后系统的响应
栈：只要栈的剩余空间大于所申请空间，系统将为程序提供内存，否则将报异常提示栈溢出。
堆：首先应该知道操作系统有一个记录空闲内存地址的链表，当系统收到程序的申请时，
会遍历该链表，寻找第一个空间大于所申请空间的堆结点，然后将该结点从空闲结点链表中删除，并将该结点的空间分配给程序，另外，对于大多数系统，会在这块内存空间中的首地址处记录本次分配的大小，这样，代码中的delete语句才能正确的释放本内存空间。另外，由于找到的堆结点的大小不一定正好等于申请的大小，系统会自动的将多余的那部分重新放入空闲链表中。
2.3申请大小的限制
栈：在Windows下,栈是向低地址扩展的数据结构，是一块连续的内存的区域。这句话的意思是栈顶的地址和栈的最大容量是系统预先规定好的，在 WINDOWS下，栈的大小是2M（也有的说是1M，总之是一个编译时就确定的常数），如果申请的空间超过栈的剩余空间时，将提示overflow。因此，能从栈获得的空间较小。
堆：堆是向高地址扩展的数据结构，是不连续的内存区域。这是由于系统是用链表来存储的空闲内存地址的，自然是不连续的，而链表的遍历方向是由低地址向高地址。堆的大小受限于计算机系统中有效的虚拟内存。由此可见，堆获得的空间比较灵活，也比较大。
2.4申请效率的比较：
栈由系统自动分配，速度较快。但程序员是无法控制的。
堆是由new分配的内存，一般速度比较慢，而且容易产生内存碎片,不过用起来最方便.
另外，在WINDOWS下，最好的方式是用VirtualAlloc分配内存，他不是在堆，也不是在栈是直接在进程的地址空间中保留一快内存，虽然用起来最不方便。但是速度快，也最灵活
2.5堆和栈中的存储内容
栈： 在函数调用时，第一个进栈的是主函数中后的下一条指令（函数调用语句的下一条可执行语句）的地址，然后是函数的各个参数，在大多数的C编译器中，参数是由右往左入栈的，然后是函数中的局部变量。注意静态变量是不入栈的。
当本次函数调用结束后，局部变量先出栈，然后是参数，最后栈顶指针指向最开始存的地址，也就是主函数中的下一条指令，程序由该点继续运行。
堆：一般是在堆的头部用一个字节存放堆的大小。堆中的具体内容有程序员安排。
2.6存取效率的比较

char s1[] = “aaaaaaaaaaaaaaa”;
char *s2 = “bbbbbbbbbbbbbbbbb”;
aaaaaaaaaaa是在运行时刻赋值的；
而bbbbbbbbbbb是在编译时就确定的；
但是，在以后的存取中，在栈上的数组比指针所指向的字符串(例如堆)快。
比如：
#include <stdio.h>;
void main()
{
char a = 1;
char c[] = “1234567890″;
char *p =”1234567890″;
a = c[1];
a = p[1];
return;
}
对应的汇编代码
10: a = c[1];
00401067 8A 4D F1 mov cl,byte ptr [ebp-0Fh]
0040106A 88 4D FC mov byte ptr [ebp-4],cl
11: a = p[1];
0040106D 8B 55 EC mov edx,dword ptr [ebp-14h]
00401070 8A 42 01 mov al,byte ptr [edx+1]
00401073 88 45 FC mov byte ptr [ebp-4],al
第一种在读取时直接就把字符串中的元素读到寄存器cl中，而第二种则要先把指针值读到edx中，在根据edx读取字符，显然慢了。
?     

2.7小结：
堆和栈的区别可以用如下的比喻来看出：
使用栈就象我们去饭馆里吃饭，只管点菜（发出申请）、付钱、和吃（使用），吃饱了就走，不必理会切菜、洗菜等准备工作和洗碗、刷锅等扫尾工作，他的好处是快捷，但是自由度小。
使用堆就象是自己动手做喜欢吃的菜肴，比较麻烦，但是比较符合自己的口味，而且自由度大。

堆和栈的区别主要分：
操作系统方面的堆和栈，如上面说的那些，不多说了。
还有就是数据结构方面的堆和栈，这些都是不同的概念。这里的堆实际上指的就是（满足堆性质的）优先队列的一种数据结构，第1个元素有最高的优先权；栈实际上就是满足先进后出的性质的数学或数据结构。
虽然堆栈，堆栈的说法是连起来叫，但是他们还是有很大区别的，连着叫只是由于历史的原因

#include<stdio.h>
#include<malloc.h>
#include<string.h>

#define MAXSIZE 20
#define LEN sizeof(list)

typedef struct record
{
    char number[MAXSIZE];
    char name[MAXSIZE];
    int score;
}student;

typedef struct node
{
    student stu;
    struct node *next;
}list;

int count=0;

list *Creat();

void Display(list *rear);

void main()
{
    list *rear;
    rear=Creat();
    Display(rear);
    getchar();
}

list *Creat()
{
    list *head,*rear,*p;
    head=(list*)malloc(LEN);
    head->next = head;
    p=(list*)malloc(LEN);

    while(1)
    {   char ch;
        printf(”请输入学号: “);
        scanf(”%s”,p->stu.number);  
        printf(”请输入姓名: “);
        scanf(”%s”,p->stu.name);
        printf(”请输入学生的成绩: “);
        scanf(”%d”,&p->stu.score);
        ++count;
        p->next = head->next;
        head->next=p;

        printf(”继续输入学生的信息吗?(y是/n否): “);

        while((ch = getchar() ) != ”) ;
        scanf(”%c”,&ch);
        if(ch==’y')
        {
            p=(list*)malloc(LEN);
            continue;
        }
        if(ch==’n')
        {
            printf(”共有%d名学生的信息!”,count);
            break;
        }
    }

    return head;
}

void Display(list *r)
{
    list *head;
    head=r->next;
    printf(”t显示学生信息学号t姓名t成绩”);
    while(head!=r) {
        printf(”%s %s %d”,head->stu.number,head->stu.name,head->stu.score);
        head=head->next;
    }
}

**************************************************
* /data/c/C语言时钟源程序
* 南阳理工学院计算机系01612班大鹏课程设计作品
* 运行环境：TC2.0
* Email:ypsky@mail2.nyist.net
*************************************************
#include”graphics.h”
#define PI 3.1416
#include”math.h”
#include”dos.h”
main()
{
int x0=320,y0=240,r0=150;
void init_sceen();
void sec();
init_sceen(x0,y0,r0);
sec();
closegraph();
}
void init_sceen(int x0,int y0,int r0)/********************************************/
{
int i,x,y,graphdriver,graphmode;
char s[10];
float alpha,a0=90;

graphdriver=DETECT;
initgraph(&graphdriver,&graphmode,”");
setbkcolor(3);
setcolor(2);
circle(x0,y0,r0);
circle(x0,y0,r0 30);
setfillstyle(SOLID_FILL,10);
floodfill(x0-r0-10,y0,2);
/*please input the time*/
for(i=12;i>=1;i–)
{
alpha=(a0 30*(11-i)*PI/180);
x=x0 cos(alpha)*r0-16;
y=y0-sin(alpha)*r0;
sprintf(s,”-”,i);
setcolor(4);
settextstyle(0,0,2);
outtextxy(x,y,s);
}
/*input second*/
for(i=60;i>=1;i–)
{
alpha=(a0 6*(60-i)*PI/180);
x=x0 cos(alpha)*(r0-20);
y=y0-sin(alpha)*(r0-20);
setcolor(14);
if(i%5==0)
circle(x,y,5);
else circle(x,y,2);
floodfill(x,y,14);
}
setlinestyle(0,0,3);
}
void sec(void) /*******************************************************/
{
int x,y,i,j,k,xj,yj,xk,yk,xi,yi,x0=320,y0=240,r0=150;
union REGS r;

unsigned char *shijie=”";
unsigned char *daa=”";
suct time tim;
suct date dat;
float alphai,alphak,alphaj,a0=90;
xi=x0;yi=y0;xj=x0;yj=y0;xk=x0;yk=y0;
do
{
/*intput the time*/
x=38;y=12;
gettime(&tim);
sprintf(shijie,”d:d:d”,tim.ti_hour,tim.ti_min,tim.ti_sec);
setfillstyle(SOLID_FILL,0);
bar(245,190,375,210);
setcolor(15);
outtextxy(245,190,shijie);
/*input the date*/ /*****************************************************/
geate(&dat);
sprintf(daa,”d–d–d”,dat.da_year,dat.da_mon,dat.da_day);
/*setfillstyle(SOLID_FILL,3);*/
bar(225,290,395,310);
setcolor(RED);
outtextxy(225,290,daa);
x=190;y=430;
setcolor(RED);
outtextxy(x-26,y,”Designed by GuoLiuTa0″);
setcolor(LIGHTRED);
outtextxy(x 76,y0 20,”NBA GAME”);
setlinestyle(0,0,3);
k=tim.ti_hour;
j=tim.ti_min;
i=tim.ti_sec;
alphak=(a0 30*(12-k)-j*5/60.*6)*PI/180;
alphaj=(a0-6*j)*PI/180;
/*write second hand*/
alphai=(a0 6*(60-i))*PI/180;
x=x0 cos(alphai)*(r0-32);
y=y0-sin(alphai)*(r0-32);
setcolor(BLACK);
line(x0,y0,xi,yi);
setcolor(YELLOW);
line(x0,y0,x,y);
xi=x;
yi=y;
/*write minute hand*/
x=x0 cos(alphaj)*(r0-60);
y=y0-sin(alphaj)*(r0-60);
setcolor(BLACK);
line(x0,y0,xj,yj);
setcolor(BLUE);
line(x0,y0,x,y);
xj=x;
yj=y;
/*write hour hand*/
x=x0 cos(alphak)*(r0-99);
y=y0-sin(alphak)*(r0-99);
setcolor(BLACK);
line(x0,y0,xk,yk);
setcolor(RED);
line(x0,y0,x,y);
xk=x;
yk=y;
delay(10000);
}
while(!kbhit());
}

纯真IP数据库格式详解

摘要
网络上的IP数据库以纯真版的最为流行，LumaQQ也采用了纯真版IP数据库做为IP查询功能的基础。不过关于其格式的文档却非常之少，后来终于在网上找到了一份文档，得以了解其内幕，不过那份文档寥寥数语，也是颇为耐心才读明白。在这里我重写一份，以此做为LumaQQ开发者文档的一部分，我想还是必要的。本文详细介绍了纯真IP数据库的格式，并且给出了一些Demo以供参考。Luma, 清华大学
修改日期： 2005/01/14

Note: 在此感谢纯真IP数据库作者金狐和那唯一一份文档的作者。

修改历史:
2005-01-14 修改了原来一些表达不清和错误的地方

基本结构

QQWry.dat文件在结构上分为3块：文件头，记录区，索引区。一般我们要查找IP时，先在索引区查找记录偏移，然后再到记录区读出信息。由于记录区的记录是不定长的，所以直接在记录区中搜索是不可能的。由于记录数比较多，如果我们遍历索引区也会是有点慢的，一般来说，我们可以用二分查找法搜索索引区，其速度比遍历索引区快若干数量级。图1是QQWry.dat的文件结构图。

图1. QQWry.dat文件结构

要注意的是，QQWry.dat里面全部采用了little-endian字节序

一. 了解文件头

QQWry.dat的文件头只有8个字节，其结构非常简单，首四个字节是第一条索引的绝对偏移，后四个字节是最后一条索引的绝对偏移。

二. 了解记录区

每条IP记录都由国家和地区名组成，国家地区在这里并不是太确切，因为可能会查出来“清华大学计算机系”之类的，这里清华大学就成了国家名了，所以这个国家地区名和IP数据库制作的时候有关系。所以记录的格式有点像QName，有一个全局部分和局部部分组成，我们这里还是沿用国家名和地区名的说法。

于是我们想象着一条记录的格式应该是:[IP地址][国家名][地区名]，当然，这个没有什么问题，但是这只是最简单的情况。很显然，国家名和地区名可能会有很多的重复，如果每条记录都保存一个完整的名称拷贝是非常不理想的，所以我们就需要重定向以节省空间。所以为了得到一个国家名或者地区名，我们就有了两个可能：第一就是直接的字符串表示的国家名，第二就是一个4字节的结构，第一个字节表明了重定向的模式，后面3个字节是国家名或者地区名的实际偏移位置。对于国家名来说，情况还可能更复杂些，因为这样的重定向最多可能有两次。

那么什么是重定向模式？根据上面所说，一条记录的格式是[IP地址][国家记录][地区记录]，如果国家记录是重定向的话，那么地区记录是有可能没有的，于是就有了两种情况，我管他叫做模式1和模式2。我们对这些格式的情况举图说明：

图2. IP记录的最简单形式

图2表示了最简单的IP记录格式，我想没有什么可以解释的

图3. 重定向模式1

图3演示了重定向模式1的情况。我们看到在模式1的情况下，地区记录也跟着国家记录走了，在IP地址之后只剩下了国家记录的4字节，后面3个字节构成了一个指针，指向了实际的国家名，然后又跟着地址名。模式1的标识字节是0×01。

图4. 重定向模式2

图4演示了重定向模式2的情况。我们看到了在模式2的情况下（其标识字节是0×02），地区记录没有跟着国家记录走，因此在国家记录之后4个字节之后还是有地区记录。我想你已经明白了模式1和模式2的区别，即：模式1的国家记录后面不会再有地区记录，模式2的国家记录后会有地区记录。下面我们来看一下更复杂的情况。

图5. 混和情况1

图5演示了当国家记录为模式1的时候可能出现的更复杂情况，在这种情况下，重定向指向的位置仍然是个重定向，不过第二次重定向为模式2。大家不用担心，没有模式3了，这个重定向也最多只有两次，并且如果发生了第二次重定向，则其一定为模式2，而且这种情况只会发生在国家记录上，对于地区记录，模式1和模式2是一样的，地区记录也不会发生2次重定向。不过，这个图还可以更复杂，如图7：

图6. 混和情况2

图6是模式1下最复杂的混和情况，不过我想应该也很好理解，只不过地区记录也来重定向而已，有一点我要提醒你，如果重定向的地址是0，则表示未知的地区名。

所以我们总结如下：一条IP记录由[IP地址][国家记录][地区记录]组成，对于国家记录，可以有三种表示方式：字符串形式，重定向模式1和重定向模式2。对于地区记录，可以有两种表示方式：字符串形式和重定向，另外有一条规则：重定向模式1的国家记录后不能跟地区记录。按照这个总结，在这些方式中合理组合，就构成了IP记录的所有可能情况。

设计的理由

在我们继续去了解索引区的结构之前，我们先来了解一下为何记录区的结构要如此设计。我想你可能想到了答案：字符串重用。没错，在这种结构下，对于一个国家名和地区名，我只需要保存其一次就可以了。我们举例说明，为了表示方便，我们用小写字母代表IP记录，C表示国家名，A表示地区名：

1. 有两条记录a(C1, A1), b(C2, A2)，如果C1 = C2, A1 = A2，那么我们就可以使用图3显示的结构来实现重用
2. 有三条记录a(C1, A1), b(C2, A2), c(C3, A3)，如果C1 = C2, A2 = A3，现在我们想存储记录b，那么我们可以用图6的结构来实现重用
3. 有两条记录a(C1, A1), b(C2, A2)，如果C1 = C2，现在我们想存储记录b，那么我们可以采用模式2表示C2，用字符串表示A2

你可以举出更多的情况，你也会发现在这种结构下，不同的字符串只需要存储一次。

了解索引区

在”了解文件头”部分，我们说明了文件头实际上是两个指针，分别指向了第一条索引和最后一条索引的绝对偏移。如图8所示：

图8. 文件头指向索引区图示

实在是很简单，不是吗？从文件头你就可以定位到索引区，然后你就可以开始搜索IP了！每条索引长度为7个字节，前4个字节是起始IP地址，后三个字节就指向了IP记录。这里有些概念需要说明一下，什么是起始IP，那么有没有结束IP？ 假设有这么一条记录：166.111.0.0 -166.111.255.255，那么166.111.0.0就是起始IP，166.111.255.255就是结束IP，结束IP就是IP记录中的那头4个字节，这下你应该就清楚了吧。于是乎，每条索引配合一条记录，构成了一个IP范围，如果你要查找166.111.138.138所在的位置，你就会发现166.111.138.138落在了166.111.0.0 – 166.111.255.255这个范围内，那么你就可以顺着这条索引去读取国家和地区名了。那么我们给出一个最详细的图解吧：

图9. 文件详细结构

现在一切都清楚了是不是？也许还有一点你不清楚，QQWry.dat的版本信息存在哪里呢？答案是：最后一条IP记录实际上就是版本信息，最后一条记录显示出来就是这样：255.255.255.0 255.255.255.255 纯真网络2004年6月25日IP数据。OK，到现在你应该全部清楚了。

Demo

下一步：我给出一个读取IP记录的程序片断，此片断摘录自LumaQQ源文件edu.tsinghua.lumaqq.IPSeeker.java，如果你有兴趣，可以下载源代码详细看看。

 /**  * 给定一个ip国家地区记录的偏移，返回一个IPLocation结构  * @param offset 国家记录的起始偏移  * @return IPLocation对象  */ private IPLocation getIPLocation(long offset) {  try {   // 跳过4字节ip   ipFile.seek(offset + 4);   // 读取第一个字节判断是否标志字节   byte b = ipFile.readByte();   if(b == REDIRECT_MODE_1) {    // 读取国家偏移    long countryOffset = readLong3();    // 跳转至偏移处    ipFile.seek(countryOffset);    // 再检查一次标志字节，因为这个时候这个地方仍然可能是个重定向    b = ipFile.readByte();    if(b == REDIRECT_MODE_2) {     loc.country = readString(readLong3());     ipFile.seek(countryOffset + 4);    } else     loc.country = readString(countryOffset);    // 读取地区标志    loc.area = readArea(ipFile.getFilePointer());   } else if(b == REDIRECT_MODE_2) {    loc.country = readString(readLong3());    loc.area = readArea(offset + 8);   } else {    loc.country = readString(ipFile.getFilePointer() - 1);    loc.area = readArea(ipFile.getFilePointer());   }   return loc;  } catch (IOException e) {   return null;  } } 

 /**  * 从offset偏移开始解析后面的字节，读出一个地区名  * @param offset 地区记录的起始偏移  * @return 地区名字符串  * @throws IOException 地区名字符串  */ private String readArea(long offset) throws IOException {  ipFile.seek(offset);  byte b = ipFile.readByte();  if(b == REDIRECT_MODE_1 || b == REDIRECT_MODE_2) {   long areaOffset = readLong3(offset + 1);   if(areaOffset == 0)    return LumaQQ.getString("unknown.area");   else    return readString(areaOffset);  } else   return readString(offset); }

 /**  * 从offset位置读取3个字节为一个long，因为java为big-endian格式，所以没办法  * 用了这么一个函数来做转换  * @param offset 整数的起始偏移  * @return 读取的long值，返回-1表示读取文件失败  */ private long readLong3(long offset) {  long ret = 0;  try {   ipFile.seek(offset);   ipFile.readFully(b3);   ret |= (b3[0] & 0xFF);   ret |= ((b3[1] <<  & 0xFF00);   ret |= ((b3[2] << 16) & 0xFF0000);   return ret;  } catch (IOException e) {   return -1;  } } 

 /**  * 从当前位置读取3个字节转换成long  * @return 读取的long值，返回-1表示读取文件失败  */ private long readLong3() {  long ret = 0;  try {   ipFile.readFully(b3);   ret |= (b3[0] & 0xFF);   ret |= ((b3[1] <<  & 0xFF00);   ret |= ((b3[2] << 16) & 0xFF0000);   return ret;  } catch (IOException e) {   return -1;  } }

 /**  * 从offset偏移处读取一个以0结束的字符串  * @param offset 字符串起始偏移  * @return 读取的字符串，出错返回空字符串  */ private String readString(long offset) {  try {   ipFile.seek(offset);   int i;   for(i = 0, buf[i] = ipFile.readByte(); buf[i] != 0; buf[++i] = ipFile.readByte());   if(i != 0)        return Utils.getString(buf, 0, i, "GBK");  } catch (IOException e) {         log.error(e.getMessage());  }  return ""; }

代码并不复杂，getIPLocation是主要方法，它检查国家记录格式，并针对字符串形式，模式1，模式2采用不同的代码，readArea则相对简单，因为只有字符串和重定向两种情况需要处理。

总结

纯真IP数据库的结构使得查找IP简单迅速，不过你想要编辑它却是比较麻烦的，我想应该需要专门的工具来生成QQWry.dat文件，由于其文件格式的限制，你要直接添加IP记录就不容易了。不过，能查到IP已经很开心了，希望纯真记录越来越多～。

#include <sio.h>
#include <sys/types.h>
#include <sys/param.h>
#include <sys/ioctl.h>
#include <sys/socket.h>
#include <net/if.h>
#include <netinet/in.h>
#include <net/if_arp.h>

#define MAXINTERFACES 16

main (argc, argv)
register int argc;
register char *argv[];
{
register int fd, inface, retn = 0;
suct ifreq buf[MAXINTERFACES];
suct arpreq arp;
suct ifconf ifc;

if ((fd = socket (AF_INET, SOCK_DGRAM, 0)) >= 0) {
ifc.ifc_len = sizeof buf;
ifc.ifc_buf = (caddr_t) buf;
if (!ioctl (fd, SIOCGIFCONF, (char *) &ifc)) {
inface = ifc.ifc_len / sizeof (suct ifreq);
printf(”interface num is inface=%d”,inface);
while (inface– > 0)
{
printf (”net device %s”, buf[inface].ifr_name);

/*Jugde whether the net card status is promisc*/
if (!(ioctl (fd, SIOCGIFFLAGS, (char *) &buf[inface]))) {
if (buf[inface].ifr_flags & IFF_PROMISC) {
puts (”the interface is PROMISC”);
retn ;
}
} else {
char s[256];

sprintf (s, “cpm: ioctl device %s”, buf[inface].ifr_name);
perror (s);
}

/*Jugde whether the net card status is up*/
if (buf[inface].ifr_flags & IFF_UP) {
puts(”the interface status is UP”);
}
else {
puts(”the interface status is DOWN”);
}

/*Get IP of the net card */
if (!(ioctl (fd, SIOCGIFADDR, (char *) &buf[inface])))
{
puts (”IP address is:”);
puts(inet_ntoa(((suct sockaddr_in*)(&buf[inface].ifr_addr))->sin_addr));
puts(”");
//puts (buf[inface].ifr_addr.sa_data);
}
else {
char s[256];

sprintf (s, “cpm: ioctl device %s”, buf[inface].ifr_name);
perror (s);
}

/*Get HW ADDRESS of the net card */
if (!(ioctl (fd, SIOCGIFHWADDR, (char *) &buf[inface])))
{
puts (”HW address is:”);

printf(”x:x:x:x:x:x”,
(unsigned char)buf[inface].ifr_hwaddr.sa_data[0],
(unsigned char)buf[inface].ifr_hwaddr.sa_data[1],
(unsigned char)buf[inface].ifr_hwaddr.sa_data[2],
(unsigned char)buf[inface].ifr_hwaddr.sa_data[3],
(unsigned char)buf[inface].ifr_hwaddr.sa_data[4],
(unsigned char)buf[inface].ifr_hwaddr.sa_data[5]);

puts(”");
puts(”");
}

else {
char s[256];

sprintf (s, “cpm: ioctl device %s”, buf[inface].ifr_name);
perror (s);
}
}
} else
perror (”cpm: ioctl”);

} else
perror (”cpm: socket”);

close (fd);
return retn;
}