~zulcss/samba/server-dailies-3.4

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

}

NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->name), sizeof(uint16_t)));

NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->name, ndr_get_array_length(ndr, &r->name), sizeof(uint16_t), CH_UTF16));

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_name_0, 0);

}

return NDR_ERR_SUCCESS;

}

_PUBLIC_ void ndr_print_winreg_String(struct ndr_print *ndr, const char *name, const struct winreg_String *r)

{

ndr_print_struct(ndr, name, "winreg_String");

ndr->depth++;

ndr_print_uint16(ndr, "name_len", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?strlen_m_term(r->name) * 2:r->name_len);

ndr_print_uint16(ndr, "name_size", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?strlen_m_term(r->name) * 2:r->name_size);

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

ndr->depth++;

if (r->name) {

ndr_print_string(ndr, "name", r->name);

}

100

ndr->depth--;

101

ndr->depth--;

102

}

103

104

static enum ndr_err_code ndr_push_KeySecurityData(struct ndr_push *ndr, int ndr_flags, const struct KeySecurityData *r)

105

{

106

if (ndr_flags & NDR_SCALARS) {

107

NDR_CHECK(ndr_push_align(ndr, 4));

108

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

109

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

110

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

111

}

112

if (ndr_flags & NDR_BUFFERS) {

113

if (r->data) {

114

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

115

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

116

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

117

NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->data, r->len));

118

}

119

}

120

return NDR_ERR_SUCCESS;

121

}

122

123

static enum ndr_err_code ndr_pull_KeySecurityData(struct ndr_pull *ndr, int ndr_flags, struct KeySecurityData *r)

124

{

125

uint32_t _ptr_data;

126

TALLOC_CTX *_mem_save_data_0;

127

if (ndr_flags & NDR_SCALARS) {

128

NDR_CHECK(ndr_pull_align(ndr, 4));

129

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data));

130

if (_ptr_data) {

131

NDR_PULL_ALLOC(ndr, r->data);

132

} else {

133

r->data = NULL;

134

}

135

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

136

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

137

}

138

if (ndr_flags & NDR_BUFFERS) {

139

if (r->data) {

140

_mem_save_data_0 = NDR_PULL_GET_MEM_CTX(ndr);

141

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

142

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

143

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

144

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

145

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

146

}

147

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

148

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

149

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_0, 0);

150

}

151

if (r->data) {

152

NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->data, r->size));

153

}

154

if (r->data) {

155

NDR_CHECK(ndr_check_array_length(ndr, (void*)&r->data, r->len));

156

}

157

}

158

return NDR_ERR_SUCCESS;

159

}

160

161

_PUBLIC_ void ndr_print_KeySecurityData(struct ndr_print *ndr, const char *name, const struct KeySecurityData *r)

162

{

163

ndr_print_struct(ndr, name, "KeySecurityData");

164

ndr->depth++;

165

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

166

ndr->depth++;

167

if (r->data) {

168

ndr_print_array_uint8(ndr, "data", r->data, r->len);

169

}

170

ndr->depth--;

171

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

172

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

173

ndr->depth--;

174

}

175

176

static enum ndr_err_code ndr_push_winreg_SecBuf(struct ndr_push *ndr, int ndr_flags, const struct winreg_SecBuf *r)

177

{

178

if (ndr_flags & NDR_SCALARS) {

179

NDR_CHECK(ndr_push_align(ndr, 4));

180

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

181

NDR_CHECK(ndr_push_KeySecurityData(ndr, NDR_SCALARS, &r->sd));

182

NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->inherit));

183

}

184

if (ndr_flags & NDR_BUFFERS) {

185

NDR_CHECK(ndr_push_KeySecurityData(ndr, NDR_BUFFERS, &r->sd));

186

}

187

return NDR_ERR_SUCCESS;

188

}

189

190

static enum ndr_err_code ndr_pull_winreg_SecBuf(struct ndr_pull *ndr, int ndr_flags, struct winreg_SecBuf *r)

191

{

192

if (ndr_flags & NDR_SCALARS) {

193

NDR_CHECK(ndr_pull_align(ndr, 4));

194

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

195

NDR_CHECK(ndr_pull_KeySecurityData(ndr, NDR_SCALARS, &r->sd));

196

NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->inherit));

197

}

198

if (ndr_flags & NDR_BUFFERS) {

199

NDR_CHECK(ndr_pull_KeySecurityData(ndr, NDR_BUFFERS, &r->sd));

200

}

201

return NDR_ERR_SUCCESS;

202

}

203

204

_PUBLIC_ void ndr_print_winreg_SecBuf(struct ndr_print *ndr, const char *name, const struct winreg_SecBuf *r)

205

{

206

ndr_print_struct(ndr, name, "winreg_SecBuf");

207

ndr->depth++;

208

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

209

ndr_print_KeySecurityData(ndr, "sd", &r->sd);

210

ndr_print_uint8(ndr, "inherit", r->inherit);

211

ndr->depth--;

212

}

213

214

static enum ndr_err_code ndr_push_winreg_CreateAction(struct ndr_push *ndr, int ndr_flags, enum winreg_CreateAction r)

215

{

216

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

217

return NDR_ERR_SUCCESS;

218

}

219

220

static enum ndr_err_code ndr_pull_winreg_CreateAction(struct ndr_pull *ndr, int ndr_flags, enum winreg_CreateAction *r)

221

{

222

uint32_t v;

223

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

224

*r = v;

225

return NDR_ERR_SUCCESS;

226

}

227

228

_PUBLIC_ void ndr_print_winreg_CreateAction(struct ndr_print *ndr, const char *name, enum winreg_CreateAction r)

229

{

230

const char *val = NULL;

231

232

switch (r) {

233

case REG_ACTION_NONE: val = "REG_ACTION_NONE"; break;

234

case REG_CREATED_NEW_KEY: val = "REG_CREATED_NEW_KEY"; break;

235

case REG_OPENED_EXISTING_KEY: val = "REG_OPENED_EXISTING_KEY"; break;

236

}

237

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

238

}

239

240

static enum ndr_err_code ndr_push_winreg_StringBuf(struct ndr_push *ndr, int ndr_flags, const struct winreg_StringBuf *r)

241

{

242

if (ndr_flags & NDR_SCALARS) {

243

NDR_CHECK(ndr_push_align(ndr, 4));

244

NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, strlen_m_term_null(r->name) * 2));

245

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

246

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

247

}

248

if (ndr_flags & NDR_BUFFERS) {

249

if (r->name) {

250

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size / 2));

251

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

252

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, strlen_m_term_null(r->name) * 2 / 2));

253

NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->name, strlen_m_term_null(r->name) * 2 / 2, sizeof(uint16_t), CH_UTF16));

254

}

255

}

256

return NDR_ERR_SUCCESS;

257

}

258

259

static enum ndr_err_code ndr_pull_winreg_StringBuf(struct ndr_pull *ndr, int ndr_flags, struct winreg_StringBuf *r)

260

{

261

uint32_t _ptr_name;

262

TALLOC_CTX *_mem_save_name_0;

263

if (ndr_flags & NDR_SCALARS) {

264

NDR_CHECK(ndr_pull_align(ndr, 4));

265

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

266

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

267

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_name));

268

if (_ptr_name) {

269

NDR_PULL_ALLOC(ndr, r->name);

270

} else {

271

r->name = NULL;

272

}

273

}

274

if (ndr_flags & NDR_BUFFERS) {

275

if (r->name) {

276

_mem_save_name_0 = NDR_PULL_GET_MEM_CTX(ndr);

277

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

278

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

279

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

280

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

281

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

282

}

283

NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->name, ndr_get_array_length(ndr, &r->name), sizeof(uint16_t), CH_UTF16));

284

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_name_0, 0);

285

}

286

if (r->name) {

287

NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->name, r->size / 2));

288

}

289

if (r->name) {

290

NDR_CHECK(ndr_check_array_length(ndr, (void*)&r->name, r->length / 2));

291

}

292

}

293

return NDR_ERR_SUCCESS;

294

}

295

296

_PUBLIC_ void ndr_print_winreg_StringBuf(struct ndr_print *ndr, const char *name, const struct winreg_StringBuf *r)

297

{

298

ndr_print_struct(ndr, name, "winreg_StringBuf");

299

ndr->depth++;

300

ndr_print_uint16(ndr, "length", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?strlen_m_term_null(r->name) * 2:r->length);

301

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

302

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

303

ndr->depth++;

304

if (r->name) {

305

ndr_print_string(ndr, "name", r->name);

306

}

307

ndr->depth--;

308

ndr->depth--;

309

}

310

311

static enum ndr_err_code ndr_push_winreg_ValNameBuf(struct ndr_push *ndr, int ndr_flags, const struct winreg_ValNameBuf *r)

312

{

313

if (ndr_flags & NDR_SCALARS) {

314

NDR_CHECK(ndr_push_align(ndr, 4));

315

NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, strlen_m_term(r->name) * 2));

316

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

317

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

318

}

319

if (ndr_flags & NDR_BUFFERS) {

320

if (r->name) {

321

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size / 2));

322

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

323

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, strlen_m_term(r->name) * 2 / 2));

324

NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->name, strlen_m_term(r->name) * 2 / 2, sizeof(uint16_t), CH_UTF16));

325

}

326

}

327

return NDR_ERR_SUCCESS;

328

}

329

330

static enum ndr_err_code ndr_pull_winreg_ValNameBuf(struct ndr_pull *ndr, int ndr_flags, struct winreg_ValNameBuf *r)

331

{

332

uint32_t _ptr_name;

333

TALLOC_CTX *_mem_save_name_0;

334

if (ndr_flags & NDR_SCALARS) {

335

NDR_CHECK(ndr_pull_align(ndr, 4));

336

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

337

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

338

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_name));

339

if (_ptr_name) {

340

NDR_PULL_ALLOC(ndr, r->name);

341

} else {

342

r->name = NULL;

343

}

344

}

345

if (ndr_flags & NDR_BUFFERS) {

346

if (r->name) {

347

_mem_save_name_0 = NDR_PULL_GET_MEM_CTX(ndr);

348

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

349

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

350

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

351

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

352

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

353

}

354

NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->name, ndr_get_array_length(ndr, &r->name), sizeof(uint16_t), CH_UTF16));

355

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_name_0, 0);

356

}

357

if (r->name) {

358

NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->name, r->size / 2));

359

}

360

if (r->name) {

361

NDR_CHECK(ndr_check_array_length(ndr, (void*)&r->name, r->length / 2));

362

}

363

}

364

return NDR_ERR_SUCCESS;

365

}

366

367

_PUBLIC_ void ndr_print_winreg_ValNameBuf(struct ndr_print *ndr, const char *name, const struct winreg_ValNameBuf *r)

368

{

369

ndr_print_struct(ndr, name, "winreg_ValNameBuf");

370

ndr->depth++;

371

ndr_print_uint16(ndr, "length", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?strlen_m_term(r->name) * 2:r->length);

372

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

373

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

374

ndr->depth++;

375

if (r->name) {

376

ndr_print_string(ndr, "name", r->name);

377

}

378

ndr->depth--;

379

ndr->depth--;

380

}

381

382

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

383

{

384

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

385

return NDR_ERR_SUCCESS;

386

}

387

388

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

389

{

390

uint32_t v;

391

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

392

*r = v;

393

return NDR_ERR_SUCCESS;

394

}

395

396

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

397

{

398

ndr_print_uint32(ndr, name, r);

399

ndr->depth++;

400

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

401

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

402

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

403

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

404

ndr->depth--;

405

}

406

407

static enum ndr_err_code ndr_push_KeySecurityAttribute(struct ndr_push *ndr, int ndr_flags, const struct KeySecurityAttribute *r)

408

{

409

if (ndr_flags & NDR_SCALARS) {

410

NDR_CHECK(ndr_push_align(ndr, 4));

411

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

412

NDR_CHECK(ndr_push_KeySecurityData(ndr, NDR_SCALARS, &r->sec_data));

413

NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->inherit));

414

}

415

if (ndr_flags & NDR_BUFFERS) {

416

NDR_CHECK(ndr_push_KeySecurityData(ndr, NDR_BUFFERS, &r->sec_data));

417

}

418

return NDR_ERR_SUCCESS;

419

}

420

421

static enum ndr_err_code ndr_pull_KeySecurityAttribute(struct ndr_pull *ndr, int ndr_flags, struct KeySecurityAttribute *r)

422

{

423

if (ndr_flags & NDR_SCALARS) {

424

NDR_CHECK(ndr_pull_align(ndr, 4));

425

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

426

NDR_CHECK(ndr_pull_KeySecurityData(ndr, NDR_SCALARS, &r->sec_data));

427

NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->inherit));

428

}

429

if (ndr_flags & NDR_BUFFERS) {

430

NDR_CHECK(ndr_pull_KeySecurityData(ndr, NDR_BUFFERS, &r->sec_data));

431

}

432

return NDR_ERR_SUCCESS;

433

}

434

435

_PUBLIC_ void ndr_print_KeySecurityAttribute(struct ndr_print *ndr, const char *name, const struct KeySecurityAttribute *r)

436

{

437

ndr_print_struct(ndr, name, "KeySecurityAttribute");

438

ndr->depth++;

439

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

440

ndr_print_KeySecurityData(ndr, "sec_data", &r->sec_data);

441

ndr_print_uint8(ndr, "inherit", r->inherit);

442

ndr->depth--;

443

}

444

445

static enum ndr_err_code ndr_push_QueryMultipleValue(struct ndr_push *ndr, int ndr_flags, const struct QueryMultipleValue *r)

446

{

447

if (ndr_flags & NDR_SCALARS) {

448

NDR_CHECK(ndr_push_align(ndr, 4));

449

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

450

NDR_CHECK(ndr_push_winreg_Type(ndr, NDR_SCALARS, r->type));

451

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

452

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

453

}

454

if (ndr_flags & NDR_BUFFERS) {

455

if (r->name) {

456

NDR_CHECK(ndr_push_winreg_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->name));

457

}

458

}

459

return NDR_ERR_SUCCESS;

460

}

461

462

static enum ndr_err_code ndr_pull_QueryMultipleValue(struct ndr_pull *ndr, int ndr_flags, struct QueryMultipleValue *r)

463

{

464

uint32_t _ptr_name;

465

TALLOC_CTX *_mem_save_name_0;

466

if (ndr_flags & NDR_SCALARS) {

467

NDR_CHECK(ndr_pull_align(ndr, 4));

468

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_name));

469

if (_ptr_name) {

470

NDR_PULL_ALLOC(ndr, r->name);

471

} else {

472

r->name = NULL;

473

}

474

NDR_CHECK(ndr_pull_winreg_Type(ndr, NDR_SCALARS, &r->type));

475

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

476

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

477

}

478

if (ndr_flags & NDR_BUFFERS) {

479

if (r->name) {

480

_mem_save_name_0 = NDR_PULL_GET_MEM_CTX(ndr);

481

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

482

NDR_CHECK(ndr_pull_winreg_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->name));

483

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_name_0, 0);

484

}

485

}

486

return NDR_ERR_SUCCESS;

487

}

488

489

_PUBLIC_ void ndr_print_QueryMultipleValue(struct ndr_print *ndr, const char *name, const struct QueryMultipleValue *r)

490

{

491

ndr_print_struct(ndr, name, "QueryMultipleValue");

492

ndr->depth++;

493

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

494

ndr->depth++;

495

if (r->name) {

496

ndr_print_winreg_String(ndr, "name", r->name);

497

}

498

ndr->depth--;

499

ndr_print_winreg_Type(ndr, "type", r->type);

500

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

501

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

502

ndr->depth--;

503

}

504

505

static enum ndr_err_code ndr_push_winreg_OpenHKCR(struct ndr_push *ndr, int flags, const struct winreg_OpenHKCR *r)

506

{

507

if (flags & NDR_IN) {

508

NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.system_name));

509

if (r->in.system_name) {

510

NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, *r->in.system_name));

511

}

512

NDR_CHECK(ndr_push_winreg_AccessMask(ndr, NDR_SCALARS, r->in.access_mask));

513

}

514

if (flags & NDR_OUT) {

515

if (r->out.handle == NULL) {

516

return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");

517

}

518

NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.handle));

519

NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));

520

}

521

return NDR_ERR_SUCCESS;

522

}

523

524

static enum ndr_err_code ndr_pull_winreg_OpenHKCR(struct ndr_pull *ndr, int flags, struct winreg_OpenHKCR *r)

525

{

526

uint32_t _ptr_system_name;

527

TALLOC_CTX *_mem_save_system_name_0;

528

TALLOC_CTX *_mem_save_handle_0;

529

if (flags & NDR_IN) {

530

ZERO_STRUCT(r->out);

531

532

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_system_name));

533

if (_ptr_system_name) {

534

NDR_PULL_ALLOC(ndr, r->in.system_name);

535

} else {

536

r->in.system_name = NULL;

537

}

538

if (r->in.system_name) {

539

_mem_save_system_name_0 = NDR_PULL_GET_MEM_CTX(ndr);

540

NDR_PULL_SET_MEM_CTX(ndr, r->in.system_name, 0);

541

NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, r->in.system_name));

542

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_system_name_0, 0);

543

}

544

NDR_CHECK(ndr_pull_winreg_AccessMask(ndr, NDR_SCALARS, &r->in.access_mask));

545

NDR_PULL_ALLOC(ndr, r->out.handle);

546

ZERO_STRUCTP(r->out.handle);

547

}

548

if (flags & NDR_OUT) {

549

if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {

550

NDR_PULL_ALLOC(ndr, r->out.handle);

551

}

552

_mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);

553

NDR_PULL_SET_MEM_CTX(ndr, r->out.handle, LIBNDR_FLAG_REF_ALLOC);

554

NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.handle));

555

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);

556

NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));

557

}

558

return NDR_ERR_SUCCESS;

559

}

560

561

_PUBLIC_ void ndr_print_winreg_OpenHKCR(struct ndr_print *ndr, const char *name, int flags, const struct winreg_OpenHKCR *r)

562

{

563

ndr_print_struct(ndr, name, "winreg_OpenHKCR");

564

ndr->depth++;

565

if (flags & NDR_SET_VALUES) {

566

ndr->flags |= LIBNDR_PRINT_SET_VALUES;

567

}

568

if (flags & NDR_IN) {

569

ndr_print_struct(ndr, "in", "winreg_OpenHKCR");

570

ndr->depth++;

571

ndr_print_ptr(ndr, "system_name", r->in.system_name);

572

ndr->depth++;

573

if (r->in.system_name) {

574

ndr_print_uint16(ndr, "system_name", *r->in.system_name);

575

}

576

ndr->depth--;

577

ndr_print_winreg_AccessMask(ndr, "access_mask", r->in.access_mask);

578

ndr->depth--;

579

}

580

if (flags & NDR_OUT) {

581

ndr_print_struct(ndr, "out", "winreg_OpenHKCR");

582

ndr->depth++;

583

ndr_print_ptr(ndr, "handle", r->out.handle);

584

ndr->depth++;

585

ndr_print_policy_handle(ndr, "handle", r->out.handle);

586

ndr->depth--;

587

ndr_print_WERROR(ndr, "result", r->out.result);

588

ndr->depth--;

589

}

590

ndr->depth--;

591

}

592

593

static enum ndr_err_code ndr_push_winreg_OpenHKCU(struct ndr_push *ndr, int flags, const struct winreg_OpenHKCU *r)

594

{

595

if (flags & NDR_IN) {

596

NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.system_name));

597

if (r->in.system_name) {

598

NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, *r->in.system_name));

599

}

600

NDR_CHECK(ndr_push_winreg_AccessMask(ndr, NDR_SCALARS, r->in.access_mask));

601

}

602

if (flags & NDR_OUT) {

603

if (r->out.handle == NULL) {

604

return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");

605

}

606

NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.handle));

607

NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));

608

}

609

return NDR_ERR_SUCCESS;

610

}

611

612

static enum ndr_err_code ndr_pull_winreg_OpenHKCU(struct ndr_pull *ndr, int flags, struct winreg_OpenHKCU *r)

613

{

614

uint32_t _ptr_system_name;

615

TALLOC_CTX *_mem_save_system_name_0;

616

TALLOC_CTX *_mem_save_handle_0;

617

if (flags & NDR_IN) {

618

ZERO_STRUCT(r->out);

619

620

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_system_name));

621

if (_ptr_system_name) {

622

NDR_PULL_ALLOC(ndr, r->in.system_name);

623

} else {

624

r->in.system_name = NULL;

625

}

626

if (r->in.system_name) {

627

_mem_save_system_name_0 = NDR_PULL_GET_MEM_CTX(ndr);

628

NDR_PULL_SET_MEM_CTX(ndr, r->in.system_name, 0);

629

NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, r->in.system_name));

630

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_system_name_0, 0);

631

}

632

NDR_CHECK(ndr_pull_winreg_AccessMask(ndr, NDR_SCALARS, &r->in.access_mask));

633

NDR_PULL_ALLOC(ndr, r->out.handle);

634

ZERO_STRUCTP(r->out.handle);

635

}

636

if (flags & NDR_OUT) {

637

if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {

638

NDR_PULL_ALLOC(ndr, r->out.handle);

639

}

640

_mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);

641

NDR_PULL_SET_MEM_CTX(ndr, r->out.handle, LIBNDR_FLAG_REF_ALLOC);

642

NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.handle));

643

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);

644

NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));

645

}

646

return NDR_ERR_SUCCESS;

647

}

648

649

_PUBLIC_ void ndr_print_winreg_OpenHKCU(struct ndr_print *ndr, const char *name, int flags, const struct winreg_OpenHKCU *r)

650

{

651

ndr_print_struct(ndr, name, "winreg_OpenHKCU");

652

ndr->depth++;

653

if (flags & NDR_SET_VALUES) {

654

ndr->flags |= LIBNDR_PRINT_SET_VALUES;

655

}

656

if (flags & NDR_IN) {

657

ndr_print_struct(ndr, "in", "winreg_OpenHKCU");

658

ndr->depth++;

659

ndr_print_ptr(ndr, "system_name", r->in.system_name);

660

ndr->depth++;

661

if (r->in.system_name) {

662

ndr_print_uint16(ndr, "system_name", *r->in.system_name);

663

}

664

ndr->depth--;

665

ndr_print_winreg_AccessMask(ndr, "access_mask", r->in.access_mask);

666

ndr->depth--;

667

}

668

if (flags & NDR_OUT) {

669

ndr_print_struct(ndr, "out", "winreg_OpenHKCU");

670

ndr->depth++;

671

ndr_print_ptr(ndr, "handle", r->out.handle);

672

ndr->depth++;

673

ndr_print_policy_handle(ndr, "handle", r->out.handle);

674

ndr->depth--;

675

ndr_print_WERROR(ndr, "result", r->out.result);

676

ndr->depth--;

677

}

678

ndr->depth--;

679

}

680

681

_PUBLIC_ enum ndr_err_code ndr_push_winreg_OpenHKLM(struct ndr_push *ndr, int flags, const struct winreg_OpenHKLM *r)

682

{

683

if (flags & NDR_IN) {

684

NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.system_name));

685

if (r->in.system_name) {

686

NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, *r->in.system_name));

687

}

688

NDR_CHECK(ndr_push_winreg_AccessMask(ndr, NDR_SCALARS, r->in.access_mask));

689

}

690

if (flags & NDR_OUT) {

691

if (r->out.handle == NULL) {

692

return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");

693

}

694

NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.handle));

695

NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));

696

}

697

return NDR_ERR_SUCCESS;

698

}

699

700

_PUBLIC_ enum ndr_err_code ndr_pull_winreg_OpenHKLM(struct ndr_pull *ndr, int flags, struct winreg_OpenHKLM *r)

701

{

702

uint32_t _ptr_system_name;

703

TALLOC_CTX *_mem_save_system_name_0;

704

TALLOC_CTX *_mem_save_handle_0;

705

if (flags & NDR_IN) {

706

ZERO_STRUCT(r->out);

707

708

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_system_name));

709

if (_ptr_system_name) {

710

NDR_PULL_ALLOC(ndr, r->in.system_name);

711

} else {

712

r->in.system_name = NULL;

713

}

714

if (r->in.system_name) {

715

_mem_save_system_name_0 = NDR_PULL_GET_MEM_CTX(ndr);

716

NDR_PULL_SET_MEM_CTX(ndr, r->in.system_name, 0);

717

NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, r->in.system_name));

718

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_system_name_0, 0);

719

}

720

NDR_CHECK(ndr_pull_winreg_AccessMask(ndr, NDR_SCALARS, &r->in.access_mask));

