qqwry

https://docs.rs/qqwry
Admin
qqwry is a Rust library for reading IP geolocation information from QQwry binary database files,...
Tokens:3,542
Snippets:41
Trust Score:9.1
Update:5 months ago
Show doc for...
Tokens:
Raw
### Get Start IP Address String

Source: https://docs.rs/qqwry/latest/qqwry/qqwry/struct.IPLocation.html

Retrieves the starting IP address of the location range as a formatted string.

```rust
pub fn get_start_ip_str(&self) -> String
```

--------------------------------

### IPLocation Methods

Source: https://docs.rs/qqwry/latest/qqwry/qqwry/struct.IPLocation.html

Provides methods to retrieve the start and end IP addresses as strings from the IPLocation struct.

```APIDOC
## impl IPLocation

### pub fn get_start_ip_str(&self) -> String

Retrieves the start IP address as a formatted string.

### pub fn get_end_ip_str(&self) -> String

Retrieves the end IP address as a formatted string.
```

--------------------------------

### Get End IP Address String

Source: https://docs.rs/qqwry/latest/qqwry/qqwry/struct.IPLocation.html

Retrieves the ending IP address of the location range as a formatted string.

```rust
pub fn get_end_ip_str(&self) -> String
```

--------------------------------

### Define IPLocation struct and methods

Source: https://docs.rs/qqwry/latest/src/qqwry/qqwry.rs.html

Defines the IPLocation struct to hold geographical information for an IP address and provides methods to convert start and end IP addresses to string format.

```rust
#[derive(Debug)]
pub struct IPLocation {
    pub index_offset: u32,
    pub record_offset: u32,
    pub start_ip: u32,
    pub end_ip:u32,
    pub country: String,
    pub area:String
}
impl IPLocation {
    pub fn get_start_ip_str(&self)->String{
        u32_to_ip(self.start_ip)
    }
    pub fn get_end_ip_str(&self)->String{
        u32_to_ip(self.end_ip)
    }
}
```

--------------------------------

### Type ID Method

Source: https://docs.rs/qqwry/latest/qqwry/qqwry/struct.QQWry.html

Gets the TypeId of the QQWry struct. This is part of the Any trait implementation.

```rust
fn type_id(&self) -> TypeId
```

--------------------------------

### Test IP Location Lookup in Rust

Source: https://docs.rs/qqwry/latest/src/qqwry/lib.rs.html

Demonstrates how to initialize the QQWry reader with a file path and perform an IP location lookup. Includes printing the location details and IP range strings.

```rust
1#[cfg(test)]
2mod tests {
3    use crate::qqwry;
4    #[test]
5    fn it_works() {
6       let mut wry = qqwry::QQWry::from(String::from("/Users/zfh/Documents/qqwry.dat"));
7       let location = wry.read_ip_location("255.255.255.255").unwrap();
8        println!("{:#?},start_ip:{},end_ip:{}",location,location.get_start_ip_str(),location.get_end_ip_str());
9    }
10}
```

--------------------------------

### QQWry::from

Source: https://docs.rs/qqwry/latest/qqwry/qqwry/struct.QQWry.html

Creates a new QQWry instance from a file path.

```APIDOC
## pub fn from(file: String) -> QQWry

### Description
Creates a new QQWry instance by initializing it with the provided file path.

### Parameters
* **file** (String) - The path to the QQWry database file.
```

--------------------------------

### QQWry Constructor

Source: https://docs.rs/qqwry/latest/qqwry/qqwry/struct.QQWry.html

Creates a new QQWry instance with the specified file path. Use this to initialize the QQWry reader.

```rust
pub fn from(file: String) -> QQWry
```

--------------------------------

### Implement QQWry struct methods

Source: https://docs.rs/qqwry/latest/src/qqwry/qqwry.rs.html

Implements methods for the QQWry struct, including a constructor and a function to read IP location information from a given IP address.

```rust
impl QQWry {
    pub fn from(file:  String) -> QQWry {
        QQWry {
            file
        }
    }
    /**
    * 读取IP信息
    */
    pub fn read_ip_location(&mut self,ip: &str) -> Option<IPLocation> {
        let ip = ip_to_u32(ip);
        let mut file = File::open(&mut self.file).unwrap();
        let  mut  b4:[u8;4]=[0,0,0,0];
        let  mut  b3:[u8;3]=[0,0,0];
        let  mut  _b1:[u8;1]=[0];

        file.read(&mut b4).unwrap();
        let  first_index_offset:u32 = tou32(&mut b4);

```

--------------------------------

### Binary Search for IP Location

Source: https://docs.rs/qqwry/latest/src/qqwry/qqwry.rs.html

