pub fn validate_address_fedex(
    fedex_settings: FedexSettings,
    va: ValidateFedexAddresses,
    test: bool,
) -> AddressValidationResult {
    let (c_key, c_pass) = if !test {
        (
            fedex_settings.credential_key,
            fedex_settings.credential_pass,
        )
    } else {
        (
            fedex_settings.test_credential_key,
            fedex_settings.test_credential_pass,
        )
    };

    let mut uc = ns2__WebAuthenticationCredential {
        Key: str_as_mut_ptr!(c_key),
        Password: str_as_mut_ptr!(c_pass),
    };

    let mut wad = ns2__WebAuthenticationDetail {
        ParentCredential: null_mut_ptr!(ns2__WebAuthenticationCredential),
        UserCredential: item_as_mut_ptr!(uc, ns2__WebAuthenticationCredential),
    };

    let (an, mn) = if !test {
        (fedex_settings.accountnumber, fedex_settings.meternumber)
    } else {
        (
            fedex_settings.test_accountnumber,
            fedex_settings.test_meternumber,
        )
    };

    let mut cd = ns2__ClientDetail {
        AccountNumber: str_as_mut_ptr!(an),
        MeterNumber: str_as_mut_ptr!(mn),
        IntegratorId: null_mut_ptr!(i8),
        Localization: null_mut_ptr!(ns2__Localization),
    };

    let now = Utc::now();
    let mut seconds: i64 = now.timestamp() as i64; // NOTE: diff for windows

    let mut td = ns2__TransactionDetail {
        CustomerTransactionId: str_as_mut_ptr!("Address Validation Request"),
        Localization: null_mut_ptr!(ns2__Localization),
    };

    let mut v = ns2__VersionId {
        ServiceId: str_as_mut_ptr!("aval"),
        Major: 4 as libc::c_int,
        Intermediate: 0 as libc::c_int,
        Minor: 0 as libc::c_int,
    };

    let mut adrs = vec![];
    for address in va.addresses.into_iter() {
        let street_lines_len = address.street_lines.len();
        let mut street_lines = vec![];

        for sl in address.street_lines.into_iter() {
            street_lines.push(str_as_mut_ptr!(sl));
        }

        let state_or_province_code = match address.state_or_province_code {
            Some(_state_or_province_code) => str_as_mut_ptr!(_state_or_province_code),
            None => str_as_mut_ptr!("".to_owned()),
        };

        let urbanization_code = match address.urbanization_code {
            Some(_urbanization_code) => str_as_mut_ptr!(_urbanization_code),
            None => str_as_mut_ptr!("".to_owned()),
        };

        let country_name = match address.country_name {
            Some(_country_name) => str_as_mut_ptr!(_country_name),
            None => str_as_mut_ptr!("".to_owned()),
        };

        let mut adr = ns2__Address {
            __sizeStreetLines: street_lines_len as libc::c_int,
            StreetLines: street_lines.as_mut_ptr(),
            City: str_as_mut_ptr!(address.city),
            StateOrProvinceCode: state_or_province_code,
            PostalCode: str_as_mut_ptr!(address.postal_code),
            UrbanizationCode: urbanization_code,
            CountryCode: str_as_mut_ptr!(address.country_code),
            CountryName: country_name,
            Residential: null_mut_ptr!(xsd__boolean), // NOTE: some day, if needed
        };

        std::mem::forget(street_lines);

        adrs.push(ns2__AddressToValidate {
            ClientReferenceId: str_as_mut_ptr!(address.reference_id),
            Contact: null_mut_ptr!(ns2__Contact),
            Address: item_as_mut_ptr!(adr, ns2__Address),
        });
    }

    let addrsss_ptr = ptr_mut_array!(adrs, ns2__AddressToValidate);

    for i in 0..adrs.len() {
        unsafe { addrsss_ptr.offset(i as isize).write(adrs[i]) };
    }

    let mut vr = ns2__AddressValidationRequest {
        WebAuthenticationDetail: item_as_mut_ptr!(wad, ns2__WebAuthenticationDetail),
        ClientDetail: item_as_mut_ptr!(cd, ns2__ClientDetail),
        InEffectAsOfTimestamp: item_as_mut_ptr!(seconds, ::std::os::raw::c_long),
        TransactionDetail: item_as_mut_ptr!(td, ns2__TransactionDetail),
        Version: item_as_mut_ptr!(v, ns2__VersionId),
        __sizeAddressesToValidate: adrs.len() as libc::c_int,
        AddressesToValidate: addrsss_ptr as *mut ns2__AddressToValidate,
    };

    let vt_ptr = item_as_mut_ptr!(vr, ns2__AddressValidationRequest);
    std::mem::forget(vr);

    let soap = unsafe { create_soap() };

    let base_url = if !test {
        fedex_settings.url
    } else {
        fedex_settings.test_url
    };

    let output: ns2__AddressValidationReply =
        unsafe { validate_address(soap, CString::new(base_url).unwrap().as_ptr(), vt_ptr) };
    //...
}