okhttp

1
/*
2
 * Copyright (C) 2023 Square, Inc.
3
 *
4
 * Licensed under the Apache License, Version 2.0 (the "License");
5
 * you may not use this file except in compliance with the License.
6
 * You may obtain a copy of the License at
7
 *
8
 *      http://www.apache.org/licenses/LICENSE-2.0
9
 *
10
 * Unless required by applicable law or agreed to in writing, software
11
 * distributed under the License is distributed on an "AS IS" BASIS,
12
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13
 * See the License for the specific language governing permissions and
14
 * limitations under the License.
15
 */
16
package okhttp3.internal.idn
17

18
import kotlin.math.abs
19
import okio.ByteString
20

21
internal sealed interface MappedRange {
22
  val rangeStart: Int
23

24
  data class Constant(
25
    override val rangeStart: Int,
26
    val type: Int,
27
  ) : MappedRange {
28
    val b1: Int
29
      get() =
30
        when (type) {
31
          TYPE_IGNORED -> 119
32
          TYPE_VALID -> 120
33
          TYPE_DISALLOWED -> 121
34
          else -> error("unexpected type: $type")
35
        }
36
  }
37

38
  data class Inline1(
39
    override val rangeStart: Int,
40
    private val mappedTo: ByteString,
41
  ) : MappedRange {
42
    val b1: Int
43
      get() {
44
        val b3bit8 = mappedTo[0] and 0x80 != 0
45
        return if (b3bit8) 123 else 122
46
      }
47

48
    val b2: Int
49
      get() = mappedTo[0] and 0x7f
50
  }
51

52
  data class Inline2(
53
    override val rangeStart: Int,
54
    private val mappedTo: ByteString,
55
  ) : MappedRange {
56
    val b1: Int
57
      get() {
58
        val b2bit8 = mappedTo[0] and 0x80 != 0
59
        val b3bit8 = mappedTo[1] and 0x80 != 0
60
        return when {
61
          b2bit8 && b3bit8 -> 127
62
          b3bit8 -> 126
63
          b2bit8 -> 125
64
          else -> 124
65
        }
66
      }
67

68
    val b2: Int
69
      get() = mappedTo[0] and 0x7f
70

71
    val b3: Int
72
      get() = mappedTo[1] and 0x7f
73
  }
74

75
  data class InlineDelta(
76
    override val rangeStart: Int,
77
    val codepointDelta: Int,
78
  ) : MappedRange {
79
    private val absoluteDelta = abs(codepointDelta)
80

81
    val b1: Int
82
      get() =
83
        when {
84
          codepointDelta < 0 -> 0x40 or (absoluteDelta shr 14)
85
          codepointDelta > 0 -> 0x50 or (absoluteDelta shr 14)
86
          else -> error("Unexpected codepointDelta of 0")
87
        }
88

89
    val b2: Int
90
      get() = absoluteDelta shr 7 and 0x7f
91

92
    val b3: Int
93
      get() = absoluteDelta and 0x7f
94

95
    companion object {
96
      const val MAX_VALUE = 0x3FFFF
97
    }
98
  }
99

100
  data class External(
101
    override val rangeStart: Int,
102
    val mappedTo: ByteString,
103
  ) : MappedRange
104
}
105