721

NDR_PULL_ALLOC(ndr, r->out.handle);

722

ZERO_STRUCTP(r->out.handle);

723

}

724

if (flags & NDR_OUT) {

725

if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {

726

NDR_PULL_ALLOC(ndr, r->out.handle);

727

}

728

_mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);

729

NDR_PULL_SET_MEM_CTX(ndr, r->out.handle, LIBNDR_FLAG_REF_ALLOC);

730

NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.handle));

731

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);

732

NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));

733

}

734

return NDR_ERR_SUCCESS;

735

}

736

737

_PUBLIC_ void ndr_print_winreg_OpenHKLM(struct ndr_print *ndr, const char *name, int flags, const struct winreg_OpenHKLM *r)

738

{

739

ndr_print_struct(ndr, name, "winreg_OpenHKLM");

740

ndr->depth++;

741

if (flags & NDR_SET_VALUES) {

742

ndr->flags |= LIBNDR_PRINT_SET_VALUES;

743

}

744

if (flags & NDR_IN) {

745

ndr_print_struct(ndr, "in", "winreg_OpenHKLM");

746

ndr->depth++;

747

ndr_print_ptr(ndr, "system_name", r->in.system_name);

748

ndr->depth++;

749

if (r->in.system_name) {

750

ndr_print_uint16(ndr, "system_name", *r->in.system_name);

751

}

752

ndr->depth--;

753

ndr_print_winreg_AccessMask(ndr, "access_mask", r->in.access_mask);

754

ndr->depth--;

755

}

756

if (flags & NDR_OUT) {

757

ndr_print_struct(ndr, "out", "winreg_OpenHKLM");

758

ndr->depth++;

759

ndr_print_ptr(ndr, "handle", r->out.handle);

760

ndr->depth++;

761

ndr_print_policy_handle(ndr, "handle", r->out.handle);

762

ndr->depth--;

763

ndr_print_WERROR(ndr, "result", r->out.result);

764

ndr->depth--;

765

}

766

ndr->depth--;

767

}

768

769

static enum ndr_err_code ndr_push_winreg_OpenHKPD(struct ndr_push *ndr, int flags, const struct winreg_OpenHKPD *r)

770

{

771

if (flags & NDR_IN) {

772

NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.system_name));

773

if (r->in.system_name) {

774

NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, *r->in.system_name));

775

}

776

NDR_CHECK(ndr_push_winreg_AccessMask(ndr, NDR_SCALARS, r->in.access_mask));

777

}

778

if (flags & NDR_OUT) {

779

if (r->out.handle == NULL) {

780

return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");

781

}

782

NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.handle));

783

NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));

784

}

785

return NDR_ERR_SUCCESS;

786

}

787

788

static enum ndr_err_code ndr_pull_winreg_OpenHKPD(struct ndr_pull *ndr, int flags, struct winreg_OpenHKPD *r)

789

{

790

uint32_t _ptr_system_name;

791

TALLOC_CTX *_mem_save_system_name_0;

792

TALLOC_CTX *_mem_save_handle_0;

793

if (flags & NDR_IN) {

794

ZERO_STRUCT(r->out);

795

796

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_system_name));

797

if (_ptr_system_name) {

798

NDR_PULL_ALLOC(ndr, r->in.system_name);

799

} else {

800

r->in.system_name = NULL;

801

}

802

if (r->in.system_name) {

803

_mem_save_system_name_0 = NDR_PULL_GET_MEM_CTX(ndr);

804

NDR_PULL_SET_MEM_CTX(ndr, r->in.system_name, 0);

805

NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, r->in.system_name));

806

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_system_name_0, 0);

807

}

808

NDR_CHECK(ndr_pull_winreg_AccessMask(ndr, NDR_SCALARS, &r->in.access_mask));

809

NDR_PULL_ALLOC(ndr, r->out.handle);

810

ZERO_STRUCTP(r->out.handle);

811

}

812

if (flags & NDR_OUT) {

813

if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {

814

NDR_PULL_ALLOC(ndr, r->out.handle);

815

}

816

_mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);

817

NDR_PULL_SET_MEM_CTX(ndr, r->out.handle, LIBNDR_FLAG_REF_ALLOC);

818

NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.handle));

819

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);

820

NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));

821

}

822

return NDR_ERR_SUCCESS;

823

}

824

825

_PUBLIC_ void ndr_print_winreg_OpenHKPD(struct ndr_print *ndr, const char *name, int flags, const struct winreg_OpenHKPD *r)

826

{

827

ndr_print_struct(ndr, name, "winreg_OpenHKPD");

828

ndr->depth++;

829

if (flags & NDR_SET_VALUES) {

830

ndr->flags |= LIBNDR_PRINT_SET_VALUES;

831

}

832

if (flags & NDR_IN) {

833

ndr_print_struct(ndr, "in", "winreg_OpenHKPD");

834

ndr->depth++;

835

ndr_print_ptr(ndr, "system_name", r->in.system_name);

836

ndr->depth++;

837

if (r->in.system_name) {

838

ndr_print_uint16(ndr, "system_name", *r->in.system_name);

839

}

840

ndr->depth--;

841

ndr_print_winreg_AccessMask(ndr, "access_mask", r->in.access_mask);

842

ndr->depth--;

843

}

844

if (flags & NDR_OUT) {

845

ndr_print_struct(ndr, "out", "winreg_OpenHKPD");

846

ndr->depth++;

847

ndr_print_ptr(ndr, "handle", r->out.handle);

848

ndr->depth++;

849

ndr_print_policy_handle(ndr, "handle", r->out.handle);

850

ndr->depth--;

851

ndr_print_WERROR(ndr, "result", r->out.result);

852

ndr->depth--;

853

}

854

ndr->depth--;

855

}

856

857

static enum ndr_err_code ndr_push_winreg_OpenHKU(struct ndr_push *ndr, int flags, const struct winreg_OpenHKU *r)

858

{

859

if (flags & NDR_IN) {

860

NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.system_name));

861

if (r->in.system_name) {

862

NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, *r->in.system_name));

863

}

864

NDR_CHECK(ndr_push_winreg_AccessMask(ndr, NDR_SCALARS, r->in.access_mask));

865

}

866

if (flags & NDR_OUT) {

867

if (r->out.handle == NULL) {

868

return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");

869

}

870

NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.handle));

871

NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));

872

}

873

return NDR_ERR_SUCCESS;

874

}

875

876

static enum ndr_err_code ndr_pull_winreg_OpenHKU(struct ndr_pull *ndr, int flags, struct winreg_OpenHKU *r)

877

{

878

uint32_t _ptr_system_name;

879

TALLOC_CTX *_mem_save_system_name_0;

880

TALLOC_CTX *_mem_save_handle_0;

881

if (flags & NDR_IN) {

882

ZERO_STRUCT(r->out);

883

884

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_system_name));

885

if (_ptr_system_name) {

886

NDR_PULL_ALLOC(ndr, r->in.system_name);

887

} else {

888

r->in.system_name = NULL;

889

}

890

if (r->in.system_name) {

891

_mem_save_system_name_0 = NDR_PULL_GET_MEM_CTX(ndr);

892

NDR_PULL_SET_MEM_CTX(ndr, r->in.system_name, 0);

893

NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, r->in.system_name));

894

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_system_name_0, 0);

895

}

896

NDR_CHECK(ndr_pull_winreg_AccessMask(ndr, NDR_SCALARS, &r->in.access_mask));

897

NDR_PULL_ALLOC(ndr, r->out.handle);

898

ZERO_STRUCTP(r->out.handle);

899

}

900

if (flags & NDR_OUT) {

901

if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {

902

NDR_PULL_ALLOC(ndr, r->out.handle);

903

}

904

_mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);

905

NDR_PULL_SET_MEM_CTX(ndr, r->out.handle, LIBNDR_FLAG_REF_ALLOC);

906

NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.handle));

907

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);

908

NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));

909

}

910

return NDR_ERR_SUCCESS;

911

}

912

913

_PUBLIC_ void ndr_print_winreg_OpenHKU(struct ndr_print *ndr, const char *name, int flags, const struct winreg_OpenHKU *r)

914

{

915

ndr_print_struct(ndr, name, "winreg_OpenHKU");

916

ndr->depth++;

917

if (flags & NDR_SET_VALUES) {

918

ndr->flags |= LIBNDR_PRINT_SET_VALUES;

919

}

920

if (flags & NDR_IN) {

921

ndr_print_struct(ndr, "in", "winreg_OpenHKU");

922

ndr->depth++;

923

ndr_print_ptr(ndr, "system_name", r->in.system_name);

924

ndr->depth++;

925

if (r->in.system_name) {

926

ndr_print_uint16(ndr, "system_name", *r->in.system_name);

927

}

928

ndr->depth--;

929

ndr_print_winreg_AccessMask(ndr, "access_mask", r->in.access_mask);

930

ndr->depth--;

931

}

932

if (flags & NDR_OUT) {

933

ndr_print_struct(ndr, "out", "winreg_OpenHKU");

934

ndr->depth++;

935

ndr_print_ptr(ndr, "handle", r->out.handle);

936

ndr->depth++;

937

ndr_print_policy_handle(ndr, "handle", r->out.handle);

938

ndr->depth--;

939

ndr_print_WERROR(ndr, "result", r->out.result);

940

ndr->depth--;

941

}

942

ndr->depth--;

943

}

944

945

_PUBLIC_ enum ndr_err_code ndr_push_winreg_CloseKey(struct ndr_push *ndr, int flags, const struct winreg_CloseKey *r)

946

{

947

if (flags & NDR_IN) {

948

if (r->in.handle == NULL) {

949

return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");

950

}

951

NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));

952

}

953

if (flags & NDR_OUT) {

954

if (r->out.handle == NULL) {

955

return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");

956

}

957

NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.handle));

958

NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));

959

}

960

return NDR_ERR_SUCCESS;

961

}

962

963

_PUBLIC_ enum ndr_err_code ndr_pull_winreg_CloseKey(struct ndr_pull *ndr, int flags, struct winreg_CloseKey *r)

964

{

965

TALLOC_CTX *_mem_save_handle_0;

966

if (flags & NDR_IN) {

967

ZERO_STRUCT(r->out);

968

969

if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {

970

NDR_PULL_ALLOC(ndr, r->in.handle);

971

}

972

_mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);

973

NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);

974

NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));

975

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);

976

NDR_PULL_ALLOC(ndr, r->out.handle);

977

*r->out.handle = *r->in.handle;

978

}

979

if (flags & NDR_OUT) {

980

if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {

981

NDR_PULL_ALLOC(ndr, r->out.handle);

982

}

983

_mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);

984

NDR_PULL_SET_MEM_CTX(ndr, r->out.handle, LIBNDR_FLAG_REF_ALLOC);

985

NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.handle));

986

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);

987

NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));

988

}

989

return NDR_ERR_SUCCESS;

990

}

991

992

_PUBLIC_ void ndr_print_winreg_CloseKey(struct ndr_print *ndr, const char *name, int flags, const struct winreg_CloseKey *r)

993

{

994

ndr_print_struct(ndr, name, "winreg_CloseKey");

995

ndr->depth++;

996

if (flags & NDR_SET_VALUES) {

997

ndr->flags |= LIBNDR_PRINT_SET_VALUES;

998

}

999

if (flags & NDR_IN) {

1000

ndr_print_struct(ndr, "in", "winreg_CloseKey");

1001

ndr->depth++;

1002

ndr_print_ptr(ndr, "handle", r->in.handle);

1003

ndr->depth++;

1004

ndr_print_policy_handle(ndr, "handle", r->in.handle);

1005

ndr->depth--;

1006

ndr->depth--;

1007

}

1008

if (flags & NDR_OUT) {

1009

ndr_print_struct(ndr, "out", "winreg_CloseKey");

1010

ndr->depth++;

1011

ndr_print_ptr(ndr, "handle", r->out.handle);

1012

ndr->depth++;

1013

ndr_print_policy_handle(ndr, "handle", r->out.handle);

1014

ndr->depth--;

1015

ndr_print_WERROR(ndr, "result", r->out.result);

1016

ndr->depth--;

1017

}

1018

ndr->depth--;

1019

}

1020

1021

_PUBLIC_ enum ndr_err_code ndr_push_winreg_CreateKey(struct ndr_push *ndr, int flags, const struct winreg_CreateKey *r)

1022

{

1023

if (flags & NDR_IN) {

1024

if (r->in.handle == NULL) {

1025

return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");

1026

}

1027

NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));

1028

NDR_CHECK(ndr_push_winreg_String(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.name));

1029

NDR_CHECK(ndr_push_winreg_String(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.keyclass));

1030

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.options));

1031

NDR_CHECK(ndr_push_winreg_AccessMask(ndr, NDR_SCALARS, r->in.access_mask));

1032

NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.secdesc));

1033

if (r->in.secdesc) {

1034

NDR_CHECK(ndr_push_winreg_SecBuf(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.secdesc));

1035

}

1036

NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.action_taken));

1037

if (r->in.action_taken) {

1038

NDR_CHECK(ndr_push_winreg_CreateAction(ndr, NDR_SCALARS, *r->in.action_taken));

1039

}

1040

}

1041

if (flags & NDR_OUT) {

1042

if (r->out.new_handle == NULL) {

1043

return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");

1044

}

1045

NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.new_handle));

1046

NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.action_taken));

1047

if (r->out.action_taken) {

1048

NDR_CHECK(ndr_push_winreg_CreateAction(ndr, NDR_SCALARS, *r->out.action_taken));

1049

}

1050

NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));

1051

}

1052

return NDR_ERR_SUCCESS;

1053

}

1054

1055

_PUBLIC_ enum ndr_err_code ndr_pull_winreg_CreateKey(struct ndr_pull *ndr, int flags, struct winreg_CreateKey *r)

1056

{

1057

uint32_t _ptr_secdesc;

1058

uint32_t _ptr_action_taken;

1059

TALLOC_CTX *_mem_save_handle_0;

1060

TALLOC_CTX *_mem_save_secdesc_0;

1061

TALLOC_CTX *_mem_save_new_handle_0;

1062

TALLOC_CTX *_mem_save_action_taken_0;

1063

if (flags & NDR_IN) {

1064

ZERO_STRUCT(r->out);

1065

1066

if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {

1067

NDR_PULL_ALLOC(ndr, r->in.handle);

1068

}

1069

_mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);

1070

NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);

1071

NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));

1072

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);

1073

NDR_CHECK(ndr_pull_winreg_String(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.name));

1074

NDR_CHECK(ndr_pull_winreg_String(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.keyclass));

1075

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.options));

1076

NDR_CHECK(ndr_pull_winreg_AccessMask(ndr, NDR_SCALARS, &r->in.access_mask));

1077

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_secdesc));

1078

if (_ptr_secdesc) {

1079

NDR_PULL_ALLOC(ndr, r->in.secdesc);

1080

} else {

1081

r->in.secdesc = NULL;

1082

}

1083

if (r->in.secdesc) {

1084

_mem_save_secdesc_0 = NDR_PULL_GET_MEM_CTX(ndr);

1085

NDR_PULL_SET_MEM_CTX(ndr, r->in.secdesc, 0);

1086

NDR_CHECK(ndr_pull_winreg_SecBuf(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.secdesc));

1087

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_secdesc_0, 0);

1088

}

1089

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_action_taken));

1090

if (_ptr_action_taken) {

1091

NDR_PULL_ALLOC(ndr, r->in.action_taken);

1092

} else {

1093

r->in.action_taken = NULL;

1094

}

1095

if (r->in.action_taken) {

1096

_mem_save_action_taken_0 = NDR_PULL_GET_MEM_CTX(ndr);

1097

NDR_PULL_SET_MEM_CTX(ndr, r->in.action_taken, 0);

1098

NDR_CHECK(ndr_pull_winreg_CreateAction(ndr, NDR_SCALARS, r->in.action_taken));

1099

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_action_taken_0, 0);

1100

}

1101

NDR_PULL_ALLOC(ndr, r->out.new_handle);

1102

ZERO_STRUCTP(r->out.new_handle);

1103

}

1104

if (flags & NDR_OUT) {

1105

if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {

1106

NDR_PULL_ALLOC(ndr, r->out.new_handle);

1107

}

1108

_mem_save_new_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);

1109

NDR_PULL_SET_MEM_CTX(ndr, r->out.new_handle, LIBNDR_FLAG_REF_ALLOC);

1110

NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.new_handle));

1111

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_new_handle_0, LIBNDR_FLAG_REF_ALLOC);

1112

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_action_taken));

1113

if (_ptr_action_taken) {

1114

NDR_PULL_ALLOC(ndr, r->out.action_taken);

1115

} else {

1116

r->out.action_taken = NULL;

1117

}

1118

if (r->out.action_taken) {

1119

_mem_save_action_taken_0 = NDR_PULL_GET_MEM_CTX(ndr);

1120

NDR_PULL_SET_MEM_CTX(ndr, r->out.action_taken, 0);

1121

NDR_CHECK(ndr_pull_winreg_CreateAction(ndr, NDR_SCALARS, r->out.action_taken));

1122

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_action_taken_0, 0);

1123

}

1124

NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));

1125

}

1126

return NDR_ERR_SUCCESS;

1127

}

1128

1129

_PUBLIC_ void ndr_print_winreg_CreateKey(struct ndr_print *ndr, const char *name, int flags, const struct winreg_CreateKey *r)

1130

{

1131

ndr_print_struct(ndr, name, "winreg_CreateKey");

1132

ndr->depth++;

1133

if (flags & NDR_SET_VALUES) {

1134

ndr->flags |= LIBNDR_PRINT_SET_VALUES;

1135

}

1136

if (flags & NDR_IN) {

1137

ndr_print_struct(ndr, "in", "winreg_CreateKey");

1138

ndr->depth++;

1139

ndr_print_ptr(ndr, "handle", r->in.handle);

1140

ndr->depth++;

1141

ndr_print_policy_handle(ndr, "handle", r->in.handle);

1142

ndr->depth--;

1143

ndr_print_winreg_String(ndr, "name", &r->in.name);

1144

ndr_print_winreg_String(ndr, "keyclass", &r->in.keyclass);

1145

ndr_print_uint32(ndr, "options", r->in.options);

1146

ndr_print_winreg_AccessMask(ndr, "access_mask", r->in.access_mask);

1147

ndr_print_ptr(ndr, "secdesc", r->in.secdesc);

1148

ndr->depth++;

1149

if (r->in.secdesc) {

1150

ndr_print_winreg_SecBuf(ndr, "secdesc", r->in.secdesc);

1151

}

1152

ndr->depth--;

1153

ndr_print_ptr(ndr, "action_taken", r->in.action_taken);

1154

ndr->depth++;

1155

if (r->in.action_taken) {

1156

ndr_print_winreg_CreateAction(ndr, "action_taken", *r->in.action_taken);

1157

}

1158

ndr->depth--;

1159

ndr->depth--;

1160

}

1161

if (flags & NDR_OUT) {

1162

ndr_print_struct(ndr, "out", "winreg_CreateKey");

1163

ndr->depth++;

1164

ndr_print_ptr(ndr, "new_handle", r->out.new_handle);

1165

ndr->depth++;

1166

ndr_print_policy_handle(ndr, "new_handle", r->out.new_handle);

1167

ndr->depth--;

1168

ndr_print_ptr(ndr, "action_taken", r->out.action_taken);

1169

ndr->depth++;

1170

if (r->out.action_taken) {

1171

ndr_print_winreg_CreateAction(ndr, "action_taken", *r->out.action_taken);

1172

}

1173

ndr->depth--;

1174

ndr_print_WERROR(ndr, "result", r->out.result);

1175

ndr->depth--;

1176

}

1177

ndr->depth--;

1178

}

1179

1180

_PUBLIC_ enum ndr_err_code ndr_push_winreg_DeleteKey(struct ndr_push *ndr, int flags, const struct winreg_DeleteKey *r)

1181

{

1182

if (flags & NDR_IN) {

1183

if (r->in.handle == NULL) {

1184

return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");

1185

}

1186

NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));

1187

NDR_CHECK(ndr_push_winreg_String(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.key));

1188

}

1189

if (flags & NDR_OUT) {

1190

NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));

1191

}

1192

return NDR_ERR_SUCCESS;

1193

}

1194

1195

_PUBLIC_ enum ndr_err_code ndr_pull_winreg_DeleteKey(struct ndr_pull *ndr, int flags, struct winreg_DeleteKey *r)

1196

{

1197

TALLOC_CTX *_mem_save_handle_0;

1198

if (flags & NDR_IN) {

1199

if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {

1200

NDR_PULL_ALLOC(ndr, r->in.handle);

1201

}

1202

_mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);

1203

NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);

1204

NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));

1205

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);

1206

NDR_CHECK(ndr_pull_winreg_String(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.key));

1207

}

1208

if (flags & NDR_OUT) {

1209

NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));

1210

}

1211

return NDR_ERR_SUCCESS;

1212

}

1213

1214

_PUBLIC_ void ndr_print_winreg_DeleteKey(struct ndr_print *ndr, const char *name, int flags, const struct winreg_DeleteKey *r)

1215

{

1216

ndr_print_struct(ndr, name, "winreg_DeleteKey");

1217

ndr->depth++;

1218

if (flags & NDR_SET_VALUES) {

1219

ndr->flags |= LIBNDR_PRINT_SET_VALUES;

1220

}

1221

if (flags & NDR_IN) {

1222

ndr_print_struct(ndr, "in", "winreg_DeleteKey");

1223

ndr->depth++;

1224

ndr_print_ptr(ndr, "handle", r->in.handle);

1225

ndr->depth++;

1226

ndr_print_policy_handle(ndr, "handle", r->in.handle);

1227

ndr->depth--;

1228

ndr_print_winreg_String(ndr, "key", &r->in.key);

1229

ndr->depth--;

1230

}

1231

if (flags & NDR_OUT) {

1232

ndr_print_struct(ndr, "out", "winreg_DeleteKey");

1233

ndr->depth++;

1234

ndr_print_WERROR(ndr, "result", r->out.result);

1235

ndr->depth--;

1236

}

1237

ndr->depth--;

1238

}

1239

1240

static enum ndr_err_code ndr_push_winreg_DeleteValue(struct ndr_push *ndr, int flags, const struct winreg_DeleteValue *r)

1241

{

1242

if (flags & NDR_IN) {

1243

if (r->in.handle == NULL) {

1244

return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");

1245

}

1246

NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));

1247

NDR_CHECK(ndr_push_winreg_String(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.value));

1248

}

1249

if (flags & NDR_OUT) {

1250

NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));

1251

}

1252

return NDR_ERR_SUCCESS;

1253

}

1254

1255

static enum ndr_err_code ndr_pull_winreg_DeleteValue(struct ndr_pull *ndr, int flags, struct winreg_DeleteValue *r)

1256

{

1257

TALLOC_CTX *_mem_save_handle_0;

1258

if (flags & NDR_IN) {

1259

if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {

1260

NDR_PULL_ALLOC(ndr, r->in.handle);

1261

}

1262

_mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);

1263

NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);

1264

NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));

1265

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);

1266

NDR_CHECK(ndr_pull_winreg_String(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.value));

1267

}

1268

if (flags & NDR_OUT) {

1269

NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));

1270

}

1271

return NDR_ERR_SUCCESS;

1272

}

1273

1274

_PUBLIC_ void ndr_print_winreg_DeleteValue(struct ndr_print *ndr, const char *name, int flags, const struct winreg_DeleteValue *r)

1275

{

1276

ndr_print_struct(ndr, name, "winreg_DeleteValue");

1277

ndr->depth++;

1278

if (flags & NDR_SET_VALUES) {

1279

ndr->flags |= LIBNDR_PRINT_SET_VALUES;

1280

}

1281

if (flags & NDR_IN) {

1282

ndr_print_struct(ndr, "in", "winreg_DeleteValue");

1283

ndr->depth++;

1284

ndr_print_ptr(ndr, "handle", r->in.handle);

1285

ndr->depth++;

1286

ndr_print_policy_handle(ndr, "handle", r->in.handle);

1287

ndr->depth--;

1288

ndr_print_winreg_String(ndr, "value", &r->in.value);

1289

ndr->depth--;

1290

}

1291

if (flags & NDR_OUT) {

1292

ndr_print_struct(ndr, "out", "winreg_DeleteValue");

1293

ndr->depth++;

1294

ndr_print_WERROR(ndr, "result", r->out.result);

1295

ndr->depth--;

1296

}

1297

ndr->depth--;

1298

}

