Chinaunix首页 | 论坛 | 博客

Unix 家族hanna.blog.chinaunix.net

首页　| 　博文目录　| 　关于我

zhanleewo

  • 博客访问： 303843
  • 博文数量： 15
  • 博客积分： 250
  • 博客等级： 一等列兵
  • 技术积分： 787
  • 用 户 组： 普通用户
  • 注册时间： 2010-08-28 16:18
文章分类

全部博文（15）

文章存档

2013年（2）

2012年（13）

我的朋友
最近访客
推荐博文
相关博文
Linux下查询IP归属地的实现

分类： LINUX

2012-04-26 21:30:05

参考文章：
1. java版实现：
2. 纯真IP数据库格式详解：
以下是我的实现：使用的时候很简单：

点击(此处)折叠或打开

  1. /**
  2. *1.调用qqwry_init_parser创建一个qqwry_parser_t类型的解析器
  3. *2.初始化一个存放查询结果信息的qqwry_record
  4. *3.调用qqwry_querey_iprecord查询指定ip的归属地
  5. *4.调用qqwry_release_parser释放资源
  6. **/

  8. qqwry_parser_t parser = qqwry_init_parser("/root/QQWry.Dat", VERBOSE_ENABLE,
  9. CACHE_ENABLE, 1);
  10. qqwry_record qr = QQWARY_RECORD_INITIALIZER();
  11. qqwry_querey_iprecord(parser, "61.172.201.195", &qr);
  12. qqwry_release_parser(parser);
这是一个初级版本，还没有经过大量的测试，可能存在很多不完备的地方，希望亲们试用了之后，能够提出改进意见啊。

qqwry_utils.h

点击(此处)折叠或打开

  1. /*
  2.  * qqwry_utils.h
  3.  *
  4.  * Created on: 2012-4-26
  5.  * Author: zhanlin
  6.  */

  8. #ifndef QQWRY_UTILS_H_
  9. #define QQWRY_UTILS_H_


  12. int ipaddr_to_bytes(const char *src, char *dest);
  13. void bytes_to_ipaddr(const char *src, char *dest);
  14. inline int32_t char3_to_int32(const char *buf);
  15. #endif /* QQWRY_UTILS_H_ */
qqwry_utils.c

点击(此处)折叠或打开

  1. /*
  2.  * qqwry_utils.c
  3.  *
  4.  * Created on: 2012-4-26
  5.  * Author: zhanlin
  6.  */

  8. #include <string.h>
  9. #include <sys/types.h>
  10. #include <stdlib.h>
  11. #include <stdio.h>
  12. #include <string.h>
  13. #include "qqwry_utils.h"

  15. int ipaddr_to_bytes(const char *src, char *dest) {
  16.     int n;
  17.     char *newstr;
  18.     char *sub;
  19.     int i = 0;

  21.     n = strlen(src);
  22.     newstr = (char *) malloc(n + 1);
  23.     if (newstr == NULL) {
  24.         return -1;
  25.     }

  27.     memcpy(newstr, src, n);
  28.     *(newstr + n) = 0;
  29.     sub = strtok(newstr, ".");

  31.     while (sub != NULL) {
  32.         // printf("%s atoi %d\n", sub, atoi(sub));
  33.         *(dest + i) = (char) atoi(sub);
  34.         sub = strtok(NULL, ".");
  35.         i++;
  36.     }
  37.     free(newstr);
  38.     return 0;
  39. }
  40. void bytes_to_ipaddr(const char *src, char *dest) {
  41.     sprintf(dest, "%c.%c.%c.%c", src[0], src[1], src[2], src[3]);
  42. }
  43. inline int32_t char3_to_int32(const char *buf) {
  44.     int32_t i = 0;
  45.     memcpy(&i, buf, 3);
  46.     return i;
  47. }
qqwry_types.h

点击(此处)折叠或打开

  1. /*
  2.  * qqwry_types.h
  3.  *
  4.  * Created on: 2012-4-26
  5.  * Author: zhanlin
  6.  */

  8. #ifndef QQWRY_TYPES_H_
  9. #define QQWRY_TYPES_H_
  10. #include <sys/types.h>
  11. #include <string.h>
  12. #include <stdio.h>
  13. #include <stdlib.h>
  14. #include <dirent.h>

  16. #pragma pack(0)

  18. typedef struct _qqwry_header {
  19.     u_int32_t qh_idx_start;
  20.     u_int32_t qh_idx_end;
  21. } qqwry_header, *qqwry_header_t;

  23. #endif /* QQWRY_TYPES_H_ */
