Fix types and symbol names
This commit is contained in:
parent
3c55eaadbc
commit
5cd13fb03a
2 changed files with 108 additions and 136 deletions
|
|
@ -1,13 +1,7 @@
|
|||
#![allow(
|
||||
non_camel_case_types,
|
||||
non_snake_case,
|
||||
non_upper_case_globals,
|
||||
clippy::too_many_arguments
|
||||
)]
|
||||
#![allow(clippy::too_many_arguments)]
|
||||
|
||||
use std::{ffi::c_void, ptr};
|
||||
|
||||
type size_t = u64;
|
||||
#[derive(Copy, Clone)]
|
||||
#[repr(C)]
|
||||
struct TDivisor {
|
||||
|
|
@ -46,12 +40,12 @@ union C2RustUnnamed_3 {
|
|||
#[derive(Copy, Clone)]
|
||||
#[repr(C, packed)]
|
||||
struct C2RustUnnamed_4 {
|
||||
HardwareID: u64,
|
||||
ProductIDLow: u64,
|
||||
ProductIDHigh: u8,
|
||||
KeySHA1: u16,
|
||||
hardware_id: u64,
|
||||
product_id_low: u64,
|
||||
product_id_high: u8,
|
||||
key_sha1: u16,
|
||||
}
|
||||
static mut f: [u64; 6] = [
|
||||
static mut F: [u64; 6] = [
|
||||
0,
|
||||
0x21840136c85381,
|
||||
0x44197b83892ad0,
|
||||
|
|
@ -220,7 +214,7 @@ unsafe fn find_divisor_v(mut d: *mut TDivisor) -> i32 {
|
|||
let mut f2: [u64; 6] = [0; 6];
|
||||
let mut i: i32 = 0_i32;
|
||||
while i < 6_i32 {
|
||||
f2[i as usize] = f[i as usize];
|
||||
f2[i as usize] = F[i as usize];
|
||||
i += 1;
|
||||
}
|
||||
let u0: u64 = (*d).u[0_i32 as usize];
|
||||
|
|
@ -629,12 +623,12 @@ unsafe fn divisor_add(src1: *const TDivisor, src2: *const TDivisor, mut dst: *mu
|
|||
v[i as usize] = residue_mul(v[i as usize], c1[0_i32 as usize]);
|
||||
i += 1;
|
||||
}
|
||||
tmp[0] = f[0];
|
||||
tmp[1] = f[1];
|
||||
tmp[2] = f[2];
|
||||
tmp[3] = f[3];
|
||||
tmp[4] = f[4];
|
||||
tmp[5] = f[5];
|
||||
tmp[0] = F[0];
|
||||
tmp[1] = F[1];
|
||||
tmp[2] = F[2];
|
||||
tmp[3] = F[3];
|
||||
tmp[4] = F[4];
|
||||
tmp[5] = F[5];
|
||||
tmpdeg = 5_i32;
|
||||
tmpdeg = polynomial_mul(
|
||||
1_i32,
|
||||
|
|
@ -703,7 +697,7 @@ unsafe fn divisor_add(src1: *const TDivisor, src2: *const TDivisor, mut dst: *mu
|
|||
);
|
||||
i = 0_i32;
|
||||
while i <= tmpdeg && i <= 5_i32 {
|
||||
tmp[i as usize] = residue_sub(f[i as usize], tmp[i as usize]);
|
||||
tmp[i as usize] = residue_sub(F[i as usize], tmp[i as usize]);
|
||||
i += 1;
|
||||
}
|
||||
while i <= tmpdeg {
|
||||
|
|
@ -711,7 +705,7 @@ unsafe fn divisor_add(src1: *const TDivisor, src2: *const TDivisor, mut dst: *mu
|
|||
i += 1;
|
||||
}
|
||||
while i <= 5_i32 {
|
||||
tmp[i as usize] = f[i as usize];
|
||||
tmp[i as usize] = F[i as usize];
|
||||
i += 1;
|
||||
}
|
||||
tmpdeg = i - 1_i32;
|
||||
|
|
@ -824,32 +818,30 @@ unsafe fn sha1_single_block(input: *mut u8, output: *mut u8) {
|
|||
let mut d = 0x10325476_i32 as u32;
|
||||
let mut e = 0xc3d2e1f0_u32;
|
||||
let mut w: [u32; 80] = [0; 80];
|
||||
let mut i = 0_i32 as size_t;
|
||||
while i < 16_i32 as u64 {
|
||||
w[i as usize] = ((*input.offset((4_i32 as u64).wrapping_mul(i) as isize) as i32) << 24_i32
|
||||
| (*input.offset((4_i32 as u64).wrapping_mul(i).wrapping_add(1_i32 as u64) as isize)
|
||||
as i32)
|
||||
let mut i = 0_i32 as usize;
|
||||
while i < 16 {
|
||||
w[i as usize] = ((*input.offset((4 as usize).wrapping_mul(i) as isize) as i32) << 24_i32
|
||||
| (*input.offset((4 as usize).wrapping_mul(i).wrapping_add(1) as isize) as i32)
|
||||
<< 16_i32
|
||||
| (*input.offset((4_i32 as u64).wrapping_mul(i).wrapping_add(2_i32 as u64) as isize)
|
||||
as i32)
|
||||
| (*input.offset((4 as usize).wrapping_mul(i).wrapping_add(2) as isize) as i32)
|
||||
<< 8_i32
|
||||
| *input.offset((4_i32 as u64).wrapping_mul(i).wrapping_add(3_i32 as u64) as isize)
|
||||
as i32) as u32;
|
||||
| *input.offset((4 as usize).wrapping_mul(i).wrapping_add(3) as isize) as i32)
|
||||
as u32;
|
||||
i = i.wrapping_add(1);
|
||||
}
|
||||
i = 16_i32 as size_t;
|
||||
while i < 80_i32 as u64 {
|
||||
i = 16_i32 as usize;
|
||||
while i < 80 {
|
||||
w[i as usize] = rol(
|
||||
w[i.wrapping_sub(3_i32 as u64) as usize]
|
||||
^ w[i.wrapping_sub(8_i32 as u64) as usize]
|
||||
^ w[i.wrapping_sub(14_i32 as u64) as usize]
|
||||
^ w[i.wrapping_sub(16_i32 as u64) as usize],
|
||||
w[i.wrapping_sub(3) as usize]
|
||||
^ w[i.wrapping_sub(8) as usize]
|
||||
^ w[i.wrapping_sub(14) as usize]
|
||||
^ w[i.wrapping_sub(16) as usize],
|
||||
1_i32,
|
||||
);
|
||||
i = i.wrapping_add(1);
|
||||
}
|
||||
i = 0_i32 as size_t;
|
||||
while i < 20_i32 as u64 {
|
||||
i = 0_i32 as usize;
|
||||
while i < 20 {
|
||||
let tmp: u32 = (rol(a, 5_i32))
|
||||
.wrapping_add(b & c | !b & d)
|
||||
.wrapping_add(e)
|
||||
|
|
@ -862,8 +854,8 @@ unsafe fn sha1_single_block(input: *mut u8, output: *mut u8) {
|
|||
a = tmp;
|
||||
i = i.wrapping_add(1);
|
||||
}
|
||||
i = 20_i32 as size_t;
|
||||
while i < 40_i32 as u64 {
|
||||
i = 20_i32 as usize;
|
||||
while i < 40 {
|
||||
let tmp_0: u32 = (rol(a, 5_i32))
|
||||
.wrapping_add(b ^ c ^ d)
|
||||
.wrapping_add(e)
|
||||
|
|
@ -876,8 +868,8 @@ unsafe fn sha1_single_block(input: *mut u8, output: *mut u8) {
|
|||
a = tmp_0;
|
||||
i = i.wrapping_add(1);
|
||||
}
|
||||
i = 40_i32 as size_t;
|
||||
while i < 60_i32 as u64 {
|
||||
i = 40_i32 as usize;
|
||||
while i < 60 {
|
||||
let tmp_1: u32 = (rol(a, 5_i32))
|
||||
.wrapping_add(b & c | b & d | c & d)
|
||||
.wrapping_add(e)
|
||||
|
|
@ -890,8 +882,8 @@ unsafe fn sha1_single_block(input: *mut u8, output: *mut u8) {
|
|||
a = tmp_1;
|
||||
i = i.wrapping_add(1);
|
||||
}
|
||||
i = 60_i32 as size_t;
|
||||
while i < 80_i32 as u64 {
|
||||
i = 60_i32 as usize;
|
||||
while i < 80 {
|
||||
let tmp_2: u32 = (rol(a, 5_i32))
|
||||
.wrapping_add(b ^ c ^ d)
|
||||
.wrapping_add(e)
|
||||
|
|
@ -931,10 +923,10 @@ unsafe fn sha1_single_block(input: *mut u8, output: *mut u8) {
|
|||
*output.offset(19_i32 as isize) = e as u8;
|
||||
}
|
||||
|
||||
unsafe fn Mix(buffer: *mut u8, bufSize: size_t, key: *const u8, keySize: size_t) {
|
||||
unsafe fn mix(buffer: *mut u8, buf_size: usize, key: *const u8, key_size: usize) {
|
||||
let mut sha1_input: [u8; 64] = [0; 64];
|
||||
let mut sha1_result: [u8; 20] = [0; 20];
|
||||
let half: size_t = bufSize.wrapping_div(2_i32 as u64);
|
||||
let half: usize = buf_size.wrapping_div(2);
|
||||
let mut external_counter = 0_i32;
|
||||
while external_counter < 4_i32 {
|
||||
for n in &mut sha1_input {
|
||||
|
|
@ -948,27 +940,25 @@ unsafe fn Mix(buffer: *mut u8, bufSize: size_t, key: *const u8, keySize: size_t)
|
|||
ptr::copy_nonoverlapping(
|
||||
key as *const c_void,
|
||||
sha1_input.as_mut_ptr().offset(half as isize) as *mut c_void,
|
||||
keySize as usize,
|
||||
key_size as usize,
|
||||
);
|
||||
sha1_input[half.wrapping_add(keySize) as usize] = 0x80_i32 as u8;
|
||||
sha1_input[half.wrapping_add(key_size) as usize] = 0x80_i32 as u8;
|
||||
sha1_input
|
||||
[(::std::mem::size_of::<[u8; 64]>() as u64).wrapping_sub(1_i32 as u64) as usize] =
|
||||
half.wrapping_add(keySize).wrapping_mul(8_i32 as u64) as u8;
|
||||
half.wrapping_add(key_size).wrapping_mul(8) as u8;
|
||||
sha1_input
|
||||
[(::std::mem::size_of::<[u8; 64]>() as u64).wrapping_sub(2_i32 as u64) as usize] =
|
||||
half.wrapping_add(keySize)
|
||||
.wrapping_mul(8_i32 as u64)
|
||||
.wrapping_div(0x100_i32 as u64) as u8;
|
||||
half.wrapping_add(key_size)
|
||||
.wrapping_mul(8)
|
||||
.wrapping_div(0x100) as u8;
|
||||
sha1_single_block(sha1_input.as_mut_ptr(), sha1_result.as_mut_ptr());
|
||||
let mut i = half & !3_i32 as u64;
|
||||
let mut i = half & !3;
|
||||
while i < half {
|
||||
sha1_result[i as usize] = sha1_result[i
|
||||
.wrapping_add(4_i32 as u64)
|
||||
.wrapping_sub(half & 3_i32 as u64)
|
||||
as usize];
|
||||
sha1_result[i as usize] =
|
||||
sha1_result[i.wrapping_add(4).wrapping_sub(half & 3) as usize];
|
||||
i = i.wrapping_add(1);
|
||||
}
|
||||
i = 0_i32 as size_t;
|
||||
i = 0_i32 as usize;
|
||||
while i < half {
|
||||
let tmp: u8 = *buffer.offset(i.wrapping_add(half) as isize);
|
||||
*buffer.offset(i.wrapping_add(half) as isize) =
|
||||
|
|
@ -980,10 +970,10 @@ unsafe fn Mix(buffer: *mut u8, bufSize: size_t, key: *const u8, keySize: size_t)
|
|||
}
|
||||
}
|
||||
|
||||
unsafe fn Unmix(buffer: *mut u8, bufSize: size_t, key: *const u8, keySize: size_t) {
|
||||
unsafe fn unmix(buffer: *mut u8, buf_size: usize, key: *const u8, key_size: usize) {
|
||||
let mut sha1_input: [u8; 64] = [0; 64];
|
||||
let mut sha1_result: [u8; 20] = [0; 20];
|
||||
let half: size_t = bufSize.wrapping_div(2_i32 as u64);
|
||||
let half: usize = buf_size.wrapping_div(2);
|
||||
let mut external_counter = 0_i32;
|
||||
while external_counter < 4_i32 {
|
||||
for n in &mut sha1_input {
|
||||
|
|
@ -993,27 +983,25 @@ unsafe fn Unmix(buffer: *mut u8, bufSize: size_t, key: *const u8, keySize: size_
|
|||
ptr::copy_nonoverlapping(
|
||||
key,
|
||||
sha1_input.as_mut_ptr().offset(half as isize),
|
||||
keySize as usize,
|
||||
key_size as usize,
|
||||
);
|
||||
sha1_input[half.wrapping_add(keySize) as usize] = 0x80_i32 as u8;
|
||||
sha1_input[half.wrapping_add(key_size) as usize] = 0x80_i32 as u8;
|
||||
sha1_input
|
||||
[(::std::mem::size_of::<[u8; 64]>() as u64).wrapping_sub(1_i32 as u64) as usize] =
|
||||
half.wrapping_add(keySize).wrapping_mul(8_i32 as u64) as u8;
|
||||
half.wrapping_add(key_size).wrapping_mul(8) as u8;
|
||||
sha1_input
|
||||
[(::std::mem::size_of::<[u8; 64]>() as u64).wrapping_sub(2_i32 as u64) as usize] =
|
||||
half.wrapping_add(keySize)
|
||||
.wrapping_mul(8_i32 as u64)
|
||||
.wrapping_div(0x100_i32 as u64) as u8;
|
||||
half.wrapping_add(key_size)
|
||||
.wrapping_mul(8)
|
||||
.wrapping_div(0x100) as u8;
|
||||
sha1_single_block(sha1_input.as_mut_ptr(), sha1_result.as_mut_ptr());
|
||||
let mut i = half & !3_i32 as u64;
|
||||
let mut i = half & !3;
|
||||
while i < half {
|
||||
sha1_result[i as usize] = sha1_result[i
|
||||
.wrapping_add(4_i32 as u64)
|
||||
.wrapping_sub(half & 3_i32 as u64)
|
||||
as usize];
|
||||
sha1_result[i as usize] =
|
||||
sha1_result[i.wrapping_add(4).wrapping_sub(half & 3) as usize];
|
||||
i = i.wrapping_add(1);
|
||||
}
|
||||
i = 0_i32 as size_t;
|
||||
i = 0_i32 as usize;
|
||||
while i < half {
|
||||
let tmp: u8 = *buffer.offset(i as isize);
|
||||
*buffer.offset(i as isize) = (*buffer.offset(i.wrapping_add(half) as isize) as i32
|
||||
|
|
@ -1025,12 +1013,12 @@ unsafe fn Unmix(buffer: *mut u8, bufSize: size_t, key: *const u8, keySize: size_
|
|||
}
|
||||
}
|
||||
|
||||
pub unsafe fn Generate(installation_id_str: *const i8, confirmation_id: *mut i8) -> i32 {
|
||||
pub unsafe fn generate(installation_id_str: *const i8, confirmation_id: *mut i8) -> i32 {
|
||||
let mut installation_id: [u8; 19] = [0; 19]; // 10**45 < 256**19
|
||||
let mut installation_id_len: size_t = 0_i32 as size_t;
|
||||
let mut installation_id_len: usize = 0_i32 as usize;
|
||||
let mut p: *const i8 = installation_id_str;
|
||||
let mut count: size_t = 0_i32 as size_t;
|
||||
let mut totalCount: size_t = 0_i32 as size_t;
|
||||
let mut count: usize = 0_i32 as usize;
|
||||
let mut total_count: usize = 0_i32 as usize;
|
||||
let mut check: u32 = 0_i32 as u32;
|
||||
while *p != 0 {
|
||||
if !(*p as i32 == ' ' as i32 || *p as i32 == '-' as i32) {
|
||||
|
|
@ -1038,34 +1026,30 @@ pub unsafe fn Generate(installation_id_str: *const i8, confirmation_id: *mut i8)
|
|||
if !(0_i32..=9_i32).contains(&d) {
|
||||
return 3_i32;
|
||||
}
|
||||
if count == 5_i32 as u64 || *p.offset(1_i32 as isize) as i32 == 0_i32 {
|
||||
if count == 5 || *p.offset(1_i32 as isize) as i32 == 0_i32 {
|
||||
if count == 0 {
|
||||
return if totalCount == 45_i32 as u64 {
|
||||
2_i32
|
||||
} else {
|
||||
1_i32
|
||||
};
|
||||
return if total_count == 45 { 2_i32 } else { 1_i32 };
|
||||
}
|
||||
if d as u32 != check.wrapping_rem(7_i32 as u32) {
|
||||
return if count < 5_i32 as u64 { 1_i32 } else { 4_i32 };
|
||||
return if count < 5 { 1_i32 } else { 4_i32 };
|
||||
}
|
||||
check = 0_i32 as u32;
|
||||
count = 0_i32 as size_t;
|
||||
count = 0_i32 as usize;
|
||||
} else {
|
||||
check = check.wrapping_add(
|
||||
(if count.wrapping_rem(2_i32 as u64) != 0 {
|
||||
(if count.wrapping_rem(2) != 0 {
|
||||
d * 2_i32
|
||||
} else {
|
||||
d
|
||||
}) as u32,
|
||||
);
|
||||
count = count.wrapping_add(1);
|
||||
totalCount = totalCount.wrapping_add(1);
|
||||
if totalCount > 45_i32 as u64 {
|
||||
total_count = total_count.wrapping_add(1);
|
||||
if total_count > 45 {
|
||||
return 2_i32;
|
||||
}
|
||||
let mut carry: u8 = d as u8;
|
||||
let mut i = 0_i32 as size_t;
|
||||
let mut i = 0_i32 as usize;
|
||||
while i < installation_id_len {
|
||||
let x: u32 =
|
||||
(installation_id[i as usize] as i32 * 10_i32 + carry as i32) as u32;
|
||||
|
|
@ -1082,73 +1066,63 @@ pub unsafe fn Generate(installation_id_str: *const i8, confirmation_id: *mut i8)
|
|||
}
|
||||
p = p.offset(1);
|
||||
}
|
||||
if totalCount != 41_i32 as u64 && totalCount < 45_i32 as u64 {
|
||||
if total_count != 41 && total_count < 45 {
|
||||
return 1_i32;
|
||||
}
|
||||
while installation_id_len < ::std::mem::size_of::<[u8; 19]>() as u64 {
|
||||
while installation_id_len < ::std::mem::size_of::<[u8; 19]>() {
|
||||
installation_id[installation_id_len as usize] = 0_i32 as u8;
|
||||
installation_id_len = installation_id_len.wrapping_add(1);
|
||||
}
|
||||
static mut iid_key: [u8; 4] = [
|
||||
const IID_KEY: [u8; 4] = [
|
||||
0x6a_i32 as u8,
|
||||
0xc8_i32 as u8,
|
||||
0x5e_i32 as u8,
|
||||
0xd4_i32 as u8,
|
||||
];
|
||||
Unmix(
|
||||
unmix(
|
||||
installation_id.as_mut_ptr(),
|
||||
(if totalCount == 41_i32 as u64 {
|
||||
17_i32
|
||||
} else {
|
||||
19_i32
|
||||
}) as size_t,
|
||||
iid_key.as_ptr(),
|
||||
4_i32 as size_t,
|
||||
(if total_count == 41 { 17_i32 } else { 19_i32 }) as usize,
|
||||
IID_KEY.as_ptr(),
|
||||
4_i32 as usize,
|
||||
);
|
||||
if installation_id[18_i32 as usize] as i32 >= 0x10_i32 {
|
||||
return 5_i32;
|
||||
}
|
||||
let mut parsed: C2RustUnnamed_4 = C2RustUnnamed_4 {
|
||||
HardwareID: 0,
|
||||
ProductIDLow: 0,
|
||||
ProductIDHigh: 0,
|
||||
KeySHA1: 0,
|
||||
hardware_id: 0,
|
||||
product_id_low: 0,
|
||||
product_id_high: 0,
|
||||
key_sha1: 0,
|
||||
};
|
||||
ptr::copy_nonoverlapping(
|
||||
installation_id.as_mut_ptr() as *const c_void,
|
||||
&mut parsed as *mut C2RustUnnamed_4 as *mut c_void,
|
||||
std::mem::size_of::<C2RustUnnamed_4>(),
|
||||
);
|
||||
let productId1: u32 = (parsed.ProductIDLow & ((1_i32 << 17_i32) - 1_i32) as u64) as u32;
|
||||
let productId2: u32 =
|
||||
(parsed.ProductIDLow >> 17_i32 & ((1_i32 << 10_i32) - 1_i32) as u64) as u32;
|
||||
let productId3: u32 =
|
||||
(parsed.ProductIDLow >> 27_i32 & ((1_i32 << 25_i32) - 1_i32) as u64) as u32;
|
||||
let version: u32 = (parsed.ProductIDLow >> 52_i32 & 7_i32 as u64) as u32;
|
||||
let productId4: u32 =
|
||||
(parsed.ProductIDLow >> 55_i32 | ((parsed.ProductIDHigh as i32) << 9_i32) as u64) as u32;
|
||||
if version
|
||||
!= (if totalCount == 41_i32 as u64 {
|
||||
4_i32
|
||||
} else {
|
||||
5_i32
|
||||
}) as u32
|
||||
{
|
||||
let product_id_1: u32 = (parsed.product_id_low & ((1_i32 << 17_i32) - 1_i32) as u64) as u32;
|
||||
let product_id_2: u32 =
|
||||
(parsed.product_id_low >> 17_i32 & ((1_i32 << 10_i32) - 1_i32) as u64) as u32;
|
||||
let product_id_3: u32 =
|
||||
(parsed.product_id_low >> 27_i32 & ((1_i32 << 25_i32) - 1_i32) as u64) as u32;
|
||||
let version: u32 = (parsed.product_id_low >> 52_i32 & 7_i32 as u64) as u32;
|
||||
let product_id_4: u32 = (parsed.product_id_low >> 55_i32
|
||||
| ((parsed.product_id_high as i32) << 9_i32) as u64) as u32;
|
||||
if version != (if total_count == 41 { 4_i32 } else { 5_i32 }) as u32 {
|
||||
return 5_i32;
|
||||
}
|
||||
let mut keybuf: [u8; 16] = [0; 16];
|
||||
let mut hardware_id = parsed.HardwareID;
|
||||
let mut hardware_id = parsed.hardware_id;
|
||||
ptr::copy_nonoverlapping(
|
||||
&mut hardware_id as *mut u64 as *const c_void,
|
||||
keybuf.as_mut_ptr() as *mut c_void,
|
||||
8,
|
||||
);
|
||||
let mut productIdMixed: u64 = (productId1 as u64) << 41_i32
|
||||
| (productId2 as u64) << 58_i32
|
||||
| (productId3 as u64) << 17_i32
|
||||
| productId4 as u64;
|
||||
let mut product_id_mixed: u64 = (product_id_1 as u64) << 41_i32
|
||||
| (product_id_2 as u64) << 58_i32
|
||||
| (product_id_3 as u64) << 17_i32
|
||||
| product_id_4 as u64;
|
||||
ptr::copy_nonoverlapping(
|
||||
&mut productIdMixed as *mut u64 as *const c_void,
|
||||
&mut product_id_mixed as *mut u64 as *const c_void,
|
||||
keybuf.as_mut_ptr().offset(8) as *mut c_void,
|
||||
8,
|
||||
);
|
||||
|
|
@ -1162,11 +1136,11 @@ pub unsafe fn Generate(installation_id_str: *const i8, confirmation_id: *mut i8)
|
|||
u.c2rust_unnamed.lo = 0_i32 as u64;
|
||||
u.c2rust_unnamed.hi = 0_i32 as u64;
|
||||
u.buffer[7_i32 as usize] = attempt;
|
||||
Mix(
|
||||
mix(
|
||||
(u.buffer).as_mut_ptr(),
|
||||
14_i32 as size_t,
|
||||
14_i32 as usize,
|
||||
keybuf.as_mut_ptr(),
|
||||
16_i32 as size_t,
|
||||
16_i32 as usize,
|
||||
);
|
||||
let mut x2: u64 = ui128_quotient_mod(u.c2rust_unnamed.lo, u.c2rust_unnamed.hi);
|
||||
let x1: u64 = u.c2rust_unnamed.lo.wrapping_sub(x2.wrapping_mul(MOD));
|
||||
|
|
@ -1266,8 +1240,8 @@ pub unsafe fn Generate(installation_id_str: *const i8, confirmation_id: *mut i8)
|
|||
}
|
||||
}
|
||||
let mut decimal: [u8; 35] = [0; 35];
|
||||
let mut i = 0_i32 as size_t;
|
||||
while i < 35_i32 as u64 {
|
||||
let mut i = 0_i32 as usize;
|
||||
while i < 35 {
|
||||
let c: u32 = (e.c2rust_unnamed_0.encoded[3_i32 as usize]).wrapping_rem(10_i32 as u32);
|
||||
e.c2rust_unnamed_0.encoded[3_i32 as usize] =
|
||||
e.c2rust_unnamed_0.encoded[3_i32 as usize].wrapping_div(10_i32 as u32);
|
||||
|
|
@ -1286,20 +1260,18 @@ pub unsafe fn Generate(installation_id_str: *const i8, confirmation_id: *mut i8)
|
|||
e.c2rust_unnamed_0.encoded[0_i32 as usize] =
|
||||
((c3 as u64) << 32_i32 | e.c2rust_unnamed_0.encoded[0_i32 as usize] as u64)
|
||||
.wrapping_div(10_i32 as u64) as u32;
|
||||
decimal[(34_i32 as u64).wrapping_sub(i) as usize] = c4 as u8;
|
||||
decimal[(34 as usize).wrapping_sub(i) as usize] = c4 as u8;
|
||||
i = i.wrapping_add(1);
|
||||
}
|
||||
let mut q: *mut i8 = confirmation_id;
|
||||
i = 0_i32 as size_t;
|
||||
while i < 7_i32 as u64 {
|
||||
i = 0_i32 as usize;
|
||||
while i < 7 {
|
||||
if i != 0 {
|
||||
let fresh2 = q;
|
||||
q = q.offset(1);
|
||||
*fresh2 = '-' as i32 as i8;
|
||||
}
|
||||
let p_0: *mut u8 = decimal
|
||||
.as_mut_ptr()
|
||||
.offset(i.wrapping_mul(5_i32 as u64) as isize);
|
||||
let p_0: *mut u8 = decimal.as_mut_ptr().offset(i.wrapping_mul(5) as isize);
|
||||
*q.offset(0_i32 as isize) = (*p_0.offset(0_i32 as isize) as i32 + '0' as i32) as i8;
|
||||
*q.offset(1_i32 as isize) = (*p_0.offset(1_i32 as isize) as i32 + '0' as i32) as i8;
|
||||
*q.offset(2_i32 as isize) = (*p_0.offset(2_i32 as isize) as i32 + '0' as i32) as i8;
|
||||
|
|
|
|||
|
|
@ -23,7 +23,7 @@ pub enum ConfirmationIdError {
|
|||
pub fn generate(installation_id: &str) -> Result<String, ConfirmationIdError> {
|
||||
let inst_id = CString::new(installation_id).unwrap();
|
||||
let conf_id = [0u8; 49];
|
||||
let result = unsafe { black_box::Generate(inst_id.as_ptr(), conf_id.as_ptr() as *mut i8) };
|
||||
let result = unsafe { black_box::generate(inst_id.as_ptr(), conf_id.as_ptr() as *mut i8) };
|
||||
match result {
|
||||
0 => {}
|
||||
1 => return Err(ConfirmationIdError::TooShort),
|
||||
|
|
|
|||
Loading…
Add table
Reference in a new issue