1299

1300

_PUBLIC_ enum ndr_err_code ndr_push_winreg_EnumKey(struct ndr_push *ndr, int flags, const struct winreg_EnumKey *r)

1301

{

1302

if (flags & NDR_IN) {

1303

if (r->in.handle == NULL) {

1304

return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");

1305

}

1306

NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));

1307

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.enum_index));

1308

if (r->in.name == NULL) {

1309

return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");

1310

}

1311

NDR_CHECK(ndr_push_winreg_StringBuf(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.name));

1312

NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.keyclass));

1313

if (r->in.keyclass) {

1314

NDR_CHECK(ndr_push_winreg_StringBuf(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.keyclass));

1315

}

1316

NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.last_changed_time));

1317

if (r->in.last_changed_time) {

1318

NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, *r->in.last_changed_time));

1319

}

1320

}

1321

if (flags & NDR_OUT) {

1322

if (r->out.name == NULL) {

1323

return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");

1324

}

1325

NDR_CHECK(ndr_push_winreg_StringBuf(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.name));

1326

NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.keyclass));

1327

if (r->out.keyclass) {

1328

NDR_CHECK(ndr_push_winreg_StringBuf(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.keyclass));

1329

}

1330

NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.last_changed_time));

1331

if (r->out.last_changed_time) {

1332

NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, *r->out.last_changed_time));

1333

}

1334

NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));

1335

}

1336

return NDR_ERR_SUCCESS;

1337

}

1338

1339

_PUBLIC_ enum ndr_err_code ndr_pull_winreg_EnumKey(struct ndr_pull *ndr, int flags, struct winreg_EnumKey *r)

1340

{

1341

uint32_t _ptr_keyclass;

1342

uint32_t _ptr_last_changed_time;

1343

TALLOC_CTX *_mem_save_handle_0;

1344

TALLOC_CTX *_mem_save_name_0;

1345

TALLOC_CTX *_mem_save_keyclass_0;

1346

TALLOC_CTX *_mem_save_last_changed_time_0;

1347

if (flags & NDR_IN) {

1348

ZERO_STRUCT(r->out);

1349

1350

if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {

1351

NDR_PULL_ALLOC(ndr, r->in.handle);

1352

}

1353

_mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);

1354

NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);

1355

NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));

1356

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);

1357

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.enum_index));

1358

if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {

1359

NDR_PULL_ALLOC(ndr, r->in.name);

1360

}

1361

_mem_save_name_0 = NDR_PULL_GET_MEM_CTX(ndr);

1362

NDR_PULL_SET_MEM_CTX(ndr, r->in.name, LIBNDR_FLAG_REF_ALLOC);

1363

NDR_CHECK(ndr_pull_winreg_StringBuf(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.name));

1364

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_name_0, LIBNDR_FLAG_REF_ALLOC);

1365

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_keyclass));

1366

if (_ptr_keyclass) {

1367

NDR_PULL_ALLOC(ndr, r->in.keyclass);

1368

} else {

1369

r->in.keyclass = NULL;

1370

}

1371

if (r->in.keyclass) {

1372

_mem_save_keyclass_0 = NDR_PULL_GET_MEM_CTX(ndr);

1373

NDR_PULL_SET_MEM_CTX(ndr, r->in.keyclass, 0);

1374

NDR_CHECK(ndr_pull_winreg_StringBuf(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.keyclass));

1375

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_keyclass_0, 0);

1376

}

1377

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_last_changed_time));

1378

if (_ptr_last_changed_time) {

1379

NDR_PULL_ALLOC(ndr, r->in.last_changed_time);

1380

} else {

1381

r->in.last_changed_time = NULL;

1382

}

1383

if (r->in.last_changed_time) {

1384

_mem_save_last_changed_time_0 = NDR_PULL_GET_MEM_CTX(ndr);

1385

NDR_PULL_SET_MEM_CTX(ndr, r->in.last_changed_time, 0);

1386

NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, r->in.last_changed_time));

1387

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_last_changed_time_0, 0);

1388

}

1389

NDR_PULL_ALLOC(ndr, r->out.name);

1390

*r->out.name = *r->in.name;

1391

}

1392

if (flags & NDR_OUT) {

1393

if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {

1394

NDR_PULL_ALLOC(ndr, r->out.name);

1395

}

1396

_mem_save_name_0 = NDR_PULL_GET_MEM_CTX(ndr);

1397

NDR_PULL_SET_MEM_CTX(ndr, r->out.name, LIBNDR_FLAG_REF_ALLOC);

1398

NDR_CHECK(ndr_pull_winreg_StringBuf(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.name));

1399

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_name_0, LIBNDR_FLAG_REF_ALLOC);

1400

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_keyclass));

1401

if (_ptr_keyclass) {

1402

NDR_PULL_ALLOC(ndr, r->out.keyclass);

1403

} else {

1404

r->out.keyclass = NULL;

1405

}

1406

if (r->out.keyclass) {

1407

_mem_save_keyclass_0 = NDR_PULL_GET_MEM_CTX(ndr);

1408

NDR_PULL_SET_MEM_CTX(ndr, r->out.keyclass, 0);

1409

NDR_CHECK(ndr_pull_winreg_StringBuf(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.keyclass));

1410

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_keyclass_0, 0);

1411

}

1412

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_last_changed_time));

1413

if (_ptr_last_changed_time) {

1414

NDR_PULL_ALLOC(ndr, r->out.last_changed_time);

1415

} else {

1416

r->out.last_changed_time = NULL;

1417

}

1418

if (r->out.last_changed_time) {

1419

_mem_save_last_changed_time_0 = NDR_PULL_GET_MEM_CTX(ndr);

1420

NDR_PULL_SET_MEM_CTX(ndr, r->out.last_changed_time, 0);

1421

NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, r->out.last_changed_time));

1422

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_last_changed_time_0, 0);

1423

}

1424

NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));

1425

}

1426

return NDR_ERR_SUCCESS;

1427

}

1428

1429

_PUBLIC_ void ndr_print_winreg_EnumKey(struct ndr_print *ndr, const char *name, int flags, const struct winreg_EnumKey *r)

1430

{

1431

ndr_print_struct(ndr, name, "winreg_EnumKey");

1432

ndr->depth++;

1433

if (flags & NDR_SET_VALUES) {

1434

ndr->flags |= LIBNDR_PRINT_SET_VALUES;

1435

}

1436

if (flags & NDR_IN) {

1437

ndr_print_struct(ndr, "in", "winreg_EnumKey");

1438

ndr->depth++;

1439

ndr_print_ptr(ndr, "handle", r->in.handle);

1440

ndr->depth++;

1441

ndr_print_policy_handle(ndr, "handle", r->in.handle);

1442

ndr->depth--;

1443

ndr_print_uint32(ndr, "enum_index", r->in.enum_index);

1444

ndr_print_ptr(ndr, "name", r->in.name);

1445

ndr->depth++;

1446

ndr_print_winreg_StringBuf(ndr, "name", r->in.name);

1447

ndr->depth--;

1448

ndr_print_ptr(ndr, "keyclass", r->in.keyclass);

1449

ndr->depth++;

1450

if (r->in.keyclass) {

1451

ndr_print_winreg_StringBuf(ndr, "keyclass", r->in.keyclass);

1452

}

1453

ndr->depth--;

1454

ndr_print_ptr(ndr, "last_changed_time", r->in.last_changed_time);

1455

ndr->depth++;

1456

if (r->in.last_changed_time) {

1457

ndr_print_NTTIME(ndr, "last_changed_time", *r->in.last_changed_time);

1458

}

1459

ndr->depth--;

1460

ndr->depth--;

1461

}

1462

if (flags & NDR_OUT) {

1463

ndr_print_struct(ndr, "out", "winreg_EnumKey");

1464

ndr->depth++;

1465

ndr_print_ptr(ndr, "name", r->out.name);

1466

ndr->depth++;

1467

ndr_print_winreg_StringBuf(ndr, "name", r->out.name);

1468

ndr->depth--;

1469

ndr_print_ptr(ndr, "keyclass", r->out.keyclass);

1470

ndr->depth++;

1471

if (r->out.keyclass) {

1472

ndr_print_winreg_StringBuf(ndr, "keyclass", r->out.keyclass);

1473

}

1474

ndr->depth--;

1475

ndr_print_ptr(ndr, "last_changed_time", r->out.last_changed_time);

1476

ndr->depth++;

1477

if (r->out.last_changed_time) {

1478

ndr_print_NTTIME(ndr, "last_changed_time", *r->out.last_changed_time);

1479

}

1480

ndr->depth--;

1481

ndr_print_WERROR(ndr, "result", r->out.result);

1482

ndr->depth--;

1483

}

1484

ndr->depth--;

1485

}

1486

1487

_PUBLIC_ enum ndr_err_code ndr_push_winreg_EnumValue(struct ndr_push *ndr, int flags, const struct winreg_EnumValue *r)

1488

{

1489

if (flags & NDR_IN) {

1490

if (r->in.handle == NULL) {

1491

return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");

1492

}

1493

NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));

1494

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.enum_index));

1495

if (r->in.name == NULL) {

1496

return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");

1497

}

1498

NDR_CHECK(ndr_push_winreg_ValNameBuf(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.name));

1499

NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.type));

1500

if (r->in.type) {

1501

NDR_CHECK(ndr_push_winreg_Type(ndr, NDR_SCALARS, *r->in.type));

1502

}

1503

NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.value));

1504

if (r->in.value) {

1505

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->in.size));

1506

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

1507

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->in.length));

1508

NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->in.value, *r->in.length));

1509

}

1510

NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.size));

1511

if (r->in.size) {

1512

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->in.size));

1513

}

1514

NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.length));

1515

if (r->in.length) {

1516

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->in.length));

1517

}

1518

}

1519

if (flags & NDR_OUT) {

1520

if (r->out.name == NULL) {

1521

return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");

1522

}

1523

NDR_CHECK(ndr_push_winreg_ValNameBuf(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.name));

1524

NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.type));

1525

if (r->out.type) {

1526

NDR_CHECK(ndr_push_winreg_Type(ndr, NDR_SCALARS, *r->out.type));

1527

}

1528

NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.value));

1529

if (r->out.value) {

1530

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.size));

1531

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

1532

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.length));

1533

NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->out.value, *r->out.length));

1534

}

1535

NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.size));

1536

if (r->out.size) {

1537

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.size));

1538

}

1539

NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.length));

1540

if (r->out.length) {

1541

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.length));

1542

}

1543

NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));

1544

}

1545

return NDR_ERR_SUCCESS;

1546

}

1547

1548

_PUBLIC_ enum ndr_err_code ndr_pull_winreg_EnumValue(struct ndr_pull *ndr, int flags, struct winreg_EnumValue *r)

1549

{

1550

uint32_t _ptr_type;

1551

uint32_t _ptr_value;

1552

uint32_t _ptr_size;

1553

uint32_t _ptr_length;

1554

TALLOC_CTX *_mem_save_handle_0;

1555

TALLOC_CTX *_mem_save_name_0;

1556

TALLOC_CTX *_mem_save_type_0;

1557

TALLOC_CTX *_mem_save_value_0;

1558

TALLOC_CTX *_mem_save_size_0;

1559

TALLOC_CTX *_mem_save_length_0;

1560

if (flags & NDR_IN) {

1561

ZERO_STRUCT(r->out);

1562

1563

if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {

1564

NDR_PULL_ALLOC(ndr, r->in.handle);

1565

}

1566

_mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);

1567

NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);

1568

NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));

1569

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);

1570

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.enum_index));

1571

if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {

1572

NDR_PULL_ALLOC(ndr, r->in.name);

1573

}

1574

_mem_save_name_0 = NDR_PULL_GET_MEM_CTX(ndr);

1575

NDR_PULL_SET_MEM_CTX(ndr, r->in.name, LIBNDR_FLAG_REF_ALLOC);

1576

NDR_CHECK(ndr_pull_winreg_ValNameBuf(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.name));

1577

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_name_0, LIBNDR_FLAG_REF_ALLOC);

1578

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_type));

1579

if (_ptr_type) {

1580

NDR_PULL_ALLOC(ndr, r->in.type);

1581

} else {

1582

r->in.type = NULL;

1583

}

1584

if (r->in.type) {

1585

_mem_save_type_0 = NDR_PULL_GET_MEM_CTX(ndr);

1586

NDR_PULL_SET_MEM_CTX(ndr, r->in.type, 0);

1587

NDR_CHECK(ndr_pull_winreg_Type(ndr, NDR_SCALARS, r->in.type));

1588

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_type_0, 0);

1589

}

1590

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_value));

1591

if (_ptr_value) {

1592

NDR_PULL_ALLOC(ndr, r->in.value);

1593

} else {

1594

r->in.value = NULL;

1595

}

1596

if (r->in.value) {

1597

_mem_save_value_0 = NDR_PULL_GET_MEM_CTX(ndr);

1598

NDR_PULL_SET_MEM_CTX(ndr, r->in.value, 0);

1599

NDR_CHECK(ndr_pull_array_size(ndr, &r->in.value));

1600

NDR_CHECK(ndr_pull_array_length(ndr, &r->in.value));

1601

if (ndr_get_array_length(ndr, &r->in.value) > ndr_get_array_size(ndr, &r->in.value)) {

1602

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.value), ndr_get_array_length(ndr, &r->in.value));

1603

}

1604

NDR_PULL_ALLOC_N(ndr, r->in.value, ndr_get_array_size(ndr, &r->in.value));

1605

NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->in.value, ndr_get_array_length(ndr, &r->in.value)));

1606

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_value_0, 0);

1607

}

1608

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_size));

1609

if (_ptr_size) {

1610

NDR_PULL_ALLOC(ndr, r->in.size);

1611

} else {

1612

r->in.size = NULL;

1613

}

1614

if (r->in.size) {

1615

_mem_save_size_0 = NDR_PULL_GET_MEM_CTX(ndr);

1616

NDR_PULL_SET_MEM_CTX(ndr, r->in.size, 0);

1617

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->in.size));

1618

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_size_0, 0);

1619

}

1620

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_length));

1621

if (_ptr_length) {

1622

NDR_PULL_ALLOC(ndr, r->in.length);

1623

} else {

1624

r->in.length = NULL;

1625

}

1626

if (r->in.length) {

1627

_mem_save_length_0 = NDR_PULL_GET_MEM_CTX(ndr);

1628

NDR_PULL_SET_MEM_CTX(ndr, r->in.length, 0);

1629

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->in.length));

1630

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_length_0, 0);

1631

}

1632

NDR_PULL_ALLOC(ndr, r->out.name);

1633

*r->out.name = *r->in.name;

1634

if (r->in.value) {

1635

if (r->in.size == NULL) return ndr_pull_error(ndr, NDR_ERR_INVALID_POINTER, "NULL Pointer for size_is()");

1636

NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->in.value, *r->in.size));

1637

}

1638

if (r->in.value) {

1639

if (r->in.length == NULL) return ndr_pull_error(ndr, NDR_ERR_INVALID_POINTER, "NULL Pointer for length_is()");

1640

NDR_CHECK(ndr_check_array_length(ndr, (void*)&r->in.value, *r->in.length));

1641

}

1642

}

1643

if (flags & NDR_OUT) {

1644

if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {

1645

NDR_PULL_ALLOC(ndr, r->out.name);

1646

}

1647

_mem_save_name_0 = NDR_PULL_GET_MEM_CTX(ndr);

1648

NDR_PULL_SET_MEM_CTX(ndr, r->out.name, LIBNDR_FLAG_REF_ALLOC);

1649

NDR_CHECK(ndr_pull_winreg_ValNameBuf(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.name));

1650

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_name_0, LIBNDR_FLAG_REF_ALLOC);

1651

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_type));

1652

if (_ptr_type) {

1653

NDR_PULL_ALLOC(ndr, r->out.type);

1654

} else {

1655

r->out.type = NULL;

1656

}

1657

if (r->out.type) {

1658

_mem_save_type_0 = NDR_PULL_GET_MEM_CTX(ndr);

1659

NDR_PULL_SET_MEM_CTX(ndr, r->out.type, 0);

1660

NDR_CHECK(ndr_pull_winreg_Type(ndr, NDR_SCALARS, r->out.type));

1661

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_type_0, 0);

1662

}

1663

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_value));

1664

if (_ptr_value) {

1665

NDR_PULL_ALLOC(ndr, r->out.value);

1666

} else {

1667

r->out.value = NULL;

1668

}

1669

if (r->out.value) {

1670

_mem_save_value_0 = NDR_PULL_GET_MEM_CTX(ndr);

1671

NDR_PULL_SET_MEM_CTX(ndr, r->out.value, 0);

1672

NDR_CHECK(ndr_pull_array_size(ndr, &r->out.value));

1673

NDR_CHECK(ndr_pull_array_length(ndr, &r->out.value));

1674

if (ndr_get_array_length(ndr, &r->out.value) > ndr_get_array_size(ndr, &r->out.value)) {

1675

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

1676

}

1677

NDR_PULL_ALLOC_N(ndr, r->out.value, ndr_get_array_size(ndr, &r->out.value));

1678

NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->out.value, ndr_get_array_length(ndr, &r->out.value)));

1679

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_value_0, 0);

1680

}

1681

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_size));

1682

if (_ptr_size) {

1683

NDR_PULL_ALLOC(ndr, r->out.size);

1684

} else {

1685

r->out.size = NULL;

1686

}

1687

if (r->out.size) {

1688

_mem_save_size_0 = NDR_PULL_GET_MEM_CTX(ndr);

1689

NDR_PULL_SET_MEM_CTX(ndr, r->out.size, 0);

1690

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.size));

1691

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_size_0, 0);

1692

}

1693

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_length));

1694

if (_ptr_length) {

1695

NDR_PULL_ALLOC(ndr, r->out.length);

1696

} else {

1697

r->out.length = NULL;

1698

}

1699

if (r->out.length) {

1700

_mem_save_length_0 = NDR_PULL_GET_MEM_CTX(ndr);

1701

NDR_PULL_SET_MEM_CTX(ndr, r->out.length, 0);

1702

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.length));

1703

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_length_0, 0);

1704

}

1705

NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));

1706

if (r->out.value) {

1707

if (r->out.size == NULL) return ndr_pull_error(ndr, NDR_ERR_INVALID_POINTER, "NULL Pointer for size_is()");

1708

NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->out.value, *r->out.size));

1709

}

1710

if (r->out.value) {

1711

if (r->out.length == NULL) return ndr_pull_error(ndr, NDR_ERR_INVALID_POINTER, "NULL Pointer for length_is()");

1712

NDR_CHECK(ndr_check_array_length(ndr, (void*)&r->out.value, *r->out.length));

1713

}

1714

}

1715

return NDR_ERR_SUCCESS;

1716

}

1717

1718

_PUBLIC_ void ndr_print_winreg_EnumValue(struct ndr_print *ndr, const char *name, int flags, const struct winreg_EnumValue *r)

1719

{

1720

ndr_print_struct(ndr, name, "winreg_EnumValue");

1721

ndr->depth++;

1722

if (flags & NDR_SET_VALUES) {

1723

ndr->flags |= LIBNDR_PRINT_SET_VALUES;

1724

}

1725

if (flags & NDR_IN) {

1726

ndr_print_struct(ndr, "in", "winreg_EnumValue");

1727

ndr->depth++;

1728

ndr_print_ptr(ndr, "handle", r->in.handle);

1729

ndr->depth++;

1730

ndr_print_policy_handle(ndr, "handle", r->in.handle);

1731

ndr->depth--;

1732

ndr_print_uint32(ndr, "enum_index", r->in.enum_index);

1733

ndr_print_ptr(ndr, "name", r->in.name);

1734

ndr->depth++;

1735

ndr_print_winreg_ValNameBuf(ndr, "name", r->in.name);

1736

ndr->depth--;

1737

ndr_print_ptr(ndr, "type", r->in.type);

1738

ndr->depth++;

1739

if (r->in.type) {

1740

ndr_print_winreg_Type(ndr, "type", *r->in.type);

1741

}

1742

ndr->depth--;

1743

ndr_print_ptr(ndr, "value", r->in.value);

1744

ndr->depth++;

1745

if (r->in.value) {

1746

if (r->in.length == NULL) return;

1747

ndr_print_array_uint8(ndr, "value", r->in.value, *r->in.length);

1748

}

1749

ndr->depth--;

1750

ndr_print_ptr(ndr, "size", r->in.size);

1751

ndr->depth++;

1752

if (r->in.size) {

1753

ndr_print_uint32(ndr, "size", *r->in.size);

1754

}

1755

ndr->depth--;

1756

ndr_print_ptr(ndr, "length", r->in.length);

1757

ndr->depth++;

1758

if (r->in.length) {

1759

ndr_print_uint32(ndr, "length", *r->in.length);

1760

}

1761

ndr->depth--;

1762

ndr->depth--;

1763

}

1764

if (flags & NDR_OUT) {

1765

ndr_print_struct(ndr, "out", "winreg_EnumValue");

1766

ndr->depth++;

1767

ndr_print_ptr(ndr, "name", r->out.name);

1768

ndr->depth++;

1769

ndr_print_winreg_ValNameBuf(ndr, "name", r->out.name);

1770

ndr->depth--;

1771

ndr_print_ptr(ndr, "type", r->out.type);

1772

ndr->depth++;

1773

if (r->out.type) {

1774

ndr_print_winreg_Type(ndr, "type", *r->out.type);

1775

}

1776

ndr->depth--;

1777

ndr_print_ptr(ndr, "value", r->out.value);

1778

ndr->depth++;

1779

if (r->out.value) {

1780

if (r->out.length == NULL) return;

1781

ndr_print_array_uint8(ndr, "value", r->out.value, *r->out.length);

1782

}

1783

ndr->depth--;

1784

ndr_print_ptr(ndr, "size", r->out.size);

1785

ndr->depth++;

1786

if (r->out.size) {

1787

ndr_print_uint32(ndr, "size", *r->out.size);

1788

}

1789

ndr->depth--;

1790

ndr_print_ptr(ndr, "length", r->out.length);

1791

ndr->depth++;

1792

if (r->out.length) {

1793

ndr_print_uint32(ndr, "length", *r->out.length);

1794

}

1795

ndr->depth--;

1796

ndr_print_WERROR(ndr, "result", r->out.result);

1797

ndr->depth--;

1798

}

1799

ndr->depth--;

1800

}

1801

1802

_PUBLIC_ enum ndr_err_code ndr_push_winreg_FlushKey(struct ndr_push *ndr, int flags, const struct winreg_FlushKey *r)

1803

{

1804

if (flags & NDR_IN) {

1805

if (r->in.handle == NULL) {

1806

return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");

1807

}

1808

NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));

1809

}

1810

if (flags & NDR_OUT) {

1811

NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));

1812

}

1813

return NDR_ERR_SUCCESS;

1814

}

1815

1816

_PUBLIC_ enum ndr_err_code ndr_pull_winreg_FlushKey(struct ndr_pull *ndr, int flags, struct winreg_FlushKey *r)

1817

{

1818

TALLOC_CTX *_mem_save_handle_0;

1819

if (flags & NDR_IN) {

1820

if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {

1821

NDR_PULL_ALLOC(ndr, r->in.handle);

1822

}

1823

_mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);

1824

NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);

1825

NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));

1826

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);

1827

}

1828

if (flags & NDR_OUT) {

1829

NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));

1830

}

1831

return NDR_ERR_SUCCESS;

1832

}

1833

1834

_PUBLIC_ void ndr_print_winreg_FlushKey(struct ndr_print *ndr, const char *name, int flags, const struct winreg_FlushKey *r)

1835

{

1836

ndr_print_struct(ndr, name, "winreg_FlushKey");

1837

ndr->depth++;

1838

if (flags & NDR_SET_VALUES) {

1839

ndr->flags |= LIBNDR_PRINT_SET_VALUES;

1840

}

1841

if (flags & NDR_IN) {

1842

ndr_print_struct(ndr, "in", "winreg_FlushKey");

1843

ndr->depth++;

1844

ndr_print_ptr(ndr, "handle", r->in.handle);

1845

ndr->depth++;

1846

ndr_print_policy_handle(ndr, "handle", r->in.handle);

1847

ndr->depth--;

1848

ndr->depth--;

1849

}

1850

if (flags & NDR_OUT) {

1851

ndr_print_struct(ndr, "out", "winreg_FlushKey");

1852

ndr->depth++;

1853

ndr_print_WERROR(ndr, "result", r->out.result);

1854

ndr->depth--;

1855

}

1856

ndr->depth--;

1857

}

