mirror of
https://github.com/OMGeeky/google-apis-rs.git
synced 2026-01-01 00:51:17 +01:00
963 lines
46 KiB
Rust
963 lines
46 KiB
Rust
// DO NOT EDIT !
|
||
// This file was generated automatically from 'src/mako/cli/main.rs.mako'
|
||
// DO NOT EDIT !
|
||
#![allow(unused_variables, unused_imports, dead_code, unused_mut)]
|
||
|
||
extern crate tokio;
|
||
|
||
#[macro_use]
|
||
extern crate clap;
|
||
extern crate yup_oauth2 as oauth2;
|
||
|
||
use std::env;
|
||
use std::io::{self, Write};
|
||
use clap::{App, SubCommand, Arg};
|
||
|
||
use google_safebrowsing4::{api, Error};
|
||
|
||
mod client;
|
||
|
||
use client::{InvalidOptionsError, CLIError, arg_from_str, writer_from_opts, parse_kv_arg,
|
||
input_file_from_opts, input_mime_from_opts, FieldCursor, FieldError, CallType, UploadProtocol,
|
||
calltype_from_str, remove_json_null_values, ComplexType, JsonType, JsonTypeInfo};
|
||
|
||
use std::default::Default;
|
||
use std::str::FromStr;
|
||
|
||
use serde_json as json;
|
||
use clap::ArgMatches;
|
||
|
||
enum DoitError {
|
||
IoError(String, io::Error),
|
||
ApiError(Error),
|
||
}
|
||
|
||
struct Engine<'n> {
|
||
opt: ArgMatches<'n>,
|
||
hub: api::Safebrowsing,
|
||
gp: Vec<&'static str>,
|
||
gpm: Vec<(&'static str, &'static str)>,
|
||
}
|
||
|
||
|
||
impl<'n> Engine<'n> {
|
||
async fn _encoded_full_hashes_get(&self, opt: &ArgMatches<'n>, dry_run: bool, err: &mut InvalidOptionsError)
|
||
-> Result<(), DoitError> {
|
||
let mut call = self.hub.encoded_full_hashes().get(opt.value_of("encoded-request").unwrap_or(""));
|
||
for parg in opt.values_of("v").map(|i|i.collect()).unwrap_or(Vec::new()).iter() {
|
||
let (key, value) = parse_kv_arg(&*parg, err, false);
|
||
match key {
|
||
"client-version" => {
|
||
call = call.client_version(value.unwrap_or(""));
|
||
},
|
||
"client-id" => {
|
||
call = call.client_id(value.unwrap_or(""));
|
||
},
|
||
_ => {
|
||
let mut found = false;
|
||
for param in &self.gp {
|
||
if key == *param {
|
||
found = true;
|
||
call = call.param(self.gpm.iter().find(|t| t.0 == key).unwrap_or(&("", key)).1, value.unwrap_or("unset"));
|
||
break;
|
||
}
|
||
}
|
||
if !found {
|
||
err.issues.push(CLIError::UnknownParameter(key.to_string(),
|
||
{let mut v = Vec::new();
|
||
v.extend(self.gp.iter().map(|v|*v));
|
||
v.extend(["client-id", "client-version"].iter().map(|v|*v));
|
||
v } ));
|
||
}
|
||
}
|
||
}
|
||
}
|
||
let protocol = CallType::Standard;
|
||
if dry_run {
|
||
Ok(())
|
||
} else {
|
||
assert!(err.issues.len() == 0);
|
||
let mut ostream = match writer_from_opts(opt.value_of("out")) {
|
||
Ok(mut f) => f,
|
||
Err(io_err) => return Err(DoitError::IoError(opt.value_of("out").unwrap_or("-").to_string(), io_err)),
|
||
};
|
||
match match protocol {
|
||
CallType::Standard => call.doit().await,
|
||
_ => unreachable!()
|
||
} {
|
||
Err(api_err) => Err(DoitError::ApiError(api_err)),
|
||
Ok((mut response, output_schema)) => {
|
||
let mut value = json::value::to_value(&output_schema).expect("serde to work");
|
||
remove_json_null_values(&mut value);
|
||
json::to_writer_pretty(&mut ostream, &value).unwrap();
|
||
ostream.flush().unwrap();
|
||
Ok(())
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
async fn _encoded_updates_get(&self, opt: &ArgMatches<'n>, dry_run: bool, err: &mut InvalidOptionsError)
|
||
-> Result<(), DoitError> {
|
||
let mut call = self.hub.encoded_updates().get(opt.value_of("encoded-request").unwrap_or(""));
|
||
for parg in opt.values_of("v").map(|i|i.collect()).unwrap_or(Vec::new()).iter() {
|
||
let (key, value) = parse_kv_arg(&*parg, err, false);
|
||
match key {
|
||
"client-version" => {
|
||
call = call.client_version(value.unwrap_or(""));
|
||
},
|
||
"client-id" => {
|
||
call = call.client_id(value.unwrap_or(""));
|
||
},
|
||
_ => {
|
||
let mut found = false;
|
||
for param in &self.gp {
|
||
if key == *param {
|
||
found = true;
|
||
call = call.param(self.gpm.iter().find(|t| t.0 == key).unwrap_or(&("", key)).1, value.unwrap_or("unset"));
|
||
break;
|
||
}
|
||
}
|
||
if !found {
|
||
err.issues.push(CLIError::UnknownParameter(key.to_string(),
|
||
{let mut v = Vec::new();
|
||
v.extend(self.gp.iter().map(|v|*v));
|
||
v.extend(["client-id", "client-version"].iter().map(|v|*v));
|
||
v } ));
|
||
}
|
||
}
|
||
}
|
||
}
|
||
let protocol = CallType::Standard;
|
||
if dry_run {
|
||
Ok(())
|
||
} else {
|
||
assert!(err.issues.len() == 0);
|
||
let mut ostream = match writer_from_opts(opt.value_of("out")) {
|
||
Ok(mut f) => f,
|
||
Err(io_err) => return Err(DoitError::IoError(opt.value_of("out").unwrap_or("-").to_string(), io_err)),
|
||
};
|
||
match match protocol {
|
||
CallType::Standard => call.doit().await,
|
||
_ => unreachable!()
|
||
} {
|
||
Err(api_err) => Err(DoitError::ApiError(api_err)),
|
||
Ok((mut response, output_schema)) => {
|
||
let mut value = json::value::to_value(&output_schema).expect("serde to work");
|
||
remove_json_null_values(&mut value);
|
||
json::to_writer_pretty(&mut ostream, &value).unwrap();
|
||
ostream.flush().unwrap();
|
||
Ok(())
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
async fn _full_hashes_find(&self, opt: &ArgMatches<'n>, dry_run: bool, err: &mut InvalidOptionsError)
|
||
-> Result<(), DoitError> {
|
||
|
||
let mut field_cursor = FieldCursor::default();
|
||
let mut object = json::value::Value::Object(Default::default());
|
||
|
||
for kvarg in opt.values_of("kv").map(|i|i.collect()).unwrap_or(Vec::new()).iter() {
|
||
let last_errc = err.issues.len();
|
||
let (key, value) = parse_kv_arg(&*kvarg, err, false);
|
||
let mut temp_cursor = field_cursor.clone();
|
||
if let Err(field_err) = temp_cursor.set(&*key) {
|
||
err.issues.push(field_err);
|
||
}
|
||
if value.is_none() {
|
||
field_cursor = temp_cursor.clone();
|
||
if err.issues.len() > last_errc {
|
||
err.issues.remove(last_errc);
|
||
}
|
||
continue;
|
||
}
|
||
|
||
let type_info: Option<(&'static str, JsonTypeInfo)> =
|
||
match &temp_cursor.to_string()[..] {
|
||
"api-client.client-id" => Some(("apiClient.clientId", JsonTypeInfo { jtype: JsonType::String, ctype: ComplexType::Pod })),
|
||
"api-client.client-version" => Some(("apiClient.clientVersion", JsonTypeInfo { jtype: JsonType::String, ctype: ComplexType::Pod })),
|
||
"client.client-id" => Some(("client.clientId", JsonTypeInfo { jtype: JsonType::String, ctype: ComplexType::Pod })),
|
||
"client.client-version" => Some(("client.clientVersion", JsonTypeInfo { jtype: JsonType::String, ctype: ComplexType::Pod })),
|
||
"client-states" => Some(("clientStates", JsonTypeInfo { jtype: JsonType::String, ctype: ComplexType::Vec })),
|
||
"threat-info.platform-types" => Some(("threatInfo.platformTypes", JsonTypeInfo { jtype: JsonType::String, ctype: ComplexType::Vec })),
|
||
"threat-info.threat-entry-types" => Some(("threatInfo.threatEntryTypes", JsonTypeInfo { jtype: JsonType::String, ctype: ComplexType::Vec })),
|
||
"threat-info.threat-types" => Some(("threatInfo.threatTypes", JsonTypeInfo { jtype: JsonType::String, ctype: ComplexType::Vec })),
|
||
_ => {
|
||
let suggestion = FieldCursor::did_you_mean(key, &vec!["api-client", "client", "client-id", "client-states", "client-version", "platform-types", "threat-entry-types", "threat-info", "threat-types"]);
|
||
err.issues.push(CLIError::Field(FieldError::Unknown(temp_cursor.to_string(), suggestion, value.map(|v| v.to_string()))));
|
||
None
|
||
}
|
||
};
|
||
if let Some((field_cursor_str, type_info)) = type_info {
|
||
FieldCursor::from(field_cursor_str).set_json_value(&mut object, value.unwrap(), type_info, err, &temp_cursor);
|
||
}
|
||
}
|
||
let mut request: api::GoogleSecuritySafebrowsingV4FindFullHashesRequest = json::value::from_value(object).unwrap();
|
||
let mut call = self.hub.full_hashes().find(request);
|
||
for parg in opt.values_of("v").map(|i|i.collect()).unwrap_or(Vec::new()).iter() {
|
||
let (key, value) = parse_kv_arg(&*parg, err, false);
|
||
match key {
|
||
_ => {
|
||
let mut found = false;
|
||
for param in &self.gp {
|
||
if key == *param {
|
||
found = true;
|
||
call = call.param(self.gpm.iter().find(|t| t.0 == key).unwrap_or(&("", key)).1, value.unwrap_or("unset"));
|
||
break;
|
||
}
|
||
}
|
||
if !found {
|
||
err.issues.push(CLIError::UnknownParameter(key.to_string(),
|
||
{let mut v = Vec::new();
|
||
v.extend(self.gp.iter().map(|v|*v));
|
||
v } ));
|
||
}
|
||
}
|
||
}
|
||
}
|
||
let protocol = CallType::Standard;
|
||
if dry_run {
|
||
Ok(())
|
||
} else {
|
||
assert!(err.issues.len() == 0);
|
||
let mut ostream = match writer_from_opts(opt.value_of("out")) {
|
||
Ok(mut f) => f,
|
||
Err(io_err) => return Err(DoitError::IoError(opt.value_of("out").unwrap_or("-").to_string(), io_err)),
|
||
};
|
||
match match protocol {
|
||
CallType::Standard => call.doit().await,
|
||
_ => unreachable!()
|
||
} {
|
||
Err(api_err) => Err(DoitError::ApiError(api_err)),
|
||
Ok((mut response, output_schema)) => {
|
||
let mut value = json::value::to_value(&output_schema).expect("serde to work");
|
||
remove_json_null_values(&mut value);
|
||
json::to_writer_pretty(&mut ostream, &value).unwrap();
|
||
ostream.flush().unwrap();
|
||
Ok(())
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
async fn _threat_hits_create(&self, opt: &ArgMatches<'n>, dry_run: bool, err: &mut InvalidOptionsError)
|
||
-> Result<(), DoitError> {
|
||
|
||
let mut field_cursor = FieldCursor::default();
|
||
let mut object = json::value::Value::Object(Default::default());
|
||
|
||
for kvarg in opt.values_of("kv").map(|i|i.collect()).unwrap_or(Vec::new()).iter() {
|
||
let last_errc = err.issues.len();
|
||
let (key, value) = parse_kv_arg(&*kvarg, err, false);
|
||
let mut temp_cursor = field_cursor.clone();
|
||
if let Err(field_err) = temp_cursor.set(&*key) {
|
||
err.issues.push(field_err);
|
||
}
|
||
if value.is_none() {
|
||
field_cursor = temp_cursor.clone();
|
||
if err.issues.len() > last_errc {
|
||
err.issues.remove(last_errc);
|
||
}
|
||
continue;
|
||
}
|
||
|
||
let type_info: Option<(&'static str, JsonTypeInfo)> =
|
||
match &temp_cursor.to_string()[..] {
|
||
"client-info.client-id" => Some(("clientInfo.clientId", JsonTypeInfo { jtype: JsonType::String, ctype: ComplexType::Pod })),
|
||
"client-info.client-version" => Some(("clientInfo.clientVersion", JsonTypeInfo { jtype: JsonType::String, ctype: ComplexType::Pod })),
|
||
"entry.digest" => Some(("entry.digest", JsonTypeInfo { jtype: JsonType::String, ctype: ComplexType::Pod })),
|
||
"entry.hash" => Some(("entry.hash", JsonTypeInfo { jtype: JsonType::String, ctype: ComplexType::Pod })),
|
||
"entry.url" => Some(("entry.url", JsonTypeInfo { jtype: JsonType::String, ctype: ComplexType::Pod })),
|
||
"platform-type" => Some(("platformType", JsonTypeInfo { jtype: JsonType::String, ctype: ComplexType::Pod })),
|
||
"threat-type" => Some(("threatType", JsonTypeInfo { jtype: JsonType::String, ctype: ComplexType::Pod })),
|
||
"user-info.region-code" => Some(("userInfo.regionCode", JsonTypeInfo { jtype: JsonType::String, ctype: ComplexType::Pod })),
|
||
"user-info.user-id" => Some(("userInfo.userId", JsonTypeInfo { jtype: JsonType::String, ctype: ComplexType::Pod })),
|
||
_ => {
|
||
let suggestion = FieldCursor::did_you_mean(key, &vec!["client-id", "client-info", "client-version", "digest", "entry", "hash", "platform-type", "region-code", "threat-type", "url", "user-id", "user-info"]);
|
||
err.issues.push(CLIError::Field(FieldError::Unknown(temp_cursor.to_string(), suggestion, value.map(|v| v.to_string()))));
|
||
None
|
||
}
|
||
};
|
||
if let Some((field_cursor_str, type_info)) = type_info {
|
||
FieldCursor::from(field_cursor_str).set_json_value(&mut object, value.unwrap(), type_info, err, &temp_cursor);
|
||
}
|
||
}
|
||
let mut request: api::GoogleSecuritySafebrowsingV4ThreatHit = json::value::from_value(object).unwrap();
|
||
let mut call = self.hub.threat_hits().create(request);
|
||
for parg in opt.values_of("v").map(|i|i.collect()).unwrap_or(Vec::new()).iter() {
|
||
let (key, value) = parse_kv_arg(&*parg, err, false);
|
||
match key {
|
||
_ => {
|
||
let mut found = false;
|
||
for param in &self.gp {
|
||
if key == *param {
|
||
found = true;
|
||
call = call.param(self.gpm.iter().find(|t| t.0 == key).unwrap_or(&("", key)).1, value.unwrap_or("unset"));
|
||
break;
|
||
}
|
||
}
|
||
if !found {
|
||
err.issues.push(CLIError::UnknownParameter(key.to_string(),
|
||
{let mut v = Vec::new();
|
||
v.extend(self.gp.iter().map(|v|*v));
|
||
v } ));
|
||
}
|
||
}
|
||
}
|
||
}
|
||
let protocol = CallType::Standard;
|
||
if dry_run {
|
||
Ok(())
|
||
} else {
|
||
assert!(err.issues.len() == 0);
|
||
let mut ostream = match writer_from_opts(opt.value_of("out")) {
|
||
Ok(mut f) => f,
|
||
Err(io_err) => return Err(DoitError::IoError(opt.value_of("out").unwrap_or("-").to_string(), io_err)),
|
||
};
|
||
match match protocol {
|
||
CallType::Standard => call.doit().await,
|
||
_ => unreachable!()
|
||
} {
|
||
Err(api_err) => Err(DoitError::ApiError(api_err)),
|
||
Ok((mut response, output_schema)) => {
|
||
let mut value = json::value::to_value(&output_schema).expect("serde to work");
|
||
remove_json_null_values(&mut value);
|
||
json::to_writer_pretty(&mut ostream, &value).unwrap();
|
||
ostream.flush().unwrap();
|
||
Ok(())
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
async fn _threat_list_updates_fetch(&self, opt: &ArgMatches<'n>, dry_run: bool, err: &mut InvalidOptionsError)
|
||
-> Result<(), DoitError> {
|
||
|
||
let mut field_cursor = FieldCursor::default();
|
||
let mut object = json::value::Value::Object(Default::default());
|
||
|
||
for kvarg in opt.values_of("kv").map(|i|i.collect()).unwrap_or(Vec::new()).iter() {
|
||
let last_errc = err.issues.len();
|
||
let (key, value) = parse_kv_arg(&*kvarg, err, false);
|
||
let mut temp_cursor = field_cursor.clone();
|
||
if let Err(field_err) = temp_cursor.set(&*key) {
|
||
err.issues.push(field_err);
|
||
}
|
||
if value.is_none() {
|
||
field_cursor = temp_cursor.clone();
|
||
if err.issues.len() > last_errc {
|
||
err.issues.remove(last_errc);
|
||
}
|
||
continue;
|
||
}
|
||
|
||
let type_info: Option<(&'static str, JsonTypeInfo)> =
|
||
match &temp_cursor.to_string()[..] {
|
||
"client.client-id" => Some(("client.clientId", JsonTypeInfo { jtype: JsonType::String, ctype: ComplexType::Pod })),
|
||
"client.client-version" => Some(("client.clientVersion", JsonTypeInfo { jtype: JsonType::String, ctype: ComplexType::Pod })),
|
||
_ => {
|
||
let suggestion = FieldCursor::did_you_mean(key, &vec!["client", "client-id", "client-version"]);
|
||
err.issues.push(CLIError::Field(FieldError::Unknown(temp_cursor.to_string(), suggestion, value.map(|v| v.to_string()))));
|
||
None
|
||
}
|
||
};
|
||
if let Some((field_cursor_str, type_info)) = type_info {
|
||
FieldCursor::from(field_cursor_str).set_json_value(&mut object, value.unwrap(), type_info, err, &temp_cursor);
|
||
}
|
||
}
|
||
let mut request: api::GoogleSecuritySafebrowsingV4FetchThreatListUpdatesRequest = json::value::from_value(object).unwrap();
|
||
let mut call = self.hub.threat_list_updates().fetch(request);
|
||
for parg in opt.values_of("v").map(|i|i.collect()).unwrap_or(Vec::new()).iter() {
|
||
let (key, value) = parse_kv_arg(&*parg, err, false);
|
||
match key {
|
||
_ => {
|
||
let mut found = false;
|
||
for param in &self.gp {
|
||
if key == *param {
|
||
found = true;
|
||
call = call.param(self.gpm.iter().find(|t| t.0 == key).unwrap_or(&("", key)).1, value.unwrap_or("unset"));
|
||
break;
|
||
}
|
||
}
|
||
if !found {
|
||
err.issues.push(CLIError::UnknownParameter(key.to_string(),
|
||
{let mut v = Vec::new();
|
||
v.extend(self.gp.iter().map(|v|*v));
|
||
v } ));
|
||
}
|
||
}
|
||
}
|
||
}
|
||
let protocol = CallType::Standard;
|
||
if dry_run {
|
||
Ok(())
|
||
} else {
|
||
assert!(err.issues.len() == 0);
|
||
let mut ostream = match writer_from_opts(opt.value_of("out")) {
|
||
Ok(mut f) => f,
|
||
Err(io_err) => return Err(DoitError::IoError(opt.value_of("out").unwrap_or("-").to_string(), io_err)),
|
||
};
|
||
match match protocol {
|
||
CallType::Standard => call.doit().await,
|
||
_ => unreachable!()
|
||
} {
|
||
Err(api_err) => Err(DoitError::ApiError(api_err)),
|
||
Ok((mut response, output_schema)) => {
|
||
let mut value = json::value::to_value(&output_schema).expect("serde to work");
|
||
remove_json_null_values(&mut value);
|
||
json::to_writer_pretty(&mut ostream, &value).unwrap();
|
||
ostream.flush().unwrap();
|
||
Ok(())
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
async fn _threat_lists_list(&self, opt: &ArgMatches<'n>, dry_run: bool, err: &mut InvalidOptionsError)
|
||
-> Result<(), DoitError> {
|
||
let mut call = self.hub.threat_lists().list();
|
||
for parg in opt.values_of("v").map(|i|i.collect()).unwrap_or(Vec::new()).iter() {
|
||
let (key, value) = parse_kv_arg(&*parg, err, false);
|
||
match key {
|
||
_ => {
|
||
let mut found = false;
|
||
for param in &self.gp {
|
||
if key == *param {
|
||
found = true;
|
||
call = call.param(self.gpm.iter().find(|t| t.0 == key).unwrap_or(&("", key)).1, value.unwrap_or("unset"));
|
||
break;
|
||
}
|
||
}
|
||
if !found {
|
||
err.issues.push(CLIError::UnknownParameter(key.to_string(),
|
||
{let mut v = Vec::new();
|
||
v.extend(self.gp.iter().map(|v|*v));
|
||
v } ));
|
||
}
|
||
}
|
||
}
|
||
}
|
||
let protocol = CallType::Standard;
|
||
if dry_run {
|
||
Ok(())
|
||
} else {
|
||
assert!(err.issues.len() == 0);
|
||
let mut ostream = match writer_from_opts(opt.value_of("out")) {
|
||
Ok(mut f) => f,
|
||
Err(io_err) => return Err(DoitError::IoError(opt.value_of("out").unwrap_or("-").to_string(), io_err)),
|
||
};
|
||
match match protocol {
|
||
CallType::Standard => call.doit().await,
|
||
_ => unreachable!()
|
||
} {
|
||
Err(api_err) => Err(DoitError::ApiError(api_err)),
|
||
Ok((mut response, output_schema)) => {
|
||
let mut value = json::value::to_value(&output_schema).expect("serde to work");
|
||
remove_json_null_values(&mut value);
|
||
json::to_writer_pretty(&mut ostream, &value).unwrap();
|
||
ostream.flush().unwrap();
|
||
Ok(())
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
async fn _threat_matches_find(&self, opt: &ArgMatches<'n>, dry_run: bool, err: &mut InvalidOptionsError)
|
||
-> Result<(), DoitError> {
|
||
|
||
let mut field_cursor = FieldCursor::default();
|
||
let mut object = json::value::Value::Object(Default::default());
|
||
|
||
for kvarg in opt.values_of("kv").map(|i|i.collect()).unwrap_or(Vec::new()).iter() {
|
||
let last_errc = err.issues.len();
|
||
let (key, value) = parse_kv_arg(&*kvarg, err, false);
|
||
let mut temp_cursor = field_cursor.clone();
|
||
if let Err(field_err) = temp_cursor.set(&*key) {
|
||
err.issues.push(field_err);
|
||
}
|
||
if value.is_none() {
|
||
field_cursor = temp_cursor.clone();
|
||
if err.issues.len() > last_errc {
|
||
err.issues.remove(last_errc);
|
||
}
|
||
continue;
|
||
}
|
||
|
||
let type_info: Option<(&'static str, JsonTypeInfo)> =
|
||
match &temp_cursor.to_string()[..] {
|
||
"client.client-id" => Some(("client.clientId", JsonTypeInfo { jtype: JsonType::String, ctype: ComplexType::Pod })),
|
||
"client.client-version" => Some(("client.clientVersion", JsonTypeInfo { jtype: JsonType::String, ctype: ComplexType::Pod })),
|
||
"threat-info.platform-types" => Some(("threatInfo.platformTypes", JsonTypeInfo { jtype: JsonType::String, ctype: ComplexType::Vec })),
|
||
"threat-info.threat-entry-types" => Some(("threatInfo.threatEntryTypes", JsonTypeInfo { jtype: JsonType::String, ctype: ComplexType::Vec })),
|
||
"threat-info.threat-types" => Some(("threatInfo.threatTypes", JsonTypeInfo { jtype: JsonType::String, ctype: ComplexType::Vec })),
|
||
_ => {
|
||
let suggestion = FieldCursor::did_you_mean(key, &vec!["client", "client-id", "client-version", "platform-types", "threat-entry-types", "threat-info", "threat-types"]);
|
||
err.issues.push(CLIError::Field(FieldError::Unknown(temp_cursor.to_string(), suggestion, value.map(|v| v.to_string()))));
|
||
None
|
||
}
|
||
};
|
||
if let Some((field_cursor_str, type_info)) = type_info {
|
||
FieldCursor::from(field_cursor_str).set_json_value(&mut object, value.unwrap(), type_info, err, &temp_cursor);
|
||
}
|
||
}
|
||
let mut request: api::GoogleSecuritySafebrowsingV4FindThreatMatchesRequest = json::value::from_value(object).unwrap();
|
||
let mut call = self.hub.threat_matches().find(request);
|
||
for parg in opt.values_of("v").map(|i|i.collect()).unwrap_or(Vec::new()).iter() {
|
||
let (key, value) = parse_kv_arg(&*parg, err, false);
|
||
match key {
|
||
_ => {
|
||
let mut found = false;
|
||
for param in &self.gp {
|
||
if key == *param {
|
||
found = true;
|
||
call = call.param(self.gpm.iter().find(|t| t.0 == key).unwrap_or(&("", key)).1, value.unwrap_or("unset"));
|
||
break;
|
||
}
|
||
}
|
||
if !found {
|
||
err.issues.push(CLIError::UnknownParameter(key.to_string(),
|
||
{let mut v = Vec::new();
|
||
v.extend(self.gp.iter().map(|v|*v));
|
||
v } ));
|
||
}
|
||
}
|
||
}
|
||
}
|
||
let protocol = CallType::Standard;
|
||
if dry_run {
|
||
Ok(())
|
||
} else {
|
||
assert!(err.issues.len() == 0);
|
||
let mut ostream = match writer_from_opts(opt.value_of("out")) {
|
||
Ok(mut f) => f,
|
||
Err(io_err) => return Err(DoitError::IoError(opt.value_of("out").unwrap_or("-").to_string(), io_err)),
|
||
};
|
||
match match protocol {
|
||
CallType::Standard => call.doit().await,
|
||
_ => unreachable!()
|
||
} {
|
||
Err(api_err) => Err(DoitError::ApiError(api_err)),
|
||
Ok((mut response, output_schema)) => {
|
||
let mut value = json::value::to_value(&output_schema).expect("serde to work");
|
||
remove_json_null_values(&mut value);
|
||
json::to_writer_pretty(&mut ostream, &value).unwrap();
|
||
ostream.flush().unwrap();
|
||
Ok(())
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
async fn _doit(&self, dry_run: bool) -> Result<Result<(), DoitError>, Option<InvalidOptionsError>> {
|
||
let mut err = InvalidOptionsError::new();
|
||
let mut call_result: Result<(), DoitError> = Ok(());
|
||
let mut err_opt: Option<InvalidOptionsError> = None;
|
||
match self.opt.subcommand() {
|
||
("encoded-full-hashes", Some(opt)) => {
|
||
match opt.subcommand() {
|
||
("get", Some(opt)) => {
|
||
call_result = self._encoded_full_hashes_get(opt, dry_run, &mut err).await;
|
||
},
|
||
_ => {
|
||
err.issues.push(CLIError::MissingMethodError("encoded-full-hashes".to_string()));
|
||
writeln!(io::stderr(), "{}\n", opt.usage()).ok();
|
||
}
|
||
}
|
||
},
|
||
("encoded-updates", Some(opt)) => {
|
||
match opt.subcommand() {
|
||
("get", Some(opt)) => {
|
||
call_result = self._encoded_updates_get(opt, dry_run, &mut err).await;
|
||
},
|
||
_ => {
|
||
err.issues.push(CLIError::MissingMethodError("encoded-updates".to_string()));
|
||
writeln!(io::stderr(), "{}\n", opt.usage()).ok();
|
||
}
|
||
}
|
||
},
|
||
("full-hashes", Some(opt)) => {
|
||
match opt.subcommand() {
|
||
("find", Some(opt)) => {
|
||
call_result = self._full_hashes_find(opt, dry_run, &mut err).await;
|
||
},
|
||
_ => {
|
||
err.issues.push(CLIError::MissingMethodError("full-hashes".to_string()));
|
||
writeln!(io::stderr(), "{}\n", opt.usage()).ok();
|
||
}
|
||
}
|
||
},
|
||
("threat-hits", Some(opt)) => {
|
||
match opt.subcommand() {
|
||
("create", Some(opt)) => {
|
||
call_result = self._threat_hits_create(opt, dry_run, &mut err).await;
|
||
},
|
||
_ => {
|
||
err.issues.push(CLIError::MissingMethodError("threat-hits".to_string()));
|
||
writeln!(io::stderr(), "{}\n", opt.usage()).ok();
|
||
}
|
||
}
|
||
},
|
||
("threat-list-updates", Some(opt)) => {
|
||
match opt.subcommand() {
|
||
("fetch", Some(opt)) => {
|
||
call_result = self._threat_list_updates_fetch(opt, dry_run, &mut err).await;
|
||
},
|
||
_ => {
|
||
err.issues.push(CLIError::MissingMethodError("threat-list-updates".to_string()));
|
||
writeln!(io::stderr(), "{}\n", opt.usage()).ok();
|
||
}
|
||
}
|
||
},
|
||
("threat-lists", Some(opt)) => {
|
||
match opt.subcommand() {
|
||
("list", Some(opt)) => {
|
||
call_result = self._threat_lists_list(opt, dry_run, &mut err).await;
|
||
},
|
||
_ => {
|
||
err.issues.push(CLIError::MissingMethodError("threat-lists".to_string()));
|
||
writeln!(io::stderr(), "{}\n", opt.usage()).ok();
|
||
}
|
||
}
|
||
},
|
||
("threat-matches", Some(opt)) => {
|
||
match opt.subcommand() {
|
||
("find", Some(opt)) => {
|
||
call_result = self._threat_matches_find(opt, dry_run, &mut err).await;
|
||
},
|
||
_ => {
|
||
err.issues.push(CLIError::MissingMethodError("threat-matches".to_string()));
|
||
writeln!(io::stderr(), "{}\n", opt.usage()).ok();
|
||
}
|
||
}
|
||
},
|
||
_ => {
|
||
err.issues.push(CLIError::MissingCommandError);
|
||
writeln!(io::stderr(), "{}\n", self.opt.usage()).ok();
|
||
}
|
||
}
|
||
|
||
if dry_run {
|
||
if err.issues.len() > 0 {
|
||
err_opt = Some(err);
|
||
}
|
||
Err(err_opt)
|
||
} else {
|
||
Ok(call_result)
|
||
}
|
||
}
|
||
|
||
// Please note that this call will fail if any part of the opt can't be handled
|
||
async fn new(opt: ArgMatches<'n>) -> Result<Engine<'n>, InvalidOptionsError> {
|
||
let (config_dir, secret) = {
|
||
let config_dir = match client::assure_config_dir_exists(opt.value_of("folder").unwrap_or("~/.google-service-cli")) {
|
||
Err(e) => return Err(InvalidOptionsError::single(e, 3)),
|
||
Ok(p) => p,
|
||
};
|
||
|
||
match client::application_secret_from_directory(&config_dir, "safebrowsing4-secret.json",
|
||
"{\"installed\":{\"auth_uri\":\"https://accounts.google.com/o/oauth2/auth\",\"client_secret\":\"hCsslbCUyfehWMmbkG8vTYxG\",\"token_uri\":\"https://accounts.google.com/o/oauth2/token\",\"client_email\":\"\",\"redirect_uris\":[\"urn:ietf:wg:oauth:2.0:oob\",\"oob\"],\"client_x509_cert_url\":\"\",\"client_id\":\"620010449518-9ngf7o4dhs0dka470npqvor6dc5lqb9b.apps.googleusercontent.com\",\"auth_provider_x509_cert_url\":\"https://www.googleapis.com/oauth2/v1/certs\"}}") {
|
||
Ok(secret) => (config_dir, secret),
|
||
Err(e) => return Err(InvalidOptionsError::single(e, 4))
|
||
}
|
||
};
|
||
|
||
let auth = yup_oauth2::InstalledFlowAuthenticator::builder(
|
||
secret,
|
||
yup_oauth2::InstalledFlowReturnMethod::HTTPRedirect,
|
||
).persist_tokens_to_disk(format!("{}/safebrowsing4", config_dir)).build().await.unwrap();
|
||
|
||
let client = hyper::Client::builder().build(hyper_rustls::HttpsConnector::with_native_roots());
|
||
let engine = Engine {
|
||
opt: opt,
|
||
hub: api::Safebrowsing::new(client, auth),
|
||
gp: vec!["$-xgafv", "access-token", "alt", "callback", "fields", "key", "oauth-token", "pretty-print", "quota-user", "upload-type", "upload-protocol"],
|
||
gpm: vec![
|
||
("$-xgafv", "$.xgafv"),
|
||
("access-token", "access_token"),
|
||
("oauth-token", "oauth_token"),
|
||
("pretty-print", "prettyPrint"),
|
||
("quota-user", "quotaUser"),
|
||
("upload-type", "uploadType"),
|
||
("upload-protocol", "upload_protocol"),
|
||
]
|
||
};
|
||
|
||
match engine._doit(true).await {
|
||
Err(Some(err)) => Err(err),
|
||
Err(None) => Ok(engine),
|
||
Ok(_) => unreachable!(),
|
||
}
|
||
}
|
||
|
||
async fn doit(&self) -> Result<(), DoitError> {
|
||
match self._doit(false).await {
|
||
Ok(res) => res,
|
||
Err(_) => unreachable!(),
|
||
}
|
||
}
|
||
}
|
||
|
||
#[tokio::main]
|
||
async fn main() {
|
||
let mut exit_status = 0i32;
|
||
let arg_data = [
|
||
("encoded-full-hashes", "methods: 'get'", vec![
|
||
("get",
|
||
Some(r##""##),
|
||
"Details at http://byron.github.io/google-apis-rs/google_safebrowsing4_cli/encoded-full-hashes_get",
|
||
vec![
|
||
(Some(r##"encoded-request"##),
|
||
None,
|
||
Some(r##"A serialized FindFullHashesRequest proto."##),
|
||
Some(true),
|
||
Some(false)),
|
||
|
||
(Some(r##"v"##),
|
||
Some(r##"p"##),
|
||
Some(r##"Set various optional parameters, matching the key=value form"##),
|
||
Some(false),
|
||
Some(true)),
|
||
|
||
(Some(r##"out"##),
|
||
Some(r##"o"##),
|
||
Some(r##"Specify the file into which to write the program's output"##),
|
||
Some(false),
|
||
Some(false)),
|
||
]),
|
||
]),
|
||
|
||
("encoded-updates", "methods: 'get'", vec![
|
||
("get",
|
||
Some(r##""##),
|
||
"Details at http://byron.github.io/google-apis-rs/google_safebrowsing4_cli/encoded-updates_get",
|
||
vec![
|
||
(Some(r##"encoded-request"##),
|
||
None,
|
||
Some(r##"A serialized FetchThreatListUpdatesRequest proto."##),
|
||
Some(true),
|
||
Some(false)),
|
||
|
||
(Some(r##"v"##),
|
||
Some(r##"p"##),
|
||
Some(r##"Set various optional parameters, matching the key=value form"##),
|
||
Some(false),
|
||
Some(true)),
|
||
|
||
(Some(r##"out"##),
|
||
Some(r##"o"##),
|
||
Some(r##"Specify the file into which to write the program's output"##),
|
||
Some(false),
|
||
Some(false)),
|
||
]),
|
||
]),
|
||
|
||
("full-hashes", "methods: 'find'", vec![
|
||
("find",
|
||
Some(r##"Finds the full hashes that match the requested hash prefixes."##),
|
||
"Details at http://byron.github.io/google-apis-rs/google_safebrowsing4_cli/full-hashes_find",
|
||
vec![
|
||
(Some(r##"kv"##),
|
||
Some(r##"r"##),
|
||
Some(r##"Set various fields of the request structure, matching the key=value form"##),
|
||
Some(true),
|
||
Some(true)),
|
||
|
||
(Some(r##"v"##),
|
||
Some(r##"p"##),
|
||
Some(r##"Set various optional parameters, matching the key=value form"##),
|
||
Some(false),
|
||
Some(true)),
|
||
|
||
(Some(r##"out"##),
|
||
Some(r##"o"##),
|
||
Some(r##"Specify the file into which to write the program's output"##),
|
||
Some(false),
|
||
Some(false)),
|
||
]),
|
||
]),
|
||
|
||
("threat-hits", "methods: 'create'", vec![
|
||
("create",
|
||
Some(r##"Reports a Safe Browsing threat list hit to Google. Only projects with TRUSTED_REPORTER visibility can use this method."##),
|
||
"Details at http://byron.github.io/google-apis-rs/google_safebrowsing4_cli/threat-hits_create",
|
||
vec![
|
||
(Some(r##"kv"##),
|
||
Some(r##"r"##),
|
||
Some(r##"Set various fields of the request structure, matching the key=value form"##),
|
||
Some(true),
|
||
Some(true)),
|
||
|
||
(Some(r##"v"##),
|
||
Some(r##"p"##),
|
||
Some(r##"Set various optional parameters, matching the key=value form"##),
|
||
Some(false),
|
||
Some(true)),
|
||
|
||
(Some(r##"out"##),
|
||
Some(r##"o"##),
|
||
Some(r##"Specify the file into which to write the program's output"##),
|
||
Some(false),
|
||
Some(false)),
|
||
]),
|
||
]),
|
||
|
||
("threat-list-updates", "methods: 'fetch'", vec![
|
||
("fetch",
|
||
Some(r##"Fetches the most recent threat list updates. A client can request updates for multiple lists at once."##),
|
||
"Details at http://byron.github.io/google-apis-rs/google_safebrowsing4_cli/threat-list-updates_fetch",
|
||
vec![
|
||
(Some(r##"kv"##),
|
||
Some(r##"r"##),
|
||
Some(r##"Set various fields of the request structure, matching the key=value form"##),
|
||
Some(true),
|
||
Some(true)),
|
||
|
||
(Some(r##"v"##),
|
||
Some(r##"p"##),
|
||
Some(r##"Set various optional parameters, matching the key=value form"##),
|
||
Some(false),
|
||
Some(true)),
|
||
|
||
(Some(r##"out"##),
|
||
Some(r##"o"##),
|
||
Some(r##"Specify the file into which to write the program's output"##),
|
||
Some(false),
|
||
Some(false)),
|
||
]),
|
||
]),
|
||
|
||
("threat-lists", "methods: 'list'", vec![
|
||
("list",
|
||
Some(r##"Lists the Safe Browsing threat lists available for download."##),
|
||
"Details at http://byron.github.io/google-apis-rs/google_safebrowsing4_cli/threat-lists_list",
|
||
vec![
|
||
(Some(r##"v"##),
|
||
Some(r##"p"##),
|
||
Some(r##"Set various optional parameters, matching the key=value form"##),
|
||
Some(false),
|
||
Some(true)),
|
||
|
||
(Some(r##"out"##),
|
||
Some(r##"o"##),
|
||
Some(r##"Specify the file into which to write the program's output"##),
|
||
Some(false),
|
||
Some(false)),
|
||
]),
|
||
]),
|
||
|
||
("threat-matches", "methods: 'find'", vec![
|
||
("find",
|
||
Some(r##"Finds the threat entries that match the Safe Browsing lists."##),
|
||
"Details at http://byron.github.io/google-apis-rs/google_safebrowsing4_cli/threat-matches_find",
|
||
vec![
|
||
(Some(r##"kv"##),
|
||
Some(r##"r"##),
|
||
Some(r##"Set various fields of the request structure, matching the key=value form"##),
|
||
Some(true),
|
||
Some(true)),
|
||
|
||
(Some(r##"v"##),
|
||
Some(r##"p"##),
|
||
Some(r##"Set various optional parameters, matching the key=value form"##),
|
||
Some(false),
|
||
Some(true)),
|
||
|
||
(Some(r##"out"##),
|
||
Some(r##"o"##),
|
||
Some(r##"Specify the file into which to write the program's output"##),
|
||
Some(false),
|
||
Some(false)),
|
||
]),
|
||
]),
|
||
|
||
];
|
||
|
||
let mut app = App::new("safebrowsing4")
|
||
.author("Sebastian Thiel <byronimo@gmail.com>")
|
||
.version("2.0.8+20210330")
|
||
.about("Enables client applications to check web resources (most commonly URLs) against Google-generated lists of unsafe web resources. The Safe Browsing APIs are for non-commercial use only. If you need to use APIs to detect malicious URLs for commercial purposes – meaning “for sale or revenue-generating purposes” – please refer to the Web Risk API.")
|
||
.after_help("All documentation details can be found at http://byron.github.io/google-apis-rs/google_safebrowsing4_cli")
|
||
.arg(Arg::with_name("folder")
|
||
.long("config-dir")
|
||
.help("A directory into which we will store our persistent data. Defaults to a user-writable directory that we will create during the first invocation.[default: ~/.google-service-cli")
|
||
.multiple(false)
|
||
.takes_value(true))
|
||
.arg(Arg::with_name("debug")
|
||
.long("debug")
|
||
.help("Debug print all errors")
|
||
.multiple(false)
|
||
.takes_value(false));
|
||
|
||
for &(main_command_name, about, ref subcommands) in arg_data.iter() {
|
||
let mut mcmd = SubCommand::with_name(main_command_name).about(about);
|
||
|
||
for &(sub_command_name, ref desc, url_info, ref args) in subcommands {
|
||
let mut scmd = SubCommand::with_name(sub_command_name);
|
||
if let &Some(desc) = desc {
|
||
scmd = scmd.about(desc);
|
||
}
|
||
scmd = scmd.after_help(url_info);
|
||
|
||
for &(ref arg_name, ref flag, ref desc, ref required, ref multi) in args {
|
||
let arg_name_str =
|
||
match (arg_name, flag) {
|
||
(&Some(an), _ ) => an,
|
||
(_ , &Some(f)) => f,
|
||
_ => unreachable!(),
|
||
};
|
||
let mut arg = Arg::with_name(arg_name_str)
|
||
.empty_values(false);
|
||
if let &Some(short_flag) = flag {
|
||
arg = arg.short(short_flag);
|
||
}
|
||
if let &Some(desc) = desc {
|
||
arg = arg.help(desc);
|
||
}
|
||
if arg_name.is_some() && flag.is_some() {
|
||
arg = arg.takes_value(true);
|
||
}
|
||
if let &Some(required) = required {
|
||
arg = arg.required(required);
|
||
}
|
||
if let &Some(multi) = multi {
|
||
arg = arg.multiple(multi);
|
||
}
|
||
scmd = scmd.arg(arg);
|
||
}
|
||
mcmd = mcmd.subcommand(scmd);
|
||
}
|
||
app = app.subcommand(mcmd);
|
||
}
|
||
|
||
let matches = app.get_matches();
|
||
|
||
let debug = matches.is_present("debug");
|
||
match Engine::new(matches).await {
|
||
Err(err) => {
|
||
exit_status = err.exit_code;
|
||
writeln!(io::stderr(), "{}", err).ok();
|
||
},
|
||
Ok(engine) => {
|
||
if let Err(doit_err) = engine.doit().await {
|
||
exit_status = 1;
|
||
match doit_err {
|
||
DoitError::IoError(path, err) => {
|
||
writeln!(io::stderr(), "Failed to open output file '{}': {}", path, err).ok();
|
||
},
|
||
DoitError::ApiError(err) => {
|
||
if debug {
|
||
writeln!(io::stderr(), "{:#?}", err).ok();
|
||
} else {
|
||
writeln!(io::stderr(), "{}", err).ok();
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
std::process::exit(exit_status);
|
||
}
|