1package sarama
2
3import "time"
4
5type ScramMechanismType int8
6
7const (
8	SCRAM_MECHANISM_UNKNOWN ScramMechanismType = iota // 0
9	SCRAM_MECHANISM_SHA_256                           // 1
10	SCRAM_MECHANISM_SHA_512                           // 2
11)
12
13func (s ScramMechanismType) String() string {
14	switch s {
15	case 1:
16		return SASLTypeSCRAMSHA256
17	case 2:
18		return SASLTypeSCRAMSHA512
19	default:
20		return "Unknown"
21	}
22}
23
24type DescribeUserScramCredentialsResponse struct {
25	// Version 0 is currently only supported
26	Version int16
27
28	ThrottleTime time.Duration
29
30	ErrorCode    KError
31	ErrorMessage *string
32
33	Results []*DescribeUserScramCredentialsResult
34}
35
36type DescribeUserScramCredentialsResult struct {
37	User string
38
39	ErrorCode    KError
40	ErrorMessage *string
41
42	CredentialInfos []*UserScramCredentialsResponseInfo
43}
44
45type UserScramCredentialsResponseInfo struct {
46	Mechanism  ScramMechanismType
47	Iterations int32
48}
49
50func (r *DescribeUserScramCredentialsResponse) encode(pe packetEncoder) error {
51	pe.putInt32(int32(r.ThrottleTime / time.Millisecond))
52
53	pe.putInt16(int16(r.ErrorCode))
54	if err := pe.putNullableCompactString(r.ErrorMessage); err != nil {
55		return err
56	}
57
58	pe.putCompactArrayLength(len(r.Results))
59	for _, u := range r.Results {
60		if err := pe.putCompactString(u.User); err != nil {
61			return err
62		}
63		pe.putInt16(int16(u.ErrorCode))
64		if err := pe.putNullableCompactString(u.ErrorMessage); err != nil {
65			return err
66		}
67
68		pe.putCompactArrayLength(len(u.CredentialInfos))
69		for _, c := range u.CredentialInfos {
70			pe.putInt8(int8(c.Mechanism))
71			pe.putInt32(c.Iterations)
72			pe.putEmptyTaggedFieldArray()
73		}
74
75		pe.putEmptyTaggedFieldArray()
76	}
77
78	pe.putEmptyTaggedFieldArray()
79	return nil
80}
81
82func (r *DescribeUserScramCredentialsResponse) decode(pd packetDecoder, version int16) error {
83	throttleTime, err := pd.getInt32()
84	if err != nil {
85		return err
86	}
87	r.ThrottleTime = time.Duration(throttleTime) * time.Millisecond
88
89	kerr, err := pd.getInt16()
90	if err != nil {
91		return err
92	}
93
94	r.ErrorCode = KError(kerr)
95	if r.ErrorMessage, err = pd.getCompactNullableString(); err != nil {
96		return err
97	}
98
99	numUsers, err := pd.getCompactArrayLength()
100	if err != nil {
101		return err
102	}
103
104	if numUsers > 0 {
105		r.Results = make([]*DescribeUserScramCredentialsResult, numUsers)
106		for i := 0; i < numUsers; i++ {
107			r.Results[i] = &DescribeUserScramCredentialsResult{}
108			if r.Results[i].User, err = pd.getCompactString(); err != nil {
109				return err
110			}
111
112			errorCode, err := pd.getInt16()
113			if err != nil {
114				return err
115			}
116			r.Results[i].ErrorCode = KError(errorCode)
117			if r.Results[i].ErrorMessage, err = pd.getCompactNullableString(); err != nil {
118				return err
119			}
120
121			numCredentialInfos, err := pd.getCompactArrayLength()
122			if err != nil {
123				return err
124			}
125
126			r.Results[i].CredentialInfos = make([]*UserScramCredentialsResponseInfo, numCredentialInfos)
127			for j := 0; j < numCredentialInfos; j++ {
128				r.Results[i].CredentialInfos[j] = &UserScramCredentialsResponseInfo{}
129				scramMechanism, err := pd.getInt8()
130				if err != nil {
131					return err
132				}
133				r.Results[i].CredentialInfos[j].Mechanism = ScramMechanismType(scramMechanism)
134				if r.Results[i].CredentialInfos[j].Iterations, err = pd.getInt32(); err != nil {
135					return err
136				}
137				if _, err = pd.getEmptyTaggedFieldArray(); err != nil {
138					return err
139				}
140			}
141
142			if _, err = pd.getEmptyTaggedFieldArray(); err != nil {
143				return err
144			}
145		}
146	}
147
148	if _, err = pd.getEmptyTaggedFieldArray(); err != nil {
149		return err
150	}
151	return nil
152}
153
154func (r *DescribeUserScramCredentialsResponse) key() int16 {
155	return 50
156}
157
158func (r *DescribeUserScramCredentialsResponse) version() int16 {
159	return r.Version
160}
161
162func (r *DescribeUserScramCredentialsResponse) headerVersion() int16 {
163	return 2
164}
165
166func (r *DescribeUserScramCredentialsResponse) requiredVersion() KafkaVersion {
167	return V2_7_0_0
168}
169