1858

1859

_PUBLIC_ enum ndr_err_code ndr_push_winreg_GetKeySecurity(struct ndr_push *ndr, int flags, const struct winreg_GetKeySecurity *r)

1860

{

1861

if (flags & NDR_IN) {

1862

if (r->in.handle == NULL) {

1863

return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");

1864

}

1865

NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));

1866

NDR_CHECK(ndr_push_security_secinfo(ndr, NDR_SCALARS, r->in.sec_info));

1867

if (r->in.sd == NULL) {

1868

return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");

1869

}

1870

NDR_CHECK(ndr_push_KeySecurityData(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.sd));

1871

}

1872

if (flags & NDR_OUT) {

1873

if (r->out.sd == NULL) {

1874

return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");

1875

}

1876

NDR_CHECK(ndr_push_KeySecurityData(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.sd));

1877

NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));

1878

}

1879

return NDR_ERR_SUCCESS;

1880

}

1881

1882

_PUBLIC_ enum ndr_err_code ndr_pull_winreg_GetKeySecurity(struct ndr_pull *ndr, int flags, struct winreg_GetKeySecurity *r)

1883

{

1884

TALLOC_CTX *_mem_save_handle_0;

1885

TALLOC_CTX *_mem_save_sd_0;

1886

if (flags & NDR_IN) {

1887

ZERO_STRUCT(r->out);

1888

1889

if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {

1890

NDR_PULL_ALLOC(ndr, r->in.handle);

1891

}

1892

_mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);

1893

NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);

1894

NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));

1895

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);

1896

NDR_CHECK(ndr_pull_security_secinfo(ndr, NDR_SCALARS, &r->in.sec_info));

1897

if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {

1898

NDR_PULL_ALLOC(ndr, r->in.sd);

1899

}

1900

_mem_save_sd_0 = NDR_PULL_GET_MEM_CTX(ndr);

1901

NDR_PULL_SET_MEM_CTX(ndr, r->in.sd, LIBNDR_FLAG_REF_ALLOC);

1902

NDR_CHECK(ndr_pull_KeySecurityData(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.sd));

1903

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sd_0, LIBNDR_FLAG_REF_ALLOC);

1904

NDR_PULL_ALLOC(ndr, r->out.sd);

1905

*r->out.sd = *r->in.sd;

1906

}

1907

if (flags & NDR_OUT) {

1908

if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {

1909

NDR_PULL_ALLOC(ndr, r->out.sd);

1910

}

1911

_mem_save_sd_0 = NDR_PULL_GET_MEM_CTX(ndr);

1912

NDR_PULL_SET_MEM_CTX(ndr, r->out.sd, LIBNDR_FLAG_REF_ALLOC);

1913

NDR_CHECK(ndr_pull_KeySecurityData(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.sd));

1914

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sd_0, LIBNDR_FLAG_REF_ALLOC);

1915

NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));

1916

}

1917

return NDR_ERR_SUCCESS;

1918

}

1919

1920

_PUBLIC_ void ndr_print_winreg_GetKeySecurity(struct ndr_print *ndr, const char *name, int flags, const struct winreg_GetKeySecurity *r)

1921

{

1922

ndr_print_struct(ndr, name, "winreg_GetKeySecurity");

1923

ndr->depth++;

1924

if (flags & NDR_SET_VALUES) {

1925

ndr->flags |= LIBNDR_PRINT_SET_VALUES;

1926

}

1927

if (flags & NDR_IN) {

1928

ndr_print_struct(ndr, "in", "winreg_GetKeySecurity");

1929

ndr->depth++;

1930

ndr_print_ptr(ndr, "handle", r->in.handle);

1931

ndr->depth++;

1932

ndr_print_policy_handle(ndr, "handle", r->in.handle);

1933

ndr->depth--;

1934

ndr_print_security_secinfo(ndr, "sec_info", r->in.sec_info);

1935

ndr_print_ptr(ndr, "sd", r->in.sd);

1936

ndr->depth++;

1937

ndr_print_KeySecurityData(ndr, "sd", r->in.sd);

1938

ndr->depth--;

1939

ndr->depth--;

1940

}

1941

if (flags & NDR_OUT) {

1942

ndr_print_struct(ndr, "out", "winreg_GetKeySecurity");

1943

ndr->depth++;

1944

ndr_print_ptr(ndr, "sd", r->out.sd);

1945

ndr->depth++;

1946

ndr_print_KeySecurityData(ndr, "sd", r->out.sd);

1947

ndr->depth--;

1948

ndr_print_WERROR(ndr, "result", r->out.result);

1949

ndr->depth--;

1950

}

1951

ndr->depth--;

1952

}

1953

1954

static enum ndr_err_code ndr_push_winreg_LoadKey(struct ndr_push *ndr, int flags, const struct winreg_LoadKey *r)

1955

{

1956

if (flags & NDR_IN) {

1957

if (r->in.handle == NULL) {

1958

return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");

1959

}

1960

NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));

1961

NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.keyname));

1962

if (r->in.keyname) {

1963

NDR_CHECK(ndr_push_winreg_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.keyname));

1964

}

1965

NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.filename));

1966

if (r->in.filename) {

1967

NDR_CHECK(ndr_push_winreg_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.filename));

1968

}

1969

}

1970

if (flags & NDR_OUT) {

1971

NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));

1972

}

1973

return NDR_ERR_SUCCESS;

1974

}

1975

1976

static enum ndr_err_code ndr_pull_winreg_LoadKey(struct ndr_pull *ndr, int flags, struct winreg_LoadKey *r)

1977

{

1978

uint32_t _ptr_keyname;

1979

uint32_t _ptr_filename;

1980

TALLOC_CTX *_mem_save_handle_0;

1981

TALLOC_CTX *_mem_save_keyname_0;

1982

TALLOC_CTX *_mem_save_filename_0;

1983

if (flags & NDR_IN) {

1984

if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {

1985

NDR_PULL_ALLOC(ndr, r->in.handle);

1986

}

1987

_mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);

1988

NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);

1989

NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));

1990

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);

1991

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_keyname));

1992

if (_ptr_keyname) {

1993

NDR_PULL_ALLOC(ndr, r->in.keyname);

1994

} else {

1995

r->in.keyname = NULL;

1996

}

1997

if (r->in.keyname) {

1998

_mem_save_keyname_0 = NDR_PULL_GET_MEM_CTX(ndr);

1999

NDR_PULL_SET_MEM_CTX(ndr, r->in.keyname, 0);

2000

NDR_CHECK(ndr_pull_winreg_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.keyname));

2001

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_keyname_0, 0);

2002

}

2003

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_filename));

2004

if (_ptr_filename) {

2005

NDR_PULL_ALLOC(ndr, r->in.filename);

2006

} else {

2007

r->in.filename = NULL;

2008

}

2009

if (r->in.filename) {

2010

_mem_save_filename_0 = NDR_PULL_GET_MEM_CTX(ndr);

2011

NDR_PULL_SET_MEM_CTX(ndr, r->in.filename, 0);

2012

NDR_CHECK(ndr_pull_winreg_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.filename));

2013

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_filename_0, 0);

2014

}

2015

}

2016

if (flags & NDR_OUT) {

2017

NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));

2018

}

2019

return NDR_ERR_SUCCESS;

2020

}

2021

2022

_PUBLIC_ void ndr_print_winreg_LoadKey(struct ndr_print *ndr, const char *name, int flags, const struct winreg_LoadKey *r)

2023

{

2024

ndr_print_struct(ndr, name, "winreg_LoadKey");

2025

ndr->depth++;

2026

if (flags & NDR_SET_VALUES) {

2027

ndr->flags |= LIBNDR_PRINT_SET_VALUES;

2028

}

2029

if (flags & NDR_IN) {

2030

ndr_print_struct(ndr, "in", "winreg_LoadKey");

2031

ndr->depth++;

2032

ndr_print_ptr(ndr, "handle", r->in.handle);

2033

ndr->depth++;

2034

ndr_print_policy_handle(ndr, "handle", r->in.handle);

2035

ndr->depth--;

2036

ndr_print_ptr(ndr, "keyname", r->in.keyname);

2037

ndr->depth++;

2038

if (r->in.keyname) {

2039

ndr_print_winreg_String(ndr, "keyname", r->in.keyname);

2040

}

2041

ndr->depth--;

2042

ndr_print_ptr(ndr, "filename", r->in.filename);

2043

ndr->depth++;

2044

if (r->in.filename) {

2045

ndr_print_winreg_String(ndr, "filename", r->in.filename);

2046

}

2047

ndr->depth--;

2048

ndr->depth--;

2049

}

2050

if (flags & NDR_OUT) {

2051

ndr_print_struct(ndr, "out", "winreg_LoadKey");

2052

ndr->depth++;

2053

ndr_print_WERROR(ndr, "result", r->out.result);

2054

ndr->depth--;

2055

}

2056

ndr->depth--;

2057

}

2058

2059

_PUBLIC_ enum ndr_err_code ndr_push_winreg_NotifyChangeKeyValue(struct ndr_push *ndr, int flags, const struct winreg_NotifyChangeKeyValue *r)

2060

{

2061

if (flags & NDR_IN) {

2062

if (r->in.handle == NULL) {

2063

return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");

2064

}

2065

NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));

2066

NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->in.watch_subtree));

2067

NDR_CHECK(ndr_push_winreg_NotifyChangeType(ndr, NDR_SCALARS, r->in.notify_filter));

2068

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.unknown));

2069

NDR_CHECK(ndr_push_winreg_String(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.string1));

2070

NDR_CHECK(ndr_push_winreg_String(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.string2));

2071

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.unknown2));

2072

}

2073

if (flags & NDR_OUT) {

2074

NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));

2075

}

2076

return NDR_ERR_SUCCESS;

2077

}

2078

2079

_PUBLIC_ enum ndr_err_code ndr_pull_winreg_NotifyChangeKeyValue(struct ndr_pull *ndr, int flags, struct winreg_NotifyChangeKeyValue *r)

2080

{

2081

TALLOC_CTX *_mem_save_handle_0;

2082

if (flags & NDR_IN) {

2083

if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {

2084

NDR_PULL_ALLOC(ndr, r->in.handle);

2085

}

2086

_mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);

2087

NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);

2088

NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));

2089

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);

2090

NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->in.watch_subtree));

2091

NDR_CHECK(ndr_pull_winreg_NotifyChangeType(ndr, NDR_SCALARS, &r->in.notify_filter));

2092

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.unknown));

2093

NDR_CHECK(ndr_pull_winreg_String(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.string1));

2094

NDR_CHECK(ndr_pull_winreg_String(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.string2));

2095

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.unknown2));

2096

}

2097

if (flags & NDR_OUT) {

2098

NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));

2099

}

2100

return NDR_ERR_SUCCESS;

2101

}

2102

2103

_PUBLIC_ void ndr_print_winreg_NotifyChangeKeyValue(struct ndr_print *ndr, const char *name, int flags, const struct winreg_NotifyChangeKeyValue *r)

2104

{

2105

ndr_print_struct(ndr, name, "winreg_NotifyChangeKeyValue");

2106

ndr->depth++;

2107

if (flags & NDR_SET_VALUES) {

2108

ndr->flags |= LIBNDR_PRINT_SET_VALUES;

2109

}

2110

if (flags & NDR_IN) {

2111

ndr_print_struct(ndr, "in", "winreg_NotifyChangeKeyValue");

2112

ndr->depth++;

2113

ndr_print_ptr(ndr, "handle", r->in.handle);

2114

ndr->depth++;

2115

ndr_print_policy_handle(ndr, "handle", r->in.handle);

2116

ndr->depth--;

2117

ndr_print_uint8(ndr, "watch_subtree", r->in.watch_subtree);

2118

ndr_print_winreg_NotifyChangeType(ndr, "notify_filter", r->in.notify_filter);

2119

ndr_print_uint32(ndr, "unknown", r->in.unknown);

2120

ndr_print_winreg_String(ndr, "string1", &r->in.string1);

2121

ndr_print_winreg_String(ndr, "string2", &r->in.string2);

2122

ndr_print_uint32(ndr, "unknown2", r->in.unknown2);

2123

ndr->depth--;

2124

}

2125

if (flags & NDR_OUT) {

2126

ndr_print_struct(ndr, "out", "winreg_NotifyChangeKeyValue");

2127

ndr->depth++;

2128

ndr_print_WERROR(ndr, "result", r->out.result);

2129

ndr->depth--;

2130

}

2131

ndr->depth--;

2132

}

2133

2134

_PUBLIC_ enum ndr_err_code ndr_push_winreg_OpenKey(struct ndr_push *ndr, int flags, const struct winreg_OpenKey *r)

2135

{

2136

if (flags & NDR_IN) {

2137

if (r->in.parent_handle == NULL) {

2138

return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");

2139

}

2140

NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.parent_handle));

2141

NDR_CHECK(ndr_push_winreg_String(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.keyname));

2142

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.unknown));

2143

NDR_CHECK(ndr_push_winreg_AccessMask(ndr, NDR_SCALARS, r->in.access_mask));

2144

}

2145

if (flags & NDR_OUT) {

2146

if (r->out.handle == NULL) {

2147

return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");

2148

}

2149

NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.handle));

2150

NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));

2151

}

2152

return NDR_ERR_SUCCESS;

2153

}

2154

2155

_PUBLIC_ enum ndr_err_code ndr_pull_winreg_OpenKey(struct ndr_pull *ndr, int flags, struct winreg_OpenKey *r)

2156

{

2157

TALLOC_CTX *_mem_save_parent_handle_0;

2158

TALLOC_CTX *_mem_save_handle_0;

2159

if (flags & NDR_IN) {

2160

ZERO_STRUCT(r->out);

2161

2162

if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {

2163

NDR_PULL_ALLOC(ndr, r->in.parent_handle);

2164

}

2165

_mem_save_parent_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);

2166

NDR_PULL_SET_MEM_CTX(ndr, r->in.parent_handle, LIBNDR_FLAG_REF_ALLOC);

2167

NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.parent_handle));

2168

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_parent_handle_0, LIBNDR_FLAG_REF_ALLOC);

2169

NDR_CHECK(ndr_pull_winreg_String(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.keyname));

2170

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.unknown));

2171

NDR_CHECK(ndr_pull_winreg_AccessMask(ndr, NDR_SCALARS, &r->in.access_mask));

2172

NDR_PULL_ALLOC(ndr, r->out.handle);

2173

ZERO_STRUCTP(r->out.handle);

2174

}

2175

if (flags & NDR_OUT) {

2176

if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {

2177

NDR_PULL_ALLOC(ndr, r->out.handle);

2178

}

2179

_mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);

2180

NDR_PULL_SET_MEM_CTX(ndr, r->out.handle, LIBNDR_FLAG_REF_ALLOC);

2181

NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.handle));

2182

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);

2183

NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));

2184

}

2185

return NDR_ERR_SUCCESS;

2186

}

2187

2188

_PUBLIC_ void ndr_print_winreg_OpenKey(struct ndr_print *ndr, const char *name, int flags, const struct winreg_OpenKey *r)

2189

{

2190

ndr_print_struct(ndr, name, "winreg_OpenKey");

2191

ndr->depth++;

2192

if (flags & NDR_SET_VALUES) {

2193

ndr->flags |= LIBNDR_PRINT_SET_VALUES;

2194

}

2195

if (flags & NDR_IN) {

2196

ndr_print_struct(ndr, "in", "winreg_OpenKey");

2197

ndr->depth++;

2198

ndr_print_ptr(ndr, "parent_handle", r->in.parent_handle);

2199

ndr->depth++;

2200

ndr_print_policy_handle(ndr, "parent_handle", r->in.parent_handle);

2201

ndr->depth--;

2202

ndr_print_winreg_String(ndr, "keyname", &r->in.keyname);

2203

ndr_print_uint32(ndr, "unknown", r->in.unknown);

2204

ndr_print_winreg_AccessMask(ndr, "access_mask", r->in.access_mask);

2205

ndr->depth--;

2206

}

2207

if (flags & NDR_OUT) {

2208

ndr_print_struct(ndr, "out", "winreg_OpenKey");

2209

ndr->depth++;

2210

ndr_print_ptr(ndr, "handle", r->out.handle);

2211

ndr->depth++;

2212

ndr_print_policy_handle(ndr, "handle", r->out.handle);

2213

ndr->depth--;

2214

ndr_print_WERROR(ndr, "result", r->out.result);

2215

ndr->depth--;

2216

}

2217

ndr->depth--;

2218

}

2219

2220

_PUBLIC_ enum ndr_err_code ndr_push_winreg_QueryInfoKey(struct ndr_push *ndr, int flags, const struct winreg_QueryInfoKey *r)

2221

{

2222

if (flags & NDR_IN) {

2223

if (r->in.handle == NULL) {

2224

return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");

2225

}

2226

NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));

2227

if (r->in.classname == NULL) {

2228

return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");

2229

}

2230

NDR_CHECK(ndr_push_winreg_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.classname));

2231

}

2232

if (flags & NDR_OUT) {

2233

if (r->out.classname == NULL) {

2234

return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");

2235

}

2236

NDR_CHECK(ndr_push_winreg_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.classname));

2237

if (r->out.num_subkeys == NULL) {

2238

return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");

2239

}

2240

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.num_subkeys));

2241

if (r->out.max_subkeylen == NULL) {

2242

return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");

2243

}

2244

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.max_subkeylen));

2245

if (r->out.max_classlen == NULL) {

2246

return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");

2247

}

2248

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.max_classlen));

2249

if (r->out.num_values == NULL) {

2250

return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");

2251

}

2252

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.num_values));

2253

if (r->out.max_valnamelen == NULL) {

2254

return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");

2255

}

2256

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.max_valnamelen));

2257

if (r->out.max_valbufsize == NULL) {

2258

return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");

2259

}

2260

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.max_valbufsize));

2261

if (r->out.secdescsize == NULL) {

2262

return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");

2263

}

2264

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.secdescsize));

2265

if (r->out.last_changed_time == NULL) {

2266

return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");

2267

}

2268

NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, *r->out.last_changed_time));

2269

NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));

2270

}

2271

return NDR_ERR_SUCCESS;

2272

}

2273

2274

_PUBLIC_ enum ndr_err_code ndr_pull_winreg_QueryInfoKey(struct ndr_pull *ndr, int flags, struct winreg_QueryInfoKey *r)

2275

{

2276

TALLOC_CTX *_mem_save_handle_0;

2277

TALLOC_CTX *_mem_save_classname_0;

2278

TALLOC_CTX *_mem_save_num_subkeys_0;

2279

TALLOC_CTX *_mem_save_max_subkeylen_0;

2280

TALLOC_CTX *_mem_save_max_classlen_0;

2281

TALLOC_CTX *_mem_save_num_values_0;

2282

TALLOC_CTX *_mem_save_max_valnamelen_0;

2283

TALLOC_CTX *_mem_save_max_valbufsize_0;

2284

TALLOC_CTX *_mem_save_secdescsize_0;

2285

TALLOC_CTX *_mem_save_last_changed_time_0;

2286

if (flags & NDR_IN) {

2287

ZERO_STRUCT(r->out);

2288

2289

if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {

2290

NDR_PULL_ALLOC(ndr, r->in.handle);

2291

}

2292

_mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);

2293

NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);

2294

NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));

2295

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);

2296

if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {

2297

NDR_PULL_ALLOC(ndr, r->in.classname);

2298

}

2299

_mem_save_classname_0 = NDR_PULL_GET_MEM_CTX(ndr);

2300

NDR_PULL_SET_MEM_CTX(ndr, r->in.classname, LIBNDR_FLAG_REF_ALLOC);

2301

NDR_CHECK(ndr_pull_winreg_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.classname));

2302

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_classname_0, LIBNDR_FLAG_REF_ALLOC);

2303

NDR_PULL_ALLOC(ndr, r->out.classname);

2304

*r->out.classname = *r->in.classname;

2305

NDR_PULL_ALLOC(ndr, r->out.num_subkeys);

2306

ZERO_STRUCTP(r->out.num_subkeys);

2307

NDR_PULL_ALLOC(ndr, r->out.max_subkeylen);

2308

ZERO_STRUCTP(r->out.max_subkeylen);

2309

NDR_PULL_ALLOC(ndr, r->out.max_classlen);

2310

ZERO_STRUCTP(r->out.max_classlen);

2311

NDR_PULL_ALLOC(ndr, r->out.num_values);

2312

ZERO_STRUCTP(r->out.num_values);

2313

NDR_PULL_ALLOC(ndr, r->out.max_valnamelen);

2314

ZERO_STRUCTP(r->out.max_valnamelen);

2315

NDR_PULL_ALLOC(ndr, r->out.max_valbufsize);

2316

ZERO_STRUCTP(r->out.max_valbufsize);

2317

NDR_PULL_ALLOC(ndr, r->out.secdescsize);

2318

ZERO_STRUCTP(r->out.secdescsize);

2319

NDR_PULL_ALLOC(ndr, r->out.last_changed_time);

2320

ZERO_STRUCTP(r->out.last_changed_time);

2321

}

2322

if (flags & NDR_OUT) {

2323

if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {

2324

NDR_PULL_ALLOC(ndr, r->out.classname);

2325

}

2326

_mem_save_classname_0 = NDR_PULL_GET_MEM_CTX(ndr);

2327

NDR_PULL_SET_MEM_CTX(ndr, r->out.classname, LIBNDR_FLAG_REF_ALLOC);

2328

NDR_CHECK(ndr_pull_winreg_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.classname));

2329

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_classname_0, LIBNDR_FLAG_REF_ALLOC);

2330

if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {

2331

NDR_PULL_ALLOC(ndr, r->out.num_subkeys);

2332

}

2333

_mem_save_num_subkeys_0 = NDR_PULL_GET_MEM_CTX(ndr);

2334

NDR_PULL_SET_MEM_CTX(ndr, r->out.num_subkeys, LIBNDR_FLAG_REF_ALLOC);

2335

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.num_subkeys));

2336

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_num_subkeys_0, LIBNDR_FLAG_REF_ALLOC);

2337

if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {

2338

NDR_PULL_ALLOC(ndr, r->out.max_subkeylen);

2339

}

2340

_mem_save_max_subkeylen_0 = NDR_PULL_GET_MEM_CTX(ndr);

2341

NDR_PULL_SET_MEM_CTX(ndr, r->out.max_subkeylen, LIBNDR_FLAG_REF_ALLOC);

2342

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.max_subkeylen));

2343

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_max_subkeylen_0, LIBNDR_FLAG_REF_ALLOC);

2344

if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {

2345

NDR_PULL_ALLOC(ndr, r->out.max_classlen);

2346

}

2347

_mem_save_max_classlen_0 = NDR_PULL_GET_MEM_CTX(ndr);

2348

NDR_PULL_SET_MEM_CTX(ndr, r->out.max_classlen, LIBNDR_FLAG_REF_ALLOC);

2349

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.max_classlen));

2350

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_max_classlen_0, LIBNDR_FLAG_REF_ALLOC);

2351

if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {

2352

NDR_PULL_ALLOC(ndr, r->out.num_values);

2353

}

2354

_mem_save_num_values_0 = NDR_PULL_GET_MEM_CTX(ndr);

2355

NDR_PULL_SET_MEM_CTX(ndr, r->out.num_values, LIBNDR_FLAG_REF_ALLOC);

2356

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.num_values));

2357

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_num_values_0, LIBNDR_FLAG_REF_ALLOC);

2358

if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {

2359

NDR_PULL_ALLOC(ndr, r->out.max_valnamelen);

2360

}

2361

_mem_save_max_valnamelen_0 = NDR_PULL_GET_MEM_CTX(ndr);

2362

NDR_PULL_SET_MEM_CTX(ndr, r->out.max_valnamelen, LIBNDR_FLAG_REF_ALLOC);

2363

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.max_valnamelen));

2364

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_max_valnamelen_0, LIBNDR_FLAG_REF_ALLOC);

2365

if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {

2366

NDR_PULL_ALLOC(ndr, r->out.max_valbufsize);

2367

}

2368

_mem_save_max_valbufsize_0 = NDR_PULL_GET_MEM_CTX(ndr);

2369

NDR_PULL_SET_MEM_CTX(ndr, r->out.max_valbufsize, LIBNDR_FLAG_REF_ALLOC);

2370

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.max_valbufsize));

2371

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_max_valbufsize_0, LIBNDR_FLAG_REF_ALLOC);

2372

if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {

2373

NDR_PULL_ALLOC(ndr, r->out.secdescsize);

2374

}

