openpgp: Unawkwardify Encryptor::add_password.

4 files changed, 15 insertions, 16 deletions

diff --git a/openpgp-ffi/src/serialize.rs b/openpgp-ffi/src/serialize.rs
index 610cb7f1..20ccc684 100644
--- a/openpgp-ffi/src/serialize.rs
+++ b/openpgp-ffi/src/serialize.rs
@@ -366,7 +366,7 @@ pub extern "C" fn pgp_encryptor_new<'a>
         };
         for password in passwords {
             passwords_.push(ffi_param_cstr!(*password)
-                            .to_bytes().to_owned().into());
+                            .to_bytes().to_owned());
         }
     }
     let mut recipients_ = Vec::new();
@@ -394,10 +394,8 @@ pub extern "C" fn pgp_encryptor_new<'a>
             "Neither recipient nor password given")));
     }
 
-    let mut encryptor = Encryptor::for_recipients(*inner, recipients_);
-    for p in passwords_ {
-        encryptor = encryptor.add_password(p);
-    }
+    let mut encryptor = Encryptor::for_recipients(*inner, recipients_)
+        .add_passwords(passwords_);
     if let Some(algo) = cipher_algo {
         encryptor = encryptor.symmetric_algo(algo);
     }
diff --git a/openpgp/src/serialize/stream.rs b/openpgp/src/serialize/stream.rs
index e2ee0f34..ff25d3b3 100644
--- a/openpgp/src/serialize/stream.rs
+++ b/openpgp/src/serialize/stream.rs
@@ -2343,15 +2343,20 @@ impl<'a> Encryptor<'a> {
     /// let message = Message::new(&mut sink);
     /// let message =
     ///     Encryptor::for_recipients(message, recipients)
-    ///         .add_password("совершенно секретно".into())
+    ///         .add_passwords(Some("совершенно секретно"))
     ///         .build()?;
     /// let mut message = LiteralWriter::new(message).build()?;
     /// message.write_all(b"Hello world.")?;
     /// message.finalize()?;
     /// # Ok(()) }
     /// ```
-    pub fn add_password(mut self, password: Password) -> Self {
-        self.passwords.push(password);
+    pub fn add_passwords<P>(mut self, passwords: P) -> Self
+        where P: IntoIterator,
+              P::Item: Into<Password>,
+    {
+        for p in passwords {
+            self.passwords.push(p.into());
+        }
         self
     }
 
diff --git a/sop/src/main.rs b/sop/src/main.rs
index f708e001..f8abce91 100644
--- a/sop/src/main.rs
+++ b/sop/src/main.rs
@@ -302,14 +302,12 @@ fn real_main() -> Result<()> {
             // Encrypt the message.
             let mut encryptor =
                 Encryptor::for_recipients(message, recipients)
+                .add_passwords(passwords)
                 .symmetric_algo(
                     symmetric_algos.get(0).cloned().unwrap_or_default());
             if let Some(&a) = aead_algos.get(0) {
                 encryptor = encryptor.aead_algo(a);
             }
-            for p in passwords {
-                encryptor = encryptor.add_password(p);
-            }
             let message = encryptor.build()
                 .context("Failed to create encryptor")?;
 
diff --git a/tool/src/commands/mod.rs b/tool/src/commands/mod.rs
index e7851f70..32239d8d 100644
--- a/tool/src/commands/mod.rs
+++ b/tool/src/commands/mod.rs
@@ -120,11 +120,9 @@ pub fn encrypt<'a>(policy: &'a dyn Policy,
     }
 
     // We want to encrypt a literal data packet.
-    let mut encryptor =
-        Encryptor::for_recipients(message, recipient_subkeys);
-    for p in passwords {
-        encryptor = encryptor.add_password(p);
-    }
+    let encryptor =
+        Encryptor::for_recipients(message, recipient_subkeys)
+        .add_passwords(passwords);
 
     let mut sink = encryptor.build()
         .context("Failed to create encryptor")?;