An experimental share extension to send files and too much refactoring

closes #4

NearbyShare/Protobuf/device_to_device_messages.pb.swift

@@ -0,0 +1,540 @@
+// DO NOT EDIT.
+// swift-format-ignore-file
+//
+// Generated by the Swift generator plugin for the protocol buffer compiler.
+// Source: device_to_device_messages.proto
+//
+// For information on using the generated types, please see the documentation:
+//   https://github.com/apple/swift-protobuf/
+
+// Copyright 2020 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     https://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+import Foundation
+import SwiftProtobuf
+
+// If the compiler emits an error on this type, it is because this file
+// was generated by a version of the `protoc` Swift plug-in that is
+// incompatible with the version of SwiftProtobuf to which you are linking.
+// Please ensure that you are building against the same version of the API
+// that was used to generate this file.
+fileprivate struct _GeneratedWithProtocGenSwiftVersion: SwiftProtobuf.ProtobufAPIVersionCheck {
+  struct _2: SwiftProtobuf.ProtobufAPIVersion_2 {}
+  typealias Version = _2
+}
+
+/// Type of curve
+enum Securegcm_Curve: SwiftProtobuf.Enum {
+  typealias RawValue = Int
+  case ed25519 // = 1
+
+  init() {
+    self = .ed25519
+  }
+
+  init?(rawValue: Int) {
+    switch rawValue {
+    case 1: self = .ed25519
+    default: return nil
+    }
+  }
+
+  var rawValue: Int {
+    switch self {
+    case .ed25519: return 1
+    }
+  }
+
+}
+
+#if swift(>=4.2)
+
+extension Securegcm_Curve: CaseIterable {
+  // Support synthesized by the compiler.
+}
+
+#endif  // swift(>=4.2)
+
+/// Used by protocols between devices
+struct Securegcm_DeviceToDeviceMessage {
+  // SwiftProtobuf.Message conformance is added in an extension below. See the
+  // `Message` and `Message+*Additions` files in the SwiftProtobuf library for
+  // methods supported on all messages.
+
+  /// the payload of the message
+  var message: Data {
+    get {return _message ?? Data()}
+    set {_message = newValue}
+  }
+  /// Returns true if `message` has been explicitly set.
+  var hasMessage: Bool {return self._message != nil}
+  /// Clears the value of `message`. Subsequent reads from it will return its default value.
+  mutating func clearMessage() {self._message = nil}
+
+  /// the sequence number of the message - must be increasing.
+  var sequenceNumber: Int32 {
+    get {return _sequenceNumber ?? 0}
+    set {_sequenceNumber = newValue}
+  }
+  /// Returns true if `sequenceNumber` has been explicitly set.
+  var hasSequenceNumber: Bool {return self._sequenceNumber != nil}
+  /// Clears the value of `sequenceNumber`. Subsequent reads from it will return its default value.
+  mutating func clearSequenceNumber() {self._sequenceNumber = nil}
+
+  var unknownFields = SwiftProtobuf.UnknownStorage()
+
+  init() {}
+
+  fileprivate var _message: Data? = nil
+  fileprivate var _sequenceNumber: Int32? = nil
+}
+
+/// sent as the first message from initiator to responder
+/// in an unauthenticated Diffie-Hellman Key Exchange
+struct Securegcm_InitiatorHello {
+  // SwiftProtobuf.Message conformance is added in an extension below. See the
+  // `Message` and `Message+*Additions` files in the SwiftProtobuf library for
+  // methods supported on all messages.
+
+  /// The session public key to send to the responder
+  var publicDhKey: Securemessage_GenericPublicKey {
+    get {return _publicDhKey ?? Securemessage_GenericPublicKey()}
+    set {_publicDhKey = newValue}
+  }
+  /// Returns true if `publicDhKey` has been explicitly set.
+  var hasPublicDhKey: Bool {return self._publicDhKey != nil}
+  /// Clears the value of `publicDhKey`. Subsequent reads from it will return its default value.
+  mutating func clearPublicDhKey() {self._publicDhKey = nil}
+
+  /// The protocol version
+  var protocolVersion: Int32 {
+    get {return _protocolVersion ?? 0}
+    set {_protocolVersion = newValue}
+  }
+  /// Returns true if `protocolVersion` has been explicitly set.
+  var hasProtocolVersion: Bool {return self._protocolVersion != nil}
+  /// Clears the value of `protocolVersion`. Subsequent reads from it will return its default value.
+  mutating func clearProtocolVersion() {self._protocolVersion = nil}
+
+  var unknownFields = SwiftProtobuf.UnknownStorage()
+
+  init() {}
+
+  fileprivate var _publicDhKey: Securemessage_GenericPublicKey? = nil
+  fileprivate var _protocolVersion: Int32? = nil
+}
+
+/// sent inside the header of the first message from the responder to the
+/// initiator in an unauthenticated Diffie-Hellman Key Exchange
+struct Securegcm_ResponderHello {
+  // SwiftProtobuf.Message conformance is added in an extension below. See the
+  // `Message` and `Message+*Additions` files in the SwiftProtobuf library for
+  // methods supported on all messages.
+
+  /// The session public key to send to the initiator
+  var publicDhKey: Securemessage_GenericPublicKey {
+    get {return _publicDhKey ?? Securemessage_GenericPublicKey()}
+    set {_publicDhKey = newValue}
+  }
+  /// Returns true if `publicDhKey` has been explicitly set.
+  var hasPublicDhKey: Bool {return self._publicDhKey != nil}
+  /// Clears the value of `publicDhKey`. Subsequent reads from it will return its default value.
+  mutating func clearPublicDhKey() {self._publicDhKey = nil}
+
+  /// The protocol version
+  var protocolVersion: Int32 {
+    get {return _protocolVersion ?? 0}
+    set {_protocolVersion = newValue}
+  }
+  /// Returns true if `protocolVersion` has been explicitly set.
+  var hasProtocolVersion: Bool {return self._protocolVersion != nil}
+  /// Clears the value of `protocolVersion`. Subsequent reads from it will return its default value.
+  mutating func clearProtocolVersion() {self._protocolVersion = nil}
+
+  var unknownFields = SwiftProtobuf.UnknownStorage()
+
+  init() {}
+
+  fileprivate var _publicDhKey: Securemessage_GenericPublicKey? = nil
+  fileprivate var _protocolVersion: Int32? = nil
+}
+
+/// A convenience proto for encoding curve points in affine representation
+struct Securegcm_EcPoint {
+  // SwiftProtobuf.Message conformance is added in an extension below. See the
+  // `Message` and `Message+*Additions` files in the SwiftProtobuf library for
+  // methods supported on all messages.
+
+  var curve: Securegcm_Curve {
+    get {return _curve ?? .ed25519}
+    set {_curve = newValue}
+  }
+  /// Returns true if `curve` has been explicitly set.
+  var hasCurve: Bool {return self._curve != nil}
+  /// Clears the value of `curve`. Subsequent reads from it will return its default value.
+  mutating func clearCurve() {self._curve = nil}
+
+  /// x and y are encoded in big-endian two's complement
+  /// client MUST verify (x,y) is a valid point on the specified curve
+  var x: Data {
+    get {return _x ?? Data()}
+    set {_x = newValue}
+  }
+  /// Returns true if `x` has been explicitly set.
+  var hasX: Bool {return self._x != nil}
+  /// Clears the value of `x`. Subsequent reads from it will return its default value.
+  mutating func clearX() {self._x = nil}
+
+  var y: Data {
+    get {return _y ?? Data()}
+    set {_y = newValue}
+  }
+  /// Returns true if `y` has been explicitly set.
+  var hasY: Bool {return self._y != nil}
+  /// Clears the value of `y`. Subsequent reads from it will return its default value.
+  mutating func clearY() {self._y = nil}
+
+  var unknownFields = SwiftProtobuf.UnknownStorage()
+
+  init() {}
+
+  fileprivate var _curve: Securegcm_Curve? = nil
+  fileprivate var _x: Data? = nil
+  fileprivate var _y: Data? = nil
+}
+
+struct Securegcm_SpakeHandshakeMessage {
+  // SwiftProtobuf.Message conformance is added in an extension below. See the
+  // `Message` and `Message+*Additions` files in the SwiftProtobuf library for
+  // methods supported on all messages.
+
+  /// Each flow in the protocol bumps this counter
+  var flowNumber: Int32 {
+    get {return _flowNumber ?? 0}
+    set {_flowNumber = newValue}
+  }
+  /// Returns true if `flowNumber` has been explicitly set.
+  var hasFlowNumber: Bool {return self._flowNumber != nil}
+  /// Clears the value of `flowNumber`. Subsequent reads from it will return its default value.
+  mutating func clearFlowNumber() {self._flowNumber = nil}
+
+  /// Some (but not all) SPAKE flows send a point on an elliptic curve
+  var ecPoint: Securegcm_EcPoint {
+    get {return _ecPoint ?? Securegcm_EcPoint()}
+    set {_ecPoint = newValue}
+  }
+  /// Returns true if `ecPoint` has been explicitly set.
+  var hasEcPoint: Bool {return self._ecPoint != nil}
+  /// Clears the value of `ecPoint`. Subsequent reads from it will return its default value.
+  mutating func clearEcPoint() {self._ecPoint = nil}
+
+  /// Some (but not all) SPAKE flows send a hash value
+  var hashValue_p: Data {
+    get {return _hashValue_p ?? Data()}
+    set {_hashValue_p = newValue}
+  }
+  /// Returns true if `hashValue_p` has been explicitly set.
+  var hasHashValue_p: Bool {return self._hashValue_p != nil}
+  /// Clears the value of `hashValue_p`. Subsequent reads from it will return its default value.
+  mutating func clearHashValue_p() {self._hashValue_p = nil}
+
+  /// The last flow of a SPAKE protocol can send an optional payload,
+  /// since the key exchange is already complete on the sender's side.
+  var payload: Data {
+    get {return _payload ?? Data()}
+    set {_payload = newValue}
+  }
+  /// Returns true if `payload` has been explicitly set.
+  var hasPayload: Bool {return self._payload != nil}
+  /// Clears the value of `payload`. Subsequent reads from it will return its default value.
+  mutating func clearPayload() {self._payload = nil}
+
+  var unknownFields = SwiftProtobuf.UnknownStorage()
+
+  init() {}
+
+  fileprivate var _flowNumber: Int32? = nil
+  fileprivate var _ecPoint: Securegcm_EcPoint? = nil
+  fileprivate var _hashValue_p: Data? = nil
+  fileprivate var _payload: Data? = nil
+}
+
+#if swift(>=5.5) && canImport(_Concurrency)
+extension Securegcm_Curve: @unchecked Sendable {}
+extension Securegcm_DeviceToDeviceMessage: @unchecked Sendable {}
+extension Securegcm_InitiatorHello: @unchecked Sendable {}
+extension Securegcm_ResponderHello: @unchecked Sendable {}
+extension Securegcm_EcPoint: @unchecked Sendable {}
+extension Securegcm_SpakeHandshakeMessage: @unchecked Sendable {}
+#endif  // swift(>=5.5) && canImport(_Concurrency)
+
+// MARK: - Code below here is support for the SwiftProtobuf runtime.
+
+fileprivate let _protobuf_package = "securegcm"
+
+extension Securegcm_Curve: SwiftProtobuf._ProtoNameProviding {
+  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
+    1: .same(proto: "ED_25519"),
+  ]
+}
+
+extension Securegcm_DeviceToDeviceMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
+  static let protoMessageName: String = _protobuf_package + ".DeviceToDeviceMessage"
+  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
+    1: .same(proto: "message"),
+    2: .standard(proto: "sequence_number"),
+  ]
+
+  mutating func decodeMessage<D: SwiftProtobuf.Decoder>(decoder: inout D) throws {
+    while let fieldNumber = try decoder.nextFieldNumber() {
+      // The use of inline closures is to circumvent an issue where the compiler
+      // allocates stack space for every case branch when no optimizations are
+      // enabled. https://github.com/apple/swift-protobuf/issues/1034
+      switch fieldNumber {
+      case 1: try { try decoder.decodeSingularBytesField(value: &self._message) }()
+      case 2: try { try decoder.decodeSingularInt32Field(value: &self._sequenceNumber) }()
+      default: break
+      }
+    }
+  }
+
+  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
+    // The use of inline closures is to circumvent an issue where the compiler
+    // allocates stack space for every if/case branch local when no optimizations
+    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
+    // https://github.com/apple/swift-protobuf/issues/1182
+    try { if let v = self._message {
+      try visitor.visitSingularBytesField(value: v, fieldNumber: 1)
+    } }()
+    try { if let v = self._sequenceNumber {
+      try visitor.visitSingularInt32Field(value: v, fieldNumber: 2)
+    } }()
+    try unknownFields.traverse(visitor: &visitor)
+  }
+
+  static func ==(lhs: Securegcm_DeviceToDeviceMessage, rhs: Securegcm_DeviceToDeviceMessage) -> Bool {
+    if lhs._message != rhs._message {return false}
+    if lhs._sequenceNumber != rhs._sequenceNumber {return false}
+    if lhs.unknownFields != rhs.unknownFields {return false}
+    return true
+  }
+}
+
+extension Securegcm_InitiatorHello: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
+  static let protoMessageName: String = _protobuf_package + ".InitiatorHello"
+  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
+    1: .standard(proto: "public_dh_key"),
+    2: .standard(proto: "protocol_version"),
+  ]
+
+  public var isInitialized: Bool {
+    if let v = self._publicDhKey, !v.isInitialized {return false}
+    return true
+  }
+
+  mutating func decodeMessage<D: SwiftProtobuf.Decoder>(decoder: inout D) throws {
+    while let fieldNumber = try decoder.nextFieldNumber() {
+      // The use of inline closures is to circumvent an issue where the compiler
+      // allocates stack space for every case branch when no optimizations are
+      // enabled. https://github.com/apple/swift-protobuf/issues/1034
+      switch fieldNumber {
+      case 1: try { try decoder.decodeSingularMessageField(value: &self._publicDhKey) }()
+      case 2: try { try decoder.decodeSingularInt32Field(value: &self._protocolVersion) }()
+      default: break
+      }
+    }
+  }
+
+  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
+    // The use of inline closures is to circumvent an issue where the compiler
+    // allocates stack space for every if/case branch local when no optimizations
+    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
+    // https://github.com/apple/swift-protobuf/issues/1182
+    try { if let v = self._publicDhKey {
+      try visitor.visitSingularMessageField(value: v, fieldNumber: 1)
+    } }()
+    try { if let v = self._protocolVersion {
+      try visitor.visitSingularInt32Field(value: v, fieldNumber: 2)
+    } }()
+    try unknownFields.traverse(visitor: &visitor)
+  }
+
+  static func ==(lhs: Securegcm_InitiatorHello, rhs: Securegcm_InitiatorHello) -> Bool {
+    if lhs._publicDhKey != rhs._publicDhKey {return false}
+    if lhs._protocolVersion != rhs._protocolVersion {return false}
+    if lhs.unknownFields != rhs.unknownFields {return false}
+    return true
+  }
+}
+
+extension Securegcm_ResponderHello: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
+  static let protoMessageName: String = _protobuf_package + ".ResponderHello"
+  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
+    1: .standard(proto: "public_dh_key"),
+    2: .standard(proto: "protocol_version"),
+  ]
+
+  public var isInitialized: Bool {
+    if let v = self._publicDhKey, !v.isInitialized {return false}
+    return true
+  }
+
+  mutating func decodeMessage<D: SwiftProtobuf.Decoder>(decoder: inout D) throws {
+    while let fieldNumber = try decoder.nextFieldNumber() {
+      // The use of inline closures is to circumvent an issue where the compiler
+      // allocates stack space for every case branch when no optimizations are
+      // enabled. https://github.com/apple/swift-protobuf/issues/1034
+      switch fieldNumber {
+      case 1: try { try decoder.decodeSingularMessageField(value: &self._publicDhKey) }()
+      case 2: try { try decoder.decodeSingularInt32Field(value: &self._protocolVersion) }()
+      default: break
+      }
+    }
+  }
+
+  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
+    // The use of inline closures is to circumvent an issue where the compiler
+    // allocates stack space for every if/case branch local when no optimizations
+    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
+    // https://github.com/apple/swift-protobuf/issues/1182
+    try { if let v = self._publicDhKey {
+      try visitor.visitSingularMessageField(value: v, fieldNumber: 1)
+    } }()
+    try { if let v = self._protocolVersion {
+      try visitor.visitSingularInt32Field(value: v, fieldNumber: 2)
+    } }()
+    try unknownFields.traverse(visitor: &visitor)
+  }
+
+  static func ==(lhs: Securegcm_ResponderHello, rhs: Securegcm_ResponderHello) -> Bool {
+    if lhs._publicDhKey != rhs._publicDhKey {return false}
+    if lhs._protocolVersion != rhs._protocolVersion {return false}
+    if lhs.unknownFields != rhs.unknownFields {return false}
+    return true
+  }
+}
+
+extension Securegcm_EcPoint: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
+  static let protoMessageName: String = _protobuf_package + ".EcPoint"
+  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
+    1: .same(proto: "curve"),
+    2: .same(proto: "x"),
+    3: .same(proto: "y"),
+  ]
+
+  public var isInitialized: Bool {
+    if self._curve == nil {return false}
+    if self._x == nil {return false}
+    if self._y == nil {return false}
+    return true
+  }
+
+  mutating func decodeMessage<D: SwiftProtobuf.Decoder>(decoder: inout D) throws {
+    while let fieldNumber = try decoder.nextFieldNumber() {
+      // The use of inline closures is to circumvent an issue where the compiler
+      // allocates stack space for every case branch when no optimizations are
+      // enabled. https://github.com/apple/swift-protobuf/issues/1034
+      switch fieldNumber {
+      case 1: try { try decoder.decodeSingularEnumField(value: &self._curve) }()
+      case 2: try { try decoder.decodeSingularBytesField(value: &self._x) }()
+      case 3: try { try decoder.decodeSingularBytesField(value: &self._y) }()
+      default: break
+      }
+    }
+  }
+
+  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
+    // The use of inline closures is to circumvent an issue where the compiler
+    // allocates stack space for every if/case branch local when no optimizations
+    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
+    // https://github.com/apple/swift-protobuf/issues/1182
+    try { if let v = self._curve {
+      try visitor.visitSingularEnumField(value: v, fieldNumber: 1)
+    } }()
+    try { if let v = self._x {
+      try visitor.visitSingularBytesField(value: v, fieldNumber: 2)
+    } }()
+    try { if let v = self._y {
+      try visitor.visitSingularBytesField(value: v, fieldNumber: 3)
+    } }()
+    try unknownFields.traverse(visitor: &visitor)
+  }
+
+  static func ==(lhs: Securegcm_EcPoint, rhs: Securegcm_EcPoint) -> Bool {
+    if lhs._curve != rhs._curve {return false}
+    if lhs._x != rhs._x {return false}
+    if lhs._y != rhs._y {return false}
+    if lhs.unknownFields != rhs.unknownFields {return false}
+    return true
+  }
+}
+
+extension Securegcm_SpakeHandshakeMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
+  static let protoMessageName: String = _protobuf_package + ".SpakeHandshakeMessage"
+  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
+    1: .standard(proto: "flow_number"),
+    2: .standard(proto: "ec_point"),
+    3: .standard(proto: "hash_value"),
+    4: .same(proto: "payload"),
+  ]
+
+  public var isInitialized: Bool {
+    if let v = self._ecPoint, !v.isInitialized {return false}
+    return true
+  }
+
+  mutating func decodeMessage<D: SwiftProtobuf.Decoder>(decoder: inout D) throws {
+    while let fieldNumber = try decoder.nextFieldNumber() {
+      // The use of inline closures is to circumvent an issue where the compiler
+      // allocates stack space for every case branch when no optimizations are
+      // enabled. https://github.com/apple/swift-protobuf/issues/1034
+      switch fieldNumber {
+      case 1: try { try decoder.decodeSingularInt32Field(value: &self._flowNumber) }()
+      case 2: try { try decoder.decodeSingularMessageField(value: &self._ecPoint) }()
+      case 3: try { try decoder.decodeSingularBytesField(value: &self._hashValue_p) }()
+      case 4: try { try decoder.decodeSingularBytesField(value: &self._payload) }()
+      default: break
+      }
+    }
+  }
+
+  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
+    // The use of inline closures is to circumvent an issue where the compiler
+    // allocates stack space for every if/case branch local when no optimizations
+    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
+    // https://github.com/apple/swift-protobuf/issues/1182
+    try { if let v = self._flowNumber {
+      try visitor.visitSingularInt32Field(value: v, fieldNumber: 1)
+    } }()
+    try { if let v = self._ecPoint {
+      try visitor.visitSingularMessageField(value: v, fieldNumber: 2)
+    } }()
+    try { if let v = self._hashValue_p {
+      try visitor.visitSingularBytesField(value: v, fieldNumber: 3)
+    } }()
+    try { if let v = self._payload {
+      try visitor.visitSingularBytesField(value: v, fieldNumber: 4)
+    } }()
+    try unknownFields.traverse(visitor: &visitor)
+  }
+
+  static func ==(lhs: Securegcm_SpakeHandshakeMessage, rhs: Securegcm_SpakeHandshakeMessage) -> Bool {
+    if lhs._flowNumber != rhs._flowNumber {return false}
+    if lhs._ecPoint != rhs._ecPoint {return false}
+    if lhs._hashValue_p != rhs._hashValue_p {return false}
+    if lhs._payload != rhs._payload {return false}
+    if lhs.unknownFields != rhs.unknownFields {return false}
+    return true
+  }
+}