2375

_mem_save_secdescsize_0 = NDR_PULL_GET_MEM_CTX(ndr);

2376

NDR_PULL_SET_MEM_CTX(ndr, r->out.secdescsize, LIBNDR_FLAG_REF_ALLOC);

2377

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.secdescsize));

2378

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_secdescsize_0, LIBNDR_FLAG_REF_ALLOC);

2379

if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {

2380

NDR_PULL_ALLOC(ndr, r->out.last_changed_time);

2381

}

2382

_mem_save_last_changed_time_0 = NDR_PULL_GET_MEM_CTX(ndr);

2383

NDR_PULL_SET_MEM_CTX(ndr, r->out.last_changed_time, LIBNDR_FLAG_REF_ALLOC);

2384

NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, r->out.last_changed_time));

2385

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_last_changed_time_0, LIBNDR_FLAG_REF_ALLOC);

2386

NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));

2387

}

2388

return NDR_ERR_SUCCESS;

2389

}

2390

2391

_PUBLIC_ void ndr_print_winreg_QueryInfoKey(struct ndr_print *ndr, const char *name, int flags, const struct winreg_QueryInfoKey *r)

2392

{

2393

ndr_print_struct(ndr, name, "winreg_QueryInfoKey");

2394

ndr->depth++;

2395

if (flags & NDR_SET_VALUES) {

2396

ndr->flags |= LIBNDR_PRINT_SET_VALUES;

2397

}

2398

if (flags & NDR_IN) {

2399

ndr_print_struct(ndr, "in", "winreg_QueryInfoKey");

2400

ndr->depth++;

2401

ndr_print_ptr(ndr, "handle", r->in.handle);

2402

ndr->depth++;

2403

ndr_print_policy_handle(ndr, "handle", r->in.handle);

2404

ndr->depth--;

2405

ndr_print_ptr(ndr, "classname", r->in.classname);

2406

ndr->depth++;

2407

ndr_print_winreg_String(ndr, "classname", r->in.classname);

2408

ndr->depth--;

2409

ndr->depth--;

2410

}

2411

if (flags & NDR_OUT) {

2412

ndr_print_struct(ndr, "out", "winreg_QueryInfoKey");

2413

ndr->depth++;

2414

ndr_print_ptr(ndr, "classname", r->out.classname);

2415

ndr->depth++;

2416

ndr_print_winreg_String(ndr, "classname", r->out.classname);

2417

ndr->depth--;

2418

ndr_print_ptr(ndr, "num_subkeys", r->out.num_subkeys);

2419

ndr->depth++;

2420

ndr_print_uint32(ndr, "num_subkeys", *r->out.num_subkeys);

2421

ndr->depth--;

2422

ndr_print_ptr(ndr, "max_subkeylen", r->out.max_subkeylen);

2423

ndr->depth++;

2424

ndr_print_uint32(ndr, "max_subkeylen", *r->out.max_subkeylen);

2425

ndr->depth--;

2426

ndr_print_ptr(ndr, "max_classlen", r->out.max_classlen);

2427

ndr->depth++;

2428

ndr_print_uint32(ndr, "max_classlen", *r->out.max_classlen);

2429

ndr->depth--;

2430

ndr_print_ptr(ndr, "num_values", r->out.num_values);

2431

ndr->depth++;

2432

ndr_print_uint32(ndr, "num_values", *r->out.num_values);

2433

ndr->depth--;

2434

ndr_print_ptr(ndr, "max_valnamelen", r->out.max_valnamelen);

2435

ndr->depth++;

2436

ndr_print_uint32(ndr, "max_valnamelen", *r->out.max_valnamelen);

2437

ndr->depth--;

2438

ndr_print_ptr(ndr, "max_valbufsize", r->out.max_valbufsize);

2439

ndr->depth++;

2440

ndr_print_uint32(ndr, "max_valbufsize", *r->out.max_valbufsize);

2441

ndr->depth--;

2442

ndr_print_ptr(ndr, "secdescsize", r->out.secdescsize);

2443

ndr->depth++;

2444

ndr_print_uint32(ndr, "secdescsize", *r->out.secdescsize);

2445

ndr->depth--;

2446

ndr_print_ptr(ndr, "last_changed_time", r->out.last_changed_time);

2447

ndr->depth++;

2448

ndr_print_NTTIME(ndr, "last_changed_time", *r->out.last_changed_time);

2449

ndr->depth--;

2450

ndr_print_WERROR(ndr, "result", r->out.result);

2451

ndr->depth--;

2452

}

2453

ndr->depth--;

2454

}

2455

2456

_PUBLIC_ enum ndr_err_code ndr_push_winreg_QueryValue(struct ndr_push *ndr, int flags, const struct winreg_QueryValue *r)

2457

{

2458

if (flags & NDR_IN) {

2459

if (r->in.handle == NULL) {

2460

return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");

2461

}

2462

NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));

2463

if (r->in.value_name == NULL) {

2464

return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");

2465

}

2466

NDR_CHECK(ndr_push_winreg_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.value_name));

2467

NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.type));

2468

if (r->in.type) {

2469

NDR_CHECK(ndr_push_winreg_Type(ndr, NDR_SCALARS, *r->in.type));

2470

}

2471

NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.data));

2472

if (r->in.data) {

2473

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->in.data_size));

2474

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

2475

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->in.data_length));

2476

NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->in.data, *r->in.data_length));

2477

}

2478

NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.data_size));

2479

if (r->in.data_size) {

2480

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->in.data_size));

2481

}

2482

NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.data_length));

2483

if (r->in.data_length) {

2484

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->in.data_length));

2485

}

2486

}

2487

if (flags & NDR_OUT) {

2488

NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.type));

2489

if (r->out.type) {

2490

NDR_CHECK(ndr_push_winreg_Type(ndr, NDR_SCALARS, *r->out.type));

2491

}

2492

NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.data));

2493

if (r->out.data) {

2494

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.data_size));

2495

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

2496

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.data_length));

2497

NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->out.data, *r->out.data_length));

2498

}

2499

NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.data_size));

2500

if (r->out.data_size) {

2501

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.data_size));

2502

}

2503

NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.data_length));

2504

if (r->out.data_length) {

2505

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.data_length));

2506

}

2507

NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));

2508

}

2509

return NDR_ERR_SUCCESS;

2510

}

2511

2512

_PUBLIC_ enum ndr_err_code ndr_pull_winreg_QueryValue(struct ndr_pull *ndr, int flags, struct winreg_QueryValue *r)

2513

{

2514

uint32_t _ptr_type;

2515

uint32_t _ptr_data;

2516

uint32_t _ptr_data_size;

2517

uint32_t _ptr_data_length;

2518

TALLOC_CTX *_mem_save_handle_0;

2519

TALLOC_CTX *_mem_save_value_name_0;

2520

TALLOC_CTX *_mem_save_type_0;

2521

TALLOC_CTX *_mem_save_data_0;

2522

TALLOC_CTX *_mem_save_data_size_0;

2523

TALLOC_CTX *_mem_save_data_length_0;

2524

if (flags & NDR_IN) {

2525

ZERO_STRUCT(r->out);

2526

2527

if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {

2528

NDR_PULL_ALLOC(ndr, r->in.handle);

2529

}

2530

_mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);

2531

NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);

2532

NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));

2533

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);

2534

if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {

2535

NDR_PULL_ALLOC(ndr, r->in.value_name);

2536

}

2537

_mem_save_value_name_0 = NDR_PULL_GET_MEM_CTX(ndr);

2538

NDR_PULL_SET_MEM_CTX(ndr, r->in.value_name, LIBNDR_FLAG_REF_ALLOC);

2539

NDR_CHECK(ndr_pull_winreg_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.value_name));

2540

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_value_name_0, LIBNDR_FLAG_REF_ALLOC);

2541

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_type));

2542

if (_ptr_type) {

2543

NDR_PULL_ALLOC(ndr, r->in.type);

2544

} else {

2545

r->in.type = NULL;

2546

}

2547

if (r->in.type) {

2548

_mem_save_type_0 = NDR_PULL_GET_MEM_CTX(ndr);

2549

NDR_PULL_SET_MEM_CTX(ndr, r->in.type, 0);

2550

NDR_CHECK(ndr_pull_winreg_Type(ndr, NDR_SCALARS, r->in.type));

2551

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_type_0, 0);

2552

}

2553

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data));

2554

if (_ptr_data) {

2555

NDR_PULL_ALLOC(ndr, r->in.data);

2556

} else {

2557

r->in.data = NULL;

2558

}

2559

if (r->in.data) {

2560

_mem_save_data_0 = NDR_PULL_GET_MEM_CTX(ndr);

2561

NDR_PULL_SET_MEM_CTX(ndr, r->in.data, 0);

2562

NDR_CHECK(ndr_pull_array_size(ndr, &r->in.data));

2563

NDR_CHECK(ndr_pull_array_length(ndr, &r->in.data));

2564

if (ndr_get_array_length(ndr, &r->in.data) > ndr_get_array_size(ndr, &r->in.data)) {

2565

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.data), ndr_get_array_length(ndr, &r->in.data));

2566

}

2567

NDR_PULL_ALLOC_N(ndr, r->in.data, ndr_get_array_size(ndr, &r->in.data));

2568

NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->in.data, ndr_get_array_length(ndr, &r->in.data)));

2569

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_0, 0);

2570

}

2571

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_size));

2572

if (_ptr_data_size) {

2573

NDR_PULL_ALLOC(ndr, r->in.data_size);

2574

} else {

2575

r->in.data_size = NULL;

2576

}

2577

if (r->in.data_size) {

2578

_mem_save_data_size_0 = NDR_PULL_GET_MEM_CTX(ndr);

2579

NDR_PULL_SET_MEM_CTX(ndr, r->in.data_size, 0);

2580

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->in.data_size));

2581

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_size_0, 0);

2582

}

2583

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_length));

2584

if (_ptr_data_length) {

2585

NDR_PULL_ALLOC(ndr, r->in.data_length);

2586

} else {

2587

r->in.data_length = NULL;

2588

}

2589

if (r->in.data_length) {

2590

_mem_save_data_length_0 = NDR_PULL_GET_MEM_CTX(ndr);

2591

NDR_PULL_SET_MEM_CTX(ndr, r->in.data_length, 0);

2592

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->in.data_length));

2593

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_length_0, 0);

2594

}

2595

if (r->in.data) {

2596

if (r->in.data_size == NULL) return ndr_pull_error(ndr, NDR_ERR_INVALID_POINTER, "NULL Pointer for size_is()");

2597

NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->in.data, *r->in.data_size));

2598

}

2599

if (r->in.data) {

2600

if (r->in.data_length == NULL) return ndr_pull_error(ndr, NDR_ERR_INVALID_POINTER, "NULL Pointer for length_is()");

2601

NDR_CHECK(ndr_check_array_length(ndr, (void*)&r->in.data, *r->in.data_length));

2602

}

2603

}

2604

if (flags & NDR_OUT) {

2605

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_type));

2606

if (_ptr_type) {

2607

NDR_PULL_ALLOC(ndr, r->out.type);

2608

} else {

2609

r->out.type = NULL;

2610

}

2611

if (r->out.type) {

2612

_mem_save_type_0 = NDR_PULL_GET_MEM_CTX(ndr);

2613

NDR_PULL_SET_MEM_CTX(ndr, r->out.type, 0);

2614

NDR_CHECK(ndr_pull_winreg_Type(ndr, NDR_SCALARS, r->out.type));

2615

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_type_0, 0);

2616

}

2617

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data));

2618

if (_ptr_data) {

2619

NDR_PULL_ALLOC(ndr, r->out.data);

2620

} else {

2621

r->out.data = NULL;

2622

}

2623

if (r->out.data) {

2624

_mem_save_data_0 = NDR_PULL_GET_MEM_CTX(ndr);

2625

NDR_PULL_SET_MEM_CTX(ndr, r->out.data, 0);

2626

NDR_CHECK(ndr_pull_array_size(ndr, &r->out.data));

2627

NDR_CHECK(ndr_pull_array_length(ndr, &r->out.data));

2628

if (ndr_get_array_length(ndr, &r->out.data) > ndr_get_array_size(ndr, &r->out.data)) {

2629

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

2630

}

2631

NDR_PULL_ALLOC_N(ndr, r->out.data, ndr_get_array_size(ndr, &r->out.data));

2632

NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->out.data, ndr_get_array_length(ndr, &r->out.data)));

2633

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_0, 0);

2634

}

2635

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_size));

2636

if (_ptr_data_size) {

2637

NDR_PULL_ALLOC(ndr, r->out.data_size);

2638

} else {

2639

r->out.data_size = NULL;

2640

}

2641

if (r->out.data_size) {

2642

_mem_save_data_size_0 = NDR_PULL_GET_MEM_CTX(ndr);

2643

NDR_PULL_SET_MEM_CTX(ndr, r->out.data_size, 0);

2644

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.data_size));

2645

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_size_0, 0);

2646

}

2647

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_length));

2648

if (_ptr_data_length) {

2649

NDR_PULL_ALLOC(ndr, r->out.data_length);

2650

} else {

2651

r->out.data_length = NULL;

2652

}

2653

if (r->out.data_length) {

2654

_mem_save_data_length_0 = NDR_PULL_GET_MEM_CTX(ndr);

2655

NDR_PULL_SET_MEM_CTX(ndr, r->out.data_length, 0);

2656

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.data_length));

2657

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_length_0, 0);

2658

}

2659

NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));

2660

if (r->out.data) {

2661

if (r->out.data_size == NULL) return ndr_pull_error(ndr, NDR_ERR_INVALID_POINTER, "NULL Pointer for size_is()");

2662

NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->out.data, *r->out.data_size));

2663

}

2664

if (r->out.data) {

2665

if (r->out.data_length == NULL) return ndr_pull_error(ndr, NDR_ERR_INVALID_POINTER, "NULL Pointer for length_is()");

2666

NDR_CHECK(ndr_check_array_length(ndr, (void*)&r->out.data, *r->out.data_length));

2667

}

2668

}

2669

return NDR_ERR_SUCCESS;

2670

}

2671

2672

_PUBLIC_ void ndr_print_winreg_QueryValue(struct ndr_print *ndr, const char *name, int flags, const struct winreg_QueryValue *r)

2673

{

2674

ndr_print_struct(ndr, name, "winreg_QueryValue");

2675

ndr->depth++;

2676

if (flags & NDR_SET_VALUES) {

2677

ndr->flags |= LIBNDR_PRINT_SET_VALUES;

2678

}

2679

if (flags & NDR_IN) {

2680

ndr_print_struct(ndr, "in", "winreg_QueryValue");

2681

ndr->depth++;

2682

ndr_print_ptr(ndr, "handle", r->in.handle);

2683

ndr->depth++;

2684

ndr_print_policy_handle(ndr, "handle", r->in.handle);

2685

ndr->depth--;

2686

ndr_print_ptr(ndr, "value_name", r->in.value_name);

2687

ndr->depth++;

2688

ndr_print_winreg_String(ndr, "value_name", r->in.value_name);

2689

ndr->depth--;

2690

ndr_print_ptr(ndr, "type", r->in.type);

2691

ndr->depth++;

2692

if (r->in.type) {

2693

ndr_print_winreg_Type(ndr, "type", *r->in.type);

2694

}

2695

ndr->depth--;

2696

ndr_print_ptr(ndr, "data", r->in.data);

2697

ndr->depth++;

2698

if (r->in.data) {

2699

if (r->in.data_length == NULL) return;

2700

ndr_print_array_uint8(ndr, "data", r->in.data, *r->in.data_length);

2701

}

2702

ndr->depth--;

2703

ndr_print_ptr(ndr, "data_size", r->in.data_size);

2704

ndr->depth++;

2705

if (r->in.data_size) {

2706

ndr_print_uint32(ndr, "data_size", *r->in.data_size);

2707

}

2708

ndr->depth--;

2709

ndr_print_ptr(ndr, "data_length", r->in.data_length);

2710

ndr->depth++;

2711

if (r->in.data_length) {

2712

ndr_print_uint32(ndr, "data_length", *r->in.data_length);

2713

}

2714

ndr->depth--;

2715

ndr->depth--;

2716

}

2717

if (flags & NDR_OUT) {

2718

ndr_print_struct(ndr, "out", "winreg_QueryValue");

2719

ndr->depth++;

2720

ndr_print_ptr(ndr, "type", r->out.type);

2721

ndr->depth++;

2722

if (r->out.type) {

2723

ndr_print_winreg_Type(ndr, "type", *r->out.type);

2724

}

2725

ndr->depth--;

2726

ndr_print_ptr(ndr, "data", r->out.data);

2727

ndr->depth++;

2728

if (r->out.data) {

2729

if (r->out.data_length == NULL) return;

2730

ndr_print_array_uint8(ndr, "data", r->out.data, *r->out.data_length);

2731

}

2732

ndr->depth--;

2733

ndr_print_ptr(ndr, "data_size", r->out.data_size);

2734

ndr->depth++;

2735

if (r->out.data_size) {

2736

ndr_print_uint32(ndr, "data_size", *r->out.data_size);

2737

}

2738

ndr->depth--;

2739

ndr_print_ptr(ndr, "data_length", r->out.data_length);

2740

ndr->depth++;

2741

if (r->out.data_length) {

2742

ndr_print_uint32(ndr, "data_length", *r->out.data_length);

2743

}

2744

ndr->depth--;

2745

ndr_print_WERROR(ndr, "result", r->out.result);

2746

ndr->depth--;

2747

}

2748

ndr->depth--;

2749

}

2750

2751

static enum ndr_err_code ndr_push_winreg_ReplaceKey(struct ndr_push *ndr, int flags, const struct winreg_ReplaceKey *r)

2752

{

2753

if (flags & NDR_IN) {

2754

}

2755

if (flags & NDR_OUT) {

2756

NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));

2757

}

2758

return NDR_ERR_SUCCESS;

2759

}

2760

2761

static enum ndr_err_code ndr_pull_winreg_ReplaceKey(struct ndr_pull *ndr, int flags, struct winreg_ReplaceKey *r)

2762

{

2763

if (flags & NDR_IN) {

2764

}

2765

if (flags & NDR_OUT) {

2766

NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));

2767

}

2768

return NDR_ERR_SUCCESS;

2769

}

2770

2771

_PUBLIC_ void ndr_print_winreg_ReplaceKey(struct ndr_print *ndr, const char *name, int flags, const struct winreg_ReplaceKey *r)

2772

{

2773

ndr_print_struct(ndr, name, "winreg_ReplaceKey");

2774

ndr->depth++;

2775

if (flags & NDR_SET_VALUES) {

2776

ndr->flags |= LIBNDR_PRINT_SET_VALUES;

2777

}

2778

if (flags & NDR_IN) {

2779

ndr_print_struct(ndr, "in", "winreg_ReplaceKey");

2780

ndr->depth++;

2781

ndr->depth--;

2782

}

2783

if (flags & NDR_OUT) {

2784

ndr_print_struct(ndr, "out", "winreg_ReplaceKey");

2785

ndr->depth++;

2786

ndr_print_WERROR(ndr, "result", r->out.result);

2787

ndr->depth--;

2788

}

2789

ndr->depth--;

2790

}

2791

2792

static enum ndr_err_code ndr_push_winreg_RestoreKey(struct ndr_push *ndr, int flags, const struct winreg_RestoreKey *r)

2793

{

2794

if (flags & NDR_IN) {

2795

if (r->in.handle == NULL) {

2796

return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");

2797

}

2798

NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));

2799

if (r->in.filename == NULL) {

2800

return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");

2801

}

2802

NDR_CHECK(ndr_push_winreg_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.filename));

2803

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.flags));

2804

}

2805

if (flags & NDR_OUT) {

2806

NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));

2807

}

2808

return NDR_ERR_SUCCESS;

2809

}

2810

2811

static enum ndr_err_code ndr_pull_winreg_RestoreKey(struct ndr_pull *ndr, int flags, struct winreg_RestoreKey *r)

2812

{

2813

TALLOC_CTX *_mem_save_handle_0;

2814

TALLOC_CTX *_mem_save_filename_0;

2815

if (flags & NDR_IN) {

2816

if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {

2817

NDR_PULL_ALLOC(ndr, r->in.handle);

2818

}

2819

_mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);

2820

NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);

2821

NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));

2822

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);

2823

if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {

2824

NDR_PULL_ALLOC(ndr, r->in.filename);

2825

}

2826

_mem_save_filename_0 = NDR_PULL_GET_MEM_CTX(ndr);

2827

NDR_PULL_SET_MEM_CTX(ndr, r->in.filename, LIBNDR_FLAG_REF_ALLOC);

2828

NDR_CHECK(ndr_pull_winreg_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.filename));

2829

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_filename_0, LIBNDR_FLAG_REF_ALLOC);

2830

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.flags));

2831

}

2832

if (flags & NDR_OUT) {

2833

NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));

2834

}

2835

return NDR_ERR_SUCCESS;

2836

}

2837

2838

_PUBLIC_ void ndr_print_winreg_RestoreKey(struct ndr_print *ndr, const char *name, int flags, const struct winreg_RestoreKey *r)

2839

{

2840

ndr_print_struct(ndr, name, "winreg_RestoreKey");

2841

ndr->depth++;

2842

if (flags & NDR_SET_VALUES) {

2843

ndr->flags |= LIBNDR_PRINT_SET_VALUES;

2844

}

2845

if (flags & NDR_IN) {

2846

ndr_print_struct(ndr, "in", "winreg_RestoreKey");

2847

ndr->depth++;

2848

ndr_print_ptr(ndr, "handle", r->in.handle);

2849

ndr->depth++;

2850

ndr_print_policy_handle(ndr, "handle", r->in.handle);

2851

ndr->depth--;

2852

ndr_print_ptr(ndr, "filename", r->in.filename);

2853

ndr->depth++;

2854

ndr_print_winreg_String(ndr, "filename", r->in.filename);

2855

ndr->depth--;

2856

ndr_print_uint32(ndr, "flags", r->in.flags);

2857

ndr->depth--;

2858

}

2859

if (flags & NDR_OUT) {

2860

ndr_print_struct(ndr, "out", "winreg_RestoreKey");

2861

ndr->depth++;

2862

ndr_print_WERROR(ndr, "result", r->out.result);

2863

ndr->depth--;

2864

}

2865

ndr->depth--;

2866

}

2867

2868

static enum ndr_err_code ndr_push_winreg_SaveKey(struct ndr_push *ndr, int flags, const struct winreg_SaveKey *r)

2869

{

2870

if (flags & NDR_IN) {

2871

if (r->in.handle == NULL) {

2872

return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");

2873

}

2874

NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));

2875

if (r->in.filename == NULL) {

2876

return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");

2877

}

2878

NDR_CHECK(ndr_push_winreg_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.filename));

2879

NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.sec_attrib));

2880

if (r->in.sec_attrib) {

2881

NDR_CHECK(ndr_push_KeySecurityAttribute(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.sec_attrib));

2882

}

2883

}

2884

if (flags & NDR_OUT) {

2885

NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));

2886

}

2887

return NDR_ERR_SUCCESS;

2888

}

2889

2890

static enum ndr_err_code ndr_pull_winreg_SaveKey(struct ndr_pull *ndr, int flags, struct winreg_SaveKey *r)

2891

{

2892

uint32_t _ptr_sec_attrib;

2893

TALLOC_CTX *_mem_save_handle_0;

2894

TALLOC_CTX *_mem_save_filename_0;

2895

TALLOC_CTX *_mem_save_sec_attrib_0;

2896

if (flags & NDR_IN) {

2897

if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {

2898

NDR_PULL_ALLOC(ndr, r->in.handle);

2899

}

2900

_mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);

2901

NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);

2902

NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));

2903

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);

2904

if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {

2905

NDR_PULL_ALLOC(ndr, r->in.filename);

2906

}

2907

_mem_save_filename_0 = NDR_PULL_GET_MEM_CTX(ndr);

2908

NDR_PULL_SET_MEM_CTX(ndr, r->in.filename, LIBNDR_FLAG_REF_ALLOC);

2909

NDR_CHECK(ndr_pull_winreg_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.filename));

2910

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_filename_0, LIBNDR_FLAG_REF_ALLOC);

2911

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_sec_attrib));

2912

if (_ptr_sec_attrib) {

2913

NDR_PULL_ALLOC(ndr, r->in.sec_attrib);

2914

} else {

2915

r->in.sec_attrib = NULL;

2916

}

2917