qqwry_parser.h

点击(此处)折叠或打开

  1. /*
  2.  * qqwry_parser.h
  3.  *
  4.  * Created on: 2012-4-26
  5.  * Author: zhanlin
  6.  */

  8. #ifndef QQWRY_PARSER_H_
  9. #define QQWRY_PARSER_H_

  11. #include <sys/types.h>
  12. enum {
  13.     VERBOSE_DISABLE = 0, VERBOSE_ENABLE = 1
  14. };

  16. enum {
  17.     CACHE_DISABLE = 0, CACHE_ENABLE = 1
  18. };

  20. typedef struct _qqwry_record {
  21.     char qr_ipaddr[20];
  22.     int32_t qr_ip;
  23.     char qr_bigzone[1024];
  24.     char qr_smallzone[1024];
  25. } qqwry_record, *qqwry_record_t;

  27. #define QQWARY_RECORD_INITIALIZER() {\
  28.         .qr_ipaddr = {0}, \
  29.         .qr_ip = 0, \
  30.         .qr_bigzone = {0}, \
  31.         .qr_smallzone = {0}, \
  32. }
  33. struct _qqwry_parser;
  34. typedef struct _qqwry_parser qqwry_parser, *qqwry_parser_t;
  35. qqwry_parser_t qqwry_init_parser(const char *dbpath, int verb, int cache,
  36.         int loaddb);
  37. int qqwry_load_db(qqwry_parser_t parser);
  38. void qqwry_unload_db(qqwry_parser_t parser);
  39. int qqwry_querey_iprecord(qqwry_parser_t parser, const char *ipaddr, qqwry_record_t qr);
  40. void qqwry_release_parser(qqwry_parser_t parser);

  42. int load_db_to_mem(qqwry_parser_t parser);

  44. #endif /* QQWRY_PARSER_H_ */
qqwry_types.c

