~ubuntu-branches/ubuntu/quantal/samba/quantal : revision 179

1

/* parser auto-generated by pidl */

2

3

#include "includes.h"

4

#include "librpc/gen_ndr/ndr_samr.h"

5

6

#include "librpc/gen_ndr/ndr_misc.h"

7

#include "librpc/gen_ndr/ndr_lsa.h"

8

#include "librpc/gen_ndr/ndr_security.h"

9

_PUBLIC_ enum ndr_err_code ndr_push_netr_SamDatabaseID(struct ndr_push *ndr, int ndr_flags, enum netr_SamDatabaseID r)

10

{

11

NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));

12

return NDR_ERR_SUCCESS;

13

}

14

15

_PUBLIC_ enum ndr_err_code ndr_pull_netr_SamDatabaseID(struct ndr_pull *ndr, int ndr_flags, enum netr_SamDatabaseID *r)

16

{

17

uint32_t v;

18

NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));

19

*r = v;

20

return NDR_ERR_SUCCESS;

21

}

22

23

_PUBLIC_ void ndr_print_netr_SamDatabaseID(struct ndr_print *ndr, const char *name, enum netr_SamDatabaseID r)

24

{

25

const char *val = NULL;

26

27

switch (r) {

28

case SAM_DATABASE_DOMAIN: val = "SAM_DATABASE_DOMAIN"; break;

29

case SAM_DATABASE_BUILTIN: val = "SAM_DATABASE_BUILTIN"; break;

30

case SAM_DATABASE_PRIVS: val = "SAM_DATABASE_PRIVS"; break;

31

}

32

ndr_print_enum(ndr, name, "ENUM", val, r);

33

}

34

35

_PUBLIC_ enum ndr_err_code ndr_push_samr_AcctFlags(struct ndr_push *ndr, int ndr_flags, uint32_t r)

36

{

37

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));

38

return NDR_ERR_SUCCESS;

39

}

40

41

_PUBLIC_ enum ndr_err_code ndr_pull_samr_AcctFlags(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)

42

{

43

uint32_t v;

44

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));

45

*r = v;

46

return NDR_ERR_SUCCESS;

47

}

48

49

_PUBLIC_ void ndr_print_samr_AcctFlags(struct ndr_print *ndr, const char *name, uint32_t r)

50

{

51

ndr_print_uint32(ndr, name, r);

52

ndr->depth++;

53

ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "ACB_DISABLED", ACB_DISABLED, r);

54

ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "ACB_HOMDIRREQ", ACB_HOMDIRREQ, r);

55

ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "ACB_PWNOTREQ", ACB_PWNOTREQ, r);

56

ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "ACB_TEMPDUP", ACB_TEMPDUP, r);

57

ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "ACB_NORMAL", ACB_NORMAL, r);

58

ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "ACB_MNS", ACB_MNS, r);

59

ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "ACB_DOMTRUST", ACB_DOMTRUST, r);

60

ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "ACB_WSTRUST", ACB_WSTRUST, r);

61

ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "ACB_SVRTRUST", ACB_SVRTRUST, r);

62

ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "ACB_PWNOEXP", ACB_PWNOEXP, r);

63

ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "ACB_AUTOLOCK", ACB_AUTOLOCK, r);

64

ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "ACB_ENC_TXT_PWD_ALLOWED", ACB_ENC_TXT_PWD_ALLOWED, r);

65

ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "ACB_SMARTCARD_REQUIRED", ACB_SMARTCARD_REQUIRED, r);

66

ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "ACB_TRUSTED_FOR_DELEGATION", ACB_TRUSTED_FOR_DELEGATION, r);

67

ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "ACB_NOT_DELEGATED", ACB_NOT_DELEGATED, r);

68

ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "ACB_USE_DES_KEY_ONLY", ACB_USE_DES_KEY_ONLY, r);

69

ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "ACB_DONT_REQUIRE_PREAUTH", ACB_DONT_REQUIRE_PREAUTH, r);

70

ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "ACB_PW_EXPIRED", ACB_PW_EXPIRED, r);

71

ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "ACB_TRUSTED_TO_AUTHENTICATE_FOR_DELEGATION", ACB_TRUSTED_TO_AUTHENTICATE_FOR_DELEGATION, r);

72

ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "ACB_NO_AUTH_DATA_REQD", ACB_NO_AUTH_DATA_REQD, r);

73

ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "ACB_PARTIAL_SECRETS_ACCOUNT", ACB_PARTIAL_SECRETS_ACCOUNT, r);

74

ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "ACB_USE_AES_KEYS", ACB_USE_AES_KEYS, r);

75

ndr->depth--;

76

}

77

78

static enum ndr_err_code ndr_push_samr_ConnectAccessMask(struct ndr_push *ndr, int ndr_flags, uint32_t r)

79

{

80

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));

81

return NDR_ERR_SUCCESS;

82

}

83

84

static enum ndr_err_code ndr_pull_samr_ConnectAccessMask(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)

85

{

86

uint32_t v;

87

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));

88

*r = v;

89

return NDR_ERR_SUCCESS;

90

}

91

92

_PUBLIC_ void ndr_print_samr_ConnectAccessMask(struct ndr_print *ndr, const char *name, uint32_t r)

93

{

94

ndr_print_uint32(ndr, name, r);

95

ndr->depth++;

96

ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_ACCESS_CONNECT_TO_SERVER", SAMR_ACCESS_CONNECT_TO_SERVER, r);

97

ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_ACCESS_SHUTDOWN_SERVER", SAMR_ACCESS_SHUTDOWN_SERVER, r);

98

ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_ACCESS_INITIALIZE_SERVER", SAMR_ACCESS_INITIALIZE_SERVER, r);

99

ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_ACCESS_CREATE_DOMAIN", SAMR_ACCESS_CREATE_DOMAIN, r);

100

ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_ACCESS_ENUM_DOMAINS", SAMR_ACCESS_ENUM_DOMAINS, r);

101

ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_ACCESS_LOOKUP_DOMAIN", SAMR_ACCESS_LOOKUP_DOMAIN, r);

102

ndr->depth--;

103

}

104

105

static enum ndr_err_code ndr_push_samr_UserAccessMask(struct ndr_push *ndr, int ndr_flags, uint32_t r)

106

{

107

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));

108

return NDR_ERR_SUCCESS;

109

}

110

111

static enum ndr_err_code ndr_pull_samr_UserAccessMask(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)

112

{

113

uint32_t v;

114

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));

115

*r = v;

116

return NDR_ERR_SUCCESS;

117

}

118

119

_PUBLIC_ void ndr_print_samr_UserAccessMask(struct ndr_print *ndr, const char *name, uint32_t r)

120

{

121

ndr_print_uint32(ndr, name, r);

122

ndr->depth++;

123

ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_USER_ACCESS_GET_NAME_ETC", SAMR_USER_ACCESS_GET_NAME_ETC, r);

124

ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_USER_ACCESS_GET_LOCALE", SAMR_USER_ACCESS_GET_LOCALE, r);

125

ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_USER_ACCESS_SET_LOC_COM", SAMR_USER_ACCESS_SET_LOC_COM, r);

126

ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_USER_ACCESS_GET_LOGONINFO", SAMR_USER_ACCESS_GET_LOGONINFO, r);

127

ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_USER_ACCESS_GET_ATTRIBUTES", SAMR_USER_ACCESS_GET_ATTRIBUTES, r);

128

ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_USER_ACCESS_SET_ATTRIBUTES", SAMR_USER_ACCESS_SET_ATTRIBUTES, r);

129

ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_USER_ACCESS_CHANGE_PASSWORD", SAMR_USER_ACCESS_CHANGE_PASSWORD, r);

130

ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_USER_ACCESS_SET_PASSWORD", SAMR_USER_ACCESS_SET_PASSWORD, r);

131

ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_USER_ACCESS_GET_GROUPS", SAMR_USER_ACCESS_GET_GROUPS, r);

132

ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_USER_ACCESS_GET_GROUP_MEMBERSHIP", SAMR_USER_ACCESS_GET_GROUP_MEMBERSHIP, r);

133

ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_USER_ACCESS_CHANGE_GROUP_MEMBERSHIP", SAMR_USER_ACCESS_CHANGE_GROUP_MEMBERSHIP, r);

134

ndr->depth--;

135

}

136

137

static enum ndr_err_code ndr_push_samr_DomainAccessMask(struct ndr_push *ndr, int ndr_flags, uint32_t r)

138

{

139

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));

140

return NDR_ERR_SUCCESS;

141

}

142

143

static enum ndr_err_code ndr_pull_samr_DomainAccessMask(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)

144

{

145

uint32_t v;

146

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));

147

*r = v;

148

return NDR_ERR_SUCCESS;

149

}

150

151

_PUBLIC_ void ndr_print_samr_DomainAccessMask(struct ndr_print *ndr, const char *name, uint32_t r)

152

{

153

ndr_print_uint32(ndr, name, r);

154

ndr->depth++;

155

ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_DOMAIN_ACCESS_LOOKUP_INFO_1", SAMR_DOMAIN_ACCESS_LOOKUP_INFO_1, r);

156

ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_DOMAIN_ACCESS_SET_INFO_1", SAMR_DOMAIN_ACCESS_SET_INFO_1, r);

157

ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_DOMAIN_ACCESS_LOOKUP_INFO_2", SAMR_DOMAIN_ACCESS_LOOKUP_INFO_2, r);

158

ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_DOMAIN_ACCESS_SET_INFO_2", SAMR_DOMAIN_ACCESS_SET_INFO_2, r);

159

ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_DOMAIN_ACCESS_CREATE_USER", SAMR_DOMAIN_ACCESS_CREATE_USER, r);

160

ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_DOMAIN_ACCESS_CREATE_GROUP", SAMR_DOMAIN_ACCESS_CREATE_GROUP, r);

161

ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_DOMAIN_ACCESS_CREATE_ALIAS", SAMR_DOMAIN_ACCESS_CREATE_ALIAS, r);

162

ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_DOMAIN_ACCESS_LOOKUP_ALIAS", SAMR_DOMAIN_ACCESS_LOOKUP_ALIAS, r);

163

ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_DOMAIN_ACCESS_ENUM_ACCOUNTS", SAMR_DOMAIN_ACCESS_ENUM_ACCOUNTS, r);

164

ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_DOMAIN_ACCESS_OPEN_ACCOUNT", SAMR_DOMAIN_ACCESS_OPEN_ACCOUNT, r);

165

ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_DOMAIN_ACCESS_SET_INFO_3", SAMR_DOMAIN_ACCESS_SET_INFO_3, r);

166

ndr->depth--;

167

}

168

169

static enum ndr_err_code ndr_push_samr_GroupAccessMask(struct ndr_push *ndr, int ndr_flags, uint32_t r)

170

{

171

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));

172

return NDR_ERR_SUCCESS;

173

}

174

175

static enum ndr_err_code ndr_pull_samr_GroupAccessMask(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)

176

{

177

uint32_t v;

178

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));

179

*r = v;

180

return NDR_ERR_SUCCESS;

181

}

182

183

_PUBLIC_ void ndr_print_samr_GroupAccessMask(struct ndr_print *ndr, const char *name, uint32_t r)

184

{

185

ndr_print_uint32(ndr, name, r);

186

ndr->depth++;

187

ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_GROUP_ACCESS_LOOKUP_INFO", SAMR_GROUP_ACCESS_LOOKUP_INFO, r);

188

ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_GROUP_ACCESS_SET_INFO", SAMR_GROUP_ACCESS_SET_INFO, r);

189

ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_GROUP_ACCESS_ADD_MEMBER", SAMR_GROUP_ACCESS_ADD_MEMBER, r);

190

ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_GROUP_ACCESS_REMOVE_MEMBER", SAMR_GROUP_ACCESS_REMOVE_MEMBER, r);

191

ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_GROUP_ACCESS_GET_MEMBERS", SAMR_GROUP_ACCESS_GET_MEMBERS, r);

192

ndr->depth--;

193

}

194

195

static enum ndr_err_code ndr_push_samr_AliasAccessMask(struct ndr_push *ndr, int ndr_flags, uint32_t r)

196

{

197

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));

198

return NDR_ERR_SUCCESS;

199

}

200

201

static enum ndr_err_code ndr_pull_samr_AliasAccessMask(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)

202

{

203

uint32_t v;

204

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));

205

*r = v;

206

return NDR_ERR_SUCCESS;

207

}

208

209

_PUBLIC_ void ndr_print_samr_AliasAccessMask(struct ndr_print *ndr, const char *name, uint32_t r)

210

{

211

ndr_print_uint32(ndr, name, r);

212

ndr->depth++;

213

ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_ALIAS_ACCESS_ADD_MEMBER", SAMR_ALIAS_ACCESS_ADD_MEMBER, r);

214

ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_ALIAS_ACCESS_REMOVE_MEMBER", SAMR_ALIAS_ACCESS_REMOVE_MEMBER, r);

215

ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_ALIAS_ACCESS_GET_MEMBERS", SAMR_ALIAS_ACCESS_GET_MEMBERS, r);

216

ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_ALIAS_ACCESS_LOOKUP_INFO", SAMR_ALIAS_ACCESS_LOOKUP_INFO, r);

217

ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_ALIAS_ACCESS_SET_INFO", SAMR_ALIAS_ACCESS_SET_INFO, r);

218

ndr->depth--;

219

}

220

221

static enum ndr_err_code ndr_push_samr_SamEntry(struct ndr_push *ndr, int ndr_flags, const struct samr_SamEntry *r)

222

{

223

if (ndr_flags & NDR_SCALARS) {

224

NDR_CHECK(ndr_push_align(ndr, 5));

225

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->idx));

226

NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->name));

227

NDR_CHECK(ndr_push_trailer_align(ndr, 5));

228

}

229

if (ndr_flags & NDR_BUFFERS) {

230

NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->name));

231

}

232

return NDR_ERR_SUCCESS;

233

}

234

235

static enum ndr_err_code ndr_pull_samr_SamEntry(struct ndr_pull *ndr, int ndr_flags, struct samr_SamEntry *r)

236

{

237

if (ndr_flags & NDR_SCALARS) {

238

NDR_CHECK(ndr_pull_align(ndr, 5));

239

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->idx));

240

NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->name));

241

NDR_CHECK(ndr_pull_trailer_align(ndr, 5));

242

}

243

if (ndr_flags & NDR_BUFFERS) {

244

NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->name));

245

}

246

return NDR_ERR_SUCCESS;

247

}

248

249

_PUBLIC_ void ndr_print_samr_SamEntry(struct ndr_print *ndr, const char *name, const struct samr_SamEntry *r)

250

{

251

ndr_print_struct(ndr, name, "samr_SamEntry");

252

if (r == NULL) { ndr_print_null(ndr); return; }

253

ndr->depth++;

254

ndr_print_uint32(ndr, "idx", r->idx);

255

ndr_print_lsa_String(ndr, "name", &r->name);

256

ndr->depth--;

257

}

258

259

static enum ndr_err_code ndr_push_samr_SamArray(struct ndr_push *ndr, int ndr_flags, const struct samr_SamArray *r)

260

{

261

uint32_t cntr_entries_1;

262

if (ndr_flags & NDR_SCALARS) {

263

NDR_CHECK(ndr_push_align(ndr, 5));

264

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));

265

NDR_CHECK(ndr_push_unique_ptr(ndr, r->entries));

266

NDR_CHECK(ndr_push_trailer_align(ndr, 5));

267

}

268

if (ndr_flags & NDR_BUFFERS) {

269

if (r->entries) {

270

NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));

271

for (cntr_entries_1 = 0; cntr_entries_1 < r->count; cntr_entries_1++) {

272

NDR_CHECK(ndr_push_samr_SamEntry(ndr, NDR_SCALARS, &r->entries[cntr_entries_1]));

273

}

274

for (cntr_entries_1 = 0; cntr_entries_1 < r->count; cntr_entries_1++) {

275

NDR_CHECK(ndr_push_samr_SamEntry(ndr, NDR_BUFFERS, &r->entries[cntr_entries_1]));

276

}

277

}

278

}

279

return NDR_ERR_SUCCESS;

280

}

281

282

static enum ndr_err_code ndr_pull_samr_SamArray(struct ndr_pull *ndr, int ndr_flags, struct samr_SamArray *r)

283

{

284

uint32_t _ptr_entries;

285

uint32_t cntr_entries_1;

286

TALLOC_CTX *_mem_save_entries_0;

287

TALLOC_CTX *_mem_save_entries_1;

288

if (ndr_flags & NDR_SCALARS) {

289

NDR_CHECK(ndr_pull_align(ndr, 5));

290

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));

291

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_entries));

292

if (_ptr_entries) {

293

NDR_PULL_ALLOC(ndr, r->entries);

294

} else {

295

r->entries = NULL;

296

}

297

NDR_CHECK(ndr_pull_trailer_align(ndr, 5));

298

}

299

if (ndr_flags & NDR_BUFFERS) {

300

if (r->entries) {

301

_mem_save_entries_0 = NDR_PULL_GET_MEM_CTX(ndr);

302

NDR_PULL_SET_MEM_CTX(ndr, r->entries, 0);

303

NDR_CHECK(ndr_pull_array_size(ndr, &r->entries));

304

NDR_PULL_ALLOC_N(ndr, r->entries, ndr_get_array_size(ndr, &r->entries));

305

_mem_save_entries_1 = NDR_PULL_GET_MEM_CTX(ndr);

306

NDR_PULL_SET_MEM_CTX(ndr, r->entries, 0);

307

for (cntr_entries_1 = 0; cntr_entries_1 < r->count; cntr_entries_1++) {

308

NDR_CHECK(ndr_pull_samr_SamEntry(ndr, NDR_SCALARS, &r->entries[cntr_entries_1]));

309

}

310

for (cntr_entries_1 = 0; cntr_entries_1 < r->count; cntr_entries_1++) {

311

NDR_CHECK(ndr_pull_samr_SamEntry(ndr, NDR_BUFFERS, &r->entries[cntr_entries_1]));

312

}

313

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_entries_1, 0);

314

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_entries_0, 0);

315

}

316

if (r->entries) {

317

NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->entries, r->count));

318

}

319

}

320

return NDR_ERR_SUCCESS;

321

}

322

323

_PUBLIC_ void ndr_print_samr_SamArray(struct ndr_print *ndr, const char *name, const struct samr_SamArray *r)

324

{

325

uint32_t cntr_entries_1;

326

ndr_print_struct(ndr, name, "samr_SamArray");

327

if (r == NULL) { ndr_print_null(ndr); return; }

328

ndr->depth++;

329

ndr_print_uint32(ndr, "count", r->count);

330

ndr_print_ptr(ndr, "entries", r->entries);

331

ndr->depth++;

332

if (r->entries) {

333

ndr->print(ndr, "%s: ARRAY(%d)", "entries", (int)r->count);

334

ndr->depth++;

335

for (cntr_entries_1=0;cntr_entries_1<r->count;cntr_entries_1++) {

336

ndr_print_samr_SamEntry(ndr, "entries", &r->entries[cntr_entries_1]);

337

}

338

ndr->depth--;

339

}

340

ndr->depth--;

341

ndr->depth--;

342

}

343

344

static enum ndr_err_code ndr_push_samr_DomainInfoClass(struct ndr_push *ndr, int ndr_flags, enum samr_DomainInfoClass r)

345

{

346

NDR_CHECK(ndr_push_enum_uint1632(ndr, NDR_SCALARS, r));

347

return NDR_ERR_SUCCESS;

348

}

349

350

static enum ndr_err_code ndr_pull_samr_DomainInfoClass(struct ndr_pull *ndr, int ndr_flags, enum samr_DomainInfoClass *r)

351

{

352

uint16_t v;

353

NDR_CHECK(ndr_pull_enum_uint1632(ndr, NDR_SCALARS, &v));

354

*r = v;

355

return NDR_ERR_SUCCESS;

356

}

357

358

_PUBLIC_ void ndr_print_samr_DomainInfoClass(struct ndr_print *ndr, const char *name, enum samr_DomainInfoClass r)

359

{

360

const char *val = NULL;

361

362

switch (r) {

363

case DomainPasswordInformation: val = "DomainPasswordInformation"; break;

364

case DomainGeneralInformation: val = "DomainGeneralInformation"; break;

365

case DomainLogoffInformation: val = "DomainLogoffInformation"; break;

366

case DomainOemInformation: val = "DomainOemInformation"; break;

367

case DomainNameInformation: val = "DomainNameInformation"; break;

368

case DomainReplicationInformation: val = "DomainReplicationInformation"; break;

369

case DomainServerRoleInformation: val = "DomainServerRoleInformation"; break;

370

case DomainModifiedInformation: val = "DomainModifiedInformation"; break;

371

case DomainStateInformation: val = "DomainStateInformation"; break;

372

case DomainUasInformation: val = "DomainUasInformation"; break;

373

case DomainGeneralInformation2: val = "DomainGeneralInformation2"; break;

374

case DomainLockoutInformation: val = "DomainLockoutInformation"; break;

375

case DomainModifiedInformation2: val = "DomainModifiedInformation2"; break;

376

}

377

ndr_print_enum(ndr, name, "ENUM", val, r);

378

}

379

380

static enum ndr_err_code ndr_push_samr_Role(struct ndr_push *ndr, int ndr_flags, enum samr_Role r)

381

{

382

NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));

383

return NDR_ERR_SUCCESS;

384

}

385

386

static enum ndr_err_code ndr_pull_samr_Role(struct ndr_pull *ndr, int ndr_flags, enum samr_Role *r)

387

{

388

uint32_t v;

389

NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));

390

*r = v;

391

return NDR_ERR_SUCCESS;

392

}

393

394

_PUBLIC_ void ndr_print_samr_Role(struct ndr_print *ndr, const char *name, enum samr_Role r)

395

{

396

const char *val = NULL;

397

398

switch (r) {

399

case SAMR_ROLE_STANDALONE: val = "SAMR_ROLE_STANDALONE"; break;

400

case SAMR_ROLE_DOMAIN_MEMBER: val = "SAMR_ROLE_DOMAIN_MEMBER"; break;

401

case SAMR_ROLE_DOMAIN_BDC: val = "SAMR_ROLE_DOMAIN_BDC"; break;

402

case SAMR_ROLE_DOMAIN_PDC: val = "SAMR_ROLE_DOMAIN_PDC"; break;

403

}

404

ndr_print_enum(ndr, name, "ENUM", val, r);

405

}

406

407

_PUBLIC_ enum ndr_err_code ndr_push_samr_PasswordProperties(struct ndr_push *ndr, int ndr_flags, uint32_t r)

408

{

409

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));

410

return NDR_ERR_SUCCESS;

411

}

412

413

_PUBLIC_ enum ndr_err_code ndr_pull_samr_PasswordProperties(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)

414

{

415

uint32_t v;

416

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));

417

*r = v;

418

return NDR_ERR_SUCCESS;

419

}

420

421

_PUBLIC_ void ndr_print_samr_PasswordProperties(struct ndr_print *ndr, const char *name, uint32_t r)

422

{

423

ndr_print_uint32(ndr, name, r);

424

ndr->depth++;

425

ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DOMAIN_PASSWORD_COMPLEX", DOMAIN_PASSWORD_COMPLEX, r);

426

ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DOMAIN_PASSWORD_NO_ANON_CHANGE", DOMAIN_PASSWORD_NO_ANON_CHANGE, r);

427

ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DOMAIN_PASSWORD_NO_CLEAR_CHANGE", DOMAIN_PASSWORD_NO_CLEAR_CHANGE, r);

428

ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DOMAIN_PASSWORD_LOCKOUT_ADMINS", DOMAIN_PASSWORD_LOCKOUT_ADMINS, r);

429

ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DOMAIN_PASSWORD_STORE_CLEARTEXT", DOMAIN_PASSWORD_STORE_CLEARTEXT, r);

430

ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DOMAIN_REFUSE_PASSWORD_CHANGE", DOMAIN_REFUSE_PASSWORD_CHANGE, r);

431

ndr->depth--;

432

}

433

434

static enum ndr_err_code ndr_push_samr_DomainServerState(struct ndr_push *ndr, int ndr_flags, enum samr_DomainServerState r)

435

{

436

NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));

437

return NDR_ERR_SUCCESS;

438

}

439

440

static enum ndr_err_code ndr_pull_samr_DomainServerState(struct ndr_pull *ndr, int ndr_flags, enum samr_DomainServerState *r)

441

{

442

uint32_t v;

443

NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));

444

*r = v;

445

return NDR_ERR_SUCCESS;

446

}

447

448

_PUBLIC_ void ndr_print_samr_DomainServerState(struct ndr_print *ndr, const char *name, enum samr_DomainServerState r)

449

{

450

const char *val = NULL;

451

452

switch (r) {

453

case DOMAIN_SERVER_ENABLED: val = "DOMAIN_SERVER_ENABLED"; break;

454

case DOMAIN_SERVER_DISABLED: val = "DOMAIN_SERVER_DISABLED"; break;

455

}

456

ndr_print_enum(ndr, name, "ENUM", val, r);

457

}

458

459

static enum ndr_err_code ndr_push_samr_DomInfo1(struct ndr_push *ndr, int ndr_flags, const struct samr_DomInfo1 *r)

460

{

461

if (ndr_flags & NDR_SCALARS) {

462

NDR_CHECK(ndr_push_align(ndr, 4));

463

NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->min_password_length));

464

NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->password_history_length));

465

NDR_CHECK(ndr_push_samr_PasswordProperties(ndr, NDR_SCALARS, r->password_properties));

466

NDR_CHECK(ndr_push_dlong(ndr, NDR_SCALARS, r->max_password_age));

467

NDR_CHECK(ndr_push_dlong(ndr, NDR_SCALARS, r->min_password_age));

468

NDR_CHECK(ndr_push_trailer_align(ndr, 4));

469

}

470

if (ndr_flags & NDR_BUFFERS) {

471

}

472

return NDR_ERR_SUCCESS;

473

}

474

475

static enum ndr_err_code ndr_pull_samr_DomInfo1(struct ndr_pull *ndr, int ndr_flags, struct samr_DomInfo1 *r)

476

{

477

if (ndr_flags & NDR_SCALARS) {

478

NDR_CHECK(ndr_pull_align(ndr, 4));

479

NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->min_password_length));

480

NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->password_history_length));

481

NDR_CHECK(ndr_pull_samr_PasswordProperties(ndr, NDR_SCALARS, &r->password_properties));

482

NDR_CHECK(ndr_pull_dlong(ndr, NDR_SCALARS, &r->max_password_age));

483

NDR_CHECK(ndr_pull_dlong(ndr, NDR_SCALARS, &r->min_password_age));

484

NDR_CHECK(ndr_pull_trailer_align(ndr, 4));

485

}

486

if (ndr_flags & NDR_BUFFERS) {

487

}

488

return NDR_ERR_SUCCESS;

489

}

490

491

_PUBLIC_ void ndr_print_samr_DomInfo1(struct ndr_print *ndr, const char *name, const struct samr_DomInfo1 *r)

492

{

493

ndr_print_struct(ndr, name, "samr_DomInfo1");

494

if (r == NULL) { ndr_print_null(ndr); return; }

495

ndr->depth++;

496

ndr_print_uint16(ndr, "min_password_length", r->min_password_length);

497

ndr_print_uint16(ndr, "password_history_length", r->password_history_length);

498

ndr_print_samr_PasswordProperties(ndr, "password_properties", r->password_properties);

499

ndr_print_dlong(ndr, "max_password_age", r->max_password_age);

500

ndr_print_dlong(ndr, "min_password_age", r->min_password_age);

501

ndr->depth--;

502

}

503

504

static enum ndr_err_code ndr_push_samr_DomGeneralInformation(struct ndr_push *ndr, int ndr_flags, const struct samr_DomGeneralInformation *r)

505

{

506

if (ndr_flags & NDR_SCALARS) {

507

NDR_CHECK(ndr_push_align(ndr, 5));

508

NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->force_logoff_time));

509

NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->oem_information));

510

NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->domain_name));

511

NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->primary));

512

NDR_CHECK(ndr_push_udlong(ndr, NDR_SCALARS, r->sequence_num));

513

NDR_CHECK(ndr_push_samr_DomainServerState(ndr, NDR_SCALARS, r->domain_server_state));

514

NDR_CHECK(ndr_push_samr_Role(ndr, NDR_SCALARS, r->role));

515

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown3));

516

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_users));

517

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_groups));

518

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_aliases));

519

NDR_CHECK(ndr_push_trailer_align(ndr, 5));

520

}

521

if (ndr_flags & NDR_BUFFERS) {

522

NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->oem_information));

523

NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->domain_name));

524

NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->primary));

525

}

526

return NDR_ERR_SUCCESS;

527

}

528

529

static enum ndr_err_code ndr_pull_samr_DomGeneralInformation(struct ndr_pull *ndr, int ndr_flags, struct samr_DomGeneralInformation *r)

530

{

531

if (ndr_flags & NDR_SCALARS) {

532

NDR_CHECK(ndr_pull_align(ndr, 5));

533

NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->force_logoff_time));

534

NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->oem_information));

535

NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->domain_name));

536

NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->primary));

537

NDR_CHECK(ndr_pull_udlong(ndr, NDR_SCALARS, &r->sequence_num));

538

NDR_CHECK(ndr_pull_samr_DomainServerState(ndr, NDR_SCALARS, &r->domain_server_state));

539

NDR_CHECK(ndr_pull_samr_Role(ndr, NDR_SCALARS, &r->role));

540

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown3));

541

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_users));

542

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_groups));

543

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_aliases));

544

NDR_CHECK(ndr_pull_trailer_align(ndr, 5));

545

}

546

if (ndr_flags & NDR_BUFFERS) {

547

NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->oem_information));

548

NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->domain_name));

549

NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->primary));

550

}

551

return NDR_ERR_SUCCESS;

552

}

553

554

_PUBLIC_ void ndr_print_samr_DomGeneralInformation(struct ndr_print *ndr, const char *name, const struct samr_DomGeneralInformation *r)

555

{

556

ndr_print_struct(ndr, name, "samr_DomGeneralInformation");

557

if (r == NULL) { ndr_print_null(ndr); return; }

558

ndr->depth++;

559

ndr_print_NTTIME(ndr, "force_logoff_time", r->force_logoff_time);

560

ndr_print_lsa_String(ndr, "oem_information", &r->oem_information);

561

ndr_print_lsa_String(ndr, "domain_name", &r->domain_name);

562

ndr_print_lsa_String(ndr, "primary", &r->primary);

563

ndr_print_udlong(ndr, "sequence_num", r->sequence_num);

564

ndr_print_samr_DomainServerState(ndr, "domain_server_state", r->domain_server_state);

565

ndr_print_samr_Role(ndr, "role", r->role);

566

ndr_print_uint32(ndr, "unknown3", r->unknown3);

567

ndr_print_uint32(ndr, "num_users", r->num_users);

568

ndr_print_uint32(ndr, "num_groups", r->num_groups);

569

ndr_print_uint32(ndr, "num_aliases", r->num_aliases);

570

ndr->depth--;

571

}

572

573

static enum ndr_err_code ndr_push_samr_DomInfo3(struct ndr_push *ndr, int ndr_flags, const struct samr_DomInfo3 *r)

574

{

575

if (ndr_flags & NDR_SCALARS) {

576

NDR_CHECK(ndr_push_align(ndr, 4));

577

NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->force_logoff_time));

578

NDR_CHECK(ndr_push_trailer_align(ndr, 4));

579

}

580

if (ndr_flags & NDR_BUFFERS) {

581

}

582

return NDR_ERR_SUCCESS;

583

}

584

585

static enum ndr_err_code ndr_pull_samr_DomInfo3(struct ndr_pull *ndr, int ndr_flags, struct samr_DomInfo3 *r)

586

{

587

if (ndr_flags & NDR_SCALARS) {

588

NDR_CHECK(ndr_pull_align(ndr, 4));

589

NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->force_logoff_time));

590

NDR_CHECK(ndr_pull_trailer_align(ndr, 4));

591

}

592

if (ndr_flags & NDR_BUFFERS) {

593

}

594

return NDR_ERR_SUCCESS;

595

}

596

597

_PUBLIC_ void ndr_print_samr_DomInfo3(struct ndr_print *ndr, const char *name, const struct samr_DomInfo3 *r)

598

{

599

ndr_print_struct(ndr, name, "samr_DomInfo3");

600

if (r == NULL) { ndr_print_null(ndr); return; }

601

ndr->depth++;

602

ndr_print_NTTIME(ndr, "force_logoff_time", r->force_logoff_time);

603

ndr->depth--;

604

}

605

606

static enum ndr_err_code ndr_push_samr_DomOEMInformation(struct ndr_push *ndr, int ndr_flags, const struct samr_DomOEMInformation *r)

607

{

608

if (ndr_flags & NDR_SCALARS) {

609

NDR_CHECK(ndr_push_align(ndr, 5));

610

NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->oem_information));

611

NDR_CHECK(ndr_push_trailer_align(ndr, 5));

612

}

613

if (ndr_flags & NDR_BUFFERS) {

614

NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->oem_information));

615

}

616

return NDR_ERR_SUCCESS;

617

}

618

619

static enum ndr_err_code ndr_pull_samr_DomOEMInformation(struct ndr_pull *ndr, int ndr_flags, struct samr_DomOEMInformation *r)

620

{

621

if (ndr_flags & NDR_SCALARS) {

622

NDR_CHECK(ndr_pull_align(ndr, 5));

623

NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->oem_information));

624

NDR_CHECK(ndr_pull_trailer_align(ndr, 5));

625

}

626

if (ndr_flags & NDR_BUFFERS) {

627

NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->oem_information));

628

}

629

return NDR_ERR_SUCCESS;

630

}

631

632

_PUBLIC_ void ndr_print_samr_DomOEMInformation(struct ndr_print *ndr, const char *name, const struct samr_DomOEMInformation *r)

633

{

634

ndr_print_struct(ndr, name, "samr_DomOEMInformation");

635

if (r == NULL) { ndr_print_null(ndr); return; }

636

ndr->depth++;

637

ndr_print_lsa_String(ndr, "oem_information", &r->oem_information);

638

ndr->depth--;

639

}

640

641

static enum ndr_err_code ndr_push_samr_DomInfo5(struct ndr_push *ndr, int ndr_flags, const struct samr_DomInfo5 *r)

642

{

643

if (ndr_flags & NDR_SCALARS) {

644

NDR_CHECK(ndr_push_align(ndr, 5));

645

NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->domain_name));

646

NDR_CHECK(ndr_push_trailer_align(ndr, 5));

647

}

648

if (ndr_flags & NDR_BUFFERS) {

649

NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->domain_name));

650

}

651

return NDR_ERR_SUCCESS;

652

}

653

654

static enum ndr_err_code ndr_pull_samr_DomInfo5(struct ndr_pull *ndr, int ndr_flags, struct samr_DomInfo5 *r)

655

{

656

if (ndr_flags & NDR_SCALARS) {

657

NDR_CHECK(ndr_pull_align(ndr, 5));

658

NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->domain_name));

659

NDR_CHECK(ndr_pull_trailer_align(ndr, 5));

660

}

661

if (ndr_flags & NDR_BUFFERS) {

662

NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->domain_name));

663

}

664

return NDR_ERR_SUCCESS;

665

}

666

667

_PUBLIC_ void ndr_print_samr_DomInfo5(struct ndr_print *ndr, const char *name, const struct samr_DomInfo5 *r)

668

{

669

ndr_print_struct(ndr, name, "samr_DomInfo5");

670

if (r == NULL) { ndr_print_null(ndr); return; }

671

ndr->depth++;

672

ndr_print_lsa_String(ndr, "domain_name", &r->domain_name);

673

ndr->depth--;

674

}

675

676

static enum ndr_err_code ndr_push_samr_DomInfo6(struct ndr_push *ndr, int ndr_flags, const struct samr_DomInfo6 *r)

677

{

678

if (ndr_flags & NDR_SCALARS) {

679

NDR_CHECK(ndr_push_align(ndr, 5));

680

NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->primary));

681

NDR_CHECK(ndr_push_trailer_align(ndr, 5));

682

}

683

if (ndr_flags & NDR_BUFFERS) {

684

NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->primary));

685

}

686

return NDR_ERR_SUCCESS;

687

}

688

689

static enum ndr_err_code ndr_pull_samr_DomInfo6(struct ndr_pull *ndr, int ndr_flags, struct samr_DomInfo6 *r)

690

{

691

if (ndr_flags & NDR_SCALARS) {

692

NDR_CHECK(ndr_pull_align(ndr, 5));

693

NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->primary));

694

NDR_CHECK(ndr_pull_trailer_align(ndr, 5));

695

}

696

if (ndr_flags & NDR_BUFFERS) {

697

NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->primary));

698

}

699

return NDR_ERR_SUCCESS;

700

}

701

702

_PUBLIC_ void ndr_print_samr_DomInfo6(struct ndr_print *ndr, const char *name, const struct samr_DomInfo6 *r)

703

{

704

ndr_print_struct(ndr, name, "samr_DomInfo6");

705

if (r == NULL) { ndr_print_null(ndr); return; }

706

ndr->depth++;

707

ndr_print_lsa_String(ndr, "primary", &r->primary);

708

ndr->depth--;

709

}

710

711

static enum ndr_err_code ndr_push_samr_DomInfo7(struct ndr_push *ndr, int ndr_flags, const struct samr_DomInfo7 *r)

712

{

713

if (ndr_flags & NDR_SCALARS) {

714

NDR_CHECK(ndr_push_align(ndr, 4));

715

NDR_CHECK(ndr_push_samr_Role(ndr, NDR_SCALARS, r->role));

716

NDR_CHECK(ndr_push_trailer_align(ndr, 4));

717

}

718

if (ndr_flags & NDR_BUFFERS) {

719

}

720

return NDR_ERR_SUCCESS;

721

}

722

723

static enum ndr_err_code ndr_pull_samr_DomInfo7(struct ndr_pull *ndr, int ndr_flags, struct samr_DomInfo7 *r)

724

{

725

if (ndr_flags & NDR_SCALARS) {

726

NDR_CHECK(ndr_pull_align(ndr, 4));

727

NDR_CHECK(ndr_pull_samr_Role(ndr, NDR_SCALARS, &r->role));

728

NDR_CHECK(ndr_pull_trailer_align(ndr, 4));

729

}

730

if (ndr_flags & NDR_BUFFERS) {

731

}

732

return NDR_ERR_SUCCESS;

733

}

734

735

_PUBLIC_ void ndr_print_samr_DomInfo7(struct ndr_print *ndr, const char *name, const struct samr_DomInfo7 *r)

736

{

737

ndr_print_struct(ndr, name, "samr_DomInfo7");

738

if (r == NULL) { ndr_print_null(ndr); return; }

739

ndr->depth++;

740

ndr_print_samr_Role(ndr, "role", r->role);

741

ndr->depth--;

742

}

743

744

static enum ndr_err_code ndr_push_samr_DomInfo8(struct ndr_push *ndr, int ndr_flags, const struct samr_DomInfo8 *r)

745

{

746

if (ndr_flags & NDR_SCALARS) {

747

NDR_CHECK(ndr_push_align(ndr, 8));

748

NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->sequence_num));

749

NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->domain_create_time));

750

NDR_CHECK(ndr_push_trailer_align(ndr, 8));

751

}

752

if (ndr_flags & NDR_BUFFERS) {

753

}

754

return NDR_ERR_SUCCESS;

755

}

756

757

static enum ndr_err_code ndr_pull_samr_DomInfo8(struct ndr_pull *ndr, int ndr_flags, struct samr_DomInfo8 *r)

758

{

759

if (ndr_flags & NDR_SCALARS) {

760

NDR_CHECK(ndr_pull_align(ndr, 8));

761

NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->sequence_num));

762

NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->domain_create_time));

763

NDR_CHECK(ndr_pull_trailer_align(ndr, 8));

764

}

765

if (ndr_flags & NDR_BUFFERS) {

766

}

767

return NDR_ERR_SUCCESS;

768

}

769

770

_PUBLIC_ void ndr_print_samr_DomInfo8(struct ndr_print *ndr, const char *name, const struct samr_DomInfo8 *r)

771

{

772

ndr_print_struct(ndr, name, "samr_DomInfo8");

773

if (r == NULL) { ndr_print_null(ndr); return; }

774

ndr->depth++;

775

ndr_print_hyper(ndr, "sequence_num", r->sequence_num);

776

ndr_print_NTTIME(ndr, "domain_create_time", r->domain_create_time);

777

ndr->depth--;

778

}

779

780

static enum ndr_err_code ndr_push_samr_DomInfo9(struct ndr_push *ndr, int ndr_flags, const struct samr_DomInfo9 *r)

781

{

782

if (ndr_flags & NDR_SCALARS) {

783

NDR_CHECK(ndr_push_align(ndr, 4));

784

NDR_CHECK(ndr_push_samr_DomainServerState(ndr, NDR_SCALARS, r->domain_server_state));

785

NDR_CHECK(ndr_push_trailer_align(ndr, 4));

786

}

787

if (ndr_flags & NDR_BUFFERS) {

788

}

789

return NDR_ERR_SUCCESS;

790

}

791

792

static enum ndr_err_code ndr_pull_samr_DomInfo9(struct ndr_pull *ndr, int ndr_flags, struct samr_DomInfo9 *r)

793

{

794

if (ndr_flags & NDR_SCALARS) {

795

NDR_CHECK(ndr_pull_align(ndr, 4));

796

NDR_CHECK(ndr_pull_samr_DomainServerState(ndr, NDR_SCALARS, &r->domain_server_state));

797

NDR_CHECK(ndr_pull_trailer_align(ndr, 4));

798

}

799

if (ndr_flags & NDR_BUFFERS) {

800

}

801

return NDR_ERR_SUCCESS;

802

}

803

804

_PUBLIC_ void ndr_print_samr_DomInfo9(struct ndr_print *ndr, const char *name, const struct samr_DomInfo9 *r)

805

{

806

ndr_print_struct(ndr, name, "samr_DomInfo9");

807

if (r == NULL) { ndr_print_null(ndr); return; }

808

ndr->depth++;

809

ndr_print_samr_DomainServerState(ndr, "domain_server_state", r->domain_server_state);

810

ndr->depth--;

811

}

812

813

static enum ndr_err_code ndr_push_samr_DomGeneralInformation2(struct ndr_push *ndr, int ndr_flags, const struct samr_DomGeneralInformation2 *r)

814

{

815

if (ndr_flags & NDR_SCALARS) {

816

NDR_CHECK(ndr_push_align(ndr, 8));

817

NDR_CHECK(ndr_push_samr_DomGeneralInformation(ndr, NDR_SCALARS, &r->general));

818

NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->lockout_duration));

819

NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->lockout_window));

820

NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->lockout_threshold));

821

NDR_CHECK(ndr_push_trailer_align(ndr, 8));

822

}

823

if (ndr_flags & NDR_BUFFERS) {

824

NDR_CHECK(ndr_push_samr_DomGeneralInformation(ndr, NDR_BUFFERS, &r->general));

825

}

826

return NDR_ERR_SUCCESS;

827

}

828

829

static enum ndr_err_code ndr_pull_samr_DomGeneralInformation2(struct ndr_pull *ndr, int ndr_flags, struct samr_DomGeneralInformation2 *r)

830

{

831

if (ndr_flags & NDR_SCALARS) {

832

NDR_CHECK(ndr_pull_align(ndr, 8));

833

NDR_CHECK(ndr_pull_samr_DomGeneralInformation(ndr, NDR_SCALARS, &r->general));

834

NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->lockout_duration));

835

NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->lockout_window));

836

NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->lockout_threshold));

837

NDR_CHECK(ndr_pull_trailer_align(ndr, 8));

838

}

839

if (ndr_flags & NDR_BUFFERS) {

840

NDR_CHECK(ndr_pull_samr_DomGeneralInformation(ndr, NDR_BUFFERS, &r->general));

841

}

842

return NDR_ERR_SUCCESS;

843

}

844

845

_PUBLIC_ void ndr_print_samr_DomGeneralInformation2(struct ndr_print *ndr, const char *name, const struct samr_DomGeneralInformation2 *r)

846

{

847

ndr_print_struct(ndr, name, "samr_DomGeneralInformation2");

848

if (r == NULL) { ndr_print_null(ndr); return; }

849

ndr->depth++;

850

ndr_print_samr_DomGeneralInformation(ndr, "general", &r->general);

851

ndr_print_hyper(ndr, "lockout_duration", r->lockout_duration);

852

ndr_print_hyper(ndr, "lockout_window", r->lockout_window);

853

ndr_print_uint16(ndr, "lockout_threshold", r->lockout_threshold);

854

ndr->depth--;

855

}

856

857

static enum ndr_err_code ndr_push_samr_DomInfo12(struct ndr_push *ndr, int ndr_flags, const struct samr_DomInfo12 *r)

858

{

859

if (ndr_flags & NDR_SCALARS) {

860

NDR_CHECK(ndr_push_align(ndr, 8));

861

NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->lockout_duration));

862

NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->lockout_window));

863

NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->lockout_threshold));

864

NDR_CHECK(ndr_push_trailer_align(ndr, 8));

865

}

866

if (ndr_flags & NDR_BUFFERS) {

867

}

868

return NDR_ERR_SUCCESS;

869

}

870

871

static enum ndr_err_code ndr_pull_samr_DomInfo12(struct ndr_pull *ndr, int ndr_flags, struct samr_DomInfo12 *r)

872

{

873

if (ndr_flags & NDR_SCALARS) {

874

NDR_CHECK(ndr_pull_align(ndr, 8));

875

NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->lockout_duration));

876

NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->lockout_window));

877

NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->lockout_threshold));

878

NDR_CHECK(ndr_pull_trailer_align(ndr, 8));

879

}

880

if (ndr_flags & NDR_BUFFERS) {

881

}

882

return NDR_ERR_SUCCESS;

883

}

884

885

_PUBLIC_ void ndr_print_samr_DomInfo12(struct ndr_print *ndr, const char *name, const struct samr_DomInfo12 *r)

886

{

887

ndr_print_struct(ndr, name, "samr_DomInfo12");

888

if (r == NULL) { ndr_print_null(ndr); return; }

889

ndr->depth++;

890

ndr_print_hyper(ndr, "lockout_duration", r->lockout_duration);

891

ndr_print_hyper(ndr, "lockout_window", r->lockout_window);

892

ndr_print_uint16(ndr, "lockout_threshold", r->lockout_threshold);

893

ndr->depth--;

894

}

895

896

static enum ndr_err_code ndr_push_samr_DomInfo13(struct ndr_push *ndr, int ndr_flags, const struct samr_DomInfo13 *r)

897

{

898

if (ndr_flags & NDR_SCALARS) {

899

NDR_CHECK(ndr_push_align(ndr, 8));

900

NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->sequence_num));

901

NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->domain_create_time));

902

NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->modified_count_at_last_promotion));

903

NDR_CHECK(ndr_push_trailer_align(ndr, 8));

904

}

905

if (ndr_flags & NDR_BUFFERS) {

906

}

907

return NDR_ERR_SUCCESS;

908

}

909

910

static enum ndr_err_code ndr_pull_samr_DomInfo13(struct ndr_pull *ndr, int ndr_flags, struct samr_DomInfo13 *r)

911

{

912

if (ndr_flags & NDR_SCALARS) {

913

NDR_CHECK(ndr_pull_align(ndr, 8));

914

NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->sequence_num));

915

NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->domain_create_time));

916

NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->modified_count_at_last_promotion));

917

NDR_CHECK(ndr_pull_trailer_align(ndr, 8));

918

}

919

if (ndr_flags & NDR_BUFFERS) {

920

}

921

return NDR_ERR_SUCCESS;

922

}

923

924

_PUBLIC_ void ndr_print_samr_DomInfo13(struct ndr_print *ndr, const char *name, const struct samr_DomInfo13 *r)

925

{

926

ndr_print_struct(ndr, name, "samr_DomInfo13");

927

if (r == NULL) { ndr_print_null(ndr); return; }

928

ndr->depth++;

929

ndr_print_hyper(ndr, "sequence_num", r->sequence_num);

930

ndr_print_NTTIME(ndr, "domain_create_time", r->domain_create_time);

931

ndr_print_hyper(ndr, "modified_count_at_last_promotion", r->modified_count_at_last_promotion);

932

ndr->depth--;

933

}

934

935

static enum ndr_err_code ndr_push_samr_DomainInfo(struct ndr_push *ndr, int ndr_flags, const union samr_DomainInfo *r)

936

{

937

if (ndr_flags & NDR_SCALARS) {

938

uint32_t level = ndr_push_get_switch_value(ndr, r);

939

NDR_CHECK(ndr_push_union_align(ndr, 8));

940

NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, level));

941

NDR_CHECK(ndr_push_union_align(ndr, 8));

942

switch (level) {

943

case 1: {

944

NDR_CHECK(ndr_push_samr_DomInfo1(ndr, NDR_SCALARS, &r->info1));

945

break; }

946

947

case 2: {

948

NDR_CHECK(ndr_push_samr_DomGeneralInformation(ndr, NDR_SCALARS, &r->general));

949

break; }

950

951

case 3: {

952

NDR_CHECK(ndr_push_samr_DomInfo3(ndr, NDR_SCALARS, &r->info3));

953

break; }

954

955

case 4: {

956

NDR_CHECK(ndr_push_samr_DomOEMInformation(ndr, NDR_SCALARS, &r->oem));

957

break; }

958

959

case 5: {

960

NDR_CHECK(ndr_push_samr_DomInfo5(ndr, NDR_SCALARS, &r->info5));

961

break; }

962

963

case 6: {

964

NDR_CHECK(ndr_push_samr_DomInfo6(ndr, NDR_SCALARS, &r->info6));

965

break; }

966

967

case 7: {

968

NDR_CHECK(ndr_push_samr_DomInfo7(ndr, NDR_SCALARS, &r->info7));

969

break; }

970

971

case 8: {

972

NDR_CHECK(ndr_push_samr_DomInfo8(ndr, NDR_SCALARS, &r->info8));

973

break; }

974

975

case 9: {

976

NDR_CHECK(ndr_push_samr_DomInfo9(ndr, NDR_SCALARS, &r->info9));

977

break; }

978

979

case 11: {

980

NDR_CHECK(ndr_push_samr_DomGeneralInformation2(ndr, NDR_SCALARS, &r->general2));

981

break; }

982

983

case 12: {

984

NDR_CHECK(ndr_push_samr_DomInfo12(ndr, NDR_SCALARS, &r->info12));

985

break; }

986

987

case 13: {

988

NDR_CHECK(ndr_push_samr_DomInfo13(ndr, NDR_SCALARS, &r->info13));

989

break; }

990

991

default:

992

return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);

993

}

994

}

995

if (ndr_flags & NDR_BUFFERS) {

996

uint32_t level = ndr_push_get_switch_value(ndr, r);

997

switch (level) {

998

case 1:

999

break;

1000

1001

case 2:

1002

NDR_CHECK(ndr_push_samr_DomGeneralInformation(ndr, NDR_BUFFERS, &r->general));

1003

break;

1004

1005

case 3:

1006

break;

1007

1008

case 4:

1009

NDR_CHECK(ndr_push_samr_DomOEMInformation(ndr, NDR_BUFFERS, &r->oem));

1010

break;

1011

1012

case 5:

1013

NDR_CHECK(ndr_push_samr_DomInfo5(ndr, NDR_BUFFERS, &r->info5));

1014

break;

1015

1016

case 6:

1017

NDR_CHECK(ndr_push_samr_DomInfo6(ndr, NDR_BUFFERS, &r->info6));

1018

break;

1019

1020

case 7:

1021

break;

1022

1023

case 8:

1024

break;

1025

1026

case 9:

1027

break;

1028

1029

case 11:

1030

NDR_CHECK(ndr_push_samr_DomGeneralInformation2(ndr, NDR_BUFFERS, &r->general2));

1031

break;

1032

1033

case 12:

1034

break;

1035

1036

case 13:

1037

break;

1038

1039

default:

1040

return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);

1041

}

1042

}

1043

return NDR_ERR_SUCCESS;

1044

}

1045

1046

static enum ndr_err_code ndr_pull_samr_DomainInfo(struct ndr_pull *ndr, int ndr_flags, union samr_DomainInfo *r)

1047

{

1048

uint32_t level;

1049

uint16_t _level;

1050

level = ndr_pull_get_switch_value(ndr, r);

1051

if (ndr_flags & NDR_SCALARS) {

1052

NDR_CHECK(ndr_pull_union_align(ndr, 8));

1053

NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &_level));

1054

if (_level != level) {

1055

return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);

1056

}

1057

NDR_CHECK(ndr_pull_union_align(ndr, 8));

1058

switch (level) {

1059

case 1: {

1060

NDR_CHECK(ndr_pull_samr_DomInfo1(ndr, NDR_SCALARS, &r->info1));

1061

break; }

1062

1063

case 2: {

1064

NDR_CHECK(ndr_pull_samr_DomGeneralInformation(ndr, NDR_SCALARS, &r->general));

1065

break; }

1066

1067

case 3: {

1068

NDR_CHECK(ndr_pull_samr_DomInfo3(ndr, NDR_SCALARS, &r->info3));

1069

break; }

1070

1071

case 4: {

1072

NDR_CHECK(ndr_pull_samr_DomOEMInformation(ndr, NDR_SCALARS, &r->oem));

1073

break; }

1074

1075

case 5: {

1076

NDR_CHECK(ndr_pull_samr_DomInfo5(ndr, NDR_SCALARS, &r->info5));

1077

break; }

1078

1079

case 6: {

1080

NDR_CHECK(ndr_pull_samr_DomInfo6(ndr, NDR_SCALARS, &r->info6));

1081

break; }

1082

1083

case 7: {

1084

NDR_CHECK(ndr_pull_samr_DomInfo7(ndr, NDR_SCALARS, &r->info7));

1085

break; }

1086

1087

case 8: {

1088

NDR_CHECK(ndr_pull_samr_DomInfo8(ndr, NDR_SCALARS, &r->info8));

1089

break; }

1090

1091

case 9: {

1092

NDR_CHECK(ndr_pull_samr_DomInfo9(ndr, NDR_SCALARS, &r->info9));

1093

break; }

1094

1095

case 11: {

1096

NDR_CHECK(ndr_pull_samr_DomGeneralInformation2(ndr, NDR_SCALARS, &r->general2));

1097

break; }

1098

1099

case 12: {

1100

NDR_CHECK(ndr_pull_samr_DomInfo12(ndr, NDR_SCALARS, &r->info12));

1101

break; }

1102

1103

case 13: {

1104

NDR_CHECK(ndr_pull_samr_DomInfo13(ndr, NDR_SCALARS, &r->info13));

1105

break; }

1106

1107

default:

1108

return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);

1109

}

1110

}

1111

if (ndr_flags & NDR_BUFFERS) {

1112

switch (level) {

1113

case 1:

1114

break;

1115

1116

case 2:

1117

NDR_CHECK(ndr_pull_samr_DomGeneralInformation(ndr, NDR_BUFFERS, &r->general));

1118

break;

1119

1120

case 3:

1121

break;

1122

1123

case 4:

1124

NDR_CHECK(ndr_pull_samr_DomOEMInformation(ndr, NDR_BUFFERS, &r->oem));

1125

break;

1126

1127

case 5:

1128

NDR_CHECK(ndr_pull_samr_DomInfo5(ndr, NDR_BUFFERS, &r->info5));

1129

break;

1130

1131

case 6:

1132

NDR_CHECK(ndr_pull_samr_DomInfo6(ndr, NDR_BUFFERS, &r->info6));

1133

break;

1134

1135

case 7:

1136

break;

1137

1138

case 8:

1139

break;

1140

1141

case 9:

1142

break;

1143

1144

case 11:

1145

NDR_CHECK(ndr_pull_samr_DomGeneralInformation2(ndr, NDR_BUFFERS, &r->general2));

1146

break;

1147

1148

case 12:

1149

break;

1150

1151

case 13:

1152

break;

1153

1154

default:

1155

return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);

1156

}

1157

}

1158

return NDR_ERR_SUCCESS;

1159

}

1160

1161

_PUBLIC_ void ndr_print_samr_DomainInfo(struct ndr_print *ndr, const char *name, const union samr_DomainInfo *r)

1162

{

1163

uint32_t level;

1164

level = ndr_print_get_switch_value(ndr, r);

1165

ndr_print_union(ndr, name, level, "samr_DomainInfo");

1166

switch (level) {

1167

case 1:

1168

ndr_print_samr_DomInfo1(ndr, "info1", &r->info1);

1169

break;

1170

1171

case 2:

1172

ndr_print_samr_DomGeneralInformation(ndr, "general", &r->general);

1173

break;

1174

1175

case 3:

1176

ndr_print_samr_DomInfo3(ndr, "info3", &r->info3);

1177

break;

1178

1179

case 4:

1180

ndr_print_samr_DomOEMInformation(ndr, "oem", &r->oem);

1181

break;

1182

1183

case 5:

1184

ndr_print_samr_DomInfo5(ndr, "info5", &r->info5);

1185

break;

1186

1187

case 6:

1188

ndr_print_samr_DomInfo6(ndr, "info6", &r->info6);

1189

break;

1190

1191

case 7:

1192

ndr_print_samr_DomInfo7(ndr, "info7", &r->info7);

1193

break;

1194

1195

case 8:

1196

ndr_print_samr_DomInfo8(ndr, "info8", &r->info8);

1197

break;

1198

1199

case 9:

1200

ndr_print_samr_DomInfo9(ndr, "info9", &r->info9);

1201

break;

1202

1203

case 11:

1204

ndr_print_samr_DomGeneralInformation2(ndr, "general2", &r->general2);

1205

break;

1206

1207

case 12:

1208

ndr_print_samr_DomInfo12(ndr, "info12", &r->info12);

1209

break;

1210

1211

case 13:

1212

ndr_print_samr_DomInfo13(ndr, "info13", &r->info13);

1213

break;

1214

1215

default:

1216

ndr_print_bad_level(ndr, name, level);

1217

}

1218

}

1219

1220

static enum ndr_err_code ndr_push_samr_Ids(struct ndr_push *ndr, int ndr_flags, const struct samr_Ids *r)

1221

{

1222

uint32_t cntr_ids_1;

1223

if (ndr_flags & NDR_SCALARS) {

1224

NDR_CHECK(ndr_push_align(ndr, 5));

1225

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));

1226

NDR_CHECK(ndr_push_unique_ptr(ndr, r->ids));

1227

NDR_CHECK(ndr_push_trailer_align(ndr, 5));

1228

}

1229

if (ndr_flags & NDR_BUFFERS) {

1230

if (r->ids) {

1231

NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));

1232

for (cntr_ids_1 = 0; cntr_ids_1 < r->count; cntr_ids_1++) {

1233

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->ids[cntr_ids_1]));

1234

}

1235

}

1236

}

1237

return NDR_ERR_SUCCESS;

1238

}

1239

1240

static enum ndr_err_code ndr_pull_samr_Ids(struct ndr_pull *ndr, int ndr_flags, struct samr_Ids *r)

1241

{

1242

uint32_t _ptr_ids;

1243

uint32_t cntr_ids_1;

1244

TALLOC_CTX *_mem_save_ids_0;

1245

TALLOC_CTX *_mem_save_ids_1;

1246

if (ndr_flags & NDR_SCALARS) {

1247

NDR_CHECK(ndr_pull_align(ndr, 5));

1248

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));

1249

if (r->count > 1024) {

1250

return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");

1251

}

1252

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_ids));

1253

if (_ptr_ids) {

1254

NDR_PULL_ALLOC(ndr, r->ids);

1255

} else {

1256

r->ids = NULL;

1257

}

1258

NDR_CHECK(ndr_pull_trailer_align(ndr, 5));

1259

}

1260

if (ndr_flags & NDR_BUFFERS) {

1261

if (r->ids) {

1262

_mem_save_ids_0 = NDR_PULL_GET_MEM_CTX(ndr);

1263

NDR_PULL_SET_MEM_CTX(ndr, r->ids, 0);

1264

NDR_CHECK(ndr_pull_array_size(ndr, &r->ids));

1265

NDR_PULL_ALLOC_N(ndr, r->ids, ndr_get_array_size(ndr, &r->ids));

1266

_mem_save_ids_1 = NDR_PULL_GET_MEM_CTX(ndr);

1267

NDR_PULL_SET_MEM_CTX(ndr, r->ids, 0);

1268

for (cntr_ids_1 = 0; cntr_ids_1 < r->count; cntr_ids_1++) {

1269

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->ids[cntr_ids_1]));

1270

}

1271

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ids_1, 0);

1272

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ids_0, 0);

1273

}

1274

if (r->ids) {

1275

NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->ids, r->count));

1276

}

1277

}

1278

return NDR_ERR_SUCCESS;

1279

}

1280

1281

_PUBLIC_ void ndr_print_samr_Ids(struct ndr_print *ndr, const char *name, const struct samr_Ids *r)

1282

{

1283

uint32_t cntr_ids_1;

1284

ndr_print_struct(ndr, name, "samr_Ids");

1285

if (r == NULL) { ndr_print_null(ndr); return; }

1286

ndr->depth++;

1287

ndr_print_uint32(ndr, "count", r->count);

1288

ndr_print_ptr(ndr, "ids", r->ids);

1289

ndr->depth++;

1290

if (r->ids) {

1291

ndr->print(ndr, "%s: ARRAY(%d)", "ids", (int)r->count);

1292

ndr->depth++;

1293

for (cntr_ids_1=0;cntr_ids_1<r->count;cntr_ids_1++) {

1294

ndr_print_uint32(ndr, "ids", r->ids[cntr_ids_1]);

1295

}

1296

ndr->depth--;

1297

}

1298

ndr->depth--;

1299

ndr->depth--;

1300

}

1301

1302

_PUBLIC_ enum ndr_err_code ndr_push_samr_GroupAttrs(struct ndr_push *ndr, int ndr_flags, uint32_t r)

1303

{

1304

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));

1305

return NDR_ERR_SUCCESS;

1306

}

1307

1308

_PUBLIC_ enum ndr_err_code ndr_pull_samr_GroupAttrs(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)

1309

{

1310

uint32_t v;

1311

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));

1312

*r = v;

1313

return NDR_ERR_SUCCESS;

1314

}

1315

1316

_PUBLIC_ void ndr_print_samr_GroupAttrs(struct ndr_print *ndr, const char *name, uint32_t r)

1317

{

1318

ndr_print_uint32(ndr, name, r);

1319

ndr->depth++;

1320

ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SE_GROUP_MANDATORY", SE_GROUP_MANDATORY, r);

1321

ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SE_GROUP_ENABLED_BY_DEFAULT", SE_GROUP_ENABLED_BY_DEFAULT, r);

1322

ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SE_GROUP_ENABLED", SE_GROUP_ENABLED, r);

1323

ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SE_GROUP_OWNER", SE_GROUP_OWNER, r);

1324

ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SE_GROUP_USE_FOR_DENY_ONLY", SE_GROUP_USE_FOR_DENY_ONLY, r);

1325

ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SE_GROUP_RESOURCE", SE_GROUP_RESOURCE, r);

1326

ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SE_GROUP_LOGON_ID", SE_GROUP_LOGON_ID, r);

1327

ndr->depth--;

1328

}

1329

1330

static enum ndr_err_code ndr_push_samr_GroupInfoAll(struct ndr_push *ndr, int ndr_flags, const struct samr_GroupInfoAll *r)

1331

{

1332

if (ndr_flags & NDR_SCALARS) {

1333

NDR_CHECK(ndr_push_align(ndr, 5));

1334

NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->name));

1335

NDR_CHECK(ndr_push_samr_GroupAttrs(ndr, NDR_SCALARS, r->attributes));

1336

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_members));

1337

NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->description));

1338

NDR_CHECK(ndr_push_trailer_align(ndr, 5));

1339

}

1340

if (ndr_flags & NDR_BUFFERS) {

1341

NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->name));

1342

NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->description));

1343

}

1344

return NDR_ERR_SUCCESS;

1345

}

1346

1347

static enum ndr_err_code ndr_pull_samr_GroupInfoAll(struct ndr_pull *ndr, int ndr_flags, struct samr_GroupInfoAll *r)

1348

{

1349

if (ndr_flags & NDR_SCALARS) {

1350

NDR_CHECK(ndr_pull_align(ndr, 5));

1351

NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->name));

1352

NDR_CHECK(ndr_pull_samr_GroupAttrs(ndr, NDR_SCALARS, &r->attributes));

1353

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_members));

1354

NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->description));

1355

NDR_CHECK(ndr_pull_trailer_align(ndr, 5));

1356

}

1357

if (ndr_flags & NDR_BUFFERS) {

1358

NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->name));

1359

NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->description));

1360

}

1361

return NDR_ERR_SUCCESS;

1362

}

1363

1364

_PUBLIC_ void ndr_print_samr_GroupInfoAll(struct ndr_print *ndr, const char *name, const struct samr_GroupInfoAll *r)

1365

{

1366

ndr_print_struct(ndr, name, "samr_GroupInfoAll");

1367

if (r == NULL) { ndr_print_null(ndr); return; }

1368

ndr->depth++;

1369

ndr_print_lsa_String(ndr, "name", &r->name);

1370

ndr_print_samr_GroupAttrs(ndr, "attributes", r->attributes);

1371

ndr_print_uint32(ndr, "num_members", r->num_members);

1372

ndr_print_lsa_String(ndr, "description", &r->description);

1373

ndr->depth--;

1374

}

1375

1376

static enum ndr_err_code ndr_push_samr_GroupInfoAttributes(struct ndr_push *ndr, int ndr_flags, const struct samr_GroupInfoAttributes *r)

1377

{

1378

if (ndr_flags & NDR_SCALARS) {

1379

NDR_CHECK(ndr_push_align(ndr, 4));

1380

NDR_CHECK(ndr_push_samr_GroupAttrs(ndr, NDR_SCALARS, r->attributes));

1381

NDR_CHECK(ndr_push_trailer_align(ndr, 4));

1382

}

1383

if (ndr_flags & NDR_BUFFERS) {

1384

}

1385

return NDR_ERR_SUCCESS;

1386

}

1387

1388

static enum ndr_err_code ndr_pull_samr_GroupInfoAttributes(struct ndr_pull *ndr, int ndr_flags, struct samr_GroupInfoAttributes *r)

1389

{

1390

if (ndr_flags & NDR_SCALARS) {

1391

NDR_CHECK(ndr_pull_align(ndr, 4));

1392

NDR_CHECK(ndr_pull_samr_GroupAttrs(ndr, NDR_SCALARS, &r->attributes));

1393

NDR_CHECK(ndr_pull_trailer_align(ndr, 4));

1394

}

1395

if (ndr_flags & NDR_BUFFERS) {

1396

}

1397

return NDR_ERR_SUCCESS;

1398

}

1399

1400

_PUBLIC_ void ndr_print_samr_GroupInfoAttributes(struct ndr_print *ndr, const char *name, const struct samr_GroupInfoAttributes *r)

1401

{

1402

ndr_print_struct(ndr, name, "samr_GroupInfoAttributes");

1403

if (r == NULL) { ndr_print_null(ndr); return; }

1404

ndr->depth++;

1405

ndr_print_samr_GroupAttrs(ndr, "attributes", r->attributes);

1406

ndr->depth--;

1407

}

1408

1409

static enum ndr_err_code ndr_push_samr_GroupInfoEnum(struct ndr_push *ndr, int ndr_flags, enum samr_GroupInfoEnum r)

1410

{

1411

NDR_CHECK(ndr_push_enum_uint1632(ndr, NDR_SCALARS, r));

1412

return NDR_ERR_SUCCESS;

1413

}

1414

1415

static enum ndr_err_code ndr_pull_samr_GroupInfoEnum(struct ndr_pull *ndr, int ndr_flags, enum samr_GroupInfoEnum *r)

1416

{

1417

uint16_t v;

1418

NDR_CHECK(ndr_pull_enum_uint1632(ndr, NDR_SCALARS, &v));

1419

*r = v;

1420

return NDR_ERR_SUCCESS;

1421

}

1422

1423

_PUBLIC_ void ndr_print_samr_GroupInfoEnum(struct ndr_print *ndr, const char *name, enum samr_GroupInfoEnum r)

1424

{

1425

const char *val = NULL;

1426

1427

switch (r) {

1428

case GROUPINFOALL: val = "GROUPINFOALL"; break;

1429

case GROUPINFONAME: val = "GROUPINFONAME"; break;

1430

case GROUPINFOATTRIBUTES: val = "GROUPINFOATTRIBUTES"; break;

1431

case GROUPINFODESCRIPTION: val = "GROUPINFODESCRIPTION"; break;

1432

case GROUPINFOALL2: val = "GROUPINFOALL2"; break;

1433

}

1434

ndr_print_enum(ndr, name, "ENUM", val, r);

1435

}

1436

1437

static enum ndr_err_code ndr_push_samr_GroupInfo(struct ndr_push *ndr, int ndr_flags, const union samr_GroupInfo *r)

1438

{

1439

if (ndr_flags & NDR_SCALARS) {

1440

uint32_t level = ndr_push_get_switch_value(ndr, r);

1441

NDR_CHECK(ndr_push_union_align(ndr, 5));

1442

NDR_CHECK(ndr_push_samr_GroupInfoEnum(ndr, NDR_SCALARS, level));

1443

NDR_CHECK(ndr_push_union_align(ndr, 5));

1444

switch (level) {

1445

case GROUPINFOALL: {

1446

NDR_CHECK(ndr_push_samr_GroupInfoAll(ndr, NDR_SCALARS, &r->all));

1447

break; }

1448

1449

case GROUPINFONAME: {

1450

NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->name));

1451

break; }

1452

1453

case GROUPINFOATTRIBUTES: {

1454

NDR_CHECK(ndr_push_samr_GroupInfoAttributes(ndr, NDR_SCALARS, &r->attributes));

1455

break; }

1456

1457

case GROUPINFODESCRIPTION: {

1458

NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->description));

1459

break; }

1460

1461

case GROUPINFOALL2: {

1462

NDR_CHECK(ndr_push_samr_GroupInfoAll(ndr, NDR_SCALARS, &r->all2));

1463

break; }

1464

1465

default:

1466

return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);

1467

}

1468

}

1469

if (ndr_flags & NDR_BUFFERS) {

1470

uint32_t level = ndr_push_get_switch_value(ndr, r);

1471

switch (level) {

1472

case GROUPINFOALL:

1473

NDR_CHECK(ndr_push_samr_GroupInfoAll(ndr, NDR_BUFFERS, &r->all));

1474

break;

1475

1476

case GROUPINFONAME:

1477

NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->name));

1478

break;

1479

1480

case GROUPINFOATTRIBUTES:

1481

break;

1482

1483

case GROUPINFODESCRIPTION:

1484

NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->description));

1485

break;

1486

1487

case GROUPINFOALL2:

1488

NDR_CHECK(ndr_push_samr_GroupInfoAll(ndr, NDR_BUFFERS, &r->all2));

1489

break;

1490

1491

default:

1492

return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);

1493

}

1494

}

1495

return NDR_ERR_SUCCESS;

1496

}

1497

1498

static enum ndr_err_code ndr_pull_samr_GroupInfo(struct ndr_pull *ndr, int ndr_flags, union samr_GroupInfo *r)

1499

{

1500

uint32_t level;

1501

uint16_t _level;

1502

level = ndr_pull_get_switch_value(ndr, r);

1503

if (ndr_flags & NDR_SCALARS) {

1504

NDR_CHECK(ndr_pull_union_align(ndr, 5));

1505

NDR_CHECK(ndr_pull_uint1632(ndr, NDR_SCALARS, &_level));

1506

if (_level != level) {

1507

return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);

1508

}

1509

NDR_CHECK(ndr_pull_union_align(ndr, 5));

1510

switch (level) {

1511

case GROUPINFOALL: {

1512

NDR_CHECK(ndr_pull_samr_GroupInfoAll(ndr, NDR_SCALARS, &r->all));

1513

break; }

1514

1515

case GROUPINFONAME: {

1516

NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->name));

1517

break; }

1518

1519

case GROUPINFOATTRIBUTES: {

1520

NDR_CHECK(ndr_pull_samr_GroupInfoAttributes(ndr, NDR_SCALARS, &r->attributes));

1521

break; }

1522

1523

case GROUPINFODESCRIPTION: {

1524

NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->description));

1525

break; }

1526

1527

case GROUPINFOALL2: {

1528

NDR_CHECK(ndr_pull_samr_GroupInfoAll(ndr, NDR_SCALARS, &r->all2));

1529

break; }

1530

1531

default:

1532

return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);

1533

}

1534

}

1535

if (ndr_flags & NDR_BUFFERS) {

1536

switch (level) {

1537

case GROUPINFOALL:

1538

NDR_CHECK(ndr_pull_samr_GroupInfoAll(ndr, NDR_BUFFERS, &r->all));

1539

break;

1540

1541

case GROUPINFONAME:

1542

NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->name));

1543

break;

1544

1545

case GROUPINFOATTRIBUTES:

1546

break;

1547

1548

case GROUPINFODESCRIPTION:

1549

NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->description));

1550

break;

1551

1552

case GROUPINFOALL2:

1553

NDR_CHECK(ndr_pull_samr_GroupInfoAll(ndr, NDR_BUFFERS, &r->all2));

1554

break;

1555

1556

default:

1557

return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);

1558

}

1559

}

1560

return NDR_ERR_SUCCESS;

1561

}

1562

1563

_PUBLIC_ void ndr_print_samr_GroupInfo(struct ndr_print *ndr, const char *name, const union samr_GroupInfo *r)

1564

{

1565

uint32_t level;

1566

level = ndr_print_get_switch_value(ndr, r);

1567

ndr_print_union(ndr, name, level, "samr_GroupInfo");

1568

switch (level) {

1569

case GROUPINFOALL:

1570

ndr_print_samr_GroupInfoAll(ndr, "all", &r->all);

1571

break;

1572

1573

case GROUPINFONAME:

1574

ndr_print_lsa_String(ndr, "name", &r->name);

1575

break;

1576

1577

case GROUPINFOATTRIBUTES:

1578

ndr_print_samr_GroupInfoAttributes(ndr, "attributes", &r->attributes);

1579

break;

1580

1581

case GROUPINFODESCRIPTION:

1582

ndr_print_lsa_String(ndr, "description", &r->description);

1583

break;

1584

1585

case GROUPINFOALL2:

1586

ndr_print_samr_GroupInfoAll(ndr, "all2", &r->all2);

1587

break;

1588

1589

default:

1590

ndr_print_bad_level(ndr, name, level);

1591

}

1592

}

1593

1594

static enum ndr_err_code ndr_push_samr_RidAttrArray(struct ndr_push *ndr, int ndr_flags, const struct samr_RidAttrArray *r)

1595

{

1596

uint32_t cntr_rids_1;

1597

uint32_t cntr_attributes_1;

1598

if (ndr_flags & NDR_SCALARS) {

1599

NDR_CHECK(ndr_push_align(ndr, 5));

1600

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));

1601

NDR_CHECK(ndr_push_unique_ptr(ndr, r->rids));

1602

NDR_CHECK(ndr_push_unique_ptr(ndr, r->attributes));

1603

NDR_CHECK(ndr_push_trailer_align(ndr, 5));

1604

}

1605

if (ndr_flags & NDR_BUFFERS) {

1606

if (r->rids) {

1607

NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));

1608

for (cntr_rids_1 = 0; cntr_rids_1 < r->count; cntr_rids_1++) {

1609

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->rids[cntr_rids_1]));

1610

}

1611

}

1612

if (r->attributes) {

1613

NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));

1614

for (cntr_attributes_1 = 0; cntr_attributes_1 < r->count; cntr_attributes_1++) {

1615

NDR_CHECK(ndr_push_samr_GroupAttrs(ndr, NDR_SCALARS, r->attributes[cntr_attributes_1]));

1616

}

1617

}

1618

}

1619

return NDR_ERR_SUCCESS;

1620

}

1621

1622

static enum ndr_err_code ndr_pull_samr_RidAttrArray(struct ndr_pull *ndr, int ndr_flags, struct samr_RidAttrArray *r)

1623

{

1624

uint32_t _ptr_rids;

1625

uint32_t cntr_rids_1;

1626

TALLOC_CTX *_mem_save_rids_0;

1627

TALLOC_CTX *_mem_save_rids_1;

1628

uint32_t _ptr_attributes;

1629

uint32_t cntr_attributes_1;

1630

TALLOC_CTX *_mem_save_attributes_0;

1631

TALLOC_CTX *_mem_save_attributes_1;

1632

if (ndr_flags & NDR_SCALARS) {

1633

NDR_CHECK(ndr_pull_align(ndr, 5));

1634

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));

1635

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_rids));

1636

if (_ptr_rids) {

1637

NDR_PULL_ALLOC(ndr, r->rids);

1638

} else {

1639

r->rids = NULL;

1640

}

1641

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_attributes));

1642

if (_ptr_attributes) {

1643

NDR_PULL_ALLOC(ndr, r->attributes);

1644

} else {

1645

r->attributes = NULL;

1646

}

1647

NDR_CHECK(ndr_pull_trailer_align(ndr, 5));

1648

}

1649

if (ndr_flags & NDR_BUFFERS) {

1650

if (r->rids) {

1651

_mem_save_rids_0 = NDR_PULL_GET_MEM_CTX(ndr);

1652

NDR_PULL_SET_MEM_CTX(ndr, r->rids, 0);

1653

NDR_CHECK(ndr_pull_array_size(ndr, &r->rids));

1654

NDR_PULL_ALLOC_N(ndr, r->rids, ndr_get_array_size(ndr, &r->rids));

1655

_mem_save_rids_1 = NDR_PULL_GET_MEM_CTX(ndr);

1656

NDR_PULL_SET_MEM_CTX(ndr, r->rids, 0);

1657

for (cntr_rids_1 = 0; cntr_rids_1 < r->count; cntr_rids_1++) {

1658

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->rids[cntr_rids_1]));

1659

}

1660

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_rids_1, 0);

1661

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_rids_0, 0);

1662

}

1663

if (r->attributes) {

1664

_mem_save_attributes_0 = NDR_PULL_GET_MEM_CTX(ndr);

1665

NDR_PULL_SET_MEM_CTX(ndr, r->attributes, 0);

1666

NDR_CHECK(ndr_pull_array_size(ndr, &r->attributes));

1667

NDR_PULL_ALLOC_N(ndr, r->attributes, ndr_get_array_size(ndr, &r->attributes));

1668

_mem_save_attributes_1 = NDR_PULL_GET_MEM_CTX(ndr);

1669

NDR_PULL_SET_MEM_CTX(ndr, r->attributes, 0);

1670

for (cntr_attributes_1 = 0; cntr_attributes_1 < r->count; cntr_attributes_1++) {

1671

NDR_CHECK(ndr_pull_samr_GroupAttrs(ndr, NDR_SCALARS, &r->attributes[cntr_attributes_1]));

1672

}

1673

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_attributes_1, 0);

1674

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_attributes_0, 0);

1675

}

1676

if (r->rids) {

1677

NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->rids, r->count));

1678

}

1679

if (r->attributes) {

1680

NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->attributes, r->count));

1681

}

1682

}

1683

return NDR_ERR_SUCCESS;

1684

}

1685

1686

_PUBLIC_ void ndr_print_samr_RidAttrArray(struct ndr_print *ndr, const char *name, const struct samr_RidAttrArray *r)

1687

{

1688

uint32_t cntr_rids_1;

1689

uint32_t cntr_attributes_1;

1690

ndr_print_struct(ndr, name, "samr_RidAttrArray");

1691

if (r == NULL) { ndr_print_null(ndr); return; }

1692

ndr->depth++;

1693

ndr_print_uint32(ndr, "count", r->count);

1694

ndr_print_ptr(ndr, "rids", r->rids);

1695

ndr->depth++;

1696

if (r->rids) {

1697

ndr->print(ndr, "%s: ARRAY(%d)", "rids", (int)r->count);

1698

ndr->depth++;

1699

for (cntr_rids_1=0;cntr_rids_1<r->count;cntr_rids_1++) {

1700

ndr_print_uint32(ndr, "rids", r->rids[cntr_rids_1]);

1701

}

1702

ndr->depth--;

1703

}

1704

ndr->depth--;

1705

ndr_print_ptr(ndr, "attributes", r->attributes);

1706

ndr->depth++;

1707

if (r->attributes) {

1708

ndr->print(ndr, "%s: ARRAY(%d)", "attributes", (int)r->count);

1709

ndr->depth++;

1710

for (cntr_attributes_1=0;cntr_attributes_1<r->count;cntr_attributes_1++) {

1711

ndr_print_samr_GroupAttrs(ndr, "attributes", r->attributes[cntr_attributes_1]);

1712

}

1713

ndr->depth--;

1714

}

1715

ndr->depth--;

1716

ndr->depth--;

1717

}

1718

1719

static enum ndr_err_code ndr_push_samr_AliasInfoAll(struct ndr_push *ndr, int ndr_flags, const struct samr_AliasInfoAll *r)

1720

{

1721

if (ndr_flags & NDR_SCALARS) {

1722

NDR_CHECK(ndr_push_align(ndr, 5));

1723

NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->name));

1724

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_members));

1725

NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->description));

1726

NDR_CHECK(ndr_push_trailer_align(ndr, 5));

1727

}

1728

if (ndr_flags & NDR_BUFFERS) {

1729

NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->name));

1730

NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->description));

1731

}

1732

return NDR_ERR_SUCCESS;

1733

}

1734

1735

static enum ndr_err_code ndr_pull_samr_AliasInfoAll(struct ndr_pull *ndr, int ndr_flags, struct samr_AliasInfoAll *r)

1736

{

1737

if (ndr_flags & NDR_SCALARS) {

1738

NDR_CHECK(ndr_pull_align(ndr, 5));

1739

NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->name));

1740

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_members));

1741

NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->description));

1742

NDR_CHECK(ndr_pull_trailer_align(ndr, 5));

1743

}

1744

if (ndr_flags & NDR_BUFFERS) {

1745

NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->name));

1746

NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->description));

1747

}

1748

return NDR_ERR_SUCCESS;

1749

}

1750

1751

_PUBLIC_ void ndr_print_samr_AliasInfoAll(struct ndr_print *ndr, const char *name, const struct samr_AliasInfoAll *r)

1752

{

1753

ndr_print_struct(ndr, name, "samr_AliasInfoAll");

1754

if (r == NULL) { ndr_print_null(ndr); return; }

1755

ndr->depth++;

1756

ndr_print_lsa_String(ndr, "name", &r->name);

1757

ndr_print_uint32(ndr, "num_members", r->num_members);

1758

ndr_print_lsa_String(ndr, "description", &r->description);

1759

ndr->depth--;

1760

}

1761

1762

static enum ndr_err_code ndr_push_samr_AliasInfoEnum(struct ndr_push *ndr, int ndr_flags, enum samr_AliasInfoEnum r)

1763

{

1764

NDR_CHECK(ndr_push_enum_uint1632(ndr, NDR_SCALARS, r));

1765

return NDR_ERR_SUCCESS;

1766

}

1767

1768

static enum ndr_err_code ndr_pull_samr_AliasInfoEnum(struct ndr_pull *ndr, int ndr_flags, enum samr_AliasInfoEnum *r)

1769

{

1770

uint16_t v;

1771

NDR_CHECK(ndr_pull_enum_uint1632(ndr, NDR_SCALARS, &v));

1772

*r = v;

1773

return NDR_ERR_SUCCESS;

1774

}

1775

1776

_PUBLIC_ void ndr_print_samr_AliasInfoEnum(struct ndr_print *ndr, const char *name, enum samr_AliasInfoEnum r)

1777

{

1778

const char *val = NULL;

1779

1780

switch (r) {

1781

case ALIASINFOALL: val = "ALIASINFOALL"; break;

1782

case ALIASINFONAME: val = "ALIASINFONAME"; break;

1783

case ALIASINFODESCRIPTION: val = "ALIASINFODESCRIPTION"; break;

1784

}

1785

ndr_print_enum(ndr, name, "ENUM", val, r);

1786

}

1787

1788

static enum ndr_err_code ndr_push_samr_AliasInfo(struct ndr_push *ndr, int ndr_flags, const union samr_AliasInfo *r)

1789

{

1790

if (ndr_flags & NDR_SCALARS) {

1791

uint32_t level = ndr_push_get_switch_value(ndr, r);

1792

NDR_CHECK(ndr_push_union_align(ndr, 5));

1793

NDR_CHECK(ndr_push_samr_AliasInfoEnum(ndr, NDR_SCALARS, level));

1794

NDR_CHECK(ndr_push_union_align(ndr, 5));

1795

switch (level) {

1796

case ALIASINFOALL: {

1797

NDR_CHECK(ndr_push_samr_AliasInfoAll(ndr, NDR_SCALARS, &r->all));

1798

break; }

1799

1800

case ALIASINFONAME: {

1801

NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->name));

1802

break; }

1803

1804

case ALIASINFODESCRIPTION: {

1805

NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->description));

1806

break; }

1807

1808

default:

1809

return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);

1810

}

1811

}

1812

if (ndr_flags & NDR_BUFFERS) {

1813

uint32_t level = ndr_push_get_switch_value(ndr, r);

1814

switch (level) {

1815

case ALIASINFOALL:

1816

NDR_CHECK(ndr_push_samr_AliasInfoAll(ndr, NDR_BUFFERS, &r->all));

1817

break;

1818

1819

case ALIASINFONAME:

1820

NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->name));

1821

break;

1822

1823

case ALIASINFODESCRIPTION:

1824

NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->description));

1825

break;

1826

1827

default:

1828

return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);

1829

}

1830

}

1831

return NDR_ERR_SUCCESS;

1832

}

1833

1834

static enum ndr_err_code ndr_pull_samr_AliasInfo(struct ndr_pull *ndr, int ndr_flags, union samr_AliasInfo *r)

1835

{

1836

uint32_t level;

1837

uint16_t _level;

1838

level = ndr_pull_get_switch_value(ndr, r);

1839

if (ndr_flags & NDR_SCALARS) {

1840

NDR_CHECK(ndr_pull_union_align(ndr, 5));

1841

NDR_CHECK(ndr_pull_uint1632(ndr, NDR_SCALARS, &_level));

1842

if (_level != level) {

1843

return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);

1844

}

1845

NDR_CHECK(ndr_pull_union_align(ndr, 5));

1846

switch (level) {

1847

case ALIASINFOALL: {

1848

NDR_CHECK(ndr_pull_samr_AliasInfoAll(ndr, NDR_SCALARS, &r->all));

1849

break; }

1850

1851

case ALIASINFONAME: {

1852

NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->name));

1853

break; }

1854

1855

case ALIASINFODESCRIPTION: {

1856

NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->description));

1857

break; }

1858

1859

default:

1860

return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);

1861

}

1862

}

1863

if (ndr_flags & NDR_BUFFERS) {

1864

switch (level) {

1865

case ALIASINFOALL:

1866

NDR_CHECK(ndr_pull_samr_AliasInfoAll(ndr, NDR_BUFFERS, &r->all));

1867

break;

1868

1869

case ALIASINFONAME:

1870

NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->name));

1871

break;

1872

1873

case ALIASINFODESCRIPTION:

1874

NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->description));

1875

break;

1876

1877

default:

1878

return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);

1879

}

1880

}

1881

return NDR_ERR_SUCCESS;

1882

}

1883

1884

_PUBLIC_ void ndr_print_samr_AliasInfo(struct ndr_print *ndr, const char *name, const union samr_AliasInfo *r)

1885

{

1886

uint32_t level;

1887

level = ndr_print_get_switch_value(ndr, r);

1888

ndr_print_union(ndr, name, level, "samr_AliasInfo");

1889

switch (level) {

1890

case ALIASINFOALL:

1891

ndr_print_samr_AliasInfoAll(ndr, "all", &r->all);

1892

break;

1893

1894

case ALIASINFONAME:

1895

ndr_print_lsa_String(ndr, "name", &r->name);

1896

break;

1897

1898

case ALIASINFODESCRIPTION:

1899

ndr_print_lsa_String(ndr, "description", &r->description);

1900

break;

1901

1902

default:

1903

ndr_print_bad_level(ndr, name, level);

1904

}

1905

}

1906

1907

static enum ndr_err_code ndr_push_samr_UserInfoLevel(struct ndr_push *ndr, int ndr_flags, enum samr_UserInfoLevel r)

1908

{

1909

NDR_CHECK(ndr_push_enum_uint1632(ndr, NDR_SCALARS, r));

1910

return NDR_ERR_SUCCESS;

1911

}

1912

1913

static enum ndr_err_code ndr_pull_samr_UserInfoLevel(struct ndr_pull *ndr, int ndr_flags, enum samr_UserInfoLevel *r)

1914

{

1915

uint16_t v;

1916

NDR_CHECK(ndr_pull_enum_uint1632(ndr, NDR_SCALARS, &v));

1917

*r = v;

1918

return NDR_ERR_SUCCESS;

1919

}

1920

1921

_PUBLIC_ void ndr_print_samr_UserInfoLevel(struct ndr_print *ndr, const char *name, enum samr_UserInfoLevel r)

1922

{

1923

const char *val = NULL;

1924

1925

switch (r) {

1926

case UserGeneralInformation: val = "UserGeneralInformation"; break;

1927

case UserPreferencesInformation: val = "UserPreferencesInformation"; break;

1928

case UserLogonInformation: val = "UserLogonInformation"; break;

1929

case UserLogonHoursInformation: val = "UserLogonHoursInformation"; break;

1930

case UserAccountInformation: val = "UserAccountInformation"; break;

1931

case UserNameInformation: val = "UserNameInformation"; break;

1932

case UserAccountNameInformation: val = "UserAccountNameInformation"; break;

1933

case UserFullNameInformation: val = "UserFullNameInformation"; break;

1934

case UserPrimaryGroupInformation: val = "UserPrimaryGroupInformation"; break;

1935

case UserHomeInformation: val = "UserHomeInformation"; break;

1936

case UserScriptInformation: val = "UserScriptInformation"; break;

1937

case UserProfileInformation: val = "UserProfileInformation"; break;

1938

case UserAdminCommentInformation: val = "UserAdminCommentInformation"; break;

1939

case UserWorkStationsInformation: val = "UserWorkStationsInformation"; break;

1940

case UserControlInformation: val = "UserControlInformation"; break;

1941

case UserExpiresInformation: val = "UserExpiresInformation"; break;

1942

case UserInternal1Information: val = "UserInternal1Information"; break;

1943

case UserParametersInformation: val = "UserParametersInformation"; break;

1944

case UserAllInformation: val = "UserAllInformation"; break;

1945

case UserInternal4Information: val = "UserInternal4Information"; break;

1946

case UserInternal5Information: val = "UserInternal5Information"; break;

1947

case UserInternal4InformationNew: val = "UserInternal4InformationNew"; break;

1948

case UserInternal5InformationNew: val = "UserInternal5InformationNew"; break;

1949

}

1950

ndr_print_enum(ndr, name, "ENUM", val, r);

1951

}

1952

1953

static enum ndr_err_code ndr_push_samr_UserInfo1(struct ndr_push *ndr, int ndr_flags, const struct samr_UserInfo1 *r)

1954

{

1955

if (ndr_flags & NDR_SCALARS) {

1956

NDR_CHECK(ndr_push_align(ndr, 5));

1957

NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->account_name));

1958

NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->full_name));

1959

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->primary_gid));

1960

NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->description));

1961

NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->comment));

1962

NDR_CHECK(ndr_push_trailer_align(ndr, 5));

1963

}

1964

if (ndr_flags & NDR_BUFFERS) {

1965

NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->account_name));

1966

NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->full_name));

1967

NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->description));

1968

NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->comment));

1969

}

1970

return NDR_ERR_SUCCESS;

1971

}

1972

1973

static enum ndr_err_code ndr_pull_samr_UserInfo1(struct ndr_pull *ndr, int ndr_flags, struct samr_UserInfo1 *r)

1974

{

1975

if (ndr_flags & NDR_SCALARS) {

1976

NDR_CHECK(ndr_pull_align(ndr, 5));

1977

NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->account_name));

1978

NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->full_name));

1979

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->primary_gid));

1980

NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->description));

1981

NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->comment));

1982

NDR_CHECK(ndr_pull_trailer_align(ndr, 5));

1983

}

1984

if (ndr_flags & NDR_BUFFERS) {

1985

NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->account_name));

1986

NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->full_name));

1987

NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->description));

1988

NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->comment));

1989

}

1990

return NDR_ERR_SUCCESS;

1991

}

1992

1993

_PUBLIC_ void ndr_print_samr_UserInfo1(struct ndr_print *ndr, const char *name, const struct samr_UserInfo1 *r)

1994

{

1995

ndr_print_struct(ndr, name, "samr_UserInfo1");

1996

if (r == NULL) { ndr_print_null(ndr); return; }

1997

ndr->depth++;

1998

ndr_print_lsa_String(ndr, "account_name", &r->account_name);

1999

ndr_print_lsa_String(ndr, "full_name", &r->full_name);

2000

ndr_print_uint32(ndr, "primary_gid", r->primary_gid);

2001

ndr_print_lsa_String(ndr, "description", &r->description);

2002

ndr_print_lsa_String(ndr, "comment", &r->comment);

2003

ndr->depth--;

2004

}

2005

2006

static enum ndr_err_code ndr_push_samr_UserInfo2(struct ndr_push *ndr, int ndr_flags, const struct samr_UserInfo2 *r)

2007

{

2008

if (ndr_flags & NDR_SCALARS) {

2009

NDR_CHECK(ndr_push_align(ndr, 5));

2010

NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->comment));

2011

NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->reserved));

2012

NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->country_code));

2013

NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->code_page));

2014

NDR_CHECK(ndr_push_trailer_align(ndr, 5));

2015

}

2016

if (ndr_flags & NDR_BUFFERS) {

2017

NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->comment));

2018

NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->reserved));

2019

}

2020

return NDR_ERR_SUCCESS;

2021

}

2022

2023

static enum ndr_err_code ndr_pull_samr_UserInfo2(struct ndr_pull *ndr, int ndr_flags, struct samr_UserInfo2 *r)

2024

{

2025

if (ndr_flags & NDR_SCALARS) {

2026

NDR_CHECK(ndr_pull_align(ndr, 5));

2027

NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->comment));

2028

NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->reserved));

2029

NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->country_code));

2030

NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->code_page));

2031

NDR_CHECK(ndr_pull_trailer_align(ndr, 5));

2032

}

2033

if (ndr_flags & NDR_BUFFERS) {

2034

NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->comment));

2035

NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->reserved));

2036

}

2037

return NDR_ERR_SUCCESS;

2038

}

2039

2040

_PUBLIC_ void ndr_print_samr_UserInfo2(struct ndr_print *ndr, const char *name, const struct samr_UserInfo2 *r)

2041

{

2042

ndr_print_struct(ndr, name, "samr_UserInfo2");

2043

if (r == NULL) { ndr_print_null(ndr); return; }

2044

ndr->depth++;

2045

ndr_print_lsa_String(ndr, "comment", &r->comment);

2046

ndr_print_lsa_String(ndr, "reserved", &r->reserved);

2047

ndr_print_uint16(ndr, "country_code", r->country_code);

2048

ndr_print_uint16(ndr, "code_page", r->code_page);

2049

ndr->depth--;

2050

}

2051

2052

_PUBLIC_ enum ndr_err_code ndr_push_samr_LogonHours(struct ndr_push *ndr, int ndr_flags, const struct samr_LogonHours *r)

2053

{

2054

{

2055

uint32_t _flags_save_STRUCT = ndr->flags;

2056

ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);

2057

if (ndr_flags & NDR_SCALARS) {

2058

NDR_CHECK(ndr_push_align(ndr, 5));

2059

NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->units_per_week));

2060

NDR_CHECK(ndr_push_unique_ptr(ndr, r->bits));

2061

NDR_CHECK(ndr_push_trailer_align(ndr, 5));

2062

}

2063

if (ndr_flags & NDR_BUFFERS) {

2064

if (r->bits) {

2065

NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 1260));

2066

NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));

2067

NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->units_per_week / 8));

2068

NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->bits, r->units_per_week / 8));

2069

}

2070

}

2071

ndr->flags = _flags_save_STRUCT;

2072

}

2073

return NDR_ERR_SUCCESS;

2074

}

2075

2076

_PUBLIC_ enum ndr_err_code ndr_pull_samr_LogonHours(struct ndr_pull *ndr, int ndr_flags, struct samr_LogonHours *r)

2077

{

2078

uint32_t _ptr_bits;

2079

TALLOC_CTX *_mem_save_bits_0;

2080

{

2081

uint32_t _flags_save_STRUCT = ndr->flags;

2082

ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);

2083

if (ndr_flags & NDR_SCALARS) {

2084

NDR_CHECK(ndr_pull_align(ndr, 5));

2085

NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->units_per_week));

2086

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_bits));

2087

if (_ptr_bits) {

2088

NDR_PULL_ALLOC(ndr, r->bits);

2089

} else {

2090

r->bits = NULL;

2091

}

2092

NDR_CHECK(ndr_pull_trailer_align(ndr, 5));

2093

}

2094

if (ndr_flags & NDR_BUFFERS) {

2095

if (r->bits) {

2096

_mem_save_bits_0 = NDR_PULL_GET_MEM_CTX(ndr);

2097

NDR_PULL_SET_MEM_CTX(ndr, r->bits, 0);

2098

NDR_CHECK(ndr_pull_array_size(ndr, &r->bits));

2099

NDR_CHECK(ndr_pull_array_length(ndr, &r->bits));

2100

if (ndr_get_array_length(ndr, &r->bits) > ndr_get_array_size(ndr, &r->bits)) {

2101

return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->bits), ndr_get_array_length(ndr, &r->bits));

2102

}

2103

NDR_PULL_ALLOC_N(ndr, r->bits, ndr_get_array_size(ndr, &r->bits));

2104

NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->bits, ndr_get_array_length(ndr, &r->bits)));

2105

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_bits_0, 0);

2106

}

2107

if (r->bits) {

2108

NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->bits, 1260));

2109

}

2110

if (r->bits) {

2111

NDR_CHECK(ndr_check_array_length(ndr, (void*)&r->bits, r->units_per_week / 8));

2112

}

2113

}

2114

ndr->flags = _flags_save_STRUCT;

2115

}

2116

return NDR_ERR_SUCCESS;

2117

}

2118

2119

_PUBLIC_ void ndr_print_samr_LogonHours(struct ndr_print *ndr, const char *name, const struct samr_LogonHours *r)

2120

{

2121

ndr_print_struct(ndr, name, "samr_LogonHours");

2122

if (r == NULL) { ndr_print_null(ndr); return; }

2123

{

2124

uint32_t _flags_save_STRUCT = ndr->flags;

2125

ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);

2126

ndr->depth++;

2127

ndr_print_uint16(ndr, "units_per_week", r->units_per_week);

2128

ndr_print_ptr(ndr, "bits", r->bits);

2129

ndr->depth++;

2130

if (r->bits) {

2131

ndr_print_array_uint8(ndr, "bits", r->bits, r->units_per_week / 8);

2132

}

2133

ndr->depth--;

2134

ndr->depth--;

2135

ndr->flags = _flags_save_STRUCT;

2136

}

2137

}

2138

2139

static enum ndr_err_code ndr_push_samr_UserInfo3(struct ndr_push *ndr, int ndr_flags, const struct samr_UserInfo3 *r)

2140

{

2141

if (ndr_flags & NDR_SCALARS) {

2142

NDR_CHECK(ndr_push_align(ndr, 5));

2143

NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->account_name));

2144

NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->full_name));

2145

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->rid));

2146

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->primary_gid));

2147

NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->home_directory));

2148

NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->home_drive));

2149

NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->logon_script));

2150

NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->profile_path));

2151

NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->workstations));

2152

NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->last_logon));

2153

NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->last_logoff));

2154

NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->last_password_change));

2155

NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->allow_password_change));

2156

NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->force_password_change));

2157

NDR_CHECK(ndr_push_samr_LogonHours(ndr, NDR_SCALARS, &r->logon_hours));

2158

NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->bad_password_count));

2159

NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->logon_count));

2160

NDR_CHECK(ndr_push_samr_AcctFlags(ndr, NDR_SCALARS, r->acct_flags));

2161

NDR_CHECK(ndr_push_trailer_align(ndr, 5));

2162

}

2163

if (ndr_flags & NDR_BUFFERS) {

2164

NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->account_name));

2165

NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->full_name));

2166

NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->home_directory));

2167

NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->home_drive));

2168

NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->logon_script));

2169

NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->profile_path));

2170

NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->workstations));

2171

NDR_CHECK(ndr_push_samr_LogonHours(ndr, NDR_BUFFERS, &r->logon_hours));

2172

}

2173

return NDR_ERR_SUCCESS;

2174

}

2175

2176

static enum ndr_err_code ndr_pull_samr_UserInfo3(struct ndr_pull *ndr, int ndr_flags, struct samr_UserInfo3 *r)

2177

{

2178

if (ndr_flags & NDR_SCALARS) {

2179

NDR_CHECK(ndr_pull_align(ndr, 5));

2180

NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->account_name));

2181

NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->full_name));

2182

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->rid));

2183

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->primary_gid));

2184

NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->home_directory));

2185

NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->home_drive));

2186

NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->logon_script));

2187

NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->profile_path));

2188

NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->workstations));

2189

NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->last_logon));

2190

NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->last_logoff));

2191

NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->last_password_change));

2192

NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->allow_password_change));

2193

NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->force_password_change));

2194

NDR_CHECK(ndr_pull_samr_LogonHours(ndr, NDR_SCALARS, &r->logon_hours));

2195

NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->bad_password_count));

2196

NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->logon_count));

2197

NDR_CHECK(ndr_pull_samr_AcctFlags(ndr, NDR_SCALARS, &r->acct_flags));

2198

NDR_CHECK(ndr_pull_trailer_align(ndr, 5));

2199

}

2200

if (ndr_flags & NDR_BUFFERS) {

2201

NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->account_name));

2202

NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->full_name));

2203

NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->home_directory));

2204

NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->home_drive));

2205

NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->logon_script));

2206

NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->profile_path));

2207

NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->workstations));

2208

NDR_CHECK(ndr_pull_samr_LogonHours(ndr, NDR_BUFFERS, &r->logon_hours));

2209

}

2210

return NDR_ERR_SUCCESS;

2211

}

2212

2213

_PUBLIC_ void ndr_print_samr_UserInfo3(struct ndr_print *ndr, const char *name, const struct samr_UserInfo3 *r)

2214

{

2215

ndr_print_struct(ndr, name, "samr_UserInfo3");

2216

if (r == NULL) { ndr_print_null(ndr); return; }

2217

ndr->depth++;

2218

ndr_print_lsa_String(ndr, "account_name", &r->account_name);

2219

ndr_print_lsa_String(ndr, "full_name", &r->full_name);

2220

ndr_print_uint32(ndr, "rid", r->rid);

2221

ndr_print_uint32(ndr, "primary_gid", r->primary_gid);

2222

ndr_print_lsa_String(ndr, "home_directory", &r->home_directory);

2223

ndr_print_lsa_String(ndr, "home_drive", &r->home_drive);

2224

ndr_print_lsa_String(ndr, "logon_script", &r->logon_script);

2225

ndr_print_lsa_String(ndr, "profile_path", &r->profile_path);

2226

ndr_print_lsa_String(ndr, "workstations", &r->workstations);

2227

ndr_print_NTTIME(ndr, "last_logon", r->last_logon);

2228

ndr_print_NTTIME(ndr, "last_logoff", r->last_logoff);

2229

ndr_print_NTTIME(ndr, "last_password_change", r->last_password_change);

2230

ndr_print_NTTIME(ndr, "allow_password_change", r->allow_password_change);

2231

ndr_print_NTTIME(ndr, "force_password_change", r->force_password_change);

2232

ndr_print_samr_LogonHours(ndr, "logon_hours", &r->logon_hours);

2233

ndr_print_uint16(ndr, "bad_password_count", r->bad_password_count);

2234

ndr_print_uint16(ndr, "logon_count", r->logon_count);

2235

ndr_print_samr_AcctFlags(ndr, "acct_flags", r->acct_flags);

2236

ndr->depth--;

2237

}

2238

2239

static enum ndr_err_code ndr_push_samr_UserInfo4(struct ndr_push *ndr, int ndr_flags, const struct samr_UserInfo4 *r)

2240

{

2241

if (ndr_flags & NDR_SCALARS) {

2242

NDR_CHECK(ndr_push_align(ndr, 5));

2243

NDR_CHECK(ndr_push_samr_LogonHours(ndr, NDR_SCALARS, &r->logon_hours));

2244

NDR_CHECK(ndr_push_trailer_align(ndr, 5));

2245

}

2246

if (ndr_flags & NDR_BUFFERS) {

2247

NDR_CHECK(ndr_push_samr_LogonHours(ndr, NDR_BUFFERS, &r->logon_hours));

2248

}

2249

return NDR_ERR_SUCCESS;

2250

}

2251

2252

static enum ndr_err_code ndr_pull_samr_UserInfo4(struct ndr_pull *ndr, int ndr_flags, struct samr_UserInfo4 *r)

2253

{

2254

if (ndr_flags & NDR_SCALARS) {

2255

NDR_CHECK(ndr_pull_align(ndr, 5));

2256

NDR_CHECK(ndr_pull_samr_LogonHours(ndr, NDR_SCALARS, &r->logon_hours));

2257

NDR_CHECK(ndr_pull_trailer_align(ndr, 5));

2258

}

2259

if (ndr_flags & NDR_BUFFERS) {

2260

NDR_CHECK(ndr_pull_samr_LogonHours(ndr, NDR_BUFFERS, &r->logon_hours));

2261

}

2262

return NDR_ERR_SUCCESS;

2263

}

2264

2265

_PUBLIC_ void ndr_print_samr_UserInfo4(struct ndr_print *ndr, const char *name, const struct samr_UserInfo4 *r)

2266

{

2267

ndr_print_struct(ndr, name, "samr_UserInfo4");

2268

if (r == NULL) { ndr_print_null(ndr); return; }

2269

ndr->depth++;

2270

ndr_print_samr_LogonHours(ndr, "logon_hours", &r->logon_hours);

2271

ndr->depth--;

2272

}

2273

2274

static enum ndr_err_code ndr_push_samr_UserInfo5(struct ndr_push *ndr, int ndr_flags, const struct samr_UserInfo5 *r)

2275

{

2276

if (ndr_flags & NDR_SCALARS) {

2277

NDR_CHECK(ndr_push_align(ndr, 5));

2278

NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->account_name));

2279

NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->full_name));

2280

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->rid));

2281

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->primary_gid));

2282

NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->home_directory));

2283

NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->home_drive));

2284

NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->logon_script));

2285

NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->profile_path));

2286

NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->description));

2287

NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->workstations));

2288

NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->last_logon));

2289

NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->last_logoff));

2290

NDR_CHECK(ndr_push_samr_LogonHours(ndr, NDR_SCALARS, &r->logon_hours));

2291

NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->bad_password_count));

2292

NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->logon_count));

2293

NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->last_password_change));

2294

NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->acct_expiry));

2295

NDR_CHECK(ndr_push_samr_AcctFlags(ndr, NDR_SCALARS, r->acct_flags));

2296

NDR_CHECK(ndr_push_trailer_align(ndr, 5));

2297

}

2298

if (ndr_flags & NDR_BUFFERS) {

2299

NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->account_name));

2300

NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->full_name));

2301

NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->home_directory));

2302

NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->home_drive));

2303

NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->logon_script));

2304

NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->profile_path));

2305

NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->description));

2306

NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->workstations));

2307

NDR_CHECK(ndr_push_samr_LogonHours(ndr, NDR_BUFFERS, &r->logon_hours));

2308

}

2309

return NDR_ERR_SUCCESS;

2310

}

2311

2312

static enum ndr_err_code ndr_pull_samr_UserInfo5(struct ndr_pull *ndr, int ndr_flags, struct samr_UserInfo5 *r)

2313

{

2314

if (ndr_flags & NDR_SCALARS) {

2315

NDR_CHECK(ndr_pull_align(ndr, 5));

2316

NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->account_name));

2317

NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->full_name));

2318

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->rid));

2319

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->primary_gid));

2320

NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->home_directory));

2321

NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->home_drive));

2322

NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->logon_script));

2323

NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->profile_path));

2324

NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->description));

2325

NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->workstations));

2326

NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->last_logon));

2327

NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->last_logoff));

2328

NDR_CHECK(ndr_pull_samr_LogonHours(ndr, NDR_SCALARS, &r->logon_hours));

2329

NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->bad_password_count));

2330

NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->logon_count));

2331

NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->last_password_change));

2332

NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->acct_expiry));

2333

NDR_CHECK(ndr_pull_samr_AcctFlags(ndr, NDR_SCALARS, &r->acct_flags));

2334

NDR_CHECK(ndr_pull_trailer_align(ndr, 5));

2335

}

2336

if (ndr_flags & NDR_BUFFERS) {

2337

NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->account_name));

2338

NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->full_name));

2339

NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->home_directory));

2340

NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->home_drive));

2341

NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->logon_script));

2342

NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->profile_path));

2343

NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->description));

2344

NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->workstations));

2345

NDR_CHECK(ndr_pull_samr_LogonHours(ndr, NDR_BUFFERS, &r->logon_hours));

2346

}

2347

return NDR_ERR_SUCCESS;

2348

}

2349

2350

_PUBLIC_ void ndr_print_samr_UserInfo5(struct ndr_print *ndr, const char *name, const struct samr_UserInfo5 *r)

2351

{

2352

ndr_print_struct(ndr, name, "samr_UserInfo5");

2353

if (r == NULL) { ndr_print_null(ndr); return; }

2354

ndr->depth++;

2355

ndr_print_lsa_String(ndr, "account_name", &r->account_name);

2356

ndr_print_lsa_String(ndr, "full_name", &r->full_name);

2357

ndr_print_uint32(ndr, "rid", r->rid);

2358

ndr_print_uint32(ndr, "primary_gid", r->primary_gid);

2359

ndr_print_lsa_String(ndr, "home_directory", &r->home_directory);

2360

ndr_print_lsa_String(ndr, "home_drive", &r->home_drive);

2361

ndr_print_lsa_String(ndr, "logon_script", &r->logon_script);

2362

ndr_print_lsa_String(ndr, "profile_path", &r->profile_path);

2363

ndr_print_lsa_String(ndr, "description", &r->description);

2364

ndr_print_lsa_String(ndr, "workstations", &r->workstations);

2365

ndr_print_NTTIME(ndr, "last_logon", r->last_logon);

2366

ndr_print_NTTIME(ndr, "last_logoff", r->last_logoff);

2367

ndr_print_samr_LogonHours(ndr, "logon_hours", &r->logon_hours);

2368

ndr_print_uint16(ndr, "bad_password_count", r->bad_password_count);

2369

ndr_print_uint16(ndr, "logon_count", r->logon_count);

2370

ndr_print_NTTIME(ndr, "last_password_change", r->last_password_change);

2371

ndr_print_NTTIME(ndr, "acct_expiry", r->acct_expiry);

2372

ndr_print_samr_AcctFlags(ndr, "acct_flags", r->acct_flags);

2373

ndr->depth--;

2374

}

2375

2376

static enum ndr_err_code ndr_push_samr_UserInfo6(struct ndr_push *ndr, int ndr_flags, const struct samr_UserInfo6 *r)

2377

{

2378

if (ndr_flags & NDR_SCALARS) {

2379

NDR_CHECK(ndr_push_align(ndr, 5));

2380

NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->account_name));

2381

NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->full_name));

2382

NDR_CHECK(ndr_push_trailer_align(ndr, 5));

2383

}

2384

if (ndr_flags & NDR_BUFFERS) {

2385

NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->account_name));

2386

NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->full_name));

2387

}

2388

return NDR_ERR_SUCCESS;

2389

}

2390

2391

static enum ndr_err_code ndr_pull_samr_UserInfo6(struct ndr_pull *ndr, int ndr_flags, struct samr_UserInfo6 *r)

2392

{

2393

if (ndr_flags & NDR_SCALARS) {

2394

NDR_CHECK(ndr_pull_align(ndr, 5));

2395

NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->account_name));

2396

NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->full_name));

2397

NDR_CHECK(ndr_pull_trailer_align(ndr, 5));

2398

}

2399

if (ndr_flags & NDR_BUFFERS) {

2400

NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->account_name));

2401

NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->full_name));

2402

}

2403

return NDR_ERR_SUCCESS;

2404

}

2405

2406

_PUBLIC_ void ndr_print_samr_UserInfo6(struct ndr_print *ndr, const char *name, const struct samr_UserInfo6 *r)

2407

{

2408

ndr_print_struct(ndr, name, "samr_UserInfo6");

2409

if (r == NULL) { ndr_print_null(ndr); return; }

2410

ndr->depth++;

2411

ndr_print_lsa_String(ndr, "account_name", &r->account_name);

2412

ndr_print_lsa_String(ndr, "full_name", &r->full_name);

2413

ndr->depth--;

2414

}

2415

2416

static enum ndr_err_code ndr_push_samr_UserInfo7(struct ndr_push *ndr, int ndr_flags, const struct samr_UserInfo7 *r)

2417

{

2418

if (ndr_flags & NDR_SCALARS) {

2419

NDR_CHECK(ndr_push_align(ndr, 5));

2420

NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->account_name));

2421

NDR_CHECK(ndr_push_trailer_align(ndr, 5));

2422

}

2423

if (ndr_flags & NDR_BUFFERS) {

2424

NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->account_name));

2425

}

2426

return NDR_ERR_SUCCESS;

2427

}

2428

2429

static enum ndr_err_code ndr_pull_samr_UserInfo7(struct ndr_pull *ndr, int ndr_flags, struct samr_UserInfo7 *r)

2430

{

2431

if (ndr_flags & NDR_SCALARS) {

2432

NDR_CHECK(ndr_pull_align(ndr, 5));

2433

NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->account_name));

2434

NDR_CHECK(ndr_pull_trailer_align(ndr, 5));

2435

}

2436

if (ndr_flags & NDR_BUFFERS) {

2437

NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->account_name));

2438

}

2439

return NDR_ERR_SUCCESS;

2440

}

2441

2442

_PUBLIC_ void ndr_print_samr_UserInfo7(struct ndr_print *ndr, const char *name, const struct samr_UserInfo7 *r)

2443

{

2444

ndr_print_struct(ndr, name, "samr_UserInfo7");

2445

if (r == NULL) { ndr_print_null(ndr); return; }

2446

ndr->depth++;

2447

ndr_print_lsa_String(ndr, "account_name", &r->account_name);

2448

ndr->depth--;

2449

}

2450

2451

static enum ndr_err_code ndr_push_samr_UserInfo8(struct ndr_push *ndr, int ndr_flags, const struct samr_UserInfo8 *r)

2452

{

2453

if (ndr_flags & NDR_SCALARS) {

2454

NDR_CHECK(ndr_push_align(ndr, 5));

2455

NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->full_name));

2456

NDR_CHECK(ndr_push_trailer_align(ndr, 5));

2457

}

2458

if (ndr_flags & NDR_BUFFERS) {

2459

NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->full_name));

2460

}

2461

return NDR_ERR_SUCCESS;

2462

}

2463

2464

static enum ndr_err_code ndr_pull_samr_UserInfo8(struct ndr_pull *ndr, int ndr_flags, struct samr_UserInfo8 *r)

2465

{

2466

if (ndr_flags & NDR_SCALARS) {

2467

NDR_CHECK(ndr_pull_align(ndr, 5));

2468

NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->full_name));

2469

NDR_CHECK(ndr_pull_trailer_align(ndr, 5));

2470

}

2471

if (ndr_flags & NDR_BUFFERS) {

2472

NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->full_name));

2473

}

2474

return NDR_ERR_SUCCESS;

2475

}

2476

2477

_PUBLIC_ void ndr_print_samr_UserInfo8(struct ndr_print *ndr, const char *name, const struct samr_UserInfo8 *r)

2478

{

2479

ndr_print_struct(ndr, name, "samr_UserInfo8");

2480

if (r == NULL) { ndr_print_null(ndr); return; }

2481

ndr->depth++;

2482

ndr_print_lsa_String(ndr, "full_name", &r->full_name);

2483

ndr->depth--;

2484

}

2485

2486

static enum ndr_err_code ndr_push_samr_UserInfo9(struct ndr_push *ndr, int ndr_flags, const struct samr_UserInfo9 *r)

2487

{

2488

if (ndr_flags & NDR_SCALARS) {

2489

NDR_CHECK(ndr_push_align(ndr, 4));

2490

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->primary_gid));

2491

NDR_CHECK(ndr_push_trailer_align(ndr, 4));

2492

}

2493

if (ndr_flags & NDR_BUFFERS) {

2494

}

2495

return NDR_ERR_SUCCESS;

2496

}

2497

2498

static enum ndr_err_code ndr_pull_samr_UserInfo9(struct ndr_pull *ndr, int ndr_flags, struct samr_UserInfo9 *r)

2499

{

2500

if (ndr_flags & NDR_SCALARS) {

2501

NDR_CHECK(ndr_pull_align(ndr, 4));

2502

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->primary_gid));

2503

NDR_CHECK(ndr_pull_trailer_align(ndr, 4));

2504

}

2505

if (ndr_flags & NDR_BUFFERS) {

2506

}

2507

return NDR_ERR_SUCCESS;

2508

}

2509

2510

_PUBLIC_ void ndr_print_samr_UserInfo9(struct ndr_print *ndr, const char *name, const struct samr_UserInfo9 *r)

2511

{

2512

ndr_print_struct(ndr, name, "samr_UserInfo9");

2513

if (r == NULL) { ndr_print_null(ndr); return; }

2514

ndr->depth++;

2515

ndr_print_uint32(ndr, "primary_gid", r->primary_gid);

2516

ndr->depth--;

2517

}

2518

2519

static enum ndr_err_code ndr_push_samr_UserInfo10(struct ndr_push *ndr, int ndr_flags, const struct samr_UserInfo10 *r)

2520

{

2521

if (ndr_flags & NDR_SCALARS) {

2522

NDR_CHECK(ndr_push_align(ndr, 5));

2523

NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->home_directory));

2524

NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->home_drive));

2525

NDR_CHECK(ndr_push_trailer_align(ndr, 5));

2526

}

2527

if (ndr_flags & NDR_BUFFERS) {

2528

NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->home_directory));

2529

NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->home_drive));

2530

}

2531

return NDR_ERR_SUCCESS;

2532

}

2533

2534

static enum ndr_err_code ndr_pull_samr_UserInfo10(struct ndr_pull *ndr, int ndr_flags, struct samr_UserInfo10 *r)

2535

{

2536

if (ndr_flags & NDR_SCALARS) {

2537

NDR_CHECK(ndr_pull_align(ndr, 5));

2538

NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->home_directory));

2539

NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->home_drive));

2540

NDR_CHECK(ndr_pull_trailer_align(ndr, 5));

2541

}

2542

if (ndr_flags & NDR_BUFFERS) {

2543

NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->home_directory));

2544

NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->home_drive));

2545

}

2546

return NDR_ERR_SUCCESS;

2547

}

2548

2549

_PUBLIC_ void ndr_print_samr_UserInfo10(struct ndr_print *ndr, const char *name, const struct samr_UserInfo10 *r)

2550

{

2551

ndr_print_struct(ndr, name, "samr_UserInfo10");

2552

if (r == NULL) { ndr_print_null(ndr); return; }

2553

ndr->depth++;

2554

ndr_print_lsa_String(ndr, "home_directory", &r->home_directory);

2555

ndr_print_lsa_String(ndr, "home_drive", &r->home_drive);

2556

ndr->depth--;

2557

}

2558

2559

static enum ndr_err_code ndr_push_samr_UserInfo11(struct ndr_push *ndr, int ndr_flags, const struct samr_UserInfo11 *r)

2560

{

2561

if (ndr_flags & NDR_SCALARS) {

2562

NDR_CHECK(ndr_push_align(ndr, 5));

2563

NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->logon_script));

2564

NDR_CHECK(ndr_push_trailer_align(ndr, 5));

2565

}

2566

if (ndr_flags & NDR_BUFFERS) {

2567

NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->logon_script));

2568

}

2569

return NDR_ERR_SUCCESS;

2570

}

2571

2572

static enum ndr_err_code ndr_pull_samr_UserInfo11(struct ndr_pull *ndr, int ndr_flags, struct samr_UserInfo11 *r)

2573

{

2574

if (ndr_flags & NDR_SCALARS) {

2575

NDR_CHECK(ndr_pull_align(ndr, 5));

2576

NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->logon_script));

2577

NDR_CHECK(ndr_pull_trailer_align(ndr, 5));

2578

}

2579

if (ndr_flags & NDR_BUFFERS) {

2580

NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->logon_script));

2581

}

2582

return NDR_ERR_SUCCESS;

2583

}

2584

2585

_PUBLIC_ void ndr_print_samr_UserInfo11(struct ndr_print *ndr, const char *name, const struct samr_UserInfo11 *r)

2586

{

2587

ndr_print_struct(ndr, name, "samr_UserInfo11");

2588

if (r == NULL) { ndr_print_null(ndr); return; }

2589

ndr->depth++;

2590

ndr_print_lsa_String(ndr, "logon_script", &r->logon_script);

2591

ndr->depth--;

2592

}

2593

2594

static enum ndr_err_code ndr_push_samr_UserInfo12(struct ndr_push *ndr, int ndr_flags, const struct samr_UserInfo12 *r)

2595

{

2596

if (ndr_flags & NDR_SCALARS) {

2597

NDR_CHECK(ndr_push_align(ndr, 5));

2598

NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->profile_path));

2599

NDR_CHECK(ndr_push_trailer_align(ndr, 5));

2600

}

2601

if (ndr_flags & NDR_BUFFERS) {

2602

NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->profile_path));

2603

}

2604

return NDR_ERR_SUCCESS;

2605

}

2606

2607

static enum ndr_err_code ndr_pull_samr_UserInfo12(struct ndr_pull *ndr, int ndr_flags, struct samr_UserInfo12 *r)

2608

{

2609

if (ndr_flags & NDR_SCALARS) {

2610

NDR_CHECK(ndr_pull_align(ndr, 5));

2611

NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->profile_path));

2612

NDR_CHECK(ndr_pull_trailer_align(ndr, 5));

2613

}

2614

if (ndr_flags & NDR_BUFFERS) {

2615

NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->profile_path));

2616

}

2617

return NDR_ERR_SUCCESS;

2618

}

2619

2620

_PUBLIC_ void ndr_print_samr_UserInfo12(struct ndr_print *ndr, const char *name, const struct samr_UserInfo12 *r)

2621

{

2622

ndr_print_struct(ndr, name, "samr_UserInfo12");

2623

if (r == NULL) { ndr_print_null(ndr); return; }

2624

ndr->depth++;

2625

ndr_print_lsa_String(ndr, "profile_path", &r->profile_path);

2626

ndr->depth--;

2627

}

2628

2629

static enum ndr_err_code ndr_push_samr_UserInfo13(struct ndr_push *ndr, int ndr_flags, const struct samr_UserInfo13 *r)

2630

{

2631

if (ndr_flags & NDR_SCALARS) {

2632

NDR_CHECK(ndr_push_align(ndr, 5));

2633

NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->description));

2634

NDR_CHECK(ndr_push_trailer_align(ndr, 5));

2635

}

2636

if (ndr_flags & NDR_BUFFERS) {

2637

NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->description));

2638

}

2639

return NDR_ERR_SUCCESS;

2640

}

2641

2642

static enum ndr_err_code ndr_pull_samr_UserInfo13(struct ndr_pull *ndr, int ndr_flags, struct samr_UserInfo13 *r)

2643

{

2644

if (ndr_flags & NDR_SCALARS) {

2645

NDR_CHECK(ndr_pull_align(ndr, 5));

2646

NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->description));

2647

NDR_CHECK(ndr_pull_trailer_align(ndr, 5));

2648

}

2649

if (ndr_flags & NDR_BUFFERS) {

2650

NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->description));

2651

}

2652

return NDR_ERR_SUCCESS;

2653

}

2654

2655

_PUBLIC_ void ndr_print_samr_UserInfo13(struct ndr_print *ndr, const char *name, const struct samr_UserInfo13 *r)

2656

{

2657

ndr_print_struct(ndr, name, "samr_UserInfo13");

2658

if (r == NULL) { ndr_print_null(ndr); return; }

2659

ndr->depth++;

2660

ndr_print_lsa_String(ndr, "description", &r->description);

2661

ndr->depth--;

2662

}

2663

2664

static enum ndr_err_code ndr_push_samr_UserInfo14(struct ndr_push *ndr, int ndr_flags, const struct samr_UserInfo14 *r)

2665

{

2666

if (ndr_flags & NDR_SCALARS) {

2667

NDR_CHECK(ndr_push_align(ndr, 5));

2668

NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->workstations));

2669

NDR_CHECK(ndr_push_trailer_align(ndr, 5));

2670

}

2671

if (ndr_flags & NDR_BUFFERS) {

2672

NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->workstations));

2673

}

2674

return NDR_ERR_SUCCESS;

2675

}

2676

2677

static enum ndr_err_code ndr_pull_samr_UserInfo14(struct ndr_pull *ndr, int ndr_flags, struct samr_UserInfo14 *r)

2678

{

2679

if (ndr_flags & NDR_SCALARS) {

2680

NDR_CHECK(ndr_pull_align(ndr, 5));

2681

NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->workstations));

2682

NDR_CHECK(ndr_pull_trailer_align(ndr, 5));

2683

}

2684

if (ndr_flags & NDR_BUFFERS) {

2685

NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->workstations));

2686

}

2687

return NDR_ERR_SUCCESS;

2688

}

2689

2690

_PUBLIC_ void ndr_print_samr_UserInfo14(struct ndr_print *ndr, const char *name, const struct samr_UserInfo14 *r)

2691

{

2692

ndr_print_struct(ndr, name, "samr_UserInfo14");

2693

if (r == NULL) { ndr_print_null(ndr); return; }

2694

ndr->depth++;

2695

ndr_print_lsa_String(ndr, "workstations", &r->workstations);

2696

ndr->depth--;

2697

}

2698

2699

static enum ndr_err_code ndr_push_samr_UserInfo16(struct ndr_push *ndr, int ndr_flags, const struct samr_UserInfo16 *r)

2700

{

2701

if (ndr_flags & NDR_SCALARS) {

2702

NDR_CHECK(ndr_push_align(ndr, 4));

2703

NDR_CHECK(ndr_push_samr_AcctFlags(ndr, NDR_SCALARS, r->acct_flags));

2704

NDR_CHECK(ndr_push_trailer_align(ndr, 4));

2705

}

2706

if (ndr_flags & NDR_BUFFERS) {

2707

}

2708

return NDR_ERR_SUCCESS;

2709

}

2710

2711

static enum ndr_err_code ndr_pull_samr_UserInfo16(struct ndr_pull *ndr, int ndr_flags, struct samr_UserInfo16 *r)

2712

{

2713

if (ndr_flags & NDR_SCALARS) {

2714

NDR_CHECK(ndr_pull_align(ndr, 4));

2715

NDR_CHECK(ndr_pull_samr_AcctFlags(ndr, NDR_SCALARS, &r->acct_flags));

2716

NDR_CHECK(ndr_pull_trailer_align(ndr, 4));

2717

}

2718

if (ndr_flags & NDR_BUFFERS) {

2719

}

2720

return NDR_ERR_SUCCESS;

2721

}

2722

2723

_PUBLIC_ void ndr_print_samr_UserInfo16(struct ndr_print *ndr, const char *name, const struct samr_UserInfo16 *r)

2724

{

2725

ndr_print_struct(ndr, name, "samr_UserInfo16");

2726

if (r == NULL) { ndr_print_null(ndr); return; }

2727

ndr->depth++;

2728

ndr_print_samr_AcctFlags(ndr, "acct_flags", r->acct_flags);

2729

ndr->depth--;

2730

}

2731

2732

static enum ndr_err_code ndr_push_samr_UserInfo17(struct ndr_push *ndr, int ndr_flags, const struct samr_UserInfo17 *r)

2733

{

2734

if (ndr_flags & NDR_SCALARS) {

2735

NDR_CHECK(ndr_push_align(ndr, 4));

2736

NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->acct_expiry));

2737

NDR_CHECK(ndr_push_trailer_align(ndr, 4));

2738

}

2739

if (ndr_flags & NDR_BUFFERS) {

2740

}

2741

return NDR_ERR_SUCCESS;

2742

}

2743

2744

static enum ndr_err_code ndr_pull_samr_UserInfo17(struct ndr_pull *ndr, int ndr_flags, struct samr_UserInfo17 *r)

2745

{

2746

if (ndr_flags & NDR_SCALARS) {

2747

NDR_CHECK(ndr_pull_align(ndr, 4));

2748

NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->acct_expiry));

2749

NDR_CHECK(ndr_pull_trailer_align(ndr, 4));

2750

}

2751

if (ndr_flags & NDR_BUFFERS) {

2752

}

2753

return NDR_ERR_SUCCESS;

2754

}

2755

2756

_PUBLIC_ void ndr_print_samr_UserInfo17(struct ndr_print *ndr, const char *name, const struct samr_UserInfo17 *r)

2757

{

2758

ndr_print_struct(ndr, name, "samr_UserInfo17");

2759

if (r == NULL) { ndr_print_null(ndr); return; }

2760

ndr->depth++;

2761

ndr_print_NTTIME(ndr, "acct_expiry", r->acct_expiry);

2762

ndr->depth--;

2763

}

2764

2765

_PUBLIC_ enum ndr_err_code ndr_push_samr_Password(struct ndr_push *ndr, int ndr_flags, const struct samr_Password *r)

2766

{

2767

{

2768

uint32_t _flags_save_STRUCT = ndr->flags;

2769

ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);

2770

if (ndr_flags & NDR_SCALARS) {

2771

NDR_CHECK(ndr_push_align(ndr, 1));

2772

NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->hash, 16));

2773

NDR_CHECK(ndr_push_trailer_align(ndr, 1));

2774

}

2775

if (ndr_flags & NDR_BUFFERS) {

2776

}

2777

ndr->flags = _flags_save_STRUCT;

2778

}

2779

return NDR_ERR_SUCCESS;

2780

}

2781

2782

_PUBLIC_ enum ndr_err_code ndr_pull_samr_Password(struct ndr_pull *ndr, int ndr_flags, struct samr_Password *r)

2783

{

2784

{

2785

uint32_t _flags_save_STRUCT = ndr->flags;

2786

ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);

2787

if (ndr_flags & NDR_SCALARS) {

2788

NDR_CHECK(ndr_pull_align(ndr, 1));

2789

NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->hash, 16));

2790

NDR_CHECK(ndr_pull_trailer_align(ndr, 1));

2791

}

2792

if (ndr_flags & NDR_BUFFERS) {

2793

}

2794

ndr->flags = _flags_save_STRUCT;

2795

}

2796

return NDR_ERR_SUCCESS;

2797

}

2798

2799

_PUBLIC_ void ndr_print_samr_Password(struct ndr_print *ndr, const char *name, const struct samr_Password *r)

2800

{

2801

ndr_print_struct(ndr, name, "samr_Password");

2802

if (r == NULL) { ndr_print_null(ndr); return; }

2803

{

2804

uint32_t _flags_save_STRUCT = ndr->flags;

2805

ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);

2806

ndr->depth++;

2807

ndr_print_array_uint8(ndr, "hash", r->hash, 16);

2808

ndr->depth--;

2809

ndr->flags = _flags_save_STRUCT;

2810

}

2811

}

2812

2813

static enum ndr_err_code ndr_push_samr_UserInfo18(struct ndr_push *ndr, int ndr_flags, const struct samr_UserInfo18 *r)

2814

{

2815

if (ndr_flags & NDR_SCALARS) {

2816

NDR_CHECK(ndr_push_align(ndr, 1));

2817

NDR_CHECK(ndr_push_samr_Password(ndr, NDR_SCALARS, &r->nt_pwd));

2818

NDR_CHECK(ndr_push_samr_Password(ndr, NDR_SCALARS, &r->lm_pwd));

2819

NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->nt_pwd_active));

2820

NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->lm_pwd_active));

2821

NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->password_expired));

2822

NDR_CHECK(ndr_push_trailer_align(ndr, 1));

2823

}

2824

if (ndr_flags & NDR_BUFFERS) {

2825

}

2826

return NDR_ERR_SUCCESS;

2827

}

2828

2829

static enum ndr_err_code ndr_pull_samr_UserInfo18(struct ndr_pull *ndr, int ndr_flags, struct samr_UserInfo18 *r)

2830

{

2831

if (ndr_flags & NDR_SCALARS) {

2832

NDR_CHECK(ndr_pull_align(ndr, 1));

2833

NDR_CHECK(ndr_pull_samr_Password(ndr, NDR_SCALARS, &r->nt_pwd));

2834

NDR_CHECK(ndr_pull_samr_Password(ndr, NDR_SCALARS, &r->lm_pwd));

2835

NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->nt_pwd_active));

2836

NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->lm_pwd_active));

2837

NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->password_expired));

2838

NDR_CHECK(ndr_pull_trailer_align(ndr, 1));

2839

}

2840

if (ndr_flags & NDR_BUFFERS) {

2841

}

2842

return NDR_ERR_SUCCESS;

2843

}

2844

2845

_PUBLIC_ void ndr_print_samr_UserInfo18(struct ndr_print *ndr, const char *name, const struct samr_UserInfo18 *r)

2846

{

2847

ndr_print_struct(ndr, name, "samr_UserInfo18");

2848

if (r == NULL) { ndr_print_null(ndr); return; }

2849

ndr->depth++;

2850

ndr_print_samr_Password(ndr, "nt_pwd", &r->nt_pwd);

2851

ndr_print_samr_Password(ndr, "lm_pwd", &r->lm_pwd);

2852

ndr_print_uint8(ndr, "nt_pwd_active", r->nt_pwd_active);

2853

ndr_print_uint8(ndr, "lm_pwd_active", r->lm_pwd_active);

2854

ndr_print_uint8(ndr, "password_expired", r->password_expired);

2855

ndr->depth--;

2856

}

2857

2858

static enum ndr_err_code ndr_push_samr_UserInfo20(struct ndr_push *ndr, int ndr_flags, const struct samr_UserInfo20 *r)

2859

{

2860

if (ndr_flags & NDR_SCALARS) {

2861

NDR_CHECK(ndr_push_align(ndr, 5));

2862

NDR_CHECK(ndr_push_lsa_BinaryString(ndr, NDR_SCALARS, &r->parameters));

2863

NDR_CHECK(ndr_push_trailer_align(ndr, 5));

2864

}

2865

if (ndr_flags & NDR_BUFFERS) {

2866

NDR_CHECK(ndr_push_lsa_BinaryString(ndr, NDR_BUFFERS, &r->parameters));

2867

}

2868

return NDR_ERR_SUCCESS;

2869

}

2870

2871

static enum ndr_err_code ndr_pull_samr_UserInfo20(struct ndr_pull *ndr, int ndr_flags, struct samr_UserInfo20 *r)

2872

{

2873

if (ndr_flags & NDR_SCALARS) {

2874

NDR_CHECK(ndr_pull_align(ndr, 5));

2875

NDR_CHECK(ndr_pull_lsa_BinaryString(ndr, NDR_SCALARS, &r->parameters));

2876

NDR_CHECK(ndr_pull_trailer_align(ndr, 5));

2877

}

2878

if (ndr_flags & NDR_BUFFERS) {

2879

NDR_CHECK(ndr_pull_lsa_BinaryString(ndr, NDR_BUFFERS, &r->parameters));

2880

}

2881

return NDR_ERR_SUCCESS;

2882

}

2883

2884

_PUBLIC_ void ndr_print_samr_UserInfo20(struct ndr_print *ndr, const char *name, const struct samr_UserInfo20 *r)

2885

{

2886

ndr_print_struct(ndr, name, "samr_UserInfo20");

2887

if (r == NULL) { ndr_print_null(ndr); return; }

2888

ndr->depth++;

2889

ndr_print_lsa_BinaryString(ndr, "parameters", &r->parameters);

2890

ndr->depth--;

2891

}

2892

2893

static enum ndr_err_code ndr_push_samr_FieldsPresent(struct ndr_push *ndr, int ndr_flags, uint32_t r)

2894

{

2895

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));

2896

return NDR_ERR_SUCCESS;

2897

}

2898

2899

static enum ndr_err_code ndr_pull_samr_FieldsPresent(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)

2900

{

2901

uint32_t v;

2902

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));

2903

*r = v;

2904

return NDR_ERR_SUCCESS;

2905

}

2906

2907

_PUBLIC_ void ndr_print_samr_FieldsPresent(struct ndr_print *ndr, const char *name, uint32_t r)

2908

{

2909

ndr_print_uint32(ndr, name, r);

2910

ndr->depth++;

2911

ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_FIELD_ACCOUNT_NAME", SAMR_FIELD_ACCOUNT_NAME, r);

2912

ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_FIELD_FULL_NAME", SAMR_FIELD_FULL_NAME, r);

2913

ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_FIELD_RID", SAMR_FIELD_RID, r);

2914

ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_FIELD_PRIMARY_GID", SAMR_FIELD_PRIMARY_GID, r);

2915

ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_FIELD_DESCRIPTION", SAMR_FIELD_DESCRIPTION, r);

2916

ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_FIELD_COMMENT", SAMR_FIELD_COMMENT, r);

2917

ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_FIELD_HOME_DIRECTORY", SAMR_FIELD_HOME_DIRECTORY, r);

2918

ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_FIELD_HOME_DRIVE", SAMR_FIELD_HOME_DRIVE, r);

2919

ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_FIELD_LOGON_SCRIPT", SAMR_FIELD_LOGON_SCRIPT, r);

2920

ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_FIELD_PROFILE_PATH", SAMR_FIELD_PROFILE_PATH, r);

2921

ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_FIELD_WORKSTATIONS", SAMR_FIELD_WORKSTATIONS, r);

2922

ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_FIELD_LAST_LOGON", SAMR_FIELD_LAST_LOGON, r);

2923

ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_FIELD_LAST_LOGOFF", SAMR_FIELD_LAST_LOGOFF, r);

2924

ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_FIELD_LOGON_HOURS", SAMR_FIELD_LOGON_HOURS, r);

2925

ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_FIELD_BAD_PWD_COUNT", SAMR_FIELD_BAD_PWD_COUNT, r);

2926

ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_FIELD_NUM_LOGONS", SAMR_FIELD_NUM_LOGONS, r);

2927

ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_FIELD_ALLOW_PWD_CHANGE", SAMR_FIELD_ALLOW_PWD_CHANGE, r);

2928

ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_FIELD_FORCE_PWD_CHANGE", SAMR_FIELD_FORCE_PWD_CHANGE, r);

2929

ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_FIELD_LAST_PWD_CHANGE", SAMR_FIELD_LAST_PWD_CHANGE, r);

2930

ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_FIELD_ACCT_EXPIRY", SAMR_FIELD_ACCT_EXPIRY, r);

2931

ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_FIELD_ACCT_FLAGS", SAMR_FIELD_ACCT_FLAGS, r);

2932

ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_FIELD_PARAMETERS", SAMR_FIELD_PARAMETERS, r);

2933

ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_FIELD_COUNTRY_CODE", SAMR_FIELD_COUNTRY_CODE, r);

2934

ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_FIELD_CODE_PAGE", SAMR_FIELD_CODE_PAGE, r);

2935

ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_FIELD_NT_PASSWORD_PRESENT", SAMR_FIELD_NT_PASSWORD_PRESENT, r);

2936

ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_FIELD_LM_PASSWORD_PRESENT", SAMR_FIELD_LM_PASSWORD_PRESENT, r);

2937

ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_FIELD_PRIVATE_DATA", SAMR_FIELD_PRIVATE_DATA, r);

2938

ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_FIELD_EXPIRED_FLAG", SAMR_FIELD_EXPIRED_FLAG, r);

2939

ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_FIELD_SEC_DESC", SAMR_FIELD_SEC_DESC, r);

2940

ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_FIELD_OWF_PWD", SAMR_FIELD_OWF_PWD, r);

2941

ndr->depth--;

2942

}

2943

2944

static enum ndr_err_code ndr_push_samr_UserInfo21(struct ndr_push *ndr, int ndr_flags, const struct samr_UserInfo21 *r)

2945

{

2946

if (ndr_flags & NDR_SCALARS) {

2947

NDR_CHECK(ndr_push_align(ndr, 5));

2948

NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->last_logon));

2949

NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->last_logoff));

2950

NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->last_password_change));

2951

NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->acct_expiry));

2952

NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->allow_password_change));

2953

NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->force_password_change));

2954

NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->account_name));

2955

NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->full_name));

2956

NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->home_directory));

2957

NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->home_drive));

2958

NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->logon_script));

2959

NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->profile_path));

2960

NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->description));

2961

NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->workstations));

2962

NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->comment));

2963

NDR_CHECK(ndr_push_lsa_BinaryString(ndr, NDR_SCALARS, &r->parameters));

2964

NDR_CHECK(ndr_push_lsa_BinaryString(ndr, NDR_SCALARS, &r->lm_owf_password));

2965

NDR_CHECK(ndr_push_lsa_BinaryString(ndr, NDR_SCALARS, &r->nt_owf_password));

2966

NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->private_data));

2967

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->buf_count));

2968

NDR_CHECK(ndr_push_unique_ptr(ndr, r->buffer));

2969

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->rid));

2970

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->primary_gid));

2971

NDR_CHECK(ndr_push_samr_AcctFlags(ndr, NDR_SCALARS, r->acct_flags));

2972

NDR_CHECK(ndr_push_samr_FieldsPresent(ndr, NDR_SCALARS, r->fields_present));

2973

NDR_CHECK(ndr_push_samr_LogonHours(ndr, NDR_SCALARS, &r->logon_hours));

2974

NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->bad_password_count));

2975

NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->logon_count));

2976

NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->country_code));

2977

NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->code_page));

2978

NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->lm_password_set));

2979

NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->nt_password_set));

2980

NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->password_expired));

2981

NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->private_data_sensitive));

2982

NDR_CHECK(ndr_push_trailer_align(ndr, 5));

2983

}

2984

if (ndr_flags & NDR_BUFFERS) {

2985

NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->account_name));

2986

NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->full_name));

2987

NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->home_directory));

2988

NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->home_drive));

2989

NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->logon_script));

2990

NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->profile_path));

2991

NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->description));

2992

NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->workstations));

2993

NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->comment));

2994

NDR_CHECK(ndr_push_lsa_BinaryString(ndr, NDR_BUFFERS, &r->parameters));

2995

NDR_CHECK(ndr_push_lsa_BinaryString(ndr, NDR_BUFFERS, &r->lm_owf_password));

2996

NDR_CHECK(ndr_push_lsa_BinaryString(ndr, NDR_BUFFERS, &r->nt_owf_password));

2997

NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->private_data));

2998

if (r->buffer) {

2999

NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->buf_count));

3000

NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->buffer, r->buf_count));

3001

}

3002

NDR_CHECK(ndr_push_samr_LogonHours(ndr, NDR_BUFFERS, &r->logon_hours));

3003

}

3004

return NDR_ERR_SUCCESS;

3005

}

3006

3007

static enum ndr_err_code ndr_pull_samr_UserInfo21(struct ndr_pull *ndr, int ndr_flags, struct samr_UserInfo21 *r)

3008

{

3009

uint32_t _ptr_buffer;

3010

TALLOC_CTX *_mem_save_buffer_0;

3011

if (ndr_flags & NDR_SCALARS) {

3012

NDR_CHECK(ndr_pull_align(ndr, 5));

3013

NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->last_logon));

3014

NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->last_logoff));

3015

NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->last_password_change));

3016

NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->acct_expiry));

3017

NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->allow_password_change));

3018

NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->force_password_change));

3019

NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->account_name));

3020

NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->full_name));

3021

NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->home_directory));

3022

NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->home_drive));

3023

NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->logon_script));

3024

NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->profile_path));

3025

NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->description));

3026

NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->workstations));

3027

NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->comment));

3028

NDR_CHECK(ndr_pull_lsa_BinaryString(ndr, NDR_SCALARS, &r->parameters));

3029

NDR_CHECK(ndr_pull_lsa_BinaryString(ndr, NDR_SCALARS, &r->lm_owf_password));

3030

NDR_CHECK(ndr_pull_lsa_BinaryString(ndr, NDR_SCALARS, &r->nt_owf_password));

3031

NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->private_data));

3032

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->buf_count));

3033

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));

3034

if (_ptr_buffer) {

3035

NDR_PULL_ALLOC(ndr, r->buffer);

3036

} else {

3037

r->buffer = NULL;

3038

}

3039

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->rid));

3040

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->primary_gid));

3041

NDR_CHECK(ndr_pull_samr_AcctFlags(ndr, NDR_SCALARS, &r->acct_flags));

3042

NDR_CHECK(ndr_pull_samr_FieldsPresent(ndr, NDR_SCALARS, &r->fields_present));

3043

NDR_CHECK(ndr_pull_samr_LogonHours(ndr, NDR_SCALARS, &r->logon_hours));

3044

NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->bad_password_count));

3045

NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->logon_count));

3046

NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->country_code));

3047

NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->code_page));

3048

NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->lm_password_set));

3049

NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->nt_password_set));

3050

NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->password_expired));

3051

NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->private_data_sensitive));

3052

NDR_CHECK(ndr_pull_trailer_align(ndr, 5));

3053

}

3054

if (ndr_flags & NDR_BUFFERS) {

3055

NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->account_name));

3056

NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->full_name));

3057

NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->home_directory));

3058

NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->home_drive));

3059

NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->logon_script));

3060

NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->profile_path));

3061

NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->description));

3062

NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->workstations));

3063

NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->comment));

3064

NDR_CHECK(ndr_pull_lsa_BinaryString(ndr, NDR_BUFFERS, &r->parameters));

3065

NDR_CHECK(ndr_pull_lsa_BinaryString(ndr, NDR_BUFFERS, &r->lm_owf_password));

3066

NDR_CHECK(ndr_pull_lsa_BinaryString(ndr, NDR_BUFFERS, &r->nt_owf_password));

3067

NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->private_data));

3068

if (r->buffer) {

3069

_mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);

3070

NDR_PULL_SET_MEM_CTX(ndr, r->buffer, 0);

3071

NDR_CHECK(ndr_pull_array_size(ndr, &r->buffer));

3072

NDR_PULL_ALLOC_N(ndr, r->buffer, ndr_get_array_size(ndr, &r->buffer));

3073

NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->buffer, ndr_get_array_size(ndr, &r->buffer)));

3074

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);

3075

}

3076

NDR_CHECK(ndr_pull_samr_LogonHours(ndr, NDR_BUFFERS, &r->logon_hours));

3077

if (r->buffer) {

3078

NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->buffer, r->buf_count));

3079

}

3080

}

3081

return NDR_ERR_SUCCESS;

3082

}

3083

3084

_PUBLIC_ void ndr_print_samr_UserInfo21(struct ndr_print *ndr, const char *name, const struct samr_UserInfo21 *r)

3085

{

3086

ndr_print_struct(ndr, name, "samr_UserInfo21");

3087

if (r == NULL) { ndr_print_null(ndr); return; }

3088

ndr->depth++;

3089

ndr_print_NTTIME(ndr, "last_logon", r->last_logon);

3090

ndr_print_NTTIME(ndr, "last_logoff", r->last_logoff);

3091

ndr_print_NTTIME(ndr, "last_password_change", r->last_password_change);

3092

ndr_print_NTTIME(ndr, "acct_expiry", r->acct_expiry);

3093

ndr_print_NTTIME(ndr, "allow_password_change", r->allow_password_change);

3094

ndr_print_NTTIME(ndr, "force_password_change", r->force_password_change);

3095

ndr_print_lsa_String(ndr, "account_name", &r->account_name);

3096

ndr_print_lsa_String(ndr, "full_name", &r->full_name);

3097

ndr_print_lsa_String(ndr, "home_directory", &r->home_directory);

3098

ndr_print_lsa_String(ndr, "home_drive", &r->home_drive);

3099

ndr_print_lsa_String(ndr, "logon_script", &r->logon_script);

3100

ndr_print_lsa_String(ndr, "profile_path", &r->profile_path);

3101

ndr_print_lsa_String(ndr, "description", &r->description);

3102

ndr_print_lsa_String(ndr, "workstations", &r->workstations);

3103

ndr_print_lsa_String(ndr, "comment", &r->comment);

3104

ndr_print_lsa_BinaryString(ndr, "parameters", &r->parameters);

3105

ndr_print_lsa_BinaryString(ndr, "lm_owf_password", &r->lm_owf_password);

3106

ndr_print_lsa_BinaryString(ndr, "nt_owf_password", &r->nt_owf_password);

3107

ndr_print_lsa_String(ndr, "private_data", &r->private_data);

3108

ndr_print_uint32(ndr, "buf_count", r->buf_count);

3109

ndr_print_ptr(ndr, "buffer", r->buffer);

3110

ndr->depth++;

3111

if (r->buffer) {

3112

ndr_print_array_uint8(ndr, "buffer", r->buffer, r->buf_count);

3113

}

3114

ndr->depth--;

3115

ndr_print_uint32(ndr, "rid", r->rid);

3116

ndr_print_uint32(ndr, "primary_gid", r->primary_gid);

3117

ndr_print_samr_AcctFlags(ndr, "acct_flags", r->acct_flags);

3118

ndr_print_samr_FieldsPresent(ndr, "fields_present", r->fields_present);

3119

ndr_print_samr_LogonHours(ndr, "logon_hours", &r->logon_hours);

3120

ndr_print_uint16(ndr, "bad_password_count", r->bad_password_count);

3121

ndr_print_uint16(ndr, "logon_count", r->logon_count);

3122

ndr_print_uint16(ndr, "country_code", r->country_code);

3123

ndr_print_uint16(ndr, "code_page", r->code_page);

3124

ndr_print_uint8(ndr, "lm_password_set", r->lm_password_set);

3125

ndr_print_uint8(ndr, "nt_password_set", r->nt_password_set);

3126

ndr_print_uint8(ndr, "password_expired", r->password_expired);

3127

ndr_print_uint8(ndr, "private_data_sensitive", r->private_data_sensitive);

3128

ndr->depth--;

3129

}

3130

3131

_PUBLIC_ enum ndr_err_code ndr_push_samr_CryptPassword(struct ndr_push *ndr, int ndr_flags, const struct samr_CryptPassword *r)

3132

{

3133

{

3134

uint32_t _flags_save_STRUCT = ndr->flags;

3135

ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);

3136

if (ndr_flags & NDR_SCALARS) {

3137

NDR_CHECK(ndr_push_align(ndr, 1));

3138

NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->data, 516));

3139

NDR_CHECK(ndr_push_trailer_align(ndr, 1));

3140

}

3141

if (ndr_flags & NDR_BUFFERS) {

3142

}

3143

ndr->flags = _flags_save_STRUCT;

3144

}

3145

return NDR_ERR_SUCCESS;

3146

}

3147

3148

_PUBLIC_ enum ndr_err_code ndr_pull_samr_CryptPassword(struct ndr_pull *ndr, int ndr_flags, struct samr_CryptPassword *r)

3149

{

3150

{

3151

uint32_t _flags_save_STRUCT = ndr->flags;

3152

ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);

3153

if (ndr_flags & NDR_SCALARS) {

3154

NDR_CHECK(ndr_pull_align(ndr, 1));

3155

NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->data, 516));

3156

NDR_CHECK(ndr_pull_trailer_align(ndr, 1));

3157

}

3158

if (ndr_flags & NDR_BUFFERS) {

3159

}

3160

ndr->flags = _flags_save_STRUCT;

3161

}

3162

return NDR_ERR_SUCCESS;

3163

}

3164

3165

_PUBLIC_ void ndr_print_samr_CryptPassword(struct ndr_print *ndr, const char *name, const struct samr_CryptPassword *r)

3166

{

3167

ndr_print_struct(ndr, name, "samr_CryptPassword");

3168

if (r == NULL) { ndr_print_null(ndr); return; }

3169

{

3170

uint32_t _flags_save_STRUCT = ndr->flags;

3171

ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);

3172

ndr->depth++;

3173

ndr_print_array_uint8(ndr, "data", r->data, 516);

3174

ndr->depth--;

3175

ndr->flags = _flags_save_STRUCT;

3176

}

3177

}

3178

3179

static enum ndr_err_code ndr_push_samr_UserInfo23(struct ndr_push *ndr, int ndr_flags, const struct samr_UserInfo23 *r)

3180

{

3181

if (ndr_flags & NDR_SCALARS) {

3182

NDR_CHECK(ndr_push_align(ndr, 5));

3183

NDR_CHECK(ndr_push_samr_UserInfo21(ndr, NDR_SCALARS, &r->info));

3184

NDR_CHECK(ndr_push_samr_CryptPassword(ndr, NDR_SCALARS, &r->password));

3185

NDR_CHECK(ndr_push_trailer_align(ndr, 5));

3186

}

3187

if (ndr_flags & NDR_BUFFERS) {

3188

NDR_CHECK(ndr_push_samr_UserInfo21(ndr, NDR_BUFFERS, &r->info));

3189

}

3190

return NDR_ERR_SUCCESS;

3191

}

3192

3193

static enum ndr_err_code ndr_pull_samr_UserInfo23(struct ndr_pull *ndr, int ndr_flags, struct samr_UserInfo23 *r)

3194

{

3195

if (ndr_flags & NDR_SCALARS) {

3196

NDR_CHECK(ndr_pull_align(ndr, 5));

3197

NDR_CHECK(ndr_pull_samr_UserInfo21(ndr, NDR_SCALARS, &r->info));

3198

NDR_CHECK(ndr_pull_samr_CryptPassword(ndr, NDR_SCALARS, &r->password));

3199

NDR_CHECK(ndr_pull_trailer_align(ndr, 5));

3200

}

3201

if (ndr_flags & NDR_BUFFERS) {

3202

NDR_CHECK(ndr_pull_samr_UserInfo21(ndr, NDR_BUFFERS, &r->info));

3203

}

3204

return NDR_ERR_SUCCESS;

3205

}

3206

3207

_PUBLIC_ void ndr_print_samr_UserInfo23(struct ndr_print *ndr, const char *name, const struct samr_UserInfo23 *r)

3208

{

3209

ndr_print_struct(ndr, name, "samr_UserInfo23");

3210

if (r == NULL) { ndr_print_null(ndr); return; }

3211

ndr->depth++;

3212

ndr_print_samr_UserInfo21(ndr, "info", &r->info);

3213

ndr_print_samr_CryptPassword(ndr, "password", &r->password);

3214

ndr->depth--;

3215

}

3216

3217

static enum ndr_err_code ndr_push_samr_UserInfo24(struct ndr_push *ndr, int ndr_flags, const struct samr_UserInfo24 *r)

3218

{

3219

if (ndr_flags & NDR_SCALARS) {

3220

NDR_CHECK(ndr_push_align(ndr, 1));

3221

NDR_CHECK(ndr_push_samr_CryptPassword(ndr, NDR_SCALARS, &r->password));

3222

NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->password_expired));

3223

NDR_CHECK(ndr_push_trailer_align(ndr, 1));

3224

}

3225

if (ndr_flags & NDR_BUFFERS) {

3226

}

3227

return NDR_ERR_SUCCESS;

3228

}

3229

3230

static enum ndr_err_code ndr_pull_samr_UserInfo24(struct ndr_pull *ndr, int ndr_flags, struct samr_UserInfo24 *r)

3231

{

3232

if (ndr_flags & NDR_SCALARS) {

3233

NDR_CHECK(ndr_pull_align(ndr, 1));

3234

NDR_CHECK(ndr_pull_samr_CryptPassword(ndr, NDR_SCALARS, &r->password));

3235

NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->password_expired));

3236

NDR_CHECK(ndr_pull_trailer_align(ndr, 1));

3237

}

3238

if (ndr_flags & NDR_BUFFERS) {

3239

}

3240

return NDR_ERR_SUCCESS;

3241

}

3242

3243

_PUBLIC_ void ndr_print_samr_UserInfo24(struct ndr_print *ndr, const char *name, const struct samr_UserInfo24 *r)

3244

{

3245

ndr_print_struct(ndr, name, "samr_UserInfo24");

3246

if (r == NULL) { ndr_print_null(ndr); return; }

3247

ndr->depth++;

3248

ndr_print_samr_CryptPassword(ndr, "password", &r->password);

3249

ndr_print_uint8(ndr, "password_expired", r->password_expired);

3250

ndr->depth--;

3251

}

3252

3253

static enum ndr_err_code ndr_push_samr_CryptPasswordEx(struct ndr_push *ndr, int ndr_flags, const struct samr_CryptPasswordEx *r)

3254

{

3255

{

3256

uint32_t _flags_save_STRUCT = ndr->flags;

3257

ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);

3258

if (ndr_flags & NDR_SCALARS) {

3259

NDR_CHECK(ndr_push_align(ndr, 1));

3260

NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->data, 532));

3261

NDR_CHECK(ndr_push_trailer_align(ndr, 1));

3262

}

3263

if (ndr_flags & NDR_BUFFERS) {

3264

}

3265

ndr->flags = _flags_save_STRUCT;

3266

}

3267

return NDR_ERR_SUCCESS;

3268

}

3269

3270

static enum ndr_err_code ndr_pull_samr_CryptPasswordEx(struct ndr_pull *ndr, int ndr_flags, struct samr_CryptPasswordEx *r)

3271

{

3272

{

3273

uint32_t _flags_save_STRUCT = ndr->flags;

3274

ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);

3275

if (ndr_flags & NDR_SCALARS) {

3276

NDR_CHECK(ndr_pull_align(ndr, 1));

3277

NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->data, 532));

3278

NDR_CHECK(ndr_pull_trailer_align(ndr, 1));

3279

}

3280

if (ndr_flags & NDR_BUFFERS) {

3281

}

3282

ndr->flags = _flags_save_STRUCT;

3283

}

3284

return NDR_ERR_SUCCESS;

3285

}

3286

3287

_PUBLIC_ void ndr_print_samr_CryptPasswordEx(struct ndr_print *ndr, const char *name, const struct samr_CryptPasswordEx *r)

3288

{

3289

ndr_print_struct(ndr, name, "samr_CryptPasswordEx");

3290

if (r == NULL) { ndr_print_null(ndr); return; }

3291

{

3292

uint32_t _flags_save_STRUCT = ndr->flags;

3293

ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);

3294

ndr->depth++;

3295

ndr_print_array_uint8(ndr, "data", r->data, 532);

3296

ndr->depth--;

3297

ndr->flags = _flags_save_STRUCT;

3298

}

3299

}

3300

3301

static enum ndr_err_code ndr_push_samr_UserInfo25(struct ndr_push *ndr, int ndr_flags, const struct samr_UserInfo25 *r)

3302

{

3303

if (ndr_flags & NDR_SCALARS) {

3304

NDR_CHECK(ndr_push_align(ndr, 5));

3305

NDR_CHECK(ndr_push_samr_UserInfo21(ndr, NDR_SCALARS, &r->info));

3306

NDR_CHECK(ndr_push_samr_CryptPasswordEx(ndr, NDR_SCALARS, &r->password));

3307

NDR_CHECK(ndr_push_trailer_align(ndr, 5));

3308

}

3309

if (ndr_flags & NDR_BUFFERS) {

3310

NDR_CHECK(ndr_push_samr_UserInfo21(ndr, NDR_BUFFERS, &r->info));

3311

}

3312

return NDR_ERR_SUCCESS;

3313

}

3314

3315

static enum ndr_err_code ndr_pull_samr_UserInfo25(struct ndr_pull *ndr, int ndr_flags, struct samr_UserInfo25 *r)

3316

{

3317

if (ndr_flags & NDR_SCALARS) {

3318

NDR_CHECK(ndr_pull_align(ndr, 5));

3319

NDR_CHECK(ndr_pull_samr_UserInfo21(ndr, NDR_SCALARS, &r->info));

3320

NDR_CHECK(ndr_pull_samr_CryptPasswordEx(ndr, NDR_SCALARS, &r->password));

3321

NDR_CHECK(ndr_pull_trailer_align(ndr, 5));

3322

}

3323

if (ndr_flags & NDR_BUFFERS) {

3324

NDR_CHECK(ndr_pull_samr_UserInfo21(ndr, NDR_BUFFERS, &r->info));

3325

}

3326

return NDR_ERR_SUCCESS;

3327

}

3328

3329

_PUBLIC_ void ndr_print_samr_UserInfo25(struct ndr_print *ndr, const char *name, const struct samr_UserInfo25 *r)

3330

{

3331

ndr_print_struct(ndr, name, "samr_UserInfo25");

3332

if (r == NULL) { ndr_print_null(ndr); return; }

3333

ndr->depth++;

3334

ndr_print_samr_UserInfo21(ndr, "info", &r->info);

3335

ndr_print_samr_CryptPasswordEx(ndr, "password", &r->password);

3336

ndr->depth--;

3337

}

3338

3339

static enum ndr_err_code ndr_push_samr_UserInfo26(struct ndr_push *ndr, int ndr_flags, const struct samr_UserInfo26 *r)

3340

{

3341

if (ndr_flags & NDR_SCALARS) {

3342

NDR_CHECK(ndr_push_align(ndr, 1));

3343

NDR_CHECK(ndr_push_samr_CryptPasswordEx(ndr, NDR_SCALARS, &r->password));

3344

NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->password_expired));

3345

NDR_CHECK(ndr_push_trailer_align(ndr, 1));

3346

}

3347

if (ndr_flags & NDR_BUFFERS) {

3348

}

3349

return NDR_ERR_SUCCESS;

3350

}

3351

3352

static enum ndr_err_code ndr_pull_samr_UserInfo26(struct ndr_pull *ndr, int ndr_flags, struct samr_UserInfo26 *r)

3353

{

3354

if (ndr_flags & NDR_SCALARS) {

3355

NDR_CHECK(ndr_pull_align(ndr, 1));

3356

NDR_CHECK(ndr_pull_samr_CryptPasswordEx(ndr, NDR_SCALARS, &r->password));

3357

NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->password_expired));

3358

NDR_CHECK(ndr_pull_trailer_align(ndr, 1));

3359

}

3360

if (ndr_flags & NDR_BUFFERS) {

3361

}

3362

return NDR_ERR_SUCCESS;

3363

}

3364

3365

_PUBLIC_ void ndr_print_samr_UserInfo26(struct ndr_print *ndr, const char *name, const struct samr_UserInfo26 *r)

3366

{

3367

ndr_print_struct(ndr, name, "samr_UserInfo26");

3368

if (r == NULL) { ndr_print_null(ndr); return; }

3369

ndr->depth++;

3370

ndr_print_samr_CryptPasswordEx(ndr, "password", &r->password);

3371

ndr_print_uint8(ndr, "password_expired", r->password_expired);

3372

ndr->depth--;

3373

}

3374

3375

static enum ndr_err_code ndr_push_samr_UserInfo(struct ndr_push *ndr, int ndr_flags, const union samr_UserInfo *r)

3376

{

3377

if (ndr_flags & NDR_SCALARS) {

3378

uint32_t level = ndr_push_get_switch_value(ndr, r);

3379

NDR_CHECK(ndr_push_union_align(ndr, 5));

3380

NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, level));

3381

NDR_CHECK(ndr_push_union_align(ndr, 5));

3382

switch (level) {

3383

case 1: {

3384

NDR_CHECK(ndr_push_samr_UserInfo1(ndr, NDR_SCALARS, &r->info1));

3385

break; }

3386

3387

case 2: {

3388

NDR_CHECK(ndr_push_samr_UserInfo2(ndr, NDR_SCALARS, &r->info2));

3389

break; }

3390

3391

case 3: {

3392

NDR_CHECK(ndr_push_samr_UserInfo3(ndr, NDR_SCALARS, &r->info3));

3393

break; }

3394

3395

case 4: {

3396

NDR_CHECK(ndr_push_samr_UserInfo4(ndr, NDR_SCALARS, &r->info4));

3397

break; }

3398

3399

case 5: {

3400

NDR_CHECK(ndr_push_samr_UserInfo5(ndr, NDR_SCALARS, &r->info5));

3401

break; }

3402

3403

case 6: {

3404

NDR_CHECK(ndr_push_samr_UserInfo6(ndr, NDR_SCALARS, &r->info6));

3405

break; }

3406

3407

case 7: {

3408

NDR_CHECK(ndr_push_samr_UserInfo7(ndr, NDR_SCALARS, &r->info7));

3409

break; }

3410

3411

case 8: {

3412

NDR_CHECK(ndr_push_samr_UserInfo8(ndr, NDR_SCALARS, &r->info8));

3413

break; }

3414

3415

case 9: {

3416

NDR_CHECK(ndr_push_samr_UserInfo9(ndr, NDR_SCALARS, &r->info9));

3417

break; }

3418

3419

case 10: {

3420

NDR_CHECK(ndr_push_samr_UserInfo10(ndr, NDR_SCALARS, &r->info10));

3421

break; }

3422

3423

case 11: {

3424

NDR_CHECK(ndr_push_samr_UserInfo11(ndr, NDR_SCALARS, &r->info11));

3425

break; }

3426

3427

case 12: {

3428

NDR_CHECK(ndr_push_samr_UserInfo12(ndr, NDR_SCALARS, &r->info12));

3429

break; }

3430

3431

case 13: {

3432

NDR_CHECK(ndr_push_samr_UserInfo13(ndr, NDR_SCALARS, &r->info13));

3433

break; }

3434

3435

case 14: {

3436

NDR_CHECK(ndr_push_samr_UserInfo14(ndr, NDR_SCALARS, &r->info14));

3437

break; }

3438

3439

case 16: {

3440

NDR_CHECK(ndr_push_samr_UserInfo16(ndr, NDR_SCALARS, &r->info16));

3441

break; }

3442

3443

case 17: {

3444

NDR_CHECK(ndr_push_samr_UserInfo17(ndr, NDR_SCALARS, &r->info17));

3445

break; }

3446

3447

case 18: {

3448

NDR_CHECK(ndr_push_samr_UserInfo18(ndr, NDR_SCALARS, &r->info18));

3449

break; }

3450

3451

case 20: {

3452

NDR_CHECK(ndr_push_samr_UserInfo20(ndr, NDR_SCALARS, &r->info20));

3453

break; }

3454

3455

case 21: {

3456

NDR_CHECK(ndr_push_samr_UserInfo21(ndr, NDR_SCALARS, &r->info21));

3457

break; }

3458

3459

case 23: {

3460

NDR_CHECK(ndr_push_samr_UserInfo23(ndr, NDR_SCALARS, &r->info23));

3461

break; }

3462

3463

case 24: {

3464

NDR_CHECK(ndr_push_samr_UserInfo24(ndr, NDR_SCALARS, &r->info24));

3465

break; }

3466

3467

case 25: {

3468

NDR_CHECK(ndr_push_samr_UserInfo25(ndr, NDR_SCALARS, &r->info25));

3469

break; }

3470

3471

case 26: {

3472

NDR_CHECK(ndr_push_samr_UserInfo26(ndr, NDR_SCALARS, &r->info26));

3473

break; }

3474

3475

default:

3476

return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);

3477

}

3478

}

3479

if (ndr_flags & NDR_BUFFERS) {

3480

uint32_t level = ndr_push_get_switch_value(ndr, r);

3481

switch (level) {

3482

case 1:

3483

NDR_CHECK(ndr_push_samr_UserInfo1(ndr, NDR_BUFFERS, &r->info1));

3484

break;

3485

3486

case 2:

3487

NDR_CHECK(ndr_push_samr_UserInfo2(ndr, NDR_BUFFERS, &r->info2));

3488

break;

3489

3490

case 3:

3491

NDR_CHECK(ndr_push_samr_UserInfo3(ndr, NDR_BUFFERS, &r->info3));

3492

break;

3493

3494

case 4:

3495

NDR_CHECK(ndr_push_samr_UserInfo4(ndr, NDR_BUFFERS, &r->info4));

3496

break;

3497

3498

case 5:

3499

NDR_CHECK(ndr_push_samr_UserInfo5(ndr, NDR_BUFFERS, &r->info5));

3500

break;

3501

3502

case 6:

3503

NDR_CHECK(ndr_push_samr_UserInfo6(ndr, NDR_BUFFERS, &r->info6));

3504

break;

3505

3506

case 7:

3507

NDR_CHECK(ndr_push_samr_UserInfo7(ndr, NDR_BUFFERS, &r->info7));

3508

break;

3509

3510

case 8:

3511

NDR_CHECK(ndr_push_samr_UserInfo8(ndr, NDR_BUFFERS, &r->info8));

3512

break;

3513

3514

case 9:

3515

break;

3516

3517

case 10:

3518

NDR_CHECK(ndr_push_samr_UserInfo10(ndr, NDR_BUFFERS, &r->info10));

3519

break;

3520

3521

case 11:

3522

NDR_CHECK(ndr_push_samr_UserInfo11(ndr, NDR_BUFFERS, &r->info11));

3523

break;

3524

3525

case 12:

3526

NDR_CHECK(ndr_push_samr_UserInfo12(ndr, NDR_BUFFERS, &r->info12));

3527

break;

3528

3529

case 13:

3530

NDR_CHECK(ndr_push_samr_UserInfo13(ndr, NDR_BUFFERS, &r->info13));

3531

break;

3532

3533

case 14:

3534

NDR_CHECK(ndr_push_samr_UserInfo14(ndr, NDR_BUFFERS, &r->info14));

3535

break;

3536

3537

case 16:

3538

break;

3539

3540

case 17:

3541

break;

3542

3543

case 18:

3544

break;

3545

3546

case 20:

3547

NDR_CHECK(ndr_push_samr_UserInfo20(ndr, NDR_BUFFERS, &r->info20));

3548

break;

3549

3550

case 21:

3551

NDR_CHECK(ndr_push_samr_UserInfo21(ndr, NDR_BUFFERS, &r->info21));

3552

break;

3553

3554

case 23:

3555

NDR_CHECK(ndr_push_samr_UserInfo23(ndr, NDR_BUFFERS, &r->info23));

3556

break;

3557

3558

case 24:

3559

break;

3560

3561

case 25:

3562

NDR_CHECK(ndr_push_samr_UserInfo25(ndr, NDR_BUFFERS, &r->info25));

3563

break;

3564

3565

case 26:

3566

break;

3567

3568

default:

3569

return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);

3570

}

3571

}

3572

return NDR_ERR_SUCCESS;

3573

}

3574

3575

static enum ndr_err_code ndr_pull_samr_UserInfo(struct ndr_pull *ndr, int ndr_flags, union samr_UserInfo *r)

3576

{

3577

uint32_t level;

3578

uint16_t _level;

3579

level = ndr_pull_get_switch_value(ndr, r);

3580

if (ndr_flags & NDR_SCALARS) {

3581

NDR_CHECK(ndr_pull_union_align(ndr, 5));

3582

NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &_level));

3583

if (_level != level) {

3584

return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);

3585

}

3586

NDR_CHECK(ndr_pull_union_align(ndr, 5));

3587

switch (level) {

3588

case 1: {

3589

NDR_CHECK(ndr_pull_samr_UserInfo1(ndr, NDR_SCALARS, &r->info1));

3590

break; }

3591

3592

case 2: {

3593

NDR_CHECK(ndr_pull_samr_UserInfo2(ndr, NDR_SCALARS, &r->info2));

3594

break; }

3595

3596

case 3: {

3597

NDR_CHECK(ndr_pull_samr_UserInfo3(ndr, NDR_SCALARS, &r->info3));

3598

break; }

3599

3600

case 4: {

3601

NDR_CHECK(ndr_pull_samr_UserInfo4(ndr, NDR_SCALARS, &r->info4));

3602

break; }

3603

3604

case 5: {

3605

NDR_CHECK(ndr_pull_samr_UserInfo5(ndr, NDR_SCALARS, &r->info5));

3606

break; }

3607

3608

case 6: {

3609

NDR_CHECK(ndr_pull_samr_UserInfo6(ndr, NDR_SCALARS, &r->info6));

3610

break; }

3611

3612

case 7: {

3613

NDR_CHECK(ndr_pull_samr_UserInfo7(ndr, NDR_SCALARS, &r->info7));

3614

break; }

3615

3616

case 8: {

3617

NDR_CHECK(ndr_pull_samr_UserInfo8(ndr, NDR_SCALARS, &r->info8));

3618

break; }

3619

3620

case 9: {

3621

NDR_CHECK(ndr_pull_samr_UserInfo9(ndr, NDR_SCALARS, &r->info9));

3622

break; }

3623

3624

case 10: {

3625

NDR_CHECK(ndr_pull_samr_UserInfo10(ndr, NDR_SCALARS, &r->info10));

3626

break; }

3627

3628

case 11: {

3629

NDR_CHECK(ndr_pull_samr_UserInfo11(ndr, NDR_SCALARS, &r->info11));

3630

break; }

3631

3632

case 12: {

3633

NDR_CHECK(ndr_pull_samr_UserInfo12(ndr, NDR_SCALARS, &r->info12));

3634

break; }

3635

3636

case 13: {

3637

NDR_CHECK(ndr_pull_samr_UserInfo13(ndr, NDR_SCALARS, &r->info13));

3638

break; }

3639

3640

case 14: {

3641

NDR_CHECK(ndr_pull_samr_UserInfo14(ndr, NDR_SCALARS, &r->info14));

3642

break; }

3643

3644

case 16: {

3645

NDR_CHECK(ndr_pull_samr_UserInfo16(ndr, NDR_SCALARS, &r->info16));

3646

break; }

3647

3648

case 17: {

3649

NDR_CHECK(ndr_pull_samr_UserInfo17(ndr, NDR_SCALARS, &r->info17));

3650

break; }

3651

3652

case 18: {

3653

NDR_CHECK(ndr_pull_samr_UserInfo18(ndr, NDR_SCALARS, &r->info18));

3654

break; }

3655

3656

case 20: {

3657

NDR_CHECK(ndr_pull_samr_UserInfo20(ndr, NDR_SCALARS, &r->info20));

3658

break; }

3659

3660

case 21: {

3661

NDR_CHECK(ndr_pull_samr_UserInfo21(ndr, NDR_SCALARS, &r->info21));

3662

break; }

3663

3664

case 23: {

3665

NDR_CHECK(ndr_pull_samr_UserInfo23(ndr, NDR_SCALARS, &r->info23));

3666

break; }

3667

3668

case 24: {

3669

NDR_CHECK(ndr_pull_samr_UserInfo24(ndr, NDR_SCALARS, &r->info24));

3670

break; }

3671

3672

case 25: {

3673

NDR_CHECK(ndr_pull_samr_UserInfo25(ndr, NDR_SCALARS, &r->info25));

3674

break; }

3675

3676

case 26: {

3677

NDR_CHECK(ndr_pull_samr_UserInfo26(ndr, NDR_SCALARS, &r->info26));

3678

break; }

3679

3680

default:

3681

return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);

3682

}

3683

}

3684

if (ndr_flags & NDR_BUFFERS) {

3685

switch (level) {

3686

case 1:

3687

NDR_CHECK(ndr_pull_samr_UserInfo1(ndr, NDR_BUFFERS, &r->info1));

3688

break;

3689

3690

case 2:

3691

NDR_CHECK(ndr_pull_samr_UserInfo2(ndr, NDR_BUFFERS, &r->info2));

3692

break;

3693

3694

case 3:

3695

NDR_CHECK(ndr_pull_samr_UserInfo3(ndr, NDR_BUFFERS, &r->info3));

3696

break;

3697

3698

case 4:

3699

NDR_CHECK(ndr_pull_samr_UserInfo4(ndr, NDR_BUFFERS, &r->info4));

3700

break;

3701

3702

case 5:

3703

NDR_CHECK(ndr_pull_samr_UserInfo5(ndr, NDR_BUFFERS, &r->info5));

3704

break;

3705

3706

case 6:

3707

NDR_CHECK(ndr_pull_samr_UserInfo6(ndr, NDR_BUFFERS, &r->info6));

3708

break;

3709

3710

case 7:

3711

NDR_CHECK(ndr_pull_samr_UserInfo7(ndr, NDR_BUFFERS, &r->info7));

3712

break;

3713

3714

case 8:

3715

NDR_CHECK(ndr_pull_samr_UserInfo8(ndr, NDR_BUFFERS, &r->info8));

3716

break;

3717

3718

case 9:

3719

break;

3720

3721

case 10:

3722

NDR_CHECK(ndr_pull_samr_UserInfo10(ndr, NDR_BUFFERS, &r->info10));

3723

break;

3724

3725

case 11:

3726

NDR_CHECK(ndr_pull_samr_UserInfo11(ndr, NDR_BUFFERS, &r->info11));

3727

break;

3728

3729

case 12:

3730

NDR_CHECK(ndr_pull_samr_UserInfo12(ndr, NDR_BUFFERS, &r->info12));

3731

break;

3732

3733

case 13:

3734

NDR_CHECK(ndr_pull_samr_UserInfo13(ndr, NDR_BUFFERS, &r->info13));

3735

break;

3736

3737

case 14:

3738

NDR_CHECK(ndr_pull_samr_UserInfo14(ndr, NDR_BUFFERS, &r->info14));

3739

break;

3740

3741

case 16:

3742

break;

3743

3744

case 17:

3745

break;

3746

3747

case 18:

3748

break;

3749

3750

case 20:

3751

NDR_CHECK(ndr_pull_samr_UserInfo20(ndr, NDR_BUFFERS, &r->info20));

3752

break;

3753

3754

case 21:

3755

NDR_CHECK(ndr_pull_samr_UserInfo21(ndr, NDR_BUFFERS, &r->info21));

3756

break;

3757

3758

case 23:

3759

NDR_CHECK(ndr_pull_samr_UserInfo23(ndr, NDR_BUFFERS, &r->info23));

3760

break;

3761

3762

case 24:

3763

break;

3764

3765

case 25:

3766

NDR_CHECK(ndr_pull_samr_UserInfo25(ndr, NDR_BUFFERS, &r->info25));

3767

break;

3768

3769

case 26:

3770

break;

3771

3772

default:

3773

return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);

3774

}

3775

}

3776

return NDR_ERR_SUCCESS;

3777

}

3778

3779

_PUBLIC_ void ndr_print_samr_UserInfo(struct ndr_print *ndr, const char *name, const union samr_UserInfo *r)

3780

{

3781

uint32_t level;

3782

level = ndr_print_get_switch_value(ndr, r);

3783

ndr_print_union(ndr, name, level, "samr_UserInfo");

3784

switch (level) {

3785

case 1:

3786

ndr_print_samr_UserInfo1(ndr, "info1", &r->info1);

3787

break;

3788

3789

case 2:

3790

ndr_print_samr_UserInfo2(ndr, "info2", &r->info2);

3791

break;

3792

3793

case 3:

3794

ndr_print_samr_UserInfo3(ndr, "info3", &r->info3);

3795

break;

3796

3797

case 4:

3798

ndr_print_samr_UserInfo4(ndr, "info4", &r->info4);

3799

break;

3800

3801

case 5:

3802

ndr_print_samr_UserInfo5(ndr, "info5", &r->info5);

3803

break;

3804

3805

case 6:

3806

ndr_print_samr_UserInfo6(ndr, "info6", &r->info6);

3807

break;

3808

3809

case 7:

3810

ndr_print_samr_UserInfo7(ndr, "info7", &r->info7);

3811

break;

3812

3813

case 8:

3814

ndr_print_samr_UserInfo8(ndr, "info8", &r->info8);

3815

break;

3816

3817

case 9:

3818

ndr_print_samr_UserInfo9(ndr, "info9", &r->info9);

3819

break;

3820

3821

case 10:

3822

ndr_print_samr_UserInfo10(ndr, "info10", &r->info10);

3823

break;

3824

3825

case 11:

3826

ndr_print_samr_UserInfo11(ndr, "info11", &r->info11);

3827

break;

3828

3829

case 12:

3830

ndr_print_samr_UserInfo12(ndr, "info12", &r->info12);

3831

break;

3832

3833

case 13:

3834

ndr_print_samr_UserInfo13(ndr, "info13", &r->info13);

3835

break;

3836

3837

case 14:

3838

ndr_print_samr_UserInfo14(ndr, "info14", &r->info14);

3839

break;

3840

3841

case 16:

3842

ndr_print_samr_UserInfo16(ndr, "info16", &r->info16);

3843

break;

3844

3845

case 17:

3846

ndr_print_samr_UserInfo17(ndr, "info17", &r->info17);

3847

break;

3848

3849

case 18:

3850

ndr_print_samr_UserInfo18(ndr, "info18", &r->info18);

3851

break;

3852

3853

case 20:

3854

ndr_print_samr_UserInfo20(ndr, "info20", &r->info20);

3855

break;

3856

3857

case 21:

3858

ndr_print_samr_UserInfo21(ndr, "info21", &r->info21);

3859

break;

3860

3861

case 23:

3862

ndr_print_samr_UserInfo23(ndr, "info23", &r->info23);

3863

break;

3864

3865

case 24:

3866

ndr_print_samr_UserInfo24(ndr, "info24", &r->info24);

3867

break;

3868

3869

case 25:

3870

ndr_print_samr_UserInfo25(ndr, "info25", &r->info25);

3871

break;

3872

3873

case 26:

3874

ndr_print_samr_UserInfo26(ndr, "info26", &r->info26);

3875

break;

3876

3877

default:

3878

ndr_print_bad_level(ndr, name, level);

3879

}

3880

}

3881

3882

_PUBLIC_ enum ndr_err_code ndr_push_samr_RidWithAttribute(struct ndr_push *ndr, int ndr_flags, const struct samr_RidWithAttribute *r)

3883

{

3884

if (ndr_flags & NDR_SCALARS) {

3885

NDR_CHECK(ndr_push_align(ndr, 4));

3886

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->rid));

3887

NDR_CHECK(ndr_push_samr_GroupAttrs(ndr, NDR_SCALARS, r->attributes));

3888

NDR_CHECK(ndr_push_trailer_align(ndr, 4));

3889

}

3890

if (ndr_flags & NDR_BUFFERS) {

3891

}

3892

return NDR_ERR_SUCCESS;

3893

}

3894

3895

_PUBLIC_ enum ndr_err_code ndr_pull_samr_RidWithAttribute(struct ndr_pull *ndr, int ndr_flags, struct samr_RidWithAttribute *r)

3896

{

3897

if (ndr_flags & NDR_SCALARS) {

3898

NDR_CHECK(ndr_pull_align(ndr, 4));

3899

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->rid));

3900

NDR_CHECK(ndr_pull_samr_GroupAttrs(ndr, NDR_SCALARS, &r->attributes));

3901

NDR_CHECK(ndr_pull_trailer_align(ndr, 4));

3902

}

3903

if (ndr_flags & NDR_BUFFERS) {

3904

}

3905

return NDR_ERR_SUCCESS;

3906

}

3907

3908

_PUBLIC_ void ndr_print_samr_RidWithAttribute(struct ndr_print *ndr, const char *name, const struct samr_RidWithAttribute *r)

3909

{

3910

ndr_print_struct(ndr, name, "samr_RidWithAttribute");

3911

if (r == NULL) { ndr_print_null(ndr); return; }

3912

ndr->depth++;

3913

ndr_print_uint32(ndr, "rid", r->rid);

3914

ndr_print_samr_GroupAttrs(ndr, "attributes", r->attributes);

3915

ndr->depth--;

3916

}

3917

3918

_PUBLIC_ enum ndr_err_code ndr_push_samr_RidWithAttributeArray(struct ndr_push *ndr, int ndr_flags, const struct samr_RidWithAttributeArray *r)

3919

{

3920

uint32_t cntr_rids_1;

3921

if (ndr_flags & NDR_SCALARS) {

3922

NDR_CHECK(ndr_push_align(ndr, 5));

3923

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));

3924

NDR_CHECK(ndr_push_unique_ptr(ndr, r->rids));

3925

NDR_CHECK(ndr_push_trailer_align(ndr, 5));

3926

}

3927

if (ndr_flags & NDR_BUFFERS) {

3928

if (r->rids) {

3929

NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));

3930

for (cntr_rids_1 = 0; cntr_rids_1 < r->count; cntr_rids_1++) {

3931

NDR_CHECK(ndr_push_samr_RidWithAttribute(ndr, NDR_SCALARS, &r->rids[cntr_rids_1]));

3932

}

3933

}

3934

}

3935

return NDR_ERR_SUCCESS;

3936

}

3937

3938

_PUBLIC_ enum ndr_err_code ndr_pull_samr_RidWithAttributeArray(struct ndr_pull *ndr, int ndr_flags, struct samr_RidWithAttributeArray *r)

3939

{

3940

uint32_t _ptr_rids;

3941

uint32_t cntr_rids_1;

3942

TALLOC_CTX *_mem_save_rids_0;

3943

TALLOC_CTX *_mem_save_rids_1;

3944

if (ndr_flags & NDR_SCALARS) {

3945

NDR_CHECK(ndr_pull_align(ndr, 5));

3946

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));

3947

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_rids));

3948

if (_ptr_rids) {

3949

NDR_PULL_ALLOC(ndr, r->rids);

3950

} else {

3951

r->rids = NULL;

3952

}

3953

NDR_CHECK(ndr_pull_trailer_align(ndr, 5));

3954

}

3955

if (ndr_flags & NDR_BUFFERS) {

3956

if (r->rids) {

3957

_mem_save_rids_0 = NDR_PULL_GET_MEM_CTX(ndr);

3958

NDR_PULL_SET_MEM_CTX(ndr, r->rids, 0);

3959

NDR_CHECK(ndr_pull_array_size(ndr, &r->rids));

3960

NDR_PULL_ALLOC_N(ndr, r->rids, ndr_get_array_size(ndr, &r->rids));

3961

_mem_save_rids_1 = NDR_PULL_GET_MEM_CTX(ndr);

3962

NDR_PULL_SET_MEM_CTX(ndr, r->rids, 0);

3963

for (cntr_rids_1 = 0; cntr_rids_1 < r->count; cntr_rids_1++) {

3964

NDR_CHECK(ndr_pull_samr_RidWithAttribute(ndr, NDR_SCALARS, &r->rids[cntr_rids_1]));

3965

}

3966

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_rids_1, 0);

3967

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_rids_0, 0);

3968

}

3969

if (r->rids) {

3970

NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->rids, r->count));

3971

}

3972

}

3973

return NDR_ERR_SUCCESS;

3974

}

3975

3976

_PUBLIC_ void ndr_print_samr_RidWithAttributeArray(struct ndr_print *ndr, const char *name, const struct samr_RidWithAttributeArray *r)

3977

{

3978

uint32_t cntr_rids_1;

3979

ndr_print_struct(ndr, name, "samr_RidWithAttributeArray");

3980

if (r == NULL) { ndr_print_null(ndr); return; }

3981

ndr->depth++;

3982

ndr_print_uint32(ndr, "count", r->count);

3983

ndr_print_ptr(ndr, "rids", r->rids);

3984

ndr->depth++;

3985

if (r->rids) {

3986

ndr->print(ndr, "%s: ARRAY(%d)", "rids", (int)r->count);

3987

ndr->depth++;

3988

for (cntr_rids_1=0;cntr_rids_1<r->count;cntr_rids_1++) {

3989

ndr_print_samr_RidWithAttribute(ndr, "rids", &r->rids[cntr_rids_1]);

3990

}

3991

ndr->depth--;

3992

}

3993

ndr->depth--;

3994

ndr->depth--;

3995

}

3996

3997

static enum ndr_err_code ndr_push_samr_DispEntryGeneral(struct ndr_push *ndr, int ndr_flags, const struct samr_DispEntryGeneral *r)

3998

{

3999

if (ndr_flags & NDR_SCALARS) {

4000

NDR_CHECK(ndr_push_align(ndr, 5));

4001

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->idx));

4002

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->rid));

4003

NDR_CHECK(ndr_push_samr_AcctFlags(ndr, NDR_SCALARS, r->acct_flags));

4004

NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->account_name));

4005

NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->description));

4006

NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->full_name));

4007

NDR_CHECK(ndr_push_trailer_align(ndr, 5));

4008

}

4009

if (ndr_flags & NDR_BUFFERS) {

4010

NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->account_name));

4011

NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->description));

4012

NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->full_name));

4013

}

4014

return NDR_ERR_SUCCESS;

4015

}

4016

4017

static enum ndr_err_code ndr_pull_samr_DispEntryGeneral(struct ndr_pull *ndr, int ndr_flags, struct samr_DispEntryGeneral *r)

4018

{

4019

if (ndr_flags & NDR_SCALARS) {

4020

NDR_CHECK(ndr_pull_align(ndr, 5));

4021

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->idx));

4022

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->rid));

4023

NDR_CHECK(ndr_pull_samr_AcctFlags(ndr, NDR_SCALARS, &r->acct_flags));

4024

NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->account_name));

4025

NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->description));

4026

NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->full_name));

4027

NDR_CHECK(ndr_pull_trailer_align(ndr, 5));

4028

}

4029

if (ndr_flags & NDR_BUFFERS) {

4030

NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->account_name));

4031

NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->description));

4032

NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->full_name));

4033

}

4034

return NDR_ERR_SUCCESS;

4035

}

4036

4037

_PUBLIC_ void ndr_print_samr_DispEntryGeneral(struct ndr_print *ndr, const char *name, const struct samr_DispEntryGeneral *r)

4038

{

4039

ndr_print_struct(ndr, name, "samr_DispEntryGeneral");

4040

if (r == NULL) { ndr_print_null(ndr); return; }

4041

ndr->depth++;

4042

ndr_print_uint32(ndr, "idx", r->idx);

4043

ndr_print_uint32(ndr, "rid", r->rid);

4044

ndr_print_samr_AcctFlags(ndr, "acct_flags", r->acct_flags);

4045

ndr_print_lsa_String(ndr, "account_name", &r->account_name);

4046

ndr_print_lsa_String(ndr, "description", &r->description);

4047

ndr_print_lsa_String(ndr, "full_name", &r->full_name);

4048

ndr->depth--;

4049

}

4050

4051

static enum ndr_err_code ndr_push_samr_DispInfoGeneral(struct ndr_push *ndr, int ndr_flags, const struct samr_DispInfoGeneral *r)

4052

{

4053

uint32_t cntr_entries_1;

4054

if (ndr_flags & NDR_SCALARS) {

4055

NDR_CHECK(ndr_push_align(ndr, 5));

4056

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));

4057

NDR_CHECK(ndr_push_unique_ptr(ndr, r->entries));

4058

NDR_CHECK(ndr_push_trailer_align(ndr, 5));

4059

}

4060

if (ndr_flags & NDR_BUFFERS) {

4061

if (r->entries) {

4062

NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));

4063

for (cntr_entries_1 = 0; cntr_entries_1 < r->count; cntr_entries_1++) {

4064

NDR_CHECK(ndr_push_samr_DispEntryGeneral(ndr, NDR_SCALARS, &r->entries[cntr_entries_1]));

4065

}

4066

for (cntr_entries_1 = 0; cntr_entries_1 < r->count; cntr_entries_1++) {

4067

NDR_CHECK(ndr_push_samr_DispEntryGeneral(ndr, NDR_BUFFERS, &r->entries[cntr_entries_1]));

4068

}

4069

}

4070

}

4071

return NDR_ERR_SUCCESS;

4072

}

4073

4074

static enum ndr_err_code ndr_pull_samr_DispInfoGeneral(struct ndr_pull *ndr, int ndr_flags, struct samr_DispInfoGeneral *r)

4075

{

4076

uint32_t _ptr_entries;

4077

uint32_t cntr_entries_1;

4078

TALLOC_CTX *_mem_save_entries_0;

4079

TALLOC_CTX *_mem_save_entries_1;

4080

if (ndr_flags & NDR_SCALARS) {

4081

NDR_CHECK(ndr_pull_align(ndr, 5));

4082

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));

4083

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_entries));

4084

if (_ptr_entries) {

4085

NDR_PULL_ALLOC(ndr, r->entries);

4086

} else {

4087

r->entries = NULL;

4088

}

4089

NDR_CHECK(ndr_pull_trailer_align(ndr, 5));

4090

}

4091

if (ndr_flags & NDR_BUFFERS) {

4092

if (r->entries) {

4093

_mem_save_entries_0 = NDR_PULL_GET_MEM_CTX(ndr);

4094

NDR_PULL_SET_MEM_CTX(ndr, r->entries, 0);

4095

NDR_CHECK(ndr_pull_array_size(ndr, &r->entries));

4096

NDR_PULL_ALLOC_N(ndr, r->entries, ndr_get_array_size(ndr, &r->entries));

4097

_mem_save_entries_1 = NDR_PULL_GET_MEM_CTX(ndr);

4098

NDR_PULL_SET_MEM_CTX(ndr, r->entries, 0);

4099

for (cntr_entries_1 = 0; cntr_entries_1 < r->count; cntr_entries_1++) {

4100

NDR_CHECK(ndr_pull_samr_DispEntryGeneral(ndr, NDR_SCALARS, &r->entries[cntr_entries_1]));

4101

}

4102

for (cntr_entries_1 = 0; cntr_entries_1 < r->count; cntr_entries_1++) {

4103

NDR_CHECK(ndr_pull_samr_DispEntryGeneral(ndr, NDR_BUFFERS, &r->entries[cntr_entries_1]));

4104

}

4105

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_entries_1, 0);

4106

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_entries_0, 0);

4107

}

4108

if (r->entries) {

4109

NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->entries, r->count));

4110

}

4111

}

4112

return NDR_ERR_SUCCESS;

4113

}

4114

4115

_PUBLIC_ void ndr_print_samr_DispInfoGeneral(struct ndr_print *ndr, const char *name, const struct samr_DispInfoGeneral *r)

4116

{

4117

uint32_t cntr_entries_1;

4118

ndr_print_struct(ndr, name, "samr_DispInfoGeneral");

4119

if (r == NULL) { ndr_print_null(ndr); return; }

4120

ndr->depth++;

4121

ndr_print_uint32(ndr, "count", r->count);

4122

ndr_print_ptr(ndr, "entries", r->entries);

4123

ndr->depth++;

4124

if (r->entries) {

4125

ndr->print(ndr, "%s: ARRAY(%d)", "entries", (int)r->count);

4126

ndr->depth++;

4127

for (cntr_entries_1=0;cntr_entries_1<r->count;cntr_entries_1++) {

4128

ndr_print_samr_DispEntryGeneral(ndr, "entries", &r->entries[cntr_entries_1]);

4129

}

4130

ndr->depth--;

4131

}

4132

ndr->depth--;

4133

ndr->depth--;

4134

}

4135

4136

static enum ndr_err_code ndr_push_samr_DispEntryFull(struct ndr_push *ndr, int ndr_flags, const struct samr_DispEntryFull *r)

4137

{

4138

if (ndr_flags & NDR_SCALARS) {

4139

NDR_CHECK(ndr_push_align(ndr, 5));

4140

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->idx));

4141

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->rid));

4142

NDR_CHECK(ndr_push_samr_AcctFlags(ndr, NDR_SCALARS, r->acct_flags));

4143

NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->account_name));

4144

NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->description));

4145

NDR_CHECK(ndr_push_trailer_align(ndr, 5));

4146

}

4147

if (ndr_flags & NDR_BUFFERS) {

4148

NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->account_name));

4149

NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->description));

4150

}

4151

return NDR_ERR_SUCCESS;

4152

}

4153

4154

static enum ndr_err_code ndr_pull_samr_DispEntryFull(struct ndr_pull *ndr, int ndr_flags, struct samr_DispEntryFull *r)

4155

{

4156

if (ndr_flags & NDR_SCALARS) {

4157

NDR_CHECK(ndr_pull_align(ndr, 5));

4158

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->idx));

4159

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->rid));

4160

NDR_CHECK(ndr_pull_samr_AcctFlags(ndr, NDR_SCALARS, &r->acct_flags));

4161

NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->account_name));

4162

NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->description));

4163

NDR_CHECK(ndr_pull_trailer_align(ndr, 5));

4164

}

4165

if (ndr_flags & NDR_BUFFERS) {

4166

NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->account_name));

4167

NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->description));

4168

}

4169

return NDR_ERR_SUCCESS;

4170

}

4171

4172

_PUBLIC_ void ndr_print_samr_DispEntryFull(struct ndr_print *ndr, const char *name, const struct samr_DispEntryFull *r)

4173

{

4174

ndr_print_struct(ndr, name, "samr_DispEntryFull");

4175

if (r == NULL) { ndr_print_null(ndr); return; }

4176

ndr->depth++;

4177

ndr_print_uint32(ndr, "idx", r->idx);

4178

ndr_print_uint32(ndr, "rid", r->rid);

4179

ndr_print_samr_AcctFlags(ndr, "acct_flags", r->acct_flags);

4180

ndr_print_lsa_String(ndr, "account_name", &r->account_name);

4181

ndr_print_lsa_String(ndr, "description", &r->description);

4182

ndr->depth--;

4183

}

4184

4185

static enum ndr_err_code ndr_push_samr_DispInfoFull(struct ndr_push *ndr, int ndr_flags, const struct samr_DispInfoFull *r)

4186

{

4187

uint32_t cntr_entries_1;

4188

if (ndr_flags & NDR_SCALARS) {

4189

NDR_CHECK(ndr_push_align(ndr, 5));

4190

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));

4191

NDR_CHECK(ndr_push_unique_ptr(ndr, r->entries));

4192

NDR_CHECK(ndr_push_trailer_align(ndr, 5));

4193

}

4194

if (ndr_flags & NDR_BUFFERS) {

4195

if (r->entries) {

4196

NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));

4197

for (cntr_entries_1 = 0; cntr_entries_1 < r->count; cntr_entries_1++) {

4198

NDR_CHECK(ndr_push_samr_DispEntryFull(ndr, NDR_SCALARS, &r->entries[cntr_entries_1]));

4199

}

4200

for (cntr_entries_1 = 0; cntr_entries_1 < r->count; cntr_entries_1++) {

4201

NDR_CHECK(ndr_push_samr_DispEntryFull(ndr, NDR_BUFFERS, &r->entries[cntr_entries_1]));

4202

}

4203

}

4204

}

4205

return NDR_ERR_SUCCESS;

4206

}

4207

4208

static enum ndr_err_code ndr_pull_samr_DispInfoFull(struct ndr_pull *ndr, int ndr_flags, struct samr_DispInfoFull *r)

4209

{

4210

uint32_t _ptr_entries;

4211

uint32_t cntr_entries_1;

4212

TALLOC_CTX *_mem_save_entries_0;

4213

TALLOC_CTX *_mem_save_entries_1;

4214

if (ndr_flags & NDR_SCALARS) {

4215

NDR_CHECK(ndr_pull_align(ndr, 5));

4216

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));

4217

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_entries));

4218

if (_ptr_entries) {

4219

NDR_PULL_ALLOC(ndr, r->entries);

4220

} else {

4221

r->entries = NULL;

4222

}

4223

NDR_CHECK(ndr_pull_trailer_align(ndr, 5));

4224

}

4225

if (ndr_flags & NDR_BUFFERS) {

4226

if (r->entries) {

4227

_mem_save_entries_0 = NDR_PULL_GET_MEM_CTX(ndr);

4228

NDR_PULL_SET_MEM_CTX(ndr, r->entries, 0);

4229

NDR_CHECK(ndr_pull_array_size(ndr, &r->entries));

4230

NDR_PULL_ALLOC_N(ndr, r->entries, ndr_get_array_size(ndr, &r->entries));

4231

_mem_save_entries_1 = NDR_PULL_GET_MEM_CTX(ndr);

4232

NDR_PULL_SET_MEM_CTX(ndr, r->entries, 0);

4233

for (cntr_entries_1 = 0; cntr_entries_1 < r->count; cntr_entries_1++) {

4234

NDR_CHECK(ndr_pull_samr_DispEntryFull(ndr, NDR_SCALARS, &r->entries[cntr_entries_1]));

4235

}

4236

for (cntr_entries_1 = 0; cntr_entries_1 < r->count; cntr_entries_1++) {

4237

NDR_CHECK(ndr_pull_samr_DispEntryFull(ndr, NDR_BUFFERS, &r->entries[cntr_entries_1]));

4238

}

4239

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_entries_1, 0);

4240

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_entries_0, 0);

4241

}

4242

if (r->entries) {

4243

NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->entries, r->count));

4244

}

4245

}

4246

return NDR_ERR_SUCCESS;

4247

}

4248

4249

_PUBLIC_ void ndr_print_samr_DispInfoFull(struct ndr_print *ndr, const char *name, const struct samr_DispInfoFull *r)

4250

{

4251

uint32_t cntr_entries_1;

4252

ndr_print_struct(ndr, name, "samr_DispInfoFull");

4253

if (r == NULL) { ndr_print_null(ndr); return; }

4254

ndr->depth++;

4255

ndr_print_uint32(ndr, "count", r->count);

4256

ndr_print_ptr(ndr, "entries", r->entries);

4257

ndr->depth++;

4258

if (r->entries) {

4259

ndr->print(ndr, "%s: ARRAY(%d)", "entries", (int)r->count);

4260

ndr->depth++;

4261

for (cntr_entries_1=0;cntr_entries_1<r->count;cntr_entries_1++) {

4262

ndr_print_samr_DispEntryFull(ndr, "entries", &r->entries[cntr_entries_1]);

4263

}

4264

ndr->depth--;

4265

}

4266

ndr->depth--;

4267

ndr->depth--;

4268

}

4269

4270

static enum ndr_err_code ndr_push_samr_DispEntryFullGroup(struct ndr_push *ndr, int ndr_flags, const struct samr_DispEntryFullGroup *r)

4271

{

4272

if (ndr_flags & NDR_SCALARS) {

4273

NDR_CHECK(ndr_push_align(ndr, 5));

4274

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->idx));

4275

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->rid));

4276

NDR_CHECK(ndr_push_samr_GroupAttrs(ndr, NDR_SCALARS, r->acct_flags));

4277

NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->account_name));

4278

NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->description));

4279

NDR_CHECK(ndr_push_trailer_align(ndr, 5));

4280

}

4281

if (ndr_flags & NDR_BUFFERS) {

4282

NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->account_name));

4283

NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->description));

4284

}

4285

return NDR_ERR_SUCCESS;

4286

}

4287

4288

static enum ndr_err_code ndr_pull_samr_DispEntryFullGroup(struct ndr_pull *ndr, int ndr_flags, struct samr_DispEntryFullGroup *r)

4289

{

4290

if (ndr_flags & NDR_SCALARS) {

4291

NDR_CHECK(ndr_pull_align(ndr, 5));

4292

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->idx));

4293

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->rid));

4294

NDR_CHECK(ndr_pull_samr_GroupAttrs(ndr, NDR_SCALARS, &r->acct_flags));

4295

NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->account_name));

4296

NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->description));

4297

NDR_CHECK(ndr_pull_trailer_align(ndr, 5));

4298

}

4299

if (ndr_flags & NDR_BUFFERS) {

4300

NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->account_name));

4301

NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->description));

4302

}

4303

return NDR_ERR_SUCCESS;

4304

}

4305

4306

_PUBLIC_ void ndr_print_samr_DispEntryFullGroup(struct ndr_print *ndr, const char *name, const struct samr_DispEntryFullGroup *r)

4307

{

4308

ndr_print_struct(ndr, name, "samr_DispEntryFullGroup");

4309

if (r == NULL) { ndr_print_null(ndr); return; }

4310

ndr->depth++;

4311

ndr_print_uint32(ndr, "idx", r->idx);

4312

ndr_print_uint32(ndr, "rid", r->rid);

4313

ndr_print_samr_GroupAttrs(ndr, "acct_flags", r->acct_flags);

4314

ndr_print_lsa_String(ndr, "account_name", &r->account_name);

4315

ndr_print_lsa_String(ndr, "description", &r->description);

4316

ndr->depth--;

4317

}

4318

4319

static enum ndr_err_code ndr_push_samr_DispInfoFullGroups(struct ndr_push *ndr, int ndr_flags, const struct samr_DispInfoFullGroups *r)

4320

{

4321

uint32_t cntr_entries_1;

4322

if (ndr_flags & NDR_SCALARS) {

4323

NDR_CHECK(ndr_push_align(ndr, 5));

4324

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));

4325

NDR_CHECK(ndr_push_unique_ptr(ndr, r->entries));

4326

NDR_CHECK(ndr_push_trailer_align(ndr, 5));

4327

}

4328

if (ndr_flags & NDR_BUFFERS) {

4329

if (r->entries) {

4330

NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));

4331

for (cntr_entries_1 = 0; cntr_entries_1 < r->count; cntr_entries_1++) {

4332

NDR_CHECK(ndr_push_samr_DispEntryFullGroup(ndr, NDR_SCALARS, &r->entries[cntr_entries_1]));

4333

}

4334

for (cntr_entries_1 = 0; cntr_entries_1 < r->count; cntr_entries_1++) {

4335

NDR_CHECK(ndr_push_samr_DispEntryFullGroup(ndr, NDR_BUFFERS, &r->entries[cntr_entries_1]));

4336

}

4337

}

4338

}

4339

return NDR_ERR_SUCCESS;

4340

}

4341

4342

static enum ndr_err_code ndr_pull_samr_DispInfoFullGroups(struct ndr_pull *ndr, int ndr_flags, struct samr_DispInfoFullGroups *r)

4343

{

4344

uint32_t _ptr_entries;

4345

uint32_t cntr_entries_1;

4346

TALLOC_CTX *_mem_save_entries_0;

4347

TALLOC_CTX *_mem_save_entries_1;

4348

if (ndr_flags & NDR_SCALARS) {

4349

NDR_CHECK(ndr_pull_align(ndr, 5));

4350

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));

4351

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_entries));

4352

if (_ptr_entries) {

4353

NDR_PULL_ALLOC(ndr, r->entries);

4354

} else {

4355

r->entries = NULL;

4356

}

4357

NDR_CHECK(ndr_pull_trailer_align(ndr, 5));

4358

}

4359

if (ndr_flags & NDR_BUFFERS) {

4360

if (r->entries) {

4361

_mem_save_entries_0 = NDR_PULL_GET_MEM_CTX(ndr);

4362

NDR_PULL_SET_MEM_CTX(ndr, r->entries, 0);

4363

NDR_CHECK(ndr_pull_array_size(ndr, &r->entries));

4364

NDR_PULL_ALLOC_N(ndr, r->entries, ndr_get_array_size(ndr, &r->entries));

4365

_mem_save_entries_1 = NDR_PULL_GET_MEM_CTX(ndr);

4366

NDR_PULL_SET_MEM_CTX(ndr, r->entries, 0);

4367

for (cntr_entries_1 = 0; cntr_entries_1 < r->count; cntr_entries_1++) {

4368

NDR_CHECK(ndr_pull_samr_DispEntryFullGroup(ndr, NDR_SCALARS, &r->entries[cntr_entries_1]));

4369

}

4370

for (cntr_entries_1 = 0; cntr_entries_1 < r->count; cntr_entries_1++) {

4371

NDR_CHECK(ndr_pull_samr_DispEntryFullGroup(ndr, NDR_BUFFERS, &r->entries[cntr_entries_1]));

4372

}

4373

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_entries_1, 0);

4374

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_entries_0, 0);

4375

}

4376

if (r->entries) {

4377

NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->entries, r->count));

4378

}

4379

}

4380

return NDR_ERR_SUCCESS;

4381

}

4382

4383

_PUBLIC_ void ndr_print_samr_DispInfoFullGroups(struct ndr_print *ndr, const char *name, const struct samr_DispInfoFullGroups *r)

4384

{

4385

uint32_t cntr_entries_1;

4386

ndr_print_struct(ndr, name, "samr_DispInfoFullGroups");

4387

if (r == NULL) { ndr_print_null(ndr); return; }

4388

ndr->depth++;

4389

ndr_print_uint32(ndr, "count", r->count);

4390

ndr_print_ptr(ndr, "entries", r->entries);

4391

ndr->depth++;

4392

if (r->entries) {

4393

ndr->print(ndr, "%s: ARRAY(%d)", "entries", (int)r->count);

4394

ndr->depth++;

4395

for (cntr_entries_1=0;cntr_entries_1<r->count;cntr_entries_1++) {

4396

ndr_print_samr_DispEntryFullGroup(ndr, "entries", &r->entries[cntr_entries_1]);

4397

}

4398

ndr->depth--;

4399

}

4400

ndr->depth--;

4401

ndr->depth--;

4402

}

4403

4404

static enum ndr_err_code ndr_push_samr_DispEntryAscii(struct ndr_push *ndr, int ndr_flags, const struct samr_DispEntryAscii *r)

4405

{

4406

if (ndr_flags & NDR_SCALARS) {

4407

NDR_CHECK(ndr_push_align(ndr, 5));

4408

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->idx));

4409

NDR_CHECK(ndr_push_lsa_AsciiStringLarge(ndr, NDR_SCALARS, &r->account_name));

4410

NDR_CHECK(ndr_push_trailer_align(ndr, 5));

4411

}

4412

if (ndr_flags & NDR_BUFFERS) {

4413

NDR_CHECK(ndr_push_lsa_AsciiStringLarge(ndr, NDR_BUFFERS, &r->account_name));

4414

}

4415

return NDR_ERR_SUCCESS;

4416

}

4417

4418

static enum ndr_err_code ndr_pull_samr_DispEntryAscii(struct ndr_pull *ndr, int ndr_flags, struct samr_DispEntryAscii *r)

4419

{

4420

if (ndr_flags & NDR_SCALARS) {

4421

NDR_CHECK(ndr_pull_align(ndr, 5));

4422

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->idx));

4423

NDR_CHECK(ndr_pull_lsa_AsciiStringLarge(ndr, NDR_SCALARS, &r->account_name));

4424

NDR_CHECK(ndr_pull_trailer_align(ndr, 5));

4425

}

4426

if (ndr_flags & NDR_BUFFERS) {

4427

NDR_CHECK(ndr_pull_lsa_AsciiStringLarge(ndr, NDR_BUFFERS, &r->account_name));

4428

}

4429

return NDR_ERR_SUCCESS;

4430

}

4431

4432

_PUBLIC_ void ndr_print_samr_DispEntryAscii(struct ndr_print *ndr, const char *name, const struct samr_DispEntryAscii *r)

4433

{

4434

ndr_print_struct(ndr, name, "samr_DispEntryAscii");

4435

if (r == NULL) { ndr_print_null(ndr); return; }

4436

ndr->depth++;

4437

ndr_print_uint32(ndr, "idx", r->idx);

4438

ndr_print_lsa_AsciiStringLarge(ndr, "account_name", &r->account_name);

4439

ndr->depth--;

4440

}

4441

4442

static enum ndr_err_code ndr_push_samr_DispInfoAscii(struct ndr_push *ndr, int ndr_flags, const struct samr_DispInfoAscii *r)

4443

{

4444

uint32_t cntr_entries_1;

4445

if (ndr_flags & NDR_SCALARS) {

4446

NDR_CHECK(ndr_push_align(ndr, 5));

4447

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));

4448

NDR_CHECK(ndr_push_unique_ptr(ndr, r->entries));

4449

NDR_CHECK(ndr_push_trailer_align(ndr, 5));

4450

}

4451

if (ndr_flags & NDR_BUFFERS) {

4452

if (r->entries) {

4453

NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));

4454

for (cntr_entries_1 = 0; cntr_entries_1 < r->count; cntr_entries_1++) {

4455

NDR_CHECK(ndr_push_samr_DispEntryAscii(ndr, NDR_SCALARS, &r->entries[cntr_entries_1]));

4456

}

4457

for (cntr_entries_1 = 0; cntr_entries_1 < r->count; cntr_entries_1++) {

4458

NDR_CHECK(ndr_push_samr_DispEntryAscii(ndr, NDR_BUFFERS, &r->entries[cntr_entries_1]));

4459

}

4460

}

4461

}

4462

return NDR_ERR_SUCCESS;

4463

}

4464

4465

static enum ndr_err_code ndr_pull_samr_DispInfoAscii(struct ndr_pull *ndr, int ndr_flags, struct samr_DispInfoAscii *r)

4466

{

4467

uint32_t _ptr_entries;

4468

uint32_t cntr_entries_1;

4469

TALLOC_CTX *_mem_save_entries_0;

4470

TALLOC_CTX *_mem_save_entries_1;

4471

if (ndr_flags & NDR_SCALARS) {

4472

NDR_CHECK(ndr_pull_align(ndr, 5));

4473

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));

4474

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_entries));

4475

if (_ptr_entries) {

4476

NDR_PULL_ALLOC(ndr, r->entries);

4477

} else {

4478

r->entries = NULL;

4479

}

4480

NDR_CHECK(ndr_pull_trailer_align(ndr, 5));

4481

}

4482

if (ndr_flags & NDR_BUFFERS) {

4483

if (r->entries) {

4484

_mem_save_entries_0 = NDR_PULL_GET_MEM_CTX(ndr);

4485

NDR_PULL_SET_MEM_CTX(ndr, r->entries, 0);

4486

NDR_CHECK(ndr_pull_array_size(ndr, &r->entries));

4487

NDR_PULL_ALLOC_N(ndr, r->entries, ndr_get_array_size(ndr, &r->entries));

4488

_mem_save_entries_1 = NDR_PULL_GET_MEM_CTX(ndr);

4489

NDR_PULL_SET_MEM_CTX(ndr, r->entries, 0);

4490

for (cntr_entries_1 = 0; cntr_entries_1 < r->count; cntr_entries_1++) {

4491

NDR_CHECK(ndr_pull_samr_DispEntryAscii(ndr, NDR_SCALARS, &r->entries[cntr_entries_1]));

4492

}

4493

for (cntr_entries_1 = 0; cntr_entries_1 < r->count; cntr_entries_1++) {

4494

NDR_CHECK(ndr_pull_samr_DispEntryAscii(ndr, NDR_BUFFERS, &r->entries[cntr_entries_1]));

4495

}

4496

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_entries_1, 0);

4497

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_entries_0, 0);

4498

}

4499

if (r->entries) {

4500

NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->entries, r->count));

4501

}

4502

}

4503

return NDR_ERR_SUCCESS;

4504

}

4505

4506

_PUBLIC_ void ndr_print_samr_DispInfoAscii(struct ndr_print *ndr, const char *name, const struct samr_DispInfoAscii *r)

4507

{

4508

uint32_t cntr_entries_1;

4509

ndr_print_struct(ndr, name, "samr_DispInfoAscii");

4510

if (r == NULL) { ndr_print_null(ndr); return; }

4511

ndr->depth++;

4512

ndr_print_uint32(ndr, "count", r->count);

4513

ndr_print_ptr(ndr, "entries", r->entries);

4514

ndr->depth++;

4515

if (r->entries) {

4516

ndr->print(ndr, "%s: ARRAY(%d)", "entries", (int)r->count);

4517

ndr->depth++;

4518

for (cntr_entries_1=0;cntr_entries_1<r->count;cntr_entries_1++) {

4519

ndr_print_samr_DispEntryAscii(ndr, "entries", &r->entries[cntr_entries_1]);

4520

}

4521

ndr->depth--;

4522

}

4523

ndr->depth--;

4524

ndr->depth--;

4525

}

4526

4527

static enum ndr_err_code ndr_push_samr_DispInfo(struct ndr_push *ndr, int ndr_flags, const union samr_DispInfo *r)

4528

{

4529

if (ndr_flags & NDR_SCALARS) {

4530

uint32_t level = ndr_push_get_switch_value(ndr, r);

4531

NDR_CHECK(ndr_push_union_align(ndr, 5));

4532

NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, level));

4533

NDR_CHECK(ndr_push_union_align(ndr, 5));

4534

switch (level) {

4535

case 1: {

4536

NDR_CHECK(ndr_push_samr_DispInfoGeneral(ndr, NDR_SCALARS, &r->info1));

4537

break; }

4538

4539

case 2: {

4540

NDR_CHECK(ndr_push_samr_DispInfoFull(ndr, NDR_SCALARS, &r->info2));

4541

break; }

4542

4543

case 3: {

4544

NDR_CHECK(ndr_push_samr_DispInfoFullGroups(ndr, NDR_SCALARS, &r->info3));

4545

break; }

4546

4547

case 4: {

4548

NDR_CHECK(ndr_push_samr_DispInfoAscii(ndr, NDR_SCALARS, &r->info4));

4549

break; }

4550

4551

case 5: {

4552

NDR_CHECK(ndr_push_samr_DispInfoAscii(ndr, NDR_SCALARS, &r->info5));

4553

break; }

4554

4555

default:

4556

return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);

4557

}

4558

}

4559

if (ndr_flags & NDR_BUFFERS) {

4560

uint32_t level = ndr_push_get_switch_value(ndr, r);

4561

switch (level) {

4562

case 1:

4563

NDR_CHECK(ndr_push_samr_DispInfoGeneral(ndr, NDR_BUFFERS, &r->info1));

4564

break;

4565

4566

case 2:

4567

NDR_CHECK(ndr_push_samr_DispInfoFull(ndr, NDR_BUFFERS, &r->info2));

4568

break;

4569

4570

case 3:

4571

NDR_CHECK(ndr_push_samr_DispInfoFullGroups(ndr, NDR_BUFFERS, &r->info3));

4572

break;

4573

4574

case 4:

4575

NDR_CHECK(ndr_push_samr_DispInfoAscii(ndr, NDR_BUFFERS, &r->info4));

4576

break;

4577

4578

case 5:

4579

NDR_CHECK(ndr_push_samr_DispInfoAscii(ndr, NDR_BUFFERS, &r->info5));

4580

break;

4581

4582

default:

4583

return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);

4584

}

4585

}

4586

return NDR_ERR_SUCCESS;

4587

}

4588

4589

static enum ndr_err_code ndr_pull_samr_DispInfo(struct ndr_pull *ndr, int ndr_flags, union samr_DispInfo *r)

4590

{

4591

uint32_t level;

4592

uint16_t _level;

4593

level = ndr_pull_get_switch_value(ndr, r);

4594

if (ndr_flags & NDR_SCALARS) {

4595

NDR_CHECK(ndr_pull_union_align(ndr, 5));

4596

NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &_level));

4597

if (_level != level) {

4598

return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);

4599

}

4600

NDR_CHECK(ndr_pull_union_align(ndr, 5));

4601

switch (level) {

4602

case 1: {

4603

NDR_CHECK(ndr_pull_samr_DispInfoGeneral(ndr, NDR_SCALARS, &r->info1));

4604

break; }

4605

4606

case 2: {

4607

NDR_CHECK(ndr_pull_samr_DispInfoFull(ndr, NDR_SCALARS, &r->info2));

4608

break; }

4609

4610

case 3: {

4611

NDR_CHECK(ndr_pull_samr_DispInfoFullGroups(ndr, NDR_SCALARS, &r->info3));

4612

break; }

4613

4614

case 4: {

4615

NDR_CHECK(ndr_pull_samr_DispInfoAscii(ndr, NDR_SCALARS, &r->info4));

4616

break; }

4617

4618

case 5: {

4619

NDR_CHECK(ndr_pull_samr_DispInfoAscii(ndr, NDR_SCALARS, &r->info5));

4620

break; }

4621

4622

default:

4623

return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);

4624

}

4625

}

4626

if (ndr_flags & NDR_BUFFERS) {

4627

switch (level) {

4628

case 1:

4629

NDR_CHECK(ndr_pull_samr_DispInfoGeneral(ndr, NDR_BUFFERS, &r->info1));

4630

break;

4631

4632

case 2:

4633

NDR_CHECK(ndr_pull_samr_DispInfoFull(ndr, NDR_BUFFERS, &r->info2));

4634

break;

4635

4636

case 3:

4637

NDR_CHECK(ndr_pull_samr_DispInfoFullGroups(ndr, NDR_BUFFERS, &r->info3));

4638

break;

4639

4640

case 4:

4641

NDR_CHECK(ndr_pull_samr_DispInfoAscii(ndr, NDR_BUFFERS, &r->info4));

4642

break;

4643

4644

case 5:

4645

NDR_CHECK(ndr_pull_samr_DispInfoAscii(ndr, NDR_BUFFERS, &r->info5));

4646

break;

4647

4648

default:

4649

return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);

4650

}

4651

}

4652

return NDR_ERR_SUCCESS;

4653

}

4654

4655

_PUBLIC_ void ndr_print_samr_DispInfo(struct ndr_print *ndr, const char *name, const union samr_DispInfo *r)

4656

{

4657

uint32_t level;

4658

level = ndr_print_get_switch_value(ndr, r);

4659

ndr_print_union(ndr, name, level, "samr_DispInfo");

4660

switch (level) {

4661

case 1:

4662

ndr_print_samr_DispInfoGeneral(ndr, "info1", &r->info1);

4663

break;

4664

4665

case 2:

4666

ndr_print_samr_DispInfoFull(ndr, "info2", &r->info2);

4667

break;

4668

4669

case 3:

4670

ndr_print_samr_DispInfoFullGroups(ndr, "info3", &r->info3);

4671

break;

4672

4673

case 4:

4674

ndr_print_samr_DispInfoAscii(ndr, "info4", &r->info4);

4675

break;

4676

4677

case 5:

4678

ndr_print_samr_DispInfoAscii(ndr, "info5", &r->info5);

4679

break;

4680

4681

default:

4682

ndr_print_bad_level(ndr, name, level);

4683

}

4684

}

4685

4686

static enum ndr_err_code ndr_push_samr_PwInfo(struct ndr_push *ndr, int ndr_flags, const struct samr_PwInfo *r)

4687

{

4688

if (ndr_flags & NDR_SCALARS) {

4689

NDR_CHECK(ndr_push_align(ndr, 4));

4690

NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->min_password_length));

4691

NDR_CHECK(ndr_push_samr_PasswordProperties(ndr, NDR_SCALARS, r->password_properties));

4692

NDR_CHECK(ndr_push_trailer_align(ndr, 4));

4693

}

4694

if (ndr_flags & NDR_BUFFERS) {

4695

}

4696

return NDR_ERR_SUCCESS;

4697

}

4698

4699

static enum ndr_err_code ndr_pull_samr_PwInfo(struct ndr_pull *ndr, int ndr_flags, struct samr_PwInfo *r)

4700

{

4701

if (ndr_flags & NDR_SCALARS) {

4702

NDR_CHECK(ndr_pull_align(ndr, 4));

4703

NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->min_password_length));

4704

NDR_CHECK(ndr_pull_samr_PasswordProperties(ndr, NDR_SCALARS, &r->password_properties));

4705

NDR_CHECK(ndr_pull_trailer_align(ndr, 4));

4706

}

4707

if (ndr_flags & NDR_BUFFERS) {

4708

}

4709

return NDR_ERR_SUCCESS;

4710

}

4711

4712

_PUBLIC_ void ndr_print_samr_PwInfo(struct ndr_print *ndr, const char *name, const struct samr_PwInfo *r)

4713

{

4714

ndr_print_struct(ndr, name, "samr_PwInfo");

4715

if (r == NULL) { ndr_print_null(ndr); return; }

4716

ndr->depth++;

4717

ndr_print_uint16(ndr, "min_password_length", r->min_password_length);

4718

ndr_print_samr_PasswordProperties(ndr, "password_properties", r->password_properties);

4719

ndr->depth--;

4720

}

4721

4722

static enum ndr_err_code ndr_push_samr_ConnectVersion(struct ndr_push *ndr, int ndr_flags, enum samr_ConnectVersion r)

4723

{

4724

NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));

4725

return NDR_ERR_SUCCESS;

4726

}

4727

4728

static enum ndr_err_code ndr_pull_samr_ConnectVersion(struct ndr_pull *ndr, int ndr_flags, enum samr_ConnectVersion *r)

4729

{

4730

uint32_t v;

4731

NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));

4732

*r = v;

4733

return NDR_ERR_SUCCESS;

4734

}

4735

4736

_PUBLIC_ void ndr_print_samr_ConnectVersion(struct ndr_print *ndr, const char *name, enum samr_ConnectVersion r)

4737

{

4738

const char *val = NULL;

4739

4740

switch (r) {

4741

case SAMR_CONNECT_PRE_W2K: val = "SAMR_CONNECT_PRE_W2K"; break;

4742

case SAMR_CONNECT_W2K: val = "SAMR_CONNECT_W2K"; break;

4743

case SAMR_CONNECT_AFTER_W2K: val = "SAMR_CONNECT_AFTER_W2K"; break;

4744

}

4745

ndr_print_enum(ndr, name, "ENUM", val, r);

4746

}

4747

4748

_PUBLIC_ enum ndr_err_code ndr_push_samPwdChangeReason(struct ndr_push *ndr, int ndr_flags, enum samPwdChangeReason r)

4749

{

4750

NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));

4751

return NDR_ERR_SUCCESS;

4752

}

4753

4754

_PUBLIC_ enum ndr_err_code ndr_pull_samPwdChangeReason(struct ndr_pull *ndr, int ndr_flags, enum samPwdChangeReason *r)

4755

{

4756

uint32_t v;

4757

NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));

4758

*r = v;

4759

return NDR_ERR_SUCCESS;

4760

}

4761

4762

_PUBLIC_ void ndr_print_samPwdChangeReason(struct ndr_print *ndr, const char *name, enum samPwdChangeReason r)

4763

{

4764

const char *val = NULL;

4765

4766

switch (r) {

4767

case SAM_PWD_CHANGE_NO_ERROR: val = "SAM_PWD_CHANGE_NO_ERROR"; break;

4768

case SAM_PWD_CHANGE_PASSWORD_TOO_SHORT: val = "SAM_PWD_CHANGE_PASSWORD_TOO_SHORT"; break;

4769

case SAM_PWD_CHANGE_PWD_IN_HISTORY: val = "SAM_PWD_CHANGE_PWD_IN_HISTORY"; break;

4770

case SAM_PWD_CHANGE_USERNAME_IN_PASSWORD: val = "SAM_PWD_CHANGE_USERNAME_IN_PASSWORD"; break;

4771

case SAM_PWD_CHANGE_FULLNAME_IN_PASSWORD: val = "SAM_PWD_CHANGE_FULLNAME_IN_PASSWORD"; break;

4772

case SAM_PWD_CHANGE_NOT_COMPLEX: val = "SAM_PWD_CHANGE_NOT_COMPLEX"; break;

4773

case SAM_PWD_CHANGE_MACHINE_NOT_DEFAULT: val = "SAM_PWD_CHANGE_MACHINE_NOT_DEFAULT"; break;

4774

case SAM_PWD_CHANGE_FAILED_BY_FILTER: val = "SAM_PWD_CHANGE_FAILED_BY_FILTER"; break;

4775

case SAM_PWD_CHANGE_PASSWORD_TOO_LONG: val = "SAM_PWD_CHANGE_PASSWORD_TOO_LONG"; break;

4776

}

4777

ndr_print_enum(ndr, name, "ENUM", val, r);

4778

}

4779

4780

static enum ndr_err_code ndr_push_userPwdChangeFailureInformation(struct ndr_push *ndr, int ndr_flags, const struct userPwdChangeFailureInformation *r)

4781

{

4782

if (ndr_flags & NDR_SCALARS) {

4783

NDR_CHECK(ndr_push_align(ndr, 5));

4784

NDR_CHECK(ndr_push_samPwdChangeReason(ndr, NDR_SCALARS, r->extendedFailureReason));

4785

NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->filterModuleName));

4786

NDR_CHECK(ndr_push_trailer_align(ndr, 5));

4787

}

4788

if (ndr_flags & NDR_BUFFERS) {

4789

NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->filterModuleName));

4790

}

4791

return NDR_ERR_SUCCESS;

4792

}

4793

4794

static enum ndr_err_code ndr_pull_userPwdChangeFailureInformation(struct ndr_pull *ndr, int ndr_flags, struct userPwdChangeFailureInformation *r)

4795

{

4796

if (ndr_flags & NDR_SCALARS) {

4797

NDR_CHECK(ndr_pull_align(ndr, 5));

4798

NDR_CHECK(ndr_pull_samPwdChangeReason(ndr, NDR_SCALARS, &r->extendedFailureReason));

4799

NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->filterModuleName));

4800

NDR_CHECK(ndr_pull_trailer_align(ndr, 5));

4801

}

4802

if (ndr_flags & NDR_BUFFERS) {

4803

NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->filterModuleName));

4804

}

4805

return NDR_ERR_SUCCESS;

4806

}

4807

4808

_PUBLIC_ void ndr_print_userPwdChangeFailureInformation(struct ndr_print *ndr, const char *name, const struct userPwdChangeFailureInformation *r)

4809

{

4810

ndr_print_struct(ndr, name, "userPwdChangeFailureInformation");

4811

if (r == NULL) { ndr_print_null(ndr); return; }

4812

ndr->depth++;

4813

ndr_print_samPwdChangeReason(ndr, "extendedFailureReason", r->extendedFailureReason);

4814

ndr_print_lsa_String(ndr, "filterModuleName", &r->filterModuleName);

4815

ndr->depth--;

4816

}

4817

4818

static enum ndr_err_code ndr_push_samr_ConnectInfo1(struct ndr_push *ndr, int ndr_flags, const struct samr_ConnectInfo1 *r)

4819

{

4820

if (ndr_flags & NDR_SCALARS) {

4821

NDR_CHECK(ndr_push_align(ndr, 4));

4822

NDR_CHECK(ndr_push_samr_ConnectVersion(ndr, NDR_SCALARS, r->client_version));

4823

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown2));

4824

NDR_CHECK(ndr_push_trailer_align(ndr, 4));

4825

}

4826

if (ndr_flags & NDR_BUFFERS) {

4827

}

4828

return NDR_ERR_SUCCESS;

4829

}

4830

4831

static enum ndr_err_code ndr_pull_samr_ConnectInfo1(struct ndr_pull *ndr, int ndr_flags, struct samr_ConnectInfo1 *r)

4832

{

4833

if (ndr_flags & NDR_SCALARS) {

4834

NDR_CHECK(ndr_pull_align(ndr, 4));

4835

NDR_CHECK(ndr_pull_samr_ConnectVersion(ndr, NDR_SCALARS, &r->client_version));

4836

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown2));

4837

NDR_CHECK(ndr_pull_trailer_align(ndr, 4));

4838

}

4839

if (ndr_flags & NDR_BUFFERS) {

4840

}

4841

return NDR_ERR_SUCCESS;

4842

}

4843

4844

_PUBLIC_ void ndr_print_samr_ConnectInfo1(struct ndr_print *ndr, const char *name, const struct samr_ConnectInfo1 *r)

4845

{

4846

ndr_print_struct(ndr, name, "samr_ConnectInfo1");

4847

if (r == NULL) { ndr_print_null(ndr); return; }

4848

ndr->depth++;

4849

ndr_print_samr_ConnectVersion(ndr, "client_version", r->client_version);

4850

ndr_print_uint32(ndr, "unknown2", r->unknown2);

4851

ndr->depth--;

4852

}

4853

4854

static enum ndr_err_code ndr_push_samr_ConnectInfo(struct ndr_push *ndr, int ndr_flags, const union samr_ConnectInfo *r)

4855

{

4856

if (ndr_flags & NDR_SCALARS) {

4857

uint32_t level = ndr_push_get_switch_value(ndr, r);

4858

NDR_CHECK(ndr_push_union_align(ndr, 4));

4859

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));

4860

NDR_CHECK(ndr_push_union_align(ndr, 4));

4861

switch (level) {

4862

case 1: {

4863

NDR_CHECK(ndr_push_samr_ConnectInfo1(ndr, NDR_SCALARS, &r->info1));

4864

break; }

4865

4866

default:

4867

return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);

4868

}

4869

}

4870

if (ndr_flags & NDR_BUFFERS) {

4871

uint32_t level = ndr_push_get_switch_value(ndr, r);

4872

switch (level) {

4873

case 1:

4874

break;

4875

4876

default:

4877

return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);

4878

}

4879

}

4880

return NDR_ERR_SUCCESS;

4881

}

4882

4883

static enum ndr_err_code ndr_pull_samr_ConnectInfo(struct ndr_pull *ndr, int ndr_flags, union samr_ConnectInfo *r)

4884

{

4885

uint32_t level;

4886

uint32_t _level;

4887

level = ndr_pull_get_switch_value(ndr, r);

4888

if (ndr_flags & NDR_SCALARS) {

4889

NDR_CHECK(ndr_pull_union_align(ndr, 4));

4890

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));

4891

if (_level != level) {

4892

return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);

4893

}

4894

NDR_CHECK(ndr_pull_union_align(ndr, 4));

4895

switch (level) {

4896

case 1: {

4897

NDR_CHECK(ndr_pull_samr_ConnectInfo1(ndr, NDR_SCALARS, &r->info1));

4898

break; }

4899

4900

default:

4901

return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);

4902

}

4903

}

4904

if (ndr_flags & NDR_BUFFERS) {

4905

switch (level) {

4906

case 1:

4907

break;

4908

4909

default:

4910

return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);

4911

}

4912

}

4913

return NDR_ERR_SUCCESS;

4914

}

4915

4916

_PUBLIC_ void ndr_print_samr_ConnectInfo(struct ndr_print *ndr, const char *name, const union samr_ConnectInfo *r)

4917

{

4918

uint32_t level;

4919

level = ndr_print_get_switch_value(ndr, r);

4920

ndr_print_union(ndr, name, level, "samr_ConnectInfo");

4921

switch (level) {

4922

case 1:

4923

ndr_print_samr_ConnectInfo1(ndr, "info1", &r->info1);

4924

break;

4925

4926

default:

4927

ndr_print_bad_level(ndr, name, level);

4928

}

4929

}

4930

4931

static enum ndr_err_code ndr_push_samr_ValidateFieldsPresent(struct ndr_push *ndr, int ndr_flags, uint32_t r)

4932

{

4933

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));

4934

return NDR_ERR_SUCCESS;

4935

}

4936

4937

static enum ndr_err_code ndr_pull_samr_ValidateFieldsPresent(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)

4938

{

4939

uint32_t v;

4940

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));

4941

*r = v;

4942

return NDR_ERR_SUCCESS;

4943

}

4944

4945

_PUBLIC_ void ndr_print_samr_ValidateFieldsPresent(struct ndr_print *ndr, const char *name, uint32_t r)

4946

{

4947

ndr_print_uint32(ndr, name, r);

4948

ndr->depth++;

4949

ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_VALIDATE_FIELD_PASSWORD_LAST_SET", SAMR_VALIDATE_FIELD_PASSWORD_LAST_SET, r);

4950

ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_VALIDATE_FIELD_BAD_PASSWORD_TIME", SAMR_VALIDATE_FIELD_BAD_PASSWORD_TIME, r);

4951

ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_VALIDATE_FIELD_LOCKOUT_TIME", SAMR_VALIDATE_FIELD_LOCKOUT_TIME, r);

4952

ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_VALIDATE_FIELD_BAD_PASSWORD_COUNT", SAMR_VALIDATE_FIELD_BAD_PASSWORD_COUNT, r);

4953

ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_VALIDATE_FIELD_PASSWORD_HISTORY_LENGTH", SAMR_VALIDATE_FIELD_PASSWORD_HISTORY_LENGTH, r);

4954

ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SAMR_VALIDATE_FIELD_PASSWORD_HISTORY", SAMR_VALIDATE_FIELD_PASSWORD_HISTORY, r);

4955

ndr->depth--;

4956

}

4957

4958

static enum ndr_err_code ndr_push_samr_ValidatePasswordLevel(struct ndr_push *ndr, int ndr_flags, enum samr_ValidatePasswordLevel r)

4959

{

4960

NDR_CHECK(ndr_push_enum_uint1632(ndr, NDR_SCALARS, r));

4961

return NDR_ERR_SUCCESS;

4962

}

4963

4964

static enum ndr_err_code ndr_pull_samr_ValidatePasswordLevel(struct ndr_pull *ndr, int ndr_flags, enum samr_ValidatePasswordLevel *r)

4965

{

4966

uint16_t v;

4967

NDR_CHECK(ndr_pull_enum_uint1632(ndr, NDR_SCALARS, &v));

4968

*r = v;

4969

return NDR_ERR_SUCCESS;

4970

}

4971

4972

_PUBLIC_ void ndr_print_samr_ValidatePasswordLevel(struct ndr_print *ndr, const char *name, enum samr_ValidatePasswordLevel r)

4973

{

4974

const char *val = NULL;

4975

4976

switch (r) {

4977

case NetValidateAuthentication: val = "NetValidateAuthentication"; break;

4978

case NetValidatePasswordChange: val = "NetValidatePasswordChange"; break;

4979

case NetValidatePasswordReset: val = "NetValidatePasswordReset"; break;

4980

}

4981

ndr_print_enum(ndr, name, "ENUM", val, r);

4982

}

4983

4984

static enum ndr_err_code ndr_push_samr_ValidationStatus(struct ndr_push *ndr, int ndr_flags, enum samr_ValidationStatus r)

4985

{

4986

NDR_CHECK(ndr_push_enum_uint1632(ndr, NDR_SCALARS, r));

4987

return NDR_ERR_SUCCESS;

4988

}

4989

4990

static enum ndr_err_code ndr_pull_samr_ValidationStatus(struct ndr_pull *ndr, int ndr_flags, enum samr_ValidationStatus *r)

4991

{

4992

uint16_t v;

4993

NDR_CHECK(ndr_pull_enum_uint1632(ndr, NDR_SCALARS, &v));

4994

*r = v;

4995

return NDR_ERR_SUCCESS;

4996

}

4997

4998

_PUBLIC_ void ndr_print_samr_ValidationStatus(struct ndr_print *ndr, const char *name, enum samr_ValidationStatus r)

4999

{

5000

const char *val = NULL;

5001

5002

switch (r) {

5003

case SAMR_VALIDATION_STATUS_SUCCESS: val = "SAMR_VALIDATION_STATUS_SUCCESS"; break;

5004

case SAMR_VALIDATION_STATUS_PASSWORD_MUST_CHANGE: val = "SAMR_VALIDATION_STATUS_PASSWORD_MUST_CHANGE"; break;

5005

case SAMR_VALIDATION_STATUS_ACCOUNT_LOCKED_OUT: val = "SAMR_VALIDATION_STATUS_ACCOUNT_LOCKED_OUT"; break;

5006

case SAMR_VALIDATION_STATUS_PASSWORD_EXPIRED: val = "SAMR_VALIDATION_STATUS_PASSWORD_EXPIRED"; break;

5007

case SAMR_VALIDATION_STATUS_BAD_PASSWORD: val = "SAMR_VALIDATION_STATUS_BAD_PASSWORD"; break;

5008

case SAMR_VALIDATION_STATUS_PWD_HISTORY_CONFLICT: val = "SAMR_VALIDATION_STATUS_PWD_HISTORY_CONFLICT"; break;

5009

case SAMR_VALIDATION_STATUS_PWD_TOO_SHORT: val = "SAMR_VALIDATION_STATUS_PWD_TOO_SHORT"; break;

5010

case SAMR_VALIDATION_STATUS_PWD_TOO_LONG: val = "SAMR_VALIDATION_STATUS_PWD_TOO_LONG"; break;

5011

case SAMR_VALIDATION_STATUS_NOT_COMPLEX_ENOUGH: val = "SAMR_VALIDATION_STATUS_NOT_COMPLEX_ENOUGH"; break;

5012

case SAMR_VALIDATION_STATUS_PASSWORD_TOO_RECENT: val = "SAMR_VALIDATION_STATUS_PASSWORD_TOO_RECENT"; break;

5013

case SAMR_VALIDATION_STATUS_PASSWORD_FILTER_ERROR: val = "SAMR_VALIDATION_STATUS_PASSWORD_FILTER_ERROR"; break;

5014

}

5015

ndr_print_enum(ndr, name, "ENUM", val, r);

5016

}

5017

5018

static enum ndr_err_code ndr_push_samr_ValidationBlob(struct ndr_push *ndr, int ndr_flags, const struct samr_ValidationBlob *r)

5019

{

5020

if (ndr_flags & NDR_SCALARS) {

5021

NDR_CHECK(ndr_push_align(ndr, 5));

5022

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->length));

5023

NDR_CHECK(ndr_push_unique_ptr(ndr, r->data));

5024

NDR_CHECK(ndr_push_trailer_align(ndr, 5));

5025

}

5026

if (ndr_flags & NDR_BUFFERS) {

5027

if (r->data) {

5028

NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->length));

5029

NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->data, r->length));

5030

}

5031

}

5032

return NDR_ERR_SUCCESS;

5033

}

5034

5035

static enum ndr_err_code ndr_pull_samr_ValidationBlob(struct ndr_pull *ndr, int ndr_flags, struct samr_ValidationBlob *r)

5036

{

5037

uint32_t _ptr_data;

5038

TALLOC_CTX *_mem_save_data_0;

5039

if (ndr_flags & NDR_SCALARS) {

5040

NDR_CHECK(ndr_pull_align(ndr, 5));

5041

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->length));

5042

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data));

5043

if (_ptr_data) {

5044

NDR_PULL_ALLOC(ndr, r->data);

5045

} else {

5046

r->data = NULL;

5047

}

5048

NDR_CHECK(ndr_pull_trailer_align(ndr, 5));

5049

}

5050

if (ndr_flags & NDR_BUFFERS) {

5051

if (r->data) {

5052

_mem_save_data_0 = NDR_PULL_GET_MEM_CTX(ndr);

5053

NDR_PULL_SET_MEM_CTX(ndr, r->data, 0);

5054

NDR_CHECK(ndr_pull_array_size(ndr, &r->data));

5055

NDR_PULL_ALLOC_N(ndr, r->data, ndr_get_array_size(ndr, &r->data));

5056

NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->data, ndr_get_array_size(ndr, &r->data)));

5057

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_0, 0);

5058

}

5059

if (r->data) {

5060

NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->data, r->length));

5061

}

5062

}

5063

return NDR_ERR_SUCCESS;

5064

}

5065

5066

_PUBLIC_ void ndr_print_samr_ValidationBlob(struct ndr_print *ndr, const char *name, const struct samr_ValidationBlob *r)

5067

{

5068

ndr_print_struct(ndr, name, "samr_ValidationBlob");

5069

if (r == NULL) { ndr_print_null(ndr); return; }

5070

ndr->depth++;

5071

ndr_print_uint32(ndr, "length", r->length);

5072

ndr_print_ptr(ndr, "data", r->data);

5073

ndr->depth++;

5074

if (r->data) {

5075

ndr_print_array_uint8(ndr, "data", r->data, r->length);

5076

}

5077

ndr->depth--;

5078

ndr->depth--;

5079

}

5080

5081

static enum ndr_err_code ndr_push_samr_ValidatePasswordInfo(struct ndr_push *ndr, int ndr_flags, const struct samr_ValidatePasswordInfo *r)

5082

{

5083

uint32_t cntr_pwd_history_1;

5084

if (ndr_flags & NDR_SCALARS) {

5085

NDR_CHECK(ndr_push_align(ndr, 8));

5086

NDR_CHECK(ndr_push_samr_ValidateFieldsPresent(ndr, NDR_SCALARS, r->fields_present));

5087

NDR_CHECK(ndr_push_NTTIME_hyper(ndr, NDR_SCALARS, r->last_password_change));

5088

NDR_CHECK(ndr_push_NTTIME_hyper(ndr, NDR_SCALARS, r->bad_password_time));

5089

NDR_CHECK(ndr_push_NTTIME_hyper(ndr, NDR_SCALARS, r->lockout_time));

5090

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->bad_pwd_count));

5091

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->pwd_history_len));

5092

NDR_CHECK(ndr_push_unique_ptr(ndr, r->pwd_history));

5093

NDR_CHECK(ndr_push_trailer_align(ndr, 8));

5094

}

5095

if (ndr_flags & NDR_BUFFERS) {

5096

if (r->pwd_history) {

5097

NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->pwd_history_len));

5098

for (cntr_pwd_history_1 = 0; cntr_pwd_history_1 < r->pwd_history_len; cntr_pwd_history_1++) {

5099

NDR_CHECK(ndr_push_samr_ValidationBlob(ndr, NDR_SCALARS, &r->pwd_history[cntr_pwd_history_1]));

5100

}

5101

for (cntr_pwd_history_1 = 0; cntr_pwd_history_1 < r->pwd_history_len; cntr_pwd_history_1++) {

5102

NDR_CHECK(ndr_push_samr_ValidationBlob(ndr, NDR_BUFFERS, &r->pwd_history[cntr_pwd_history_1]));

5103

}

5104

}

5105

}

5106

return NDR_ERR_SUCCESS;

5107

}

5108

5109

static enum ndr_err_code ndr_pull_samr_ValidatePasswordInfo(struct ndr_pull *ndr, int ndr_flags, struct samr_ValidatePasswordInfo *r)

5110

{

5111

uint32_t _ptr_pwd_history;

5112

uint32_t cntr_pwd_history_1;

5113

TALLOC_CTX *_mem_save_pwd_history_0;

5114

TALLOC_CTX *_mem_save_pwd_history_1;

5115

if (ndr_flags & NDR_SCALARS) {

5116

NDR_CHECK(ndr_pull_align(ndr, 8));

5117

NDR_CHECK(ndr_pull_samr_ValidateFieldsPresent(ndr, NDR_SCALARS, &r->fields_present));

5118

NDR_CHECK(ndr_pull_NTTIME_hyper(ndr, NDR_SCALARS, &r->last_password_change));

5119

NDR_CHECK(ndr_pull_NTTIME_hyper(ndr, NDR_SCALARS, &r->bad_password_time));

5120

NDR_CHECK(ndr_pull_NTTIME_hyper(ndr, NDR_SCALARS, &r->lockout_time));

5121

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->bad_pwd_count));

5122

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->pwd_history_len));

5123

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_pwd_history));

5124

if (_ptr_pwd_history) {

5125

NDR_PULL_ALLOC(ndr, r->pwd_history);

5126

} else {

5127

r->pwd_history = NULL;

5128

}

5129

NDR_CHECK(ndr_pull_trailer_align(ndr, 8));

5130

}

5131

if (ndr_flags & NDR_BUFFERS) {

5132

if (r->pwd_history) {

5133

_mem_save_pwd_history_0 = NDR_PULL_GET_MEM_CTX(ndr);

5134

NDR_PULL_SET_MEM_CTX(ndr, r->pwd_history, 0);

5135

NDR_CHECK(ndr_pull_array_size(ndr, &r->pwd_history));

5136

NDR_PULL_ALLOC_N(ndr, r->pwd_history, ndr_get_array_size(ndr, &r->pwd_history));

5137

_mem_save_pwd_history_1 = NDR_PULL_GET_MEM_CTX(ndr);

5138

NDR_PULL_SET_MEM_CTX(ndr, r->pwd_history, 0);

5139

for (cntr_pwd_history_1 = 0; cntr_pwd_history_1 < r->pwd_history_len; cntr_pwd_history_1++) {

5140

NDR_CHECK(ndr_pull_samr_ValidationBlob(ndr, NDR_SCALARS, &r->pwd_history[cntr_pwd_history_1]));

5141

}

5142

for (cntr_pwd_history_1 = 0; cntr_pwd_history_1 < r->pwd_history_len; cntr_pwd_history_1++) {

5143

NDR_CHECK(ndr_pull_samr_ValidationBlob(ndr, NDR_BUFFERS, &r->pwd_history[cntr_pwd_history_1]));

5144

}

5145

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_pwd_history_1, 0);

5146

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_pwd_history_0, 0);

5147

}

5148

if (r->pwd_history) {

5149

NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->pwd_history, r->pwd_history_len));

5150

}

5151

}

5152

return NDR_ERR_SUCCESS;

5153

}

5154

5155

_PUBLIC_ void ndr_print_samr_ValidatePasswordInfo(struct ndr_print *ndr, const char *name, const struct samr_ValidatePasswordInfo *r)

5156

{

5157

uint32_t cntr_pwd_history_1;

5158

ndr_print_struct(ndr, name, "samr_ValidatePasswordInfo");

5159

if (r == NULL) { ndr_print_null(ndr); return; }

5160

ndr->depth++;

5161

ndr_print_samr_ValidateFieldsPresent(ndr, "fields_present", r->fields_present);

5162

ndr_print_NTTIME_hyper(ndr, "last_password_change", r->last_password_change);

5163

ndr_print_NTTIME_hyper(ndr, "bad_password_time", r->bad_password_time);

5164

ndr_print_NTTIME_hyper(ndr, "lockout_time", r->lockout_time);

5165

ndr_print_uint32(ndr, "bad_pwd_count", r->bad_pwd_count);

5166

ndr_print_uint32(ndr, "pwd_history_len", r->pwd_history_len);

5167

ndr_print_ptr(ndr, "pwd_history", r->pwd_history);

5168

ndr->depth++;

5169

if (r->pwd_history) {

5170

ndr->print(ndr, "%s: ARRAY(%d)", "pwd_history", (int)r->pwd_history_len);

5171

ndr->depth++;

5172

for (cntr_pwd_history_1=0;cntr_pwd_history_1<r->pwd_history_len;cntr_pwd_history_1++) {

5173

ndr_print_samr_ValidationBlob(ndr, "pwd_history", &r->pwd_history[cntr_pwd_history_1]);

5174

}

5175

ndr->depth--;

5176

}

5177

ndr->depth--;

5178

ndr->depth--;

5179

}

5180

5181

static enum ndr_err_code ndr_push_samr_ValidatePasswordRepCtr(struct ndr_push *ndr, int ndr_flags, const struct samr_ValidatePasswordRepCtr *r)

5182

{

5183

if (ndr_flags & NDR_SCALARS) {

5184

NDR_CHECK(ndr_push_align(ndr, 8));

5185

NDR_CHECK(ndr_push_samr_ValidatePasswordInfo(ndr, NDR_SCALARS, &r->info));

5186

NDR_CHECK(ndr_push_samr_ValidationStatus(ndr, NDR_SCALARS, r->status));

5187

NDR_CHECK(ndr_push_trailer_align(ndr, 8));

5188

}

5189

if (ndr_flags & NDR_BUFFERS) {

5190

NDR_CHECK(ndr_push_samr_ValidatePasswordInfo(ndr, NDR_BUFFERS, &r->info));

5191

}

5192

return NDR_ERR_SUCCESS;

5193

}

5194

5195

static enum ndr_err_code ndr_pull_samr_ValidatePasswordRepCtr(struct ndr_pull *ndr, int ndr_flags, struct samr_ValidatePasswordRepCtr *r)

5196

{

5197

if (ndr_flags & NDR_SCALARS) {

5198

NDR_CHECK(ndr_pull_align(ndr, 8));

5199

NDR_CHECK(ndr_pull_samr_ValidatePasswordInfo(ndr, NDR_SCALARS, &r->info));

5200

NDR_CHECK(ndr_pull_samr_ValidationStatus(ndr, NDR_SCALARS, &r->status));

5201

NDR_CHECK(ndr_pull_trailer_align(ndr, 8));

5202

}

5203

if (ndr_flags & NDR_BUFFERS) {

5204

NDR_CHECK(ndr_pull_samr_ValidatePasswordInfo(ndr, NDR_BUFFERS, &r->info));

5205

}

5206

return NDR_ERR_SUCCESS;

5207

}

5208

5209

_PUBLIC_ void ndr_print_samr_ValidatePasswordRepCtr(struct ndr_print *ndr, const char *name, const struct samr_ValidatePasswordRepCtr *r)

5210

{

5211

ndr_print_struct(ndr, name, "samr_ValidatePasswordRepCtr");

5212

if (r == NULL) { ndr_print_null(ndr); return; }

5213

ndr->depth++;

5214

ndr_print_samr_ValidatePasswordInfo(ndr, "info", &r->info);

5215

ndr_print_samr_ValidationStatus(ndr, "status", r->status);

5216

ndr->depth--;

5217

}

5218

5219

static enum ndr_err_code ndr_push_samr_ValidatePasswordRep(struct ndr_push *ndr, int ndr_flags, const union samr_ValidatePasswordRep *r)

5220

{

5221

if (ndr_flags & NDR_SCALARS) {

5222

uint32_t level = ndr_push_get_switch_value(ndr, r);

5223

NDR_CHECK(ndr_push_union_align(ndr, 8));

5224

NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, level));

5225

NDR_CHECK(ndr_push_union_align(ndr, 8));

5226

switch (level) {

5227

case 1: {

5228

NDR_CHECK(ndr_push_samr_ValidatePasswordRepCtr(ndr, NDR_SCALARS, &r->ctr1));

5229

break; }

5230

5231

case 2: {

5232

NDR_CHECK(ndr_push_samr_ValidatePasswordRepCtr(ndr, NDR_SCALARS, &r->ctr2));

5233

break; }

5234

5235

case 3: {

5236

NDR_CHECK(ndr_push_samr_ValidatePasswordRepCtr(ndr, NDR_SCALARS, &r->ctr3));

5237

break; }

5238

5239

default:

5240

return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);

5241

}

5242

}

5243

if (ndr_flags & NDR_BUFFERS) {

5244

uint32_t level = ndr_push_get_switch_value(ndr, r);

5245

switch (level) {

5246

case 1:

5247

NDR_CHECK(ndr_push_samr_ValidatePasswordRepCtr(ndr, NDR_BUFFERS, &r->ctr1));

5248

break;

5249

5250

case 2:

5251

NDR_CHECK(ndr_push_samr_ValidatePasswordRepCtr(ndr, NDR_BUFFERS, &r->ctr2));

5252

break;

5253

5254

case 3:

5255

NDR_CHECK(ndr_push_samr_ValidatePasswordRepCtr(ndr, NDR_BUFFERS, &r->ctr3));

5256

break;

5257

5258

default:

5259

return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);

5260

}

5261

}

5262

return NDR_ERR_SUCCESS;

5263

}

5264

5265

static enum ndr_err_code ndr_pull_samr_ValidatePasswordRep(struct ndr_pull *ndr, int ndr_flags, union samr_ValidatePasswordRep *r)

5266

{

5267

uint32_t level;

5268

uint16_t _level;

5269

level = ndr_pull_get_switch_value(ndr, r);

5270

if (ndr_flags & NDR_SCALARS) {

5271

NDR_CHECK(ndr_pull_union_align(ndr, 8));

5272

NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &_level));

5273

if (_level != level) {

5274

return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);

5275

}

5276

NDR_CHECK(ndr_pull_union_align(ndr, 8));

5277

switch (level) {

5278

case 1: {

5279

NDR_CHECK(ndr_pull_samr_ValidatePasswordRepCtr(ndr, NDR_SCALARS, &r->ctr1));

5280

break; }

5281

5282

case 2: {

5283

NDR_CHECK(ndr_pull_samr_ValidatePasswordRepCtr(ndr, NDR_SCALARS, &r->ctr2));

5284

break; }

5285

5286

case 3: {

5287

NDR_CHECK(ndr_pull_samr_ValidatePasswordRepCtr(ndr, NDR_SCALARS, &r->ctr3));

5288

break; }

5289

5290

default:

5291

return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);

5292

}

5293

}

5294

if (ndr_flags & NDR_BUFFERS) {

5295

switch (level) {

5296

case 1:

5297

NDR_CHECK(ndr_pull_samr_ValidatePasswordRepCtr(ndr, NDR_BUFFERS, &r->ctr1));

5298

break;

5299

5300

case 2:

5301

NDR_CHECK(ndr_pull_samr_ValidatePasswordRepCtr(ndr, NDR_BUFFERS, &r->ctr2));

5302

break;

5303

5304

case 3:

5305

NDR_CHECK(ndr_pull_samr_ValidatePasswordRepCtr(ndr, NDR_BUFFERS, &r->ctr3));

5306

break;

5307

5308

default:

5309

return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);

5310

}

5311

}

5312

return NDR_ERR_SUCCESS;

5313

}

5314

5315

_PUBLIC_ void ndr_print_samr_ValidatePasswordRep(struct ndr_print *ndr, const char *name, const union samr_ValidatePasswordRep *r)

5316

{

5317

uint32_t level;

5318

level = ndr_print_get_switch_value(ndr, r);

5319

ndr_print_union(ndr, name, level, "samr_ValidatePasswordRep");

5320

switch (level) {

5321

case 1:

5322

ndr_print_samr_ValidatePasswordRepCtr(ndr, "ctr1", &r->ctr1);

5323

break;

5324

5325

case 2:

5326

ndr_print_samr_ValidatePasswordRepCtr(ndr, "ctr2", &r->ctr2);

5327

break;

5328

5329

case 3:

5330

ndr_print_samr_ValidatePasswordRepCtr(ndr, "ctr3", &r->ctr3);

5331

break;

5332

5333

default:

5334

ndr_print_bad_level(ndr, name, level);

5335

}

5336

}

5337

5338

static enum ndr_err_code ndr_push_samr_ValidatePasswordReq3(struct ndr_push *ndr, int ndr_flags, const struct samr_ValidatePasswordReq3 *r)

5339

{

5340

if (ndr_flags & NDR_SCALARS) {

5341

NDR_CHECK(ndr_push_align(ndr, 8));

5342

NDR_CHECK(ndr_push_samr_ValidatePasswordInfo(ndr, NDR_SCALARS, &r->info));

5343

NDR_CHECK(ndr_push_lsa_StringLarge(ndr, NDR_SCALARS, &r->password));

5344

NDR_CHECK(ndr_push_lsa_StringLarge(ndr, NDR_SCALARS, &r->account));

5345

NDR_CHECK(ndr_push_samr_ValidationBlob(ndr, NDR_SCALARS, &r->hash));

5346

NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->pwd_must_change_at_next_logon));

5347

NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->clear_lockout));

5348

NDR_CHECK(ndr_push_trailer_align(ndr, 8));

5349

}

5350

if (ndr_flags & NDR_BUFFERS) {

5351

NDR_CHECK(ndr_push_samr_ValidatePasswordInfo(ndr, NDR_BUFFERS, &r->info));

5352

NDR_CHECK(ndr_push_lsa_StringLarge(ndr, NDR_BUFFERS, &r->password));

5353

NDR_CHECK(ndr_push_lsa_StringLarge(ndr, NDR_BUFFERS, &r->account));

5354

NDR_CHECK(ndr_push_samr_ValidationBlob(ndr, NDR_BUFFERS, &r->hash));

5355

}

5356

return NDR_ERR_SUCCESS;

5357

}

5358

5359

static enum ndr_err_code ndr_pull_samr_ValidatePasswordReq3(struct ndr_pull *ndr, int ndr_flags, struct samr_ValidatePasswordReq3 *r)

5360

{

5361

if (ndr_flags & NDR_SCALARS) {

5362

NDR_CHECK(ndr_pull_align(ndr, 8));

5363

NDR_CHECK(ndr_pull_samr_ValidatePasswordInfo(ndr, NDR_SCALARS, &r->info));

5364

NDR_CHECK(ndr_pull_lsa_StringLarge(ndr, NDR_SCALARS, &r->password));

5365

NDR_CHECK(ndr_pull_lsa_StringLarge(ndr, NDR_SCALARS, &r->account));

5366

NDR_CHECK(ndr_pull_samr_ValidationBlob(ndr, NDR_SCALARS, &r->hash));

5367

NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->pwd_must_change_at_next_logon));

5368

NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->clear_lockout));

5369

NDR_CHECK(ndr_pull_trailer_align(ndr, 8));

5370

}

5371

if (ndr_flags & NDR_BUFFERS) {

5372

NDR_CHECK(ndr_pull_samr_ValidatePasswordInfo(ndr, NDR_BUFFERS, &r->info));

5373

NDR_CHECK(ndr_pull_lsa_StringLarge(ndr, NDR_BUFFERS, &r->password));

5374

NDR_CHECK(ndr_pull_lsa_StringLarge(ndr, NDR_BUFFERS, &r->account));

5375

NDR_CHECK(ndr_pull_samr_ValidationBlob(ndr, NDR_BUFFERS, &r->hash));

5376

}

5377

return NDR_ERR_SUCCESS;

5378

}

5379

5380

_PUBLIC_ void ndr_print_samr_ValidatePasswordReq3(struct ndr_print *ndr, const char *name, const struct samr_ValidatePasswordReq3 *r)

5381

{

5382

ndr_print_struct(ndr, name, "samr_ValidatePasswordReq3");

5383

if (r == NULL) { ndr_print_null(ndr); return; }

5384

ndr->depth++;

5385

ndr_print_samr_ValidatePasswordInfo(ndr, "info", &r->info);

5386

ndr_print_lsa_StringLarge(ndr, "password", &r->password);

5387

ndr_print_lsa_StringLarge(ndr, "account", &r->account);

5388

ndr_print_samr_ValidationBlob(ndr, "hash", &r->hash);

5389

ndr_print_uint8(ndr, "pwd_must_change_at_next_logon", r->pwd_must_change_at_next_logon);

5390

ndr_print_uint8(ndr, "clear_lockout", r->clear_lockout);

5391

ndr->depth--;

5392

}

5393

5394

static enum ndr_err_code ndr_push_samr_ValidatePasswordReq2(struct ndr_push *ndr, int ndr_flags, const struct samr_ValidatePasswordReq2 *r)

5395

{

5396

if (ndr_flags & NDR_SCALARS) {

5397

NDR_CHECK(ndr_push_align(ndr, 8));

5398

NDR_CHECK(ndr_push_samr_ValidatePasswordInfo(ndr, NDR_SCALARS, &r->info));

5399

NDR_CHECK(ndr_push_lsa_StringLarge(ndr, NDR_SCALARS, &r->password));

5400

NDR_CHECK(ndr_push_lsa_StringLarge(ndr, NDR_SCALARS, &r->account));

5401

NDR_CHECK(ndr_push_samr_ValidationBlob(ndr, NDR_SCALARS, &r->hash));

5402

NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->password_matched));

5403

NDR_CHECK(ndr_push_trailer_align(ndr, 8));

5404

}

5405

if (ndr_flags & NDR_BUFFERS) {

5406

NDR_CHECK(ndr_push_samr_ValidatePasswordInfo(ndr, NDR_BUFFERS, &r->info));

5407

NDR_CHECK(ndr_push_lsa_StringLarge(ndr, NDR_BUFFERS, &r->password));

5408

NDR_CHECK(ndr_push_lsa_StringLarge(ndr, NDR_BUFFERS, &r->account));

5409

NDR_CHECK(ndr_push_samr_ValidationBlob(ndr, NDR_BUFFERS, &r->hash));

5410

}

5411

return NDR_ERR_SUCCESS;

5412

}

5413

5414

static enum ndr_err_code ndr_pull_samr_ValidatePasswordReq2(struct ndr_pull *ndr, int ndr_flags, struct samr_ValidatePasswordReq2 *r)

5415

{

5416

if (ndr_flags & NDR_SCALARS) {

5417

NDR_CHECK(ndr_pull_align(ndr, 8));

5418

NDR_CHECK(ndr_pull_samr_ValidatePasswordInfo(ndr, NDR_SCALARS, &r->info));

5419

NDR_CHECK(ndr_pull_lsa_StringLarge(ndr, NDR_SCALARS, &r->password));

5420

NDR_CHECK(ndr_pull_lsa_StringLarge(ndr, NDR_SCALARS, &r->account));

5421

NDR_CHECK(ndr_pull_samr_ValidationBlob(ndr, NDR_SCALARS, &r->hash));

5422

NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->password_matched));

5423

NDR_CHECK(ndr_pull_trailer_align(ndr, 8));

5424

}

5425

if (ndr_flags & NDR_BUFFERS) {

5426

NDR_CHECK(ndr_pull_samr_ValidatePasswordInfo(ndr, NDR_BUFFERS, &r->info));

5427

NDR_CHECK(ndr_pull_lsa_StringLarge(ndr, NDR_BUFFERS, &r->password));

5428

NDR_CHECK(ndr_pull_lsa_StringLarge(ndr, NDR_BUFFERS, &r->account));

5429

NDR_CHECK(ndr_pull_samr_ValidationBlob(ndr, NDR_BUFFERS, &r->hash));

5430

}

5431

return NDR_ERR_SUCCESS;

5432

}

5433

5434

_PUBLIC_ void ndr_print_samr_ValidatePasswordReq2(struct ndr_print *ndr, const char *name, const struct samr_ValidatePasswordReq2 *r)

5435

{

5436

ndr_print_struct(ndr, name, "samr_ValidatePasswordReq2");

5437

if (r == NULL) { ndr_print_null(ndr); return; }

5438

ndr->depth++;

5439

ndr_print_samr_ValidatePasswordInfo(ndr, "info", &r->info);

5440

ndr_print_lsa_StringLarge(ndr, "password", &r->password);

5441

ndr_print_lsa_StringLarge(ndr, "account", &r->account);

5442

ndr_print_samr_ValidationBlob(ndr, "hash", &r->hash);

5443

ndr_print_uint8(ndr, "password_matched", r->password_matched);

5444

ndr->depth--;

5445

}

5446

5447

static enum ndr_err_code ndr_push_samr_ValidatePasswordReq1(struct ndr_push *ndr, int ndr_flags, const struct samr_ValidatePasswordReq1 *r)

5448

{

5449

if (ndr_flags & NDR_SCALARS) {

5450

NDR_CHECK(ndr_push_align(ndr, 8));

5451

NDR_CHECK(ndr_push_samr_ValidatePasswordInfo(ndr, NDR_SCALARS, &r->info));

5452

NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->password_matched));

5453

NDR_CHECK(ndr_push_trailer_align(ndr, 8));

5454

}

5455

if (ndr_flags & NDR_BUFFERS) {

5456

NDR_CHECK(ndr_push_samr_ValidatePasswordInfo(ndr, NDR_BUFFERS, &r->info));

5457

}

5458

return NDR_ERR_SUCCESS;

5459

}

5460

5461

static enum ndr_err_code ndr_pull_samr_ValidatePasswordReq1(struct ndr_pull *ndr, int ndr_flags, struct samr_ValidatePasswordReq1 *r)

5462

{

5463

if (ndr_flags & NDR_SCALARS) {

5464

NDR_CHECK(ndr_pull_align(ndr, 8));

5465

NDR_CHECK(ndr_pull_samr_ValidatePasswordInfo(ndr, NDR_SCALARS, &r->info));

5466

NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->password_matched));

5467

NDR_CHECK(ndr_pull_trailer_align(ndr, 8));

5468

}

5469

if (ndr_flags & NDR_BUFFERS) {

5470

NDR_CHECK(ndr_pull_samr_ValidatePasswordInfo(ndr, NDR_BUFFERS, &r->info));

5471

}

5472

return NDR_ERR_SUCCESS;

5473

}

5474

5475

_PUBLIC_ void ndr_print_samr_ValidatePasswordReq1(struct ndr_print *ndr, const char *name, const struct samr_ValidatePasswordReq1 *r)

5476

{

5477

ndr_print_struct(ndr, name, "samr_ValidatePasswordReq1");

5478

if (r == NULL) { ndr_print_null(ndr); return; }

5479

ndr->depth++;

5480

ndr_print_samr_ValidatePasswordInfo(ndr, "info", &r->info);

5481

ndr_print_uint8(ndr, "password_matched", r->password_matched);

5482

ndr->depth--;

5483

}

5484

5485

static enum ndr_err_code ndr_push_samr_ValidatePasswordReq(struct ndr_push *ndr, int ndr_flags, const union samr_ValidatePasswordReq *r)

5486

{

5487

if (ndr_flags & NDR_SCALARS) {

5488

uint32_t level = ndr_push_get_switch_value(ndr, r);

5489

NDR_CHECK(ndr_push_union_align(ndr, 8));

5490

NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, level));

5491

NDR_CHECK(ndr_push_union_align(ndr, 8));

5492

switch (level) {

5493

case 1: {

5494

NDR_CHECK(ndr_push_samr_ValidatePasswordReq1(ndr, NDR_SCALARS, &r->req1));

5495

break; }

5496

5497

case 2: {

5498

NDR_CHECK(ndr_push_samr_ValidatePasswordReq2(ndr, NDR_SCALARS, &r->req2));

5499

break; }

5500

5501

case 3: {

5502

NDR_CHECK(ndr_push_samr_ValidatePasswordReq3(ndr, NDR_SCALARS, &r->req3));

5503

break; }

5504

5505

default:

5506

return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);

5507

}

5508

}

5509

if (ndr_flags & NDR_BUFFERS) {

5510

uint32_t level = ndr_push_get_switch_value(ndr, r);

5511

switch (level) {

5512

case 1:

5513

NDR_CHECK(ndr_push_samr_ValidatePasswordReq1(ndr, NDR_BUFFERS, &r->req1));

5514

break;

5515

5516

case 2:

5517

NDR_CHECK(ndr_push_samr_ValidatePasswordReq2(ndr, NDR_BUFFERS, &r->req2));

5518

break;

5519

5520

case 3:

5521

NDR_CHECK(ndr_push_samr_ValidatePasswordReq3(ndr, NDR_BUFFERS, &r->req3));

5522

break;

5523

5524

default:

5525

return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);

5526

}

5527

}

5528

return NDR_ERR_SUCCESS;

5529

}

5530

5531

static enum ndr_err_code ndr_pull_samr_ValidatePasswordReq(struct ndr_pull *ndr, int ndr_flags, union samr_ValidatePasswordReq *r)

5532

{

5533

uint32_t level;

5534

uint16_t _level;

5535

level = ndr_pull_get_switch_value(ndr, r);

5536

if (ndr_flags & NDR_SCALARS) {

5537

NDR_CHECK(ndr_pull_union_align(ndr, 8));

5538

NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &_level));

5539

if (_level != level) {

5540

return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);

5541

}

5542

NDR_CHECK(ndr_pull_union_align(ndr, 8));

5543

switch (level) {

5544

case 1: {

5545

NDR_CHECK(ndr_pull_samr_ValidatePasswordReq1(ndr, NDR_SCALARS, &r->req1));

5546

break; }

5547

5548

case 2: {

5549

NDR_CHECK(ndr_pull_samr_ValidatePasswordReq2(ndr, NDR_SCALARS, &r->req2));

5550

break; }

5551

5552

case 3: {

5553

NDR_CHECK(ndr_pull_samr_ValidatePasswordReq3(ndr, NDR_SCALARS, &r->req3));

5554

break; }

5555

5556

default:

5557

return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);

5558

}

5559

}

5560

if (ndr_flags & NDR_BUFFERS) {

5561

switch (level) {

5562

case 1:

5563

NDR_CHECK(ndr_pull_samr_ValidatePasswordReq1(ndr, NDR_BUFFERS, &r->req1));

5564

break;

5565

5566

case 2:

5567

NDR_CHECK(ndr_pull_samr_ValidatePasswordReq2(ndr, NDR_BUFFERS, &r->req2));

5568

break;

5569

5570

case 3:

5571

NDR_CHECK(ndr_pull_samr_ValidatePasswordReq3(ndr, NDR_BUFFERS, &r->req3));

5572

break;

5573

5574

default:

5575

return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);

5576

}

5577

}

5578

return NDR_ERR_SUCCESS;

5579

}

5580

5581

_PUBLIC_ void ndr_print_samr_ValidatePasswordReq(struct ndr_print *ndr, const char *name, const union samr_ValidatePasswordReq *r)

5582

{

5583

uint32_t level;

5584

level = ndr_print_get_switch_value(ndr, r);

5585

ndr_print_union(ndr, name, level, "samr_ValidatePasswordReq");

5586

switch (level) {

5587

case 1:

5588

ndr_print_samr_ValidatePasswordReq1(ndr, "req1", &r->req1);

5589

break;

5590

5591

case 2:

5592

ndr_print_samr_ValidatePasswordReq2(ndr, "req2", &r->req2);

5593

break;

5594

5595

case 3:

5596

ndr_print_samr_ValidatePasswordReq3(ndr, "req3", &r->req3);

5597

break;

5598

5599

default:

5600

ndr_print_bad_level(ndr, name, level);

5601

}

5602

}

5603

5604

static enum ndr_err_code ndr_push_samr_Connect(struct ndr_push *ndr, int flags, const struct samr_Connect *r)

5605

{

5606

if (flags & NDR_IN) {

5607

NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.system_name));

5608

if (r->in.system_name) {

5609

NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, *r->in.system_name));

5610

}

5611

NDR_CHECK(ndr_push_samr_ConnectAccessMask(ndr, NDR_SCALARS, r->in.access_mask));

5612

}

5613

if (flags & NDR_OUT) {

5614

if (r->out.connect_handle == NULL) {

5615

return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");

5616

}

5617

NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.connect_handle));

5618

NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));

5619

}

5620

return NDR_ERR_SUCCESS;

5621

}

5622

5623

static enum ndr_err_code ndr_pull_samr_Connect(struct ndr_pull *ndr, int flags, struct samr_Connect *r)

5624

{

5625

uint32_t _ptr_system_name;

5626

TALLOC_CTX *_mem_save_system_name_0;

5627

TALLOC_CTX *_mem_save_connect_handle_0;

5628

if (flags & NDR_IN) {

5629

ZERO_STRUCT(r->out);

5630

5631

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_system_name));

5632

if (_ptr_system_name) {

5633

NDR_PULL_ALLOC(ndr, r->in.system_name);

5634

} else {

5635

r->in.system_name = NULL;

5636

}

5637

if (r->in.system_name) {

5638

_mem_save_system_name_0 = NDR_PULL_GET_MEM_CTX(ndr);

5639

NDR_PULL_SET_MEM_CTX(ndr, r->in.system_name, 0);

5640

NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, r->in.system_name));

5641

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_system_name_0, 0);

5642

}

5643

NDR_CHECK(ndr_pull_samr_ConnectAccessMask(ndr, NDR_SCALARS, &r->in.access_mask));

5644

NDR_PULL_ALLOC(ndr, r->out.connect_handle);

5645

ZERO_STRUCTP(r->out.connect_handle);

5646

}

5647

if (flags & NDR_OUT) {

5648

if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {

5649

NDR_PULL_ALLOC(ndr, r->out.connect_handle);

5650

}

5651

_mem_save_connect_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);

5652

NDR_PULL_SET_MEM_CTX(ndr, r->out.connect_handle, LIBNDR_FLAG_REF_ALLOC);

5653

NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.connect_handle));

5654

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_connect_handle_0, LIBNDR_FLAG_REF_ALLOC);

5655

NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));

5656

}

5657

return NDR_ERR_SUCCESS;

5658

}

5659

5660

_PUBLIC_ void ndr_print_samr_Connect(struct ndr_print *ndr, const char *name, int flags, const struct samr_Connect *r)

5661

{

5662

ndr_print_struct(ndr, name, "samr_Connect");

5663

if (r == NULL) { ndr_print_null(ndr); return; }

5664

ndr->depth++;

5665

if (flags & NDR_SET_VALUES) {

5666

ndr->flags |= LIBNDR_PRINT_SET_VALUES;

5667

}

5668

if (flags & NDR_IN) {

5669

ndr_print_struct(ndr, "in", "samr_Connect");

5670

ndr->depth++;

5671

ndr_print_ptr(ndr, "system_name", r->in.system_name);

5672

ndr->depth++;

5673

if (r->in.system_name) {

5674

ndr_print_uint16(ndr, "system_name", *r->in.system_name);

5675

}

5676

ndr->depth--;

5677

ndr_print_samr_ConnectAccessMask(ndr, "access_mask", r->in.access_mask);

5678

ndr->depth--;

5679

}

5680

if (flags & NDR_OUT) {

5681

ndr_print_struct(ndr, "out", "samr_Connect");

5682

ndr->depth++;

5683

ndr_print_ptr(ndr, "connect_handle", r->out.connect_handle);

5684

ndr->depth++;

5685

ndr_print_policy_handle(ndr, "connect_handle", r->out.connect_handle);

5686

ndr->depth--;

5687

ndr_print_NTSTATUS(ndr, "result", r->out.result);

5688

ndr->depth--;

5689

}

5690

ndr->depth--;

5691

}

5692

5693

_PUBLIC_ enum ndr_err_code ndr_push_samr_Close(struct ndr_push *ndr, int flags, const struct samr_Close *r)

5694

{

5695

if (flags & NDR_IN) {

5696

if (r->in.handle == NULL) {

5697

return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");

5698

}

5699

NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));

5700

}

5701

if (flags & NDR_OUT) {

5702

if (r->out.handle == NULL) {

5703

return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");

5704

}

5705

NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.handle));

5706

NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));

5707

}

5708

return NDR_ERR_SUCCESS;

5709

}

5710

5711

_PUBLIC_ enum ndr_err_code ndr_pull_samr_Close(struct ndr_pull *ndr, int flags, struct samr_Close *r)

5712

{

5713

TALLOC_CTX *_mem_save_handle_0;

5714

if (flags & NDR_IN) {

5715

ZERO_STRUCT(r->out);

5716

5717

if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {

5718

NDR_PULL_ALLOC(ndr, r->in.handle);

5719

}

5720

_mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);

5721

NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);

5722

NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));

5723

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);

5724

NDR_PULL_ALLOC(ndr, r->out.handle);

5725

*r->out.handle = *r->in.handle;

5726

}

5727

if (flags & NDR_OUT) {

5728

if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {

5729

NDR_PULL_ALLOC(ndr, r->out.handle);

5730

}

5731

_mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);

5732

NDR_PULL_SET_MEM_CTX(ndr, r->out.handle, LIBNDR_FLAG_REF_ALLOC);

5733

NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.handle));

5734

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);

5735

NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));

5736

}

5737

return NDR_ERR_SUCCESS;

5738

}

5739

5740

_PUBLIC_ void ndr_print_samr_Close(struct ndr_print *ndr, const char *name, int flags, const struct samr_Close *r)

5741

{

5742

ndr_print_struct(ndr, name, "samr_Close");

5743

if (r == NULL) { ndr_print_null(ndr); return; }

5744

ndr->depth++;

5745

if (flags & NDR_SET_VALUES) {

5746

ndr->flags |= LIBNDR_PRINT_SET_VALUES;

5747

}

5748

if (flags & NDR_IN) {

5749

ndr_print_struct(ndr, "in", "samr_Close");

5750

ndr->depth++;

5751

ndr_print_ptr(ndr, "handle", r->in.handle);

5752

ndr->depth++;

5753

ndr_print_policy_handle(ndr, "handle", r->in.handle);

5754

ndr->depth--;

5755

ndr->depth--;

5756

}

5757

if (flags & NDR_OUT) {

5758

ndr_print_struct(ndr, "out", "samr_Close");

5759

ndr->depth++;

5760

ndr_print_ptr(ndr, "handle", r->out.handle);

5761

ndr->depth++;

5762

ndr_print_policy_handle(ndr, "handle", r->out.handle);

5763

ndr->depth--;

5764

ndr_print_NTSTATUS(ndr, "result", r->out.result);

5765

ndr->depth--;

5766

}

5767

ndr->depth--;

5768

}

5769

5770

static enum ndr_err_code ndr_push_samr_SetSecurity(struct ndr_push *ndr, int flags, const struct samr_SetSecurity *r)

5771

{

5772

if (flags & NDR_IN) {

5773

if (r->in.handle == NULL) {

5774

return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");

5775

}

5776

NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));

5777

NDR_CHECK(ndr_push_security_secinfo(ndr, NDR_SCALARS, r->in.sec_info));

5778

if (r->in.sdbuf == NULL) {

5779

return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");

5780

}

5781

NDR_CHECK(ndr_push_sec_desc_buf(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.sdbuf));

5782

}

5783

if (flags & NDR_OUT) {

5784

NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));

5785

}

5786

return NDR_ERR_SUCCESS;

5787

}

5788

5789

static enum ndr_err_code ndr_pull_samr_SetSecurity(struct ndr_pull *ndr, int flags, struct samr_SetSecurity *r)

5790

{

5791

TALLOC_CTX *_mem_save_handle_0;

5792

TALLOC_CTX *_mem_save_sdbuf_0;

5793

if (flags & NDR_IN) {

5794

if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {

5795

NDR_PULL_ALLOC(ndr, r->in.handle);

5796

}

5797

_mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);

5798

NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);

5799

NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));

5800

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);

5801

NDR_CHECK(ndr_pull_security_secinfo(ndr, NDR_SCALARS, &r->in.sec_info));

5802

if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {

5803

NDR_PULL_ALLOC(ndr, r->in.sdbuf);

5804

}

5805

_mem_save_sdbuf_0 = NDR_PULL_GET_MEM_CTX(ndr);

5806

NDR_PULL_SET_MEM_CTX(ndr, r->in.sdbuf, LIBNDR_FLAG_REF_ALLOC);

5807

NDR_CHECK(ndr_pull_sec_desc_buf(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.sdbuf));

5808

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sdbuf_0, LIBNDR_FLAG_REF_ALLOC);

5809

}

5810

if (flags & NDR_OUT) {

5811

NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));

5812

}

5813

return NDR_ERR_SUCCESS;

5814

}

5815

5816

_PUBLIC_ void ndr_print_samr_SetSecurity(struct ndr_print *ndr, const char *name, int flags, const struct samr_SetSecurity *r)

5817

{

5818

ndr_print_struct(ndr, name, "samr_SetSecurity");

5819

if (r == NULL) { ndr_print_null(ndr); return; }

5820

ndr->depth++;

5821

if (flags & NDR_SET_VALUES) {

5822

ndr->flags |= LIBNDR_PRINT_SET_VALUES;

5823

}

5824

if (flags & NDR_IN) {

5825

ndr_print_struct(ndr, "in", "samr_SetSecurity");

5826

ndr->depth++;

5827

ndr_print_ptr(ndr, "handle", r->in.handle);

5828

ndr->depth++;

5829

ndr_print_policy_handle(ndr, "handle", r->in.handle);

5830

ndr->depth--;

5831

ndr_print_security_secinfo(ndr, "sec_info", r->in.sec_info);

5832

ndr_print_ptr(ndr, "sdbuf", r->in.sdbuf);

5833

ndr->depth++;

5834

ndr_print_sec_desc_buf(ndr, "sdbuf", r->in.sdbuf);

5835

ndr->depth--;

5836

ndr->depth--;

5837

}

5838

if (flags & NDR_OUT) {

5839

ndr_print_struct(ndr, "out", "samr_SetSecurity");

5840

ndr->depth++;

5841

ndr_print_NTSTATUS(ndr, "result", r->out.result);

5842

ndr->depth--;

5843

}

5844

ndr->depth--;

5845

}

5846

5847

static enum ndr_err_code ndr_push_samr_QuerySecurity(struct ndr_push *ndr, int flags, const struct samr_QuerySecurity *r)

5848

{

5849

if (flags & NDR_IN) {

5850

if (r->in.handle == NULL) {

5851

return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");

5852

}

5853

NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));

5854

NDR_CHECK(ndr_push_security_secinfo(ndr, NDR_SCALARS, r->in.sec_info));

5855

}

5856

if (flags & NDR_OUT) {

5857

if (r->out.sdbuf == NULL) {

5858

return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");

5859

}

5860

NDR_CHECK(ndr_push_unique_ptr(ndr, *r->out.sdbuf));

5861

if (*r->out.sdbuf) {

5862

NDR_CHECK(ndr_push_sec_desc_buf(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.sdbuf));

5863

}

5864

NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));

5865

}

5866

return NDR_ERR_SUCCESS;

5867

}

5868

5869

static enum ndr_err_code ndr_pull_samr_QuerySecurity(struct ndr_pull *ndr, int flags, struct samr_QuerySecurity *r)

5870

{

5871

uint32_t _ptr_sdbuf;

5872

TALLOC_CTX *_mem_save_handle_0;

5873

TALLOC_CTX *_mem_save_sdbuf_0;

5874

TALLOC_CTX *_mem_save_sdbuf_1;

5875

if (flags & NDR_IN) {

5876

ZERO_STRUCT(r->out);

5877

5878

if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {

5879

NDR_PULL_ALLOC(ndr, r->in.handle);

5880

}

5881

_mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);

5882

NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);

5883

NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));

5884

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);

5885

NDR_CHECK(ndr_pull_security_secinfo(ndr, NDR_SCALARS, &r->in.sec_info));

5886

NDR_PULL_ALLOC(ndr, r->out.sdbuf);

5887

ZERO_STRUCTP(r->out.sdbuf);

5888

}

5889

if (flags & NDR_OUT) {

5890

if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {

5891

NDR_PULL_ALLOC(ndr, r->out.sdbuf);

5892

}

5893

_mem_save_sdbuf_0 = NDR_PULL_GET_MEM_CTX(ndr);

5894

NDR_PULL_SET_MEM_CTX(ndr, r->out.sdbuf, LIBNDR_FLAG_REF_ALLOC);

5895

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_sdbuf));

5896

if (_ptr_sdbuf) {

5897

NDR_PULL_ALLOC(ndr, *r->out.sdbuf);

5898

} else {

5899

*r->out.sdbuf = NULL;

5900

}

5901

if (*r->out.sdbuf) {

5902

_mem_save_sdbuf_1 = NDR_PULL_GET_MEM_CTX(ndr);

5903

NDR_PULL_SET_MEM_CTX(ndr, *r->out.sdbuf, 0);

5904

NDR_CHECK(ndr_pull_sec_desc_buf(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.sdbuf));

5905

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sdbuf_1, 0);

5906

}

5907

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sdbuf_0, LIBNDR_FLAG_REF_ALLOC);

5908

NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));

5909

}

5910

return NDR_ERR_SUCCESS;

5911

}

5912

5913

_PUBLIC_ void ndr_print_samr_QuerySecurity(struct ndr_print *ndr, const char *name, int flags, const struct samr_QuerySecurity *r)

5914

{

5915

ndr_print_struct(ndr, name, "samr_QuerySecurity");

5916

if (r == NULL) { ndr_print_null(ndr); return; }

5917

ndr->depth++;

5918

if (flags & NDR_SET_VALUES) {

5919

ndr->flags |= LIBNDR_PRINT_SET_VALUES;

5920

}

5921

if (flags & NDR_IN) {

5922

ndr_print_struct(ndr, "in", "samr_QuerySecurity");

5923

ndr->depth++;

5924

ndr_print_ptr(ndr, "handle", r->in.handle);

5925

ndr->depth++;

5926

ndr_print_policy_handle(ndr, "handle", r->in.handle);

5927

ndr->depth--;

5928

ndr_print_security_secinfo(ndr, "sec_info", r->in.sec_info);

5929

ndr->depth--;

5930

}

5931

if (flags & NDR_OUT) {

5932

ndr_print_struct(ndr, "out", "samr_QuerySecurity");

5933

ndr->depth++;

5934

ndr_print_ptr(ndr, "sdbuf", r->out.sdbuf);

5935

ndr->depth++;

5936

ndr_print_ptr(ndr, "sdbuf", *r->out.sdbuf);

5937

ndr->depth++;

5938

if (*r->out.sdbuf) {

5939

ndr_print_sec_desc_buf(ndr, "sdbuf", *r->out.sdbuf);

5940

}

5941

ndr->depth--;

5942

ndr->depth--;

5943

ndr_print_NTSTATUS(ndr, "result", r->out.result);

5944

ndr->depth--;

5945

}

5946

ndr->depth--;

5947

}

5948

5949

static enum ndr_err_code ndr_push_samr_Shutdown(struct ndr_push *ndr, int flags, const struct samr_Shutdown *r)

5950

{

5951

if (flags & NDR_IN) {

5952

if (r->in.connect_handle == NULL) {

5953

return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");

5954

}

5955

NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.connect_handle));

5956

}

5957

if (flags & NDR_OUT) {

5958

NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));

5959

}

5960

return NDR_ERR_SUCCESS;

5961

}

5962

5963

static enum ndr_err_code ndr_pull_samr_Shutdown(struct ndr_pull *ndr, int flags, struct samr_Shutdown *r)

5964

{

5965

TALLOC_CTX *_mem_save_connect_handle_0;

5966

if (flags & NDR_IN) {

5967

if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {

5968

NDR_PULL_ALLOC(ndr, r->in.connect_handle);

5969

}

5970

_mem_save_connect_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);

5971

NDR_PULL_SET_MEM_CTX(ndr, r->in.connect_handle, LIBNDR_FLAG_REF_ALLOC);

5972

NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.connect_handle));

5973

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_connect_handle_0, LIBNDR_FLAG_REF_ALLOC);

5974

}

5975

if (flags & NDR_OUT) {

5976

NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));

5977

}

5978

return NDR_ERR_SUCCESS;

5979

}

5980

5981

_PUBLIC_ void ndr_print_samr_Shutdown(struct ndr_print *ndr, const char *name, int flags, const struct samr_Shutdown *r)

5982

{

5983

ndr_print_struct(ndr, name, "samr_Shutdown");

5984

if (r == NULL) { ndr_print_null(ndr); return; }

5985

ndr->depth++;

5986

if (flags & NDR_SET_VALUES) {

5987

ndr->flags |= LIBNDR_PRINT_SET_VALUES;

5988

}

5989

if (flags & NDR_IN) {

5990

ndr_print_struct(ndr, "in", "samr_Shutdown");

5991

ndr->depth++;

5992

ndr_print_ptr(ndr, "connect_handle", r->in.connect_handle);

5993

ndr->depth++;

5994

ndr_print_policy_handle(ndr, "connect_handle", r->in.connect_handle);

5995

ndr->depth--;

5996

ndr->depth--;

5997

}

5998

if (flags & NDR_OUT) {

5999

ndr_print_struct(ndr, "out", "samr_Shutdown");

6000

ndr->depth++;

6001

ndr_print_NTSTATUS(ndr, "result", r->out.result);

6002

ndr->depth--;

6003

}

6004

ndr->depth--;

6005

}

6006

6007

static enum ndr_err_code ndr_push_samr_LookupDomain(struct ndr_push *ndr, int flags, const struct samr_LookupDomain *r)

6008

{

6009

if (flags & NDR_IN) {

6010

if (r->in.connect_handle == NULL) {

6011

return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");

6012

}

6013

NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.connect_handle));

6014

if (r->in.domain_name == NULL) {

6015

return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");

6016

}

6017

NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.domain_name));

6018

}

6019

if (flags & NDR_OUT) {

6020

if (r->out.sid == NULL) {

6021

return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");

6022

}

6023

NDR_CHECK(ndr_push_unique_ptr(ndr, *r->out.sid));

6024

if (*r->out.sid) {

6025

NDR_CHECK(ndr_push_dom_sid2(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.sid));

6026

}

6027

NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));

6028

}

6029

return NDR_ERR_SUCCESS;

6030

}

6031

6032

static enum ndr_err_code ndr_pull_samr_LookupDomain(struct ndr_pull *ndr, int flags, struct samr_LookupDomain *r)

6033

{

6034

uint32_t _ptr_sid;

6035

TALLOC_CTX *_mem_save_connect_handle_0;

6036

TALLOC_CTX *_mem_save_domain_name_0;

6037

TALLOC_CTX *_mem_save_sid_0;

6038

TALLOC_CTX *_mem_save_sid_1;

6039

if (flags & NDR_IN) {

6040

ZERO_STRUCT(r->out);

6041

6042

if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {

6043

NDR_PULL_ALLOC(ndr, r->in.connect_handle);

6044

}

6045

_mem_save_connect_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);

6046

NDR_PULL_SET_MEM_CTX(ndr, r->in.connect_handle, LIBNDR_FLAG_REF_ALLOC);

6047

NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.connect_handle));

6048

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_connect_handle_0, LIBNDR_FLAG_REF_ALLOC);

6049

if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {

6050

NDR_PULL_ALLOC(ndr, r->in.domain_name);

6051

}

6052

_mem_save_domain_name_0 = NDR_PULL_GET_MEM_CTX(ndr);

6053

NDR_PULL_SET_MEM_CTX(ndr, r->in.domain_name, LIBNDR_FLAG_REF_ALLOC);

6054

NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.domain_name));

6055

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domain_name_0, LIBNDR_FLAG_REF_ALLOC);

6056

NDR_PULL_ALLOC(ndr, r->out.sid);

6057

ZERO_STRUCTP(r->out.sid);

6058

}

6059

if (flags & NDR_OUT) {

6060

if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {

6061

NDR_PULL_ALLOC(ndr, r->out.sid);

6062

}

6063

_mem_save_sid_0 = NDR_PULL_GET_MEM_CTX(ndr);

6064

NDR_PULL_SET_MEM_CTX(ndr, r->out.sid, LIBNDR_FLAG_REF_ALLOC);

6065

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_sid));

6066

if (_ptr_sid) {

6067

NDR_PULL_ALLOC(ndr, *r->out.sid);

6068

} else {

6069

*r->out.sid = NULL;

6070

}

6071

if (*r->out.sid) {

6072

_mem_save_sid_1 = NDR_PULL_GET_MEM_CTX(ndr);

6073

NDR_PULL_SET_MEM_CTX(ndr, *r->out.sid, 0);

6074

NDR_CHECK(ndr_pull_dom_sid2(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.sid));

6075

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sid_1, 0);

6076

}

6077

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sid_0, LIBNDR_FLAG_REF_ALLOC);

6078

NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));

6079

}

6080

return NDR_ERR_SUCCESS;

6081

}

6082

6083

_PUBLIC_ void ndr_print_samr_LookupDomain(struct ndr_print *ndr, const char *name, int flags, const struct samr_LookupDomain *r)

6084

{

6085

ndr_print_struct(ndr, name, "samr_LookupDomain");

6086

if (r == NULL) { ndr_print_null(ndr); return; }

6087

ndr->depth++;

6088

if (flags & NDR_SET_VALUES) {

6089

ndr->flags |= LIBNDR_PRINT_SET_VALUES;

6090

}

6091

if (flags & NDR_IN) {

6092

ndr_print_struct(ndr, "in", "samr_LookupDomain");

6093

ndr->depth++;

6094

ndr_print_ptr(ndr, "connect_handle", r->in.connect_handle);

6095

ndr->depth++;

6096

ndr_print_policy_handle(ndr, "connect_handle", r->in.connect_handle);

6097

ndr->depth--;

6098

ndr_print_ptr(ndr, "domain_name", r->in.domain_name);

6099

ndr->depth++;

6100

ndr_print_lsa_String(ndr, "domain_name", r->in.domain_name);

6101

ndr->depth--;

6102

ndr->depth--;

6103

}

6104

if (flags & NDR_OUT) {

6105

ndr_print_struct(ndr, "out", "samr_LookupDomain");

6106

ndr->depth++;

6107

ndr_print_ptr(ndr, "sid", r->out.sid);

6108

ndr->depth++;

6109

ndr_print_ptr(ndr, "sid", *r->out.sid);

6110

ndr->depth++;

6111

if (*r->out.sid) {

6112

ndr_print_dom_sid2(ndr, "sid", *r->out.sid);

6113

}

6114

ndr->depth--;

6115

ndr->depth--;

6116

ndr_print_NTSTATUS(ndr, "result", r->out.result);

6117

ndr->depth--;

6118

}

6119

ndr->depth--;

6120

}

6121

6122

static enum ndr_err_code ndr_push_samr_EnumDomains(struct ndr_push *ndr, int flags, const struct samr_EnumDomains *r)

6123

{

6124

if (flags & NDR_IN) {

6125

if (r->in.connect_handle == NULL) {

6126

return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");

6127

}

6128

NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.connect_handle));

6129

if (r->in.resume_handle == NULL) {

6130

return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");

6131

}

6132

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->in.resume_handle));

6133

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.buf_size));

6134

}

6135

if (flags & NDR_OUT) {

6136

if (r->out.resume_handle == NULL) {

6137

return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");

6138

}

6139

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.resume_handle));

6140

if (r->out.sam == NULL) {

6141

return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");

6142

}

6143

NDR_CHECK(ndr_push_unique_ptr(ndr, *r->out.sam));

6144

if (*r->out.sam) {

6145

NDR_CHECK(ndr_push_samr_SamArray(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.sam));

6146

}

6147

if (r->out.num_entries == NULL) {

6148

return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");

6149

}

6150

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.num_entries));

6151

NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));

6152

}

6153

return NDR_ERR_SUCCESS;

6154

}

6155

6156

static enum ndr_err_code ndr_pull_samr_EnumDomains(struct ndr_pull *ndr, int flags, struct samr_EnumDomains *r)

6157

{

6158

uint32_t _ptr_sam;

6159

TALLOC_CTX *_mem_save_connect_handle_0;

6160

TALLOC_CTX *_mem_save_resume_handle_0;

6161

TALLOC_CTX *_mem_save_sam_0;

6162

TALLOC_CTX *_mem_save_sam_1;

6163

TALLOC_CTX *_mem_save_num_entries_0;

6164

if (flags & NDR_IN) {

6165

ZERO_STRUCT(r->out);

6166

6167

if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {

6168

NDR_PULL_ALLOC(ndr, r->in.connect_handle);

6169

}

6170

_mem_save_connect_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);

6171

NDR_PULL_SET_MEM_CTX(ndr, r->in.connect_handle, LIBNDR_FLAG_REF_ALLOC);

6172

NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.connect_handle));

6173

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_connect_handle_0, LIBNDR_FLAG_REF_ALLOC);

6174

if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {

6175

NDR_PULL_ALLOC(ndr, r->in.resume_handle);

6176

}

6177

_mem_save_resume_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);

6178

NDR_PULL_SET_MEM_CTX(ndr, r->in.resume_handle, LIBNDR_FLAG_REF_ALLOC);

6179

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->in.resume_handle));

6180

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_resume_handle_0, LIBNDR_FLAG_REF_ALLOC);

6181

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.buf_size));

6182

NDR_PULL_ALLOC(ndr, r->out.resume_handle);

6183

*r->out.resume_handle = *r->in.resume_handle;

6184

NDR_PULL_ALLOC(ndr, r->out.sam);

6185

ZERO_STRUCTP(r->out.sam);

6186

NDR_PULL_ALLOC(ndr, r->out.num_entries);

6187

ZERO_STRUCTP(r->out.num_entries);

6188

}

6189

if (flags & NDR_OUT) {

6190

if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {

6191

NDR_PULL_ALLOC(ndr, r->out.resume_handle);

6192

}

6193

_mem_save_resume_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);

6194

NDR_PULL_SET_MEM_CTX(ndr, r->out.resume_handle, LIBNDR_FLAG_REF_ALLOC);

6195

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.resume_handle));

6196

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_resume_handle_0, LIBNDR_FLAG_REF_ALLOC);

6197

if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {

6198

NDR_PULL_ALLOC(ndr, r->out.sam);

6199

}

6200

_mem_save_sam_0 = NDR_PULL_GET_MEM_CTX(ndr);

6201

NDR_PULL_SET_MEM_CTX(ndr, r->out.sam, LIBNDR_FLAG_REF_ALLOC);

6202

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_sam));

6203

if (_ptr_sam) {

6204

NDR_PULL_ALLOC(ndr, *r->out.sam);

6205

} else {

6206

*r->out.sam = NULL;

6207

}

6208

if (*r->out.sam) {

6209

_mem_save_sam_1 = NDR_PULL_GET_MEM_CTX(ndr);

6210

NDR_PULL_SET_MEM_CTX(ndr, *r->out.sam, 0);

6211

NDR_CHECK(ndr_pull_samr_SamArray(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.sam));

6212

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sam_1, 0);

6213

}

6214

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sam_0, LIBNDR_FLAG_REF_ALLOC);

6215

if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {

6216

NDR_PULL_ALLOC(ndr, r->out.num_entries);

6217

}

6218

_mem_save_num_entries_0 = NDR_PULL_GET_MEM_CTX(ndr);

6219

NDR_PULL_SET_MEM_CTX(ndr, r->out.num_entries, LIBNDR_FLAG_REF_ALLOC);

6220

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.num_entries));

6221

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_num_entries_0, LIBNDR_FLAG_REF_ALLOC);

6222

NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));

6223

}

6224

return NDR_ERR_SUCCESS;

6225

}

6226

6227

_PUBLIC_ void ndr_print_samr_EnumDomains(struct ndr_print *ndr, const char *name, int flags, const struct samr_EnumDomains *r)

6228

{

6229

ndr_print_struct(ndr, name, "samr_EnumDomains");

6230

if (r == NULL) { ndr_print_null(ndr); return; }

6231

ndr->depth++;

6232

if (flags & NDR_SET_VALUES) {

6233

ndr->flags |= LIBNDR_PRINT_SET_VALUES;

6234

}

6235

if (flags & NDR_IN) {

6236

ndr_print_struct(ndr, "in", "samr_EnumDomains");

6237

ndr->depth++;

6238

ndr_print_ptr(ndr, "connect_handle", r->in.connect_handle);

6239

ndr->depth++;

6240

ndr_print_policy_handle(ndr, "connect_handle", r->in.connect_handle);

6241

ndr->depth--;

6242

ndr_print_ptr(ndr, "resume_handle", r->in.resume_handle);

6243

ndr->depth++;

6244

ndr_print_uint32(ndr, "resume_handle", *r->in.resume_handle);

6245

ndr->depth--;

6246

ndr_print_uint32(ndr, "buf_size", r->in.buf_size);

6247

ndr->depth--;

6248

}

6249

if (flags & NDR_OUT) {

6250

ndr_print_struct(ndr, "out", "samr_EnumDomains");

6251

ndr->depth++;

6252

ndr_print_ptr(ndr, "resume_handle", r->out.resume_handle);

6253

ndr->depth++;

6254

ndr_print_uint32(ndr, "resume_handle", *r->out.resume_handle);

6255

ndr->depth--;

6256

ndr_print_ptr(ndr, "sam", r->out.sam);

6257

ndr->depth++;

6258

ndr_print_ptr(ndr, "sam", *r->out.sam);

6259

ndr->depth++;

6260

if (*r->out.sam) {

6261

ndr_print_samr_SamArray(ndr, "sam", *r->out.sam);

6262

}

6263

ndr->depth--;

6264

ndr->depth--;

6265

ndr_print_ptr(ndr, "num_entries", r->out.num_entries);

6266

ndr->depth++;

6267

ndr_print_uint32(ndr, "num_entries", *r->out.num_entries);

6268

ndr->depth--;

6269

ndr_print_NTSTATUS(ndr, "result", r->out.result);

6270

ndr->depth--;

6271

}

6272

ndr->depth--;

6273

}

6274

6275

_PUBLIC_ enum ndr_err_code ndr_push_samr_OpenDomain(struct ndr_push *ndr, int flags, const struct samr_OpenDomain *r)

6276

{

6277

if (flags & NDR_IN) {

6278

if (r->in.connect_handle == NULL) {

6279

return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");

6280

}

6281

NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.connect_handle));

6282

NDR_CHECK(ndr_push_samr_DomainAccessMask(ndr, NDR_SCALARS, r->in.access_mask));

6283

if (r->in.sid == NULL) {

6284

return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");

6285

}

6286

NDR_CHECK(ndr_push_dom_sid2(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.sid));

6287

}

6288

if (flags & NDR_OUT) {

6289

if (r->out.domain_handle == NULL) {

6290

return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");

6291

}

6292

NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.domain_handle));

6293

NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));

6294

}

6295

return NDR_ERR_SUCCESS;

6296

}

6297

6298

_PUBLIC_ enum ndr_err_code ndr_pull_samr_OpenDomain(struct ndr_pull *ndr, int flags, struct samr_OpenDomain *r)

6299

{

6300

TALLOC_CTX *_mem_save_connect_handle_0;

6301

TALLOC_CTX *_mem_save_sid_0;

6302

TALLOC_CTX *_mem_save_domain_handle_0;

6303

if (flags & NDR_IN) {

6304

ZERO_STRUCT(r->out);

6305

6306

if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {

6307

NDR_PULL_ALLOC(ndr, r->in.connect_handle);

6308

}

6309

_mem_save_connect_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);

6310

NDR_PULL_SET_MEM_CTX(ndr, r->in.connect_handle, LIBNDR_FLAG_REF_ALLOC);

6311

NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.connect_handle));

6312

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_connect_handle_0, LIBNDR_FLAG_REF_ALLOC);

6313

NDR_CHECK(ndr_pull_samr_DomainAccessMask(ndr, NDR_SCALARS, &r->in.access_mask));

6314

if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {

6315

NDR_PULL_ALLOC(ndr, r->in.sid);

6316

}

6317

_mem_save_sid_0 = NDR_PULL_GET_MEM_CTX(ndr);

6318

NDR_PULL_SET_MEM_CTX(ndr, r->in.sid, LIBNDR_FLAG_REF_ALLOC);

6319

NDR_CHECK(ndr_pull_dom_sid2(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.sid));

6320

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sid_0, LIBNDR_FLAG_REF_ALLOC);

6321

NDR_PULL_ALLOC(ndr, r->out.domain_handle);

6322

ZERO_STRUCTP(r->out.domain_handle);

6323

}

6324

if (flags & NDR_OUT) {

6325

if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {

6326

NDR_PULL_ALLOC(ndr, r->out.domain_handle);

6327

}

6328

_mem_save_domain_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);

6329

NDR_PULL_SET_MEM_CTX(ndr, r->out.domain_handle, LIBNDR_FLAG_REF_ALLOC);

6330

NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.domain_handle));

6331

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domain_handle_0, LIBNDR_FLAG_REF_ALLOC);

6332

NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));

6333

}

6334

return NDR_ERR_SUCCESS;

6335

}

6336

6337

_PUBLIC_ void ndr_print_samr_OpenDomain(struct ndr_print *ndr, const char *name, int flags, const struct samr_OpenDomain *r)

6338

{

6339

ndr_print_struct(ndr, name, "samr_OpenDomain");

6340

if (r == NULL) { ndr_print_null(ndr); return; }

6341

ndr->depth++;

6342

if (flags & NDR_SET_VALUES) {

6343

ndr->flags |= LIBNDR_PRINT_SET_VALUES;

6344

}

6345

if (flags & NDR_IN) {

6346

ndr_print_struct(ndr, "in", "samr_OpenDomain");

6347

ndr->depth++;

6348

ndr_print_ptr(ndr, "connect_handle", r->in.connect_handle);

6349

ndr->depth++;

6350

ndr_print_policy_handle(ndr, "connect_handle", r->in.connect_handle);

6351

ndr->depth--;

6352

ndr_print_samr_DomainAccessMask(ndr, "access_mask", r->in.access_mask);

6353

ndr_print_ptr(ndr, "sid", r->in.sid);

6354

ndr->depth++;

6355

ndr_print_dom_sid2(ndr, "sid", r->in.sid);

6356

ndr->depth--;

6357

ndr->depth--;

6358

}

6359

if (flags & NDR_OUT) {

6360

ndr_print_struct(ndr, "out", "samr_OpenDomain");

6361

ndr->depth++;

6362

ndr_print_ptr(ndr, "domain_handle", r->out.domain_handle);

6363

ndr->depth++;

6364

ndr_print_policy_handle(ndr, "domain_handle", r->out.domain_handle);

6365

ndr->depth--;

6366

ndr_print_NTSTATUS(ndr, "result", r->out.result);

6367

ndr->depth--;

6368

}

6369

ndr->depth--;

6370

}

6371

6372

static enum ndr_err_code ndr_push_samr_QueryDomainInfo(struct ndr_push *ndr, int flags, const struct samr_QueryDomainInfo *r)

6373

{

6374

if (flags & NDR_IN) {

6375

if (r->in.domain_handle == NULL) {

6376

return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");

6377

}

6378

NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));

6379

NDR_CHECK(ndr_push_samr_DomainInfoClass(ndr, NDR_SCALARS, r->in.level));

6380

}

6381

if (flags & NDR_OUT) {

6382

if (r->out.info == NULL) {

6383

return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");

6384

}

6385

NDR_CHECK(ndr_push_unique_ptr(ndr, *r->out.info));

6386

if (*r->out.info) {

6387

NDR_CHECK(ndr_push_set_switch_value(ndr, *r->out.info, r->in.level));

6388

NDR_CHECK(ndr_push_samr_DomainInfo(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.info));

6389

}

6390

NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));

6391

}

6392

return NDR_ERR_SUCCESS;

6393

}

6394

6395

static enum ndr_err_code ndr_pull_samr_QueryDomainInfo(struct ndr_pull *ndr, int flags, struct samr_QueryDomainInfo *r)

6396

{

6397

uint32_t _ptr_info;

6398

TALLOC_CTX *_mem_save_domain_handle_0;

6399

TALLOC_CTX *_mem_save_info_0;

6400

TALLOC_CTX *_mem_save_info_1;

6401

if (flags & NDR_IN) {

6402

ZERO_STRUCT(r->out);

6403

6404

if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {

6405

NDR_PULL_ALLOC(ndr, r->in.domain_handle);

6406

}

6407

_mem_save_domain_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);

6408

NDR_PULL_SET_MEM_CTX(ndr, r->in.domain_handle, LIBNDR_FLAG_REF_ALLOC);

6409

NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));

6410

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domain_handle_0, LIBNDR_FLAG_REF_ALLOC);

6411

NDR_CHECK(ndr_pull_samr_DomainInfoClass(ndr, NDR_SCALARS, &r->in.level));

6412

NDR_PULL_ALLOC(ndr, r->out.info);

6413

ZERO_STRUCTP(r->out.info);

6414

}

6415

if (flags & NDR_OUT) {

6416

if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {

6417

NDR_PULL_ALLOC(ndr, r->out.info);

6418

}

6419

_mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);

6420

NDR_PULL_SET_MEM_CTX(ndr, r->out.info, LIBNDR_FLAG_REF_ALLOC);

6421

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));

6422

if (_ptr_info) {

6423

NDR_PULL_ALLOC(ndr, *r->out.info);

6424

} else {

6425

*r->out.info = NULL;

6426

}

6427

if (*r->out.info) {

6428

_mem_save_info_1 = NDR_PULL_GET_MEM_CTX(ndr);

6429

NDR_PULL_SET_MEM_CTX(ndr, *r->out.info, 0);

6430

NDR_CHECK(ndr_pull_set_switch_value(ndr, *r->out.info, r->in.level));

6431

NDR_CHECK(ndr_pull_samr_DomainInfo(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.info));

6432

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_1, 0);

6433

}

6434

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, LIBNDR_FLAG_REF_ALLOC);

6435

NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));

6436

}

6437

return NDR_ERR_SUCCESS;

6438

}

6439

6440

_PUBLIC_ void ndr_print_samr_QueryDomainInfo(struct ndr_print *ndr, const char *name, int flags, const struct samr_QueryDomainInfo *r)

6441

{

6442

ndr_print_struct(ndr, name, "samr_QueryDomainInfo");

6443

if (r == NULL) { ndr_print_null(ndr); return; }

6444

ndr->depth++;

6445

if (flags & NDR_SET_VALUES) {

6446

ndr->flags |= LIBNDR_PRINT_SET_VALUES;

6447

}

6448

if (flags & NDR_IN) {

6449

ndr_print_struct(ndr, "in", "samr_QueryDomainInfo");

6450

ndr->depth++;

6451

ndr_print_ptr(ndr, "domain_handle", r->in.domain_handle);

6452

ndr->depth++;

6453

ndr_print_policy_handle(ndr, "domain_handle", r->in.domain_handle);

6454

ndr->depth--;

6455

ndr_print_samr_DomainInfoClass(ndr, "level", r->in.level);

6456

ndr->depth--;

6457

}

6458

if (flags & NDR_OUT) {

6459

ndr_print_struct(ndr, "out", "samr_QueryDomainInfo");

6460

ndr->depth++;

6461

ndr_print_ptr(ndr, "info", r->out.info);

6462

ndr->depth++;

6463

ndr_print_ptr(ndr, "info", *r->out.info);

6464

ndr->depth++;

6465

if (*r->out.info) {

6466

ndr_print_set_switch_value(ndr, *r->out.info, r->in.level);

6467

ndr_print_samr_DomainInfo(ndr, "info", *r->out.info);

6468

}

6469

ndr->depth--;

6470

ndr->depth--;

6471

ndr_print_NTSTATUS(ndr, "result", r->out.result);

6472

ndr->depth--;

6473

}

6474

ndr->depth--;

6475

}

6476

6477

static enum ndr_err_code ndr_push_samr_SetDomainInfo(struct ndr_push *ndr, int flags, const struct samr_SetDomainInfo *r)

6478

{

6479

if (flags & NDR_IN) {

6480

if (r->in.domain_handle == NULL) {

6481

return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");

6482

}

6483

NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));

6484

NDR_CHECK(ndr_push_samr_DomainInfoClass(ndr, NDR_SCALARS, r->in.level));

6485

if (r->in.info == NULL) {

6486

return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");

6487

}

6488

NDR_CHECK(ndr_push_set_switch_value(ndr, r->in.info, r->in.level));

6489

NDR_CHECK(ndr_push_samr_DomainInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info));

6490

}

6491

if (flags & NDR_OUT) {

6492

NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));

6493

}

6494

return NDR_ERR_SUCCESS;

6495

}

6496

6497

static enum ndr_err_code ndr_pull_samr_SetDomainInfo(struct ndr_pull *ndr, int flags, struct samr_SetDomainInfo *r)

6498

{

6499

TALLOC_CTX *_mem_save_domain_handle_0;

6500

TALLOC_CTX *_mem_save_info_0;

6501

if (flags & NDR_IN) {

6502

if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {

6503

NDR_PULL_ALLOC(ndr, r->in.domain_handle);

6504

}

6505

_mem_save_domain_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);

6506

NDR_PULL_SET_MEM_CTX(ndr, r->in.domain_handle, LIBNDR_FLAG_REF_ALLOC);

6507

NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));

6508

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domain_handle_0, LIBNDR_FLAG_REF_ALLOC);

6509

NDR_CHECK(ndr_pull_samr_DomainInfoClass(ndr, NDR_SCALARS, &r->in.level));

6510

if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {

6511

NDR_PULL_ALLOC(ndr, r->in.info);

6512

}

6513

_mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);

6514

NDR_PULL_SET_MEM_CTX(ndr, r->in.info, LIBNDR_FLAG_REF_ALLOC);

6515

NDR_CHECK(ndr_pull_set_switch_value(ndr, r->in.info, r->in.level));

6516

NDR_CHECK(ndr_pull_samr_DomainInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info));

6517

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, LIBNDR_FLAG_REF_ALLOC);

6518

}

6519

if (flags & NDR_OUT) {

6520

NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));

6521

}

6522

return NDR_ERR_SUCCESS;

6523

}

6524

6525

_PUBLIC_ void ndr_print_samr_SetDomainInfo(struct ndr_print *ndr, const char *name, int flags, const struct samr_SetDomainInfo *r)

6526

{

6527

ndr_print_struct(ndr, name, "samr_SetDomainInfo");

6528

if (r == NULL) { ndr_print_null(ndr); return; }

6529

ndr->depth++;

6530

if (flags & NDR_SET_VALUES) {

6531

ndr->flags |= LIBNDR_PRINT_SET_VALUES;

6532

}

6533

if (flags & NDR_IN) {

6534

ndr_print_struct(ndr, "in", "samr_SetDomainInfo");

6535

ndr->depth++;

6536

ndr_print_ptr(ndr, "domain_handle", r->in.domain_handle);

6537

ndr->depth++;

6538

ndr_print_policy_handle(ndr, "domain_handle", r->in.domain_handle);

6539

ndr->depth--;

6540

ndr_print_samr_DomainInfoClass(ndr, "level", r->in.level);

6541

ndr_print_ptr(ndr, "info", r->in.info);

6542

ndr->depth++;

6543

ndr_print_set_switch_value(ndr, r->in.info, r->in.level);

6544

ndr_print_samr_DomainInfo(ndr, "info", r->in.info);

6545

ndr->depth--;

6546

ndr->depth--;

6547

}

6548

if (flags & NDR_OUT) {

6549

ndr_print_struct(ndr, "out", "samr_SetDomainInfo");

6550

ndr->depth++;

6551

ndr_print_NTSTATUS(ndr, "result", r->out.result);

6552

ndr->depth--;

6553

}

6554

ndr->depth--;

6555

}

6556

6557

static enum ndr_err_code ndr_push_samr_CreateDomainGroup(struct ndr_push *ndr, int flags, const struct samr_CreateDomainGroup *r)

6558

{

6559

if (flags & NDR_IN) {

6560

if (r->in.domain_handle == NULL) {

6561

return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");

6562

}

6563

NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));

6564

if (r->in.name == NULL) {

6565

return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");

6566

}

6567

NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.name));

6568

NDR_CHECK(ndr_push_samr_GroupAccessMask(ndr, NDR_SCALARS, r->in.access_mask));

6569

}

6570

if (flags & NDR_OUT) {

6571

if (r->out.group_handle == NULL) {

6572

return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");

6573

}

6574

NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.group_handle));

6575

if (r->out.rid == NULL) {

6576

return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");

6577

}

6578

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.rid));

6579

NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));

6580

}

6581

return NDR_ERR_SUCCESS;

6582

}

6583

6584

static enum ndr_err_code ndr_pull_samr_CreateDomainGroup(struct ndr_pull *ndr, int flags, struct samr_CreateDomainGroup *r)

6585

{

6586

TALLOC_CTX *_mem_save_domain_handle_0;

6587

TALLOC_CTX *_mem_save_name_0;

6588

TALLOC_CTX *_mem_save_group_handle_0;

6589

TALLOC_CTX *_mem_save_rid_0;

6590

if (flags & NDR_IN) {

6591

ZERO_STRUCT(r->out);

6592

6593

if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {

6594

NDR_PULL_ALLOC(ndr, r->in.domain_handle);

6595

}

6596

_mem_save_domain_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);

6597

NDR_PULL_SET_MEM_CTX(ndr, r->in.domain_handle, LIBNDR_FLAG_REF_ALLOC);

6598

NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));

6599

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domain_handle_0, LIBNDR_FLAG_REF_ALLOC);

6600

if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {

6601

NDR_PULL_ALLOC(ndr, r->in.name);

6602

}

6603

_mem_save_name_0 = NDR_PULL_GET_MEM_CTX(ndr);

6604

NDR_PULL_SET_MEM_CTX(ndr, r->in.name, LIBNDR_FLAG_REF_ALLOC);

6605

NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.name));

6606

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_name_0, LIBNDR_FLAG_REF_ALLOC);

6607

NDR_CHECK(ndr_pull_samr_GroupAccessMask(ndr, NDR_SCALARS, &r->in.access_mask));

6608

NDR_PULL_ALLOC(ndr, r->out.group_handle);

6609

ZERO_STRUCTP(r->out.group_handle);

6610

NDR_PULL_ALLOC(ndr, r->out.rid);

6611

ZERO_STRUCTP(r->out.rid);

6612

}

6613

if (flags & NDR_OUT) {

6614

if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {

6615

NDR_PULL_ALLOC(ndr, r->out.group_handle);

6616

}

6617

_mem_save_group_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);

6618

NDR_PULL_SET_MEM_CTX(ndr, r->out.group_handle, LIBNDR_FLAG_REF_ALLOC);

6619

NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.group_handle));

6620

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_group_handle_0, LIBNDR_FLAG_REF_ALLOC);

6621

if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {

6622

NDR_PULL_ALLOC(ndr, r->out.rid);

6623

}

6624

_mem_save_rid_0 = NDR_PULL_GET_MEM_CTX(ndr);

6625

NDR_PULL_SET_MEM_CTX(ndr, r->out.rid, LIBNDR_FLAG_REF_ALLOC);

6626

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.rid));

6627

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_rid_0, LIBNDR_FLAG_REF_ALLOC);

6628

NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));

6629

}

6630

return NDR_ERR_SUCCESS;

6631

}

6632

6633

_PUBLIC_ void ndr_print_samr_CreateDomainGroup(struct ndr_print *ndr, const char *name, int flags, const struct samr_CreateDomainGroup *r)

6634

{

6635

ndr_print_struct(ndr, name, "samr_CreateDomainGroup");

6636

if (r == NULL) { ndr_print_null(ndr); return; }

6637

ndr->depth++;

6638

if (flags & NDR_SET_VALUES) {

6639

ndr->flags |= LIBNDR_PRINT_SET_VALUES;

6640

}

6641

if (flags & NDR_IN) {

6642

ndr_print_struct(ndr, "in", "samr_CreateDomainGroup");

6643

ndr->depth++;

6644

ndr_print_ptr(ndr, "domain_handle", r->in.domain_handle);

6645

ndr->depth++;

6646

ndr_print_policy_handle(ndr, "domain_handle", r->in.domain_handle);

6647

ndr->depth--;

6648

ndr_print_ptr(ndr, "name", r->in.name);

6649

ndr->depth++;

6650

ndr_print_lsa_String(ndr, "name", r->in.name);

6651

ndr->depth--;

6652

ndr_print_samr_GroupAccessMask(ndr, "access_mask", r->in.access_mask);

6653

ndr->depth--;

6654

}

6655

if (flags & NDR_OUT) {

6656

ndr_print_struct(ndr, "out", "samr_CreateDomainGroup");

6657

ndr->depth++;

6658

ndr_print_ptr(ndr, "group_handle", r->out.group_handle);

6659

ndr->depth++;

6660

ndr_print_policy_handle(ndr, "group_handle", r->out.group_handle);

6661

ndr->depth--;

6662

ndr_print_ptr(ndr, "rid", r->out.rid);

6663

ndr->depth++;

6664

ndr_print_uint32(ndr, "rid", *r->out.rid);

6665

ndr->depth--;

6666

ndr_print_NTSTATUS(ndr, "result", r->out.result);

6667

ndr->depth--;

6668

}

6669

ndr->depth--;

6670

}

6671

6672

static enum ndr_err_code ndr_push_samr_EnumDomainGroups(struct ndr_push *ndr, int flags, const struct samr_EnumDomainGroups *r)

6673

{

6674

if (flags & NDR_IN) {

6675

if (r->in.domain_handle == NULL) {

6676

return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");

6677

}

6678

NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));

6679

if (r->in.resume_handle == NULL) {

6680

return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");

6681

}

6682

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->in.resume_handle));

6683

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.max_size));

6684

}

6685

if (flags & NDR_OUT) {

6686

if (r->out.resume_handle == NULL) {

6687

return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");

6688

}

6689

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.resume_handle));

6690

if (r->out.sam == NULL) {

6691

return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");

6692

}

6693

NDR_CHECK(ndr_push_unique_ptr(ndr, *r->out.sam));

6694

if (*r->out.sam) {

6695

NDR_CHECK(ndr_push_samr_SamArray(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.sam));

6696

}

6697

if (r->out.num_entries == NULL) {

6698

return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");

6699

}

6700

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.num_entries));

6701

NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));

6702

}

6703

return NDR_ERR_SUCCESS;

6704

}

6705

6706

static enum ndr_err_code ndr_pull_samr_EnumDomainGroups(struct ndr_pull *ndr, int flags, struct samr_EnumDomainGroups *r)

6707

{

6708

uint32_t _ptr_sam;

6709

TALLOC_CTX *_mem_save_domain_handle_0;

6710

TALLOC_CTX *_mem_save_resume_handle_0;

6711

TALLOC_CTX *_mem_save_sam_0;

6712

TALLOC_CTX *_mem_save_sam_1;

6713

TALLOC_CTX *_mem_save_num_entries_0;

6714

if (flags & NDR_IN) {

6715

ZERO_STRUCT(r->out);

6716

6717

if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {

6718

NDR_PULL_ALLOC(ndr, r->in.domain_handle);

6719

}

6720

_mem_save_domain_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);

6721

NDR_PULL_SET_MEM_CTX(ndr, r->in.domain_handle, LIBNDR_FLAG_REF_ALLOC);

6722

NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));

6723

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domain_handle_0, LIBNDR_FLAG_REF_ALLOC);

6724

if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {

6725

NDR_PULL_ALLOC(ndr, r->in.resume_handle);

6726

}

6727

_mem_save_resume_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);

6728

NDR_PULL_SET_MEM_CTX(ndr, r->in.resume_handle, LIBNDR_FLAG_REF_ALLOC);

6729

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->in.resume_handle));

6730

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_resume_handle_0, LIBNDR_FLAG_REF_ALLOC);

6731

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.max_size));

6732

NDR_PULL_ALLOC(ndr, r->out.resume_handle);

6733

*r->out.resume_handle = *r->in.resume_handle;

6734

NDR_PULL_ALLOC(ndr, r->out.sam);

6735

ZERO_STRUCTP(r->out.sam);

6736

NDR_PULL_ALLOC(ndr, r->out.num_entries);

6737

ZERO_STRUCTP(r->out.num_entries);

6738

}

6739

if (flags & NDR_OUT) {

6740

if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {

6741

NDR_PULL_ALLOC(ndr, r->out.resume_handle);

6742

}

6743

_mem_save_resume_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);

6744

NDR_PULL_SET_MEM_CTX(ndr, r->out.resume_handle, LIBNDR_FLAG_REF_ALLOC);

6745

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.resume_handle));

6746

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_resume_handle_0, LIBNDR_FLAG_REF_ALLOC);

6747

if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {

6748

NDR_PULL_ALLOC(ndr, r->out.sam);

6749

}

6750

_mem_save_sam_0 = NDR_PULL_GET_MEM_CTX(ndr);

6751

NDR_PULL_SET_MEM_CTX(ndr, r->out.sam, LIBNDR_FLAG_REF_ALLOC);

6752

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_sam));

6753

if (_ptr_sam) {

6754

NDR_PULL_ALLOC(ndr, *r->out.sam);

6755

} else {

6756

*r->out.sam = NULL;

6757

}

6758

if (*r->out.sam) {

6759

_mem_save_sam_1 = NDR_PULL_GET_MEM_CTX(ndr);

6760

NDR_PULL_SET_MEM_CTX(ndr, *r->out.sam, 0);

6761

NDR_CHECK(ndr_pull_samr_SamArray(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.sam));

6762

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sam_1, 0);

6763

}

6764

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sam_0, LIBNDR_FLAG_REF_ALLOC);

6765

if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {

6766

NDR_PULL_ALLOC(ndr, r->out.num_entries);

6767

}

6768

_mem_save_num_entries_0 = NDR_PULL_GET_MEM_CTX(ndr);

6769

NDR_PULL_SET_MEM_CTX(ndr, r->out.num_entries, LIBNDR_FLAG_REF_ALLOC);

6770

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.num_entries));

6771

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_num_entries_0, LIBNDR_FLAG_REF_ALLOC);

6772

NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));

6773

}

6774

return NDR_ERR_SUCCESS;

6775

}

6776

6777

_PUBLIC_ void ndr_print_samr_EnumDomainGroups(struct ndr_print *ndr, const char *name, int flags, const struct samr_EnumDomainGroups *r)

6778

{

6779

ndr_print_struct(ndr, name, "samr_EnumDomainGroups");

6780

if (r == NULL) { ndr_print_null(ndr); return; }

6781

ndr->depth++;

6782

if (flags & NDR_SET_VALUES) {

6783

ndr->flags |= LIBNDR_PRINT_SET_VALUES;

6784

}

6785

if (flags & NDR_IN) {

6786

ndr_print_struct(ndr, "in", "samr_EnumDomainGroups");

6787

ndr->depth++;

6788

ndr_print_ptr(ndr, "domain_handle", r->in.domain_handle);

6789

ndr->depth++;

6790

ndr_print_policy_handle(ndr, "domain_handle", r->in.domain_handle);

6791

ndr->depth--;

6792

ndr_print_ptr(ndr, "resume_handle", r->in.resume_handle);

6793

ndr->depth++;

6794

ndr_print_uint32(ndr, "resume_handle", *r->in.resume_handle);

6795

ndr->depth--;

6796

ndr_print_uint32(ndr, "max_size", r->in.max_size);

6797

ndr->depth--;

6798

}

6799

if (flags & NDR_OUT) {

6800

ndr_print_struct(ndr, "out", "samr_EnumDomainGroups");

6801

ndr->depth++;

6802

ndr_print_ptr(ndr, "resume_handle", r->out.resume_handle);

6803

ndr->depth++;

6804

ndr_print_uint32(ndr, "resume_handle", *r->out.resume_handle);

6805

ndr->depth--;

6806

ndr_print_ptr(ndr, "sam", r->out.sam);

6807

ndr->depth++;

6808

ndr_print_ptr(ndr, "sam", *r->out.sam);

6809

ndr->depth++;

6810

if (*r->out.sam) {

6811

ndr_print_samr_SamArray(ndr, "sam", *r->out.sam);

6812

}

6813

ndr->depth--;

6814

ndr->depth--;

6815

ndr_print_ptr(ndr, "num_entries", r->out.num_entries);

6816

ndr->depth++;

6817

ndr_print_uint32(ndr, "num_entries", *r->out.num_entries);

6818

ndr->depth--;

6819

ndr_print_NTSTATUS(ndr, "result", r->out.result);

6820

ndr->depth--;

6821

}

6822

ndr->depth--;

6823

}

6824

6825

static enum ndr_err_code ndr_push_samr_CreateUser(struct ndr_push *ndr, int flags, const struct samr_CreateUser *r)

6826

{

6827

if (flags & NDR_IN) {

6828

if (r->in.domain_handle == NULL) {

6829

return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");

6830

}

6831

NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));

6832

if (r->in.account_name == NULL) {

6833

return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");

6834

}

6835

NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.account_name));

6836

NDR_CHECK(ndr_push_samr_UserAccessMask(ndr, NDR_SCALARS, r->in.access_mask));

6837

}

6838

if (flags & NDR_OUT) {

6839

if (r->out.user_handle == NULL) {

6840

return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");

6841

}

6842

NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.user_handle));

6843

if (r->out.rid == NULL) {

6844

return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");

6845

}

6846

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.rid));

6847

NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));

6848

}

6849

return NDR_ERR_SUCCESS;

6850

}

6851

6852

static enum ndr_err_code ndr_pull_samr_CreateUser(struct ndr_pull *ndr, int flags, struct samr_CreateUser *r)

6853

{

6854

TALLOC_CTX *_mem_save_domain_handle_0;

6855

TALLOC_CTX *_mem_save_account_name_0;

6856

TALLOC_CTX *_mem_save_user_handle_0;

6857

TALLOC_CTX *_mem_save_rid_0;

6858

if (flags & NDR_IN) {

6859

ZERO_STRUCT(r->out);

6860

6861

if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {

6862

NDR_PULL_ALLOC(ndr, r->in.domain_handle);

6863

}

6864

_mem_save_domain_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);

6865

NDR_PULL_SET_MEM_CTX(ndr, r->in.domain_handle, LIBNDR_FLAG_REF_ALLOC);

6866

NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));

6867

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domain_handle_0, LIBNDR_FLAG_REF_ALLOC);

6868

if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {

6869

NDR_PULL_ALLOC(ndr, r->in.account_name);

6870

}

6871

_mem_save_account_name_0 = NDR_PULL_GET_MEM_CTX(ndr);

6872

NDR_PULL_SET_MEM_CTX(ndr, r->in.account_name, LIBNDR_FLAG_REF_ALLOC);

6873

NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.account_name));

6874

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_account_name_0, LIBNDR_FLAG_REF_ALLOC);

6875

NDR_CHECK(ndr_pull_samr_UserAccessMask(ndr, NDR_SCALARS, &r->in.access_mask));

6876

NDR_PULL_ALLOC(ndr, r->out.user_handle);

6877

ZERO_STRUCTP(r->out.user_handle);

6878

NDR_PULL_ALLOC(ndr, r->out.rid);

6879

ZERO_STRUCTP(r->out.rid);

6880

}

6881

if (flags & NDR_OUT) {

6882

if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {

6883

NDR_PULL_ALLOC(ndr, r->out.user_handle);

6884

}

6885

_mem_save_user_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);

6886

NDR_PULL_SET_MEM_CTX(ndr, r->out.user_handle, LIBNDR_FLAG_REF_ALLOC);

6887

NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.user_handle));

6888

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_handle_0, LIBNDR_FLAG_REF_ALLOC);

6889

if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {

6890

NDR_PULL_ALLOC(ndr, r->out.rid);

6891

}

6892

_mem_save_rid_0 = NDR_PULL_GET_MEM_CTX(ndr);

6893

NDR_PULL_SET_MEM_CTX(ndr, r->out.rid, LIBNDR_FLAG_REF_ALLOC);

6894

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.rid));

6895

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_rid_0, LIBNDR_FLAG_REF_ALLOC);

6896

NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));

6897

}

6898

return NDR_ERR_SUCCESS;

6899

}

6900

6901

_PUBLIC_ void ndr_print_samr_CreateUser(struct ndr_print *ndr, const char *name, int flags, const struct samr_CreateUser *r)

6902

{

6903

ndr_print_struct(ndr, name, "samr_CreateUser");

6904

if (r == NULL) { ndr_print_null(ndr); return; }

6905

ndr->depth++;

6906

if (flags & NDR_SET_VALUES) {

6907

ndr->flags |= LIBNDR_PRINT_SET_VALUES;

6908

}

6909

if (flags & NDR_IN) {

6910

ndr_print_struct(ndr, "in", "samr_CreateUser");

6911

ndr->depth++;

6912

ndr_print_ptr(ndr, "domain_handle", r->in.domain_handle);

6913

ndr->depth++;

6914

ndr_print_policy_handle(ndr, "domain_handle", r->in.domain_handle);

6915

ndr->depth--;

6916

ndr_print_ptr(ndr, "account_name", r->in.account_name);

6917

ndr->depth++;

6918

ndr_print_lsa_String(ndr, "account_name", r->in.account_name);

6919

ndr->depth--;

6920

ndr_print_samr_UserAccessMask(ndr, "access_mask", r->in.access_mask);

6921

ndr->depth--;

6922

}

6923

if (flags & NDR_OUT) {

6924

ndr_print_struct(ndr, "out", "samr_CreateUser");

6925

ndr->depth++;

6926

ndr_print_ptr(ndr, "user_handle", r->out.user_handle);

6927

ndr->depth++;

6928

ndr_print_policy_handle(ndr, "user_handle", r->out.user_handle);

6929

ndr->depth--;

6930

ndr_print_ptr(ndr, "rid", r->out.rid);

6931

ndr->depth++;

6932

ndr_print_uint32(ndr, "rid", *r->out.rid);

6933

ndr->depth--;

6934

ndr_print_NTSTATUS(ndr, "result", r->out.result);

6935

ndr->depth--;

6936

}

6937

ndr->depth--;

6938

}

6939

6940

static enum ndr_err_code ndr_push_samr_EnumDomainUsers(struct ndr_push *ndr, int flags, const struct samr_EnumDomainUsers *r)

6941

{

6942

if (flags & NDR_IN) {

6943

if (r->in.domain_handle == NULL) {

6944

return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");

6945

}

6946

NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));

6947

if (r->in.resume_handle == NULL) {

6948

return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");

6949

}

6950

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->in.resume_handle));

6951

NDR_CHECK(ndr_push_samr_AcctFlags(ndr, NDR_SCALARS, r->in.acct_flags));

6952

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.max_size));

6953

}

6954

if (flags & NDR_OUT) {

6955

if (r->out.resume_handle == NULL) {

6956

return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");

6957

}

6958

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.resume_handle));

6959

if (r->out.sam == NULL) {

6960

return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");

6961

}

6962

NDR_CHECK(ndr_push_unique_ptr(ndr, *r->out.sam));

6963

if (*r->out.sam) {

6964

NDR_CHECK(ndr_push_samr_SamArray(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.sam));

6965

}

6966

if (r->out.num_entries == NULL) {

6967

return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");

6968

}

6969

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.num_entries));

6970

NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));

6971

}

6972

return NDR_ERR_SUCCESS;

6973

}

6974

6975

static enum ndr_err_code ndr_pull_samr_EnumDomainUsers(struct ndr_pull *ndr, int flags, struct samr_EnumDomainUsers *r)

6976

{

6977

uint32_t _ptr_sam;

6978

TALLOC_CTX *_mem_save_domain_handle_0;

6979

TALLOC_CTX *_mem_save_resume_handle_0;

6980

TALLOC_CTX *_mem_save_sam_0;

6981

TALLOC_CTX *_mem_save_sam_1;

6982

TALLOC_CTX *_mem_save_num_entries_0;

6983

if (flags & NDR_IN) {

6984

ZERO_STRUCT(r->out);

6985

6986

if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {

6987

NDR_PULL_ALLOC(ndr, r->in.domain_handle);

6988

}

6989

_mem_save_domain_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);

6990

NDR_PULL_SET_MEM_CTX(ndr, r->in.domain_handle, LIBNDR_FLAG_REF_ALLOC);

6991

NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));

6992

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domain_handle_0, LIBNDR_FLAG_REF_ALLOC);

6993

if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {

6994

NDR_PULL_ALLOC(ndr, r->in.resume_handle);

6995

}

6996

_mem_save_resume_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);

6997

NDR_PULL_SET_MEM_CTX(ndr, r->in.resume_handle, LIBNDR_FLAG_REF_ALLOC);

6998

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->in.resume_handle));

6999

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_resume_handle_0, LIBNDR_FLAG_REF_ALLOC);

7000

NDR_CHECK(ndr_pull_samr_AcctFlags(ndr, NDR_SCALARS, &r->in.acct_flags));

7001

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.max_size));

7002

NDR_PULL_ALLOC(ndr, r->out.resume_handle);

7003

*r->out.resume_handle = *r->in.resume_handle;

7004

NDR_PULL_ALLOC(ndr, r->out.sam);

7005

ZERO_STRUCTP(r->out.sam);

7006

NDR_PULL_ALLOC(ndr, r->out.num_entries);

7007

ZERO_STRUCTP(r->out.num_entries);

7008

}

7009

if (flags & NDR_OUT) {

7010

if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {

7011

NDR_PULL_ALLOC(ndr, r->out.resume_handle);

7012

}

7013

_mem_save_resume_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);

7014

NDR_PULL_SET_MEM_CTX(ndr, r->out.resume_handle, LIBNDR_FLAG_REF_ALLOC);

7015

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.resume_handle));

7016

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_resume_handle_0, LIBNDR_FLAG_REF_ALLOC);

7017

if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {

7018

NDR_PULL_ALLOC(ndr, r->out.sam);

7019

}

7020

_mem_save_sam_0 = NDR_PULL_GET_MEM_CTX(ndr);

7021

NDR_PULL_SET_MEM_CTX(ndr, r->out.sam, LIBNDR_FLAG_REF_ALLOC);

7022

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_sam));

7023

if (_ptr_sam) {

7024

NDR_PULL_ALLOC(ndr, *r->out.sam);

7025

} else {

7026

*r->out.sam = NULL;

7027

}

7028

if (*r->out.sam) {

7029

_mem_save_sam_1 = NDR_PULL_GET_MEM_CTX(ndr);

7030

NDR_PULL_SET_MEM_CTX(ndr, *r->out.sam, 0);

7031

NDR_CHECK(ndr_pull_samr_SamArray(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.sam));

7032

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sam_1, 0);

7033

}

7034

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sam_0, LIBNDR_FLAG_REF_ALLOC);

7035

if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {

7036

NDR_PULL_ALLOC(ndr, r->out.num_entries);

7037

}

7038

_mem_save_num_entries_0 = NDR_PULL_GET_MEM_CTX(ndr);

7039

NDR_PULL_SET_MEM_CTX(ndr, r->out.num_entries, LIBNDR_FLAG_REF_ALLOC);

7040

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.num_entries));

7041

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_num_entries_0, LIBNDR_FLAG_REF_ALLOC);

7042

NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));

7043

}

7044

return NDR_ERR_SUCCESS;

7045

}

7046

7047

_PUBLIC_ void ndr_print_samr_EnumDomainUsers(struct ndr_print *ndr, const char *name, int flags, const struct samr_EnumDomainUsers *r)

7048

{

7049

ndr_print_struct(ndr, name, "samr_EnumDomainUsers");

7050

if (r == NULL) { ndr_print_null(ndr); return; }

7051

ndr->depth++;

7052

if (flags & NDR_SET_VALUES) {

7053

ndr->flags |= LIBNDR_PRINT_SET_VALUES;

7054

}

7055

if (flags & NDR_IN) {

7056

ndr_print_struct(ndr, "in", "samr_EnumDomainUsers");

7057

ndr->depth++;

7058

ndr_print_ptr(ndr, "domain_handle", r->in.domain_handle);

7059

ndr->depth++;

7060

ndr_print_policy_handle(ndr, "domain_handle", r->in.domain_handle);

7061

ndr->depth--;

7062

ndr_print_ptr(ndr, "resume_handle", r->in.resume_handle);

7063

ndr->depth++;

7064

ndr_print_uint32(ndr, "resume_handle", *r->in.resume_handle);

7065

ndr->depth--;

7066

ndr_print_samr_AcctFlags(ndr, "acct_flags", r->in.acct_flags);

7067

ndr_print_uint32(ndr, "max_size", r->in.max_size);

7068

ndr->depth--;

7069

}

7070

if (flags & NDR_OUT) {

7071

ndr_print_struct(ndr, "out", "samr_EnumDomainUsers");

7072

ndr->depth++;

7073

ndr_print_ptr(ndr, "resume_handle", r->out.resume_handle);

7074

ndr->depth++;

7075

ndr_print_uint32(ndr, "resume_handle", *r->out.resume_handle);

7076

ndr->depth--;

7077

ndr_print_ptr(ndr, "sam", r->out.sam);

7078

ndr->depth++;

7079

ndr_print_ptr(ndr, "sam", *r->out.sam);

7080

ndr->depth++;

7081

if (*r->out.sam) {

7082

ndr_print_samr_SamArray(ndr, "sam", *r->out.sam);

7083

}

7084

ndr->depth--;

7085

ndr->depth--;

7086

ndr_print_ptr(ndr, "num_entries", r->out.num_entries);

7087

ndr->depth++;

7088

ndr_print_uint32(ndr, "num_entries", *r->out.num_entries);

7089

ndr->depth--;

7090

ndr_print_NTSTATUS(ndr, "result", r->out.result);

7091

ndr->depth--;

7092

}

7093

ndr->depth--;

7094

}

7095

7096

static enum ndr_err_code ndr_push_samr_CreateDomAlias(struct ndr_push *ndr, int flags, const struct samr_CreateDomAlias *r)

7097

{

7098

if (flags & NDR_IN) {

7099

if (r->in.domain_handle == NULL) {

7100

return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");

7101

}

7102

NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));

7103

if (r->in.alias_name == NULL) {

7104

return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");

7105

}

7106

NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.alias_name));

7107

NDR_CHECK(ndr_push_samr_AliasAccessMask(ndr, NDR_SCALARS, r->in.access_mask));

7108

}

7109

if (flags & NDR_OUT) {

7110

if (r->out.alias_handle == NULL) {

7111

return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");

7112

}

7113

NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.alias_handle));

7114

if (r->out.rid == NULL) {

7115

return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");

7116

}

7117

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.rid));

7118

NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));

7119

}

7120

return NDR_ERR_SUCCESS;

7121

}

7122

7123

static enum ndr_err_code ndr_pull_samr_CreateDomAlias(struct ndr_pull *ndr, int flags, struct samr_CreateDomAlias *r)

7124

{

7125

TALLOC_CTX *_mem_save_domain_handle_0;

7126

TALLOC_CTX *_mem_save_alias_name_0;

7127

TALLOC_CTX *_mem_save_alias_handle_0;

7128

TALLOC_CTX *_mem_save_rid_0;

7129

if (flags & NDR_IN) {

7130

ZERO_STRUCT(r->out);

7131

7132

if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {

7133

NDR_PULL_ALLOC(ndr, r->in.domain_handle);

7134

}

7135

_mem_save_domain_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);

7136

NDR_PULL_SET_MEM_CTX(ndr, r->in.domain_handle, LIBNDR_FLAG_REF_ALLOC);

7137

NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));

7138

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domain_handle_0, LIBNDR_FLAG_REF_ALLOC);

7139

if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {

7140

NDR_PULL_ALLOC(ndr, r->in.alias_name);

7141

}

7142

_mem_save_alias_name_0 = NDR_PULL_GET_MEM_CTX(ndr);

7143

NDR_PULL_SET_MEM_CTX(ndr, r->in.alias_name, LIBNDR_FLAG_REF_ALLOC);

7144

NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.alias_name));

7145

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_alias_name_0, LIBNDR_FLAG_REF_ALLOC);

7146

NDR_CHECK(ndr_pull_samr_AliasAccessMask(ndr, NDR_SCALARS, &r->in.access_mask));

7147

NDR_PULL_ALLOC(ndr, r->out.alias_handle);

7148

ZERO_STRUCTP(r->out.alias_handle);

7149

NDR_PULL_ALLOC(ndr, r->out.rid);

7150

ZERO_STRUCTP(r->out.rid);

7151

}

7152

if (flags & NDR_OUT) {

7153

if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {

7154

NDR_PULL_ALLOC(ndr, r->out.alias_handle);

7155

}

7156

_mem_save_alias_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);

7157

NDR_PULL_SET_MEM_CTX(ndr, r->out.alias_handle, LIBNDR_FLAG_REF_ALLOC);

7158

NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.alias_handle));

7159

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_alias_handle_0, LIBNDR_FLAG_REF_ALLOC);

7160

if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {

7161

NDR_PULL_ALLOC(ndr, r->out.rid);

7162

}

7163

_mem_save_rid_0 = NDR_PULL_GET_MEM_CTX(ndr);

7164

NDR_PULL_SET_MEM_CTX(ndr, r->out.rid, LIBNDR_FLAG_REF_ALLOC);

7165

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.rid));

7166

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_rid_0, LIBNDR_FLAG_REF_ALLOC);

7167

NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));

7168

}

7169

return NDR_ERR_SUCCESS;

7170

}

7171

7172

_PUBLIC_ void ndr_print_samr_CreateDomAlias(struct ndr_print *ndr, const char *name, int flags, const struct samr_CreateDomAlias *r)

7173

{

7174

ndr_print_struct(ndr, name, "samr_CreateDomAlias");

7175

if (r == NULL) { ndr_print_null(ndr); return; }

7176

ndr->depth++;

7177

if (flags & NDR_SET_VALUES) {

7178

ndr->flags |= LIBNDR_PRINT_SET_VALUES;

7179

}

7180

if (flags & NDR_IN) {

7181

ndr_print_struct(ndr, "in", "samr_CreateDomAlias");

7182

ndr->depth++;

7183

ndr_print_ptr(ndr, "domain_handle", r->in.domain_handle);

7184

ndr->depth++;

7185

ndr_print_policy_handle(ndr, "domain_handle", r->in.domain_handle);

7186

ndr->depth--;

7187

ndr_print_ptr(ndr, "alias_name", r->in.alias_name);

7188

ndr->depth++;

7189

ndr_print_lsa_String(ndr, "alias_name", r->in.alias_name);

7190

ndr->depth--;

7191

ndr_print_samr_AliasAccessMask(ndr, "access_mask", r->in.access_mask);

7192

ndr->depth--;

7193

}

7194

if (flags & NDR_OUT) {

7195

ndr_print_struct(ndr, "out", "samr_CreateDomAlias");

7196

ndr->depth++;

7197

ndr_print_ptr(ndr, "alias_handle", r->out.alias_handle);

7198

ndr->depth++;

7199

ndr_print_policy_handle(ndr, "alias_handle", r->out.alias_handle);

7200

ndr->depth--;

7201

ndr_print_ptr(ndr, "rid", r->out.rid);

7202

ndr->depth++;

7203

ndr_print_uint32(ndr, "rid", *r->out.rid);

7204

ndr->depth--;

7205

ndr_print_NTSTATUS(ndr, "result", r->out.result);

7206

ndr->depth--;

7207

}

7208

ndr->depth--;

7209

}

7210

7211

static enum ndr_err_code ndr_push_samr_EnumDomainAliases(struct ndr_push *ndr, int flags, const struct samr_EnumDomainAliases *r)

7212

{

7213

if (flags & NDR_IN) {

7214

if (r->in.domain_handle == NULL) {

7215

return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");

7216

}

7217

NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));

7218

if (r->in.resume_handle == NULL) {

7219

return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");

7220

}

7221

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->in.resume_handle));

7222

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.max_size));

7223

}

7224

if (flags & NDR_OUT) {

7225

if (r->out.resume_handle == NULL) {

7226

return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");

7227

}

7228

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.resume_handle));

7229

if (r->out.sam == NULL) {

7230

return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");

7231

}

7232

NDR_CHECK(ndr_push_unique_ptr(ndr, *r->out.sam));

7233

if (*r->out.sam) {

7234

NDR_CHECK(ndr_push_samr_SamArray(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.sam));

7235

}

7236

if (r->out.num_entries == NULL) {

7237

return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");

7238

}

7239

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.num_entries));

7240

NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));

7241

}

7242

return NDR_ERR_SUCCESS;

7243

}

7244

7245

static enum ndr_err_code ndr_pull_samr_EnumDomainAliases(struct ndr_pull *ndr, int flags, struct samr_EnumDomainAliases *r)

7246

{

7247

uint32_t _ptr_sam;

7248

TALLOC_CTX *_mem_save_domain_handle_0;

7249

TALLOC_CTX *_mem_save_resume_handle_0;

7250

TALLOC_CTX *_mem_save_sam_0;

7251

TALLOC_CTX *_mem_save_sam_1;

7252

TALLOC_CTX *_mem_save_num_entries_0;

7253

if (flags & NDR_IN) {

7254

ZERO_STRUCT(r->out);

7255

7256

if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {

7257

NDR_PULL_ALLOC(ndr, r->in.domain_handle);

7258

}

7259

_mem_save_domain_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);

7260

NDR_PULL_SET_MEM_CTX(ndr, r->in.domain_handle, LIBNDR_FLAG_REF_ALLOC);

7261

NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));

7262

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domain_handle_0, LIBNDR_FLAG_REF_ALLOC);

7263

if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {

7264

NDR_PULL_ALLOC(ndr, r->in.resume_handle);

7265

}

7266

_mem_save_resume_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);

7267

NDR_PULL_SET_MEM_CTX(ndr, r->in.resume_handle, LIBNDR_FLAG_REF_ALLOC);

7268

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->in.resume_handle));

7269

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_resume_handle_0, LIBNDR_FLAG_REF_ALLOC);

7270

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.max_size));

7271

NDR_PULL_ALLOC(ndr, r->out.resume_handle);

7272

*r->out.resume_handle = *r->in.resume_handle;

7273

NDR_PULL_ALLOC(ndr, r->out.sam);

7274

ZERO_STRUCTP(r->out.sam);

7275

NDR_PULL_ALLOC(ndr, r->out.num_entries);

7276

ZERO_STRUCTP(r->out.num_entries);

7277

}

7278

if (flags & NDR_OUT) {

7279

if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {

7280

NDR_PULL_ALLOC(ndr, r->out.resume_handle);

7281

}

7282

_mem_save_resume_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);

7283

NDR_PULL_SET_MEM_CTX(ndr, r->out.resume_handle, LIBNDR_FLAG_REF_ALLOC);

7284

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.resume_handle));

7285

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_resume_handle_0, LIBNDR_FLAG_REF_ALLOC);

7286

if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {

7287

NDR_PULL_ALLOC(ndr, r->out.sam);

7288

}

7289

_mem_save_sam_0 = NDR_PULL_GET_MEM_CTX(ndr);

7290

NDR_PULL_SET_MEM_CTX(ndr, r->out.sam, LIBNDR_FLAG_REF_ALLOC);

7291

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_sam));

7292

if (_ptr_sam) {

7293

NDR_PULL_ALLOC(ndr, *r->out.sam);

7294

} else {

7295

*r->out.sam = NULL;

7296

}

7297

if (*r->out.sam) {

7298

_mem_save_sam_1 = NDR_PULL_GET_MEM_CTX(ndr);

7299

NDR_PULL_SET_MEM_CTX(ndr, *r->out.sam, 0);

7300

NDR_CHECK(ndr_pull_samr_SamArray(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.sam));

7301

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sam_1, 0);

7302

}

7303

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sam_0, LIBNDR_FLAG_REF_ALLOC);

7304

if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {

7305

NDR_PULL_ALLOC(ndr, r->out.num_entries);

7306

}

7307

_mem_save_num_entries_0 = NDR_PULL_GET_MEM_CTX(ndr);

7308

NDR_PULL_SET_MEM_CTX(ndr, r->out.num_entries, LIBNDR_FLAG_REF_ALLOC);

7309

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.num_entries));

7310

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_num_entries_0, LIBNDR_FLAG_REF_ALLOC);

7311

NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));

7312

}

7313

return NDR_ERR_SUCCESS;

7314

}

7315

7316

_PUBLIC_ void ndr_print_samr_EnumDomainAliases(struct ndr_print *ndr, const char *name, int flags, const struct samr_EnumDomainAliases *r)

7317

{

7318

ndr_print_struct(ndr, name, "samr_EnumDomainAliases");

7319

if (r == NULL) { ndr_print_null(ndr); return; }

7320

ndr->depth++;

7321

if (flags & NDR_SET_VALUES) {

7322

ndr->flags |= LIBNDR_PRINT_SET_VALUES;

7323

}

7324

if (flags & NDR_IN) {

7325

ndr_print_struct(ndr, "in", "samr_EnumDomainAliases");

7326

ndr->depth++;

7327

ndr_print_ptr(ndr, "domain_handle", r->in.domain_handle);

7328

ndr->depth++;

7329

ndr_print_policy_handle(ndr, "domain_handle", r->in.domain_handle);

7330

ndr->depth--;

7331

ndr_print_ptr(ndr, "resume_handle", r->in.resume_handle);

7332

ndr->depth++;

7333

ndr_print_uint32(ndr, "resume_handle", *r->in.resume_handle);

7334

ndr->depth--;

7335

ndr_print_uint32(ndr, "max_size", r->in.max_size);

7336

ndr->depth--;

7337

}

7338

if (flags & NDR_OUT) {

7339

ndr_print_struct(ndr, "out", "samr_EnumDomainAliases");

7340

ndr->depth++;

7341

ndr_print_ptr(ndr, "resume_handle", r->out.resume_handle);

7342

ndr->depth++;

7343

ndr_print_uint32(ndr, "resume_handle", *r->out.resume_handle);

7344

ndr->depth--;

7345

ndr_print_ptr(ndr, "sam", r->out.sam);

7346

ndr->depth++;

7347

ndr_print_ptr(ndr, "sam", *r->out.sam);

7348

ndr->depth++;

7349

if (*r->out.sam) {

7350

ndr_print_samr_SamArray(ndr, "sam", *r->out.sam);

7351

}

7352

ndr->depth--;

7353

ndr->depth--;

7354

ndr_print_ptr(ndr, "num_entries", r->out.num_entries);

7355

ndr->depth++;

7356

ndr_print_uint32(ndr, "num_entries", *r->out.num_entries);

7357

ndr->depth--;

7358

ndr_print_NTSTATUS(ndr, "result", r->out.result);

7359

ndr->depth--;

7360

}

7361

ndr->depth--;

7362

}

7363

7364

static enum ndr_err_code ndr_push_samr_GetAliasMembership(struct ndr_push *ndr, int flags, const struct samr_GetAliasMembership *r)

7365

{

7366

if (flags & NDR_IN) {

7367

if (r->in.domain_handle == NULL) {

7368

return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");

7369

}

7370

NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));

7371

if (r->in.sids == NULL) {

7372

return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");

7373

}

7374

NDR_CHECK(ndr_push_lsa_SidArray(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.sids));

7375

}

7376

if (flags & NDR_OUT) {

7377

if (r->out.rids == NULL) {

7378

return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");

7379

}

7380

NDR_CHECK(ndr_push_samr_Ids(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.rids));

7381

NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));

7382

}

7383

return NDR_ERR_SUCCESS;

7384

}

7385

7386

static enum ndr_err_code ndr_pull_samr_GetAliasMembership(struct ndr_pull *ndr, int flags, struct samr_GetAliasMembership *r)

7387

{

7388

TALLOC_CTX *_mem_save_domain_handle_0;

7389

TALLOC_CTX *_mem_save_sids_0;

7390

TALLOC_CTX *_mem_save_rids_0;

7391

if (flags & NDR_IN) {

7392

ZERO_STRUCT(r->out);

7393

7394

if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {

7395

NDR_PULL_ALLOC(ndr, r->in.domain_handle);

7396

}

7397

_mem_save_domain_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);

7398

NDR_PULL_SET_MEM_CTX(ndr, r->in.domain_handle, LIBNDR_FLAG_REF_ALLOC);

7399

NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));

7400

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domain_handle_0, LIBNDR_FLAG_REF_ALLOC);

7401

if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {

7402

NDR_PULL_ALLOC(ndr, r->in.sids);

7403

}

7404

_mem_save_sids_0 = NDR_PULL_GET_MEM_CTX(ndr);

7405

NDR_PULL_SET_MEM_CTX(ndr, r->in.sids, LIBNDR_FLAG_REF_ALLOC);

7406

NDR_CHECK(ndr_pull_lsa_SidArray(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.sids));

7407

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sids_0, LIBNDR_FLAG_REF_ALLOC);

7408

NDR_PULL_ALLOC(ndr, r->out.rids);

7409

ZERO_STRUCTP(r->out.rids);

7410

}

7411

if (flags & NDR_OUT) {

7412

if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {

7413

NDR_PULL_ALLOC(ndr, r->out.rids);

7414

}

7415

_mem_save_rids_0 = NDR_PULL_GET_MEM_CTX(ndr);

7416

NDR_PULL_SET_MEM_CTX(ndr, r->out.rids, LIBNDR_FLAG_REF_ALLOC);

7417

NDR_CHECK(ndr_pull_samr_Ids(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.rids));

7418

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_rids_0, LIBNDR_FLAG_REF_ALLOC);

7419

NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));

7420

}

7421

return NDR_ERR_SUCCESS;

7422

}

7423

7424

_PUBLIC_ void ndr_print_samr_GetAliasMembership(struct ndr_print *ndr, const char *name, int flags, const struct samr_GetAliasMembership *r)

7425

{

7426

ndr_print_struct(ndr, name, "samr_GetAliasMembership");

7427

if (r == NULL) { ndr_print_null(ndr); return; }

7428

ndr->depth++;

7429

if (flags & NDR_SET_VALUES) {

7430

ndr->flags |= LIBNDR_PRINT_SET_VALUES;

7431

}

7432

if (flags & NDR_IN) {

7433

ndr_print_struct(ndr, "in", "samr_GetAliasMembership");

7434

ndr->depth++;

7435

ndr_print_ptr(ndr, "domain_handle", r->in.domain_handle);

7436

ndr->depth++;

7437

ndr_print_policy_handle(ndr, "domain_handle", r->in.domain_handle);

7438

ndr->depth--;

7439

ndr_print_ptr(ndr, "sids", r->in.sids);

7440

ndr->depth++;

7441

ndr_print_lsa_SidArray(ndr, "sids", r->in.sids);

7442

ndr->depth--;

7443

ndr->depth--;

7444

}

7445

if (flags & NDR_OUT) {

7446

ndr_print_struct(ndr, "out", "samr_GetAliasMembership");

7447

ndr->depth++;

7448

ndr_print_ptr(ndr, "rids", r->out.rids);

7449

ndr->depth++;

7450

ndr_print_samr_Ids(ndr, "rids", r->out.rids);

7451

ndr->depth--;

7452

ndr_print_NTSTATUS(ndr, "result", r->out.result);

7453

ndr->depth--;

7454

}

7455

ndr->depth--;

7456

}

7457

7458

_PUBLIC_ enum ndr_err_code ndr_push_samr_LookupNames(struct ndr_push *ndr, int flags, const struct samr_LookupNames *r)

7459

{

7460

uint32_t cntr_names_0;

7461

if (flags & NDR_IN) {

7462

if (r->in.domain_handle == NULL) {

7463

return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");

7464

}

7465

NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));

7466

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.num_names));

7467

NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 1000));

7468

NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));

7469

NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->in.num_names));

7470

for (cntr_names_0 = 0; cntr_names_0 < r->in.num_names; cntr_names_0++) {

7471

NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->in.names[cntr_names_0]));

7472

}

7473

for (cntr_names_0 = 0; cntr_names_0 < r->in.num_names; cntr_names_0++) {

7474

NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->in.names[cntr_names_0]));

7475

}

7476

}

7477

if (flags & NDR_OUT) {

7478

if (r->out.rids == NULL) {

7479

return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");

7480

}

7481

NDR_CHECK(ndr_push_samr_Ids(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.rids));

7482

if (r->out.types == NULL) {

7483

return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");

7484

}

7485

NDR_CHECK(ndr_push_samr_Ids(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.types));

7486

NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));

7487

}

7488

return NDR_ERR_SUCCESS;

7489

}

7490

7491

_PUBLIC_ enum ndr_err_code ndr_pull_samr_LookupNames(struct ndr_pull *ndr, int flags, struct samr_LookupNames *r)

7492

{

7493

uint32_t cntr_names_0;

7494

TALLOC_CTX *_mem_save_domain_handle_0;

7495

TALLOC_CTX *_mem_save_names_0;

7496

TALLOC_CTX *_mem_save_rids_0;

7497

TALLOC_CTX *_mem_save_types_0;

7498

if (flags & NDR_IN) {

7499

ZERO_STRUCT(r->out);

7500

7501

if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {

7502

NDR_PULL_ALLOC(ndr, r->in.domain_handle);

7503

}

7504

_mem_save_domain_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);

7505

NDR_PULL_SET_MEM_CTX(ndr, r->in.domain_handle, LIBNDR_FLAG_REF_ALLOC);

7506

NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));

7507

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domain_handle_0, LIBNDR_FLAG_REF_ALLOC);

7508

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.num_names));

7509

if (r->in.num_names > 1000) {

7510

return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");

7511

}

7512

NDR_CHECK(ndr_pull_array_size(ndr, &r->in.names));

7513

NDR_CHECK(ndr_pull_array_length(ndr, &r->in.names));

7514

if (ndr_get_array_length(ndr, &r->in.names) > ndr_get_array_size(ndr, &r->in.names)) {

7515

return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->in.names), ndr_get_array_length(ndr, &r->in.names));

7516

}

7517

NDR_PULL_ALLOC_N(ndr, r->in.names, ndr_get_array_size(ndr, &r->in.names));

7518

_mem_save_names_0 = NDR_PULL_GET_MEM_CTX(ndr);

7519

NDR_PULL_SET_MEM_CTX(ndr, r->in.names, 0);

7520

for (cntr_names_0 = 0; cntr_names_0 < ndr_get_array_length(ndr, &r->in.names); cntr_names_0++) {

7521

NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->in.names[cntr_names_0]));

7522

}

7523

for (cntr_names_0 = 0; cntr_names_0 < ndr_get_array_length(ndr, &r->in.names); cntr_names_0++) {

7524

NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->in.names[cntr_names_0]));

7525

}

7526

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_names_0, 0);

7527

NDR_PULL_ALLOC(ndr, r->out.rids);

7528

ZERO_STRUCTP(r->out.rids);

7529

NDR_PULL_ALLOC(ndr, r->out.types);

7530

ZERO_STRUCTP(r->out.types);

7531

if (r->in.names) {

7532

NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->in.names, 1000));

7533

}

7534

if (r->in.names) {

7535

NDR_CHECK(ndr_check_array_length(ndr, (void*)&r->in.names, r->in.num_names));

7536

}

7537

}

7538

if (flags & NDR_OUT) {

7539

if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {

7540

NDR_PULL_ALLOC(ndr, r->out.rids);

7541

}

7542

_mem_save_rids_0 = NDR_PULL_GET_MEM_CTX(ndr);

7543

NDR_PULL_SET_MEM_CTX(ndr, r->out.rids, LIBNDR_FLAG_REF_ALLOC);

7544

NDR_CHECK(ndr_pull_samr_Ids(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.rids));

7545

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_rids_0, LIBNDR_FLAG_REF_ALLOC);

7546

if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {

7547

NDR_PULL_ALLOC(ndr, r->out.types);

7548

}

7549

_mem_save_types_0 = NDR_PULL_GET_MEM_CTX(ndr);

7550

NDR_PULL_SET_MEM_CTX(ndr, r->out.types, LIBNDR_FLAG_REF_ALLOC);

7551

NDR_CHECK(ndr_pull_samr_Ids(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.types));

7552

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_types_0, LIBNDR_FLAG_REF_ALLOC);

7553

NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));

7554

}

7555

return NDR_ERR_SUCCESS;

7556

}

7557

7558

_PUBLIC_ void ndr_print_samr_LookupNames(struct ndr_print *ndr, const char *name, int flags, const struct samr_LookupNames *r)

7559

{

7560

uint32_t cntr_names_0;

7561

ndr_print_struct(ndr, name, "samr_LookupNames");

7562

if (r == NULL) { ndr_print_null(ndr); return; }

7563

ndr->depth++;

7564

if (flags & NDR_SET_VALUES) {

7565

ndr->flags |= LIBNDR_PRINT_SET_VALUES;

7566

}

7567

if (flags & NDR_IN) {

7568

ndr_print_struct(ndr, "in", "samr_LookupNames");

7569

ndr->depth++;

7570

ndr_print_ptr(ndr, "domain_handle", r->in.domain_handle);

7571

ndr->depth++;

7572

ndr_print_policy_handle(ndr, "domain_handle", r->in.domain_handle);

7573

ndr->depth--;

7574

ndr_print_uint32(ndr, "num_names", r->in.num_names);

7575

ndr->print(ndr, "%s: ARRAY(%d)", "names", (int)r->in.num_names);

7576

ndr->depth++;

7577

for (cntr_names_0=0;cntr_names_0<r->in.num_names;cntr_names_0++) {

7578

ndr_print_lsa_String(ndr, "names", &r->in.names[cntr_names_0]);

7579

}

7580

ndr->depth--;

7581

ndr->depth--;

7582

}

7583

if (flags & NDR_OUT) {

7584

ndr_print_struct(ndr, "out", "samr_LookupNames");

7585

ndr->depth++;

7586

ndr_print_ptr(ndr, "rids", r->out.rids);

7587

ndr->depth++;

7588

ndr_print_samr_Ids(ndr, "rids", r->out.rids);

7589

ndr->depth--;

7590

ndr_print_ptr(ndr, "types", r->out.types);

7591

ndr->depth++;

7592

ndr_print_samr_Ids(ndr, "types", r->out.types);

7593

ndr->depth--;

7594

ndr_print_NTSTATUS(ndr, "result", r->out.result);

7595

ndr->depth--;

7596

}

7597

ndr->depth--;

7598

}

7599

7600

static enum ndr_err_code ndr_push_samr_LookupRids(struct ndr_push *ndr, int flags, const struct samr_LookupRids *r)

7601

{

7602

uint32_t cntr_rids_0;

7603

if (flags & NDR_IN) {

7604

if (r->in.domain_handle == NULL) {

7605

return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");

7606

}

7607

NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));

7608

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.num_rids));

7609

NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 1000));

7610

NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));

7611

NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->in.num_rids));

7612

for (cntr_rids_0 = 0; cntr_rids_0 < r->in.num_rids; cntr_rids_0++) {

7613

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.rids[cntr_rids_0]));

7614

}

7615

}

7616

if (flags & NDR_OUT) {

7617

if (r->out.names == NULL) {

7618

return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");

7619

}

7620

NDR_CHECK(ndr_push_lsa_Strings(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.names));

7621

if (r->out.types == NULL) {

7622

return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");

7623

}

7624

NDR_CHECK(ndr_push_samr_Ids(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.types));

7625

NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));

7626

}

7627

return NDR_ERR_SUCCESS;

7628

}

7629

7630

static enum ndr_err_code ndr_pull_samr_LookupRids(struct ndr_pull *ndr, int flags, struct samr_LookupRids *r)

7631

{

7632

uint32_t cntr_rids_0;

7633

TALLOC_CTX *_mem_save_domain_handle_0;

7634

TALLOC_CTX *_mem_save_rids_0;

7635

TALLOC_CTX *_mem_save_names_0;

7636

TALLOC_CTX *_mem_save_types_0;

7637

if (flags & NDR_IN) {

7638

ZERO_STRUCT(r->out);

7639

7640

if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {

7641

NDR_PULL_ALLOC(ndr, r->in.domain_handle);

7642

}

7643

_mem_save_domain_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);

7644

NDR_PULL_SET_MEM_CTX(ndr, r->in.domain_handle, LIBNDR_FLAG_REF_ALLOC);

7645

NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));

7646

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domain_handle_0, LIBNDR_FLAG_REF_ALLOC);

7647

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.num_rids));

7648

if (r->in.num_rids > 1000) {

7649

return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");

7650

}

7651

NDR_CHECK(ndr_pull_array_size(ndr, &r->in.rids));

7652

NDR_CHECK(ndr_pull_array_length(ndr, &r->in.rids));

7653

if (ndr_get_array_length(ndr, &r->in.rids) > ndr_get_array_size(ndr, &r->in.rids)) {

7654

return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->in.rids), ndr_get_array_length(ndr, &r->in.rids));

7655

}

7656

NDR_PULL_ALLOC_N(ndr, r->in.rids, ndr_get_array_size(ndr, &r->in.rids));

7657

_mem_save_rids_0 = NDR_PULL_GET_MEM_CTX(ndr);

7658

NDR_PULL_SET_MEM_CTX(ndr, r->in.rids, 0);

7659

for (cntr_rids_0 = 0; cntr_rids_0 < ndr_get_array_length(ndr, &r->in.rids); cntr_rids_0++) {

7660

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.rids[cntr_rids_0]));

7661

}

7662

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_rids_0, 0);

7663

NDR_PULL_ALLOC(ndr, r->out.names);

7664

ZERO_STRUCTP(r->out.names);

7665

NDR_PULL_ALLOC(ndr, r->out.types);

7666

ZERO_STRUCTP(r->out.types);

7667

if (r->in.rids) {

7668

NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->in.rids, 1000));

7669

}

7670

if (r->in.rids) {

7671

NDR_CHECK(ndr_check_array_length(ndr, (void*)&r->in.rids, r->in.num_rids));

7672

}

7673

}

7674

if (flags & NDR_OUT) {

7675

if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {

7676

NDR_PULL_ALLOC(ndr, r->out.names);

7677

}

7678

_mem_save_names_0 = NDR_PULL_GET_MEM_CTX(ndr);

7679

NDR_PULL_SET_MEM_CTX(ndr, r->out.names, LIBNDR_FLAG_REF_ALLOC);

7680

NDR_CHECK(ndr_pull_lsa_Strings(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.names));

7681

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_names_0, LIBNDR_FLAG_REF_ALLOC);

7682

if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {

7683

NDR_PULL_ALLOC(ndr, r->out.types);

7684

}

7685

_mem_save_types_0 = NDR_PULL_GET_MEM_CTX(ndr);

7686

NDR_PULL_SET_MEM_CTX(ndr, r->out.types, LIBNDR_FLAG_REF_ALLOC);

7687

NDR_CHECK(ndr_pull_samr_Ids(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.types));

7688

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_types_0, LIBNDR_FLAG_REF_ALLOC);

7689

NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));

7690

}

7691

return NDR_ERR_SUCCESS;

7692

}

7693

7694

_PUBLIC_ void ndr_print_samr_LookupRids(struct ndr_print *ndr, const char *name, int flags, const struct samr_LookupRids *r)

7695

{

7696

uint32_t cntr_rids_0;

7697

ndr_print_struct(ndr, name, "samr_LookupRids");

7698

if (r == NULL) { ndr_print_null(ndr); return; }

7699

ndr->depth++;

7700

if (flags & NDR_SET_VALUES) {

7701

ndr->flags |= LIBNDR_PRINT_SET_VALUES;

7702

}

7703

if (flags & NDR_IN) {

7704

ndr_print_struct(ndr, "in", "samr_LookupRids");

7705

ndr->depth++;

7706

ndr_print_ptr(ndr, "domain_handle", r->in.domain_handle);

7707

ndr->depth++;

7708

ndr_print_policy_handle(ndr, "domain_handle", r->in.domain_handle);

7709

ndr->depth--;

7710

ndr_print_uint32(ndr, "num_rids", r->in.num_rids);

7711

ndr->print(ndr, "%s: ARRAY(%d)", "rids", (int)r->in.num_rids);

7712

ndr->depth++;

7713

for (cntr_rids_0=0;cntr_rids_0<r->in.num_rids;cntr_rids_0++) {

7714

ndr_print_uint32(ndr, "rids", r->in.rids[cntr_rids_0]);

7715

}

7716

ndr->depth--;

7717

ndr->depth--;

7718

}

7719

if (flags & NDR_OUT) {

7720

ndr_print_struct(ndr, "out", "samr_LookupRids");

7721

ndr->depth++;

7722

ndr_print_ptr(ndr, "names", r->out.names);

7723

ndr->depth++;

7724

ndr_print_lsa_Strings(ndr, "names", r->out.names);

7725

ndr->depth--;

7726

ndr_print_ptr(ndr, "types", r->out.types);

7727

ndr->depth++;

7728

ndr_print_samr_Ids(ndr, "types", r->out.types);

7729

ndr->depth--;

7730

ndr_print_NTSTATUS(ndr, "result", r->out.result);

7731

ndr->depth--;

7732

}

7733

ndr->depth--;

7734

}

7735

7736

static enum ndr_err_code ndr_push_samr_OpenGroup(struct ndr_push *ndr, int flags, const struct samr_OpenGroup *r)

7737

{

7738

if (flags & NDR_IN) {

7739

if (r->in.domain_handle == NULL) {

7740

return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");

7741

}

7742

NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));

7743

NDR_CHECK(ndr_push_samr_GroupAccessMask(ndr, NDR_SCALARS, r->in.access_mask));

7744

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.rid));

7745

}

7746

if (flags & NDR_OUT) {

7747

if (r->out.group_handle == NULL) {

7748

return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");

7749

}

7750

NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.group_handle));

7751

NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));

7752

}

7753

return NDR_ERR_SUCCESS;

7754

}

7755

7756

static enum ndr_err_code ndr_pull_samr_OpenGroup(struct ndr_pull *ndr, int flags, struct samr_OpenGroup *r)

7757

{

7758

TALLOC_CTX *_mem_save_domain_handle_0;

7759

TALLOC_CTX *_mem_save_group_handle_0;

7760

if (flags & NDR_IN) {

7761

ZERO_STRUCT(r->out);

7762

7763

if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {

7764

NDR_PULL_ALLOC(ndr, r->in.domain_handle);

7765

}

7766

_mem_save_domain_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);

7767

NDR_PULL_SET_MEM_CTX(ndr, r->in.domain_handle, LIBNDR_FLAG_REF_ALLOC);

7768

NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));

7769

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domain_handle_0, LIBNDR_FLAG_REF_ALLOC);

7770

NDR_CHECK(ndr_pull_samr_GroupAccessMask(ndr, NDR_SCALARS, &r->in.access_mask));

7771

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.rid));

7772

NDR_PULL_ALLOC(ndr, r->out.group_handle);

7773

ZERO_STRUCTP(r->out.group_handle);

7774

}

7775

if (flags & NDR_OUT) {

7776

if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {

7777

NDR_PULL_ALLOC(ndr, r->out.group_handle);

7778

}

7779

_mem_save_group_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);

7780

NDR_PULL_SET_MEM_CTX(ndr, r->out.group_handle, LIBNDR_FLAG_REF_ALLOC);

7781

NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.group_handle));

7782

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_group_handle_0, LIBNDR_FLAG_REF_ALLOC);

7783

NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));

7784

}

7785

return NDR_ERR_SUCCESS;

7786

}

7787

7788

_PUBLIC_ void ndr_print_samr_OpenGroup(struct ndr_print *ndr, const char *name, int flags, const struct samr_OpenGroup *r)

7789

{

7790

ndr_print_struct(ndr, name, "samr_OpenGroup");

7791

if (r == NULL) { ndr_print_null(ndr); return; }

7792

ndr->depth++;

7793

if (flags & NDR_SET_VALUES) {

7794

ndr->flags |= LIBNDR_PRINT_SET_VALUES;

7795

}

7796

if (flags & NDR_IN) {

7797

ndr_print_struct(ndr, "in", "samr_OpenGroup");

7798

ndr->depth++;

7799

ndr_print_ptr(ndr, "domain_handle", r->in.domain_handle);

7800

ndr->depth++;

7801

ndr_print_policy_handle(ndr, "domain_handle", r->in.domain_handle);

7802

ndr->depth--;

7803

ndr_print_samr_GroupAccessMask(ndr, "access_mask", r->in.access_mask);

7804

ndr_print_uint32(ndr, "rid", r->in.rid);

7805

ndr->depth--;

7806

}

7807

if (flags & NDR_OUT) {

7808

ndr_print_struct(ndr, "out", "samr_OpenGroup");

7809

ndr->depth++;

7810

ndr_print_ptr(ndr, "group_handle", r->out.group_handle);

7811

ndr->depth++;

7812

ndr_print_policy_handle(ndr, "group_handle", r->out.group_handle);

7813

ndr->depth--;

7814

ndr_print_NTSTATUS(ndr, "result", r->out.result);

7815

ndr->depth--;

7816

}

7817

ndr->depth--;

7818

}

7819

7820

static enum ndr_err_code ndr_push_samr_QueryGroupInfo(struct ndr_push *ndr, int flags, const struct samr_QueryGroupInfo *r)

7821

{

7822

if (flags & NDR_IN) {

7823

if (r->in.group_handle == NULL) {

7824

return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");

7825

}

7826

NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.group_handle));

7827

NDR_CHECK(ndr_push_samr_GroupInfoEnum(ndr, NDR_SCALARS, r->in.level));

7828

}

7829

if (flags & NDR_OUT) {

7830

if (r->out.info == NULL) {

7831

return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");

7832

}

7833

NDR_CHECK(ndr_push_unique_ptr(ndr, *r->out.info));

7834

if (*r->out.info) {

7835

NDR_CHECK(ndr_push_set_switch_value(ndr, *r->out.info, r->in.level));

7836

NDR_CHECK(ndr_push_samr_GroupInfo(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.info));

7837

}

7838

NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));

7839

}

7840

return NDR_ERR_SUCCESS;

7841

}

7842

7843

static enum ndr_err_code ndr_pull_samr_QueryGroupInfo(struct ndr_pull *ndr, int flags, struct samr_QueryGroupInfo *r)

7844

{

7845

uint32_t _ptr_info;

7846

TALLOC_CTX *_mem_save_group_handle_0;

7847

TALLOC_CTX *_mem_save_info_0;

7848

TALLOC_CTX *_mem_save_info_1;

7849

if (flags & NDR_IN) {

7850

ZERO_STRUCT(r->out);

7851

7852

if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {

7853

NDR_PULL_ALLOC(ndr, r->in.group_handle);

7854

}

7855

_mem_save_group_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);

7856

NDR_PULL_SET_MEM_CTX(ndr, r->in.group_handle, LIBNDR_FLAG_REF_ALLOC);

7857

NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.group_handle));

7858

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_group_handle_0, LIBNDR_FLAG_REF_ALLOC);

7859

NDR_CHECK(ndr_pull_samr_GroupInfoEnum(ndr, NDR_SCALARS, &r->in.level));

7860

NDR_PULL_ALLOC(ndr, r->out.info);

7861

ZERO_STRUCTP(r->out.info);

7862

}

7863

if (flags & NDR_OUT) {

7864

if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {

7865

NDR_PULL_ALLOC(ndr, r->out.info);

7866

}

7867

_mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);

7868

NDR_PULL_SET_MEM_CTX(ndr, r->out.info, LIBNDR_FLAG_REF_ALLOC);

7869

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));

7870

if (_ptr_info) {

7871

NDR_PULL_ALLOC(ndr, *r->out.info);

7872

} else {

7873

*r->out.info = NULL;

7874

}

7875

if (*r->out.info) {

7876

_mem_save_info_1 = NDR_PULL_GET_MEM_CTX(ndr);

7877

NDR_PULL_SET_MEM_CTX(ndr, *r->out.info, 0);

7878

NDR_CHECK(ndr_pull_set_switch_value(ndr, *r->out.info, r->in.level));

7879

NDR_CHECK(ndr_pull_samr_GroupInfo(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.info));

7880

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_1, 0);

7881

}

7882

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, LIBNDR_FLAG_REF_ALLOC);

7883

NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));

7884

}

7885

return NDR_ERR_SUCCESS;

7886

}

7887

7888

_PUBLIC_ void ndr_print_samr_QueryGroupInfo(struct ndr_print *ndr, const char *name, int flags, const struct samr_QueryGroupInfo *r)

7889

{

7890

ndr_print_struct(ndr, name, "samr_QueryGroupInfo");

7891

if (r == NULL) { ndr_print_null(ndr); return; }

7892

ndr->depth++;

7893

if (flags & NDR_SET_VALUES) {

7894

ndr->flags |= LIBNDR_PRINT_SET_VALUES;

7895

}

7896

if (flags & NDR_IN) {

7897

ndr_print_struct(ndr, "in", "samr_QueryGroupInfo");

7898

ndr->depth++;

7899

ndr_print_ptr(ndr, "group_handle", r->in.group_handle);

7900

ndr->depth++;

7901

ndr_print_policy_handle(ndr, "group_handle", r->in.group_handle);

7902

ndr->depth--;

7903

ndr_print_samr_GroupInfoEnum(ndr, "level", r->in.level);

7904

ndr->depth--;

7905

}

7906

if (flags & NDR_OUT) {

7907

ndr_print_struct(ndr, "out", "samr_QueryGroupInfo");

7908

ndr->depth++;

7909

ndr_print_ptr(ndr, "info", r->out.info);

7910

ndr->depth++;

7911

ndr_print_ptr(ndr, "info", *r->out.info);

7912

ndr->depth++;

7913

if (*r->out.info) {

7914

ndr_print_set_switch_value(ndr, *r->out.info, r->in.level);

7915

ndr_print_samr_GroupInfo(ndr, "info", *r->out.info);

7916

}

7917

ndr->depth--;

7918

ndr->depth--;

7919

ndr_print_NTSTATUS(ndr, "result", r->out.result);

7920

ndr->depth--;

7921

}

7922

ndr->depth--;

7923

}

7924

7925

static enum ndr_err_code ndr_push_samr_SetGroupInfo(struct ndr_push *ndr, int flags, const struct samr_SetGroupInfo *r)

7926

{

7927

if (flags & NDR_IN) {

7928

if (r->in.group_handle == NULL) {

7929

return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");

7930

}

7931

NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.group_handle));

7932

NDR_CHECK(ndr_push_samr_GroupInfoEnum(ndr, NDR_SCALARS, r->in.level));

7933

if (r->in.info == NULL) {

7934

return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");

7935

}

7936

NDR_CHECK(ndr_push_set_switch_value(ndr, r->in.info, r->in.level));

7937

NDR_CHECK(ndr_push_samr_GroupInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info));

7938

}

7939

if (flags & NDR_OUT) {

7940

NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));

7941

}

7942

return NDR_ERR_SUCCESS;

7943

}

7944

7945

static enum ndr_err_code ndr_pull_samr_SetGroupInfo(struct ndr_pull *ndr, int flags, struct samr_SetGroupInfo *r)

7946

{

7947

TALLOC_CTX *_mem_save_group_handle_0;

7948

TALLOC_CTX *_mem_save_info_0;

7949

if (flags & NDR_IN) {

7950

if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {

7951

NDR_PULL_ALLOC(ndr, r->in.group_handle);

7952

}

7953

_mem_save_group_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);

7954

NDR_PULL_SET_MEM_CTX(ndr, r->in.group_handle, LIBNDR_FLAG_REF_ALLOC);

7955

NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.group_handle));

7956

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_group_handle_0, LIBNDR_FLAG_REF_ALLOC);

7957

NDR_CHECK(ndr_pull_samr_GroupInfoEnum(ndr, NDR_SCALARS, &r->in.level));

7958

if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {

7959

NDR_PULL_ALLOC(ndr, r->in.info);

7960

}

7961

_mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);

7962

NDR_PULL_SET_MEM_CTX(ndr, r->in.info, LIBNDR_FLAG_REF_ALLOC);

7963

NDR_CHECK(ndr_pull_set_switch_value(ndr, r->in.info, r->in.level));

7964

NDR_CHECK(ndr_pull_samr_GroupInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info));

7965

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, LIBNDR_FLAG_REF_ALLOC);

7966

}

7967

if (flags & NDR_OUT) {

7968

NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));

7969

}

7970

return NDR_ERR_SUCCESS;

7971

}

7972

7973

_PUBLIC_ void ndr_print_samr_SetGroupInfo(struct ndr_print *ndr, const char *name, int flags, const struct samr_SetGroupInfo *r)

7974

{

7975

ndr_print_struct(ndr, name, "samr_SetGroupInfo");

7976

if (r == NULL) { ndr_print_null(ndr); return; }

7977

ndr->depth++;

7978

if (flags & NDR_SET_VALUES) {

7979

ndr->flags |= LIBNDR_PRINT_SET_VALUES;

7980

}

7981

if (flags & NDR_IN) {

7982

ndr_print_struct(ndr, "in", "samr_SetGroupInfo");

7983

ndr->depth++;

7984

ndr_print_ptr(ndr, "group_handle", r->in.group_handle);

7985

ndr->depth++;

7986

ndr_print_policy_handle(ndr, "group_handle", r->in.group_handle);

7987

ndr->depth--;

7988

ndr_print_samr_GroupInfoEnum(ndr, "level", r->in.level);

7989

ndr_print_ptr(ndr, "info", r->in.info);

7990

ndr->depth++;

7991

ndr_print_set_switch_value(ndr, r->in.info, r->in.level);

7992

ndr_print_samr_GroupInfo(ndr, "info", r->in.info);

7993

ndr->depth--;

7994

ndr->depth--;

7995

}

7996

if (flags & NDR_OUT) {

7997

ndr_print_struct(ndr, "out", "samr_SetGroupInfo");

7998

ndr->depth++;

7999

ndr_print_NTSTATUS(ndr, "result", r->out.result);

8000

ndr->depth--;

8001

}

8002

ndr->depth--;

8003

}

8004

8005

static enum ndr_err_code ndr_push_samr_AddGroupMember(struct ndr_push *ndr, int flags, const struct samr_AddGroupMember *r)

8006

{

8007

if (flags & NDR_IN) {

8008

if (r->in.group_handle == NULL) {

8009

return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");

8010

}

8011

NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.group_handle));

8012

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.rid));

8013

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.flags));

8014

}

8015

if (flags & NDR_OUT) {

8016

NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));

8017

}

8018

return NDR_ERR_SUCCESS;

8019

}

8020

8021

static enum ndr_err_code ndr_pull_samr_AddGroupMember(struct ndr_pull *ndr, int flags, struct samr_AddGroupMember *r)

8022

{

8023

TALLOC_CTX *_mem_save_group_handle_0;

8024

if (flags & NDR_IN) {

8025

if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {

8026

NDR_PULL_ALLOC(ndr, r->in.group_handle);

8027

}

8028

_mem_save_group_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);

8029

NDR_PULL_SET_MEM_CTX(ndr, r->in.group_handle, LIBNDR_FLAG_REF_ALLOC);

8030

NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.group_handle));

8031

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_group_handle_0, LIBNDR_FLAG_REF_ALLOC);

8032

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.rid));

8033

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.flags));

8034

}

8035

if (flags & NDR_OUT) {

8036

NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));

8037

}

8038

return NDR_ERR_SUCCESS;

8039

}

8040

8041

_PUBLIC_ void ndr_print_samr_AddGroupMember(struct ndr_print *ndr, const char *name, int flags, const struct samr_AddGroupMember *r)

8042

{

8043

ndr_print_struct(ndr, name, "samr_AddGroupMember");

8044

if (r == NULL) { ndr_print_null(ndr); return; }

8045

ndr->depth++;

8046

if (flags & NDR_SET_VALUES) {

8047

ndr->flags |= LIBNDR_PRINT_SET_VALUES;

8048

}

8049

if (flags & NDR_IN) {

8050

ndr_print_struct(ndr, "in", "samr_AddGroupMember");

8051

ndr->depth++;

8052

ndr_print_ptr(ndr, "group_handle", r->in.group_handle);

8053

ndr->depth++;

8054

ndr_print_policy_handle(ndr, "group_handle", r->in.group_handle);

8055

ndr->depth--;

8056

ndr_print_uint32(ndr, "rid", r->in.rid);

8057

ndr_print_uint32(ndr, "flags", r->in.flags);

8058

ndr->depth--;

8059

}

8060

if (flags & NDR_OUT) {

8061

ndr_print_struct(ndr, "out", "samr_AddGroupMember");

8062

ndr->depth++;

8063

ndr_print_NTSTATUS(ndr, "result", r->out.result);

8064

ndr->depth--;

8065

}

8066

ndr->depth--;

8067

}

8068

8069

static enum ndr_err_code ndr_push_samr_DeleteDomainGroup(struct ndr_push *ndr, int flags, const struct samr_DeleteDomainGroup *r)

8070

{

8071

if (flags & NDR_IN) {

8072

if (r->in.group_handle == NULL) {

8073

return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");

8074

}

8075

NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.group_handle));

8076

}

8077

if (flags & NDR_OUT) {

8078

if (r->out.group_handle == NULL) {

8079

return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");

8080

}

8081

NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.group_handle));

8082

NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));

8083

}

8084

return NDR_ERR_SUCCESS;

8085

}

8086

8087

static enum ndr_err_code ndr_pull_samr_DeleteDomainGroup(struct ndr_pull *ndr, int flags, struct samr_DeleteDomainGroup *r)

8088

{

8089

TALLOC_CTX *_mem_save_group_handle_0;

8090

if (flags & NDR_IN) {

8091

ZERO_STRUCT(r->out);

8092

8093

if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {

8094

NDR_PULL_ALLOC(ndr, r->in.group_handle);

8095

}

8096

_mem_save_group_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);

8097

NDR_PULL_SET_MEM_CTX(ndr, r->in.group_handle, LIBNDR_FLAG_REF_ALLOC);

8098

NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.group_handle));

8099

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_group_handle_0, LIBNDR_FLAG_REF_ALLOC);

8100

NDR_PULL_ALLOC(ndr, r->out.group_handle);

8101

*r->out.group_handle = *r->in.group_handle;

8102

}

8103

if (flags & NDR_OUT) {

8104

if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {

8105

NDR_PULL_ALLOC(ndr, r->out.group_handle);

8106

}

8107

_mem_save_group_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);

8108

NDR_PULL_SET_MEM_CTX(ndr, r->out.group_handle, LIBNDR_FLAG_REF_ALLOC);

8109

NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.group_handle));

8110

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_group_handle_0, LIBNDR_FLAG_REF_ALLOC);

8111

NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));

8112

}

8113

return NDR_ERR_SUCCESS;

8114

}

8115

8116

_PUBLIC_ void ndr_print_samr_DeleteDomainGroup(struct ndr_print *ndr, const char *name, int flags, const struct samr_DeleteDomainGroup *r)

8117

{

8118

ndr_print_struct(ndr, name, "samr_DeleteDomainGroup");

8119

if (r == NULL) { ndr_print_null(ndr); return; }

8120

ndr->depth++;

8121

if (flags & NDR_SET_VALUES) {

8122

ndr->flags |= LIBNDR_PRINT_SET_VALUES;

8123

}

8124

if (flags & NDR_IN) {

8125

ndr_print_struct(ndr, "in", "samr_DeleteDomainGroup");

8126

ndr->depth++;

8127

ndr_print_ptr(ndr, "group_handle", r->in.group_handle);

8128

ndr->depth++;

8129

ndr_print_policy_handle(ndr, "group_handle", r->in.group_handle);

8130

ndr->depth--;

8131

ndr->depth--;

8132

}

8133

if (flags & NDR_OUT) {

8134

ndr_print_struct(ndr, "out", "samr_DeleteDomainGroup");

8135

ndr->depth++;

8136

ndr_print_ptr(ndr, "group_handle", r->out.group_handle);

8137

ndr->depth++;

8138

ndr_print_policy_handle(ndr, "group_handle", r->out.group_handle);

8139

ndr->depth--;

8140

ndr_print_NTSTATUS(ndr, "result", r->out.result);

8141

ndr->depth--;

8142

}

8143

ndr->depth--;

8144

}

8145

8146

static enum ndr_err_code ndr_push_samr_DeleteGroupMember(struct ndr_push *ndr, int flags, const struct samr_DeleteGroupMember *r)

8147

{

8148

if (flags & NDR_IN) {

8149

if (r->in.group_handle == NULL) {

8150

return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");

8151

}

8152

NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.group_handle));

8153

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.rid));

8154

}

8155

if (flags & NDR_OUT) {

8156

NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));

8157

}

8158

return NDR_ERR_SUCCESS;

8159

}

8160

8161

static enum ndr_err_code ndr_pull_samr_DeleteGroupMember(struct ndr_pull *ndr, int flags, struct samr_DeleteGroupMember *r)

8162

{

8163

TALLOC_CTX *_mem_save_group_handle_0;

8164

if (flags & NDR_IN) {

8165

if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {

8166

NDR_PULL_ALLOC(ndr, r->in.group_handle);

8167

}

8168

_mem_save_group_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);

8169

NDR_PULL_SET_MEM_CTX(ndr, r->in.group_handle, LIBNDR_FLAG_REF_ALLOC);

8170

NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.group_handle));

8171

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_group_handle_0, LIBNDR_FLAG_REF_ALLOC);

8172

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.rid));

8173

}

8174

if (flags & NDR_OUT) {

8175

NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));

8176

}

8177

return NDR_ERR_SUCCESS;

8178

}

8179

8180

_PUBLIC_ void ndr_print_samr_DeleteGroupMember(struct ndr_print *ndr, const char *name, int flags, const struct samr_DeleteGroupMember *r)

8181

{

8182

ndr_print_struct(ndr, name, "samr_DeleteGroupMember");

8183

if (r == NULL) { ndr_print_null(ndr); return; }

8184

ndr->depth++;

8185

if (flags & NDR_SET_VALUES) {

8186

ndr->flags |= LIBNDR_PRINT_SET_VALUES;

8187

}

8188

if (flags & NDR_IN) {

8189

ndr_print_struct(ndr, "in", "samr_DeleteGroupMember");

8190

ndr->depth++;

8191

ndr_print_ptr(ndr, "group_handle", r->in.group_handle);

8192

ndr->depth++;

8193

ndr_print_policy_handle(ndr, "group_handle", r->in.group_handle);

8194

ndr->depth--;

8195

ndr_print_uint32(ndr, "rid", r->in.rid);

8196

ndr->depth--;

8197

}

8198

if (flags & NDR_OUT) {

8199

ndr_print_struct(ndr, "out", "samr_DeleteGroupMember");

8200

ndr->depth++;

8201

ndr_print_NTSTATUS(ndr, "result", r->out.result);

8202

ndr->depth--;

8203

}

8204

ndr->depth--;

8205

}

8206

8207

static enum ndr_err_code ndr_push_samr_QueryGroupMember(struct ndr_push *ndr, int flags, const struct samr_QueryGroupMember *r)

8208

{

8209

if (flags & NDR_IN) {

8210

if (r->in.group_handle == NULL) {

8211

return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");

8212

}

8213

NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.group_handle));

8214

}

8215

if (flags & NDR_OUT) {

8216

if (r->out.rids == NULL) {

8217

return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");

8218

}

8219

NDR_CHECK(ndr_push_unique_ptr(ndr, *r->out.rids));

8220

if (*r->out.rids) {

8221

NDR_CHECK(ndr_push_samr_RidAttrArray(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.rids));

8222

}

8223

NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));

8224

}

8225

return NDR_ERR_SUCCESS;

8226

}

8227

8228

static enum ndr_err_code ndr_pull_samr_QueryGroupMember(struct ndr_pull *ndr, int flags, struct samr_QueryGroupMember *r)

8229

{

8230

uint32_t _ptr_rids;

8231

TALLOC_CTX *_mem_save_group_handle_0;

8232

TALLOC_CTX *_mem_save_rids_0;

8233

TALLOC_CTX *_mem_save_rids_1;

8234

if (flags & NDR_IN) {

8235

ZERO_STRUCT(r->out);

8236

8237

if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {

8238

NDR_PULL_ALLOC(ndr, r->in.group_handle);

8239

}

8240

_mem_save_group_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);

8241

NDR_PULL_SET_MEM_CTX(ndr, r->in.group_handle, LIBNDR_FLAG_REF_ALLOC);

8242

NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.group_handle));

8243

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_group_handle_0, LIBNDR_FLAG_REF_ALLOC);

8244

NDR_PULL_ALLOC(ndr, r->out.rids);

8245

ZERO_STRUCTP(r->out.rids);

8246

}

8247

if (flags & NDR_OUT) {

8248

if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {

8249

NDR_PULL_ALLOC(ndr, r->out.rids);

8250

}

8251

_mem_save_rids_0 = NDR_PULL_GET_MEM_CTX(ndr);

8252

NDR_PULL_SET_MEM_CTX(ndr, r->out.rids, LIBNDR_FLAG_REF_ALLOC);

8253

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_rids));

8254

if (_ptr_rids) {

8255

NDR_PULL_ALLOC(ndr, *r->out.rids);

8256

} else {

8257

*r->out.rids = NULL;

8258

}

8259

if (*r->out.rids) {

8260

_mem_save_rids_1 = NDR_PULL_GET_MEM_CTX(ndr);

8261

NDR_PULL_SET_MEM_CTX(ndr, *r->out.rids, 0);

8262

NDR_CHECK(ndr_pull_samr_RidAttrArray(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.rids));

8263

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_rids_1, 0);

8264

}

8265

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_rids_0, LIBNDR_FLAG_REF_ALLOC);

8266

NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));

8267

}

8268

return NDR_ERR_SUCCESS;

8269

}

8270

8271

_PUBLIC_ void ndr_print_samr_QueryGroupMember(struct ndr_print *ndr, const char *name, int flags, const struct samr_QueryGroupMember *r)

8272

{

8273

ndr_print_struct(ndr, name, "samr_QueryGroupMember");

8274

if (r == NULL) { ndr_print_null(ndr); return; }

8275

ndr->depth++;

8276

if (flags & NDR_SET_VALUES) {

8277

ndr->flags |= LIBNDR_PRINT_SET_VALUES;

8278

}

8279

if (flags & NDR_IN) {

8280

ndr_print_struct(ndr, "in", "samr_QueryGroupMember");

8281

ndr->depth++;

8282

ndr_print_ptr(ndr, "group_handle", r->in.group_handle);

8283

ndr->depth++;

8284

ndr_print_policy_handle(ndr, "group_handle", r->in.group_handle);

8285

ndr->depth--;

8286

ndr->depth--;

8287

}

8288

if (flags & NDR_OUT) {

8289

ndr_print_struct(ndr, "out", "samr_QueryGroupMember");

8290

ndr->depth++;

8291

ndr_print_ptr(ndr, "rids", r->out.rids);

8292

ndr->depth++;

8293

ndr_print_ptr(ndr, "rids", *r->out.rids);

8294

ndr->depth++;

8295

if (*r->out.rids) {

8296

ndr_print_samr_RidAttrArray(ndr, "rids", *r->out.rids);

8297

}

8298

ndr->depth--;

8299

ndr->depth--;

8300

ndr_print_NTSTATUS(ndr, "result", r->out.result);

8301

ndr->depth--;

8302

}

8303

ndr->depth--;

8304

}

8305

8306

static enum ndr_err_code ndr_push_samr_SetMemberAttributesOfGroup(struct ndr_push *ndr, int flags, const struct samr_SetMemberAttributesOfGroup *r)

8307

{

8308

if (flags & NDR_IN) {

8309

if (r->in.group_handle == NULL) {

8310

return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");

8311

}

8312

NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.group_handle));

8313

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.unknown1));

8314

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.unknown2));

8315

}

8316

if (flags & NDR_OUT) {

8317

NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));

8318

}

8319

return NDR_ERR_SUCCESS;

8320

}

8321

8322

static enum ndr_err_code ndr_pull_samr_SetMemberAttributesOfGroup(struct ndr_pull *ndr, int flags, struct samr_SetMemberAttributesOfGroup *r)

8323

{

8324

TALLOC_CTX *_mem_save_group_handle_0;

8325

if (flags & NDR_IN) {

8326

if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {

8327

NDR_PULL_ALLOC(ndr, r->in.group_handle);

8328

}

8329

_mem_save_group_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);

8330

NDR_PULL_SET_MEM_CTX(ndr, r->in.group_handle, LIBNDR_FLAG_REF_ALLOC);

8331

NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.group_handle));

8332

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_group_handle_0, LIBNDR_FLAG_REF_ALLOC);

8333

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.unknown1));

8334

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.unknown2));

8335

}

8336

if (flags & NDR_OUT) {

8337

NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));

8338

}

8339

return NDR_ERR_SUCCESS;

8340

}

8341

8342

_PUBLIC_ void ndr_print_samr_SetMemberAttributesOfGroup(struct ndr_print *ndr, const char *name, int flags, const struct samr_SetMemberAttributesOfGroup *r)

8343

{

8344

ndr_print_struct(ndr, name, "samr_SetMemberAttributesOfGroup");

8345

if (r == NULL) { ndr_print_null(ndr); return; }

8346

ndr->depth++;

8347

if (flags & NDR_SET_VALUES) {

8348

ndr->flags |= LIBNDR_PRINT_SET_VALUES;

8349

}

8350

if (flags & NDR_IN) {

8351

ndr_print_struct(ndr, "in", "samr_SetMemberAttributesOfGroup");

8352

ndr->depth++;

8353

ndr_print_ptr(ndr, "group_handle", r->in.group_handle);

8354

ndr->depth++;

8355

ndr_print_policy_handle(ndr, "group_handle", r->in.group_handle);

8356

ndr->depth--;

8357

ndr_print_uint32(ndr, "unknown1", r->in.unknown1);

8358

ndr_print_uint32(ndr, "unknown2", r->in.unknown2);

8359

ndr->depth--;

8360

}

8361

if (flags & NDR_OUT) {

8362

ndr_print_struct(ndr, "out", "samr_SetMemberAttributesOfGroup");

8363

ndr->depth++;

8364

ndr_print_NTSTATUS(ndr, "result", r->out.result);

8365

ndr->depth--;

8366

}

8367

ndr->depth--;

8368

}

8369

8370

static enum ndr_err_code ndr_push_samr_OpenAlias(struct ndr_push *ndr, int flags, const struct samr_OpenAlias *r)

8371

{

8372

if (flags & NDR_IN) {

8373

if (r->in.domain_handle == NULL) {

8374

return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");

8375

}

8376

NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));

8377

NDR_CHECK(ndr_push_samr_AliasAccessMask(ndr, NDR_SCALARS, r->in.access_mask));

8378

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.rid));

8379

}

8380

if (flags & NDR_OUT) {

8381

if (r->out.alias_handle == NULL) {

8382

return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");

8383

}

8384

NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.alias_handle));

8385

NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));

8386

}

8387

return NDR_ERR_SUCCESS;

8388

}

8389

8390

static enum ndr_err_code ndr_pull_samr_OpenAlias(struct ndr_pull *ndr, int flags, struct samr_OpenAlias *r)

8391

{

8392

TALLOC_CTX *_mem_save_domain_handle_0;

8393

TALLOC_CTX *_mem_save_alias_handle_0;

8394

if (flags & NDR_IN) {

8395

ZERO_STRUCT(r->out);

8396

8397

if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {

8398

NDR_PULL_ALLOC(ndr, r->in.domain_handle);

8399

}

8400

_mem_save_domain_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);

8401

NDR_PULL_SET_MEM_CTX(ndr, r->in.domain_handle, LIBNDR_FLAG_REF_ALLOC);

8402

NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));

8403

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domain_handle_0, LIBNDR_FLAG_REF_ALLOC);

8404

NDR_CHECK(ndr_pull_samr_AliasAccessMask(ndr, NDR_SCALARS, &r->in.access_mask));

8405

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.rid));

8406

NDR_PULL_ALLOC(ndr, r->out.alias_handle);

8407

ZERO_STRUCTP(r->out.alias_handle);

8408

}

8409

if (flags & NDR_OUT) {

8410

if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {

8411

NDR_PULL_ALLOC(ndr, r->out.alias_handle);

8412

}

8413

_mem_save_alias_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);

8414

NDR_PULL_SET_MEM_CTX(ndr, r->out.alias_handle, LIBNDR_FLAG_REF_ALLOC);

8415

NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.alias_handle));

8416

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_alias_handle_0, LIBNDR_FLAG_REF_ALLOC);

8417

NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));

8418

}

8419

return NDR_ERR_SUCCESS;

8420

}

8421

8422

_PUBLIC_ void ndr_print_samr_OpenAlias(struct ndr_print *ndr, const char *name, int flags, const struct samr_OpenAlias *r)

8423

{

8424

ndr_print_struct(ndr, name, "samr_OpenAlias");

8425

if (r == NULL) { ndr_print_null(ndr); return; }

8426

ndr->depth++;

8427

if (flags & NDR_SET_VALUES) {

8428

ndr->flags |= LIBNDR_PRINT_SET_VALUES;

8429

}

8430

if (flags & NDR_IN) {

8431

ndr_print_struct(ndr, "in", "samr_OpenAlias");

8432

ndr->depth++;

8433

ndr_print_ptr(ndr, "domain_handle", r->in.domain_handle);

8434

ndr->depth++;

8435

ndr_print_policy_handle(ndr, "domain_handle", r->in.domain_handle);

8436

ndr->depth--;

8437

ndr_print_samr_AliasAccessMask(ndr, "access_mask", r->in.access_mask);

8438

ndr_print_uint32(ndr, "rid", r->in.rid);

8439

ndr->depth--;

8440

}

8441

if (flags & NDR_OUT) {

8442

ndr_print_struct(ndr, "out", "samr_OpenAlias");

8443

ndr->depth++;

8444

ndr_print_ptr(ndr, "alias_handle", r->out.alias_handle);

8445

ndr->depth++;

8446

ndr_print_policy_handle(ndr, "alias_handle", r->out.alias_handle);

8447

ndr->depth--;

8448

ndr_print_NTSTATUS(ndr, "result", r->out.result);

8449

ndr->depth--;

8450

}

8451

ndr->depth--;

8452

}

8453

8454

static enum ndr_err_code ndr_push_samr_QueryAliasInfo(struct ndr_push *ndr, int flags, const struct samr_QueryAliasInfo *r)

8455

{

8456

if (flags & NDR_IN) {

8457

if (r->in.alias_handle == NULL) {

8458

return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");

8459

}

8460

NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.alias_handle));

8461

NDR_CHECK(ndr_push_samr_AliasInfoEnum(ndr, NDR_SCALARS, r->in.level));

8462

}

8463

if (flags & NDR_OUT) {

8464

if (r->out.info == NULL) {

8465

return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");

8466

}

8467

NDR_CHECK(ndr_push_unique_ptr(ndr, *r->out.info));

8468

if (*r->out.info) {

8469

NDR_CHECK(ndr_push_set_switch_value(ndr, *r->out.info, r->in.level));

8470

NDR_CHECK(ndr_push_samr_AliasInfo(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.info));

8471

}

8472

NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));

8473

}

8474

return NDR_ERR_SUCCESS;

8475

}

8476

8477

static enum ndr_err_code ndr_pull_samr_QueryAliasInfo(struct ndr_pull *ndr, int flags, struct samr_QueryAliasInfo *r)

8478

{

8479

uint32_t _ptr_info;

8480

TALLOC_CTX *_mem_save_alias_handle_0;

8481

TALLOC_CTX *_mem_save_info_0;

8482

TALLOC_CTX *_mem_save_info_1;

8483

if (flags & NDR_IN) {

8484

ZERO_STRUCT(r->out);

8485

8486

if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {

8487

NDR_PULL_ALLOC(ndr, r->in.alias_handle);

8488

}

8489

_mem_save_alias_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);

8490

NDR_PULL_SET_MEM_CTX(ndr, r->in.alias_handle, LIBNDR_FLAG_REF_ALLOC);

8491

NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.alias_handle));

8492

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_alias_handle_0, LIBNDR_FLAG_REF_ALLOC);

8493

NDR_CHECK(ndr_pull_samr_AliasInfoEnum(ndr, NDR_SCALARS, &r->in.level));

8494

NDR_PULL_ALLOC(ndr, r->out.info);

8495

ZERO_STRUCTP(r->out.info);

8496

}

8497

if (flags & NDR_OUT) {

8498

if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {

8499

NDR_PULL_ALLOC(ndr, r->out.info);

8500

}

8501

_mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);

8502

NDR_PULL_SET_MEM_CTX(ndr, r->out.info, LIBNDR_FLAG_REF_ALLOC);

8503

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));

8504

if (_ptr_info) {

8505

NDR_PULL_ALLOC(ndr, *r->out.info);

8506

} else {

8507

*r->out.info = NULL;

8508

}

8509

if (*r->out.info) {

8510

_mem_save_info_1 = NDR_PULL_GET_MEM_CTX(ndr);

8511

NDR_PULL_SET_MEM_CTX(ndr, *r->out.info, 0);

8512

NDR_CHECK(ndr_pull_set_switch_value(ndr, *r->out.info, r->in.level));

8513

NDR_CHECK(ndr_pull_samr_AliasInfo(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.info));

8514

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_1, 0);

8515

}

8516

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, LIBNDR_FLAG_REF_ALLOC);

8517

NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));

8518

}

8519

return NDR_ERR_SUCCESS;

8520

}

8521

8522

_PUBLIC_ void ndr_print_samr_QueryAliasInfo(struct ndr_print *ndr, const char *name, int flags, const struct samr_QueryAliasInfo *r)

8523

{

8524

ndr_print_struct(ndr, name, "samr_QueryAliasInfo");

8525

if (r == NULL) { ndr_print_null(ndr); return; }

8526

ndr->depth++;

8527

if (flags & NDR_SET_VALUES) {

8528

ndr->flags |= LIBNDR_PRINT_SET_VALUES;

8529

}

8530

if (flags & NDR_IN) {

8531

ndr_print_struct(ndr, "in", "samr_QueryAliasInfo");

8532

ndr->depth++;

8533

ndr_print_ptr(ndr, "alias_handle", r->in.alias_handle);

8534

ndr->depth++;

8535

ndr_print_policy_handle(ndr, "alias_handle", r->in.alias_handle);

8536

ndr->depth--;

8537

ndr_print_samr_AliasInfoEnum(ndr, "level", r->in.level);

8538

ndr->depth--;

8539

}

8540

if (flags & NDR_OUT) {

8541

ndr_print_struct(ndr, "out", "samr_QueryAliasInfo");

8542

ndr->depth++;

8543

ndr_print_ptr(ndr, "info", r->out.info);

8544

ndr->depth++;

8545

ndr_print_ptr(ndr, "info", *r->out.info);

8546

ndr->depth++;

8547

if (*r->out.info) {

8548

ndr_print_set_switch_value(ndr, *r->out.info, r->in.level);

8549

ndr_print_samr_AliasInfo(ndr, "info", *r->out.info);

8550

}

8551

ndr->depth--;

8552

ndr->depth--;

8553

ndr_print_NTSTATUS(ndr, "result", r->out.result);

8554

ndr->depth--;

8555

}

8556

ndr->depth--;

8557

}

8558

8559

static enum ndr_err_code ndr_push_samr_SetAliasInfo(struct ndr_push *ndr, int flags, const struct samr_SetAliasInfo *r)

8560

{

8561

if (flags & NDR_IN) {

8562

if (r->in.alias_handle == NULL) {

8563

return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");

8564

}

8565

NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.alias_handle));

8566

NDR_CHECK(ndr_push_samr_AliasInfoEnum(ndr, NDR_SCALARS, r->in.level));

8567

if (r->in.info == NULL) {

8568

return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");

8569

}

8570

NDR_CHECK(ndr_push_set_switch_value(ndr, r->in.info, r->in.level));

8571

NDR_CHECK(ndr_push_samr_AliasInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info));

8572

}

8573

if (flags & NDR_OUT) {

8574

NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));

8575

}

8576

return NDR_ERR_SUCCESS;

8577

}

8578

8579

static enum ndr_err_code ndr_pull_samr_SetAliasInfo(struct ndr_pull *ndr, int flags, struct samr_SetAliasInfo *r)

8580

{

8581

TALLOC_CTX *_mem_save_alias_handle_0;

8582

TALLOC_CTX *_mem_save_info_0;

8583

if (flags & NDR_IN) {

8584

if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {

8585

NDR_PULL_ALLOC(ndr, r->in.alias_handle);

8586

}

8587

_mem_save_alias_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);

8588

NDR_PULL_SET_MEM_CTX(ndr, r->in.alias_handle, LIBNDR_FLAG_REF_ALLOC);

8589

NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.alias_handle));

8590

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_alias_handle_0, LIBNDR_FLAG_REF_ALLOC);

8591

NDR_CHECK(ndr_pull_samr_AliasInfoEnum(ndr, NDR_SCALARS, &r->in.level));

8592

if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {

8593

NDR_PULL_ALLOC(ndr, r->in.info);

8594

}

8595

_mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);

8596

NDR_PULL_SET_MEM_CTX(ndr, r->in.info, LIBNDR_FLAG_REF_ALLOC);

8597

NDR_CHECK(ndr_pull_set_switch_value(ndr, r->in.info, r->in.level));

8598

NDR_CHECK(ndr_pull_samr_AliasInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info));

8599

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, LIBNDR_FLAG_REF_ALLOC);

8600

}

8601

if (flags & NDR_OUT) {

8602

NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));

8603

}

8604

return NDR_ERR_SUCCESS;

8605

}

8606

8607

_PUBLIC_ void ndr_print_samr_SetAliasInfo(struct ndr_print *ndr, const char *name, int flags, const struct samr_SetAliasInfo *r)

8608

{

8609

ndr_print_struct(ndr, name, "samr_SetAliasInfo");

8610

if (r == NULL) { ndr_print_null(ndr); return; }

8611

ndr->depth++;

8612

if (flags & NDR_SET_VALUES) {

8613

ndr->flags |= LIBNDR_PRINT_SET_VALUES;

8614

}

8615

if (flags & NDR_IN) {

8616

ndr_print_struct(ndr, "in", "samr_SetAliasInfo");

8617

ndr->depth++;

8618

ndr_print_ptr(ndr, "alias_handle", r->in.alias_handle);

8619

ndr->depth++;

8620

ndr_print_policy_handle(ndr, "alias_handle", r->in.alias_handle);

8621

ndr->depth--;

8622

ndr_print_samr_AliasInfoEnum(ndr, "level", r->in.level);

8623

ndr_print_ptr(ndr, "info", r->in.info);

8624

ndr->depth++;

8625

ndr_print_set_switch_value(ndr, r->in.info, r->in.level);

8626

ndr_print_samr_AliasInfo(ndr, "info", r->in.info);

8627

ndr->depth--;

8628

ndr->depth--;

8629

}

8630

if (flags & NDR_OUT) {

8631

ndr_print_struct(ndr, "out", "samr_SetAliasInfo");

8632

ndr->depth++;

8633

ndr_print_NTSTATUS(ndr, "result", r->out.result);

8634

ndr->depth--;

8635

}

8636

ndr->depth--;

8637

}

8638

8639

static enum ndr_err_code ndr_push_samr_DeleteDomAlias(struct ndr_push *ndr, int flags, const struct samr_DeleteDomAlias *r)

8640

{

8641

if (flags & NDR_IN) {

8642

if (r->in.alias_handle == NULL) {

8643

return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");

8644

}

8645

NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.alias_handle));

8646

}

8647

if (flags & NDR_OUT) {

8648

if (r->out.alias_handle == NULL) {

8649

return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");

8650

}

8651

NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.alias_handle));

8652

NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));

8653

}

8654

return NDR_ERR_SUCCESS;

8655

}

8656

8657

static enum ndr_err_code ndr_pull_samr_DeleteDomAlias(struct ndr_pull *ndr, int flags, struct samr_DeleteDomAlias *r)

8658

{

8659

TALLOC_CTX *_mem_save_alias_handle_0;

8660

if (flags & NDR_IN) {

8661

ZERO_STRUCT(r->out);

8662

8663

if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {

8664

NDR_PULL_ALLOC(ndr, r->in.alias_handle);

8665

}

8666

_mem_save_alias_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);

8667

NDR_PULL_SET_MEM_CTX(ndr, r->in.alias_handle, LIBNDR_FLAG_REF_ALLOC);

8668

NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.alias_handle));

8669

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_alias_handle_0, LIBNDR_FLAG_REF_ALLOC);

8670

NDR_PULL_ALLOC(ndr, r->out.alias_handle);

8671

*r->out.alias_handle = *r->in.alias_handle;

8672

}

8673

if (flags & NDR_OUT) {

8674

if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {

8675

NDR_PULL_ALLOC(ndr, r->out.alias_handle);

8676

}

8677

_mem_save_alias_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);

8678

NDR_PULL_SET_MEM_CTX(ndr, r->out.alias_handle, LIBNDR_FLAG_REF_ALLOC);

8679

NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.alias_handle));

8680

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_alias_handle_0, LIBNDR_FLAG_REF_ALLOC);

8681

NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));

8682

}

8683

return NDR_ERR_SUCCESS;

8684

}

8685

8686

_PUBLIC_ void ndr_print_samr_DeleteDomAlias(struct ndr_print *ndr, const char *name, int flags, const struct samr_DeleteDomAlias *r)

8687

{

8688

ndr_print_struct(ndr, name, "samr_DeleteDomAlias");

8689

if (r == NULL) { ndr_print_null(ndr); return; }

8690

ndr->depth++;

8691

if (flags & NDR_SET_VALUES) {

8692

ndr->flags |= LIBNDR_PRINT_SET_VALUES;

8693

}

8694

if (flags & NDR_IN) {

8695

ndr_print_struct(ndr, "in", "samr_DeleteDomAlias");

8696

ndr->depth++;

8697

ndr_print_ptr(ndr, "alias_handle", r->in.alias_handle);

8698

ndr->depth++;

8699

ndr_print_policy_handle(ndr, "alias_handle", r->in.alias_handle);

8700

ndr->depth--;

8701

ndr->depth--;

8702

}

8703

if (flags & NDR_OUT) {

8704

ndr_print_struct(ndr, "out", "samr_DeleteDomAlias");

8705

ndr->depth++;

8706

ndr_print_ptr(ndr, "alias_handle", r->out.alias_handle);

8707

ndr->depth++;

8708

ndr_print_policy_handle(ndr, "alias_handle", r->out.alias_handle);

8709

ndr->depth--;

8710

ndr_print_NTSTATUS(ndr, "result", r->out.result);

8711

ndr->depth--;

8712

}

8713

ndr->depth--;

8714

}

8715

8716

static enum ndr_err_code ndr_push_samr_AddAliasMember(struct ndr_push *ndr, int flags, const struct samr_AddAliasMember *r)

8717

{

8718

if (flags & NDR_IN) {

8719

if (r->in.alias_handle == NULL) {

8720

return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");

8721

}

8722

NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.alias_handle));

8723

if (r->in.sid == NULL) {

8724

return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");

8725

}

8726

NDR_CHECK(ndr_push_dom_sid2(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.sid));

8727

}

8728

if (flags & NDR_OUT) {

8729

NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));

8730

}

8731

return NDR_ERR_SUCCESS;

8732

}

8733

8734

static enum ndr_err_code ndr_pull_samr_AddAliasMember(struct ndr_pull *ndr, int flags, struct samr_AddAliasMember *r)

8735

{

8736

TALLOC_CTX *_mem_save_alias_handle_0;

8737

TALLOC_CTX *_mem_save_sid_0;

8738

if (flags & NDR_IN) {

8739

if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {

8740

NDR_PULL_ALLOC(ndr, r->in.alias_handle);

8741

}

8742

_mem_save_alias_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);

8743

NDR_PULL_SET_MEM_CTX(ndr, r->in.alias_handle, LIBNDR_FLAG_REF_ALLOC);

8744

NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.alias_handle));

8745

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_alias_handle_0, LIBNDR_FLAG_REF_ALLOC);

8746

if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {

8747

NDR_PULL_ALLOC(ndr, r->in.sid);

8748

}

8749

_mem_save_sid_0 = NDR_PULL_GET_MEM_CTX(ndr);

8750

NDR_PULL_SET_MEM_CTX(ndr, r->in.sid, LIBNDR_FLAG_REF_ALLOC);

8751

NDR_CHECK(ndr_pull_dom_sid2(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.sid));

8752

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sid_0, LIBNDR_FLAG_REF_ALLOC);

8753

}

8754

if (flags & NDR_OUT) {

8755

NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));

8756

}

8757

return NDR_ERR_SUCCESS;

8758

}

8759

8760

_PUBLIC_ void ndr_print_samr_AddAliasMember(struct ndr_print *ndr, const char *name, int flags, const struct samr_AddAliasMember *r)

8761

{

8762

ndr_print_struct(ndr, name, "samr_AddAliasMember");

8763

if (r == NULL) { ndr_print_null(ndr); return; }

8764

ndr->depth++;

8765

if (flags & NDR_SET_VALUES) {

8766

ndr->flags |= LIBNDR_PRINT_SET_VALUES;

8767

}

8768

if (flags & NDR_IN) {

8769

ndr_print_struct(ndr, "in", "samr_AddAliasMember");

8770

ndr->depth++;

8771

ndr_print_ptr(ndr, "alias_handle", r->in.alias_handle);

8772

ndr->depth++;

8773

ndr_print_policy_handle(ndr, "alias_handle", r->in.alias_handle);

8774

ndr->depth--;

8775

ndr_print_ptr(ndr, "sid", r->in.sid);

8776

ndr->depth++;

8777

ndr_print_dom_sid2(ndr, "sid", r->in.sid);

8778

ndr->depth--;

8779

ndr->depth--;

8780

}

8781

if (flags & NDR_OUT) {

8782

ndr_print_struct(ndr, "out", "samr_AddAliasMember");

8783

ndr->depth++;

8784

ndr_print_NTSTATUS(ndr, "result", r->out.result);

8785

ndr->depth--;

8786

}

8787

ndr->depth--;

8788

}

8789

8790

static enum ndr_err_code ndr_push_samr_DeleteAliasMember(struct ndr_push *ndr, int flags, const struct samr_DeleteAliasMember *r)

8791

{

8792

if (flags & NDR_IN) {

8793

if (r->in.alias_handle == NULL) {

8794

return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");

8795

}

8796

NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.alias_handle));

8797

if (r->in.sid == NULL) {

8798

return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");

8799

}

8800

NDR_CHECK(ndr_push_dom_sid2(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.sid));

8801

}

8802

if (flags & NDR_OUT) {

8803

NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));

8804

}

8805

return NDR_ERR_SUCCESS;

8806

}

8807

8808

static enum ndr_err_code ndr_pull_samr_DeleteAliasMember(struct ndr_pull *ndr, int flags, struct samr_DeleteAliasMember *r)

8809

{

8810

TALLOC_CTX *_mem_save_alias_handle_0;

8811

TALLOC_CTX *_mem_save_sid_0;

8812

if (flags & NDR_IN) {

8813

if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {

8814

NDR_PULL_ALLOC(ndr, r->in.alias_handle);

8815

}

8816

_mem_save_alias_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);

8817

NDR_PULL_SET_MEM_CTX(ndr, r->in.alias_handle, LIBNDR_FLAG_REF_ALLOC);

8818

NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.alias_handle));

8819

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_alias_handle_0, LIBNDR_FLAG_REF_ALLOC);

8820

if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {

8821

NDR_PULL_ALLOC(ndr, r->in.sid);

8822

}

8823

_mem_save_sid_0 = NDR_PULL_GET_MEM_CTX(ndr);

8824

NDR_PULL_SET_MEM_CTX(ndr, r->in.sid, LIBNDR_FLAG_REF_ALLOC);

8825

NDR_CHECK(ndr_pull_dom_sid2(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.sid));

8826

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sid_0, LIBNDR_FLAG_REF_ALLOC);

8827

}

8828

if (flags & NDR_OUT) {

8829

NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));

8830

}

8831

return NDR_ERR_SUCCESS;

8832

}

8833

8834

_PUBLIC_ void ndr_print_samr_DeleteAliasMember(struct ndr_print *ndr, const char *name, int flags, const struct samr_DeleteAliasMember *r)

8835

{

8836

ndr_print_struct(ndr, name, "samr_DeleteAliasMember");

8837

if (r == NULL) { ndr_print_null(ndr); return; }

8838

ndr->depth++;

8839

if (flags & NDR_SET_VALUES) {

8840

ndr->flags |= LIBNDR_PRINT_SET_VALUES;

8841

}

8842

if (flags & NDR_IN) {

8843

ndr_print_struct(ndr, "in", "samr_DeleteAliasMember");

8844

ndr->depth++;

8845

ndr_print_ptr(ndr, "alias_handle", r->in.alias_handle);

8846

ndr->depth++;

8847

ndr_print_policy_handle(ndr, "alias_handle", r->in.alias_handle);

8848

ndr->depth--;

8849

ndr_print_ptr(ndr, "sid", r->in.sid);

8850

ndr->depth++;

8851

ndr_print_dom_sid2(ndr, "sid", r->in.sid);

8852

ndr->depth--;

8853

ndr->depth--;

8854

}

8855

if (flags & NDR_OUT) {

8856

ndr_print_struct(ndr, "out", "samr_DeleteAliasMember");

8857

ndr->depth++;

8858

ndr_print_NTSTATUS(ndr, "result", r->out.result);

8859

ndr->depth--;

8860

}

8861

ndr->depth--;

8862

}

8863

8864

static enum ndr_err_code ndr_push_samr_GetMembersInAlias(struct ndr_push *ndr, int flags, const struct samr_GetMembersInAlias *r)

8865

{

8866

if (flags & NDR_IN) {

8867

if (r->in.alias_handle == NULL) {

8868

return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");

8869

}

8870

NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.alias_handle));

8871

}

8872

if (flags & NDR_OUT) {

8873

if (r->out.sids == NULL) {

8874

return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");

8875

}

8876

NDR_CHECK(ndr_push_lsa_SidArray(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.sids));

8877

NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));

8878

}

8879

return NDR_ERR_SUCCESS;

8880

}

8881

8882

static enum ndr_err_code ndr_pull_samr_GetMembersInAlias(struct ndr_pull *ndr, int flags, struct samr_GetMembersInAlias *r)

8883

{

8884

TALLOC_CTX *_mem_save_alias_handle_0;

8885

TALLOC_CTX *_mem_save_sids_0;

8886

if (flags & NDR_IN) {

8887

ZERO_STRUCT(r->out);

8888

8889

if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {

8890

NDR_PULL_ALLOC(ndr, r->in.alias_handle);

8891

}

8892

_mem_save_alias_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);

8893

NDR_PULL_SET_MEM_CTX(ndr, r->in.alias_handle, LIBNDR_FLAG_REF_ALLOC);

8894

NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.alias_handle));

8895

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_alias_handle_0, LIBNDR_FLAG_REF_ALLOC);

8896

NDR_PULL_ALLOC(ndr, r->out.sids);

8897

ZERO_STRUCTP(r->out.sids);

8898

}

8899

if (flags & NDR_OUT) {

8900

if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {

8901

NDR_PULL_ALLOC(ndr, r->out.sids);

8902

}

8903

_mem_save_sids_0 = NDR_PULL_GET_MEM_CTX(ndr);

8904

NDR_PULL_SET_MEM_CTX(ndr, r->out.sids, LIBNDR_FLAG_REF_ALLOC);

8905

NDR_CHECK(ndr_pull_lsa_SidArray(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.sids));

8906

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sids_0, LIBNDR_FLAG_REF_ALLOC);

8907

NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));

8908

}

8909

return NDR_ERR_SUCCESS;

8910

}

8911

8912

_PUBLIC_ void ndr_print_samr_GetMembersInAlias(struct ndr_print *ndr, const char *name, int flags, const struct samr_GetMembersInAlias *r)

8913

{

8914

ndr_print_struct(ndr, name, "samr_GetMembersInAlias");

8915

if (r == NULL) { ndr_print_null(ndr); return; }

8916

ndr->depth++;

8917

if (flags & NDR_SET_VALUES) {

8918

ndr->flags |= LIBNDR_PRINT_SET_VALUES;

8919

}

8920

if (flags & NDR_IN) {

8921

ndr_print_struct(ndr, "in", "samr_GetMembersInAlias");

8922

ndr->depth++;

8923

ndr_print_ptr(ndr, "alias_handle", r->in.alias_handle);

8924

ndr->depth++;

8925

ndr_print_policy_handle(ndr, "alias_handle", r->in.alias_handle);

8926

ndr->depth--;

8927

ndr->depth--;

8928

}

8929

if (flags & NDR_OUT) {

8930

ndr_print_struct(ndr, "out", "samr_GetMembersInAlias");

8931

ndr->depth++;

8932

ndr_print_ptr(ndr, "sids", r->out.sids);

8933

ndr->depth++;

8934

ndr_print_lsa_SidArray(ndr, "sids", r->out.sids);

8935

ndr->depth--;

8936

ndr_print_NTSTATUS(ndr, "result", r->out.result);

8937

ndr->depth--;

8938

}

8939

ndr->depth--;

8940

}

8941

8942

_PUBLIC_ enum ndr_err_code ndr_push_samr_OpenUser(struct ndr_push *ndr, int flags, const struct samr_OpenUser *r)

8943

{

8944

if (flags & NDR_IN) {

8945

if (r->in.domain_handle == NULL) {

8946

return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");

8947

}

8948

NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));

8949

NDR_CHECK(ndr_push_samr_UserAccessMask(ndr, NDR_SCALARS, r->in.access_mask));

8950

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.rid));

8951

}

8952

if (flags & NDR_OUT) {

8953

if (r->out.user_handle == NULL) {

8954

return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");

8955

}

8956

NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.user_handle));

8957

NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));

8958

}

8959

return NDR_ERR_SUCCESS;

8960

}

8961

8962

_PUBLIC_ enum ndr_err_code ndr_pull_samr_OpenUser(struct ndr_pull *ndr, int flags, struct samr_OpenUser *r)

8963

{

8964

TALLOC_CTX *_mem_save_domain_handle_0;

8965

TALLOC_CTX *_mem_save_user_handle_0;

8966

if (flags & NDR_IN) {

8967

ZERO_STRUCT(r->out);

8968

8969

if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {

8970

NDR_PULL_ALLOC(ndr, r->in.domain_handle);

8971

}

8972

_mem_save_domain_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);

8973

NDR_PULL_SET_MEM_CTX(ndr, r->in.domain_handle, LIBNDR_FLAG_REF_ALLOC);

8974

NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));

8975

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domain_handle_0, LIBNDR_FLAG_REF_ALLOC);

8976

NDR_CHECK(ndr_pull_samr_UserAccessMask(ndr, NDR_SCALARS, &r->in.access_mask));

8977

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.rid));

8978

NDR_PULL_ALLOC(ndr, r->out.user_handle);

8979

ZERO_STRUCTP(r->out.user_handle);

8980

}

8981

if (flags & NDR_OUT) {

8982

if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {

8983

NDR_PULL_ALLOC(ndr, r->out.user_handle);

8984

}

8985

_mem_save_user_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);

8986

NDR_PULL_SET_MEM_CTX(ndr, r->out.user_handle, LIBNDR_FLAG_REF_ALLOC);

8987

NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.user_handle));

8988

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_handle_0, LIBNDR_FLAG_REF_ALLOC);

8989

NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));

8990

}

8991

return NDR_ERR_SUCCESS;

8992

}

8993

8994

_PUBLIC_ void ndr_print_samr_OpenUser(struct ndr_print *ndr, const char *name, int flags, const struct samr_OpenUser *r)

8995

{

8996

ndr_print_struct(ndr, name, "samr_OpenUser");

8997

if (r == NULL) { ndr_print_null(ndr); return; }

8998

ndr->depth++;

8999

if (flags & NDR_SET_VALUES) {

9000

ndr->flags |= LIBNDR_PRINT_SET_VALUES;

9001

}

9002

if (flags & NDR_IN) {

9003

ndr_print_struct(ndr, "in", "samr_OpenUser");

9004

ndr->depth++;

9005

ndr_print_ptr(ndr, "domain_handle", r->in.domain_handle);

9006

ndr->depth++;

9007

ndr_print_policy_handle(ndr, "domain_handle", r->in.domain_handle);

9008

ndr->depth--;

9009

ndr_print_samr_UserAccessMask(ndr, "access_mask", r->in.access_mask);

9010

ndr_print_uint32(ndr, "rid", r->in.rid);

9011

ndr->depth--;

9012

}

9013

if (flags & NDR_OUT) {

9014

ndr_print_struct(ndr, "out", "samr_OpenUser");

9015

ndr->depth++;

9016

ndr_print_ptr(ndr, "user_handle", r->out.user_handle);

9017

ndr->depth++;

9018

ndr_print_policy_handle(ndr, "user_handle", r->out.user_handle);

9019

ndr->depth--;

9020

ndr_print_NTSTATUS(ndr, "result", r->out.result);

9021

ndr->depth--;

9022

}

9023

ndr->depth--;

9024

}

9025

9026

static enum ndr_err_code ndr_push_samr_DeleteUser(struct ndr_push *ndr, int flags, const struct samr_DeleteUser *r)

9027

{

9028

if (flags & NDR_IN) {

9029

if (r->in.user_handle == NULL) {

9030

return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");

9031

}

9032

NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.user_handle));

9033

}

9034

if (flags & NDR_OUT) {

9035

if (r->out.user_handle == NULL) {

9036

return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");

9037

}

9038

NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.user_handle));

9039

NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));

9040

}

9041

return NDR_ERR_SUCCESS;

9042

}

9043

9044

static enum ndr_err_code ndr_pull_samr_DeleteUser(struct ndr_pull *ndr, int flags, struct samr_DeleteUser *r)

9045

{

9046

TALLOC_CTX *_mem_save_user_handle_0;

9047

if (flags & NDR_IN) {

9048

ZERO_STRUCT(r->out);

9049

9050

if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {

9051

NDR_PULL_ALLOC(ndr, r->in.user_handle);

9052

}

9053

_mem_save_user_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);

9054

NDR_PULL_SET_MEM_CTX(ndr, r->in.user_handle, LIBNDR_FLAG_REF_ALLOC);

9055

NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.user_handle));

9056

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_handle_0, LIBNDR_FLAG_REF_ALLOC);

9057

NDR_PULL_ALLOC(ndr, r->out.user_handle);

9058

*r->out.user_handle = *r->in.user_handle;

9059

}

9060

if (flags & NDR_OUT) {

9061

if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {

9062

NDR_PULL_ALLOC(ndr, r->out.user_handle);

9063

}

9064

_mem_save_user_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);

9065

NDR_PULL_SET_MEM_CTX(ndr, r->out.user_handle, LIBNDR_FLAG_REF_ALLOC);

9066

NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.user_handle));

9067

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_handle_0, LIBNDR_FLAG_REF_ALLOC);

9068

NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));

9069

}

9070

return NDR_ERR_SUCCESS;

9071

}

9072

9073

_PUBLIC_ void ndr_print_samr_DeleteUser(struct ndr_print *ndr, const char *name, int flags, const struct samr_DeleteUser *r)

9074

{

9075

ndr_print_struct(ndr, name, "samr_DeleteUser");

9076

if (r == NULL) { ndr_print_null(ndr); return; }

9077

ndr->depth++;

9078

if (flags & NDR_SET_VALUES) {

9079

ndr->flags |= LIBNDR_PRINT_SET_VALUES;

9080

}

9081

if (flags & NDR_IN) {

9082

ndr_print_struct(ndr, "in", "samr_DeleteUser");

9083

ndr->depth++;

9084

ndr_print_ptr(ndr, "user_handle", r->in.user_handle);

9085

ndr->depth++;

9086

ndr_print_policy_handle(ndr, "user_handle", r->in.user_handle);

9087

ndr->depth--;

9088

ndr->depth--;

9089

}

9090

if (flags & NDR_OUT) {

9091

ndr_print_struct(ndr, "out", "samr_DeleteUser");

9092

ndr->depth++;

9093

ndr_print_ptr(ndr, "user_handle", r->out.user_handle);

9094

ndr->depth++;

9095

ndr_print_policy_handle(ndr, "user_handle", r->out.user_handle);

9096

ndr->depth--;

9097

ndr_print_NTSTATUS(ndr, "result", r->out.result);

9098

ndr->depth--;

9099

}

9100

ndr->depth--;

9101

}

9102

9103

_PUBLIC_ enum ndr_err_code ndr_push_samr_QueryUserInfo(struct ndr_push *ndr, int flags, const struct samr_QueryUserInfo *r)

9104

{

9105

if (flags & NDR_IN) {

9106

if (r->in.user_handle == NULL) {

9107

return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");

9108

}

9109

NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.user_handle));

9110

NDR_CHECK(ndr_push_samr_UserInfoLevel(ndr, NDR_SCALARS, r->in.level));

9111

}

9112

if (flags & NDR_OUT) {

9113

if (r->out.info == NULL) {

9114

return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");

9115

}

9116

NDR_CHECK(ndr_push_unique_ptr(ndr, *r->out.info));

9117

if (*r->out.info) {

9118

NDR_CHECK(ndr_push_set_switch_value(ndr, *r->out.info, r->in.level));

9119

NDR_CHECK(ndr_push_samr_UserInfo(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.info));

9120

}

9121

NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));

9122

}

9123

return NDR_ERR_SUCCESS;

9124

}

9125

9126

_PUBLIC_ enum ndr_err_code ndr_pull_samr_QueryUserInfo(struct ndr_pull *ndr, int flags, struct samr_QueryUserInfo *r)

9127

{

9128

uint32_t _ptr_info;

9129

TALLOC_CTX *_mem_save_user_handle_0;

9130

TALLOC_CTX *_mem_save_info_0;

9131

TALLOC_CTX *_mem_save_info_1;

9132

if (flags & NDR_IN) {

9133

ZERO_STRUCT(r->out);

9134

9135

if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {

9136

NDR_PULL_ALLOC(ndr, r->in.user_handle);

9137

}

9138

_mem_save_user_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);

9139

NDR_PULL_SET_MEM_CTX(ndr, r->in.user_handle, LIBNDR_FLAG_REF_ALLOC);

9140

NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.user_handle));

9141

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_handle_0, LIBNDR_FLAG_REF_ALLOC);

9142

NDR_CHECK(ndr_pull_samr_UserInfoLevel(ndr, NDR_SCALARS, &r->in.level));

9143

NDR_PULL_ALLOC(ndr, r->out.info);

9144

ZERO_STRUCTP(r->out.info);

9145

}

9146

if (flags & NDR_OUT) {

9147

if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {

9148

NDR_PULL_ALLOC(ndr, r->out.info);

9149

}

9150

_mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);

9151

NDR_PULL_SET_MEM_CTX(ndr, r->out.info, LIBNDR_FLAG_REF_ALLOC);

9152

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));

9153

if (_ptr_info) {

9154

NDR_PULL_ALLOC(ndr, *r->out.info);

9155

} else {

9156

*r->out.info = NULL;

9157

}

9158

if (*r->out.info) {

9159

_mem_save_info_1 = NDR_PULL_GET_MEM_CTX(ndr);

9160

NDR_PULL_SET_MEM_CTX(ndr, *r->out.info, 0);

9161

NDR_CHECK(ndr_pull_set_switch_value(ndr, *r->out.info, r->in.level));

9162

NDR_CHECK(ndr_pull_samr_UserInfo(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.info));

9163

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_1, 0);

9164

}

9165

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, LIBNDR_FLAG_REF_ALLOC);

9166

NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));

9167

}

9168

return NDR_ERR_SUCCESS;

9169

}

9170

9171

_PUBLIC_ void ndr_print_samr_QueryUserInfo(struct ndr_print *ndr, const char *name, int flags, const struct samr_QueryUserInfo *r)

9172

{

9173

ndr_print_struct(ndr, name, "samr_QueryUserInfo");

9174

if (r == NULL) { ndr_print_null(ndr); return; }

9175

ndr->depth++;

9176

if (flags & NDR_SET_VALUES) {

9177

ndr->flags |= LIBNDR_PRINT_SET_VALUES;

9178

}

9179

if (flags & NDR_IN) {

9180

ndr_print_struct(ndr, "in", "samr_QueryUserInfo");

9181

ndr->depth++;

9182

ndr_print_ptr(ndr, "user_handle", r->in.user_handle);

9183

ndr->depth++;

9184

ndr_print_policy_handle(ndr, "user_handle", r->in.user_handle);

9185

ndr->depth--;

9186

ndr_print_samr_UserInfoLevel(ndr, "level", r->in.level);

9187

ndr->depth--;

9188

}

9189

if (flags & NDR_OUT) {

9190

ndr_print_struct(ndr, "out", "samr_QueryUserInfo");

9191

ndr->depth++;

9192

ndr_print_ptr(ndr, "info", r->out.info);

9193

ndr->depth++;

9194

ndr_print_ptr(ndr, "info", *r->out.info);

9195

ndr->depth++;

9196

if (*r->out.info) {

9197

ndr_print_set_switch_value(ndr, *r->out.info, r->in.level);

9198

ndr_print_samr_UserInfo(ndr, "info", *r->out.info);

9199

}

9200

ndr->depth--;

9201

ndr->depth--;

9202

ndr_print_NTSTATUS(ndr, "result", r->out.result);

9203

ndr->depth--;

9204

}

9205

ndr->depth--;

9206

}

9207

9208

_PUBLIC_ enum ndr_err_code ndr_push_samr_SetUserInfo(struct ndr_push *ndr, int flags, const struct samr_SetUserInfo *r)

9209

{

9210

if (flags & NDR_IN) {

9211

if (r->in.user_handle == NULL) {

9212

return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");

9213

}

9214

NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.user_handle));

9215

NDR_CHECK(ndr_push_samr_UserInfoLevel(ndr, NDR_SCALARS, r->in.level));

9216

if (r->in.info == NULL) {

9217

return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");

9218

}

9219

NDR_CHECK(ndr_push_set_switch_value(ndr, r->in.info, r->in.level));

9220

NDR_CHECK(ndr_push_samr_UserInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info));

9221

}

9222

if (flags & NDR_OUT) {

9223

NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));

9224

}

9225

return NDR_ERR_SUCCESS;

9226

}

9227

9228

_PUBLIC_ enum ndr_err_code ndr_pull_samr_SetUserInfo(struct ndr_pull *ndr, int flags, struct samr_SetUserInfo *r)

9229

{

9230

TALLOC_CTX *_mem_save_user_handle_0;

9231

TALLOC_CTX *_mem_save_info_0;

9232

if (flags & NDR_IN) {

9233

if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {

9234

NDR_PULL_ALLOC(ndr, r->in.user_handle);

9235

}

9236

_mem_save_user_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);

9237

NDR_PULL_SET_MEM_CTX(ndr, r->in.user_handle, LIBNDR_FLAG_REF_ALLOC);

9238

NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.user_handle));

9239

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_handle_0, LIBNDR_FLAG_REF_ALLOC);

9240

NDR_CHECK(ndr_pull_samr_UserInfoLevel(ndr, NDR_SCALARS, &r->in.level));

9241

if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {

9242

NDR_PULL_ALLOC(ndr, r->in.info);

9243

}

9244

_mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);

9245

NDR_PULL_SET_MEM_CTX(ndr, r->in.info, LIBNDR_FLAG_REF_ALLOC);

9246

NDR_CHECK(ndr_pull_set_switch_value(ndr, r->in.info, r->in.level));

9247

NDR_CHECK(ndr_pull_samr_UserInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info));

9248

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, LIBNDR_FLAG_REF_ALLOC);

9249

}

9250

if (flags & NDR_OUT) {

9251

NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));

9252

}

9253

return NDR_ERR_SUCCESS;

9254

}

9255

9256

_PUBLIC_ void ndr_print_samr_SetUserInfo(struct ndr_print *ndr, const char *name, int flags, const struct samr_SetUserInfo *r)

9257

{

9258

ndr_print_struct(ndr, name, "samr_SetUserInfo");

9259

if (r == NULL) { ndr_print_null(ndr); return; }

9260

ndr->depth++;

9261

if (flags & NDR_SET_VALUES) {

9262

ndr->flags |= LIBNDR_PRINT_SET_VALUES;

9263

}

9264

if (flags & NDR_IN) {

9265

ndr_print_struct(ndr, "in", "samr_SetUserInfo");

9266

ndr->depth++;

9267

ndr_print_ptr(ndr, "user_handle", r->in.user_handle);

9268

ndr->depth++;

9269

ndr_print_policy_handle(ndr, "user_handle", r->in.user_handle);

9270

ndr->depth--;

9271

ndr_print_samr_UserInfoLevel(ndr, "level", r->in.level);

9272

ndr_print_ptr(ndr, "info", r->in.info);

9273

ndr->depth++;

9274

ndr_print_set_switch_value(ndr, r->in.info, r->in.level);

9275

ndr_print_samr_UserInfo(ndr, "info", r->in.info);

9276

ndr->depth--;

9277

ndr->depth--;

9278

}

9279

if (flags & NDR_OUT) {

9280

ndr_print_struct(ndr, "out", "samr_SetUserInfo");

9281

ndr->depth++;

9282

ndr_print_NTSTATUS(ndr, "result", r->out.result);

9283

ndr->depth--;

9284

}

9285

ndr->depth--;

9286

}

9287

9288

static enum ndr_err_code ndr_push_samr_ChangePasswordUser(struct ndr_push *ndr, int flags, const struct samr_ChangePasswordUser *r)

9289

{

9290

if (flags & NDR_IN) {

9291

if (r->in.user_handle == NULL) {

9292

return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");

9293

}

9294

NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.user_handle));

9295

NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->in.lm_present));

9296

NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.old_lm_crypted));

9297

if (r->in.old_lm_crypted) {

9298

NDR_CHECK(ndr_push_samr_Password(ndr, NDR_SCALARS, r->in.old_lm_crypted));

9299

}

9300

NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.new_lm_crypted));

9301

if (r->in.new_lm_crypted) {

9302

NDR_CHECK(ndr_push_samr_Password(ndr, NDR_SCALARS, r->in.new_lm_crypted));

9303

}

9304

NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->in.nt_present));

9305

NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.old_nt_crypted));

9306

if (r->in.old_nt_crypted) {

9307

NDR_CHECK(ndr_push_samr_Password(ndr, NDR_SCALARS, r->in.old_nt_crypted));

9308

}

9309

NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.new_nt_crypted));

9310

if (r->in.new_nt_crypted) {

9311

NDR_CHECK(ndr_push_samr_Password(ndr, NDR_SCALARS, r->in.new_nt_crypted));

9312

}

9313

NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->in.cross1_present));

9314

NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.nt_cross));

9315

if (r->in.nt_cross) {

9316

NDR_CHECK(ndr_push_samr_Password(ndr, NDR_SCALARS, r->in.nt_cross));

9317

}

9318

NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->in.cross2_present));

9319

NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.lm_cross));

9320

if (r->in.lm_cross) {

9321

NDR_CHECK(ndr_push_samr_Password(ndr, NDR_SCALARS, r->in.lm_cross));

9322

}

9323

}

9324

if (flags & NDR_OUT) {

9325

NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));

9326

}

9327

return NDR_ERR_SUCCESS;

9328

}

9329

9330

static enum ndr_err_code ndr_pull_samr_ChangePasswordUser(struct ndr_pull *ndr, int flags, struct samr_ChangePasswordUser *r)

9331

{

9332

uint32_t _ptr_old_lm_crypted;

9333

uint32_t _ptr_new_lm_crypted;

9334

uint32_t _ptr_old_nt_crypted;

9335

uint32_t _ptr_new_nt_crypted;

9336

uint32_t _ptr_nt_cross;

9337

uint32_t _ptr_lm_cross;

9338

TALLOC_CTX *_mem_save_user_handle_0;

9339

TALLOC_CTX *_mem_save_old_lm_crypted_0;

9340

TALLOC_CTX *_mem_save_new_lm_crypted_0;

9341

TALLOC_CTX *_mem_save_old_nt_crypted_0;

9342

TALLOC_CTX *_mem_save_new_nt_crypted_0;

9343

TALLOC_CTX *_mem_save_nt_cross_0;

9344

TALLOC_CTX *_mem_save_lm_cross_0;

9345

if (flags & NDR_IN) {

9346

if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {

9347

NDR_PULL_ALLOC(ndr, r->in.user_handle);

9348

}

9349

_mem_save_user_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);

9350

NDR_PULL_SET_MEM_CTX(ndr, r->in.user_handle, LIBNDR_FLAG_REF_ALLOC);

9351

NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.user_handle));

9352

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_handle_0, LIBNDR_FLAG_REF_ALLOC);

9353

NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->in.lm_present));

9354

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_old_lm_crypted));

9355

if (_ptr_old_lm_crypted) {

9356

NDR_PULL_ALLOC(ndr, r->in.old_lm_crypted);

9357

} else {

9358

r->in.old_lm_crypted = NULL;

9359

}

9360

if (r->in.old_lm_crypted) {

9361

_mem_save_old_lm_crypted_0 = NDR_PULL_GET_MEM_CTX(ndr);

9362

NDR_PULL_SET_MEM_CTX(ndr, r->in.old_lm_crypted, 0);

9363

NDR_CHECK(ndr_pull_samr_Password(ndr, NDR_SCALARS, r->in.old_lm_crypted));

9364

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_old_lm_crypted_0, 0);

9365

}

9366

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_new_lm_crypted));

9367

if (_ptr_new_lm_crypted) {

9368

NDR_PULL_ALLOC(ndr, r->in.new_lm_crypted);

9369

} else {

9370

r->in.new_lm_crypted = NULL;

9371

}

9372

if (r->in.new_lm_crypted) {

9373

_mem_save_new_lm_crypted_0 = NDR_PULL_GET_MEM_CTX(ndr);

9374

NDR_PULL_SET_MEM_CTX(ndr, r->in.new_lm_crypted, 0);

9375

NDR_CHECK(ndr_pull_samr_Password(ndr, NDR_SCALARS, r->in.new_lm_crypted));

9376

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_new_lm_crypted_0, 0);

9377

}

9378

NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->in.nt_present));

9379

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_old_nt_crypted));

9380

if (_ptr_old_nt_crypted) {

9381

NDR_PULL_ALLOC(ndr, r->in.old_nt_crypted);

9382

} else {

9383

r->in.old_nt_crypted = NULL;

9384

}

9385

if (r->in.old_nt_crypted) {

9386

_mem_save_old_nt_crypted_0 = NDR_PULL_GET_MEM_CTX(ndr);

9387

NDR_PULL_SET_MEM_CTX(ndr, r->in.old_nt_crypted, 0);

9388

NDR_CHECK(ndr_pull_samr_Password(ndr, NDR_SCALARS, r->in.old_nt_crypted));

9389

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_old_nt_crypted_0, 0);

9390

}

9391

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_new_nt_crypted));

9392

if (_ptr_new_nt_crypted) {

9393

NDR_PULL_ALLOC(ndr, r->in.new_nt_crypted);

9394

} else {

9395

r->in.new_nt_crypted = NULL;

9396

}

9397

if (r->in.new_nt_crypted) {

9398

_mem_save_new_nt_crypted_0 = NDR_PULL_GET_MEM_CTX(ndr);

9399

NDR_PULL_SET_MEM_CTX(ndr, r->in.new_nt_crypted, 0);

9400

NDR_CHECK(ndr_pull_samr_Password(ndr, NDR_SCALARS, r->in.new_nt_crypted));

9401

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_new_nt_crypted_0, 0);

9402

}

9403

NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->in.cross1_present));

9404

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_nt_cross));

9405

if (_ptr_nt_cross) {

9406

NDR_PULL_ALLOC(ndr, r->in.nt_cross);

9407

} else {

9408

r->in.nt_cross = NULL;

9409

}

9410

if (r->in.nt_cross) {

9411

_mem_save_nt_cross_0 = NDR_PULL_GET_MEM_CTX(ndr);

9412

NDR_PULL_SET_MEM_CTX(ndr, r->in.nt_cross, 0);

9413

NDR_CHECK(ndr_pull_samr_Password(ndr, NDR_SCALARS, r->in.nt_cross));

9414

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_nt_cross_0, 0);

9415

}

9416

NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->in.cross2_present));

9417

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_lm_cross));

9418

if (_ptr_lm_cross) {

9419

NDR_PULL_ALLOC(ndr, r->in.lm_cross);

9420

} else {

9421

r->in.lm_cross = NULL;

9422

}

9423

if (r->in.lm_cross) {

9424

_mem_save_lm_cross_0 = NDR_PULL_GET_MEM_CTX(ndr);

9425

NDR_PULL_SET_MEM_CTX(ndr, r->in.lm_cross, 0);

9426

NDR_CHECK(ndr_pull_samr_Password(ndr, NDR_SCALARS, r->in.lm_cross));

9427

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_lm_cross_0, 0);

9428

}

9429

}

9430

if (flags & NDR_OUT) {

9431

NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));

9432

}

9433

return NDR_ERR_SUCCESS;

9434

}

9435

9436

_PUBLIC_ void ndr_print_samr_ChangePasswordUser(struct ndr_print *ndr, const char *name, int flags, const struct samr_ChangePasswordUser *r)

9437

{

9438

ndr_print_struct(ndr, name, "samr_ChangePasswordUser");

9439

if (r == NULL) { ndr_print_null(ndr); return; }

9440

ndr->depth++;

9441

if (flags & NDR_SET_VALUES) {

9442

ndr->flags |= LIBNDR_PRINT_SET_VALUES;

9443

}

9444

if (flags & NDR_IN) {

9445

ndr_print_struct(ndr, "in", "samr_ChangePasswordUser");

9446

ndr->depth++;

9447

ndr_print_ptr(ndr, "user_handle", r->in.user_handle);

9448

ndr->depth++;

9449

ndr_print_policy_handle(ndr, "user_handle", r->in.user_handle);

9450

ndr->depth--;

9451

ndr_print_uint8(ndr, "lm_present", r->in.lm_present);

9452

ndr_print_ptr(ndr, "old_lm_crypted", r->in.old_lm_crypted);

9453

ndr->depth++;

9454

if (r->in.old_lm_crypted) {

9455

ndr_print_samr_Password(ndr, "old_lm_crypted", r->in.old_lm_crypted);

9456

}

9457

ndr->depth--;

9458

ndr_print_ptr(ndr, "new_lm_crypted", r->in.new_lm_crypted);

9459

ndr->depth++;

9460

if (r->in.new_lm_crypted) {

9461

ndr_print_samr_Password(ndr, "new_lm_crypted", r->in.new_lm_crypted);

9462

}

9463

ndr->depth--;

9464

ndr_print_uint8(ndr, "nt_present", r->in.nt_present);

9465

ndr_print_ptr(ndr, "old_nt_crypted", r->in.old_nt_crypted);

9466

ndr->depth++;

9467

if (r->in.old_nt_crypted) {

9468

ndr_print_samr_Password(ndr, "old_nt_crypted", r->in.old_nt_crypted);

9469

}

9470

ndr->depth--;

9471

ndr_print_ptr(ndr, "new_nt_crypted", r->in.new_nt_crypted);

9472

ndr->depth++;

9473

if (r->in.new_nt_crypted) {

9474

ndr_print_samr_Password(ndr, "new_nt_crypted", r->in.new_nt_crypted);

9475

}

9476

ndr->depth--;

9477

ndr_print_uint8(ndr, "cross1_present", r->in.cross1_present);

9478

ndr_print_ptr(ndr, "nt_cross", r->in.nt_cross);

9479

ndr->depth++;

9480

if (r->in.nt_cross) {

9481

ndr_print_samr_Password(ndr, "nt_cross", r->in.nt_cross);

9482

}

9483

ndr->depth--;

9484

ndr_print_uint8(ndr, "cross2_present", r->in.cross2_present);

9485

ndr_print_ptr(ndr, "lm_cross", r->in.lm_cross);

9486

ndr->depth++;

9487

if (r->in.lm_cross) {

9488

ndr_print_samr_Password(ndr, "lm_cross", r->in.lm_cross);

9489

}

9490

ndr->depth--;

9491

ndr->depth--;

9492

}

9493

if (flags & NDR_OUT) {

9494

ndr_print_struct(ndr, "out", "samr_ChangePasswordUser");

9495

ndr->depth++;

9496

ndr_print_NTSTATUS(ndr, "result", r->out.result);

9497

ndr->depth--;

9498

}

9499

ndr->depth--;

9500

}

9501

9502

static enum ndr_err_code ndr_push_samr_GetGroupsForUser(struct ndr_push *ndr, int flags, const struct samr_GetGroupsForUser *r)

9503

{

9504

if (flags & NDR_IN) {

9505

if (r->in.user_handle == NULL) {

9506

return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");

9507

}

9508

NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.user_handle));

9509

}

9510

if (flags & NDR_OUT) {

9511

if (r->out.rids == NULL) {

9512

return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");

9513

}

9514

NDR_CHECK(ndr_push_unique_ptr(ndr, *r->out.rids));

9515

if (*r->out.rids) {

9516

NDR_CHECK(ndr_push_samr_RidWithAttributeArray(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.rids));

9517

}

9518

NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));

9519

}

9520

return NDR_ERR_SUCCESS;

9521

}

9522

9523

static enum ndr_err_code ndr_pull_samr_GetGroupsForUser(struct ndr_pull *ndr, int flags, struct samr_GetGroupsForUser *r)

9524

{

9525

uint32_t _ptr_rids;

9526

TALLOC_CTX *_mem_save_user_handle_0;

9527

TALLOC_CTX *_mem_save_rids_0;

9528

TALLOC_CTX *_mem_save_rids_1;

9529

if (flags & NDR_IN) {

9530

ZERO_STRUCT(r->out);

9531

9532

if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {

9533

NDR_PULL_ALLOC(ndr, r->in.user_handle);

9534

}

9535

_mem_save_user_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);

9536

NDR_PULL_SET_MEM_CTX(ndr, r->in.user_handle, LIBNDR_FLAG_REF_ALLOC);

9537

NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.user_handle));

9538

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_handle_0, LIBNDR_FLAG_REF_ALLOC);

9539

NDR_PULL_ALLOC(ndr, r->out.rids);

9540

ZERO_STRUCTP(r->out.rids);

9541

}

9542

if (flags & NDR_OUT) {

9543

if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {

9544

NDR_PULL_ALLOC(ndr, r->out.rids);

9545

}

9546

_mem_save_rids_0 = NDR_PULL_GET_MEM_CTX(ndr);

9547

NDR_PULL_SET_MEM_CTX(ndr, r->out.rids, LIBNDR_FLAG_REF_ALLOC);

9548

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_rids));

9549

if (_ptr_rids) {

9550

NDR_PULL_ALLOC(ndr, *r->out.rids);

9551

} else {

9552

*r->out.rids = NULL;

9553

}

9554

if (*r->out.rids) {

9555

_mem_save_rids_1 = NDR_PULL_GET_MEM_CTX(ndr);

9556

NDR_PULL_SET_MEM_CTX(ndr, *r->out.rids, 0);

9557

NDR_CHECK(ndr_pull_samr_RidWithAttributeArray(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.rids));

9558

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_rids_1, 0);

9559

}

9560

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_rids_0, LIBNDR_FLAG_REF_ALLOC);

9561

NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));

9562

}

9563

return NDR_ERR_SUCCESS;

9564

}

9565

9566

_PUBLIC_ void ndr_print_samr_GetGroupsForUser(struct ndr_print *ndr, const char *name, int flags, const struct samr_GetGroupsForUser *r)

9567

{

9568

ndr_print_struct(ndr, name, "samr_GetGroupsForUser");

9569

if (r == NULL) { ndr_print_null(ndr); return; }

9570

ndr->depth++;

9571

if (flags & NDR_SET_VALUES) {

9572

ndr->flags |= LIBNDR_PRINT_SET_VALUES;

9573

}

9574

if (flags & NDR_IN) {

9575

ndr_print_struct(ndr, "in", "samr_GetGroupsForUser");

9576

ndr->depth++;

9577

ndr_print_ptr(ndr, "user_handle", r->in.user_handle);

9578

ndr->depth++;

9579

ndr_print_policy_handle(ndr, "user_handle", r->in.user_handle);

9580

ndr->depth--;

9581

ndr->depth--;

9582

}

9583

if (flags & NDR_OUT) {

9584

ndr_print_struct(ndr, "out", "samr_GetGroupsForUser");

9585

ndr->depth++;

9586

ndr_print_ptr(ndr, "rids", r->out.rids);

9587

ndr->depth++;

9588

ndr_print_ptr(ndr, "rids", *r->out.rids);

9589

ndr->depth++;

9590

if (*r->out.rids) {

9591

ndr_print_samr_RidWithAttributeArray(ndr, "rids", *r->out.rids);

9592

}

9593

ndr->depth--;

9594

ndr->depth--;

9595

ndr_print_NTSTATUS(ndr, "result", r->out.result);

9596

ndr->depth--;

9597

}

9598

ndr->depth--;

9599

}

9600

9601

static enum ndr_err_code ndr_push_samr_QueryDisplayInfo(struct ndr_push *ndr, int flags, const struct samr_QueryDisplayInfo *r)

9602

{

9603

if (flags & NDR_IN) {

9604

if (r->in.domain_handle == NULL) {

9605

return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");

9606

}

9607

NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));

9608

NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->in.level));

9609

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.start_idx));

9610

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.max_entries));

9611

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.buf_size));

9612

}

9613

if (flags & NDR_OUT) {

9614

if (r->out.total_size == NULL) {

9615

return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");

9616

}

9617

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.total_size));

9618

if (r->out.returned_size == NULL) {

9619

return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");

9620

}

9621

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.returned_size));

9622

if (r->out.info == NULL) {

9623

return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");

9624

}

9625

NDR_CHECK(ndr_push_set_switch_value(ndr, r->out.info, r->in.level));

9626

NDR_CHECK(ndr_push_samr_DispInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.info));

9627

NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));

9628

}

9629

return NDR_ERR_SUCCESS;

9630

}

9631

9632

static enum ndr_err_code ndr_pull_samr_QueryDisplayInfo(struct ndr_pull *ndr, int flags, struct samr_QueryDisplayInfo *r)

9633

{

9634

TALLOC_CTX *_mem_save_domain_handle_0;

9635

TALLOC_CTX *_mem_save_total_size_0;

9636

TALLOC_CTX *_mem_save_returned_size_0;

9637

TALLOC_CTX *_mem_save_info_0;

9638

if (flags & NDR_IN) {

9639

ZERO_STRUCT(r->out);

9640

9641

if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {

9642

NDR_PULL_ALLOC(ndr, r->in.domain_handle);

9643

}

9644

_mem_save_domain_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);

9645

NDR_PULL_SET_MEM_CTX(ndr, r->in.domain_handle, LIBNDR_FLAG_REF_ALLOC);

9646

NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));

9647

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domain_handle_0, LIBNDR_FLAG_REF_ALLOC);

9648

NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->in.level));

9649

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.start_idx));

9650

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.max_entries));

9651

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.buf_size));

9652

NDR_PULL_ALLOC(ndr, r->out.total_size);

9653

ZERO_STRUCTP(r->out.total_size);

9654

NDR_PULL_ALLOC(ndr, r->out.returned_size);

9655

ZERO_STRUCTP(r->out.returned_size);

9656

NDR_PULL_ALLOC(ndr, r->out.info);

9657

ZERO_STRUCTP(r->out.info);

9658

}

9659

if (flags & NDR_OUT) {

9660

if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {

9661

NDR_PULL_ALLOC(ndr, r->out.total_size);

9662

}

9663

_mem_save_total_size_0 = NDR_PULL_GET_MEM_CTX(ndr);

9664

NDR_PULL_SET_MEM_CTX(ndr, r->out.total_size, LIBNDR_FLAG_REF_ALLOC);

9665

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.total_size));

9666

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_total_size_0, LIBNDR_FLAG_REF_ALLOC);

9667

if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {

9668

NDR_PULL_ALLOC(ndr, r->out.returned_size);

9669

}

9670

_mem_save_returned_size_0 = NDR_PULL_GET_MEM_CTX(ndr);

9671

NDR_PULL_SET_MEM_CTX(ndr, r->out.returned_size, LIBNDR_FLAG_REF_ALLOC);

9672

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.returned_size));

9673

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_returned_size_0, LIBNDR_FLAG_REF_ALLOC);

9674

if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {

9675

NDR_PULL_ALLOC(ndr, r->out.info);

9676

}

9677

_mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);

9678

NDR_PULL_SET_MEM_CTX(ndr, r->out.info, LIBNDR_FLAG_REF_ALLOC);

9679

NDR_CHECK(ndr_pull_set_switch_value(ndr, r->out.info, r->in.level));

9680

NDR_CHECK(ndr_pull_samr_DispInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.info));

9681

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, LIBNDR_FLAG_REF_ALLOC);

9682

NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));

9683

}

9684

return NDR_ERR_SUCCESS;

9685

}

9686

9687

_PUBLIC_ void ndr_print_samr_QueryDisplayInfo(struct ndr_print *ndr, const char *name, int flags, const struct samr_QueryDisplayInfo *r)

9688

{

9689

ndr_print_struct(ndr, name, "samr_QueryDisplayInfo");

9690

if (r == NULL) { ndr_print_null(ndr); return; }

9691

ndr->depth++;

9692

if (flags & NDR_SET_VALUES) {

9693

ndr->flags |= LIBNDR_PRINT_SET_VALUES;

9694

}

9695

if (flags & NDR_IN) {

9696

ndr_print_struct(ndr, "in", "samr_QueryDisplayInfo");

9697

ndr->depth++;

9698

ndr_print_ptr(ndr, "domain_handle", r->in.domain_handle);

9699

ndr->depth++;

9700

ndr_print_policy_handle(ndr, "domain_handle", r->in.domain_handle);

9701

ndr->depth--;

9702

ndr_print_uint16(ndr, "level", r->in.level);

9703

ndr_print_uint32(ndr, "start_idx", r->in.start_idx);

9704

ndr_print_uint32(ndr, "max_entries", r->in.max_entries);

9705

ndr_print_uint32(ndr, "buf_size", r->in.buf_size);

9706

ndr->depth--;

9707

}

9708

if (flags & NDR_OUT) {

9709

ndr_print_struct(ndr, "out", "samr_QueryDisplayInfo");

9710

ndr->depth++;

9711

ndr_print_ptr(ndr, "total_size", r->out.total_size);

9712

ndr->depth++;

9713

ndr_print_uint32(ndr, "total_size", *r->out.total_size);

9714

ndr->depth--;

9715

ndr_print_ptr(ndr, "returned_size", r->out.returned_size);

9716

ndr->depth++;

9717

ndr_print_uint32(ndr, "returned_size", *r->out.returned_size);

9718

ndr->depth--;

9719

ndr_print_ptr(ndr, "info", r->out.info);

9720

ndr->depth++;

9721

ndr_print_set_switch_value(ndr, r->out.info, r->in.level);

9722

ndr_print_samr_DispInfo(ndr, "info", r->out.info);

9723

ndr->depth--;

9724

ndr_print_NTSTATUS(ndr, "result", r->out.result);

9725

ndr->depth--;

9726

}

9727

ndr->depth--;

9728

}

9729

9730

static enum ndr_err_code ndr_push_samr_GetDisplayEnumerationIndex(struct ndr_push *ndr, int flags, const struct samr_GetDisplayEnumerationIndex *r)

9731

{

9732

if (flags & NDR_IN) {

9733

if (r->in.domain_handle == NULL) {

9734

return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");

9735

}

9736

NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));

9737

NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->in.level));

9738

if (r->in.name == NULL) {

9739

return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");

9740

}

9741

NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.name));

9742

}

9743

if (flags & NDR_OUT) {

9744

if (r->out.idx == NULL) {

9745

return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");

9746

}

9747

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.idx));

9748

NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));

9749

}

9750

return NDR_ERR_SUCCESS;

9751

}

9752

9753

static enum ndr_err_code ndr_pull_samr_GetDisplayEnumerationIndex(struct ndr_pull *ndr, int flags, struct samr_GetDisplayEnumerationIndex *r)

9754

{

9755

TALLOC_CTX *_mem_save_domain_handle_0;

9756

TALLOC_CTX *_mem_save_name_0;

9757

TALLOC_CTX *_mem_save_idx_0;

9758

if (flags & NDR_IN) {

9759

ZERO_STRUCT(r->out);

9760

9761

if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {

9762

NDR_PULL_ALLOC(ndr, r->in.domain_handle);

9763

}

9764

_mem_save_domain_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);

9765

NDR_PULL_SET_MEM_CTX(ndr, r->in.domain_handle, LIBNDR_FLAG_REF_ALLOC);

9766

NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));

9767

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domain_handle_0, LIBNDR_FLAG_REF_ALLOC);

9768

NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->in.level));

9769

if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {

9770

NDR_PULL_ALLOC(ndr, r->in.name);

9771

}

9772

_mem_save_name_0 = NDR_PULL_GET_MEM_CTX(ndr);

9773

NDR_PULL_SET_MEM_CTX(ndr, r->in.name, LIBNDR_FLAG_REF_ALLOC);

9774

NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.name));

9775

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_name_0, LIBNDR_FLAG_REF_ALLOC);

9776

NDR_PULL_ALLOC(ndr, r->out.idx);

9777

ZERO_STRUCTP(r->out.idx);

9778

}

9779

if (flags & NDR_OUT) {

9780

if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {

9781

NDR_PULL_ALLOC(ndr, r->out.idx);

9782

}

9783

_mem_save_idx_0 = NDR_PULL_GET_MEM_CTX(ndr);

9784

NDR_PULL_SET_MEM_CTX(ndr, r->out.idx, LIBNDR_FLAG_REF_ALLOC);

9785

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.idx));

9786

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_idx_0, LIBNDR_FLAG_REF_ALLOC);

9787

NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));

9788

}

9789

return NDR_ERR_SUCCESS;

9790

}

9791

9792

_PUBLIC_ void ndr_print_samr_GetDisplayEnumerationIndex(struct ndr_print *ndr, const char *name, int flags, const struct samr_GetDisplayEnumerationIndex *r)

9793

{

9794

ndr_print_struct(ndr, name, "samr_GetDisplayEnumerationIndex");

9795

if (r == NULL) { ndr_print_null(ndr); return; }

9796

ndr->depth++;

9797

if (flags & NDR_SET_VALUES) {

9798

ndr->flags |= LIBNDR_PRINT_SET_VALUES;

9799

}

9800

if (flags & NDR_IN) {

9801

ndr_print_struct(ndr, "in", "samr_GetDisplayEnumerationIndex");

9802

ndr->depth++;

9803

ndr_print_ptr(ndr, "domain_handle", r->in.domain_handle);

9804

ndr->depth++;

9805

ndr_print_policy_handle(ndr, "domain_handle", r->in.domain_handle);

9806

ndr->depth--;

9807

ndr_print_uint16(ndr, "level", r->in.level);

9808

ndr_print_ptr(ndr, "name", r->in.name);

9809

ndr->depth++;

9810

ndr_print_lsa_String(ndr, "name", r->in.name);

9811

ndr->depth--;

9812

ndr->depth--;

9813

}

9814

if (flags & NDR_OUT) {

9815

ndr_print_struct(ndr, "out", "samr_GetDisplayEnumerationIndex");

9816

ndr->depth++;

9817

ndr_print_ptr(ndr, "idx", r->out.idx);

9818

ndr->depth++;

9819

ndr_print_uint32(ndr, "idx", *r->out.idx);

9820

ndr->depth--;

9821

ndr_print_NTSTATUS(ndr, "result", r->out.result);

9822

ndr->depth--;

9823

}

9824

ndr->depth--;

9825

}

9826

9827

static enum ndr_err_code ndr_push_samr_TestPrivateFunctionsDomain(struct ndr_push *ndr, int flags, const struct samr_TestPrivateFunctionsDomain *r)

9828

{

9829

if (flags & NDR_IN) {

9830

if (r->in.domain_handle == NULL) {

9831

return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");

9832

}

9833

NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));

9834

}

9835

if (flags & NDR_OUT) {

9836

NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));

9837

}

9838

return NDR_ERR_SUCCESS;

9839

}

9840

9841

static enum ndr_err_code ndr_pull_samr_TestPrivateFunctionsDomain(struct ndr_pull *ndr, int flags, struct samr_TestPrivateFunctionsDomain *r)

9842

{

9843

TALLOC_CTX *_mem_save_domain_handle_0;

9844

if (flags & NDR_IN) {

9845

if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {

9846

NDR_PULL_ALLOC(ndr, r->in.domain_handle);

9847

}

9848

_mem_save_domain_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);

9849

NDR_PULL_SET_MEM_CTX(ndr, r->in.domain_handle, LIBNDR_FLAG_REF_ALLOC);

9850

NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));

9851

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domain_handle_0, LIBNDR_FLAG_REF_ALLOC);

9852

}

9853

if (flags & NDR_OUT) {

9854

NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));

9855

}

9856

return NDR_ERR_SUCCESS;

9857

}

9858

9859

_PUBLIC_ void ndr_print_samr_TestPrivateFunctionsDomain(struct ndr_print *ndr, const char *name, int flags, const struct samr_TestPrivateFunctionsDomain *r)

9860

{

9861

ndr_print_struct(ndr, name, "samr_TestPrivateFunctionsDomain");

9862

if (r == NULL) { ndr_print_null(ndr); return; }

9863

ndr->depth++;

9864

if (flags & NDR_SET_VALUES) {

9865

ndr->flags |= LIBNDR_PRINT_SET_VALUES;

9866

}

9867

if (flags & NDR_IN) {

9868

ndr_print_struct(ndr, "in", "samr_TestPrivateFunctionsDomain");

9869

ndr->depth++;

9870

ndr_print_ptr(ndr, "domain_handle", r->in.domain_handle);

9871

ndr->depth++;

9872

ndr_print_policy_handle(ndr, "domain_handle", r->in.domain_handle);

9873

ndr->depth--;

9874

ndr->depth--;

9875

}

9876

if (flags & NDR_OUT) {

9877

ndr_print_struct(ndr, "out", "samr_TestPrivateFunctionsDomain");

9878

ndr->depth++;

9879

ndr_print_NTSTATUS(ndr, "result", r->out.result);

9880

ndr->depth--;

9881

}

9882

ndr->depth--;

9883

}

9884

9885

static enum ndr_err_code ndr_push_samr_TestPrivateFunctionsUser(struct ndr_push *ndr, int flags, const struct samr_TestPrivateFunctionsUser *r)

9886

{

9887

if (flags & NDR_IN) {

9888

if (r->in.user_handle == NULL) {

9889

return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");

9890

}

9891

NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.user_handle));

9892

}

9893

if (flags & NDR_OUT) {

9894

NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));

9895

}

9896

return NDR_ERR_SUCCESS;

9897

}

9898

9899

static enum ndr_err_code ndr_pull_samr_TestPrivateFunctionsUser(struct ndr_pull *ndr, int flags, struct samr_TestPrivateFunctionsUser *r)

9900

{

9901

TALLOC_CTX *_mem_save_user_handle_0;

9902

if (flags & NDR_IN) {

9903

if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {

9904

NDR_PULL_ALLOC(ndr, r->in.user_handle);

9905

}

9906

_mem_save_user_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);

9907

NDR_PULL_SET_MEM_CTX(ndr, r->in.user_handle, LIBNDR_FLAG_REF_ALLOC);

9908

NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.user_handle));

9909

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_handle_0, LIBNDR_FLAG_REF_ALLOC);

9910

}

9911

if (flags & NDR_OUT) {

9912

NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));

9913

}

9914

return NDR_ERR_SUCCESS;

9915

}

9916

9917

_PUBLIC_ void ndr_print_samr_TestPrivateFunctionsUser(struct ndr_print *ndr, const char *name, int flags, const struct samr_TestPrivateFunctionsUser *r)

9918

{

9919

ndr_print_struct(ndr, name, "samr_TestPrivateFunctionsUser");

9920

if (r == NULL) { ndr_print_null(ndr); return; }

9921

ndr->depth++;

9922

if (flags & NDR_SET_VALUES) {

9923

ndr->flags |= LIBNDR_PRINT_SET_VALUES;

9924

}

9925

if (flags & NDR_IN) {

9926

ndr_print_struct(ndr, "in", "samr_TestPrivateFunctionsUser");

9927

ndr->depth++;

9928

ndr_print_ptr(ndr, "user_handle", r->in.user_handle);

9929

ndr->depth++;

9930

ndr_print_policy_handle(ndr, "user_handle", r->in.user_handle);

9931

ndr->depth--;

9932

ndr->depth--;

9933

}

9934

if (flags & NDR_OUT) {

9935

ndr_print_struct(ndr, "out", "samr_TestPrivateFunctionsUser");

9936

ndr->depth++;

9937

ndr_print_NTSTATUS(ndr, "result", r->out.result);

9938

ndr->depth--;

9939

}

9940

ndr->depth--;

9941

}

9942

9943

_PUBLIC_ enum ndr_err_code ndr_push_samr_GetUserPwInfo(struct ndr_push *ndr, int flags, const struct samr_GetUserPwInfo *r)

9944

{

9945

if (flags & NDR_IN) {

9946

if (r->in.user_handle == NULL) {

9947

return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");

9948

}

9949

NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.user_handle));

9950

}

9951

if (flags & NDR_OUT) {

9952

if (r->out.info == NULL) {

9953

return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");

9954

}

9955

NDR_CHECK(ndr_push_samr_PwInfo(ndr, NDR_SCALARS, r->out.info));

9956

NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));

9957

}

9958

return NDR_ERR_SUCCESS;

9959

}

9960

9961

_PUBLIC_ enum ndr_err_code ndr_pull_samr_GetUserPwInfo(struct ndr_pull *ndr, int flags, struct samr_GetUserPwInfo *r)

9962

{

9963

TALLOC_CTX *_mem_save_user_handle_0;

9964

TALLOC_CTX *_mem_save_info_0;

9965

if (flags & NDR_IN) {

9966

ZERO_STRUCT(r->out);

9967

9968

if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {

9969

NDR_PULL_ALLOC(ndr, r->in.user_handle);

9970

}

9971

_mem_save_user_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);

9972

NDR_PULL_SET_MEM_CTX(ndr, r->in.user_handle, LIBNDR_FLAG_REF_ALLOC);

9973

NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.user_handle));

9974

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_handle_0, LIBNDR_FLAG_REF_ALLOC);

9975

NDR_PULL_ALLOC(ndr, r->out.info);

9976

ZERO_STRUCTP(r->out.info);

9977

}

9978

if (flags & NDR_OUT) {

9979

if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {

9980

NDR_PULL_ALLOC(ndr, r->out.info);

9981

}

9982

_mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);

9983

NDR_PULL_SET_MEM_CTX(ndr, r->out.info, LIBNDR_FLAG_REF_ALLOC);

9984

NDR_CHECK(ndr_pull_samr_PwInfo(ndr, NDR_SCALARS, r->out.info));

9985

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, LIBNDR_FLAG_REF_ALLOC);

9986

NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));

9987

}

9988

return NDR_ERR_SUCCESS;

9989

}

9990

9991

_PUBLIC_ void ndr_print_samr_GetUserPwInfo(struct ndr_print *ndr, const char *name, int flags, const struct samr_GetUserPwInfo *r)

9992

{

9993

ndr_print_struct(ndr, name, "samr_GetUserPwInfo");

9994

if (r == NULL) { ndr_print_null(ndr); return; }

9995

ndr->depth++;

9996

if (flags & NDR_SET_VALUES) {

9997

ndr->flags |= LIBNDR_PRINT_SET_VALUES;

9998

}

9999

if (flags & NDR_IN) {

10000

ndr_print_struct(ndr, "in", "samr_GetUserPwInfo");

10001

ndr->depth++;

10002

ndr_print_ptr(ndr, "user_handle", r->in.user_handle);

10003

ndr->depth++;

10004

ndr_print_policy_handle(ndr, "user_handle", r->in.user_handle);

10005

ndr->depth--;

10006

ndr->depth--;

10007

}

10008

if (flags & NDR_OUT) {

10009

ndr_print_struct(ndr, "out", "samr_GetUserPwInfo");

10010

ndr->depth++;

10011

ndr_print_ptr(ndr, "info", r->out.info);

10012

ndr->depth++;

10013

ndr_print_samr_PwInfo(ndr, "info", r->out.info);

10014

ndr->depth--;

10015

ndr_print_NTSTATUS(ndr, "result", r->out.result);

10016

ndr->depth--;

10017

}

10018

ndr->depth--;

10019

}

10020

10021

static enum ndr_err_code ndr_push_samr_RemoveMemberFromForeignDomain(struct ndr_push *ndr, int flags, const struct samr_RemoveMemberFromForeignDomain *r)

10022

{

10023

if (flags & NDR_IN) {

10024

if (r->in.domain_handle == NULL) {

10025

return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");

10026

}

10027

NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));

10028

if (r->in.sid == NULL) {

10029

return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");

10030

}

10031

NDR_CHECK(ndr_push_dom_sid2(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.sid));

10032

}

10033

if (flags & NDR_OUT) {

10034

NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));

10035

}

10036

return NDR_ERR_SUCCESS;

10037

}

10038

10039

static enum ndr_err_code ndr_pull_samr_RemoveMemberFromForeignDomain(struct ndr_pull *ndr, int flags, struct samr_RemoveMemberFromForeignDomain *r)

10040

{

10041

TALLOC_CTX *_mem_save_domain_handle_0;

10042

TALLOC_CTX *_mem_save_sid_0;

10043

if (flags & NDR_IN) {

10044

if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {

10045

NDR_PULL_ALLOC(ndr, r->in.domain_handle);

10046

}

10047

_mem_save_domain_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);

10048

NDR_PULL_SET_MEM_CTX(ndr, r->in.domain_handle, LIBNDR_FLAG_REF_ALLOC);

10049

NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));

10050

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domain_handle_0, LIBNDR_FLAG_REF_ALLOC);

10051

if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {

10052

NDR_PULL_ALLOC(ndr, r->in.sid);

10053

}

10054

_mem_save_sid_0 = NDR_PULL_GET_MEM_CTX(ndr);

10055

NDR_PULL_SET_MEM_CTX(ndr, r->in.sid, LIBNDR_FLAG_REF_ALLOC);

10056

NDR_CHECK(ndr_pull_dom_sid2(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.sid));

10057

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sid_0, LIBNDR_FLAG_REF_ALLOC);

10058

}

10059

if (flags & NDR_OUT) {

10060

NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));

10061

}

10062

return NDR_ERR_SUCCESS;

10063

}

10064

10065

_PUBLIC_ void ndr_print_samr_RemoveMemberFromForeignDomain(struct ndr_print *ndr, const char *name, int flags, const struct samr_RemoveMemberFromForeignDomain *r)

10066

{

10067

ndr_print_struct(ndr, name, "samr_RemoveMemberFromForeignDomain");

10068

if (r == NULL) { ndr_print_null(ndr); return; }

10069

ndr->depth++;

10070

if (flags & NDR_SET_VALUES) {

10071

ndr->flags |= LIBNDR_PRINT_SET_VALUES;

10072

}

10073

if (flags & NDR_IN) {

10074

ndr_print_struct(ndr, "in", "samr_RemoveMemberFromForeignDomain");

10075

ndr->depth++;

10076

ndr_print_ptr(ndr, "domain_handle", r->in.domain_handle);

10077

ndr->depth++;

10078

ndr_print_policy_handle(ndr, "domain_handle", r->in.domain_handle);

10079

ndr->depth--;

10080

ndr_print_ptr(ndr, "sid", r->in.sid);

10081

ndr->depth++;

10082

ndr_print_dom_sid2(ndr, "sid", r->in.sid);

10083

ndr->depth--;

10084

ndr->depth--;

10085

}

10086

if (flags & NDR_OUT) {

10087

ndr_print_struct(ndr, "out", "samr_RemoveMemberFromForeignDomain");

10088

ndr->depth++;

10089

ndr_print_NTSTATUS(ndr, "result", r->out.result);

10090

ndr->depth--;

10091

}

10092

ndr->depth--;

10093

}

10094

10095

static enum ndr_err_code ndr_push_samr_QueryDomainInfo2(struct ndr_push *ndr, int flags, const struct samr_QueryDomainInfo2 *r)

10096

{

10097

if (flags & NDR_IN) {

10098

if (r->in.domain_handle == NULL) {

10099

return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");

10100

}

10101

NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));

10102

NDR_CHECK(ndr_push_samr_DomainInfoClass(ndr, NDR_SCALARS, r->in.level));

10103

}

10104

if (flags & NDR_OUT) {

10105

if (r->out.info == NULL) {

10106

return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");

10107

}

10108

NDR_CHECK(ndr_push_unique_ptr(ndr, *r->out.info));

10109

if (*r->out.info) {

10110

NDR_CHECK(ndr_push_set_switch_value(ndr, *r->out.info, r->in.level));

10111

NDR_CHECK(ndr_push_samr_DomainInfo(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.info));

10112

}

10113

NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));

10114

}

10115

return NDR_ERR_SUCCESS;

10116

}

10117

10118

static enum ndr_err_code ndr_pull_samr_QueryDomainInfo2(struct ndr_pull *ndr, int flags, struct samr_QueryDomainInfo2 *r)

10119

{

10120

uint32_t _ptr_info;

10121

TALLOC_CTX *_mem_save_domain_handle_0;

10122

TALLOC_CTX *_mem_save_info_0;

10123

TALLOC_CTX *_mem_save_info_1;

10124

if (flags & NDR_IN) {

10125

ZERO_STRUCT(r->out);

10126

10127

if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {

10128

NDR_PULL_ALLOC(ndr, r->in.domain_handle);

10129

}

10130

_mem_save_domain_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);

10131

NDR_PULL_SET_MEM_CTX(ndr, r->in.domain_handle, LIBNDR_FLAG_REF_ALLOC);

10132

NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));

10133

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domain_handle_0, LIBNDR_FLAG_REF_ALLOC);

10134

NDR_CHECK(ndr_pull_samr_DomainInfoClass(ndr, NDR_SCALARS, &r->in.level));

10135

NDR_PULL_ALLOC(ndr, r->out.info);

10136

ZERO_STRUCTP(r->out.info);

10137

}

10138

if (flags & NDR_OUT) {

10139

if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {

10140

NDR_PULL_ALLOC(ndr, r->out.info);

10141

}

10142

_mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);

10143

NDR_PULL_SET_MEM_CTX(ndr, r->out.info, LIBNDR_FLAG_REF_ALLOC);

10144

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));

10145

if (_ptr_info) {

10146

NDR_PULL_ALLOC(ndr, *r->out.info);

10147

} else {

10148

*r->out.info = NULL;

10149

}

10150

if (*r->out.info) {

10151

_mem_save_info_1 = NDR_PULL_GET_MEM_CTX(ndr);

10152

NDR_PULL_SET_MEM_CTX(ndr, *r->out.info, 0);

10153

NDR_CHECK(ndr_pull_set_switch_value(ndr, *r->out.info, r->in.level));

10154

NDR_CHECK(ndr_pull_samr_DomainInfo(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.info));

10155

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_1, 0);

10156

}

10157

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, LIBNDR_FLAG_REF_ALLOC);

10158

NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));

10159

}

10160

return NDR_ERR_SUCCESS;

10161

}

10162

10163

_PUBLIC_ void ndr_print_samr_QueryDomainInfo2(struct ndr_print *ndr, const char *name, int flags, const struct samr_QueryDomainInfo2 *r)

10164

{

10165

ndr_print_struct(ndr, name, "samr_QueryDomainInfo2");

10166

if (r == NULL) { ndr_print_null(ndr); return; }

10167

ndr->depth++;

10168

if (flags & NDR_SET_VALUES) {

10169

ndr->flags |= LIBNDR_PRINT_SET_VALUES;

10170

}

10171

if (flags & NDR_IN) {

10172

ndr_print_struct(ndr, "in", "samr_QueryDomainInfo2");

10173

ndr->depth++;

10174

ndr_print_ptr(ndr, "domain_handle", r->in.domain_handle);

10175

ndr->depth++;

10176

ndr_print_policy_handle(ndr, "domain_handle", r->in.domain_handle);

10177

ndr->depth--;

10178

ndr_print_samr_DomainInfoClass(ndr, "level", r->in.level);

10179

ndr->depth--;

10180

}

10181

if (flags & NDR_OUT) {

10182

ndr_print_struct(ndr, "out", "samr_QueryDomainInfo2");

10183

ndr->depth++;

10184

ndr_print_ptr(ndr, "info", r->out.info);

10185

ndr->depth++;

10186

ndr_print_ptr(ndr, "info", *r->out.info);

10187

ndr->depth++;

10188

if (*r->out.info) {

10189

ndr_print_set_switch_value(ndr, *r->out.info, r->in.level);

10190

ndr_print_samr_DomainInfo(ndr, "info", *r->out.info);

10191

}

10192

ndr->depth--;

10193

ndr->depth--;

10194

ndr_print_NTSTATUS(ndr, "result", r->out.result);

10195

ndr->depth--;

10196

}

10197

ndr->depth--;

10198

}

10199

10200

static enum ndr_err_code ndr_push_samr_QueryUserInfo2(struct ndr_push *ndr, int flags, const struct samr_QueryUserInfo2 *r)

10201

{

10202

if (flags & NDR_IN) {

10203

if (r->in.user_handle == NULL) {

10204

return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");

10205

}

10206

NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.user_handle));

10207

NDR_CHECK(ndr_push_samr_UserInfoLevel(ndr, NDR_SCALARS, r->in.level));

10208

}

10209

if (flags & NDR_OUT) {

10210

if (r->out.info == NULL) {

10211

return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");

10212

}

10213

NDR_CHECK(ndr_push_unique_ptr(ndr, *r->out.info));

10214

if (*r->out.info) {

10215

NDR_CHECK(ndr_push_set_switch_value(ndr, *r->out.info, r->in.level));

10216

NDR_CHECK(ndr_push_samr_UserInfo(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.info));

10217

}

10218

NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));

10219

}

10220

return NDR_ERR_SUCCESS;

10221

}

10222

10223

static enum ndr_err_code ndr_pull_samr_QueryUserInfo2(struct ndr_pull *ndr, int flags, struct samr_QueryUserInfo2 *r)

10224

{

10225

uint32_t _ptr_info;

10226

TALLOC_CTX *_mem_save_user_handle_0;

10227

TALLOC_CTX *_mem_save_info_0;

10228

TALLOC_CTX *_mem_save_info_1;

10229

if (flags & NDR_IN) {

10230

ZERO_STRUCT(r->out);

10231

10232

if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {

10233

NDR_PULL_ALLOC(ndr, r->in.user_handle);

10234

}

10235

_mem_save_user_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);

10236

NDR_PULL_SET_MEM_CTX(ndr, r->in.user_handle, LIBNDR_FLAG_REF_ALLOC);

10237

NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.user_handle));

10238

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_handle_0, LIBNDR_FLAG_REF_ALLOC);

10239

NDR_CHECK(ndr_pull_samr_UserInfoLevel(ndr, NDR_SCALARS, &r->in.level));

10240

NDR_PULL_ALLOC(ndr, r->out.info);

10241

ZERO_STRUCTP(r->out.info);

10242

}

10243

if (flags & NDR_OUT) {

10244

if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {

10245

NDR_PULL_ALLOC(ndr, r->out.info);

10246

}

10247

_mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);

10248

NDR_PULL_SET_MEM_CTX(ndr, r->out.info, LIBNDR_FLAG_REF_ALLOC);

10249

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));

10250

if (_ptr_info) {

10251

NDR_PULL_ALLOC(ndr, *r->out.info);

10252

} else {

10253

*r->out.info = NULL;

10254

}

10255

if (*r->out.info) {

10256

_mem_save_info_1 = NDR_PULL_GET_MEM_CTX(ndr);

10257

NDR_PULL_SET_MEM_CTX(ndr, *r->out.info, 0);

10258

NDR_CHECK(ndr_pull_set_switch_value(ndr, *r->out.info, r->in.level));

10259

NDR_CHECK(ndr_pull_samr_UserInfo(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.info));

10260

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_1, 0);

10261

}

10262

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, LIBNDR_FLAG_REF_ALLOC);

10263

NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));

10264

}

10265

return NDR_ERR_SUCCESS;

10266

}

10267

10268

_PUBLIC_ void ndr_print_samr_QueryUserInfo2(struct ndr_print *ndr, const char *name, int flags, const struct samr_QueryUserInfo2 *r)

10269

{

10270

ndr_print_struct(ndr, name, "samr_QueryUserInfo2");

10271

if (r == NULL) { ndr_print_null(ndr); return; }

10272

ndr->depth++;

10273

if (flags & NDR_SET_VALUES) {

10274

ndr->flags |= LIBNDR_PRINT_SET_VALUES;

10275

}

10276

if (flags & NDR_IN) {

10277

ndr_print_struct(ndr, "in", "samr_QueryUserInfo2");

10278

ndr->depth++;

10279

ndr_print_ptr(ndr, "user_handle", r->in.user_handle);

10280

ndr->depth++;

10281

ndr_print_policy_handle(ndr, "user_handle", r->in.user_handle);

10282

ndr->depth--;

10283

ndr_print_samr_UserInfoLevel(ndr, "level", r->in.level);

10284

ndr->depth--;

10285

}

10286

if (flags & NDR_OUT) {

10287

ndr_print_struct(ndr, "out", "samr_QueryUserInfo2");

10288

ndr->depth++;

10289

ndr_print_ptr(ndr, "info", r->out.info);

10290

ndr->depth++;

10291

ndr_print_ptr(ndr, "info", *r->out.info);

10292

ndr->depth++;

10293

if (*r->out.info) {

10294

ndr_print_set_switch_value(ndr, *r->out.info, r->in.level);

10295

ndr_print_samr_UserInfo(ndr, "info", *r->out.info);

10296

}

10297

ndr->depth--;

10298

ndr->depth--;

10299

ndr_print_NTSTATUS(ndr, "result", r->out.result);

10300

ndr->depth--;

10301

}

10302

ndr->depth--;

10303

}

10304

10305

static enum ndr_err_code ndr_push_samr_QueryDisplayInfo2(struct ndr_push *ndr, int flags, const struct samr_QueryDisplayInfo2 *r)

10306

{

10307

if (flags & NDR_IN) {

10308

if (r->in.domain_handle == NULL) {

10309

return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");

10310

}

10311

NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));

10312

NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->in.level));

10313

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.start_idx));

10314

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.max_entries));

10315

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.buf_size));

10316

}

10317

if (flags & NDR_OUT) {

10318

if (r->out.total_size == NULL) {

10319

return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");

10320

}

10321

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.total_size));

10322

if (r->out.returned_size == NULL) {

10323

return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");

10324

}

10325

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.returned_size));

10326

if (r->out.info == NULL) {

10327

return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");

10328

}

10329

NDR_CHECK(ndr_push_set_switch_value(ndr, r->out.info, r->in.level));

10330

NDR_CHECK(ndr_push_samr_DispInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.info));

10331

NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));

10332

}

10333

return NDR_ERR_SUCCESS;

10334

}

10335

10336

static enum ndr_err_code ndr_pull_samr_QueryDisplayInfo2(struct ndr_pull *ndr, int flags, struct samr_QueryDisplayInfo2 *r)

10337

{

10338

TALLOC_CTX *_mem_save_domain_handle_0;

10339

TALLOC_CTX *_mem_save_total_size_0;

10340

TALLOC_CTX *_mem_save_returned_size_0;

10341

TALLOC_CTX *_mem_save_info_0;

10342

if (flags & NDR_IN) {

10343

ZERO_STRUCT(r->out);

10344

10345

if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {

10346

NDR_PULL_ALLOC(ndr, r->in.domain_handle);

10347

}

10348

_mem_save_domain_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);

10349

NDR_PULL_SET_MEM_CTX(ndr, r->in.domain_handle, LIBNDR_FLAG_REF_ALLOC);

10350

NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));

10351

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domain_handle_0, LIBNDR_FLAG_REF_ALLOC);

10352

NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->in.level));

10353

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.start_idx));

10354

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.max_entries));

10355

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.buf_size));

10356

NDR_PULL_ALLOC(ndr, r->out.total_size);

10357

ZERO_STRUCTP(r->out.total_size);

10358

NDR_PULL_ALLOC(ndr, r->out.returned_size);

10359

ZERO_STRUCTP(r->out.returned_size);

10360

NDR_PULL_ALLOC(ndr, r->out.info);

10361

ZERO_STRUCTP(r->out.info);

10362

}

10363

if (flags & NDR_OUT) {

10364

if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {

10365

NDR_PULL_ALLOC(ndr, r->out.total_size);

10366

}

10367

_mem_save_total_size_0 = NDR_PULL_GET_MEM_CTX(ndr);

10368

NDR_PULL_SET_MEM_CTX(ndr, r->out.total_size, LIBNDR_FLAG_REF_ALLOC);

10369

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.total_size));

10370

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_total_size_0, LIBNDR_FLAG_REF_ALLOC);

10371

if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {

10372

NDR_PULL_ALLOC(ndr, r->out.returned_size);

10373

}

10374

_mem_save_returned_size_0 = NDR_PULL_GET_MEM_CTX(ndr);

10375

NDR_PULL_SET_MEM_CTX(ndr, r->out.returned_size, LIBNDR_FLAG_REF_ALLOC);

10376

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.returned_size));

10377

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_returned_size_0, LIBNDR_FLAG_REF_ALLOC);

10378

if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {

10379

NDR_PULL_ALLOC(ndr, r->out.info);

10380

}

10381

_mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);

10382

NDR_PULL_SET_MEM_CTX(ndr, r->out.info, LIBNDR_FLAG_REF_ALLOC);

10383

NDR_CHECK(ndr_pull_set_switch_value(ndr, r->out.info, r->in.level));

10384

NDR_CHECK(ndr_pull_samr_DispInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.info));

10385

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, LIBNDR_FLAG_REF_ALLOC);

10386

NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));

10387

}

10388

return NDR_ERR_SUCCESS;

10389

}

10390

10391

_PUBLIC_ void ndr_print_samr_QueryDisplayInfo2(struct ndr_print *ndr, const char *name, int flags, const struct samr_QueryDisplayInfo2 *r)

10392

{

10393

ndr_print_struct(ndr, name, "samr_QueryDisplayInfo2");

10394

if (r == NULL) { ndr_print_null(ndr); return; }

10395

ndr->depth++;

10396

if (flags & NDR_SET_VALUES) {

10397

ndr->flags |= LIBNDR_PRINT_SET_VALUES;

10398

}

10399

if (flags & NDR_IN) {

10400

ndr_print_struct(ndr, "in", "samr_QueryDisplayInfo2");

10401

ndr->depth++;

10402

ndr_print_ptr(ndr, "domain_handle", r->in.domain_handle);

10403

ndr->depth++;

10404

ndr_print_policy_handle(ndr, "domain_handle", r->in.domain_handle);

10405

ndr->depth--;

10406

ndr_print_uint16(ndr, "level", r->in.level);

10407

ndr_print_uint32(ndr, "start_idx", r->in.start_idx);

10408

ndr_print_uint32(ndr, "max_entries", r->in.max_entries);

10409

ndr_print_uint32(ndr, "buf_size", r->in.buf_size);

10410

ndr->depth--;

10411

}

10412

if (flags & NDR_OUT) {

10413

ndr_print_struct(ndr, "out", "samr_QueryDisplayInfo2");

10414

ndr->depth++;

10415

ndr_print_ptr(ndr, "total_size", r->out.total_size);

10416

ndr->depth++;

10417

ndr_print_uint32(ndr, "total_size", *r->out.total_size);

10418

ndr->depth--;

10419

ndr_print_ptr(ndr, "returned_size", r->out.returned_size);

10420

ndr->depth++;

10421

ndr_print_uint32(ndr, "returned_size", *r->out.returned_size);

10422

ndr->depth--;

10423

ndr_print_ptr(ndr, "info", r->out.info);

10424

ndr->depth++;

10425

ndr_print_set_switch_value(ndr, r->out.info, r->in.level);

10426

ndr_print_samr_DispInfo(ndr, "info", r->out.info);

10427

ndr->depth--;

10428

ndr_print_NTSTATUS(ndr, "result", r->out.result);

10429

ndr->depth--;

10430

}

10431

ndr->depth--;

10432

}

10433

10434

static enum ndr_err_code ndr_push_samr_GetDisplayEnumerationIndex2(struct ndr_push *ndr, int flags, const struct samr_GetDisplayEnumerationIndex2 *r)

10435

{

10436

if (flags & NDR_IN) {

10437

if (r->in.domain_handle == NULL) {

10438

return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");

10439

}

10440

NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));

10441

NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->in.level));

10442

if (r->in.name == NULL) {

10443

return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");

10444

}

10445

NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.name));

10446

}

10447

if (flags & NDR_OUT) {

10448

if (r->out.idx == NULL) {

10449

return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");

10450

}

10451

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.idx));

10452

NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));

10453

}

10454

return NDR_ERR_SUCCESS;

10455

}

10456

10457

static enum ndr_err_code ndr_pull_samr_GetDisplayEnumerationIndex2(struct ndr_pull *ndr, int flags, struct samr_GetDisplayEnumerationIndex2 *r)

10458

{

10459

TALLOC_CTX *_mem_save_domain_handle_0;

10460

TALLOC_CTX *_mem_save_name_0;

10461

TALLOC_CTX *_mem_save_idx_0;

10462

if (flags & NDR_IN) {

10463

ZERO_STRUCT(r->out);

10464

10465

if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {

10466

NDR_PULL_ALLOC(ndr, r->in.domain_handle);

10467

}

10468

_mem_save_domain_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);

10469

NDR_PULL_SET_MEM_CTX(ndr, r->in.domain_handle, LIBNDR_FLAG_REF_ALLOC);

10470

NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));

10471

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domain_handle_0, LIBNDR_FLAG_REF_ALLOC);

10472

NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->in.level));

10473

if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {

10474

NDR_PULL_ALLOC(ndr, r->in.name);

10475

}

10476

_mem_save_name_0 = NDR_PULL_GET_MEM_CTX(ndr);

10477

NDR_PULL_SET_MEM_CTX(ndr, r->in.name, LIBNDR_FLAG_REF_ALLOC);

10478

NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.name));

10479

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_name_0, LIBNDR_FLAG_REF_ALLOC);

10480

NDR_PULL_ALLOC(ndr, r->out.idx);

10481

ZERO_STRUCTP(r->out.idx);

10482

}

10483

if (flags & NDR_OUT) {

10484

if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {

10485

NDR_PULL_ALLOC(ndr, r->out.idx);

10486

}

10487

_mem_save_idx_0 = NDR_PULL_GET_MEM_CTX(ndr);

10488

NDR_PULL_SET_MEM_CTX(ndr, r->out.idx, LIBNDR_FLAG_REF_ALLOC);

10489

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.idx));

10490

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_idx_0, LIBNDR_FLAG_REF_ALLOC);

10491

NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));

10492

}

10493

return NDR_ERR_SUCCESS;

10494

}

10495

10496

_PUBLIC_ void ndr_print_samr_GetDisplayEnumerationIndex2(struct ndr_print *ndr, const char *name, int flags, const struct samr_GetDisplayEnumerationIndex2 *r)

10497

{

10498

ndr_print_struct(ndr, name, "samr_GetDisplayEnumerationIndex2");

10499

if (r == NULL) { ndr_print_null(ndr); return; }

10500

ndr->depth++;

10501

if (flags & NDR_SET_VALUES) {

10502

ndr->flags |= LIBNDR_PRINT_SET_VALUES;

10503

}

10504

if (flags & NDR_IN) {

10505

ndr_print_struct(ndr, "in", "samr_GetDisplayEnumerationIndex2");

10506

ndr->depth++;

10507

ndr_print_ptr(ndr, "domain_handle", r->in.domain_handle);

10508

ndr->depth++;

10509

ndr_print_policy_handle(ndr, "domain_handle", r->in.domain_handle);

10510

ndr->depth--;

10511

ndr_print_uint16(ndr, "level", r->in.level);

10512

ndr_print_ptr(ndr, "name", r->in.name);

10513

ndr->depth++;

10514

ndr_print_lsa_String(ndr, "name", r->in.name);

10515

ndr->depth--;

10516

ndr->depth--;

10517

}

10518

if (flags & NDR_OUT) {

10519

ndr_print_struct(ndr, "out", "samr_GetDisplayEnumerationIndex2");

10520

ndr->depth++;

10521

ndr_print_ptr(ndr, "idx", r->out.idx);

10522

ndr->depth++;

10523

ndr_print_uint32(ndr, "idx", *r->out.idx);

10524

ndr->depth--;

10525

ndr_print_NTSTATUS(ndr, "result", r->out.result);

10526

ndr->depth--;

10527

}

10528

ndr->depth--;

10529

}

10530

10531

static enum ndr_err_code ndr_push_samr_CreateUser2(struct ndr_push *ndr, int flags, const struct samr_CreateUser2 *r)

10532

{

10533

if (flags & NDR_IN) {

10534

if (r->in.domain_handle == NULL) {

10535

return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");

10536

}

10537

NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));

10538

if (r->in.account_name == NULL) {

10539

return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");

10540

}

10541

NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.account_name));

10542

NDR_CHECK(ndr_push_samr_AcctFlags(ndr, NDR_SCALARS, r->in.acct_flags));

10543

NDR_CHECK(ndr_push_samr_UserAccessMask(ndr, NDR_SCALARS, r->in.access_mask));

10544

}

10545

if (flags & NDR_OUT) {

10546

if (r->out.user_handle == NULL) {

10547

return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");

10548

}

10549

NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.user_handle));

10550

if (r->out.access_granted == NULL) {

10551

return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");

10552

}

10553

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.access_granted));

10554

if (r->out.rid == NULL) {

10555

return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");

10556

}

10557

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.rid));

10558

NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));

10559

}

10560

return NDR_ERR_SUCCESS;

10561

}

10562

10563

static enum ndr_err_code ndr_pull_samr_CreateUser2(struct ndr_pull *ndr, int flags, struct samr_CreateUser2 *r)

10564

{

10565

TALLOC_CTX *_mem_save_domain_handle_0;

10566

TALLOC_CTX *_mem_save_account_name_0;

10567

TALLOC_CTX *_mem_save_user_handle_0;

10568

TALLOC_CTX *_mem_save_access_granted_0;

10569

TALLOC_CTX *_mem_save_rid_0;

10570

if (flags & NDR_IN) {

10571

ZERO_STRUCT(r->out);

10572

10573

if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {

10574

NDR_PULL_ALLOC(ndr, r->in.domain_handle);

10575

}

10576

_mem_save_domain_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);

10577

NDR_PULL_SET_MEM_CTX(ndr, r->in.domain_handle, LIBNDR_FLAG_REF_ALLOC);

10578

NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));

10579

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domain_handle_0, LIBNDR_FLAG_REF_ALLOC);

10580

if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {

10581

NDR_PULL_ALLOC(ndr, r->in.account_name);

10582

}

10583

_mem_save_account_name_0 = NDR_PULL_GET_MEM_CTX(ndr);

10584

NDR_PULL_SET_MEM_CTX(ndr, r->in.account_name, LIBNDR_FLAG_REF_ALLOC);

10585

NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.account_name));

10586

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_account_name_0, LIBNDR_FLAG_REF_ALLOC);

10587

NDR_CHECK(ndr_pull_samr_AcctFlags(ndr, NDR_SCALARS, &r->in.acct_flags));

10588

NDR_CHECK(ndr_pull_samr_UserAccessMask(ndr, NDR_SCALARS, &r->in.access_mask));

10589

NDR_PULL_ALLOC(ndr, r->out.user_handle);

10590

ZERO_STRUCTP(r->out.user_handle);

10591

NDR_PULL_ALLOC(ndr, r->out.access_granted);

10592

ZERO_STRUCTP(r->out.access_granted);

10593

NDR_PULL_ALLOC(ndr, r->out.rid);

10594

ZERO_STRUCTP(r->out.rid);

10595

}

10596

if (flags & NDR_OUT) {

10597

if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {

10598

NDR_PULL_ALLOC(ndr, r->out.user_handle);

10599

}

10600

_mem_save_user_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);

10601

NDR_PULL_SET_MEM_CTX(ndr, r->out.user_handle, LIBNDR_FLAG_REF_ALLOC);

10602

NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.user_handle));

10603

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_handle_0, LIBNDR_FLAG_REF_ALLOC);

10604

if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {

10605

NDR_PULL_ALLOC(ndr, r->out.access_granted);

10606

}

10607

_mem_save_access_granted_0 = NDR_PULL_GET_MEM_CTX(ndr);

10608

NDR_PULL_SET_MEM_CTX(ndr, r->out.access_granted, LIBNDR_FLAG_REF_ALLOC);

10609

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.access_granted));

10610

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_access_granted_0, LIBNDR_FLAG_REF_ALLOC);

10611

if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {

10612

NDR_PULL_ALLOC(ndr, r->out.rid);

10613

}

10614

_mem_save_rid_0 = NDR_PULL_GET_MEM_CTX(ndr);

10615

NDR_PULL_SET_MEM_CTX(ndr, r->out.rid, LIBNDR_FLAG_REF_ALLOC);

10616

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.rid));

10617

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_rid_0, LIBNDR_FLAG_REF_ALLOC);

10618

NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));

10619

}

10620

return NDR_ERR_SUCCESS;

10621

}

10622

10623

_PUBLIC_ void ndr_print_samr_CreateUser2(struct ndr_print *ndr, const char *name, int flags, const struct samr_CreateUser2 *r)

10624

{

10625

ndr_print_struct(ndr, name, "samr_CreateUser2");

10626

if (r == NULL) { ndr_print_null(ndr); return; }

10627

ndr->depth++;

10628

if (flags & NDR_SET_VALUES) {

10629

ndr->flags |= LIBNDR_PRINT_SET_VALUES;

10630

}

10631

if (flags & NDR_IN) {

10632

ndr_print_struct(ndr, "in", "samr_CreateUser2");

10633

ndr->depth++;

10634

ndr_print_ptr(ndr, "domain_handle", r->in.domain_handle);

10635

ndr->depth++;

10636

ndr_print_policy_handle(ndr, "domain_handle", r->in.domain_handle);

10637

ndr->depth--;

10638

ndr_print_ptr(ndr, "account_name", r->in.account_name);

10639

ndr->depth++;

10640

ndr_print_lsa_String(ndr, "account_name", r->in.account_name);

10641

ndr->depth--;

10642

ndr_print_samr_AcctFlags(ndr, "acct_flags", r->in.acct_flags);

10643

ndr_print_samr_UserAccessMask(ndr, "access_mask", r->in.access_mask);

10644

ndr->depth--;

10645

}

10646

if (flags & NDR_OUT) {

10647

ndr_print_struct(ndr, "out", "samr_CreateUser2");

10648

ndr->depth++;

10649

ndr_print_ptr(ndr, "user_handle", r->out.user_handle);

10650

ndr->depth++;

10651

ndr_print_policy_handle(ndr, "user_handle", r->out.user_handle);

10652

ndr->depth--;

10653

ndr_print_ptr(ndr, "access_granted", r->out.access_granted);

10654

ndr->depth++;

10655

ndr_print_uint32(ndr, "access_granted", *r->out.access_granted);

10656

ndr->depth--;

10657

ndr_print_ptr(ndr, "rid", r->out.rid);

10658

ndr->depth++;

10659

ndr_print_uint32(ndr, "rid", *r->out.rid);

10660

ndr->depth--;

10661

ndr_print_NTSTATUS(ndr, "result", r->out.result);

10662

ndr->depth--;

10663

}

10664

ndr->depth--;

10665

}

10666

10667

static enum ndr_err_code ndr_push_samr_QueryDisplayInfo3(struct ndr_push *ndr, int flags, const struct samr_QueryDisplayInfo3 *r)

10668

{

10669

if (flags & NDR_IN) {

10670

if (r->in.domain_handle == NULL) {

10671

return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");

10672

}

10673

NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));

10674

NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->in.level));

10675

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.start_idx));

10676

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.max_entries));

10677

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.buf_size));

10678

}

10679

if (flags & NDR_OUT) {

10680

if (r->out.total_size == NULL) {

10681

return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");

10682

}

10683

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.total_size));

10684

if (r->out.returned_size == NULL) {

10685

return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");

10686

}

10687

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.returned_size));

10688

if (r->out.info == NULL) {

10689

return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");

10690

}

10691

NDR_CHECK(ndr_push_set_switch_value(ndr, r->out.info, r->in.level));

10692

NDR_CHECK(ndr_push_samr_DispInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.info));

10693

NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));

10694

}

10695

return NDR_ERR_SUCCESS;

10696

}

10697

10698

static enum ndr_err_code ndr_pull_samr_QueryDisplayInfo3(struct ndr_pull *ndr, int flags, struct samr_QueryDisplayInfo3 *r)

10699

{

10700

TALLOC_CTX *_mem_save_domain_handle_0;

10701

TALLOC_CTX *_mem_save_total_size_0;

10702

TALLOC_CTX *_mem_save_returned_size_0;

10703

TALLOC_CTX *_mem_save_info_0;

10704

if (flags & NDR_IN) {

10705

ZERO_STRUCT(r->out);

10706

10707

if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {

10708

NDR_PULL_ALLOC(ndr, r->in.domain_handle);

10709

}

10710

_mem_save_domain_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);

10711

NDR_PULL_SET_MEM_CTX(ndr, r->in.domain_handle, LIBNDR_FLAG_REF_ALLOC);

10712

NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));

10713

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domain_handle_0, LIBNDR_FLAG_REF_ALLOC);

10714

NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->in.level));

10715

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.start_idx));

10716

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.max_entries));

10717

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.buf_size));

10718

NDR_PULL_ALLOC(ndr, r->out.total_size);

10719

ZERO_STRUCTP(r->out.total_size);

10720

NDR_PULL_ALLOC(ndr, r->out.returned_size);

10721

ZERO_STRUCTP(r->out.returned_size);

10722

NDR_PULL_ALLOC(ndr, r->out.info);

10723

ZERO_STRUCTP(r->out.info);

10724

}

10725

if (flags & NDR_OUT) {

10726

if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {

10727

NDR_PULL_ALLOC(ndr, r->out.total_size);

10728

}

10729

_mem_save_total_size_0 = NDR_PULL_GET_MEM_CTX(ndr);

10730

NDR_PULL_SET_MEM_CTX(ndr, r->out.total_size, LIBNDR_FLAG_REF_ALLOC);

10731

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.total_size));

10732

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_total_size_0, LIBNDR_FLAG_REF_ALLOC);

10733

if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {

10734

NDR_PULL_ALLOC(ndr, r->out.returned_size);

10735

}

10736

_mem_save_returned_size_0 = NDR_PULL_GET_MEM_CTX(ndr);

10737

NDR_PULL_SET_MEM_CTX(ndr, r->out.returned_size, LIBNDR_FLAG_REF_ALLOC);

10738

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.returned_size));

10739

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_returned_size_0, LIBNDR_FLAG_REF_ALLOC);

10740

if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {

10741

NDR_PULL_ALLOC(ndr, r->out.info);

10742

}

10743

_mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);

10744

NDR_PULL_SET_MEM_CTX(ndr, r->out.info, LIBNDR_FLAG_REF_ALLOC);

10745

NDR_CHECK(ndr_pull_set_switch_value(ndr, r->out.info, r->in.level));

10746

NDR_CHECK(ndr_pull_samr_DispInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.info));

10747

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, LIBNDR_FLAG_REF_ALLOC);

10748

NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));

10749

}

10750

return NDR_ERR_SUCCESS;

10751

}

10752

10753

_PUBLIC_ void ndr_print_samr_QueryDisplayInfo3(struct ndr_print *ndr, const char *name, int flags, const struct samr_QueryDisplayInfo3 *r)

10754

{

10755

ndr_print_struct(ndr, name, "samr_QueryDisplayInfo3");

10756

if (r == NULL) { ndr_print_null(ndr); return; }

10757

ndr->depth++;

10758

if (flags & NDR_SET_VALUES) {

10759

ndr->flags |= LIBNDR_PRINT_SET_VALUES;

10760

}

10761

if (flags & NDR_IN) {

10762

ndr_print_struct(ndr, "in", "samr_QueryDisplayInfo3");

10763

ndr->depth++;

10764

ndr_print_ptr(ndr, "domain_handle", r->in.domain_handle);

10765

ndr->depth++;

10766

ndr_print_policy_handle(ndr, "domain_handle", r->in.domain_handle);

10767

ndr->depth--;

10768

ndr_print_uint16(ndr, "level", r->in.level);

10769

ndr_print_uint32(ndr, "start_idx", r->in.start_idx);

10770

ndr_print_uint32(ndr, "max_entries", r->in.max_entries);

10771

ndr_print_uint32(ndr, "buf_size", r->in.buf_size);

10772

ndr->depth--;

10773

}

10774

if (flags & NDR_OUT) {

10775

ndr_print_struct(ndr, "out", "samr_QueryDisplayInfo3");

10776

ndr->depth++;

10777

ndr_print_ptr(ndr, "total_size", r->out.total_size);

10778

ndr->depth++;

10779

ndr_print_uint32(ndr, "total_size", *r->out.total_size);

10780

ndr->depth--;

10781

ndr_print_ptr(ndr, "returned_size", r->out.returned_size);

10782

ndr->depth++;

10783

ndr_print_uint32(ndr, "returned_size", *r->out.returned_size);

10784

ndr->depth--;

10785

ndr_print_ptr(ndr, "info", r->out.info);

10786

ndr->depth++;

10787

ndr_print_set_switch_value(ndr, r->out.info, r->in.level);

10788

ndr_print_samr_DispInfo(ndr, "info", r->out.info);

10789

ndr->depth--;

10790

ndr_print_NTSTATUS(ndr, "result", r->out.result);

10791

ndr->depth--;

10792

}

10793

ndr->depth--;

10794

}

10795

10796

static enum ndr_err_code ndr_push_samr_AddMultipleMembersToAlias(struct ndr_push *ndr, int flags, const struct samr_AddMultipleMembersToAlias *r)

10797

{

10798

if (flags & NDR_IN) {

10799

if (r->in.alias_handle == NULL) {

10800

return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");

10801

}

10802

NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.alias_handle));

10803

if (r->in.sids == NULL) {

10804

return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");

10805

}

10806

NDR_CHECK(ndr_push_lsa_SidArray(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.sids));

10807

}

10808

if (flags & NDR_OUT) {

10809

NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));

10810

}

10811

return NDR_ERR_SUCCESS;

10812

}

10813

10814

static enum ndr_err_code ndr_pull_samr_AddMultipleMembersToAlias(struct ndr_pull *ndr, int flags, struct samr_AddMultipleMembersToAlias *r)

10815

{

10816

TALLOC_CTX *_mem_save_alias_handle_0;

10817

TALLOC_CTX *_mem_save_sids_0;

10818

if (flags & NDR_IN) {

10819

if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {

10820

NDR_PULL_ALLOC(ndr, r->in.alias_handle);

10821

}

10822

_mem_save_alias_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);

10823

NDR_PULL_SET_MEM_CTX(ndr, r->in.alias_handle, LIBNDR_FLAG_REF_ALLOC);

10824

NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.alias_handle));

10825

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_alias_handle_0, LIBNDR_FLAG_REF_ALLOC);

10826

if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {

10827

NDR_PULL_ALLOC(ndr, r->in.sids);

10828

}

10829

_mem_save_sids_0 = NDR_PULL_GET_MEM_CTX(ndr);

10830

NDR_PULL_SET_MEM_CTX(ndr, r->in.sids, LIBNDR_FLAG_REF_ALLOC);

10831

NDR_CHECK(ndr_pull_lsa_SidArray(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.sids));

10832

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sids_0, LIBNDR_FLAG_REF_ALLOC);

10833

}

10834

if (flags & NDR_OUT) {

10835

NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));

10836

}

10837

return NDR_ERR_SUCCESS;

10838

}

10839

10840

_PUBLIC_ void ndr_print_samr_AddMultipleMembersToAlias(struct ndr_print *ndr, const char *name, int flags, const struct samr_AddMultipleMembersToAlias *r)

10841

{

10842

ndr_print_struct(ndr, name, "samr_AddMultipleMembersToAlias");

10843

if (r == NULL) { ndr_print_null(ndr); return; }

10844

ndr->depth++;

10845

if (flags & NDR_SET_VALUES) {

10846

ndr->flags |= LIBNDR_PRINT_SET_VALUES;

10847

}

10848

if (flags & NDR_IN) {

10849

ndr_print_struct(ndr, "in", "samr_AddMultipleMembersToAlias");

10850

ndr->depth++;

10851

ndr_print_ptr(ndr, "alias_handle", r->in.alias_handle);

10852

ndr->depth++;

10853

ndr_print_policy_handle(ndr, "alias_handle", r->in.alias_handle);

10854

ndr->depth--;

10855

ndr_print_ptr(ndr, "sids", r->in.sids);

10856

ndr->depth++;

10857

ndr_print_lsa_SidArray(ndr, "sids", r->in.sids);

10858

ndr->depth--;

10859

ndr->depth--;

10860

}

10861

if (flags & NDR_OUT) {

10862

ndr_print_struct(ndr, "out", "samr_AddMultipleMembersToAlias");

10863

ndr->depth++;

10864

ndr_print_NTSTATUS(ndr, "result", r->out.result);

10865

ndr->depth--;

10866

}

10867

ndr->depth--;

10868

}

10869

10870

static enum ndr_err_code ndr_push_samr_RemoveMultipleMembersFromAlias(struct ndr_push *ndr, int flags, const struct samr_RemoveMultipleMembersFromAlias *r)

10871

{

10872

if (flags & NDR_IN) {

10873

if (r->in.alias_handle == NULL) {

10874

return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");

10875

}

10876

NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.alias_handle));

10877

if (r->in.sids == NULL) {

10878

return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");

10879

}

10880

NDR_CHECK(ndr_push_lsa_SidArray(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.sids));

10881

}

10882

if (flags & NDR_OUT) {

10883

NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));

10884

}

10885

return NDR_ERR_SUCCESS;

10886

}

10887

10888

static enum ndr_err_code ndr_pull_samr_RemoveMultipleMembersFromAlias(struct ndr_pull *ndr, int flags, struct samr_RemoveMultipleMembersFromAlias *r)

10889

{

10890

TALLOC_CTX *_mem_save_alias_handle_0;

10891

TALLOC_CTX *_mem_save_sids_0;

10892

if (flags & NDR_IN) {

10893

if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {

10894

NDR_PULL_ALLOC(ndr, r->in.alias_handle);

10895

}

10896

_mem_save_alias_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);

10897

NDR_PULL_SET_MEM_CTX(ndr, r->in.alias_handle, LIBNDR_FLAG_REF_ALLOC);

10898

NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.alias_handle));

10899

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_alias_handle_0, LIBNDR_FLAG_REF_ALLOC);

10900

if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {

10901

NDR_PULL_ALLOC(ndr, r->in.sids);

10902

}

10903

_mem_save_sids_0 = NDR_PULL_GET_MEM_CTX(ndr);

10904

NDR_PULL_SET_MEM_CTX(ndr, r->in.sids, LIBNDR_FLAG_REF_ALLOC);

10905

NDR_CHECK(ndr_pull_lsa_SidArray(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.sids));

10906

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sids_0, LIBNDR_FLAG_REF_ALLOC);

10907

}

10908

if (flags & NDR_OUT) {

10909

NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));

10910

}

10911

return NDR_ERR_SUCCESS;

10912

}

10913

10914

_PUBLIC_ void ndr_print_samr_RemoveMultipleMembersFromAlias(struct ndr_print *ndr, const char *name, int flags, const struct samr_RemoveMultipleMembersFromAlias *r)

10915

{

10916

ndr_print_struct(ndr, name, "samr_RemoveMultipleMembersFromAlias");

10917

if (r == NULL) { ndr_print_null(ndr); return; }

10918

ndr->depth++;

10919

if (flags & NDR_SET_VALUES) {

10920

ndr->flags |= LIBNDR_PRINT_SET_VALUES;

10921

}

10922

if (flags & NDR_IN) {

10923

ndr_print_struct(ndr, "in", "samr_RemoveMultipleMembersFromAlias");

10924

ndr->depth++;

10925

ndr_print_ptr(ndr, "alias_handle", r->in.alias_handle);

10926

ndr->depth++;

10927

ndr_print_policy_handle(ndr, "alias_handle", r->in.alias_handle);

10928

ndr->depth--;

10929

ndr_print_ptr(ndr, "sids", r->in.sids);

10930

ndr->depth++;

10931

ndr_print_lsa_SidArray(ndr, "sids", r->in.sids);

10932

ndr->depth--;

10933

ndr->depth--;

10934

}

10935

if (flags & NDR_OUT) {

10936

ndr_print_struct(ndr, "out", "samr_RemoveMultipleMembersFromAlias");

10937

ndr->depth++;

10938

ndr_print_NTSTATUS(ndr, "result", r->out.result);

10939

ndr->depth--;

10940

}

10941

ndr->depth--;

10942

}

10943

10944

static enum ndr_err_code ndr_push_samr_OemChangePasswordUser2(struct ndr_push *ndr, int flags, const struct samr_OemChangePasswordUser2 *r)

10945

{

10946

if (flags & NDR_IN) {

10947

NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server));

10948

if (r->in.server) {

10949

NDR_CHECK(ndr_push_lsa_AsciiString(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.server));

10950

}

10951

if (r->in.account == NULL) {

10952

return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");

10953

}

10954

NDR_CHECK(ndr_push_lsa_AsciiString(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.account));

10955

NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.password));

10956

if (r->in.password) {

10957

NDR_CHECK(ndr_push_samr_CryptPassword(ndr, NDR_SCALARS, r->in.password));

10958

}

10959

NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.hash));

10960

if (r->in.hash) {

10961

NDR_CHECK(ndr_push_samr_Password(ndr, NDR_SCALARS, r->in.hash));

10962

}

10963

}

10964

if (flags & NDR_OUT) {

10965

NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));

10966

}

10967

return NDR_ERR_SUCCESS;

10968

}

10969

10970

static enum ndr_err_code ndr_pull_samr_OemChangePasswordUser2(struct ndr_pull *ndr, int flags, struct samr_OemChangePasswordUser2 *r)

10971

{

10972

uint32_t _ptr_server;

10973

uint32_t _ptr_password;

10974

uint32_t _ptr_hash;

10975

TALLOC_CTX *_mem_save_server_0;

10976

TALLOC_CTX *_mem_save_account_0;

10977

TALLOC_CTX *_mem_save_password_0;

10978

TALLOC_CTX *_mem_save_hash_0;

10979

if (flags & NDR_IN) {

10980

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server));

10981

if (_ptr_server) {

10982

NDR_PULL_ALLOC(ndr, r->in.server);

10983

} else {

10984

r->in.server = NULL;

10985

}

10986

if (r->in.server) {

10987

_mem_save_server_0 = NDR_PULL_GET_MEM_CTX(ndr);

10988

NDR_PULL_SET_MEM_CTX(ndr, r->in.server, 0);

10989

NDR_CHECK(ndr_pull_lsa_AsciiString(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.server));

10990

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_0, 0);

10991

}

10992

if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {

10993

NDR_PULL_ALLOC(ndr, r->in.account);

10994

}

10995

_mem_save_account_0 = NDR_PULL_GET_MEM_CTX(ndr);

10996

NDR_PULL_SET_MEM_CTX(ndr, r->in.account, LIBNDR_FLAG_REF_ALLOC);

10997

NDR_CHECK(ndr_pull_lsa_AsciiString(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.account));

10998

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_account_0, LIBNDR_FLAG_REF_ALLOC);

10999

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_password));

11000

if (_ptr_password) {

11001

NDR_PULL_ALLOC(ndr, r->in.password);

11002

} else {

11003

r->in.password = NULL;

11004

}

11005

if (r->in.password) {

11006

_mem_save_password_0 = NDR_PULL_GET_MEM_CTX(ndr);

11007

NDR_PULL_SET_MEM_CTX(ndr, r->in.password, 0);

11008

NDR_CHECK(ndr_pull_samr_CryptPassword(ndr, NDR_SCALARS, r->in.password));

11009

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_password_0, 0);

11010

}

11011

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_hash));

11012

if (_ptr_hash) {

11013

NDR_PULL_ALLOC(ndr, r->in.hash);

11014

} else {

11015

r->in.hash = NULL;

11016

}

11017

if (r->in.hash) {

11018

_mem_save_hash_0 = NDR_PULL_GET_MEM_CTX(ndr);

11019

NDR_PULL_SET_MEM_CTX(ndr, r->in.hash, 0);

11020

NDR_CHECK(ndr_pull_samr_Password(ndr, NDR_SCALARS, r->in.hash));

11021

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_hash_0, 0);

11022

}

11023

}

11024

if (flags & NDR_OUT) {

11025

NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));

11026

}

11027

return NDR_ERR_SUCCESS;

11028

}

11029

11030

_PUBLIC_ void ndr_print_samr_OemChangePasswordUser2(struct ndr_print *ndr, const char *name, int flags, const struct samr_OemChangePasswordUser2 *r)

11031

{

11032

ndr_print_struct(ndr, name, "samr_OemChangePasswordUser2");

11033

if (r == NULL) { ndr_print_null(ndr); return; }

11034

ndr->depth++;

11035

if (flags & NDR_SET_VALUES) {

11036

ndr->flags |= LIBNDR_PRINT_SET_VALUES;

11037

}

11038

if (flags & NDR_IN) {

11039

ndr_print_struct(ndr, "in", "samr_OemChangePasswordUser2");

11040

ndr->depth++;

11041

ndr_print_ptr(ndr, "server", r->in.server);

11042

ndr->depth++;

11043

if (r->in.server) {

11044

ndr_print_lsa_AsciiString(ndr, "server", r->in.server);

11045

}

11046

ndr->depth--;

11047

ndr_print_ptr(ndr, "account", r->in.account);

11048

ndr->depth++;

11049

ndr_print_lsa_AsciiString(ndr, "account", r->in.account);

11050

ndr->depth--;

11051

ndr_print_ptr(ndr, "password", r->in.password);

11052

ndr->depth++;

11053

if (r->in.password) {

11054

ndr_print_samr_CryptPassword(ndr, "password", r->in.password);

11055

}

11056

ndr->depth--;

11057

ndr_print_ptr(ndr, "hash", r->in.hash);

11058

ndr->depth++;

11059

if (r->in.hash) {

11060

ndr_print_samr_Password(ndr, "hash", r->in.hash);

11061

}

11062

ndr->depth--;

11063

ndr->depth--;

11064

}

11065

if (flags & NDR_OUT) {

11066

ndr_print_struct(ndr, "out", "samr_OemChangePasswordUser2");

11067

ndr->depth++;

11068

ndr_print_NTSTATUS(ndr, "result", r->out.result);

11069

ndr->depth--;

11070

}

11071

ndr->depth--;

11072

}

11073

11074

static enum ndr_err_code ndr_push_samr_ChangePasswordUser2(struct ndr_push *ndr, int flags, const struct samr_ChangePasswordUser2 *r)

11075

{

11076

if (flags & NDR_IN) {

11077

NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server));

11078

if (r->in.server) {

11079

NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.server));

11080

}

11081

if (r->in.account == NULL) {

11082

return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");

11083

}

11084

NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.account));

11085

NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.nt_password));

11086

if (r->in.nt_password) {

11087

NDR_CHECK(ndr_push_samr_CryptPassword(ndr, NDR_SCALARS, r->in.nt_password));

11088

}

11089

NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.nt_verifier));

11090

if (r->in.nt_verifier) {

11091

NDR_CHECK(ndr_push_samr_Password(ndr, NDR_SCALARS, r->in.nt_verifier));

11092

}

11093

NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->in.lm_change));

11094

NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.lm_password));

11095

if (r->in.lm_password) {

11096

NDR_CHECK(ndr_push_samr_CryptPassword(ndr, NDR_SCALARS, r->in.lm_password));

11097

}

11098

NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.lm_verifier));

11099

if (r->in.lm_verifier) {

11100

NDR_CHECK(ndr_push_samr_Password(ndr, NDR_SCALARS, r->in.lm_verifier));

11101

}

11102

}

11103

if (flags & NDR_OUT) {

11104

NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));

11105

}

11106

return NDR_ERR_SUCCESS;

11107

}

11108

11109

static enum ndr_err_code ndr_pull_samr_ChangePasswordUser2(struct ndr_pull *ndr, int flags, struct samr_ChangePasswordUser2 *r)

11110

{

11111

uint32_t _ptr_server;

11112

uint32_t _ptr_nt_password;

11113

uint32_t _ptr_nt_verifier;

11114

uint32_t _ptr_lm_password;

11115

uint32_t _ptr_lm_verifier;

11116

TALLOC_CTX *_mem_save_server_0;

11117

TALLOC_CTX *_mem_save_account_0;

11118

TALLOC_CTX *_mem_save_nt_password_0;

11119

TALLOC_CTX *_mem_save_nt_verifier_0;

11120

TALLOC_CTX *_mem_save_lm_password_0;

11121

TALLOC_CTX *_mem_save_lm_verifier_0;

11122

if (flags & NDR_IN) {

11123

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server));

11124

if (_ptr_server) {

11125

NDR_PULL_ALLOC(ndr, r->in.server);

11126

} else {

11127

r->in.server = NULL;

11128

}

11129

if (r->in.server) {

11130

_mem_save_server_0 = NDR_PULL_GET_MEM_CTX(ndr);

11131

NDR_PULL_SET_MEM_CTX(ndr, r->in.server, 0);

11132

NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.server));

11133

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_0, 0);

11134

}

11135

if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {

11136

NDR_PULL_ALLOC(ndr, r->in.account);

11137

}

11138

_mem_save_account_0 = NDR_PULL_GET_MEM_CTX(ndr);

11139

NDR_PULL_SET_MEM_CTX(ndr, r->in.account, LIBNDR_FLAG_REF_ALLOC);

11140

NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.account));

11141

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_account_0, LIBNDR_FLAG_REF_ALLOC);

11142

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_nt_password));

11143

if (_ptr_nt_password) {

11144

NDR_PULL_ALLOC(ndr, r->in.nt_password);

11145

} else {

11146

r->in.nt_password = NULL;

11147

}

11148

if (r->in.nt_password) {

11149

_mem_save_nt_password_0 = NDR_PULL_GET_MEM_CTX(ndr);

11150

NDR_PULL_SET_MEM_CTX(ndr, r->in.nt_password, 0);

11151

NDR_CHECK(ndr_pull_samr_CryptPassword(ndr, NDR_SCALARS, r->in.nt_password));

11152

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_nt_password_0, 0);

11153

}

11154

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_nt_verifier));

11155

if (_ptr_nt_verifier) {

11156

NDR_PULL_ALLOC(ndr, r->in.nt_verifier);

11157

} else {

11158

r->in.nt_verifier = NULL;

11159

}

11160

if (r->in.nt_verifier) {

11161

_mem_save_nt_verifier_0 = NDR_PULL_GET_MEM_CTX(ndr);

11162

NDR_PULL_SET_MEM_CTX(ndr, r->in.nt_verifier, 0);

11163

NDR_CHECK(ndr_pull_samr_Password(ndr, NDR_SCALARS, r->in.nt_verifier));

11164

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_nt_verifier_0, 0);

11165

}

11166

NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->in.lm_change));

11167

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_lm_password));

11168

if (_ptr_lm_password) {

11169

NDR_PULL_ALLOC(ndr, r->in.lm_password);

11170

} else {

11171

r->in.lm_password = NULL;

11172

}

11173

if (r->in.lm_password) {

11174

_mem_save_lm_password_0 = NDR_PULL_GET_MEM_CTX(ndr);

11175

NDR_PULL_SET_MEM_CTX(ndr, r->in.lm_password, 0);

11176

NDR_CHECK(ndr_pull_samr_CryptPassword(ndr, NDR_SCALARS, r->in.lm_password));

11177

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_lm_password_0, 0);

11178

}

11179

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_lm_verifier));

11180

if (_ptr_lm_verifier) {

11181

NDR_PULL_ALLOC(ndr, r->in.lm_verifier);

11182

} else {

11183

r->in.lm_verifier = NULL;

11184

}

11185

if (r->in.lm_verifier) {

11186

_mem_save_lm_verifier_0 = NDR_PULL_GET_MEM_CTX(ndr);

11187

NDR_PULL_SET_MEM_CTX(ndr, r->in.lm_verifier, 0);

11188

NDR_CHECK(ndr_pull_samr_Password(ndr, NDR_SCALARS, r->in.lm_verifier));

11189

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_lm_verifier_0, 0);

11190

}

11191

}

11192

if (flags & NDR_OUT) {

11193

NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));

11194

}

11195

return NDR_ERR_SUCCESS;

11196

}

11197

11198

_PUBLIC_ void ndr_print_samr_ChangePasswordUser2(struct ndr_print *ndr, const char *name, int flags, const struct samr_ChangePasswordUser2 *r)

11199

{

11200

ndr_print_struct(ndr, name, "samr_ChangePasswordUser2");

11201

if (r == NULL) { ndr_print_null(ndr); return; }

11202

ndr->depth++;

11203

if (flags & NDR_SET_VALUES) {

11204

ndr->flags |= LIBNDR_PRINT_SET_VALUES;

11205

}

11206

if (flags & NDR_IN) {

11207

ndr_print_struct(ndr, "in", "samr_ChangePasswordUser2");

11208

ndr->depth++;

11209

ndr_print_ptr(ndr, "server", r->in.server);

11210

ndr->depth++;

11211

if (r->in.server) {

11212

ndr_print_lsa_String(ndr, "server", r->in.server);

11213

}

11214

ndr->depth--;

11215

ndr_print_ptr(ndr, "account", r->in.account);

11216

ndr->depth++;

11217

ndr_print_lsa_String(ndr, "account", r->in.account);

11218

ndr->depth--;

11219

ndr_print_ptr(ndr, "nt_password", r->in.nt_password);

11220

ndr->depth++;

11221

if (r->in.nt_password) {

11222

ndr_print_samr_CryptPassword(ndr, "nt_password", r->in.nt_password);

11223

}

11224

ndr->depth--;

11225

ndr_print_ptr(ndr, "nt_verifier", r->in.nt_verifier);

11226

ndr->depth++;

11227

if (r->in.nt_verifier) {

11228

ndr_print_samr_Password(ndr, "nt_verifier", r->in.nt_verifier);

11229

}

11230

ndr->depth--;

11231

ndr_print_uint8(ndr, "lm_change", r->in.lm_change);

11232

ndr_print_ptr(ndr, "lm_password", r->in.lm_password);

11233

ndr->depth++;

11234

if (r->in.lm_password) {

11235

ndr_print_samr_CryptPassword(ndr, "lm_password", r->in.lm_password);

11236

}

11237

ndr->depth--;

11238

ndr_print_ptr(ndr, "lm_verifier", r->in.lm_verifier);

11239

ndr->depth++;

11240

if (r->in.lm_verifier) {

11241

ndr_print_samr_Password(ndr, "lm_verifier", r->in.lm_verifier);

11242

}

11243

ndr->depth--;

11244

ndr->depth--;

11245

}

11246

if (flags & NDR_OUT) {

11247

ndr_print_struct(ndr, "out", "samr_ChangePasswordUser2");

11248

ndr->depth++;

11249

ndr_print_NTSTATUS(ndr, "result", r->out.result);

11250

ndr->depth--;

11251

}

11252

ndr->depth--;

11253

}

11254

11255

static enum ndr_err_code ndr_push_samr_GetDomPwInfo(struct ndr_push *ndr, int flags, const struct samr_GetDomPwInfo *r)

11256

{

11257

if (flags & NDR_IN) {

11258

NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.domain_name));

11259

if (r->in.domain_name) {

11260

NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.domain_name));

11261

}

11262

}

11263

if (flags & NDR_OUT) {

11264

if (r->out.info == NULL) {

11265

return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");

11266

}

11267

NDR_CHECK(ndr_push_samr_PwInfo(ndr, NDR_SCALARS, r->out.info));

11268

NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));

11269

}

11270

return NDR_ERR_SUCCESS;

11271

}

11272

11273

static enum ndr_err_code ndr_pull_samr_GetDomPwInfo(struct ndr_pull *ndr, int flags, struct samr_GetDomPwInfo *r)

11274

{

11275

uint32_t _ptr_domain_name;

11276

TALLOC_CTX *_mem_save_domain_name_0;

11277

TALLOC_CTX *_mem_save_info_0;

11278

if (flags & NDR_IN) {

11279

ZERO_STRUCT(r->out);

11280

11281

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_domain_name));

11282

if (_ptr_domain_name) {

11283

NDR_PULL_ALLOC(ndr, r->in.domain_name);

11284

} else {

11285

r->in.domain_name = NULL;

11286

}

11287

if (r->in.domain_name) {

11288

_mem_save_domain_name_0 = NDR_PULL_GET_MEM_CTX(ndr);

11289

NDR_PULL_SET_MEM_CTX(ndr, r->in.domain_name, 0);

11290

NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.domain_name));

11291

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domain_name_0, 0);

11292

}

11293

NDR_PULL_ALLOC(ndr, r->out.info);

11294

ZERO_STRUCTP(r->out.info);

11295

}

11296

if (flags & NDR_OUT) {

11297

if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {

11298

NDR_PULL_ALLOC(ndr, r->out.info);

11299

}

11300

_mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);

11301

NDR_PULL_SET_MEM_CTX(ndr, r->out.info, LIBNDR_FLAG_REF_ALLOC);

11302

NDR_CHECK(ndr_pull_samr_PwInfo(ndr, NDR_SCALARS, r->out.info));

11303

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, LIBNDR_FLAG_REF_ALLOC);

11304

NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));

11305

}

11306

return NDR_ERR_SUCCESS;

11307

}

11308

11309

_PUBLIC_ void ndr_print_samr_GetDomPwInfo(struct ndr_print *ndr, const char *name, int flags, const struct samr_GetDomPwInfo *r)

11310

{

11311

ndr_print_struct(ndr, name, "samr_GetDomPwInfo");

11312

if (r == NULL) { ndr_print_null(ndr); return; }

11313

ndr->depth++;

11314

if (flags & NDR_SET_VALUES) {

11315

ndr->flags |= LIBNDR_PRINT_SET_VALUES;

11316

}

11317

if (flags & NDR_IN) {

11318

ndr_print_struct(ndr, "in", "samr_GetDomPwInfo");

11319

ndr->depth++;

11320

ndr_print_ptr(ndr, "domain_name", r->in.domain_name);

11321

ndr->depth++;

11322

if (r->in.domain_name) {

11323

ndr_print_lsa_String(ndr, "domain_name", r->in.domain_name);

11324

}

11325

ndr->depth--;

11326

ndr->depth--;

11327

}

11328

if (flags & NDR_OUT) {

11329

ndr_print_struct(ndr, "out", "samr_GetDomPwInfo");

11330

ndr->depth++;

11331

ndr_print_ptr(ndr, "info", r->out.info);

11332

ndr->depth++;

11333

ndr_print_samr_PwInfo(ndr, "info", r->out.info);

11334

ndr->depth--;

11335

ndr_print_NTSTATUS(ndr, "result", r->out.result);

11336

ndr->depth--;

11337

}

11338

ndr->depth--;

11339

}

11340

11341

static enum ndr_err_code ndr_push_samr_Connect2(struct ndr_push *ndr, int flags, const struct samr_Connect2 *r)

11342

{

11343

if (flags & NDR_IN) {

11344

NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.system_name));

11345

if (r->in.system_name) {

11346

NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.system_name, CH_UTF16)));

11347

NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));

11348

NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.system_name, CH_UTF16)));

11349

NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.system_name, ndr_charset_length(r->in.system_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));

11350

}

11351

NDR_CHECK(ndr_push_samr_ConnectAccessMask(ndr, NDR_SCALARS, r->in.access_mask));

11352

}

11353

if (flags & NDR_OUT) {

11354

if (r->out.connect_handle == NULL) {

11355

return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");

11356

}

11357

NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.connect_handle));

11358

NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));

11359

}

11360

return NDR_ERR_SUCCESS;

11361

}

11362

11363

static enum ndr_err_code ndr_pull_samr_Connect2(struct ndr_pull *ndr, int flags, struct samr_Connect2 *r)

11364

{

11365

uint32_t _ptr_system_name;

11366

TALLOC_CTX *_mem_save_system_name_0;

11367

TALLOC_CTX *_mem_save_connect_handle_0;

11368

if (flags & NDR_IN) {

11369

ZERO_STRUCT(r->out);

11370

11371

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_system_name));

11372

if (_ptr_system_name) {

11373

NDR_PULL_ALLOC(ndr, r->in.system_name);

11374

} else {

11375

r->in.system_name = NULL;

11376

}

11377

if (r->in.system_name) {

11378

_mem_save_system_name_0 = NDR_PULL_GET_MEM_CTX(ndr);

11379

NDR_PULL_SET_MEM_CTX(ndr, r->in.system_name, 0);

11380

NDR_CHECK(ndr_pull_array_size(ndr, &r->in.system_name));

11381

NDR_CHECK(ndr_pull_array_length(ndr, &r->in.system_name));

11382

if (ndr_get_array_length(ndr, &r->in.system_name) > ndr_get_array_size(ndr, &r->in.system_name)) {

11383

return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->in.system_name), ndr_get_array_length(ndr, &r->in.system_name));

11384

}

11385

NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.system_name), sizeof(uint16_t)));

11386

NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.system_name, ndr_get_array_length(ndr, &r->in.system_name), sizeof(uint16_t), CH_UTF16));

11387

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_system_name_0, 0);

11388

}

11389

NDR_CHECK(ndr_pull_samr_ConnectAccessMask(ndr, NDR_SCALARS, &r->in.access_mask));

11390

NDR_PULL_ALLOC(ndr, r->out.connect_handle);

11391

ZERO_STRUCTP(r->out.connect_handle);

11392

}

11393

if (flags & NDR_OUT) {

11394

if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {

11395

NDR_PULL_ALLOC(ndr, r->out.connect_handle);

11396

}

11397

_mem_save_connect_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);

11398

NDR_PULL_SET_MEM_CTX(ndr, r->out.connect_handle, LIBNDR_FLAG_REF_ALLOC);

11399

NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.connect_handle));

11400

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_connect_handle_0, LIBNDR_FLAG_REF_ALLOC);

11401

NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));

11402

}

11403

return NDR_ERR_SUCCESS;

11404

}

11405

11406

_PUBLIC_ void ndr_print_samr_Connect2(struct ndr_print *ndr, const char *name, int flags, const struct samr_Connect2 *r)

11407

{

11408

ndr_print_struct(ndr, name, "samr_Connect2");

11409

if (r == NULL) { ndr_print_null(ndr); return; }

11410

ndr->depth++;

11411

if (flags & NDR_SET_VALUES) {

11412

ndr->flags |= LIBNDR_PRINT_SET_VALUES;

11413

}

11414

if (flags & NDR_IN) {

11415

ndr_print_struct(ndr, "in", "samr_Connect2");

11416

ndr->depth++;

11417

ndr_print_ptr(ndr, "system_name", r->in.system_name);

11418

ndr->depth++;

11419

if (r->in.system_name) {

11420

ndr_print_string(ndr, "system_name", r->in.system_name);

11421

}

11422

ndr->depth--;

11423

ndr_print_samr_ConnectAccessMask(ndr, "access_mask", r->in.access_mask);

11424

ndr->depth--;

11425

}

11426

if (flags & NDR_OUT) {

11427

ndr_print_struct(ndr, "out", "samr_Connect2");

11428

ndr->depth++;

11429

ndr_print_ptr(ndr, "connect_handle", r->out.connect_handle);

11430

ndr->depth++;

11431

ndr_print_policy_handle(ndr, "connect_handle", r->out.connect_handle);

11432

ndr->depth--;

11433

ndr_print_NTSTATUS(ndr, "result", r->out.result);

11434

ndr->depth--;

11435

}

11436

ndr->depth--;

11437

}

11438

11439

_PUBLIC_ enum ndr_err_code ndr_push_samr_SetUserInfo2(struct ndr_push *ndr, int flags, const struct samr_SetUserInfo2 *r)

11440

{

11441

if (flags & NDR_IN) {

11442

if (r->in.user_handle == NULL) {

11443

return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");

11444

}

11445

NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.user_handle));

11446

NDR_CHECK(ndr_push_samr_UserInfoLevel(ndr, NDR_SCALARS, r->in.level));

11447

if (r->in.info == NULL) {

11448

return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");

11449

}

11450

NDR_CHECK(ndr_push_set_switch_value(ndr, r->in.info, r->in.level));

11451

NDR_CHECK(ndr_push_samr_UserInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info));

11452

}

11453

if (flags & NDR_OUT) {

11454

NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));

11455

}

11456

return NDR_ERR_SUCCESS;

11457

}

11458

11459

_PUBLIC_ enum ndr_err_code ndr_pull_samr_SetUserInfo2(struct ndr_pull *ndr, int flags, struct samr_SetUserInfo2 *r)

11460

{

11461

TALLOC_CTX *_mem_save_user_handle_0;

11462

TALLOC_CTX *_mem_save_info_0;

11463

if (flags & NDR_IN) {

11464

if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {

11465

NDR_PULL_ALLOC(ndr, r->in.user_handle);

11466

}

11467

_mem_save_user_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);

11468

NDR_PULL_SET_MEM_CTX(ndr, r->in.user_handle, LIBNDR_FLAG_REF_ALLOC);

11469

NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.user_handle));

11470

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_handle_0, LIBNDR_FLAG_REF_ALLOC);

11471

NDR_CHECK(ndr_pull_samr_UserInfoLevel(ndr, NDR_SCALARS, &r->in.level));

11472

if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {

11473

NDR_PULL_ALLOC(ndr, r->in.info);

11474

}

11475

_mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);

11476

NDR_PULL_SET_MEM_CTX(ndr, r->in.info, LIBNDR_FLAG_REF_ALLOC);

11477

NDR_CHECK(ndr_pull_set_switch_value(ndr, r->in.info, r->in.level));

11478

NDR_CHECK(ndr_pull_samr_UserInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info));

11479

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, LIBNDR_FLAG_REF_ALLOC);

11480

}

11481

if (flags & NDR_OUT) {

11482

NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));

11483

}

11484

return NDR_ERR_SUCCESS;

11485

}

11486

11487

_PUBLIC_ void ndr_print_samr_SetUserInfo2(struct ndr_print *ndr, const char *name, int flags, const struct samr_SetUserInfo2 *r)

11488

{

11489

ndr_print_struct(ndr, name, "samr_SetUserInfo2");

11490

if (r == NULL) { ndr_print_null(ndr); return; }

11491

ndr->depth++;

11492

if (flags & NDR_SET_VALUES) {

11493

ndr->flags |= LIBNDR_PRINT_SET_VALUES;

11494

}

11495

if (flags & NDR_IN) {

11496

ndr_print_struct(ndr, "in", "samr_SetUserInfo2");

11497

ndr->depth++;

11498

ndr_print_ptr(ndr, "user_handle", r->in.user_handle);

11499

ndr->depth++;

11500

ndr_print_policy_handle(ndr, "user_handle", r->in.user_handle);

11501

ndr->depth--;

11502

ndr_print_samr_UserInfoLevel(ndr, "level", r->in.level);

11503

ndr_print_ptr(ndr, "info", r->in.info);

11504

ndr->depth++;

11505

ndr_print_set_switch_value(ndr, r->in.info, r->in.level);

11506

ndr_print_samr_UserInfo(ndr, "info", r->in.info);

11507

ndr->depth--;

11508

ndr->depth--;

11509

}

11510

if (flags & NDR_OUT) {

11511

ndr_print_struct(ndr, "out", "samr_SetUserInfo2");

11512

ndr->depth++;

11513

ndr_print_NTSTATUS(ndr, "result", r->out.result);

11514

ndr->depth--;

11515

}

11516

ndr->depth--;

11517

}

11518

11519

static enum ndr_err_code ndr_push_samr_SetBootKeyInformation(struct ndr_push *ndr, int flags, const struct samr_SetBootKeyInformation *r)

11520

{

11521

if (flags & NDR_IN) {

11522

if (r->in.connect_handle == NULL) {

11523

return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");

11524

}

11525

NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.connect_handle));

11526

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.unknown1));

11527

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.unknown2));

11528

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.unknown3));

11529

}

11530

if (flags & NDR_OUT) {

11531

NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));

11532

}

11533

return NDR_ERR_SUCCESS;

11534

}

11535

11536

static enum ndr_err_code ndr_pull_samr_SetBootKeyInformation(struct ndr_pull *ndr, int flags, struct samr_SetBootKeyInformation *r)

11537

{

11538

TALLOC_CTX *_mem_save_connect_handle_0;

11539

if (flags & NDR_IN) {

11540

if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {

11541

NDR_PULL_ALLOC(ndr, r->in.connect_handle);

11542

}

11543

_mem_save_connect_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);

11544

NDR_PULL_SET_MEM_CTX(ndr, r->in.connect_handle, LIBNDR_FLAG_REF_ALLOC);

11545

NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.connect_handle));

11546

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_connect_handle_0, LIBNDR_FLAG_REF_ALLOC);

11547

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.unknown1));

11548

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.unknown2));

11549

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.unknown3));

11550

}

11551

if (flags & NDR_OUT) {

11552

NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));

11553

}

11554

return NDR_ERR_SUCCESS;

11555

}

11556

11557

_PUBLIC_ void ndr_print_samr_SetBootKeyInformation(struct ndr_print *ndr, const char *name, int flags, const struct samr_SetBootKeyInformation *r)

11558

{

11559

ndr_print_struct(ndr, name, "samr_SetBootKeyInformation");

11560

if (r == NULL) { ndr_print_null(ndr); return; }

11561

ndr->depth++;

11562

if (flags & NDR_SET_VALUES) {

11563

ndr->flags |= LIBNDR_PRINT_SET_VALUES;

11564

}

11565

if (flags & NDR_IN) {

11566

ndr_print_struct(ndr, "in", "samr_SetBootKeyInformation");

11567

ndr->depth++;

11568

ndr_print_ptr(ndr, "connect_handle", r->in.connect_handle);

11569

ndr->depth++;

11570

ndr_print_policy_handle(ndr, "connect_handle", r->in.connect_handle);

11571

ndr->depth--;

11572

ndr_print_uint32(ndr, "unknown1", r->in.unknown1);

11573

ndr_print_uint32(ndr, "unknown2", r->in.unknown2);

11574

ndr_print_uint32(ndr, "unknown3", r->in.unknown3);

11575

ndr->depth--;

11576

}

11577

if (flags & NDR_OUT) {

11578

ndr_print_struct(ndr, "out", "samr_SetBootKeyInformation");

11579

ndr->depth++;

11580

ndr_print_NTSTATUS(ndr, "result", r->out.result);

11581

ndr->depth--;

11582

}

11583

ndr->depth--;

11584

}

11585

11586

static enum ndr_err_code ndr_push_samr_GetBootKeyInformation(struct ndr_push *ndr, int flags, const struct samr_GetBootKeyInformation *r)

11587

{

11588

if (flags & NDR_IN) {

11589

if (r->in.domain_handle == NULL) {

11590

return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");

11591

}

11592

NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));

11593

}

11594

if (flags & NDR_OUT) {

11595

if (r->out.unknown == NULL) {

11596

return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");

11597

}

11598

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.unknown));

11599

NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));

11600

}

11601

return NDR_ERR_SUCCESS;

11602

}

11603

11604

static enum ndr_err_code ndr_pull_samr_GetBootKeyInformation(struct ndr_pull *ndr, int flags, struct samr_GetBootKeyInformation *r)

11605

{

11606

TALLOC_CTX *_mem_save_domain_handle_0;

11607

TALLOC_CTX *_mem_save_unknown_0;

11608

if (flags & NDR_IN) {

11609

ZERO_STRUCT(r->out);

11610

11611

if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {

11612

NDR_PULL_ALLOC(ndr, r->in.domain_handle);

11613

}

11614

_mem_save_domain_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);

11615

NDR_PULL_SET_MEM_CTX(ndr, r->in.domain_handle, LIBNDR_FLAG_REF_ALLOC);

11616

NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));

11617

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domain_handle_0, LIBNDR_FLAG_REF_ALLOC);

11618

NDR_PULL_ALLOC(ndr, r->out.unknown);

11619

ZERO_STRUCTP(r->out.unknown);

11620

}

11621

if (flags & NDR_OUT) {

11622

if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {

11623

NDR_PULL_ALLOC(ndr, r->out.unknown);

11624

}

11625

_mem_save_unknown_0 = NDR_PULL_GET_MEM_CTX(ndr);

11626

NDR_PULL_SET_MEM_CTX(ndr, r->out.unknown, LIBNDR_FLAG_REF_ALLOC);

11627

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.unknown));

11628

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_unknown_0, LIBNDR_FLAG_REF_ALLOC);

11629

NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));

11630

}

11631

return NDR_ERR_SUCCESS;

11632

}

11633

11634

_PUBLIC_ void ndr_print_samr_GetBootKeyInformation(struct ndr_print *ndr, const char *name, int flags, const struct samr_GetBootKeyInformation *r)

11635

{

11636

ndr_print_struct(ndr, name, "samr_GetBootKeyInformation");

11637

if (r == NULL) { ndr_print_null(ndr); return; }

11638

ndr->depth++;

11639

if (flags & NDR_SET_VALUES) {

11640

ndr->flags |= LIBNDR_PRINT_SET_VALUES;

11641

}

11642

if (flags & NDR_IN) {

11643

ndr_print_struct(ndr, "in", "samr_GetBootKeyInformation");

11644

ndr->depth++;

11645

ndr_print_ptr(ndr, "domain_handle", r->in.domain_handle);

11646

ndr->depth++;

11647

ndr_print_policy_handle(ndr, "domain_handle", r->in.domain_handle);

11648

ndr->depth--;

11649

ndr->depth--;

11650

}

11651

if (flags & NDR_OUT) {

11652

ndr_print_struct(ndr, "out", "samr_GetBootKeyInformation");

11653

ndr->depth++;

11654

ndr_print_ptr(ndr, "unknown", r->out.unknown);

11655

ndr->depth++;

11656

ndr_print_uint32(ndr, "unknown", *r->out.unknown);

11657

ndr->depth--;

11658

ndr_print_NTSTATUS(ndr, "result", r->out.result);

11659

ndr->depth--;

11660

}

11661

ndr->depth--;

11662

}

11663

11664

static enum ndr_err_code ndr_push_samr_Connect3(struct ndr_push *ndr, int flags, const struct samr_Connect3 *r)

11665

{

11666

if (flags & NDR_IN) {

11667

NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.system_name));

11668

if (r->in.system_name) {

11669

NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.system_name, CH_UTF16)));

11670

NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));

11671

NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.system_name, CH_UTF16)));

11672

NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.system_name, ndr_charset_length(r->in.system_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));

11673

}

11674

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.unknown));

11675

NDR_CHECK(ndr_push_samr_ConnectAccessMask(ndr, NDR_SCALARS, r->in.access_mask));

11676

}

11677

if (flags & NDR_OUT) {

11678

if (r->out.connect_handle == NULL) {

11679

return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");

11680

}

11681

NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.connect_handle));

11682

NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));

11683

}

11684

return NDR_ERR_SUCCESS;

11685

}

11686

11687

static enum ndr_err_code ndr_pull_samr_Connect3(struct ndr_pull *ndr, int flags, struct samr_Connect3 *r)

11688

{

11689

uint32_t _ptr_system_name;

11690

TALLOC_CTX *_mem_save_system_name_0;

11691

TALLOC_CTX *_mem_save_connect_handle_0;

11692

if (flags & NDR_IN) {

11693

ZERO_STRUCT(r->out);

11694

11695

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_system_name));

11696

if (_ptr_system_name) {

11697

NDR_PULL_ALLOC(ndr, r->in.system_name);

11698

} else {

11699

r->in.system_name = NULL;

11700

}

11701

if (r->in.system_name) {

11702

_mem_save_system_name_0 = NDR_PULL_GET_MEM_CTX(ndr);

11703

NDR_PULL_SET_MEM_CTX(ndr, r->in.system_name, 0);

11704

NDR_CHECK(ndr_pull_array_size(ndr, &r->in.system_name));

11705

NDR_CHECK(ndr_pull_array_length(ndr, &r->in.system_name));

11706

if (ndr_get_array_length(ndr, &r->in.system_name) > ndr_get_array_size(ndr, &r->in.system_name)) {

11707

return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->in.system_name), ndr_get_array_length(ndr, &r->in.system_name));

11708

}

11709

NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.system_name), sizeof(uint16_t)));

11710

NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.system_name, ndr_get_array_length(ndr, &r->in.system_name), sizeof(uint16_t), CH_UTF16));

11711

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_system_name_0, 0);

11712

}

11713

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.unknown));

11714

NDR_CHECK(ndr_pull_samr_ConnectAccessMask(ndr, NDR_SCALARS, &r->in.access_mask));

11715

NDR_PULL_ALLOC(ndr, r->out.connect_handle);

11716

ZERO_STRUCTP(r->out.connect_handle);

11717

}

11718

if (flags & NDR_OUT) {

11719

if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {

11720

NDR_PULL_ALLOC(ndr, r->out.connect_handle);

11721

}

11722

_mem_save_connect_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);

11723

NDR_PULL_SET_MEM_CTX(ndr, r->out.connect_handle, LIBNDR_FLAG_REF_ALLOC);

11724

NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.connect_handle));

11725

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_connect_handle_0, LIBNDR_FLAG_REF_ALLOC);

11726

NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));

11727

}

11728

return NDR_ERR_SUCCESS;

11729

}

11730

11731

_PUBLIC_ void ndr_print_samr_Connect3(struct ndr_print *ndr, const char *name, int flags, const struct samr_Connect3 *r)

11732

{

11733

ndr_print_struct(ndr, name, "samr_Connect3");

11734

if (r == NULL) { ndr_print_null(ndr); return; }

11735

ndr->depth++;

11736

if (flags & NDR_SET_VALUES) {

11737

ndr->flags |= LIBNDR_PRINT_SET_VALUES;

11738

}

11739

if (flags & NDR_IN) {

11740

ndr_print_struct(ndr, "in", "samr_Connect3");

11741

ndr->depth++;

11742

ndr_print_ptr(ndr, "system_name", r->in.system_name);

11743

ndr->depth++;

11744

if (r->in.system_name) {

11745

ndr_print_string(ndr, "system_name", r->in.system_name);

11746

}

11747

ndr->depth--;

11748

ndr_print_uint32(ndr, "unknown", r->in.unknown);

11749

ndr_print_samr_ConnectAccessMask(ndr, "access_mask", r->in.access_mask);

11750

ndr->depth--;

11751

}

11752

if (flags & NDR_OUT) {

11753

ndr_print_struct(ndr, "out", "samr_Connect3");

11754

ndr->depth++;

11755

ndr_print_ptr(ndr, "connect_handle", r->out.connect_handle);

11756

ndr->depth++;

11757

ndr_print_policy_handle(ndr, "connect_handle", r->out.connect_handle);

11758

ndr->depth--;

11759

ndr_print_NTSTATUS(ndr, "result", r->out.result);

11760

ndr->depth--;

11761

}

11762

ndr->depth--;

11763

}

11764

11765

static enum ndr_err_code ndr_push_samr_Connect4(struct ndr_push *ndr, int flags, const struct samr_Connect4 *r)

11766

{

11767

if (flags & NDR_IN) {

11768

NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.system_name));

11769

if (r->in.system_name) {

11770

NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.system_name, CH_UTF16)));

11771

NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));

11772

NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.system_name, CH_UTF16)));

11773

NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.system_name, ndr_charset_length(r->in.system_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));

11774

}

11775

NDR_CHECK(ndr_push_samr_ConnectVersion(ndr, NDR_SCALARS, r->in.client_version));

11776

NDR_CHECK(ndr_push_samr_ConnectAccessMask(ndr, NDR_SCALARS, r->in.access_mask));

11777

}

11778

if (flags & NDR_OUT) {

11779

if (r->out.connect_handle == NULL) {

11780

return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");

11781

}

11782

NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.connect_handle));

11783

NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));

11784

}

11785

return NDR_ERR_SUCCESS;

11786

}

11787

11788

static enum ndr_err_code ndr_pull_samr_Connect4(struct ndr_pull *ndr, int flags, struct samr_Connect4 *r)

11789

{

11790

uint32_t _ptr_system_name;

11791

TALLOC_CTX *_mem_save_system_name_0;

11792

TALLOC_CTX *_mem_save_connect_handle_0;

11793

if (flags & NDR_IN) {

11794

ZERO_STRUCT(r->out);

11795

11796

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_system_name));

11797

if (_ptr_system_name) {

11798

NDR_PULL_ALLOC(ndr, r->in.system_name);

11799

} else {

11800

r->in.system_name = NULL;

11801

}

11802

if (r->in.system_name) {

11803

_mem_save_system_name_0 = NDR_PULL_GET_MEM_CTX(ndr);

11804

NDR_PULL_SET_MEM_CTX(ndr, r->in.system_name, 0);

11805

NDR_CHECK(ndr_pull_array_size(ndr, &r->in.system_name));

11806

NDR_CHECK(ndr_pull_array_length(ndr, &r->in.system_name));

11807

if (ndr_get_array_length(ndr, &r->in.system_name) > ndr_get_array_size(ndr, &r->in.system_name)) {

11808

return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->in.system_name), ndr_get_array_length(ndr, &r->in.system_name));

11809

}

11810

NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.system_name), sizeof(uint16_t)));

11811

NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.system_name, ndr_get_array_length(ndr, &r->in.system_name), sizeof(uint16_t), CH_UTF16));

11812

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_system_name_0, 0);

11813

}

11814

NDR_CHECK(ndr_pull_samr_ConnectVersion(ndr, NDR_SCALARS, &r->in.client_version));

11815

NDR_CHECK(ndr_pull_samr_ConnectAccessMask(ndr, NDR_SCALARS, &r->in.access_mask));

11816

NDR_PULL_ALLOC(ndr, r->out.connect_handle);

11817

ZERO_STRUCTP(r->out.connect_handle);

11818

}

11819

if (flags & NDR_OUT) {

11820

if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {

11821

NDR_PULL_ALLOC(ndr, r->out.connect_handle);

11822

}

11823

_mem_save_connect_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);

11824

NDR_PULL_SET_MEM_CTX(ndr, r->out.connect_handle, LIBNDR_FLAG_REF_ALLOC);

11825

NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.connect_handle));

11826

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_connect_handle_0, LIBNDR_FLAG_REF_ALLOC);

11827

NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));

11828

}

11829

return NDR_ERR_SUCCESS;

11830

}

11831

11832

_PUBLIC_ void ndr_print_samr_Connect4(struct ndr_print *ndr, const char *name, int flags, const struct samr_Connect4 *r)

11833

{

11834

ndr_print_struct(ndr, name, "samr_Connect4");

11835

if (r == NULL) { ndr_print_null(ndr); return; }

11836

ndr->depth++;

11837

if (flags & NDR_SET_VALUES) {

11838

ndr->flags |= LIBNDR_PRINT_SET_VALUES;

11839

}

11840

if (flags & NDR_IN) {

11841

ndr_print_struct(ndr, "in", "samr_Connect4");

11842

ndr->depth++;

11843

ndr_print_ptr(ndr, "system_name", r->in.system_name);

11844

ndr->depth++;

11845

if (r->in.system_name) {

11846

ndr_print_string(ndr, "system_name", r->in.system_name);

11847

}

11848

ndr->depth--;

11849

ndr_print_samr_ConnectVersion(ndr, "client_version", r->in.client_version);

11850

ndr_print_samr_ConnectAccessMask(ndr, "access_mask", r->in.access_mask);

11851

ndr->depth--;

11852

}

11853

if (flags & NDR_OUT) {

11854

ndr_print_struct(ndr, "out", "samr_Connect4");

11855

ndr->depth++;

11856

ndr_print_ptr(ndr, "connect_handle", r->out.connect_handle);

11857

ndr->depth++;

11858

ndr_print_policy_handle(ndr, "connect_handle", r->out.connect_handle);

11859

ndr->depth--;

11860

ndr_print_NTSTATUS(ndr, "result", r->out.result);

11861

ndr->depth--;

11862

}

11863

ndr->depth--;

11864

}

11865

11866

_PUBLIC_ enum ndr_err_code ndr_push_samr_ChangePasswordUser3(struct ndr_push *ndr, int flags, const struct samr_ChangePasswordUser3 *r)

11867

{

11868

if (flags & NDR_IN) {

11869

NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server));

11870

if (r->in.server) {

11871

NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.server));

11872

}

11873

if (r->in.account == NULL) {

11874

return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");

11875

}

11876

NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.account));

11877

NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.nt_password));

11878

if (r->in.nt_password) {

11879

NDR_CHECK(ndr_push_samr_CryptPassword(ndr, NDR_SCALARS, r->in.nt_password));

11880

}

11881

NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.nt_verifier));

11882

if (r->in.nt_verifier) {

11883

NDR_CHECK(ndr_push_samr_Password(ndr, NDR_SCALARS, r->in.nt_verifier));

11884

}

11885

NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->in.lm_change));

11886

NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.lm_password));

11887

if (r->in.lm_password) {

11888

NDR_CHECK(ndr_push_samr_CryptPassword(ndr, NDR_SCALARS, r->in.lm_password));

11889

}

11890

NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.lm_verifier));

11891

if (r->in.lm_verifier) {

11892

NDR_CHECK(ndr_push_samr_Password(ndr, NDR_SCALARS, r->in.lm_verifier));

11893

}

11894

NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.password3));

11895

if (r->in.password3) {

11896

NDR_CHECK(ndr_push_samr_CryptPassword(ndr, NDR_SCALARS, r->in.password3));

11897

}

11898

}

11899

if (flags & NDR_OUT) {

11900

if (r->out.dominfo == NULL) {

11901

return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");

11902

}

11903

NDR_CHECK(ndr_push_unique_ptr(ndr, *r->out.dominfo));

11904

if (*r->out.dominfo) {

11905

NDR_CHECK(ndr_push_samr_DomInfo1(ndr, NDR_SCALARS, *r->out.dominfo));

11906

}

11907

if (r->out.reject == NULL) {

11908

return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");

11909

}

11910

NDR_CHECK(ndr_push_unique_ptr(ndr, *r->out.reject));

11911

if (*r->out.reject) {

11912

NDR_CHECK(ndr_push_userPwdChangeFailureInformation(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.reject));

11913

}

11914

NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));

11915

}

11916

return NDR_ERR_SUCCESS;

11917

}

11918

11919

_PUBLIC_ enum ndr_err_code ndr_pull_samr_ChangePasswordUser3(struct ndr_pull *ndr, int flags, struct samr_ChangePasswordUser3 *r)

11920

{

11921

uint32_t _ptr_server;

11922

uint32_t _ptr_nt_password;

11923

uint32_t _ptr_nt_verifier;

11924

uint32_t _ptr_lm_password;

11925

uint32_t _ptr_lm_verifier;

11926

uint32_t _ptr_password3;

11927

uint32_t _ptr_dominfo;

11928

uint32_t _ptr_reject;

11929

TALLOC_CTX *_mem_save_server_0;

11930

TALLOC_CTX *_mem_save_account_0;

11931

TALLOC_CTX *_mem_save_nt_password_0;

11932

TALLOC_CTX *_mem_save_nt_verifier_0;

11933

TALLOC_CTX *_mem_save_lm_password_0;

11934

TALLOC_CTX *_mem_save_lm_verifier_0;

11935

TALLOC_CTX *_mem_save_password3_0;

11936

TALLOC_CTX *_mem_save_dominfo_0;

11937

TALLOC_CTX *_mem_save_dominfo_1;

11938

TALLOC_CTX *_mem_save_reject_0;

11939

TALLOC_CTX *_mem_save_reject_1;

11940

if (flags & NDR_IN) {

11941

ZERO_STRUCT(r->out);

11942

11943

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server));

11944

if (_ptr_server) {

11945

NDR_PULL_ALLOC(ndr, r->in.server);

11946

} else {

11947

r->in.server = NULL;

11948

}

11949

if (r->in.server) {

11950

_mem_save_server_0 = NDR_PULL_GET_MEM_CTX(ndr);

11951

NDR_PULL_SET_MEM_CTX(ndr, r->in.server, 0);

11952

NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.server));

11953

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_0, 0);

11954

}

11955

if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {

11956

NDR_PULL_ALLOC(ndr, r->in.account);

11957

}

11958

_mem_save_account_0 = NDR_PULL_GET_MEM_CTX(ndr);

11959

NDR_PULL_SET_MEM_CTX(ndr, r->in.account, LIBNDR_FLAG_REF_ALLOC);

11960

NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.account));

11961

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_account_0, LIBNDR_FLAG_REF_ALLOC);

11962

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_nt_password));

11963

if (_ptr_nt_password) {

11964

NDR_PULL_ALLOC(ndr, r->in.nt_password);

11965

} else {

11966

r->in.nt_password = NULL;

11967

}

11968

if (r->in.nt_password) {

11969

_mem_save_nt_password_0 = NDR_PULL_GET_MEM_CTX(ndr);

11970

NDR_PULL_SET_MEM_CTX(ndr, r->in.nt_password, 0);

11971

NDR_CHECK(ndr_pull_samr_CryptPassword(ndr, NDR_SCALARS, r->in.nt_password));

11972

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_nt_password_0, 0);

11973

}

11974

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_nt_verifier));

11975

if (_ptr_nt_verifier) {

11976

NDR_PULL_ALLOC(ndr, r->in.nt_verifier);

11977

} else {

11978

r->in.nt_verifier = NULL;

11979

}

11980

if (r->in.nt_verifier) {

11981

_mem_save_nt_verifier_0 = NDR_PULL_GET_MEM_CTX(ndr);

11982

NDR_PULL_SET_MEM_CTX(ndr, r->in.nt_verifier, 0);

11983

NDR_CHECK(ndr_pull_samr_Password(ndr, NDR_SCALARS, r->in.nt_verifier));

11984

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_nt_verifier_0, 0);

11985

}

11986

NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->in.lm_change));

11987

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_lm_password));

11988

if (_ptr_lm_password) {

11989

NDR_PULL_ALLOC(ndr, r->in.lm_password);

11990

} else {

11991

r->in.lm_password = NULL;

11992

}

11993

if (r->in.lm_password) {

11994

_mem_save_lm_password_0 = NDR_PULL_GET_MEM_CTX(ndr);

11995

NDR_PULL_SET_MEM_CTX(ndr, r->in.lm_password, 0);

11996

NDR_CHECK(ndr_pull_samr_CryptPassword(ndr, NDR_SCALARS, r->in.lm_password));

11997

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_lm_password_0, 0);

11998

}

11999

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_lm_verifier));

12000

if (_ptr_lm_verifier) {

12001

NDR_PULL_ALLOC(ndr, r->in.lm_verifier);

12002

} else {

12003

r->in.lm_verifier = NULL;

12004

}

12005

if (r->in.lm_verifier) {

12006

_mem_save_lm_verifier_0 = NDR_PULL_GET_MEM_CTX(ndr);

12007

NDR_PULL_SET_MEM_CTX(ndr, r->in.lm_verifier, 0);

12008

NDR_CHECK(ndr_pull_samr_Password(ndr, NDR_SCALARS, r->in.lm_verifier));

12009

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_lm_verifier_0, 0);

12010

}

12011

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_password3));

12012

if (_ptr_password3) {

12013

NDR_PULL_ALLOC(ndr, r->in.password3);

12014

} else {

12015

r->in.password3 = NULL;

12016

}

12017

if (r->in.password3) {

12018

_mem_save_password3_0 = NDR_PULL_GET_MEM_CTX(ndr);

12019

NDR_PULL_SET_MEM_CTX(ndr, r->in.password3, 0);

12020

NDR_CHECK(ndr_pull_samr_CryptPassword(ndr, NDR_SCALARS, r->in.password3));

12021

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_password3_0, 0);

12022

}

12023

NDR_PULL_ALLOC(ndr, r->out.dominfo);

12024

ZERO_STRUCTP(r->out.dominfo);

12025

NDR_PULL_ALLOC(ndr, r->out.reject);

12026

ZERO_STRUCTP(r->out.reject);

12027

}

12028

if (flags & NDR_OUT) {

12029

if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {

12030

NDR_PULL_ALLOC(ndr, r->out.dominfo);

12031

}

12032

_mem_save_dominfo_0 = NDR_PULL_GET_MEM_CTX(ndr);

12033

NDR_PULL_SET_MEM_CTX(ndr, r->out.dominfo, LIBNDR_FLAG_REF_ALLOC);

12034

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dominfo));

12035

if (_ptr_dominfo) {

12036

NDR_PULL_ALLOC(ndr, *r->out.dominfo);

12037

} else {

12038

*r->out.dominfo = NULL;

12039

}

12040

if (*r->out.dominfo) {

12041

_mem_save_dominfo_1 = NDR_PULL_GET_MEM_CTX(ndr);

12042

NDR_PULL_SET_MEM_CTX(ndr, *r->out.dominfo, 0);

12043

NDR_CHECK(ndr_pull_samr_DomInfo1(ndr, NDR_SCALARS, *r->out.dominfo));

12044

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dominfo_1, 0);

12045

}

12046

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dominfo_0, LIBNDR_FLAG_REF_ALLOC);

12047

if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {

12048

NDR_PULL_ALLOC(ndr, r->out.reject);

12049

}

12050

_mem_save_reject_0 = NDR_PULL_GET_MEM_CTX(ndr);

12051

NDR_PULL_SET_MEM_CTX(ndr, r->out.reject, LIBNDR_FLAG_REF_ALLOC);

12052

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_reject));

12053

if (_ptr_reject) {

12054

NDR_PULL_ALLOC(ndr, *r->out.reject);

12055

} else {

12056

*r->out.reject = NULL;

12057

}

12058

if (*r->out.reject) {

12059

_mem_save_reject_1 = NDR_PULL_GET_MEM_CTX(ndr);

12060

NDR_PULL_SET_MEM_CTX(ndr, *r->out.reject, 0);

12061

NDR_CHECK(ndr_pull_userPwdChangeFailureInformation(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.reject));

12062

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_reject_1, 0);

12063

}

12064

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_reject_0, LIBNDR_FLAG_REF_ALLOC);

12065

NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));

12066

}

12067

return NDR_ERR_SUCCESS;

12068

}

12069

12070

_PUBLIC_ void ndr_print_samr_ChangePasswordUser3(struct ndr_print *ndr, const char *name, int flags, const struct samr_ChangePasswordUser3 *r)

12071

{

12072

ndr_print_struct(ndr, name, "samr_ChangePasswordUser3");

12073

if (r == NULL) { ndr_print_null(ndr); return; }

12074

ndr->depth++;

12075

if (flags & NDR_SET_VALUES) {

12076

ndr->flags |= LIBNDR_PRINT_SET_VALUES;

12077

}

12078

if (flags & NDR_IN) {

12079

ndr_print_struct(ndr, "in", "samr_ChangePasswordUser3");

12080

ndr->depth++;

12081

ndr_print_ptr(ndr, "server", r->in.server);

12082

ndr->depth++;

12083

if (r->in.server) {

12084

ndr_print_lsa_String(ndr, "server", r->in.server);

12085

}

12086

ndr->depth--;

12087

ndr_print_ptr(ndr, "account", r->in.account);

12088

ndr->depth++;

12089

ndr_print_lsa_String(ndr, "account", r->in.account);

12090

ndr->depth--;

12091

ndr_print_ptr(ndr, "nt_password", r->in.nt_password);

12092

ndr->depth++;

12093

if (r->in.nt_password) {

12094

ndr_print_samr_CryptPassword(ndr, "nt_password", r->in.nt_password);

12095

}

12096

ndr->depth--;

12097

ndr_print_ptr(ndr, "nt_verifier", r->in.nt_verifier);

12098

ndr->depth++;

12099

if (r->in.nt_verifier) {

12100

ndr_print_samr_Password(ndr, "nt_verifier", r->in.nt_verifier);

12101

}

12102

ndr->depth--;

12103

ndr_print_uint8(ndr, "lm_change", r->in.lm_change);

12104

ndr_print_ptr(ndr, "lm_password", r->in.lm_password);

12105

ndr->depth++;

12106

if (r->in.lm_password) {

12107

ndr_print_samr_CryptPassword(ndr, "lm_password", r->in.lm_password);

12108

}

12109

ndr->depth--;

12110

ndr_print_ptr(ndr, "lm_verifier", r->in.lm_verifier);

12111

ndr->depth++;

12112

if (r->in.lm_verifier) {

12113

ndr_print_samr_Password(ndr, "lm_verifier", r->in.lm_verifier);

12114

}

12115

ndr->depth--;

12116

ndr_print_ptr(ndr, "password3", r->in.password3);

12117

ndr->depth++;

12118

if (r->in.password3) {

12119

ndr_print_samr_CryptPassword(ndr, "password3", r->in.password3);

12120

}

12121

ndr->depth--;

12122

ndr->depth--;

12123

}

12124

if (flags & NDR_OUT) {

12125

ndr_print_struct(ndr, "out", "samr_ChangePasswordUser3");

12126

ndr->depth++;

12127

ndr_print_ptr(ndr, "dominfo", r->out.dominfo);

12128

ndr->depth++;

12129

ndr_print_ptr(ndr, "dominfo", *r->out.dominfo);

12130

ndr->depth++;

12131

if (*r->out.dominfo) {

12132

ndr_print_samr_DomInfo1(ndr, "dominfo", *r->out.dominfo);

12133

}

12134

ndr->depth--;

12135

ndr->depth--;

12136

ndr_print_ptr(ndr, "reject", r->out.reject);

12137

ndr->depth++;

12138

ndr_print_ptr(ndr, "reject", *r->out.reject);

12139

ndr->depth++;

12140

if (*r->out.reject) {

12141

ndr_print_userPwdChangeFailureInformation(ndr, "reject", *r->out.reject);

12142

}

12143

ndr->depth--;

12144

ndr->depth--;

12145

ndr_print_NTSTATUS(ndr, "result", r->out.result);

12146

ndr->depth--;

12147

}

12148

ndr->depth--;

12149

}

12150

12151

_PUBLIC_ enum ndr_err_code ndr_push_samr_Connect5(struct ndr_push *ndr, int flags, const struct samr_Connect5 *r)

12152

{

12153

if (flags & NDR_IN) {

12154

NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.system_name));

12155

if (r->in.system_name) {

12156

NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.system_name, CH_UTF16)));

12157

NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));

12158

NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.system_name, CH_UTF16)));

12159

NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.system_name, ndr_charset_length(r->in.system_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));

12160

}

12161

NDR_CHECK(ndr_push_samr_ConnectAccessMask(ndr, NDR_SCALARS, r->in.access_mask));

12162

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level_in));

12163

if (r->in.info_in == NULL) {

12164

return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");

12165

}

12166

NDR_CHECK(ndr_push_set_switch_value(ndr, r->in.info_in, r->in.level_in));

12167

NDR_CHECK(ndr_push_samr_ConnectInfo(ndr, NDR_SCALARS, r->in.info_in));

12168

}

12169

if (flags & NDR_OUT) {

12170

if (r->out.level_out == NULL) {

12171

return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");

12172

}

12173

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.level_out));

12174

if (r->out.info_out == NULL) {

12175

return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");

12176

}

12177

NDR_CHECK(ndr_push_set_switch_value(ndr, r->out.info_out, *r->out.level_out));

12178

NDR_CHECK(ndr_push_samr_ConnectInfo(ndr, NDR_SCALARS, r->out.info_out));

12179

if (r->out.connect_handle == NULL) {

12180

return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");

12181

}

12182

NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.connect_handle));

12183

NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));

12184

}

12185

return NDR_ERR_SUCCESS;

12186

}

12187

12188

_PUBLIC_ enum ndr_err_code ndr_pull_samr_Connect5(struct ndr_pull *ndr, int flags, struct samr_Connect5 *r)

12189

{

12190

uint32_t _ptr_system_name;

12191

TALLOC_CTX *_mem_save_system_name_0;

12192

TALLOC_CTX *_mem_save_info_in_0;

12193

TALLOC_CTX *_mem_save_level_out_0;

12194

TALLOC_CTX *_mem_save_info_out_0;

12195

TALLOC_CTX *_mem_save_connect_handle_0;

12196

if (flags & NDR_IN) {

12197

ZERO_STRUCT(r->out);

12198

12199

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_system_name));

12200

if (_ptr_system_name) {

12201

NDR_PULL_ALLOC(ndr, r->in.system_name);

12202

} else {

12203

r->in.system_name = NULL;

12204

}

12205

if (r->in.system_name) {

12206

_mem_save_system_name_0 = NDR_PULL_GET_MEM_CTX(ndr);

12207

NDR_PULL_SET_MEM_CTX(ndr, r->in.system_name, 0);

12208

NDR_CHECK(ndr_pull_array_size(ndr, &r->in.system_name));

12209

NDR_CHECK(ndr_pull_array_length(ndr, &r->in.system_name));

12210

if (ndr_get_array_length(ndr, &r->in.system_name) > ndr_get_array_size(ndr, &r->in.system_name)) {

12211

return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->in.system_name), ndr_get_array_length(ndr, &r->in.system_name));

12212

}

12213

NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.system_name), sizeof(uint16_t)));

12214

NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.system_name, ndr_get_array_length(ndr, &r->in.system_name), sizeof(uint16_t), CH_UTF16));

12215

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_system_name_0, 0);

12216

}

12217

NDR_CHECK(ndr_pull_samr_ConnectAccessMask(ndr, NDR_SCALARS, &r->in.access_mask));

12218

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level_in));

12219

if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {

12220

NDR_PULL_ALLOC(ndr, r->in.info_in);

12221

}

12222

_mem_save_info_in_0 = NDR_PULL_GET_MEM_CTX(ndr);

12223

NDR_PULL_SET_MEM_CTX(ndr, r->in.info_in, LIBNDR_FLAG_REF_ALLOC);

12224

NDR_CHECK(ndr_pull_set_switch_value(ndr, r->in.info_in, r->in.level_in));

12225

NDR_CHECK(ndr_pull_samr_ConnectInfo(ndr, NDR_SCALARS, r->in.info_in));

12226

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_in_0, LIBNDR_FLAG_REF_ALLOC);

12227

NDR_PULL_ALLOC(ndr, r->out.level_out);

12228

ZERO_STRUCTP(r->out.level_out);

12229

NDR_PULL_ALLOC(ndr, r->out.info_out);

12230

ZERO_STRUCTP(r->out.info_out);

12231

NDR_PULL_ALLOC(ndr, r->out.connect_handle);

12232

ZERO_STRUCTP(r->out.connect_handle);

12233

}

12234

if (flags & NDR_OUT) {

12235

if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {

12236

NDR_PULL_ALLOC(ndr, r->out.level_out);

12237

}

12238

_mem_save_level_out_0 = NDR_PULL_GET_MEM_CTX(ndr);

12239

NDR_PULL_SET_MEM_CTX(ndr, r->out.level_out, LIBNDR_FLAG_REF_ALLOC);

12240

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.level_out));

12241

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_level_out_0, LIBNDR_FLAG_REF_ALLOC);

12242

if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {

12243

NDR_PULL_ALLOC(ndr, r->out.info_out);

12244

}

12245

_mem_save_info_out_0 = NDR_PULL_GET_MEM_CTX(ndr);

12246

NDR_PULL_SET_MEM_CTX(ndr, r->out.info_out, LIBNDR_FLAG_REF_ALLOC);

12247

NDR_CHECK(ndr_pull_set_switch_value(ndr, r->out.info_out, *r->out.level_out));

12248

NDR_CHECK(ndr_pull_samr_ConnectInfo(ndr, NDR_SCALARS, r->out.info_out));

12249

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_out_0, LIBNDR_FLAG_REF_ALLOC);

12250

if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {

12251

NDR_PULL_ALLOC(ndr, r->out.connect_handle);

12252

}

12253

_mem_save_connect_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);

12254

NDR_PULL_SET_MEM_CTX(ndr, r->out.connect_handle, LIBNDR_FLAG_REF_ALLOC);

12255

NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.connect_handle));

12256

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_connect_handle_0, LIBNDR_FLAG_REF_ALLOC);

12257

NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));

12258

}

12259

return NDR_ERR_SUCCESS;

12260

}

12261

12262

_PUBLIC_ void ndr_print_samr_Connect5(struct ndr_print *ndr, const char *name, int flags, const struct samr_Connect5 *r)

12263

{

12264

ndr_print_struct(ndr, name, "samr_Connect5");

12265

if (r == NULL) { ndr_print_null(ndr); return; }

12266

ndr->depth++;

12267

if (flags & NDR_SET_VALUES) {

12268

ndr->flags |= LIBNDR_PRINT_SET_VALUES;

12269

}

12270

if (flags & NDR_IN) {

12271

ndr_print_struct(ndr, "in", "samr_Connect5");

12272

ndr->depth++;

12273

ndr_print_ptr(ndr, "system_name", r->in.system_name);

12274

ndr->depth++;

12275

if (r->in.system_name) {

12276

ndr_print_string(ndr, "system_name", r->in.system_name);

12277

}

12278

ndr->depth--;

12279

ndr_print_samr_ConnectAccessMask(ndr, "access_mask", r->in.access_mask);

12280

ndr_print_uint32(ndr, "level_in", r->in.level_in);

12281

ndr_print_ptr(ndr, "info_in", r->in.info_in);

12282

ndr->depth++;

12283

ndr_print_set_switch_value(ndr, r->in.info_in, r->in.level_in);

12284

ndr_print_samr_ConnectInfo(ndr, "info_in", r->in.info_in);

12285

ndr->depth--;

12286

ndr->depth--;

12287

}

12288

if (flags & NDR_OUT) {

12289

ndr_print_struct(ndr, "out", "samr_Connect5");

12290

ndr->depth++;

12291

ndr_print_ptr(ndr, "level_out", r->out.level_out);

12292

ndr->depth++;

12293

ndr_print_uint32(ndr, "level_out", *r->out.level_out);

12294

ndr->depth--;

12295

ndr_print_ptr(ndr, "info_out", r->out.info_out);

12296

ndr->depth++;

12297

ndr_print_set_switch_value(ndr, r->out.info_out, *r->out.level_out);

12298

ndr_print_samr_ConnectInfo(ndr, "info_out", r->out.info_out);

12299

ndr->depth--;

12300

ndr_print_ptr(ndr, "connect_handle", r->out.connect_handle);

12301

ndr->depth++;

12302

ndr_print_policy_handle(ndr, "connect_handle", r->out.connect_handle);

12303

ndr->depth--;

12304

ndr_print_NTSTATUS(ndr, "result", r->out.result);

12305

ndr->depth--;

12306

}

12307

ndr->depth--;

12308

}

12309

12310

static enum ndr_err_code ndr_push_samr_RidToSid(struct ndr_push *ndr, int flags, const struct samr_RidToSid *r)

12311

{

12312

if (flags & NDR_IN) {

12313

if (r->in.domain_handle == NULL) {

12314

return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");

12315

}

12316

NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));

12317

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.rid));

12318

}

12319

if (flags & NDR_OUT) {

12320

if (r->out.sid == NULL) {

12321

return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");

12322

}

12323

NDR_CHECK(ndr_push_unique_ptr(ndr, *r->out.sid));

12324

if (*r->out.sid) {

12325

NDR_CHECK(ndr_push_dom_sid2(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.sid));

12326

}

12327

NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));

12328

}

12329

return NDR_ERR_SUCCESS;

12330

}

12331

12332

static enum ndr_err_code ndr_pull_samr_RidToSid(struct ndr_pull *ndr, int flags, struct samr_RidToSid *r)

12333

{

12334

uint32_t _ptr_sid;

12335

TALLOC_CTX *_mem_save_domain_handle_0;

12336

TALLOC_CTX *_mem_save_sid_0;

12337

TALLOC_CTX *_mem_save_sid_1;

12338

if (flags & NDR_IN) {

12339

ZERO_STRUCT(r->out);

12340

12341

if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {

12342

NDR_PULL_ALLOC(ndr, r->in.domain_handle);

12343

}

12344

_mem_save_domain_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);

12345

NDR_PULL_SET_MEM_CTX(ndr, r->in.domain_handle, LIBNDR_FLAG_REF_ALLOC);

12346

NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.domain_handle));

12347

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domain_handle_0, LIBNDR_FLAG_REF_ALLOC);

12348

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.rid));

12349

NDR_PULL_ALLOC(ndr, r->out.sid);

12350

ZERO_STRUCTP(r->out.sid);

12351

}

12352

if (flags & NDR_OUT) {

12353

if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {

12354

NDR_PULL_ALLOC(ndr, r->out.sid);

12355

}

12356

_mem_save_sid_0 = NDR_PULL_GET_MEM_CTX(ndr);

12357

NDR_PULL_SET_MEM_CTX(ndr, r->out.sid, LIBNDR_FLAG_REF_ALLOC);

12358

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_sid));

12359

if (_ptr_sid) {

12360

NDR_PULL_ALLOC(ndr, *r->out.sid);

12361

} else {

12362

*r->out.sid = NULL;

12363

}

12364

if (*r->out.sid) {

12365

_mem_save_sid_1 = NDR_PULL_GET_MEM_CTX(ndr);

12366

NDR_PULL_SET_MEM_CTX(ndr, *r->out.sid, 0);

12367

NDR_CHECK(ndr_pull_dom_sid2(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.sid));

12368

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sid_1, 0);

12369

}

12370

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sid_0, LIBNDR_FLAG_REF_ALLOC);

12371

NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));

12372

}

12373

return NDR_ERR_SUCCESS;

12374

}

12375

12376

_PUBLIC_ void ndr_print_samr_RidToSid(struct ndr_print *ndr, const char *name, int flags, const struct samr_RidToSid *r)

12377

{

12378

ndr_print_struct(ndr, name, "samr_RidToSid");

12379

if (r == NULL) { ndr_print_null(ndr); return; }

12380

ndr->depth++;

12381

if (flags & NDR_SET_VALUES) {

12382

ndr->flags |= LIBNDR_PRINT_SET_VALUES;

12383

}

12384

if (flags & NDR_IN) {

12385

ndr_print_struct(ndr, "in", "samr_RidToSid");

12386

ndr->depth++;

12387

ndr_print_ptr(ndr, "domain_handle", r->in.domain_handle);

12388

ndr->depth++;

12389

ndr_print_policy_handle(ndr, "domain_handle", r->in.domain_handle);

12390

ndr->depth--;

12391

ndr_print_uint32(ndr, "rid", r->in.rid);

12392

ndr->depth--;

12393

}

12394

if (flags & NDR_OUT) {

12395

ndr_print_struct(ndr, "out", "samr_RidToSid");

12396

ndr->depth++;

12397

ndr_print_ptr(ndr, "sid", r->out.sid);

12398

ndr->depth++;

12399

ndr_print_ptr(ndr, "sid", *r->out.sid);

12400

ndr->depth++;

12401

if (*r->out.sid) {

12402

ndr_print_dom_sid2(ndr, "sid", *r->out.sid);

12403

}

12404

ndr->depth--;

12405

ndr->depth--;

12406

ndr_print_NTSTATUS(ndr, "result", r->out.result);

12407

ndr->depth--;

12408

}

12409

ndr->depth--;

12410

}

12411

12412

static enum ndr_err_code ndr_push_samr_SetDsrmPassword(struct ndr_push *ndr, int flags, const struct samr_SetDsrmPassword *r)

12413

{

12414

if (flags & NDR_IN) {

12415

NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.name));

12416

if (r->in.name) {

12417

NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.name));

12418

}

12419

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.unknown));

12420

NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.hash));

12421

if (r->in.hash) {

12422

NDR_CHECK(ndr_push_samr_Password(ndr, NDR_SCALARS, r->in.hash));

12423

}

12424

}

12425

if (flags & NDR_OUT) {

12426

NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));

12427

}

12428

return NDR_ERR_SUCCESS;

12429

}

12430

12431

static enum ndr_err_code ndr_pull_samr_SetDsrmPassword(struct ndr_pull *ndr, int flags, struct samr_SetDsrmPassword *r)

12432

{

12433

uint32_t _ptr_name;

12434

uint32_t _ptr_hash;

12435

TALLOC_CTX *_mem_save_name_0;

12436

TALLOC_CTX *_mem_save_hash_0;

12437

if (flags & NDR_IN) {

12438

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_name));

12439

if (_ptr_name) {

12440

NDR_PULL_ALLOC(ndr, r->in.name);

12441

} else {

12442

r->in.name = NULL;

12443

}

12444

if (r->in.name) {

12445

_mem_save_name_0 = NDR_PULL_GET_MEM_CTX(ndr);

12446

NDR_PULL_SET_MEM_CTX(ndr, r->in.name, 0);

12447

NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.name));

12448

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_name_0, 0);

12449

}

12450

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.unknown));

12451

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_hash));

12452

if (_ptr_hash) {

12453

NDR_PULL_ALLOC(ndr, r->in.hash);

12454

} else {

12455

r->in.hash = NULL;

12456

}

12457

if (r->in.hash) {

12458

_mem_save_hash_0 = NDR_PULL_GET_MEM_CTX(ndr);

12459

NDR_PULL_SET_MEM_CTX(ndr, r->in.hash, 0);

12460

NDR_CHECK(ndr_pull_samr_Password(ndr, NDR_SCALARS, r->in.hash));

12461

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_hash_0, 0);

12462

}

12463

}

12464

if (flags & NDR_OUT) {

12465

NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));

12466

}

12467

return NDR_ERR_SUCCESS;

12468

}

12469

12470

_PUBLIC_ void ndr_print_samr_SetDsrmPassword(struct ndr_print *ndr, const char *name, int flags, const struct samr_SetDsrmPassword *r)

12471

{

12472

ndr_print_struct(ndr, name, "samr_SetDsrmPassword");

12473

if (r == NULL) { ndr_print_null(ndr); return; }

12474

ndr->depth++;

12475

if (flags & NDR_SET_VALUES) {

12476

ndr->flags |= LIBNDR_PRINT_SET_VALUES;

12477

}

12478

if (flags & NDR_IN) {

12479

ndr_print_struct(ndr, "in", "samr_SetDsrmPassword");

12480

ndr->depth++;

12481

ndr_print_ptr(ndr, "name", r->in.name);

12482

ndr->depth++;

12483

if (r->in.name) {

12484

ndr_print_lsa_String(ndr, "name", r->in.name);

12485

}

12486

ndr->depth--;

12487

ndr_print_uint32(ndr, "unknown", r->in.unknown);

12488

ndr_print_ptr(ndr, "hash", r->in.hash);

12489

ndr->depth++;

12490

if (r->in.hash) {

12491

ndr_print_samr_Password(ndr, "hash", r->in.hash);

12492

}

12493

ndr->depth--;

12494

ndr->depth--;

12495

}

12496

if (flags & NDR_OUT) {

12497

ndr_print_struct(ndr, "out", "samr_SetDsrmPassword");

12498

ndr->depth++;

12499

ndr_print_NTSTATUS(ndr, "result", r->out.result);

12500

ndr->depth--;

12501

}

12502

ndr->depth--;

12503

}

12504

12505

static enum ndr_err_code ndr_push_samr_ValidatePassword(struct ndr_push *ndr, int flags, const struct samr_ValidatePassword *r)

12506

{

12507

if (flags & NDR_IN) {

12508

NDR_CHECK(ndr_push_samr_ValidatePasswordLevel(ndr, NDR_SCALARS, r->in.level));

12509

if (r->in.req == NULL) {

12510

return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");

12511

}

12512

NDR_CHECK(ndr_push_set_switch_value(ndr, r->in.req, r->in.level));

12513

NDR_CHECK(ndr_push_samr_ValidatePasswordReq(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.req));

12514

}

12515

if (flags & NDR_OUT) {

12516

if (r->out.rep == NULL) {

12517

return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");

12518

}

12519

NDR_CHECK(ndr_push_unique_ptr(ndr, *r->out.rep));

12520

if (*r->out.rep) {

12521

NDR_CHECK(ndr_push_set_switch_value(ndr, *r->out.rep, r->in.level));

12522

NDR_CHECK(ndr_push_samr_ValidatePasswordRep(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.rep));

12523

}

12524

NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));

12525

}

12526

return NDR_ERR_SUCCESS;

12527

}

12528

12529

static enum ndr_err_code ndr_pull_samr_ValidatePassword(struct ndr_pull *ndr, int flags, struct samr_ValidatePassword *r)

12530

{

12531

uint32_t _ptr_rep;

12532

TALLOC_CTX *_mem_save_req_0;

12533

TALLOC_CTX *_mem_save_rep_0;

12534

TALLOC_CTX *_mem_save_rep_1;

12535

if (flags & NDR_IN) {

12536

ZERO_STRUCT(r->out);

12537

12538

NDR_CHECK(ndr_pull_samr_ValidatePasswordLevel(ndr, NDR_SCALARS, &r->in.level));

12539

if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {

12540

NDR_PULL_ALLOC(ndr, r->in.req);

12541

}

12542

_mem_save_req_0 = NDR_PULL_GET_MEM_CTX(ndr);

12543

NDR_PULL_SET_MEM_CTX(ndr, r->in.req, LIBNDR_FLAG_REF_ALLOC);

12544

NDR_CHECK(ndr_pull_set_switch_value(ndr, r->in.req, r->in.level));

12545

NDR_CHECK(ndr_pull_samr_ValidatePasswordReq(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.req));

12546

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_req_0, LIBNDR_FLAG_REF_ALLOC);

12547

NDR_PULL_ALLOC(ndr, r->out.rep);

12548

ZERO_STRUCTP(r->out.rep);

12549

}

12550

if (flags & NDR_OUT) {

12551

if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {

12552

NDR_PULL_ALLOC(ndr, r->out.rep);

12553

}

12554

_mem_save_rep_0 = NDR_PULL_GET_MEM_CTX(ndr);

12555

NDR_PULL_SET_MEM_CTX(ndr, r->out.rep, LIBNDR_FLAG_REF_ALLOC);

12556

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_rep));

12557

if (_ptr_rep) {

12558

NDR_PULL_ALLOC(ndr, *r->out.rep);

12559

} else {

12560

*r->out.rep = NULL;

12561

}

12562

if (*r->out.rep) {

12563

_mem_save_rep_1 = NDR_PULL_GET_MEM_CTX(ndr);

12564

NDR_PULL_SET_MEM_CTX(ndr, *r->out.rep, 0);

12565

NDR_CHECK(ndr_pull_set_switch_value(ndr, *r->out.rep, r->in.level));

12566

NDR_CHECK(ndr_pull_samr_ValidatePasswordRep(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.rep));

12567

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_rep_1, 0);

12568

}

12569

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_rep_0, LIBNDR_FLAG_REF_ALLOC);

12570

NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));

12571

}

12572

return NDR_ERR_SUCCESS;

12573

}

12574

12575

_PUBLIC_ void ndr_print_samr_ValidatePassword(struct ndr_print *ndr, const char *name, int flags, const struct samr_ValidatePassword *r)

12576

{

12577

ndr_print_struct(ndr, name, "samr_ValidatePassword");

12578

if (r == NULL) { ndr_print_null(ndr); return; }

12579

ndr->depth++;

12580

if (flags & NDR_SET_VALUES) {

12581

ndr->flags |= LIBNDR_PRINT_SET_VALUES;

12582

}

12583

if (flags & NDR_IN) {

12584

ndr_print_struct(ndr, "in", "samr_ValidatePassword");

12585

ndr->depth++;

12586

ndr_print_samr_ValidatePasswordLevel(ndr, "level", r->in.level);

12587

ndr_print_ptr(ndr, "req", r->in.req);

12588

ndr->depth++;

12589

ndr_print_set_switch_value(ndr, r->in.req, r->in.level);

12590

ndr_print_samr_ValidatePasswordReq(ndr, "req", r->in.req);

12591

ndr->depth--;

12592

ndr->depth--;

12593

}

12594

if (flags & NDR_OUT) {

12595

ndr_print_struct(ndr, "out", "samr_ValidatePassword");

12596

ndr->depth++;

12597

ndr_print_ptr(ndr, "rep", r->out.rep);

12598

ndr->depth++;

12599

ndr_print_ptr(ndr, "rep", *r->out.rep);

12600

ndr->depth++;

12601

if (*r->out.rep) {

12602

ndr_print_set_switch_value(ndr, *r->out.rep, r->in.level);

12603

ndr_print_samr_ValidatePasswordRep(ndr, "rep", *r->out.rep);

12604

}

12605

ndr->depth--;

12606

ndr->depth--;

12607

ndr_print_NTSTATUS(ndr, "result", r->out.result);

12608

ndr->depth--;

12609

}

12610

ndr->depth--;

12611

}

12612

12613

static const struct ndr_interface_call samr_calls[] = {

12614

{

12615

"samr_Connect",

12616

sizeof(struct samr_Connect),

12617

(ndr_push_flags_fn_t) ndr_push_samr_Connect,

12618

(ndr_pull_flags_fn_t) ndr_pull_samr_Connect,

12619

(ndr_print_function_t) ndr_print_samr_Connect,

12620

{ 0, NULL },

12621

{ 0, NULL },

12622

},

12623

{

12624

"samr_Close",

12625

sizeof(struct samr_Close),

12626

(ndr_push_flags_fn_t) ndr_push_samr_Close,

12627

(ndr_pull_flags_fn_t) ndr_pull_samr_Close,

12628

(ndr_print_function_t) ndr_print_samr_Close,

12629

{ 0, NULL },

12630

{ 0, NULL },

12631

},

12632

{

12633

"samr_SetSecurity",

12634

sizeof(struct samr_SetSecurity),

12635

(ndr_push_flags_fn_t) ndr_push_samr_SetSecurity,

12636

(ndr_pull_flags_fn_t) ndr_pull_samr_SetSecurity,

12637

(ndr_print_function_t) ndr_print_samr_SetSecurity,

12638

{ 0, NULL },

12639

{ 0, NULL },

12640

},

12641

{

12642

"samr_QuerySecurity",

12643

sizeof(struct samr_QuerySecurity),

12644

(ndr_push_flags_fn_t) ndr_push_samr_QuerySecurity,

12645

(ndr_pull_flags_fn_t) ndr_pull_samr_QuerySecurity,

12646

(ndr_print_function_t) ndr_print_samr_QuerySecurity,

12647

{ 0, NULL },

12648

{ 0, NULL },

12649

},

12650

{

12651

"samr_Shutdown",

12652

sizeof(struct samr_Shutdown),

12653

(ndr_push_flags_fn_t) ndr_push_samr_Shutdown,

12654

(ndr_pull_flags_fn_t) ndr_pull_samr_Shutdown,

12655

(ndr_print_function_t) ndr_print_samr_Shutdown,

12656

{ 0, NULL },

12657

{ 0, NULL },

12658

},

12659

{

12660

"samr_LookupDomain",

12661

sizeof(struct samr_LookupDomain),

12662

(ndr_push_flags_fn_t) ndr_push_samr_LookupDomain,

12663

(ndr_pull_flags_fn_t) ndr_pull_samr_LookupDomain,

12664

(ndr_print_function_t) ndr_print_samr_LookupDomain,

12665

{ 0, NULL },

12666

{ 0, NULL },

12667

},

12668

{

12669

"samr_EnumDomains",

12670

sizeof(struct samr_EnumDomains),

12671

(ndr_push_flags_fn_t) ndr_push_samr_EnumDomains,

12672

(ndr_pull_flags_fn_t) ndr_pull_samr_EnumDomains,

12673

(ndr_print_function_t) ndr_print_samr_EnumDomains,

12674

{ 0, NULL },

12675

{ 0, NULL },

12676

},

12677

{

12678

"samr_OpenDomain",

12679

sizeof(struct samr_OpenDomain),

12680

(ndr_push_flags_fn_t) ndr_push_samr_OpenDomain,

12681

(ndr_pull_flags_fn_t) ndr_pull_samr_OpenDomain,

12682

(ndr_print_function_t) ndr_print_samr_OpenDomain,

12683

{ 0, NULL },

12684

{ 0, NULL },

12685

},

12686

{

12687

"samr_QueryDomainInfo",

12688

sizeof(struct samr_QueryDomainInfo),

12689

(ndr_push_flags_fn_t) ndr_push_samr_QueryDomainInfo,

12690

(ndr_pull_flags_fn_t) ndr_pull_samr_QueryDomainInfo,

12691

(ndr_print_function_t) ndr_print_samr_QueryDomainInfo,

12692

{ 0, NULL },

12693

{ 0, NULL },

12694

},

12695

{

12696

"samr_SetDomainInfo",

12697

sizeof(struct samr_SetDomainInfo),

12698

(ndr_push_flags_fn_t) ndr_push_samr_SetDomainInfo,

12699

(ndr_pull_flags_fn_t) ndr_pull_samr_SetDomainInfo,

12700

(ndr_print_function_t) ndr_print_samr_SetDomainInfo,

12701

{ 0, NULL },

12702

{ 0, NULL },

12703

},

12704

{

12705

"samr_CreateDomainGroup",

12706

sizeof(struct samr_CreateDomainGroup),

12707

(ndr_push_flags_fn_t) ndr_push_samr_CreateDomainGroup,

12708

(ndr_pull_flags_fn_t) ndr_pull_samr_CreateDomainGroup,

12709

(ndr_print_function_t) ndr_print_samr_CreateDomainGroup,

12710

{ 0, NULL },

12711

{ 0, NULL },

12712

},

12713

{

12714

"samr_EnumDomainGroups",

12715

sizeof(struct samr_EnumDomainGroups),

12716

(ndr_push_flags_fn_t) ndr_push_samr_EnumDomainGroups,

12717

(ndr_pull_flags_fn_t) ndr_pull_samr_EnumDomainGroups,

12718

(ndr_print_function_t) ndr_print_samr_EnumDomainGroups,

12719

{ 0, NULL },

12720

{ 0, NULL },

12721

},

12722

{

12723

"samr_CreateUser",

12724

sizeof(struct samr_CreateUser),

12725

(ndr_push_flags_fn_t) ndr_push_samr_CreateUser,

12726

(ndr_pull_flags_fn_t) ndr_pull_samr_CreateUser,

12727

(ndr_print_function_t) ndr_print_samr_CreateUser,

12728

{ 0, NULL },

12729

{ 0, NULL },

12730

},

12731

{

12732

"samr_EnumDomainUsers",

12733

sizeof(struct samr_EnumDomainUsers),

12734

(ndr_push_flags_fn_t) ndr_push_samr_EnumDomainUsers,

12735

(ndr_pull_flags_fn_t) ndr_pull_samr_EnumDomainUsers,

12736

(ndr_print_function_t) ndr_print_samr_EnumDomainUsers,

12737

{ 0, NULL },

12738

{ 0, NULL },

12739

},

12740

{

12741

"samr_CreateDomAlias",

12742

sizeof(struct samr_CreateDomAlias),

12743

(ndr_push_flags_fn_t) ndr_push_samr_CreateDomAlias,

12744

(ndr_pull_flags_fn_t) ndr_pull_samr_CreateDomAlias,

12745

(ndr_print_function_t) ndr_print_samr_CreateDomAlias,

12746

{ 0, NULL },

12747

{ 0, NULL },

12748

},

12749

{

12750

"samr_EnumDomainAliases",

12751

sizeof(struct samr_EnumDomainAliases),

12752

(ndr_push_flags_fn_t) ndr_push_samr_EnumDomainAliases,

12753

(ndr_pull_flags_fn_t) ndr_pull_samr_EnumDomainAliases,

12754

(ndr_print_function_t) ndr_print_samr_EnumDomainAliases,

12755

{ 0, NULL },

12756

{ 0, NULL },

12757

},

12758

{

12759

"samr_GetAliasMembership",

12760

sizeof(struct samr_GetAliasMembership),

12761

(ndr_push_flags_fn_t) ndr_push_samr_GetAliasMembership,

12762

(ndr_pull_flags_fn_t) ndr_pull_samr_GetAliasMembership,

12763

(ndr_print_function_t) ndr_print_samr_GetAliasMembership,

12764

{ 0, NULL },

12765

{ 0, NULL },

12766

},

12767

{

12768

"samr_LookupNames",

12769

sizeof(struct samr_LookupNames),

12770

(ndr_push_flags_fn_t) ndr_push_samr_LookupNames,

12771

(ndr_pull_flags_fn_t) ndr_pull_samr_LookupNames,

12772

(ndr_print_function_t) ndr_print_samr_LookupNames,

12773

{ 0, NULL },

12774

{ 0, NULL },

12775

},

12776

{

12777

"samr_LookupRids",

12778

sizeof(struct samr_LookupRids),

12779

(ndr_push_flags_fn_t) ndr_push_samr_LookupRids,

12780

(ndr_pull_flags_fn_t) ndr_pull_samr_LookupRids,

12781

(ndr_print_function_t) ndr_print_samr_LookupRids,

12782

{ 0, NULL },

12783

{ 0, NULL },

12784

},

12785

{

12786

"samr_OpenGroup",

12787

sizeof(struct samr_OpenGroup),

12788

(ndr_push_flags_fn_t) ndr_push_samr_OpenGroup,

12789

(ndr_pull_flags_fn_t) ndr_pull_samr_OpenGroup,

12790

(ndr_print_function_t) ndr_print_samr_OpenGroup,

12791

{ 0, NULL },

12792

{ 0, NULL },

12793

},

12794

{

12795

"samr_QueryGroupInfo",

12796

sizeof(struct samr_QueryGroupInfo),

12797

(ndr_push_flags_fn_t) ndr_push_samr_QueryGroupInfo,

12798

(ndr_pull_flags_fn_t) ndr_pull_samr_QueryGroupInfo,

12799

(ndr_print_function_t) ndr_print_samr_QueryGroupInfo,

12800

{ 0, NULL },

12801

{ 0, NULL },

12802

},

12803

{

12804

"samr_SetGroupInfo",

12805

sizeof(struct samr_SetGroupInfo),

12806

(ndr_push_flags_fn_t) ndr_push_samr_SetGroupInfo,

12807

(ndr_pull_flags_fn_t) ndr_pull_samr_SetGroupInfo,

12808

(ndr_print_function_t) ndr_print_samr_SetGroupInfo,

12809

{ 0, NULL },

12810

{ 0, NULL },

12811

},

12812

{

12813

"samr_AddGroupMember",

12814

sizeof(struct samr_AddGroupMember),

12815

(ndr_push_flags_fn_t) ndr_push_samr_AddGroupMember,

12816

(ndr_pull_flags_fn_t) ndr_pull_samr_AddGroupMember,

12817

(ndr_print_function_t) ndr_print_samr_AddGroupMember,

12818

{ 0, NULL },

12819

{ 0, NULL },

12820

},

12821

{

12822

"samr_DeleteDomainGroup",

12823

sizeof(struct samr_DeleteDomainGroup),

12824

(ndr_push_flags_fn_t) ndr_push_samr_DeleteDomainGroup,

12825

(ndr_pull_flags_fn_t) ndr_pull_samr_DeleteDomainGroup,

12826

(ndr_print_function_t) ndr_print_samr_DeleteDomainGroup,

12827

{ 0, NULL },

12828

{ 0, NULL },

12829

},

12830

{

12831

"samr_DeleteGroupMember",

12832

sizeof(struct samr_DeleteGroupMember),

12833

(ndr_push_flags_fn_t) ndr_push_samr_DeleteGroupMember,

12834

(ndr_pull_flags_fn_t) ndr_pull_samr_DeleteGroupMember,

12835

(ndr_print_function_t) ndr_print_samr_DeleteGroupMember,

12836

{ 0, NULL },

12837

{ 0, NULL },

12838

},

12839

{

12840

"samr_QueryGroupMember",

12841

sizeof(struct samr_QueryGroupMember),

12842

(ndr_push_flags_fn_t) ndr_push_samr_QueryGroupMember,

12843

(ndr_pull_flags_fn_t) ndr_pull_samr_QueryGroupMember,

12844

(ndr_print_function_t) ndr_print_samr_QueryGroupMember,

12845

{ 0, NULL },

12846

{ 0, NULL },

12847

},

12848

{

12849

"samr_SetMemberAttributesOfGroup",

12850

sizeof(struct samr_SetMemberAttributesOfGroup),

12851

(ndr_push_flags_fn_t) ndr_push_samr_SetMemberAttributesOfGroup,

12852

(ndr_pull_flags_fn_t) ndr_pull_samr_SetMemberAttributesOfGroup,

12853

(ndr_print_function_t) ndr_print_samr_SetMemberAttributesOfGroup,

12854

{ 0, NULL },

12855

{ 0, NULL },

12856

},

12857

{

12858

"samr_OpenAlias",

12859

sizeof(struct samr_OpenAlias),

12860

(ndr_push_flags_fn_t) ndr_push_samr_OpenAlias,

12861

(ndr_pull_flags_fn_t) ndr_pull_samr_OpenAlias,

12862

(ndr_print_function_t) ndr_print_samr_OpenAlias,

12863

{ 0, NULL },

12864

{ 0, NULL },

12865

},

12866

{

12867

"samr_QueryAliasInfo",

12868

sizeof(struct samr_QueryAliasInfo),

12869

(ndr_push_flags_fn_t) ndr_push_samr_QueryAliasInfo,

12870

(ndr_pull_flags_fn_t) ndr_pull_samr_QueryAliasInfo,

12871

(ndr_print_function_t) ndr_print_samr_QueryAliasInfo,

12872

{ 0, NULL },

12873

{ 0, NULL },

12874

},

12875

{

12876

"samr_SetAliasInfo",

12877

sizeof(struct samr_SetAliasInfo),

12878

(ndr_push_flags_fn_t) ndr_push_samr_SetAliasInfo,

12879

(ndr_pull_flags_fn_t) ndr_pull_samr_SetAliasInfo,

12880

(ndr_print_function_t) ndr_print_samr_SetAliasInfo,

12881

{ 0, NULL },

12882

{ 0, NULL },

12883

},

12884

{

12885

"samr_DeleteDomAlias",

12886

sizeof(struct samr_DeleteDomAlias),

12887

(ndr_push_flags_fn_t) ndr_push_samr_DeleteDomAlias,

12888

(ndr_pull_flags_fn_t) ndr_pull_samr_DeleteDomAlias,

12889

(ndr_print_function_t) ndr_print_samr_DeleteDomAlias,

12890

{ 0, NULL },

12891

{ 0, NULL },

12892

},

12893

{

12894

"samr_AddAliasMember",

12895

sizeof(struct samr_AddAliasMember),

12896

(ndr_push_flags_fn_t) ndr_push_samr_AddAliasMember,

12897

(ndr_pull_flags_fn_t) ndr_pull_samr_AddAliasMember,

12898

(ndr_print_function_t) ndr_print_samr_AddAliasMember,

12899

{ 0, NULL },

12900

{ 0, NULL },

12901

},

12902

{

12903

"samr_DeleteAliasMember",

12904

sizeof(struct samr_DeleteAliasMember),

12905

(ndr_push_flags_fn_t) ndr_push_samr_DeleteAliasMember,

12906

(ndr_pull_flags_fn_t) ndr_pull_samr_DeleteAliasMember,

12907

(ndr_print_function_t) ndr_print_samr_DeleteAliasMember,

12908

{ 0, NULL },

12909

{ 0, NULL },

12910

},

12911

{

12912

"samr_GetMembersInAlias",

12913

sizeof(struct samr_GetMembersInAlias),

12914

(ndr_push_flags_fn_t) ndr_push_samr_GetMembersInAlias,

12915

(ndr_pull_flags_fn_t) ndr_pull_samr_GetMembersInAlias,

12916

(ndr_print_function_t) ndr_print_samr_GetMembersInAlias,

12917

{ 0, NULL },

12918

{ 0, NULL },

12919

},

12920

{

12921

"samr_OpenUser",

12922

sizeof(struct samr_OpenUser),

12923

(ndr_push_flags_fn_t) ndr_push_samr_OpenUser,

12924

(ndr_pull_flags_fn_t) ndr_pull_samr_OpenUser,

12925

(ndr_print_function_t) ndr_print_samr_OpenUser,

12926

{ 0, NULL },

12927

{ 0, NULL },

12928

},

12929

{

12930

"samr_DeleteUser",

12931

sizeof(struct samr_DeleteUser),

12932

(ndr_push_flags_fn_t) ndr_push_samr_DeleteUser,

12933

(ndr_pull_flags_fn_t) ndr_pull_samr_DeleteUser,

12934

(ndr_print_function_t) ndr_print_samr_DeleteUser,

12935

{ 0, NULL },

12936

{ 0, NULL },

12937

},

12938

{

12939

"samr_QueryUserInfo",

12940

sizeof(struct samr_QueryUserInfo),

12941

(ndr_push_flags_fn_t) ndr_push_samr_QueryUserInfo,

12942

(ndr_pull_flags_fn_t) ndr_pull_samr_QueryUserInfo,

12943

(ndr_print_function_t) ndr_print_samr_QueryUserInfo,

12944

{ 0, NULL },

12945

{ 0, NULL },

12946

},

12947

{

12948

"samr_SetUserInfo",

12949

sizeof(struct samr_SetUserInfo),

12950

(ndr_push_flags_fn_t) ndr_push_samr_SetUserInfo,

12951

(ndr_pull_flags_fn_t) ndr_pull_samr_SetUserInfo,

12952

(ndr_print_function_t) ndr_print_samr_SetUserInfo,

12953

{ 0, NULL },

12954

{ 0, NULL },

12955

},

12956

{

12957

"samr_ChangePasswordUser",

12958

sizeof(struct samr_ChangePasswordUser),

12959

(ndr_push_flags_fn_t) ndr_push_samr_ChangePasswordUser,

12960

(ndr_pull_flags_fn_t) ndr_pull_samr_ChangePasswordUser,

12961

(ndr_print_function_t) ndr_print_samr_ChangePasswordUser,

12962

{ 0, NULL },

12963

{ 0, NULL },

12964

},

12965

{

12966

"samr_GetGroupsForUser",

12967

sizeof(struct samr_GetGroupsForUser),

12968

(ndr_push_flags_fn_t) ndr_push_samr_GetGroupsForUser,

12969

(ndr_pull_flags_fn_t) ndr_pull_samr_GetGroupsForUser,

12970

(ndr_print_function_t) ndr_print_samr_GetGroupsForUser,

12971

{ 0, NULL },

12972

{ 0, NULL },

12973

},

12974

{

12975

"samr_QueryDisplayInfo",

12976

sizeof(struct samr_QueryDisplayInfo),

12977

(ndr_push_flags_fn_t) ndr_push_samr_QueryDisplayInfo,

12978

(ndr_pull_flags_fn_t) ndr_pull_samr_QueryDisplayInfo,

12979

(ndr_print_function_t) ndr_print_samr_QueryDisplayInfo,

12980

{ 0, NULL },

12981

{ 0, NULL },

12982

},

12983

{

12984

"samr_GetDisplayEnumerationIndex",

12985

sizeof(struct samr_GetDisplayEnumerationIndex),

12986

(ndr_push_flags_fn_t) ndr_push_samr_GetDisplayEnumerationIndex,

12987

(ndr_pull_flags_fn_t) ndr_pull_samr_GetDisplayEnumerationIndex,

12988

(ndr_print_function_t) ndr_print_samr_GetDisplayEnumerationIndex,

12989

{ 0, NULL },

12990

{ 0, NULL },

12991

},

12992

{

12993

"samr_TestPrivateFunctionsDomain",

12994

sizeof(struct samr_TestPrivateFunctionsDomain),

12995

(ndr_push_flags_fn_t) ndr_push_samr_TestPrivateFunctionsDomain,

12996

(ndr_pull_flags_fn_t) ndr_pull_samr_TestPrivateFunctionsDomain,

12997

(ndr_print_function_t) ndr_print_samr_TestPrivateFunctionsDomain,

12998

{ 0, NULL },

12999

{ 0, NULL },

13000

},

13001

{

13002

"samr_TestPrivateFunctionsUser",

13003

sizeof(struct samr_TestPrivateFunctionsUser),

13004

(ndr_push_flags_fn_t) ndr_push_samr_TestPrivateFunctionsUser,

13005

(ndr_pull_flags_fn_t) ndr_pull_samr_TestPrivateFunctionsUser,

13006

(ndr_print_function_t) ndr_print_samr_TestPrivateFunctionsUser,

13007

{ 0, NULL },

13008

{ 0, NULL },

13009

},

13010

{

13011

"samr_GetUserPwInfo",

13012

sizeof(struct samr_GetUserPwInfo),

13013

(ndr_push_flags_fn_t) ndr_push_samr_GetUserPwInfo,

13014

(ndr_pull_flags_fn_t) ndr_pull_samr_GetUserPwInfo,

13015

(ndr_print_function_t) ndr_print_samr_GetUserPwInfo,

13016

{ 0, NULL },

13017

{ 0, NULL },

13018

},

13019

{

13020

"samr_RemoveMemberFromForeignDomain",

13021

sizeof(struct samr_RemoveMemberFromForeignDomain),

13022

(ndr_push_flags_fn_t) ndr_push_samr_RemoveMemberFromForeignDomain,

13023

(ndr_pull_flags_fn_t) ndr_pull_samr_RemoveMemberFromForeignDomain,

13024

(ndr_print_function_t) ndr_print_samr_RemoveMemberFromForeignDomain,

13025

{ 0, NULL },

13026

{ 0, NULL },

13027

},

13028

{

13029

"samr_QueryDomainInfo2",

13030

sizeof(struct samr_QueryDomainInfo2),

13031

(ndr_push_flags_fn_t) ndr_push_samr_QueryDomainInfo2,

13032

(ndr_pull_flags_fn_t) ndr_pull_samr_QueryDomainInfo2,

13033

(ndr_print_function_t) ndr_print_samr_QueryDomainInfo2,

13034

{ 0, NULL },

13035

{ 0, NULL },

13036

},

13037

{

13038

"samr_QueryUserInfo2",

13039

sizeof(struct samr_QueryUserInfo2),

13040

(ndr_push_flags_fn_t) ndr_push_samr_QueryUserInfo2,

13041

(ndr_pull_flags_fn_t) ndr_pull_samr_QueryUserInfo2,

13042

(ndr_print_function_t) ndr_print_samr_QueryUserInfo2,

13043

{ 0, NULL },

13044

{ 0, NULL },

13045

},

13046

{

13047

"samr_QueryDisplayInfo2",

13048

sizeof(struct samr_QueryDisplayInfo2),

13049

(ndr_push_flags_fn_t) ndr_push_samr_QueryDisplayInfo2,

13050

(ndr_pull_flags_fn_t) ndr_pull_samr_QueryDisplayInfo2,

13051

(ndr_print_function_t) ndr_print_samr_QueryDisplayInfo2,

13052

{ 0, NULL },

13053

{ 0, NULL },

13054

},

13055

{

13056

"samr_GetDisplayEnumerationIndex2",

13057

sizeof(struct samr_GetDisplayEnumerationIndex2),

13058

(ndr_push_flags_fn_t) ndr_push_samr_GetDisplayEnumerationIndex2,

13059

(ndr_pull_flags_fn_t) ndr_pull_samr_GetDisplayEnumerationIndex2,

13060

(ndr_print_function_t) ndr_print_samr_GetDisplayEnumerationIndex2,

13061

{ 0, NULL },

13062

{ 0, NULL },

13063

},

13064

{

13065

"samr_CreateUser2",

13066

sizeof(struct samr_CreateUser2),

13067

(ndr_push_flags_fn_t) ndr_push_samr_CreateUser2,

13068

(ndr_pull_flags_fn_t) ndr_pull_samr_CreateUser2,

13069

(ndr_print_function_t) ndr_print_samr_CreateUser2,

13070

{ 0, NULL },

13071

{ 0, NULL },

13072

},

13073

{

13074

"samr_QueryDisplayInfo3",

13075

sizeof(struct samr_QueryDisplayInfo3),

13076

(ndr_push_flags_fn_t) ndr_push_samr_QueryDisplayInfo3,

13077

(ndr_pull_flags_fn_t) ndr_pull_samr_QueryDisplayInfo3,

13078

(ndr_print_function_t) ndr_print_samr_QueryDisplayInfo3,

13079

{ 0, NULL },

13080

{ 0, NULL },

13081

},

13082

{

13083

"samr_AddMultipleMembersToAlias",

13084

sizeof(struct samr_AddMultipleMembersToAlias),

13085

(ndr_push_flags_fn_t) ndr_push_samr_AddMultipleMembersToAlias,

13086

(ndr_pull_flags_fn_t) ndr_pull_samr_AddMultipleMembersToAlias,

13087

(ndr_print_function_t) ndr_print_samr_AddMultipleMembersToAlias,

13088

{ 0, NULL },

13089

{ 0, NULL },

13090

},

13091

{

13092

"samr_RemoveMultipleMembersFromAlias",

13093

sizeof(struct samr_RemoveMultipleMembersFromAlias),

13094

(ndr_push_flags_fn_t) ndr_push_samr_RemoveMultipleMembersFromAlias,

13095

(ndr_pull_flags_fn_t) ndr_pull_samr_RemoveMultipleMembersFromAlias,

13096

(ndr_print_function_t) ndr_print_samr_RemoveMultipleMembersFromAlias,

13097

{ 0, NULL },

13098

{ 0, NULL },

13099

},

13100

{

13101

"samr_OemChangePasswordUser2",

13102

sizeof(struct samr_OemChangePasswordUser2),

13103

(ndr_push_flags_fn_t) ndr_push_samr_OemChangePasswordUser2,

13104

(ndr_pull_flags_fn_t) ndr_pull_samr_OemChangePasswordUser2,

13105

(ndr_print_function_t) ndr_print_samr_OemChangePasswordUser2,

13106

{ 0, NULL },

13107

{ 0, NULL },

13108

},

13109

{

13110

"samr_ChangePasswordUser2",

13111

sizeof(struct samr_ChangePasswordUser2),

13112

(ndr_push_flags_fn_t) ndr_push_samr_ChangePasswordUser2,

13113

(ndr_pull_flags_fn_t) ndr_pull_samr_ChangePasswordUser2,

13114

(ndr_print_function_t) ndr_print_samr_ChangePasswordUser2,

13115

{ 0, NULL },

13116

{ 0, NULL },

13117

},

13118

{

13119

"samr_GetDomPwInfo",

13120

sizeof(struct samr_GetDomPwInfo),

13121

(ndr_push_flags_fn_t) ndr_push_samr_GetDomPwInfo,

13122

(ndr_pull_flags_fn_t) ndr_pull_samr_GetDomPwInfo,

13123

(ndr_print_function_t) ndr_print_samr_GetDomPwInfo,

13124

{ 0, NULL },

13125

{ 0, NULL },

13126

},

13127

{

13128

"samr_Connect2",

13129

sizeof(struct samr_Connect2),

13130

(ndr_push_flags_fn_t) ndr_push_samr_Connect2,

13131

(ndr_pull_flags_fn_t) ndr_pull_samr_Connect2,

13132

(ndr_print_function_t) ndr_print_samr_Connect2,

13133

{ 0, NULL },

13134

{ 0, NULL },

13135

},

13136

{

13137

"samr_SetUserInfo2",

13138

sizeof(struct samr_SetUserInfo2),

13139

(ndr_push_flags_fn_t) ndr_push_samr_SetUserInfo2,

13140

(ndr_pull_flags_fn_t) ndr_pull_samr_SetUserInfo2,

13141

(ndr_print_function_t) ndr_print_samr_SetUserInfo2,

13142

{ 0, NULL },

13143

{ 0, NULL },

13144

},

13145

{

13146

"samr_SetBootKeyInformation",

13147

sizeof(struct samr_SetBootKeyInformation),

13148

(ndr_push_flags_fn_t) ndr_push_samr_SetBootKeyInformation,

13149

(ndr_pull_flags_fn_t) ndr_pull_samr_SetBootKeyInformation,

13150

(ndr_print_function_t) ndr_print_samr_SetBootKeyInformation,

13151

{ 0, NULL },

13152

{ 0, NULL },

13153

},

13154

{

13155

"samr_GetBootKeyInformation",

13156

sizeof(struct samr_GetBootKeyInformation),

13157

(ndr_push_flags_fn_t) ndr_push_samr_GetBootKeyInformation,

13158

(ndr_pull_flags_fn_t) ndr_pull_samr_GetBootKeyInformation,

13159

(ndr_print_function_t) ndr_print_samr_GetBootKeyInformation,

13160

{ 0, NULL },

13161

{ 0, NULL },

13162

},

13163

{

13164

"samr_Connect3",

13165

sizeof(struct samr_Connect3),

13166

(ndr_push_flags_fn_t) ndr_push_samr_Connect3,

13167

(ndr_pull_flags_fn_t) ndr_pull_samr_Connect3,

13168

(ndr_print_function_t) ndr_print_samr_Connect3,

13169

{ 0, NULL },

13170

{ 0, NULL },

13171

},

13172

{

13173

"samr_Connect4",

13174

sizeof(struct samr_Connect4),

13175

(ndr_push_flags_fn_t) ndr_push_samr_Connect4,

13176

(ndr_pull_flags_fn_t) ndr_pull_samr_Connect4,

13177

(ndr_print_function_t) ndr_print_samr_Connect4,

13178

{ 0, NULL },

13179

{ 0, NULL },

13180

},

13181

{

13182

"samr_ChangePasswordUser3",

13183

sizeof(struct samr_ChangePasswordUser3),

13184

(ndr_push_flags_fn_t) ndr_push_samr_ChangePasswordUser3,

13185

(ndr_pull_flags_fn_t) ndr_pull_samr_ChangePasswordUser3,

13186

(ndr_print_function_t) ndr_print_samr_ChangePasswordUser3,

13187

{ 0, NULL },

13188

{ 0, NULL },

13189

},

13190

{

13191

"samr_Connect5",

13192

sizeof(struct samr_Connect5),

13193

(ndr_push_flags_fn_t) ndr_push_samr_Connect5,

13194

(ndr_pull_flags_fn_t) ndr_pull_samr_Connect5,

13195

(ndr_print_function_t) ndr_print_samr_Connect5,

13196

{ 0, NULL },

13197

{ 0, NULL },

13198

},

13199

{

13200

"samr_RidToSid",

13201

sizeof(struct samr_RidToSid),

13202

(ndr_push_flags_fn_t) ndr_push_samr_RidToSid,

13203

(ndr_pull_flags_fn_t) ndr_pull_samr_RidToSid,

13204

(ndr_print_function_t) ndr_print_samr_RidToSid,

13205

{ 0, NULL },

13206

{ 0, NULL },

13207

},

13208

{

13209

"samr_SetDsrmPassword",

13210

sizeof(struct samr_SetDsrmPassword),

13211

(ndr_push_flags_fn_t) ndr_push_samr_SetDsrmPassword,

13212

(ndr_pull_flags_fn_t) ndr_pull_samr_SetDsrmPassword,

13213

(ndr_print_function_t) ndr_print_samr_SetDsrmPassword,

13214

{ 0, NULL },

13215

{ 0, NULL },

13216

},

13217

{

13218

"samr_ValidatePassword",

13219

sizeof(struct samr_ValidatePassword),

13220

(ndr_push_flags_fn_t) ndr_push_samr_ValidatePassword,

13221

(ndr_pull_flags_fn_t) ndr_pull_samr_ValidatePassword,

13222

(ndr_print_function_t) ndr_print_samr_ValidatePassword,

13223

{ 0, NULL },

13224

{ 0, NULL },

13225

},

13226

{ NULL, 0, NULL, NULL, NULL }

13227

};

13228

13229

static const char * const samr_endpoint_strings[] = {

13230

"ncacn_np:[\\pipe\\samr]",

13231

"ncacn_ip_tcp:",

13232

"ncalrpc:",

13233

};

13234

13235

static const struct ndr_interface_string_array samr_endpoints = {

13236

.count = 3,

13237

.names = samr_endpoint_strings

13238

};

13239

13240

static const char * const samr_authservice_strings[] = {

13241

"host",

13242

};

13243

13244

static const struct ndr_interface_string_array samr_authservices = {

13245

.count = 1,

13246

.names = samr_authservice_strings

13247

};

13248

13249

13250

const struct ndr_interface_table ndr_table_samr = {

13251

.name = "samr",

13252

.syntax_id = {

13253

{0x12345778,0x1234,0xabcd,{0xef,0x00},{0x01,0x23,0x45,0x67,0x89,0xac}},

13254

NDR_SAMR_VERSION

13255

},

13256

.helpstring = NDR_SAMR_HELPSTRING,

13257

.num_calls = 68,

13258

.calls = samr_calls,

13259

.endpoints = &samr_endpoints,

13260

.authservices = &samr_authservices

13261

};

13262