if (r->in.sec_attrib) {

2918

_mem_save_sec_attrib_0 = NDR_PULL_GET_MEM_CTX(ndr);

2919

NDR_PULL_SET_MEM_CTX(ndr, r->in.sec_attrib, 0);

2920

NDR_CHECK(ndr_pull_KeySecurityAttribute(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.sec_attrib));

2921

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sec_attrib_0, 0);

2922

}

2923

}

2924

if (flags & NDR_OUT) {

2925

NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));

2926

}

2927

return NDR_ERR_SUCCESS;

2928

}

2929

2930

_PUBLIC_ void ndr_print_winreg_SaveKey(struct ndr_print *ndr, const char *name, int flags, const struct winreg_SaveKey *r)

2931

{

2932

ndr_print_struct(ndr, name, "winreg_SaveKey");

2933

ndr->depth++;

2934

if (flags & NDR_SET_VALUES) {

2935

ndr->flags |= LIBNDR_PRINT_SET_VALUES;

2936

}

2937

if (flags & NDR_IN) {

2938

ndr_print_struct(ndr, "in", "winreg_SaveKey");

2939

ndr->depth++;

2940

ndr_print_ptr(ndr, "handle", r->in.handle);

2941

ndr->depth++;

2942

ndr_print_policy_handle(ndr, "handle", r->in.handle);

2943

ndr->depth--;

2944

ndr_print_ptr(ndr, "filename", r->in.filename);

2945

ndr->depth++;

2946

ndr_print_winreg_String(ndr, "filename", r->in.filename);

2947

ndr->depth--;

2948

ndr_print_ptr(ndr, "sec_attrib", r->in.sec_attrib);

2949

ndr->depth++;

2950

if (r->in.sec_attrib) {

2951

ndr_print_KeySecurityAttribute(ndr, "sec_attrib", r->in.sec_attrib);

2952

}

2953

ndr->depth--;

2954

ndr->depth--;

2955

}

2956

if (flags & NDR_OUT) {

2957

ndr_print_struct(ndr, "out", "winreg_SaveKey");

2958

ndr->depth++;

2959

ndr_print_WERROR(ndr, "result", r->out.result);

2960

ndr->depth--;

2961

}

2962

ndr->depth--;

2963

}

2964

2965

static enum ndr_err_code ndr_push_winreg_SetKeySecurity(struct ndr_push *ndr, int flags, const struct winreg_SetKeySecurity *r)

2966

{

2967

if (flags & NDR_IN) {

2968

if (r->in.handle == NULL) {

2969

return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");

2970

}

2971

NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));

2972

NDR_CHECK(ndr_push_security_secinfo(ndr, NDR_SCALARS, r->in.sec_info));

2973

if (r->in.sd == NULL) {

2974

return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");

2975

}

2976

NDR_CHECK(ndr_push_KeySecurityData(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.sd));

2977

}

2978

if (flags & NDR_OUT) {

2979

NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));

2980

}

2981

return NDR_ERR_SUCCESS;

2982

}

2983

2984

static enum ndr_err_code ndr_pull_winreg_SetKeySecurity(struct ndr_pull *ndr, int flags, struct winreg_SetKeySecurity *r)

2985

{

2986

TALLOC_CTX *_mem_save_handle_0;

2987

TALLOC_CTX *_mem_save_sd_0;

2988

if (flags & NDR_IN) {

2989

if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {

2990

NDR_PULL_ALLOC(ndr, r->in.handle);

2991

}

2992

_mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);

2993

NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);

2994

NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));

2995

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);

2996

NDR_CHECK(ndr_pull_security_secinfo(ndr, NDR_SCALARS, &r->in.sec_info));

2997

if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {

2998

NDR_PULL_ALLOC(ndr, r->in.sd);

2999

}

3000

_mem_save_sd_0 = NDR_PULL_GET_MEM_CTX(ndr);

3001

NDR_PULL_SET_MEM_CTX(ndr, r->in.sd, LIBNDR_FLAG_REF_ALLOC);

3002

NDR_CHECK(ndr_pull_KeySecurityData(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.sd));

3003

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sd_0, LIBNDR_FLAG_REF_ALLOC);

3004

}

3005

if (flags & NDR_OUT) {

3006

NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));

3007

}

3008

return NDR_ERR_SUCCESS;

3009

}

3010

3011

_PUBLIC_ void ndr_print_winreg_SetKeySecurity(struct ndr_print *ndr, const char *name, int flags, const struct winreg_SetKeySecurity *r)

3012

{

3013

ndr_print_struct(ndr, name, "winreg_SetKeySecurity");

3014

ndr->depth++;

3015

if (flags & NDR_SET_VALUES) {

3016

ndr->flags |= LIBNDR_PRINT_SET_VALUES;

3017

}

3018

if (flags & NDR_IN) {

3019

ndr_print_struct(ndr, "in", "winreg_SetKeySecurity");

3020

ndr->depth++;

3021

ndr_print_ptr(ndr, "handle", r->in.handle);

3022

ndr->depth++;

3023

ndr_print_policy_handle(ndr, "handle", r->in.handle);

3024

ndr->depth--;

3025

ndr_print_security_secinfo(ndr, "sec_info", r->in.sec_info);

3026

ndr_print_ptr(ndr, "sd", r->in.sd);

3027

ndr->depth++;

3028

ndr_print_KeySecurityData(ndr, "sd", r->in.sd);

3029

ndr->depth--;

3030

ndr->depth--;

3031

}

3032

if (flags & NDR_OUT) {

3033

ndr_print_struct(ndr, "out", "winreg_SetKeySecurity");

3034

ndr->depth++;

3035

ndr_print_WERROR(ndr, "result", r->out.result);

3036

ndr->depth--;

3037

}

3038

ndr->depth--;

3039

}

3040

3041

static enum ndr_err_code ndr_push_winreg_SetValue(struct ndr_push *ndr, int flags, const struct winreg_SetValue *r)

3042

{

3043

if (flags & NDR_IN) {

3044

if (r->in.handle == NULL) {

3045

return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");

3046

}

3047

NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));

3048

NDR_CHECK(ndr_push_winreg_String(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.name));

3049

NDR_CHECK(ndr_push_winreg_Type(ndr, NDR_SCALARS, r->in.type));

3050

if (r->in.data == NULL) {

3051

return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");

3052

}

3053

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.size));

3054

NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->in.data, r->in.size));

3055

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.size));

3056

}

3057

if (flags & NDR_OUT) {

3058

NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));

3059

}

3060

return NDR_ERR_SUCCESS;

3061

}

3062

3063

static enum ndr_err_code ndr_pull_winreg_SetValue(struct ndr_pull *ndr, int flags, struct winreg_SetValue *r)

3064

{

3065

TALLOC_CTX *_mem_save_handle_0;

3066

if (flags & NDR_IN) {

3067

if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {

3068

NDR_PULL_ALLOC(ndr, r->in.handle);

3069

}

3070

_mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);

3071

NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);

3072

NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));

3073

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);

3074

NDR_CHECK(ndr_pull_winreg_String(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.name));

3075

NDR_CHECK(ndr_pull_winreg_Type(ndr, NDR_SCALARS, &r->in.type));

3076

NDR_CHECK(ndr_pull_array_size(ndr, &r->in.data));

3077

if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {

3078

NDR_PULL_ALLOC_N(ndr, r->in.data, ndr_get_array_size(ndr, &r->in.data));

3079

}

3080

NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->in.data, ndr_get_array_size(ndr, &r->in.data)));

3081

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.size));

3082

if (r->in.data) {

3083

NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->in.data, r->in.size));

3084

}

3085

}

3086

if (flags & NDR_OUT) {

3087

NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));

3088

}

3089

return NDR_ERR_SUCCESS;

3090

}

3091

3092

_PUBLIC_ void ndr_print_winreg_SetValue(struct ndr_print *ndr, const char *name, int flags, const struct winreg_SetValue *r)

3093

{

3094

ndr_print_struct(ndr, name, "winreg_SetValue");

3095

ndr->depth++;

3096

if (flags & NDR_SET_VALUES) {

3097

ndr->flags |= LIBNDR_PRINT_SET_VALUES;

3098

}

3099

if (flags & NDR_IN) {

3100

ndr_print_struct(ndr, "in", "winreg_SetValue");

3101

ndr->depth++;

3102

ndr_print_ptr(ndr, "handle", r->in.handle);

3103

ndr->depth++;

3104

ndr_print_policy_handle(ndr, "handle", r->in.handle);

3105

ndr->depth--;

3106

ndr_print_winreg_String(ndr, "name", &r->in.name);

3107

ndr_print_winreg_Type(ndr, "type", r->in.type);

3108

ndr_print_ptr(ndr, "data", r->in.data);

3109

ndr->depth++;

3110

ndr_print_array_uint8(ndr, "data", r->in.data, r->in.size);

3111

ndr->depth--;

3112

ndr_print_uint32(ndr, "size", r->in.size);

3113

ndr->depth--;

3114

}

3115

if (flags & NDR_OUT) {

3116

ndr_print_struct(ndr, "out", "winreg_SetValue");

3117

ndr->depth++;

3118

ndr_print_WERROR(ndr, "result", r->out.result);

3119

ndr->depth--;

3120

}

3121

ndr->depth--;

3122

}

3123

3124

static enum ndr_err_code ndr_push_winreg_UnLoadKey(struct ndr_push *ndr, int flags, const struct winreg_UnLoadKey *r)

3125

{

3126

if (flags & NDR_IN) {

3127

}

3128

if (flags & NDR_OUT) {

3129

NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));

3130

}

3131

return NDR_ERR_SUCCESS;

3132

}

3133

3134

static enum ndr_err_code ndr_pull_winreg_UnLoadKey(struct ndr_pull *ndr, int flags, struct winreg_UnLoadKey *r)

3135

{

3136

if (flags & NDR_IN) {

3137

}

3138

if (flags & NDR_OUT) {

3139

NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));

3140

}

3141

return NDR_ERR_SUCCESS;

3142

}

3143

3144

_PUBLIC_ void ndr_print_winreg_UnLoadKey(struct ndr_print *ndr, const char *name, int flags, const struct winreg_UnLoadKey *r)

3145

{

3146

ndr_print_struct(ndr, name, "winreg_UnLoadKey");

3147

ndr->depth++;

3148

if (flags & NDR_SET_VALUES) {

3149

ndr->flags |= LIBNDR_PRINT_SET_VALUES;

3150

}

3151

if (flags & NDR_IN) {

3152

ndr_print_struct(ndr, "in", "winreg_UnLoadKey");

3153

ndr->depth++;

3154

ndr->depth--;

3155

}

3156

if (flags & NDR_OUT) {

3157

ndr_print_struct(ndr, "out", "winreg_UnLoadKey");

3158

ndr->depth++;

3159

ndr_print_WERROR(ndr, "result", r->out.result);

3160

ndr->depth--;

3161

}

3162

ndr->depth--;

3163

}

3164

3165

static enum ndr_err_code ndr_push_winreg_InitiateSystemShutdown(struct ndr_push *ndr, int flags, const struct winreg_InitiateSystemShutdown *r)

3166

{

3167

if (flags & NDR_IN) {

3168

NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.hostname));

3169

if (r->in.hostname) {

3170

NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, *r->in.hostname));

3171

}

3172

NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.message));

3173

if (r->in.message) {

3174

NDR_CHECK(ndr_push_lsa_StringLarge(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.message));

3175

}

3176

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.timeout));

3177

NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->in.force_apps));

3178

NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->in.do_reboot));

3179

}

3180

if (flags & NDR_OUT) {

3181

NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));

3182

}

3183

return NDR_ERR_SUCCESS;

3184

}

3185

3186

static enum ndr_err_code ndr_pull_winreg_InitiateSystemShutdown(struct ndr_pull *ndr, int flags, struct winreg_InitiateSystemShutdown *r)

3187

{

3188

uint32_t _ptr_hostname;

3189

uint32_t _ptr_message;

3190

TALLOC_CTX *_mem_save_hostname_0;

3191

TALLOC_CTX *_mem_save_message_0;

3192

if (flags & NDR_IN) {

3193

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_hostname));

3194

if (_ptr_hostname) {

3195

NDR_PULL_ALLOC(ndr, r->in.hostname);

3196

} else {

3197

r->in.hostname = NULL;

3198

}

3199

if (r->in.hostname) {

3200

_mem_save_hostname_0 = NDR_PULL_GET_MEM_CTX(ndr);

3201

NDR_PULL_SET_MEM_CTX(ndr, r->in.hostname, 0);

3202

NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, r->in.hostname));

3203

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_hostname_0, 0);

3204

}

3205

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_message));

3206

if (_ptr_message) {

3207

NDR_PULL_ALLOC(ndr, r->in.message);

3208

} else {

3209

r->in.message = NULL;

3210

}

3211

if (r->in.message) {

3212

_mem_save_message_0 = NDR_PULL_GET_MEM_CTX(ndr);

3213

NDR_PULL_SET_MEM_CTX(ndr, r->in.message, 0);

3214

NDR_CHECK(ndr_pull_lsa_StringLarge(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.message));

3215

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_message_0, 0);

3216

}

3217

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.timeout));

3218

NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->in.force_apps));

3219

NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->in.do_reboot));

3220

}

3221

if (flags & NDR_OUT) {

3222

NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));

3223

}

3224

return NDR_ERR_SUCCESS;

3225

}

3226

3227

_PUBLIC_ void ndr_print_winreg_InitiateSystemShutdown(struct ndr_print *ndr, const char *name, int flags, const struct winreg_InitiateSystemShutdown *r)

3228

{

3229

ndr_print_struct(ndr, name, "winreg_InitiateSystemShutdown");

3230

ndr->depth++;

3231

if (flags & NDR_SET_VALUES) {

3232

ndr->flags |= LIBNDR_PRINT_SET_VALUES;

3233

}

3234

if (flags & NDR_IN) {

3235

ndr_print_struct(ndr, "in", "winreg_InitiateSystemShutdown");

3236

ndr->depth++;

3237

ndr_print_ptr(ndr, "hostname", r->in.hostname);

3238

ndr->depth++;

3239

if (r->in.hostname) {

3240

ndr_print_uint16(ndr, "hostname", *r->in.hostname);

3241

}

3242

ndr->depth--;

3243

ndr_print_ptr(ndr, "message", r->in.message);

3244

ndr->depth++;

3245

if (r->in.message) {

3246

ndr_print_lsa_StringLarge(ndr, "message", r->in.message);

3247

}

3248

ndr->depth--;

3249

ndr_print_uint32(ndr, "timeout", r->in.timeout);

3250

ndr_print_uint8(ndr, "force_apps", r->in.force_apps);

3251

ndr_print_uint8(ndr, "do_reboot", r->in.do_reboot);

3252

ndr->depth--;

3253

}

3254

if (flags & NDR_OUT) {

3255

ndr_print_struct(ndr, "out", "winreg_InitiateSystemShutdown");

3256

ndr->depth++;

3257

ndr_print_WERROR(ndr, "result", r->out.result);

3258

ndr->depth--;

3259

}

3260

ndr->depth--;

3261

}

3262

3263

static enum ndr_err_code ndr_push_winreg_AbortSystemShutdown(struct ndr_push *ndr, int flags, const struct winreg_AbortSystemShutdown *r)

3264

{

3265

if (flags & NDR_IN) {

3266

NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server));

3267

if (r->in.server) {

3268

NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, *r->in.server));

3269

}

3270

}

3271

if (flags & NDR_OUT) {

3272

NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));

3273

}

3274

return NDR_ERR_SUCCESS;

3275

}

3276

3277

static enum ndr_err_code ndr_pull_winreg_AbortSystemShutdown(struct ndr_pull *ndr, int flags, struct winreg_AbortSystemShutdown *r)

3278

{

3279

uint32_t _ptr_server;

3280

TALLOC_CTX *_mem_save_server_0;

3281

if (flags & NDR_IN) {

3282

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server));

3283

if (_ptr_server) {

3284

NDR_PULL_ALLOC(ndr, r->in.server);

3285

} else {

3286

r->in.server = NULL;

3287

}

3288

if (r->in.server) {

3289

_mem_save_server_0 = NDR_PULL_GET_MEM_CTX(ndr);

3290

NDR_PULL_SET_MEM_CTX(ndr, r->in.server, 0);

3291

NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, r->in.server));

3292

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_0, 0);

3293

}

3294

}

3295

if (flags & NDR_OUT) {

3296

NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));

3297

}

3298

return NDR_ERR_SUCCESS;

3299

}

3300

3301

_PUBLIC_ void ndr_print_winreg_AbortSystemShutdown(struct ndr_print *ndr, const char *name, int flags, const struct winreg_AbortSystemShutdown *r)

3302

{

3303

ndr_print_struct(ndr, name, "winreg_AbortSystemShutdown");

3304

ndr->depth++;

3305

if (flags & NDR_SET_VALUES) {

3306

ndr->flags |= LIBNDR_PRINT_SET_VALUES;

3307

}

3308

if (flags & NDR_IN) {

3309

ndr_print_struct(ndr, "in", "winreg_AbortSystemShutdown");

3310

ndr->depth++;

3311

ndr_print_ptr(ndr, "server", r->in.server);

3312

ndr->depth++;

3313

if (r->in.server) {

3314

ndr_print_uint16(ndr, "server", *r->in.server);

3315

}

3316

ndr->depth--;

3317

ndr->depth--;

3318

}

3319

if (flags & NDR_OUT) {

3320

ndr_print_struct(ndr, "out", "winreg_AbortSystemShutdown");

3321

ndr->depth++;

3322

ndr_print_WERROR(ndr, "result", r->out.result);

3323

ndr->depth--;

3324

}

3325

ndr->depth--;

3326

}

3327

3328

_PUBLIC_ enum ndr_err_code ndr_push_winreg_GetVersion(struct ndr_push *ndr, int flags, const struct winreg_GetVersion *r)

3329

{

3330

if (flags & NDR_IN) {

3331

if (r->in.handle == NULL) {

3332

return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");

3333

}

3334

NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));

3335

}

3336

if (flags & NDR_OUT) {

3337

if (r->out.version == NULL) {

3338

return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");

3339

}

3340

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.version));

3341

NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));

3342

}

3343

return NDR_ERR_SUCCESS;

3344

}

3345

3346

_PUBLIC_ enum ndr_err_code ndr_pull_winreg_GetVersion(struct ndr_pull *ndr, int flags, struct winreg_GetVersion *r)

3347

{

3348

TALLOC_CTX *_mem_save_handle_0;

3349

TALLOC_CTX *_mem_save_version_0;

3350

if (flags & NDR_IN) {

3351

ZERO_STRUCT(r->out);

3352

3353

if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {

3354

NDR_PULL_ALLOC(ndr, r->in.handle);

3355

}

3356

_mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);

3357

NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);

3358

NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));

3359

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);

3360

NDR_PULL_ALLOC(ndr, r->out.version);

3361

ZERO_STRUCTP(r->out.version);

3362

}

3363

if (flags & NDR_OUT) {

3364

if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {

3365

NDR_PULL_ALLOC(ndr, r->out.version);

3366

}

3367

_mem_save_version_0 = NDR_PULL_GET_MEM_CTX(ndr);

3368

NDR_PULL_SET_MEM_CTX(ndr, r->out.version, LIBNDR_FLAG_REF_ALLOC);

3369

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.version));

3370

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_version_0, LIBNDR_FLAG_REF_ALLOC);

3371

NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));

3372

}

3373

return NDR_ERR_SUCCESS;

3374

}

3375

3376

_PUBLIC_ void ndr_print_winreg_GetVersion(struct ndr_print *ndr, const char *name, int flags, const struct winreg_GetVersion *r)

3377

{

3378

ndr_print_struct(ndr, name, "winreg_GetVersion");

3379

ndr->depth++;

3380

if (flags & NDR_SET_VALUES) {

3381

ndr->flags |= LIBNDR_PRINT_SET_VALUES;

3382

}

3383

if (flags & NDR_IN) {

3384

ndr_print_struct(ndr, "in", "winreg_GetVersion");

3385

ndr->depth++;

3386

ndr_print_ptr(ndr, "handle", r->in.handle);

3387

ndr->depth++;

3388

ndr_print_policy_handle(ndr, "handle", r->in.handle);

3389

ndr->depth--;

3390

ndr->depth--;

3391

}

3392

if (flags & NDR_OUT) {

3393

ndr_print_struct(ndr, "out", "winreg_GetVersion");

3394

ndr->depth++;

3395

ndr_print_ptr(ndr, "version", r->out.version);

3396

ndr->depth++;

3397

ndr_print_uint32(ndr, "version", *r->out.version);

3398

ndr->depth--;

3399

ndr_print_WERROR(ndr, "result", r->out.result);

3400

ndr->depth--;

3401

}

3402

ndr->depth--;

3403

}

3404

3405

static enum ndr_err_code ndr_push_winreg_OpenHKCC(struct ndr_push *ndr, int flags, const struct winreg_OpenHKCC *r)

3406

{

3407

if (flags & NDR_IN) {

3408

NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.system_name));

3409

if (r->in.system_name) {

3410

NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, *r->in.system_name));

3411

}

3412

NDR_CHECK(ndr_push_winreg_AccessMask(ndr, NDR_SCALARS, r->in.access_mask));

3413

}

3414

if (flags & NDR_OUT) {

3415

if (r->out.handle == NULL) {

3416

return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");

3417

}

3418

NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.handle));

3419

NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));

3420

}

3421

return NDR_ERR_SUCCESS;

3422

}

3423

3424

static enum ndr_err_code ndr_pull_winreg_OpenHKCC(struct ndr_pull *ndr, int flags, struct winreg_OpenHKCC *r)

3425

{

3426

uint32_t _ptr_system_name;

3427

TALLOC_CTX *_mem_save_system_name_0;

3428

TALLOC_CTX *_mem_save_handle_0;

3429

if (flags & NDR_IN) {

3430

ZERO_STRUCT(r->out);

3431

3432

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_system_name));

3433

if (_ptr_system_name) {

3434

NDR_PULL_ALLOC(ndr, r->in.system_name);

3435

} else {

3436

r->in.system_name = NULL;

3437

}

3438

if (r->in.system_name) {

3439

_mem_save_system_name_0 = NDR_PULL_GET_MEM_CTX(ndr);

3440

NDR_PULL_SET_MEM_CTX(ndr, r->in.system_name, 0);

3441

NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, r->in.system_name));

3442

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_system_name_0, 0);

3443

}

3444

NDR_CHECK(ndr_pull_winreg_AccessMask(ndr, NDR_SCALARS, &r->in.access_mask));

3445

NDR_PULL_ALLOC(ndr, r->out.handle);

3446

ZERO_STRUCTP(r->out.handle);

3447

}

3448

if (flags & NDR_OUT) {

3449

if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {

3450

NDR_PULL_ALLOC(ndr, r->out.handle);

3451

}

3452

_mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);

3453

NDR_PULL_SET_MEM_CTX(ndr, r->out.handle, LIBNDR_FLAG_REF_ALLOC);

3454

NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.handle));

3455

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);

3456

NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));

3457

}

3458

return NDR_ERR_SUCCESS;

3459

}

3460

3461

_PUBLIC_ void ndr_print_winreg_OpenHKCC(struct ndr_print *ndr, const char *name, int flags, const struct winreg_OpenHKCC *r)

3462

{

3463

ndr_print_struct(ndr, name, "winreg_OpenHKCC");

3464

ndr->depth++;

3465

if (flags & NDR_SET_VALUES) {

3466

ndr->flags |= LIBNDR_PRINT_SET_VALUES;

3467

}

3468

if (flags & NDR_IN) {

3469

ndr_print_struct(ndr, "in", "winreg_OpenHKCC");

3470

ndr->depth++;

3471

ndr_print_ptr(ndr, "system_name", r->in.system_name);

3472

ndr->depth++;

3473

if (r->in.system_name) {

3474

ndr_print_uint16(ndr, "system_name", *r->in.system_name);

3475

}

3476

ndr->depth--;

3477

ndr_print_winreg_AccessMask(ndr, "access_mask", r->in.access_mask);

3478

ndr->depth--;

3479

}

3480

if (flags & NDR_OUT) {

3481

ndr_print_struct(ndr, "out", "winreg_OpenHKCC");

3482

ndr->depth++;

3483

ndr_print_ptr(ndr, "handle", r->out.handle);

3484

ndr->depth++;

3485

ndr_print_policy_handle(ndr, "handle", r->out.handle);

3486

ndr->depth--;

3487

ndr_print_WERROR(ndr, "result", r->out.result);

3488

ndr->depth--;

3489

}

3490

ndr->depth--;

3491

}