点击(此处)折叠或打开

  1. /*
  2.  * qqwry_types.c
  3.  *
  4.  * Created on: 2012-4-26
  5.  * Author: root
  6.  */

  8. #include "qqwry_parser.h"
  9. #include "qqwry_utils.h"
  10. #include "qqwry_types.h"
  11. #include <sys/stat.h>
  12. #include <fcntl.h>
  13. #include <unistd.h>
  14. #include <errno.h>
  15. #include <iconv.h>
  16. #include <arpa/inet.h>
  17. #define trace(parser, fmt, ...) {\
  18.     if((parser)->verbose) {\
  19.         printf(fmt, ##);\
  20.     }\
  21. }

  23. struct _qqwry_parser {
  24.     char qp_db_path[PATH_MAX];
  25.     int qp_db_fd;
  26.     int qp_verbose;
  27.     int qp_cache;
  28.     int qp_errno;
  29.     char *qp_memaddr;
  30.     u_int32_t qp_foff;
  31.     u_int32_t qp_fsize;
  32.     qqwry_header_t qp_header;
  33.     iconv_t qp_cd;
  34. };
  35. /*
  36.  int load_db_to_mem(qqwry_parser_t parser);
  37.  void unload_db(qqwry_parser_t parser);*/
  38. int qqwry_load_db(qqwry_parser_t parser) {
  39.     struct stat buf;
  40.     int retval = 0;

  42.     parser->qp_errno = 0;
  43.     //
  44.     if ((retval = fstat(parser->qp_db_fd, &buf)) != 0) {
  45.         parser->qp_errno = errno;
  46.         if (parser->qp_verbose)
  47.             perror("fstat execute failed");
  48.         return retval;
  49.     }
  50.     //
  51.     parser->qp_fsize = buf.st_size;
  52.     parser->qp_memaddr = (char *) malloc(buf.st_size);
  53.     if (parser->qp_memaddr == NULL) {
  54.         parser->qp_errno = errno;
  55.         if (parser->qp_verbose)
  56.             perror("malloc execute failed");
  57.         return -1;
  58.     }
  59.     //
  60.     if ((retval = read(parser->qp_db_fd, parser->qp_memaddr, buf.st_size))
  61.             != buf.st_size) {
  62.         parser->qp_errno = errno;
  63.         if (parser->qp_verbose)
  64.             perror("read file failed");
  65.     }
  66.     parser->qp_header = (qqwry_header_t) parser->qp_memaddr;

  68.     //
  69.     parser->qp_cd = iconv_open("UTF-8", "GBK");
  70.     return 0;
  71. }

  73. void qqwry_unload_db(qqwry_parser_t parser) {
  74.     if (parser->qp_memaddr) {
  75.         free(parser->qp_memaddr);
  76.         parser->qp_memaddr = NULL;
  77.     }
  78.     if (parser->qp_cd) {
  79.         iconv_close(parser->qp_cd);
  80.     }
  81. }

  83. int qqwry_open_db(qqwry_parser_t parser) {
  84.     parser->qp_db_fd = open(parser->qp_db_path, O_RDONLY, 0777);
  85.     parser->qp_errno = errno;
  86.     if (parser->qp_verbose && parser->qp_db_fd < 0)
  87.         perror("open qqwry datafile failed");
  88.     return parser->qp_db_fd;
  89. }

  91. void qqwry_close_db(qqwry_parser_t parser) {
  92.     if (parser->qp_db_fd >= 0) {
  93.         close(parser->qp_db_fd);
  94.         parser->qp_db_fd = -1;
  95.     }
  96. }

  98. int qqwry_read(qqwry_parser_t p, void *buf, int n) {
  99.     if (p->qp_fsize < p->qp_foff + n) {
  100.         n = p->qp_fsize - p->qp_foff;
  101.     }
  102.     memcpy(buf, (p->qp_memaddr + p->qp_foff), n);
  103.     p->qp_foff += n;
  104.     return n;
  105. }

  107. int qqwry_seek(qqwry_parser_t p, int32_t off) {
  108.     if (p->qp_fsize < off) {
  109.         return -1;
  110.     }
  111.     return (p->qp_foff = off);
  112. }

  114. int32_t qqwry_read3c_to_int32(qqwry_parser_t p) {
  115.     char b3[3] = { 0 };
  116.     int32_t ret = 0;
  117.     if (qqwry_read(p, b3, 3) != 3) {
  118.         return -1;
  119.     }
  120.     ret |= (b3[0] & 0xFF);
  121.     ret |= ((b3[1] << 8) & 0xFF00);
  122.     ret |= ((b3[2] << 16) & 0xFF0000);
  123.     return ret;
  124. }

  126. char qqwry_readc(qqwry_parser_t p) {
  127.     char b[1] = { 0 };
  128.     if (qqwry_read(p, b, 1) != 1) {
  129.         return -1;
  130.     }
  131.     return b[0];
  132. }

  134. int qqwry_read_ip(qqwry_parser_t p, int32_t offset, int32_t *ip) {
  135.     int ret = 0;
  136.     ret = qqwry_seek(p, offset);
  137.     if (ret < 0)
  138.         return ret;
  139.     ret = qqwry_read(p, ip, 4);
  140.     *ip = ntohl(*ip);
  141.     return ret;
  142. }

  144. /**
  145.  * 把两个byte当作无符号数进行比较
  146.  *
  147.  * @param b1
  148.  * @param b2
  149.  * @return 若b1大于b2则返回1，相等返回0，小于返回-1
  150.  */
  151. int qqwry_compare_char(char c1, char c2) {
  152.     if ((c1 & 0xFF) > (c2 & 0xFF)) // 比较是否大于
  153.         return 1;
  154.     else if ((c1 ^ c2) == 0) // 判断是否相等
  155.         return 0;
  156.     else
  157.         return -1;
  158. }
  159. /**
  160.  * 把类成员ip和beginIp比较，注意这个beginIp是big-endian的
  161.  *
  162.  * @param ip
  163.  * 要查询的IP
  164.  * @param beginIp
  165.  * 和被查询IP相比较的IP
  166.  * @return 相等返回0，ip大于beginIp则返回1，小于返回-1。
  167.  */
  168. inline int qqwry_compare_ip(int32_t *ip, int32_t *beginip) {
  169.     char *ipc = (char *) ip;
  170.     char *beginipc = (char *) beginip;
  171.     int i = 0;
  172.     for (; i < 4; i++) {
  173.         int r = qqwry_compare_char((*(ipc + i)), *(beginipc + i));
  174.         if (r != 0)
  175.             return r;
  176.     }
  177.     return 0;
  178. }

  180. qqwry_parser_t qqwry_init_parser(const char *dbpath, int verb, int cache,
  181.         int loaddb) {
  182.     qqwry_parser_t qp = (qqwry_parser_t) malloc(sizeof(qqwry_parser));
  183.     if (qp) {
  184.         //
  185.         qp->qp_cache = cache;
  186.         qp->qp_errno = 0;
  187.         qp->qp_db_fd = -1;
  188.         qp->qp_verbose = verb;
  189.         qp->qp_memaddr = NULL;
  190.         qp->qp_foff = 0;
  191.         qp->qp_header = NULL;
  192.         strncpy(qp->qp_db_path, dbpath, PATH_MAX);
  193.         //
  194.         if (loaddb) {
  195.             if (qqwry_open_db(qp) >= 0) {
  196.                 if (qqwry_load_db(qp) != 0)
  197.                     qp->qp_errno = errno;
  198.                 else
  199.                     qqwry_close_db(qp);
  200.             } else {
  201.                 qp->qp_errno = errno;
  202.             }
  203.         }
  204.     }
  205.     return qp;
  206. }
  207. int32_t get_middle_offset(int32_t begin, int32_t end) {
  208. #define IP_RECORD_LENGTH 7
  209.     long records = (end - begin) / IP_RECORD_LENGTH;
  210.     records >>= 1;
  211.     if (records == 0)
  212.         records = 1;
  213.     return begin + records * IP_RECORD_LENGTH;
  214. }

  216. int32_t qqwry_locate_ip(qqwry_parser_t p, const char *ipaddr) {
  217.     int32_t ip = 0;
  218.     int32_t rip;
  219.     int ret = 0;

  221.     int32_t m;
  222.     int32_t i = p->qp_header->qh_idx_start;
  223.     int j = p->qp_header->qh_idx_end;

  225.     ip = (int32_t) inet_addr(ipaddr) ;
  226.     // ipaddr_to_bytes(ipaddr, (char *) &ip);
  227.     qqwry_read_ip(p, p->qp_header->qh_idx_start, &rip);
  228.     ret = qqwry_compare_ip(&ip, &rip);
  229.     if (ret == 0)
  230.         return p->qp_header->qh_idx_start;
  231.     else if (ret < 0)
  232.         return -1;

  234.     // 开始二分搜索
  235.     for (; i < j;) {
  236.         m = get_middle_offset(i, j);
  237.         qqwry_read_ip(p, m, &rip);
  238.         ret = qqwry_compare_ip(&ip, &rip);
  239.         // log.debug(Utils.getIpStringFromBytes(b));
  240.         if (ret > 0)
  241.             i = m;
  242.         else if (ret < 0) {
  243.             if (m == j) {
  244.                 j -= IP_RECORD_LENGTH;
  245.                 m = j;
  246.             } else {
  247.                 j = m;
  248.             }
  249.         } else {
  250.             qqwry_seek(p, m + 4);
  251.             return qqwry_read3c_to_int32(p);
  252.         }
  253.     }
  254.     // 如果循环结束了，那么i和j必定是相等的，这个记录为最可能的记录，但是并非
  255.     // 肯定就是，还要检查一下，如果是，就返回结束地址区的绝对偏移
  256.     qqwry_seek(p, m + 4);
  257.     m = qqwry_read3c_to_int32(p);
  258.     qqwry_read_ip(p, m, &rip);
  259.     ret = qqwry_compare_ip(&ip, &rip);
  260.     if (ret <= 0)
  261.         return m;
  262.     else
  263.         return -1;
  264. }
  265. size_t conver_gbk_to_utf8(qqwry_parser_t p, char *inbuf, char *outbuf) {
  266.     int n = strlen(inbuf);
  267.     char *in = inbuf;
  268.     char *out = outbuf;
  269.     size_t outlen = n * 4;
  270.     iconv(p->qp_cd, &in, (size_t *) &n, &out, &outlen);
  271.     outlen = strlen(outbuf);
  272.     return outlen;
  273. }
  274. void qqwry_read_string(qqwry_parser_t p, char *buf) {
  275.     int i = 0;
  276.     char tmp[512] = { 0 };
  277.     for (i = 0, tmp[i] = qqwry_readc(p); tmp[i] != 0; tmp[++i] = qqwry_readc(p))
  278.         ;
  279.     conver_gbk_to_utf8(p, tmp, buf);
  280. }
  281. void qqwry_read_smallzone(qqwry_parser_t p, char *buf) {
  282.     char flag = qqwry_readc(p);
  283.     if (flag == 0x01 || flag == 0x02) {
  284.         long areaOffset = qqwry_read3c_to_int32(p);
  285.         if (areaOffset == 0)
  286.             p->qp_errno = 0;
  287.         else {
  288.             qqwry_seek(p, areaOffset);
  289.             qqwry_read_string(p, buf);
  290.         }
  291.     } else {

  293.         return qqwry_read_string(p, buf);
  294.     }
  295. }
  296. int qqwry_querey_iprecord(qqwry_parser_t parser, const char *ipaddr,
  297.         qqwry_record_t qr) {

  299. #define AREA_FOLLOWED 0x1
  300. #define NO_AREA 0x2
  301.     int32_t offset = qqwry_locate_ip(parser, ipaddr);
  302.     char flag = 0;
  303.     printf("ip off: %d\n", offset);

  305.     qqwry_seek(parser, offset + 4);
  306.     // 读取第一个字节判断是否标志字节
  307.     flag = qqwry_readc(parser);
  308.     if (flag == AREA_FOLLOWED) {
  309.         // 读取国家偏移
  310.         int32_t country_offset = qqwry_read3c_to_int32(parser);
  311.         // 跳转至偏移处
  312.         qqwry_seek(parser, country_offset);
  313.         // 再检查一次标志字节，因为这个时候这个地方仍然可能是个重定向
  314.         flag = qqwry_readc(parser);
  315.         if (flag == NO_AREA) {
  316.             qqwry_seek(parser, qqwry_read3c_to_int32(parser));
  317.             qqwry_read_string(parser, qr->qr_bigzone);
  318.             qqwry_seek(parser, country_offset + 4);
  319.         } else {
  320.             qqwry_seek(parser, country_offset);
  321.             qqwry_read_string(parser, qr->qr_bigzone);
  322.         }
  323.         // 读取地区标志
  324.         qqwry_read_smallzone(parser, qr->qr_smallzone);
  325.     } else if (flag == NO_AREA) {
  326.         int32_t country_offset = qqwry_read3c_to_int32(parser);
  327.         qqwry_seek(parser, country_offset);
  328.         qqwry_read_string(parser, qr->qr_bigzone);
  329.         qqwry_seek(parser, offset + 8);
  330.         qqwry_read_string(parser, qr->qr_smallzone);
  331.     } else {
  332.         qqwry_seek(parser, parser->qp_foff - 1);
  333.         qqwry_read_string(parser, qr->qr_bigzone);
  334.         qqwry_read_string(parser, qr->qr_smallzone);
  335.     }
  336.     return 0;
  337. }

  339. void qqwry_release_parser(qqwry_parser_t parser) {
  340.     if (parser != NULL) {
  341.         //
  342.         if (parser->qp_memaddr) {
  343.             qqwry_unload_db(parser);
  344.         }
  345.         //
  346.         free(parser);
  347.         parser = NULL;
  348.     }

  350. }