Implements a binary search algorithm to find the IP location record within the Qqwry database. It handles edge cases and ensures accurate retrieval based on the input IP address.

```rust
file.read(&mut b4).unwrap();
        let  last_index_offset:u32 = tou32(&mut b4);
        let total_index_records = (last_index_offset-first_index_offset)/7+1;
        let mut i:u32=0;
        let mut right_edge = false;
        let mut result: Option<IPLocation> = None;
        loop {
            let index_offset = first_index_offset+i*7;
            file.seek(SeekFrom::Start(index_offset as u64)).expect("read file error");
            file.read(&mut b4).expect("read file error");
            file.read(&mut b3).expect("read file error");

            let  start_ip = tou32(&mut b4);
            if ip == start_ip {
                let mut record_idx = tou32(&mut b3);
                let mut location = read_location(&mut file, &mut record_idx);
                location.index_offset = index_offset;
                location.start_ip = start_ip;
                result = Some(location);
                break;
            }
            if right_edge || (i+1 == total_index_records) {
                let mut record_idx = tou32(&mut b3);
                let mut location = read_location(&mut file, &mut record_idx);
                if ip<=location.end_ip {
                    location.index_offset = index_offset;
                    location.start_ip = start_ip;
                    result = Some(location);
                }
                break;
            }
            if ip < start_ip {
                i-=1;
                right_edge = true;
                continue;
            }

            i = i+1;
        }
        return result
    }
}
```

--------------------------------

### Define QQWry struct and helper functions

Source: https://docs.rs/qqwry/latest/src/qqwry/qqwry.rs.html

Defines the main QQWry struct and utility functions for byte-to-integer conversion, IP address string conversion, and reading data from files.

```rust
use std::fs::File;
use std::io::{Read, Seek, SeekFrom};

pub struct QQWry {
    pub file:String
}
fn tou32(buf:&mut [u8])->u32{
    let b1:u32 = buf[0] as u32 & 0xFF;
    let b2:u32 = buf[1] as u32 & 0xFF;
    let b3:u32 = buf[2] as u32 & 0xFF;
    if buf.len()==4 {
        let b4:u32 = buf[3] as u32 & 0xFF;
        b4<<24|b3<<16|b2<<8|b1
    }else{
        b3<<16|b2<<8|b1
    }
}
fn ip_to_u32(ip:&str) -> u32{
    let k = ip.split(".").enumerate();
    let mut buf = vec![];
    for (_,item) in k {
        let no = item.parse::<u8>().unwrap();
        buf.push(no);
    }
    buf.reverse();
    return tou32(&mut buf);
}
fn u32_to_ip(ip:u32)->String{
    format!("{}.{}.{}.{}",ip>>24 & 0xFF,ip>>16 & 0xFF,ip>>8 & 0xFF,ip>>0 & 0xFF)
}
fn read_as_string(file: &mut File) -> String{
    let  mut  _b1:[u8;1]=[0];
    let mut v: Vec<u8> = Vec::new();
    let mut len:u32=0;
    loop {
        file.read(&mut _b1).expect("read file error");
        len=len+1;
        if _b1[0]==('\0' as u8) {
            break;
        }
        v.push(_b1[0]);
    }
    let str = textcode::gb2312::decode_to_string(&v);
    return str;
}
fn read_as_area(file: &mut File) -> String{
    let  mut  _b1:[u8;1]=[0];
    let  mut  b3:[u8;3]=[0;3];
    file.read(&mut _b1).expect("read file error");
    if _b1[0] == 0x01 || _b1[0] == 0x02 {
        file.read(&mut b3).expect("error");
        let data_offset = tou32(&mut b3);
        if data_offset == 0 {
            return String::from("unknown.area");
        }
        file.seek(SeekFrom::Start(data_offset as u64)).expect("read file error");
        return read_as_string(file);
    }else{
        file.seek(SeekFrom::Current(-1)).expect("read file error");
        return read_as_string(file);
    }
}
fn read_location(file:&mut File, record_offset: &mut u32) ->IPLocation {
    let mut location:IPLocation = IPLocation {
        index_offset: 0,
        start_ip:0,
        end_ip: 0,
        record_offset: *record_offset,
        country: String::from(""),
        area: String::from("")
    };
    let  mut  b4:[u8;4]=[0;4];
    let  mut  b3:[u8;3]=[0;3];
    let  mut  _b1:[u8;1]=[0];

    file.seek(SeekFrom::Start(*record_offset as u64)).expect("read file error");
    file.read(&mut b4).expect("read file error");
    location.end_ip = tou32(&mut b4);

    file.read(&mut _b1).expect("read file error");
    if _b1[0] == 0x01 || _b1[0] == 0x02{
        file.read(&mut b3).expect("read file error");
        let data_offset = tou32(&mut b3);
        file.seek(SeekFrom::Start(data_offset as u64)).expect("read file error");
        if _b1[0] == 0x01 {
            file.read(&mut _b1).expect("read file error");
            let area_offset:u64;
            if _b1[0] == 0x02 {
                area_offset = (data_offset+4) as u64;
                file.read(&mut b3).expect("read file error");
                let data_offset = tou32(&mut b3);
                file.seek(SeekFrom::Start(data_offset as u64)).expect("read file error");
                location.country = read_as_string(file);
            }else{
                file.seek(SeekFrom::Current(-1)).expect("read file error");
                location.country = read_as_string(file);
                area_offset = file.stream_position().unwrap();
            }
            file.seek(SeekFrom::Start(area_offset)).expect("read file error");
            location.area = read_as_area(file);
        } else {
            location.country = read_as_string(file);
            location.area = read_as_area(file);
        }

    }else{
        file.seek(SeekFrom::Current(-1)).expect("read file error");
        location.country = read_as_string(file);
        location.area = read_as_area(file);
    }
    location
}

```