3492

3493

static enum ndr_err_code ndr_push_winreg_OpenHKDD(struct ndr_push *ndr, int flags, const struct winreg_OpenHKDD *r)

3494

{

3495

if (flags & NDR_IN) {

3496

NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.system_name));

3497

if (r->in.system_name) {

3498

NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, *r->in.system_name));

3499

}

3500

NDR_CHECK(ndr_push_winreg_AccessMask(ndr, NDR_SCALARS, r->in.access_mask));

3501

}

3502

if (flags & NDR_OUT) {

3503

if (r->out.handle == NULL) {

3504

return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");

3505

}

3506

NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.handle));

3507

NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));

3508

}

3509

return NDR_ERR_SUCCESS;

3510

}

3511

3512

static enum ndr_err_code ndr_pull_winreg_OpenHKDD(struct ndr_pull *ndr, int flags, struct winreg_OpenHKDD *r)

3513

{

3514

uint32_t _ptr_system_name;

3515

TALLOC_CTX *_mem_save_system_name_0;

3516

TALLOC_CTX *_mem_save_handle_0;

3517

if (flags & NDR_IN) {

3518

ZERO_STRUCT(r->out);

3519

3520

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_system_name));

3521

if (_ptr_system_name) {

3522

NDR_PULL_ALLOC(ndr, r->in.system_name);

3523

} else {

3524

r->in.system_name = NULL;

3525

}

3526

if (r->in.system_name) {

3527

_mem_save_system_name_0 = NDR_PULL_GET_MEM_CTX(ndr);

3528

NDR_PULL_SET_MEM_CTX(ndr, r->in.system_name, 0);

3529

NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, r->in.system_name));

3530

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_system_name_0, 0);

3531

}

3532

NDR_CHECK(ndr_pull_winreg_AccessMask(ndr, NDR_SCALARS, &r->in.access_mask));

3533

NDR_PULL_ALLOC(ndr, r->out.handle);

3534

ZERO_STRUCTP(r->out.handle);

3535

}

3536

if (flags & NDR_OUT) {

3537

if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {

3538

NDR_PULL_ALLOC(ndr, r->out.handle);

3539

}

3540

_mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);

3541

NDR_PULL_SET_MEM_CTX(ndr, r->out.handle, LIBNDR_FLAG_REF_ALLOC);

3542

NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.handle));

3543

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);

3544

NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));

3545

}

3546

return NDR_ERR_SUCCESS;

3547

}

3548

3549

_PUBLIC_ void ndr_print_winreg_OpenHKDD(struct ndr_print *ndr, const char *name, int flags, const struct winreg_OpenHKDD *r)

3550

{

3551

ndr_print_struct(ndr, name, "winreg_OpenHKDD");

3552

ndr->depth++;

3553

if (flags & NDR_SET_VALUES) {

3554

ndr->flags |= LIBNDR_PRINT_SET_VALUES;

3555

}

3556

if (flags & NDR_IN) {

3557

ndr_print_struct(ndr, "in", "winreg_OpenHKDD");

3558

ndr->depth++;

3559

ndr_print_ptr(ndr, "system_name", r->in.system_name);

3560

ndr->depth++;

3561

if (r->in.system_name) {

3562

ndr_print_uint16(ndr, "system_name", *r->in.system_name);

3563

}

3564

ndr->depth--;

3565

ndr_print_winreg_AccessMask(ndr, "access_mask", r->in.access_mask);

3566

ndr->depth--;

3567

}

3568

if (flags & NDR_OUT) {

3569

ndr_print_struct(ndr, "out", "winreg_OpenHKDD");

3570

ndr->depth++;

3571

ndr_print_ptr(ndr, "handle", r->out.handle);

3572

ndr->depth++;

3573

ndr_print_policy_handle(ndr, "handle", r->out.handle);

3574

ndr->depth--;

3575

ndr_print_WERROR(ndr, "result", r->out.result);

3576

ndr->depth--;

3577

}

3578

ndr->depth--;

3579

}

3580

3581

_PUBLIC_ enum ndr_err_code ndr_push_winreg_QueryMultipleValues(struct ndr_push *ndr, int flags, const struct winreg_QueryMultipleValues *r)

3582

{

3583

uint32_t cntr_values_1;

3584

if (flags & NDR_IN) {

3585

if (r->in.key_handle == NULL) {

3586

return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");

3587

}

3588

NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.key_handle));

3589

if (r->in.values == NULL) {

3590

return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");

3591

}

3592

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.num_values));

3593

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

3594

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.num_values));

3595

for (cntr_values_1 = 0; cntr_values_1 < r->in.num_values; cntr_values_1++) {

3596

NDR_CHECK(ndr_push_QueryMultipleValue(ndr, NDR_SCALARS, &r->in.values[cntr_values_1]));

3597

}

3598

for (cntr_values_1 = 0; cntr_values_1 < r->in.num_values; cntr_values_1++) {

3599

NDR_CHECK(ndr_push_QueryMultipleValue(ndr, NDR_BUFFERS, &r->in.values[cntr_values_1]));

3600

}

3601

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.num_values));

3602

NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));

3603

if (r->in.buffer) {

3604

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->in.buffer_size));

3605

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

3606

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->in.buffer_size));

3607

NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->in.buffer, *r->in.buffer_size));

3608

}

3609

if (r->in.buffer_size == NULL) {

3610

return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");

3611

}

3612

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->in.buffer_size));

3613

}

3614

if (flags & NDR_OUT) {

3615

if (r->out.values == NULL) {

3616

return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");

3617

}

3618

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.num_values));

3619

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

3620

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.num_values));

3621

for (cntr_values_1 = 0; cntr_values_1 < r->in.num_values; cntr_values_1++) {

3622

NDR_CHECK(ndr_push_QueryMultipleValue(ndr, NDR_SCALARS, &r->out.values[cntr_values_1]));

3623

}

3624

for (cntr_values_1 = 0; cntr_values_1 < r->in.num_values; cntr_values_1++) {

3625

NDR_CHECK(ndr_push_QueryMultipleValue(ndr, NDR_BUFFERS, &r->out.values[cntr_values_1]));

3626

}

3627

NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.buffer));

3628

if (r->out.buffer) {

3629

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.buffer_size));

3630

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

3631

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.buffer_size));

3632

NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->out.buffer, *r->out.buffer_size));

3633

}

3634

if (r->out.buffer_size == NULL) {

3635

return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");

3636

}

3637

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.buffer_size));

3638

NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));

3639

}

3640

return NDR_ERR_SUCCESS;

3641

}

3642

3643

_PUBLIC_ enum ndr_err_code ndr_pull_winreg_QueryMultipleValues(struct ndr_pull *ndr, int flags, struct winreg_QueryMultipleValues *r)

3644

{

3645

uint32_t cntr_values_1;

3646

uint32_t _ptr_buffer;

3647

TALLOC_CTX *_mem_save_key_handle_0;

3648

TALLOC_CTX *_mem_save_values_1;

3649

TALLOC_CTX *_mem_save_buffer_0;

3650

TALLOC_CTX *_mem_save_buffer_size_0;

3651

if (flags & NDR_IN) {

3652

ZERO_STRUCT(r->out);

3653

3654

if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {

3655

NDR_PULL_ALLOC(ndr, r->in.key_handle);

3656

}

3657

_mem_save_key_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);

3658

NDR_PULL_SET_MEM_CTX(ndr, r->in.key_handle, LIBNDR_FLAG_REF_ALLOC);

3659

NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.key_handle));

3660

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_key_handle_0, LIBNDR_FLAG_REF_ALLOC);

3661

NDR_CHECK(ndr_pull_array_size(ndr, &r->in.values));

3662

NDR_CHECK(ndr_pull_array_length(ndr, &r->in.values));

3663

if (ndr_get_array_length(ndr, &r->in.values) > ndr_get_array_size(ndr, &r->in.values)) {

3664

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.values), ndr_get_array_length(ndr, &r->in.values));

3665

}

3666

if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {

3667

NDR_PULL_ALLOC_N(ndr, r->in.values, ndr_get_array_size(ndr, &r->in.values));

3668

}

3669

memcpy(r->out.values, r->in.values, (ndr_get_array_size(ndr, &r->in.values)) * sizeof(*r->in.values));

3670

_mem_save_values_1 = NDR_PULL_GET_MEM_CTX(ndr);

3671

NDR_PULL_SET_MEM_CTX(ndr, r->in.values, 0);

3672

for (cntr_values_1 = 0; cntr_values_1 < r->in.num_values; cntr_values_1++) {

3673

NDR_CHECK(ndr_pull_QueryMultipleValue(ndr, NDR_SCALARS, &r->in.values[cntr_values_1]));

3674

}

3675

for (cntr_values_1 = 0; cntr_values_1 < r->in.num_values; cntr_values_1++) {

3676

NDR_CHECK(ndr_pull_QueryMultipleValue(ndr, NDR_BUFFERS, &r->in.values[cntr_values_1]));

3677

}

3678

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_values_1, 0);

3679

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.num_values));

3680

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));

3681

if (_ptr_buffer) {

3682

NDR_PULL_ALLOC(ndr, r->in.buffer);

3683

} else {

3684

r->in.buffer = NULL;

3685

}

3686

if (r->in.buffer) {

3687

_mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);

3688

NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);

3689

NDR_CHECK(ndr_pull_array_size(ndr, &r->in.buffer));

3690

NDR_CHECK(ndr_pull_array_length(ndr, &r->in.buffer));

3691

if (ndr_get_array_length(ndr, &r->in.buffer) > ndr_get_array_size(ndr, &r->in.buffer)) {

3692

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.buffer), ndr_get_array_length(ndr, &r->in.buffer));

3693

}

3694

NDR_PULL_ALLOC_N(ndr, r->in.buffer, ndr_get_array_size(ndr, &r->in.buffer));

3695

NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->in.buffer, ndr_get_array_length(ndr, &r->in.buffer)));

3696

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);

3697

}

3698

if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {

3699

NDR_PULL_ALLOC(ndr, r->in.buffer_size);

3700

}

3701

_mem_save_buffer_size_0 = NDR_PULL_GET_MEM_CTX(ndr);

3702

NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer_size, LIBNDR_FLAG_REF_ALLOC);

3703

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->in.buffer_size));

3704

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_size_0, LIBNDR_FLAG_REF_ALLOC);

3705

NDR_PULL_ALLOC_N(ndr, r->out.values, r->in.num_values);

3706

memcpy(r->out.values, r->in.values, (r->in.num_values) * sizeof(*r->in.values));

3707

NDR_PULL_ALLOC(ndr, r->out.buffer_size);

3708

*r->out.buffer_size = *r->in.buffer_size;

3709

if (r->in.values) {

3710

NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->in.values, r->in.num_values));

3711

}

3712

if (r->in.values) {

3713

NDR_CHECK(ndr_check_array_length(ndr, (void*)&r->in.values, r->in.num_values));

3714

}

3715

if (r->in.buffer) {

3716

NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->in.buffer, *r->in.buffer_size));

3717

}

3718

if (r->in.buffer) {

3719

NDR_CHECK(ndr_check_array_length(ndr, (void*)&r->in.buffer, *r->in.buffer_size));

3720

}

3721

}

3722

if (flags & NDR_OUT) {

3723

NDR_CHECK(ndr_pull_array_size(ndr, &r->out.values));

3724

NDR_CHECK(ndr_pull_array_length(ndr, &r->out.values));

3725

if (ndr_get_array_length(ndr, &r->out.values) > ndr_get_array_size(ndr, &r->out.values)) {

3726

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

3727

}

3728

if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {

3729

NDR_PULL_ALLOC_N(ndr, r->out.values, ndr_get_array_size(ndr, &r->out.values));

3730

}

3731

memcpy(r->out.values, r->in.values, (ndr_get_array_size(ndr, &r->out.values)) * sizeof(*r->in.values));

3732

_mem_save_values_1 = NDR_PULL_GET_MEM_CTX(ndr);

3733

NDR_PULL_SET_MEM_CTX(ndr, r->out.values, 0);

3734

for (cntr_values_1 = 0; cntr_values_1 < r->in.num_values; cntr_values_1++) {

3735

NDR_CHECK(ndr_pull_QueryMultipleValue(ndr, NDR_SCALARS, &r->out.values[cntr_values_1]));

3736

}

3737

for (cntr_values_1 = 0; cntr_values_1 < r->in.num_values; cntr_values_1++) {

3738

NDR_CHECK(ndr_pull_QueryMultipleValue(ndr, NDR_BUFFERS, &r->out.values[cntr_values_1]));

3739

}

3740

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_values_1, 0);

3741

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));

3742

if (_ptr_buffer) {

3743

NDR_PULL_ALLOC(ndr, r->out.buffer);

3744

} else {

3745

r->out.buffer = NULL;

3746

}

3747

if (r->out.buffer) {

3748

_mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);

3749

NDR_PULL_SET_MEM_CTX(ndr, r->out.buffer, 0);

3750

NDR_CHECK(ndr_pull_array_size(ndr, &r->out.buffer));

3751

NDR_CHECK(ndr_pull_array_length(ndr, &r->out.buffer));

3752

if (ndr_get_array_length(ndr, &r->out.buffer) > ndr_get_array_size(ndr, &r->out.buffer)) {

3753

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

3754

}

3755

NDR_PULL_ALLOC_N(ndr, r->out.buffer, ndr_get_array_size(ndr, &r->out.buffer));

3756

NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->out.buffer, ndr_get_array_length(ndr, &r->out.buffer)));

3757

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);

3758

}

3759

if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {

3760

NDR_PULL_ALLOC(ndr, r->out.buffer_size);

3761

}

3762

_mem_save_buffer_size_0 = NDR_PULL_GET_MEM_CTX(ndr);

3763

NDR_PULL_SET_MEM_CTX(ndr, r->out.buffer_size, LIBNDR_FLAG_REF_ALLOC);

3764

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.buffer_size));

3765

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_size_0, LIBNDR_FLAG_REF_ALLOC);

3766

NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));

3767

if (r->out.values) {

3768

NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->out.values, r->in.num_values));

3769

}

3770

if (r->out.values) {

3771

NDR_CHECK(ndr_check_array_length(ndr, (void*)&r->out.values, r->in.num_values));

3772

}

3773

if (r->out.buffer) {

3774

NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->out.buffer, *r->out.buffer_size));

3775

}

3776

if (r->out.buffer) {

3777

NDR_CHECK(ndr_check_array_length(ndr, (void*)&r->out.buffer, *r->out.buffer_size));

3778

}

3779

}

3780

return NDR_ERR_SUCCESS;

3781

}

3782

3783

_PUBLIC_ void ndr_print_winreg_QueryMultipleValues(struct ndr_print *ndr, const char *name, int flags, const struct winreg_QueryMultipleValues *r)

3784

{

3785

uint32_t cntr_values_1;

3786

ndr_print_struct(ndr, name, "winreg_QueryMultipleValues");

3787

ndr->depth++;

3788

if (flags & NDR_SET_VALUES) {

3789

ndr->flags |= LIBNDR_PRINT_SET_VALUES;

3790

}

3791

if (flags & NDR_IN) {

3792

ndr_print_struct(ndr, "in", "winreg_QueryMultipleValues");

3793

ndr->depth++;

3794

ndr_print_ptr(ndr, "key_handle", r->in.key_handle);

3795

ndr->depth++;

3796

ndr_print_policy_handle(ndr, "key_handle", r->in.key_handle);

3797

ndr->depth--;

3798

ndr_print_ptr(ndr, "values", r->in.values);

3799

ndr->depth++;

3800

ndr->print(ndr, "%s: ARRAY(%d)", "values", (int)r->in.num_values);

3801

ndr->depth++;

3802

for (cntr_values_1=0;cntr_values_1<r->in.num_values;cntr_values_1++) {

3803

char *idx_1=NULL;

3804

if (asprintf(&idx_1, "[%d]", cntr_values_1) != -1) {

3805

ndr_print_QueryMultipleValue(ndr, "values", &r->in.values[cntr_values_1]);

3806

free(idx_1);

3807

}

3808

}

3809

ndr->depth--;

3810

ndr->depth--;

3811

ndr_print_uint32(ndr, "num_values", r->in.num_values);

3812

ndr_print_ptr(ndr, "buffer", r->in.buffer);

3813

ndr->depth++;

3814

if (r->in.buffer) {

3815

ndr_print_array_uint8(ndr, "buffer", r->in.buffer, *r->in.buffer_size);

3816

}

3817

ndr->depth--;

3818

ndr_print_ptr(ndr, "buffer_size", r->in.buffer_size);

3819

ndr->depth++;

3820

ndr_print_uint32(ndr, "buffer_size", *r->in.buffer_size);

3821

ndr->depth--;

3822

ndr->depth--;

3823

}

3824

if (flags & NDR_OUT) {

3825

ndr_print_struct(ndr, "out", "winreg_QueryMultipleValues");

3826

ndr->depth++;

3827

ndr_print_ptr(ndr, "values", r->out.values);

3828

ndr->depth++;

3829

ndr->print(ndr, "%s: ARRAY(%d)", "values", (int)r->in.num_values);

3830

ndr->depth++;

3831

for (cntr_values_1=0;cntr_values_1<r->in.num_values;cntr_values_1++) {

3832

char *idx_1=NULL;

3833

if (asprintf(&idx_1, "[%d]", cntr_values_1) != -1) {

3834

ndr_print_QueryMultipleValue(ndr, "values", &r->out.values[cntr_values_1]);

3835

free(idx_1);

3836

}

3837

}

3838

ndr->depth--;

3839

ndr->depth--;

3840

ndr_print_ptr(ndr, "buffer", r->out.buffer);

3841

ndr->depth++;

3842

if (r->out.buffer) {

3843

ndr_print_array_uint8(ndr, "buffer", r->out.buffer, *r->out.buffer_size);

3844

}

3845

ndr->depth--;

3846

ndr_print_ptr(ndr, "buffer_size", r->out.buffer_size);

3847

ndr->depth++;

3848

ndr_print_uint32(ndr, "buffer_size", *r->out.buffer_size);

3849

ndr->depth--;

3850

ndr_print_WERROR(ndr, "result", r->out.result);

3851

ndr->depth--;

3852

}

3853

ndr->depth--;

3854

}

3855

3856

static enum ndr_err_code ndr_push_winreg_InitiateSystemShutdownEx(struct ndr_push *ndr, int flags, const struct winreg_InitiateSystemShutdownEx *r)

3857

{

3858

if (flags & NDR_IN) {

3859

NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.hostname));

3860

if (r->in.hostname) {

3861

NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, *r->in.hostname));

3862

}

3863

NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.message));

3864

if (r->in.message) {

3865

NDR_CHECK(ndr_push_lsa_StringLarge(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.message));

3866

}

3867

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.timeout));

3868

NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->in.force_apps));

3869

NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->in.do_reboot));

3870

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.reason));

3871

}

3872

if (flags & NDR_OUT) {

3873

NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));

3874

}

3875

return NDR_ERR_SUCCESS;

3876

}

3877

3878

static enum ndr_err_code ndr_pull_winreg_InitiateSystemShutdownEx(struct ndr_pull *ndr, int flags, struct winreg_InitiateSystemShutdownEx *r)

3879

{

3880

uint32_t _ptr_hostname;

3881

uint32_t _ptr_message;

3882

TALLOC_CTX *_mem_save_hostname_0;

3883

TALLOC_CTX *_mem_save_message_0;

3884

if (flags & NDR_IN) {

3885

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_hostname));

3886

if (_ptr_hostname) {

3887

NDR_PULL_ALLOC(ndr, r->in.hostname);

3888

} else {

3889

r->in.hostname = NULL;

3890

}

3891

if (r->in.hostname) {

3892

_mem_save_hostname_0 = NDR_PULL_GET_MEM_CTX(ndr);

3893

NDR_PULL_SET_MEM_CTX(ndr, r->in.hostname, 0);

3894

NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, r->in.hostname));

3895

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_hostname_0, 0);

3896

}

3897

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_message));

3898

if (_ptr_message) {

3899

NDR_PULL_ALLOC(ndr, r->in.message);

3900

} else {

3901

r->in.message = NULL;

3902

}

3903

if (r->in.message) {

3904

_mem_save_message_0 = NDR_PULL_GET_MEM_CTX(ndr);

3905

NDR_PULL_SET_MEM_CTX(ndr, r->in.message, 0);

3906

NDR_CHECK(ndr_pull_lsa_StringLarge(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.message));

3907

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_message_0, 0);

3908

}

3909

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.timeout));

3910

NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->in.force_apps));

3911

NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->in.do_reboot));

3912

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.reason));

3913

}

3914

if (flags & NDR_OUT) {

3915

NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));

3916

}

3917

return NDR_ERR_SUCCESS;

3918

}

3919

3920

_PUBLIC_ void ndr_print_winreg_InitiateSystemShutdownEx(struct ndr_print *ndr, const char *name, int flags, const struct winreg_InitiateSystemShutdownEx *r)

3921

{

3922

ndr_print_struct(ndr, name, "winreg_InitiateSystemShutdownEx");

3923

ndr->depth++;

3924

if (flags & NDR_SET_VALUES) {

3925

ndr->flags |= LIBNDR_PRINT_SET_VALUES;

3926

}

3927

if (flags & NDR_IN) {

3928

ndr_print_struct(ndr, "in", "winreg_InitiateSystemShutdownEx");

3929

ndr->depth++;

3930

ndr_print_ptr(ndr, "hostname", r->in.hostname);

3931

ndr->depth++;

3932

if (r->in.hostname) {

3933

ndr_print_uint16(ndr, "hostname", *r->in.hostname);

3934

}

3935

ndr->depth--;

3936

ndr_print_ptr(ndr, "message", r->in.message);

3937

ndr->depth++;

3938

if (r->in.message) {

3939

ndr_print_lsa_StringLarge(ndr, "message", r->in.message);

3940

}

3941

ndr->depth--;

3942

ndr_print_uint32(ndr, "timeout", r->in.timeout);

3943

ndr_print_uint8(ndr, "force_apps", r->in.force_apps);

3944

ndr_print_uint8(ndr, "do_reboot", r->in.do_reboot);

3945

ndr_print_uint32(ndr, "reason", r->in.reason);

3946

ndr->depth--;

3947

}

3948

if (flags & NDR_OUT) {

3949

ndr_print_struct(ndr, "out", "winreg_InitiateSystemShutdownEx");

3950

ndr->depth++;

3951

ndr_print_WERROR(ndr, "result", r->out.result);

3952

ndr->depth--;

3953

}

3954

ndr->depth--;

3955

}

3956

3957

static enum ndr_err_code ndr_push_winreg_SaveKeyEx(struct ndr_push *ndr, int flags, const struct winreg_SaveKeyEx *r)

3958

{

3959

if (flags & NDR_IN) {

3960

}

3961

if (flags & NDR_OUT) {

3962

NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));

3963

}

3964

return NDR_ERR_SUCCESS;

3965

}

3966

3967

static enum ndr_err_code ndr_pull_winreg_SaveKeyEx(struct ndr_pull *ndr, int flags, struct winreg_SaveKeyEx *r)

3968

{

3969

if (flags & NDR_IN) {

3970

}

3971

if (flags & NDR_OUT) {

3972

NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));

3973

}

3974

return NDR_ERR_SUCCESS;

3975

}

3976

3977

_PUBLIC_ void ndr_print_winreg_SaveKeyEx(struct ndr_print *ndr, const char *name, int flags, const struct winreg_SaveKeyEx *r)

3978

{

3979

ndr_print_struct(ndr, name, "winreg_SaveKeyEx");

3980

ndr->depth++;

3981

if (flags & NDR_SET_VALUES) {

3982

ndr->flags |= LIBNDR_PRINT_SET_VALUES;

3983

}

3984

if (flags & NDR_IN) {

3985

ndr_print_struct(ndr, "in", "winreg_SaveKeyEx");

3986

ndr->depth++;

3987

ndr->depth--;

3988

}

3989

if (flags & NDR_OUT) {

3990

ndr_print_struct(ndr, "out", "winreg_SaveKeyEx");

3991

ndr->depth++;

3992

ndr_print_WERROR(ndr, "result", r->out.result);

3993

ndr->depth--;

3994

}

3995

ndr->depth--;

3996

}

3997

3998

static enum ndr_err_code ndr_push_winreg_OpenHKPT(struct ndr_push *ndr, int flags, const struct winreg_OpenHKPT *r)

3999