ipinfo.c

点击(此处)折叠或打开

  1. /*
  2.  ============================================================================
  3.  Name : ipinfo.c
  4.  Author : ZhanLin
  5.  Version :
  6.  Copyright : GPL v2
  7.  Ansi-style
  8.  ============================================================================
  9.  */

  11. #include <stdio.h>
  12. #include <stdlib.h>
  13. #include <string.h>
  14. #include "qqwry_parser.h"
  15. #include <iconv.h>


  18. int main(void) {
  19.     qqwry_parser_t parser = qqwry_init_parser("/root/QQWry.Dat", VERBOSE_ENABLE,
  20.             CACHE_ENABLE, 1);
  21.     qqwry_record qr = QQWARY_RECORD_INITIALIZER();
  22.     qqwry_querey_iprecord(parser, "61.172.201.195", &qr);
  23.     qqwry_release_parser(parser);
  24.     printf("big zone: %s, small zone: %s\n", qr.qr_bigzone, qr.qr_smallzone);
  25.     return EXIT_SUCCESS;
  26. }





阅读(5036) | 评论(0) | 转发(0) |
0

上一篇：3. Linux 内核开发 - 并发控制

下一篇：关于GCC的__attribute__(constructor)

给主人留下些什么吧！~~
关于我们 | 关于IT168 | 联系方式 | 广告合作 | 法律声明 | 免费注册

Copyright 2001-2010 ChinaUnix.net All Rights Reserved 北京皓辰网域网络信息技术有限公司. 版权所有

感谢所有关心和支持过ChinaUnix的朋友们

16024965号-6