--------------------------------

### Read IP Location

Source: https://docs.rs/qqwry/latest/qqwry/qqwry/struct.QQWry.html

Reads the IP location information from the QQWry database for a given IP address. Returns None if the IP is not found.

```rust
pub fn read_ip_location(&mut self, ip: &str) -> Option<IPLocation>
```

--------------------------------

### QQWry Struct Definition

Source: https://docs.rs/qqwry/latest/qqwry/qqwry/struct.QQWry.html

Defines the QQWry struct, which holds the file path to the QQWry database.

```rust
pub struct QQWry {
    pub file: String,
}
```

--------------------------------

### From Conversion

Source: https://docs.rs/qqwry/latest/qqwry/qqwry/struct.QQWry.html

Returns the argument unchanged. This is part of the From trait implementation.

```rust
fn from(t: T) -> T
```

--------------------------------

### QQWry::read_ip_location

Source: https://docs.rs/qqwry/latest/qqwry/qqwry/struct.QQWry.html

Reads the IP location information from the QQWry database.

```APIDOC
## pub fn read_ip_location(&mut self, ip: &str) -> Option<IPLocation>

### Description
Reads and returns the IP location information for a given IP address from the QQWry database. Returns `None` if the IP address is not found or an error occurs.

### Parameters
* **ip** (&str) - The IP address to look up.

### Returns
* `Option<IPLocation>` - An `Option` containing the `IPLocation` if found, otherwise `None`.
```

--------------------------------

### Borrow Method

Source: https://docs.rs/qqwry/latest/qqwry/qqwry/struct.QQWry.html

Immutably borrows the QQWry struct. This is part of the Borrow trait implementation.

```rust
fn borrow(&self) -> &T
```

--------------------------------

### Into Conversion

Source: https://docs.rs/qqwry/latest/qqwry/qqwry/struct.QQWry.html

Calls U::from(self) to perform the conversion. This is part of the Into trait implementation.

```rust
fn into(self) -> U
```

--------------------------------

### Borrow Mut Method

Source: https://docs.rs/qqwry/latest/qqwry/qqwry/struct.QQWry.html

Mutably borrows the QQWry struct. This is part of the BorrowMut trait implementation.

```rust
fn borrow_mut(&mut self) -> &mut T
```

--------------------------------

### IPLocation Struct Definition

Source: https://docs.rs/qqwry/latest/qqwry/qqwry/struct.IPLocation.html

Defines the structure for storing IP location data, including IP address ranges, country, and area information.

```rust
pub struct IPLocation {
    pub index_offset: u32,
    pub record_offset: u32,
    pub start_ip: u32,
    pub end_ip: u32,
    pub country: String,
    pub area: String,
}
```

--------------------------------

### IPLocation Struct Definition

Source: https://docs.rs/qqwry/latest/qqwry/qqwry/struct.IPLocation.html

Defines the structure of IPLocation, which holds details about an IP address's geographical location.

```APIDOC
## Struct IPLocation

### Fields

- `index_offset`: u32
- `record_offset`: u32
- `start_ip`: u32
- `end_ip`: u32
- `country`: String
- `area`: String
```

--------------------------------

### TryFrom Conversion

Source: https://docs.rs/qqwry/latest/qqwry/qqwry/struct.QQWry.html

Performs the conversion from U to T. This is part of the TryFrom trait implementation.

```rust
fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>
```

--------------------------------

### TryInto Conversion

Source: https://docs.rs/qqwry/latest/qqwry/qqwry/struct.QQWry.html

Performs the conversion from T to U. This is part of the TryInto trait implementation.

```rust
fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>
```
Tokens:
Raw