{

4000

if (flags & NDR_IN) {

4001

NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.system_name));

4002

if (r->in.system_name) {

4003

NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, *r->in.system_name));

4004

}

4005

NDR_CHECK(ndr_push_winreg_AccessMask(ndr, NDR_SCALARS, r->in.access_mask));

4006

}

4007

if (flags & NDR_OUT) {

4008

if (r->out.handle == NULL) {

4009

return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");

4010

}

4011

NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.handle));

4012

NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));

4013

}

4014

return NDR_ERR_SUCCESS;

4015

}

4016

4017

static enum ndr_err_code ndr_pull_winreg_OpenHKPT(struct ndr_pull *ndr, int flags, struct winreg_OpenHKPT *r)

4018

{

4019

uint32_t _ptr_system_name;

4020

TALLOC_CTX *_mem_save_system_name_0;

4021

TALLOC_CTX *_mem_save_handle_0;

4022

if (flags & NDR_IN) {

4023

ZERO_STRUCT(r->out);

4024

4025

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_system_name));

4026

if (_ptr_system_name) {

4027

NDR_PULL_ALLOC(ndr, r->in.system_name);

4028

} else {

4029

r->in.system_name = NULL;

4030

}

4031

if (r->in.system_name) {

4032

_mem_save_system_name_0 = NDR_PULL_GET_MEM_CTX(ndr);

4033

NDR_PULL_SET_MEM_CTX(ndr, r->in.system_name, 0);

4034

NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, r->in.system_name));

4035

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_system_name_0, 0);

4036

}

4037

NDR_CHECK(ndr_pull_winreg_AccessMask(ndr, NDR_SCALARS, &r->in.access_mask));

4038

NDR_PULL_ALLOC(ndr, r->out.handle);

4039

ZERO_STRUCTP(r->out.handle);

4040

}

4041

if (flags & NDR_OUT) {

4042

if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {

4043

NDR_PULL_ALLOC(ndr, r->out.handle);

4044

}

4045

_mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);

4046

NDR_PULL_SET_MEM_CTX(ndr, r->out.handle, LIBNDR_FLAG_REF_ALLOC);

4047

NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.handle));

4048

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);

4049

NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));

4050

}

4051

return NDR_ERR_SUCCESS;

4052

}

4053

4054

_PUBLIC_ void ndr_print_winreg_OpenHKPT(struct ndr_print *ndr, const char *name, int flags, const struct winreg_OpenHKPT *r)

4055

{

4056

ndr_print_struct(ndr, name, "winreg_OpenHKPT");

4057

ndr->depth++;

4058

if (flags & NDR_SET_VALUES) {

4059

ndr->flags |= LIBNDR_PRINT_SET_VALUES;

4060

}

4061

if (flags & NDR_IN) {

4062

ndr_print_struct(ndr, "in", "winreg_OpenHKPT");

4063

ndr->depth++;

4064

ndr_print_ptr(ndr, "system_name", r->in.system_name);

4065

ndr->depth++;

4066

if (r->in.system_name) {

4067

ndr_print_uint16(ndr, "system_name", *r->in.system_name);

4068

}

4069

ndr->depth--;

4070

ndr_print_winreg_AccessMask(ndr, "access_mask", r->in.access_mask);

4071

ndr->depth--;

4072

}

4073

if (flags & NDR_OUT) {

4074

ndr_print_struct(ndr, "out", "winreg_OpenHKPT");

4075

ndr->depth++;

4076

ndr_print_ptr(ndr, "handle", r->out.handle);

4077

ndr->depth++;

4078

ndr_print_policy_handle(ndr, "handle", r->out.handle);

4079

ndr->depth--;

4080

ndr_print_WERROR(ndr, "result", r->out.result);

4081

ndr->depth--;

4082

}

4083

ndr->depth--;

4084

}

4085

4086

static enum ndr_err_code ndr_push_winreg_OpenHKPN(struct ndr_push *ndr, int flags, const struct winreg_OpenHKPN *r)

4087

{

4088

if (flags & NDR_IN) {

4089

NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.system_name));

4090

if (r->in.system_name) {

4091

NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, *r->in.system_name));

4092

}

4093

NDR_CHECK(ndr_push_winreg_AccessMask(ndr, NDR_SCALARS, r->in.access_mask));

4094

}

4095

if (flags & NDR_OUT) {

4096

if (r->out.handle == NULL) {

4097

return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");

4098

}

4099

NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.handle));

4100

NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));

4101

}

4102

return NDR_ERR_SUCCESS;

4103

}

4104

4105

static enum ndr_err_code ndr_pull_winreg_OpenHKPN(struct ndr_pull *ndr, int flags, struct winreg_OpenHKPN *r)

4106

{

4107

uint32_t _ptr_system_name;

4108

TALLOC_CTX *_mem_save_system_name_0;

4109

TALLOC_CTX *_mem_save_handle_0;

4110

if (flags & NDR_IN) {

4111

ZERO_STRUCT(r->out);

4112

4113

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_system_name));

4114

if (_ptr_system_name) {

4115

NDR_PULL_ALLOC(ndr, r->in.system_name);

4116

} else {

4117

r->in.system_name = NULL;

4118

}

4119

if (r->in.system_name) {

4120

_mem_save_system_name_0 = NDR_PULL_GET_MEM_CTX(ndr);

4121

NDR_PULL_SET_MEM_CTX(ndr, r->in.system_name, 0);

4122

NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, r->in.system_name));

4123

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_system_name_0, 0);

4124

}

4125

NDR_CHECK(ndr_pull_winreg_AccessMask(ndr, NDR_SCALARS, &r->in.access_mask));

4126

NDR_PULL_ALLOC(ndr, r->out.handle);

4127

ZERO_STRUCTP(r->out.handle);

4128

}

4129

if (flags & NDR_OUT) {

4130

if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {

4131

NDR_PULL_ALLOC(ndr, r->out.handle);

4132

}

4133

_mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);

4134

NDR_PULL_SET_MEM_CTX(ndr, r->out.handle, LIBNDR_FLAG_REF_ALLOC);

4135

NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.handle));

4136

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);

4137

NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));

4138

}

4139

return NDR_ERR_SUCCESS;

4140

}

4141

4142

_PUBLIC_ void ndr_print_winreg_OpenHKPN(struct ndr_print *ndr, const char *name, int flags, const struct winreg_OpenHKPN *r)

4143

{

4144

ndr_print_struct(ndr, name, "winreg_OpenHKPN");

4145

ndr->depth++;

4146

if (flags & NDR_SET_VALUES) {

4147

ndr->flags |= LIBNDR_PRINT_SET_VALUES;

4148

}

4149

if (flags & NDR_IN) {

4150

ndr_print_struct(ndr, "in", "winreg_OpenHKPN");

4151

ndr->depth++;

4152

ndr_print_ptr(ndr, "system_name", r->in.system_name);

4153

ndr->depth++;

4154

if (r->in.system_name) {

4155

ndr_print_uint16(ndr, "system_name", *r->in.system_name);

4156

}

4157

ndr->depth--;

4158

ndr_print_winreg_AccessMask(ndr, "access_mask", r->in.access_mask);

4159

ndr->depth--;

4160

}

4161

if (flags & NDR_OUT) {

4162

ndr_print_struct(ndr, "out", "winreg_OpenHKPN");

4163

ndr->depth++;

4164

ndr_print_ptr(ndr, "handle", r->out.handle);

4165

ndr->depth++;

4166

ndr_print_policy_handle(ndr, "handle", r->out.handle);

4167

ndr->depth--;

4168

ndr_print_WERROR(ndr, "result", r->out.result);

4169

ndr->depth--;

4170

}

4171

ndr->depth--;

4172

}

4173

4174

static enum ndr_err_code ndr_push_winreg_QueryMultipleValues2(struct ndr_push *ndr, int flags, const struct winreg_QueryMultipleValues2 *r)

4175

{

4176

if (flags & NDR_IN) {

4177

}

4178

if (flags & NDR_OUT) {

4179

NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));

4180

}

4181

return NDR_ERR_SUCCESS;

4182

}

4183

4184

static enum ndr_err_code ndr_pull_winreg_QueryMultipleValues2(struct ndr_pull *ndr, int flags, struct winreg_QueryMultipleValues2 *r)

4185

{

4186

if (flags & NDR_IN) {

4187

}

4188

if (flags & NDR_OUT) {

4189

NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));

4190

}

4191

return NDR_ERR_SUCCESS;

4192

}

4193

4194

_PUBLIC_ void ndr_print_winreg_QueryMultipleValues2(struct ndr_print *ndr, const char *name, int flags, const struct winreg_QueryMultipleValues2 *r)

4195

{

4196

ndr_print_struct(ndr, name, "winreg_QueryMultipleValues2");

4197

ndr->depth++;

4198

if (flags & NDR_SET_VALUES) {

4199

ndr->flags |= LIBNDR_PRINT_SET_VALUES;

4200

}

4201

if (flags & NDR_IN) {

4202

ndr_print_struct(ndr, "in", "winreg_QueryMultipleValues2");

4203

ndr->depth++;

4204

ndr->depth--;

4205

}

4206

if (flags & NDR_OUT) {

4207

ndr_print_struct(ndr, "out", "winreg_QueryMultipleValues2");

4208

ndr->depth++;

4209

ndr_print_WERROR(ndr, "result", r->out.result);

4210

ndr->depth--;

4211

}

4212

ndr->depth--;

4213

}

4214

4215

static const struct ndr_interface_call winreg_calls[] = {

4216

{

4217

"winreg_OpenHKCR",

4218

sizeof(struct winreg_OpenHKCR),

4219

(ndr_push_flags_fn_t) ndr_push_winreg_OpenHKCR,

4220

(ndr_pull_flags_fn_t) ndr_pull_winreg_OpenHKCR,

4221

(ndr_print_function_t) ndr_print_winreg_OpenHKCR,

4222

false,

4223

4224

{

4225

"winreg_OpenHKCU",

4226

sizeof(struct winreg_OpenHKCU),

4227

(ndr_push_flags_fn_t) ndr_push_winreg_OpenHKCU,

4228

(ndr_pull_flags_fn_t) ndr_pull_winreg_OpenHKCU,

4229

(ndr_print_function_t) ndr_print_winreg_OpenHKCU,

4230

false,

4231

4232

{

4233

"winreg_OpenHKLM",

4234

sizeof(struct winreg_OpenHKLM),

4235

(ndr_push_flags_fn_t) ndr_push_winreg_OpenHKLM,

4236

(ndr_pull_flags_fn_t) ndr_pull_winreg_OpenHKLM,

4237

(ndr_print_function_t) ndr_print_winreg_OpenHKLM,

4238

false,

4239

4240

{

4241

"winreg_OpenHKPD",

4242

sizeof(struct winreg_OpenHKPD),

4243

(ndr_push_flags_fn_t) ndr_push_winreg_OpenHKPD,

4244

(ndr_pull_flags_fn_t) ndr_pull_winreg_OpenHKPD,

4245

(ndr_print_function_t) ndr_print_winreg_OpenHKPD,

4246

false,

4247

4248

{

4249

"winreg_OpenHKU",

4250

sizeof(struct winreg_OpenHKU),

4251

(ndr_push_flags_fn_t) ndr_push_winreg_OpenHKU,

4252

(ndr_pull_flags_fn_t) ndr_pull_winreg_OpenHKU,

4253

(ndr_print_function_t) ndr_print_winreg_OpenHKU,

4254

false,

4255

4256

{

4257

"winreg_CloseKey",

4258

sizeof(struct winreg_CloseKey),

4259

(ndr_push_flags_fn_t) ndr_push_winreg_CloseKey,

4260

(ndr_pull_flags_fn_t) ndr_pull_winreg_CloseKey,

4261

(ndr_print_function_t) ndr_print_winreg_CloseKey,

4262

false,

4263

4264

{

4265

"winreg_CreateKey",

4266

sizeof(struct winreg_CreateKey),

4267

(ndr_push_flags_fn_t) ndr_push_winreg_CreateKey,

4268

(ndr_pull_flags_fn_t) ndr_pull_winreg_CreateKey,

4269

(ndr_print_function_t) ndr_print_winreg_CreateKey,

4270

false,

4271

4272

{

4273

"winreg_DeleteKey",

4274

sizeof(struct winreg_DeleteKey),

4275

(ndr_push_flags_fn_t) ndr_push_winreg_DeleteKey,

4276

(ndr_pull_flags_fn_t) ndr_pull_winreg_DeleteKey,

4277

(ndr_print_function_t) ndr_print_winreg_DeleteKey,

4278

false,

4279

4280

{

4281

"winreg_DeleteValue",

4282

sizeof(struct winreg_DeleteValue),

4283

(ndr_push_flags_fn_t) ndr_push_winreg_DeleteValue,

4284

(ndr_pull_flags_fn_t) ndr_pull_winreg_DeleteValue,

4285

(ndr_print_function_t) ndr_print_winreg_DeleteValue,

4286

false,

4287

4288

{

4289

"winreg_EnumKey",

4290

sizeof(struct winreg_EnumKey),

4291

(ndr_push_flags_fn_t) ndr_push_winreg_EnumKey,

4292

(ndr_pull_flags_fn_t) ndr_pull_winreg_EnumKey,

4293

(ndr_print_function_t) ndr_print_winreg_EnumKey,

4294

false,

4295

4296

{

4297

"winreg_EnumValue",

4298

sizeof(struct winreg_EnumValue),

4299

(ndr_push_flags_fn_t) ndr_push_winreg_EnumValue,

4300

(ndr_pull_flags_fn_t) ndr_pull_winreg_EnumValue,

4301

(ndr_print_function_t) ndr_print_winreg_EnumValue,

4302

false,

4303

4304

{

4305

"winreg_FlushKey",

4306

sizeof(struct winreg_FlushKey),

4307

(ndr_push_flags_fn_t) ndr_push_winreg_FlushKey,

4308

(ndr_pull_flags_fn_t) ndr_pull_winreg_FlushKey,

4309

(ndr_print_function_t) ndr_print_winreg_FlushKey,

4310

false,

4311

4312

{

4313

"winreg_GetKeySecurity",

4314

sizeof(struct winreg_GetKeySecurity),

4315

(ndr_push_flags_fn_t) ndr_push_winreg_GetKeySecurity,

4316

(ndr_pull_flags_fn_t) ndr_pull_winreg_GetKeySecurity,

4317

(ndr_print_function_t) ndr_print_winreg_GetKeySecurity,

4318

false,

4319

4320

{

4321

"winreg_LoadKey",

4322

sizeof(struct winreg_LoadKey),

4323

(ndr_push_flags_fn_t) ndr_push_winreg_LoadKey,

4324

(ndr_pull_flags_fn_t) ndr_pull_winreg_LoadKey,

4325

(ndr_print_function_t) ndr_print_winreg_LoadKey,

4326

false,

4327

4328

{

4329

"winreg_NotifyChangeKeyValue",

4330

sizeof(struct winreg_NotifyChangeKeyValue),

4331

(ndr_push_flags_fn_t) ndr_push_winreg_NotifyChangeKeyValue,

4332

(ndr_pull_flags_fn_t) ndr_pull_winreg_NotifyChangeKeyValue,

4333

(ndr_print_function_t) ndr_print_winreg_NotifyChangeKeyValue,

4334

false,

4335

4336

{

4337

"winreg_OpenKey",

4338

sizeof(struct winreg_OpenKey),

4339

(ndr_push_flags_fn_t) ndr_push_winreg_OpenKey,

4340

(ndr_pull_flags_fn_t) ndr_pull_winreg_OpenKey,

4341

(ndr_print_function_t) ndr_print_winreg_OpenKey,

4342

false,

4343

4344

{

4345

"winreg_QueryInfoKey",

4346

sizeof(struct winreg_QueryInfoKey),

4347

(ndr_push_flags_fn_t) ndr_push_winreg_QueryInfoKey,

4348

(ndr_pull_flags_fn_t) ndr_pull_winreg_QueryInfoKey,

4349

(ndr_print_function_t) ndr_print_winreg_QueryInfoKey,

4350

false,

4351

4352

{

4353

"winreg_QueryValue",

4354

sizeof(struct winreg_QueryValue),

4355

(ndr_push_flags_fn_t) ndr_push_winreg_QueryValue,

4356

(ndr_pull_flags_fn_t) ndr_pull_winreg_QueryValue,

4357

(ndr_print_function_t) ndr_print_winreg_QueryValue,

4358

false,

4359

4360

{

4361

"winreg_ReplaceKey",

4362

sizeof(struct winreg_ReplaceKey),

4363

(ndr_push_flags_fn_t) ndr_push_winreg_ReplaceKey,

4364

(ndr_pull_flags_fn_t) ndr_pull_winreg_ReplaceKey,

4365

(ndr_print_function_t) ndr_print_winreg_ReplaceKey,

4366

false,

4367

4368

{

4369

"winreg_RestoreKey",

4370

sizeof(struct winreg_RestoreKey),

4371

(ndr_push_flags_fn_t) ndr_push_winreg_RestoreKey,

4372

(ndr_pull_flags_fn_t) ndr_pull_winreg_RestoreKey,

4373

(ndr_print_function_t) ndr_print_winreg_RestoreKey,

4374

false,

4375

4376

{

4377

"winreg_SaveKey",

4378

sizeof(struct winreg_SaveKey),

4379

(ndr_push_flags_fn_t) ndr_push_winreg_SaveKey,

4380

(ndr_pull_flags_fn_t) ndr_pull_winreg_SaveKey,

4381

(ndr_print_function_t) ndr_print_winreg_SaveKey,

4382

false,

4383

4384

{

4385

"winreg_SetKeySecurity",

4386

sizeof(struct winreg_SetKeySecurity),

4387

(ndr_push_flags_fn_t) ndr_push_winreg_SetKeySecurity,

4388

(ndr_pull_flags_fn_t) ndr_pull_winreg_SetKeySecurity,

4389

(ndr_print_function_t) ndr_print_winreg_SetKeySecurity,

4390

false,

4391

4392

{

4393

"winreg_SetValue",

4394

sizeof(struct winreg_SetValue),

4395

(ndr_push_flags_fn_t) ndr_push_winreg_SetValue,

4396

(ndr_pull_flags_fn_t) ndr_pull_winreg_SetValue,

4397

(ndr_print_function_t) ndr_print_winreg_SetValue,

4398

false,

4399

4400

{

4401

"winreg_UnLoadKey",

4402

sizeof(struct winreg_UnLoadKey),

4403

(ndr_push_flags_fn_t) ndr_push_winreg_UnLoadKey,

4404

(ndr_pull_flags_fn_t) ndr_pull_winreg_UnLoadKey,

4405

(ndr_print_function_t) ndr_print_winreg_UnLoadKey,

4406

false,

4407

4408

{

4409

"winreg_InitiateSystemShutdown",

4410

sizeof(struct winreg_InitiateSystemShutdown),

4411

(ndr_push_flags_fn_t) ndr_push_winreg_InitiateSystemShutdown,

4412

(ndr_pull_flags_fn_t) ndr_pull_winreg_InitiateSystemShutdown,

4413

(ndr_print_function_t) ndr_print_winreg_InitiateSystemShutdown,

4414

false,

4415

4416

{

4417

"winreg_AbortSystemShutdown",

4418

sizeof(struct winreg_AbortSystemShutdown),

4419

(ndr_push_flags_fn_t) ndr_push_winreg_AbortSystemShutdown,

4420

(ndr_pull_flags_fn_t) ndr_pull_winreg_AbortSystemShutdown,

4421

(ndr_print_function_t) ndr_print_winreg_AbortSystemShutdown,

4422

false,

4423

4424

{

4425

"winreg_GetVersion",

4426

sizeof(struct winreg_GetVersion),

4427

(ndr_push_flags_fn_t) ndr_push_winreg_GetVersion,

4428

(ndr_pull_flags_fn_t) ndr_pull_winreg_GetVersion,

4429

(ndr_print_function_t) ndr_print_winreg_GetVersion,

4430

false,

4431

4432

{

4433

"winreg_OpenHKCC",

4434

sizeof(struct winreg_OpenHKCC),

4435

(ndr_push_flags_fn_t) ndr_push_winreg_OpenHKCC,

4436

(ndr_pull_flags_fn_t) ndr_pull_winreg_OpenHKCC,

4437

(ndr_print_function_t) ndr_print_winreg_OpenHKCC,

4438

false,

4439

4440

{

4441

"winreg_OpenHKDD",

4442

sizeof(struct winreg_OpenHKDD),

4443

(ndr_push_flags_fn_t) ndr_push_winreg_OpenHKDD,

4444

(ndr_pull_flags_fn_t) ndr_pull_winreg_OpenHKDD,

4445

(ndr_print_function_t) ndr_print_winreg_OpenHKDD,

4446

false,

4447

4448

{

4449

"winreg_QueryMultipleValues",

4450

sizeof(struct winreg_QueryMultipleValues),

4451

(ndr_push_flags_fn_t) ndr_push_winreg_QueryMultipleValues,

4452

(ndr_pull_flags_fn_t) ndr_pull_winreg_QueryMultipleValues,

4453

(ndr_print_function_t) ndr_print_winreg_QueryMultipleValues,

4454

false,

4455

4456

{

4457

"winreg_InitiateSystemShutdownEx",

4458

sizeof(struct winreg_InitiateSystemShutdownEx),

4459

(ndr_push_flags_fn_t) ndr_push_winreg_InitiateSystemShutdownEx,

4460

(ndr_pull_flags_fn_t) ndr_pull_winreg_InitiateSystemShutdownEx,

4461

(ndr_print_function_t) ndr_print_winreg_InitiateSystemShutdownEx,

4462

false,

4463

4464

{

4465

"winreg_SaveKeyEx",

4466

sizeof(struct winreg_SaveKeyEx),

4467

(ndr_push_flags_fn_t) ndr_push_winreg_SaveKeyEx,

4468

(ndr_pull_flags_fn_t) ndr_pull_winreg_SaveKeyEx,

4469

(ndr_print_function_t) ndr_print_winreg_SaveKeyEx,

4470

false,

4471

4472

{

4473

"winreg_OpenHKPT",

4474

sizeof(struct winreg_OpenHKPT),

4475

(ndr_push_flags_fn_t) ndr_push_winreg_OpenHKPT,

4476

(ndr_pull_flags_fn_t) ndr_pull_winreg_OpenHKPT,

4477

(ndr_print_function_t) ndr_print_winreg_OpenHKPT,

4478

false,

4479

4480

{

4481

"winreg_OpenHKPN",

4482

sizeof(struct winreg_OpenHKPN),

4483

(ndr_push_flags_fn_t) ndr_push_winreg_OpenHKPN,

4484

(ndr_pull_flags_fn_t) ndr_pull_winreg_OpenHKPN,

4485

(ndr_print_function_t) ndr_print_winreg_OpenHKPN,

4486

false,

4487

4488

{

4489

"winreg_QueryMultipleValues2",

4490

sizeof(struct winreg_QueryMultipleValues2),

4491

(ndr_push_flags_fn_t) ndr_push_winreg_QueryMultipleValues2,

4492

(ndr_pull_flags_fn_t) ndr_pull_winreg_QueryMultipleValues2,

4493

(ndr_print_function_t) ndr_print_winreg_QueryMultipleValues2,

4494

false,

4495

4496

{ NULL, 0, NULL, NULL, NULL, false }

4497

};

4498

4499

static const char * const winreg_endpoint_strings[] = {

4500

"ncacn_np:[\\pipe\\winreg]",

4501

"ncacn_ip_tcp:",

4502

"ncalrpc:",

4503

};

4504

4505

static const struct ndr_interface_string_array winreg_endpoints = {

4506

.count = 3,

4507

.names = winreg_endpoint_strings

4508

};

4509

4510

static const char * const winreg_authservice_strings[] = {

4511

"host",

4512

};

4513

4514

static const struct ndr_interface_string_array winreg_authservices = {

4515

.count = 1,

4516

.names = winreg_authservice_strings

4517

};

4518

4519

4520

const struct ndr_interface_table ndr_table_winreg = {

4521

.name = "winreg",

4522

.syntax_id = {

4523

{0x338cd001,0x2244,0x31f1,{0xaa,0xaa},{0x90,0x00,0x38,0x00,0x10,0x03}},

4524

NDR_WINREG_VERSION

4525

4526

.helpstring = NDR_WINREG_HELPSTRING,

4527

.num_calls = 35,

4528

.calls = winreg_calls,

4529

.endpoints = &winreg_endpoints,

4530

.authservices = &winreg_authservices

4531

};

4532