~ubuntu-branches/ubuntu/oneiric/samba/oneiric-security : revision 137

1

/* parser auto-generated by pidl */

2

3

#include "includes.h"

4

#include "../librpc/gen_ndr/ndr_svcctl.h"

5

6

#include "librpc/gen_ndr/ndr_misc.h"

7

#include "librpc/gen_ndr/ndr_security.h"

8

static enum ndr_err_code ndr_push_SERVICE_LOCK_STATUS(struct ndr_push *ndr, int ndr_flags, const struct SERVICE_LOCK_STATUS *r)

9

{

10

if (ndr_flags & NDR_SCALARS) {

11

NDR_CHECK(ndr_push_align(ndr, 5));

12

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

13

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

14

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

15

NDR_CHECK(ndr_push_trailer_align(ndr, 5));

16

}

17

if (ndr_flags & NDR_BUFFERS) {

18

if (r->lock_owner) {

19

NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->lock_owner, CH_UTF16)));

20

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

21

NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->lock_owner, CH_UTF16)));

22

NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->lock_owner, ndr_charset_length(r->lock_owner, CH_UTF16), sizeof(uint16_t), CH_UTF16));

23

}

24

}

25

return NDR_ERR_SUCCESS;

26

}

27

28

static enum ndr_err_code ndr_pull_SERVICE_LOCK_STATUS(struct ndr_pull *ndr, int ndr_flags, struct SERVICE_LOCK_STATUS *r)

29

{

30

uint32_t _ptr_lock_owner;

31

TALLOC_CTX *_mem_save_lock_owner_0;

32

if (ndr_flags & NDR_SCALARS) {

33

NDR_CHECK(ndr_pull_align(ndr, 5));

34

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

35

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_lock_owner));

36

if (_ptr_lock_owner) {

37

NDR_PULL_ALLOC(ndr, r->lock_owner);

38

} else {

39

r->lock_owner = NULL;

40

}

41

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

42

NDR_CHECK(ndr_pull_trailer_align(ndr, 5));

43

}

44

if (ndr_flags & NDR_BUFFERS) {

45

if (r->lock_owner) {

46

_mem_save_lock_owner_0 = NDR_PULL_GET_MEM_CTX(ndr);

47

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

48

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

49

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

50

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

51

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

52

}

53

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

54

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

55

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_lock_owner_0, 0);

56

}

57

}

58

return NDR_ERR_SUCCESS;

59

}

60

61

_PUBLIC_ void ndr_print_SERVICE_LOCK_STATUS(struct ndr_print *ndr, const char *name, const struct SERVICE_LOCK_STATUS *r)

62

{

63

ndr_print_struct(ndr, name, "SERVICE_LOCK_STATUS");

64

ndr->depth++;

65

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

66

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

67

ndr->depth++;

68

if (r->lock_owner) {

69

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

70

}

71

ndr->depth--;

72

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

73

ndr->depth--;

74

}

75

76

static enum ndr_err_code ndr_push_svcctl_ServiceStatus(struct ndr_push *ndr, int ndr_flags, enum svcctl_ServiceStatus r)

77

{

78

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

79

return NDR_ERR_SUCCESS;

80

}

81

82

static enum ndr_err_code ndr_pull_svcctl_ServiceStatus(struct ndr_pull *ndr, int ndr_flags, enum svcctl_ServiceStatus *r)

83

{

84

uint32_t v;

85

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

86

*r = v;

87

return NDR_ERR_SUCCESS;

88

}

89

90

_PUBLIC_ void ndr_print_svcctl_ServiceStatus(struct ndr_print *ndr, const char *name, enum svcctl_ServiceStatus r)

91

{

92

const char *val = NULL;

93

94

switch (r) {

95

case SVCCTL_STATE_UNKNOWN: val = "SVCCTL_STATE_UNKNOWN"; break;

96

case SVCCTL_STOPPED: val = "SVCCTL_STOPPED"; break;

97

case SVCCTL_START_PENDING: val = "SVCCTL_START_PENDING"; break;

98

case SVCCTL_STOP_PENDING: val = "SVCCTL_STOP_PENDING"; break;

99

case SVCCTL_RUNNING: val = "SVCCTL_RUNNING"; break;

100

case SVCCTL_CONTINUE_PENDING: val = "SVCCTL_CONTINUE_PENDING"; break;

101

case SVCCTL_PAUSE_PENDING: val = "SVCCTL_PAUSE_PENDING"; break;

102

case SVCCTL_PAUSED: val = "SVCCTL_PAUSED"; break;

103

}

104

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

105

}

106

107

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

108

{

109

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

110

return NDR_ERR_SUCCESS;

111

}

112

113

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

114

{

115

uint32_t v;

116

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

117

*r = v;

118

return NDR_ERR_SUCCESS;

119

}

120

121

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

122

{

123

ndr_print_uint32(ndr, name, r);

124

ndr->depth++;

125

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

126

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

127

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

128

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

129

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

130

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

131

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

132

ndr->depth--;

133

}

134

135

static enum ndr_err_code ndr_push_SERVICE_STATUS(struct ndr_push *ndr, int ndr_flags, const struct SERVICE_STATUS *r)

136

{

137

if (ndr_flags & NDR_SCALARS) {

138

NDR_CHECK(ndr_push_align(ndr, 4));

139

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

140

NDR_CHECK(ndr_push_svcctl_ServiceStatus(ndr, NDR_SCALARS, r->state));

141

NDR_CHECK(ndr_push_svcctl_ControlsAccepted(ndr, NDR_SCALARS, r->controls_accepted));

142

NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->win32_exit_code));

143

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

144

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

145

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

146

NDR_CHECK(ndr_push_trailer_align(ndr, 4));

147

}

148

if (ndr_flags & NDR_BUFFERS) {

149

}

150

return NDR_ERR_SUCCESS;

151

}

152

153

static enum ndr_err_code ndr_pull_SERVICE_STATUS(struct ndr_pull *ndr, int ndr_flags, struct SERVICE_STATUS *r)

154

{

155

if (ndr_flags & NDR_SCALARS) {

156

NDR_CHECK(ndr_pull_align(ndr, 4));

157

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

158

NDR_CHECK(ndr_pull_svcctl_ServiceStatus(ndr, NDR_SCALARS, &r->state));

159

NDR_CHECK(ndr_pull_svcctl_ControlsAccepted(ndr, NDR_SCALARS, &r->controls_accepted));

160

NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->win32_exit_code));

161

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

162

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

163

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

164

NDR_CHECK(ndr_pull_trailer_align(ndr, 4));

165

}

166

if (ndr_flags & NDR_BUFFERS) {

167

}

168

return NDR_ERR_SUCCESS;

169

}

170

171

_PUBLIC_ void ndr_print_SERVICE_STATUS(struct ndr_print *ndr, const char *name, const struct SERVICE_STATUS *r)

172

{

173

ndr_print_struct(ndr, name, "SERVICE_STATUS");

174

ndr->depth++;

175

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

176

ndr_print_svcctl_ServiceStatus(ndr, "state", r->state);

177

ndr_print_svcctl_ControlsAccepted(ndr, "controls_accepted", r->controls_accepted);

178

ndr_print_WERROR(ndr, "win32_exit_code", r->win32_exit_code);

179

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

180

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

181

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

182

ndr->depth--;

183

}

184

185

_PUBLIC_ enum ndr_err_code ndr_push_SERVICE_STATUS_PROCESS(struct ndr_push *ndr, int ndr_flags, const struct SERVICE_STATUS_PROCESS *r)

186

{

187

if (ndr_flags & NDR_SCALARS) {

188

NDR_CHECK(ndr_push_align(ndr, 4));

189

NDR_CHECK(ndr_push_SERVICE_STATUS(ndr, NDR_SCALARS, &r->status));

190

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

191

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

192

NDR_CHECK(ndr_push_trailer_align(ndr, 4));

193

}

194

if (ndr_flags & NDR_BUFFERS) {

195

}

196

return NDR_ERR_SUCCESS;

197

}

198

199

_PUBLIC_ enum ndr_err_code ndr_pull_SERVICE_STATUS_PROCESS(struct ndr_pull *ndr, int ndr_flags, struct SERVICE_STATUS_PROCESS *r)

200

{

201

if (ndr_flags & NDR_SCALARS) {

202

NDR_CHECK(ndr_pull_align(ndr, 4));

203

NDR_CHECK(ndr_pull_SERVICE_STATUS(ndr, NDR_SCALARS, &r->status));

204

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

205

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

206

NDR_CHECK(ndr_pull_trailer_align(ndr, 4));

207

}

208

if (ndr_flags & NDR_BUFFERS) {

209

}

210

return NDR_ERR_SUCCESS;

211

}

212

213

_PUBLIC_ void ndr_print_SERVICE_STATUS_PROCESS(struct ndr_print *ndr, const char *name, const struct SERVICE_STATUS_PROCESS *r)

214

{

215

ndr_print_struct(ndr, name, "SERVICE_STATUS_PROCESS");

216

ndr->depth++;

217

ndr_print_SERVICE_STATUS(ndr, "status", &r->status);

218

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

219

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

220

ndr->depth--;

221

}

222

223

_PUBLIC_ enum ndr_err_code ndr_push_ENUM_SERVICE_STATUSW(struct ndr_push *ndr, int ndr_flags, const struct ENUM_SERVICE_STATUSW *r)

224

{

225

if (ndr_flags & NDR_SCALARS) {

226

NDR_CHECK(ndr_push_align(ndr, 5));

227

{

228

uint32_t _flags_save_string = ndr->flags;

229

ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);

230

NDR_CHECK(ndr_push_relative_ptr1(ndr, r->service_name));

231

ndr->flags = _flags_save_string;

232

}

233

{

234

uint32_t _flags_save_string = ndr->flags;

235

ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);

236

NDR_CHECK(ndr_push_relative_ptr1(ndr, r->display_name));

237

ndr->flags = _flags_save_string;

238

}

239

NDR_CHECK(ndr_push_SERVICE_STATUS(ndr, NDR_SCALARS, &r->status));

240

NDR_CHECK(ndr_push_trailer_align(ndr, 5));

241

}

242

if (ndr_flags & NDR_BUFFERS) {

243

{

244

uint32_t _flags_save_string = ndr->flags;

245

ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);

246

if (r->service_name) {

247

NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->service_name));

248

NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->service_name));

249

NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->service_name));

250

}

251

ndr->flags = _flags_save_string;

252

}

253

{

254

uint32_t _flags_save_string = ndr->flags;

255

ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);

256

if (r->display_name) {

257

NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->display_name));

258

NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->display_name));

259

NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->display_name));

260

}

261

ndr->flags = _flags_save_string;

262

}

263

}

264

return NDR_ERR_SUCCESS;

265

}

266

267

_PUBLIC_ enum ndr_err_code ndr_pull_ENUM_SERVICE_STATUSW(struct ndr_pull *ndr, int ndr_flags, struct ENUM_SERVICE_STATUSW *r)

268

{

269

uint32_t _ptr_service_name;

270

TALLOC_CTX *_mem_save_service_name_0;

271

uint32_t _ptr_display_name;

272

TALLOC_CTX *_mem_save_display_name_0;

273

if (ndr_flags & NDR_SCALARS) {

274

NDR_CHECK(ndr_pull_align(ndr, 5));

275

{

276

uint32_t _flags_save_string = ndr->flags;

277

ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);

278

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_service_name));

279

if (_ptr_service_name) {

280

NDR_PULL_ALLOC(ndr, r->service_name);

281

NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->service_name, _ptr_service_name));

282

} else {

283

r->service_name = NULL;

284

}

285

ndr->flags = _flags_save_string;

286

}

287

{

288

uint32_t _flags_save_string = ndr->flags;

289

ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);

290

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_display_name));

291

if (_ptr_display_name) {

292

NDR_PULL_ALLOC(ndr, r->display_name);

293

NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->display_name, _ptr_display_name));

294

} else {

295

r->display_name = NULL;

296

}

297

ndr->flags = _flags_save_string;

298

}

299

NDR_CHECK(ndr_pull_SERVICE_STATUS(ndr, NDR_SCALARS, &r->status));

300

NDR_CHECK(ndr_pull_trailer_align(ndr, 5));

301

}

302

if (ndr_flags & NDR_BUFFERS) {

303

{

304

uint32_t _flags_save_string = ndr->flags;

305

ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);

306

if (r->service_name) {

307

uint32_t _relative_save_offset;

308

_relative_save_offset = ndr->offset;

309

NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->service_name));

310

_mem_save_service_name_0 = NDR_PULL_GET_MEM_CTX(ndr);

311

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

312

NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->service_name));

313

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_service_name_0, 0);

314

ndr->offset = _relative_save_offset;

315

}

316

ndr->flags = _flags_save_string;

317

}

318

{

319

uint32_t _flags_save_string = ndr->flags;

320

ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);

321

if (r->display_name) {

322

uint32_t _relative_save_offset;

323

_relative_save_offset = ndr->offset;

324

NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->display_name));

325

_mem_save_display_name_0 = NDR_PULL_GET_MEM_CTX(ndr);

326

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

327

NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->display_name));

328

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_display_name_0, 0);

329

ndr->offset = _relative_save_offset;

330

}

331

ndr->flags = _flags_save_string;

332

}

333

}

334

return NDR_ERR_SUCCESS;

335

}

336

337

_PUBLIC_ void ndr_print_ENUM_SERVICE_STATUSW(struct ndr_print *ndr, const char *name, const struct ENUM_SERVICE_STATUSW *r)

338

{

339

ndr_print_struct(ndr, name, "ENUM_SERVICE_STATUSW");

340

ndr->depth++;

341

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

342

ndr->depth++;

343

if (r->service_name) {

344

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

345

}

346

ndr->depth--;

347

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

348

ndr->depth++;

349

if (r->display_name) {

350

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

351

}

352

ndr->depth--;

353

ndr_print_SERVICE_STATUS(ndr, "status", &r->status);

354

ndr->depth--;

355

}

356

357

_PUBLIC_ size_t ndr_size_ENUM_SERVICE_STATUSW(const struct ENUM_SERVICE_STATUSW *r, struct smb_iconv_convenience *ic, int flags)

358

{

359

return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_ENUM_SERVICE_STATUSW, ic);

360

}

361

362

_PUBLIC_ enum ndr_err_code ndr_push_ENUM_SERVICE_STATUSA(struct ndr_push *ndr, int ndr_flags, const struct ENUM_SERVICE_STATUSA *r)

363

{

364

if (ndr_flags & NDR_SCALARS) {

365

NDR_CHECK(ndr_push_align(ndr, 5));

366

{

367

uint32_t _flags_save_string = ndr->flags;

368

ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_ASCII|LIBNDR_FLAG_STR_NULLTERM);

369

NDR_CHECK(ndr_push_relative_ptr1(ndr, r->service_name));

370

ndr->flags = _flags_save_string;

371

}

372

{

373

uint32_t _flags_save_string = ndr->flags;

374

ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_ASCII|LIBNDR_FLAG_STR_NULLTERM);

375

NDR_CHECK(ndr_push_relative_ptr1(ndr, r->display_name));

376

ndr->flags = _flags_save_string;

377

}

378

NDR_CHECK(ndr_push_SERVICE_STATUS(ndr, NDR_SCALARS, &r->status));

379

NDR_CHECK(ndr_push_trailer_align(ndr, 5));

380

}

381

if (ndr_flags & NDR_BUFFERS) {

382

{

383

uint32_t _flags_save_string = ndr->flags;

384

ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_ASCII|LIBNDR_FLAG_STR_NULLTERM);

385

if (r->service_name) {

386

NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->service_name));

387

NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->service_name));

388

NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->service_name));

389

}

390

ndr->flags = _flags_save_string;

391

}

392

{

393

uint32_t _flags_save_string = ndr->flags;

394

ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_ASCII|LIBNDR_FLAG_STR_NULLTERM);

395

if (r->display_name) {

396

NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->display_name));

397

NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->display_name));

398

NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->display_name));

399

}

400

ndr->flags = _flags_save_string;

401

}

402

}

403

return NDR_ERR_SUCCESS;

404

}

405

406

_PUBLIC_ enum ndr_err_code ndr_pull_ENUM_SERVICE_STATUSA(struct ndr_pull *ndr, int ndr_flags, struct ENUM_SERVICE_STATUSA *r)

407

{

408

uint32_t _ptr_service_name;

409

TALLOC_CTX *_mem_save_service_name_0;

410

uint32_t _ptr_display_name;

411

TALLOC_CTX *_mem_save_display_name_0;

412

if (ndr_flags & NDR_SCALARS) {

413

NDR_CHECK(ndr_pull_align(ndr, 5));

414

{

415

uint32_t _flags_save_string = ndr->flags;

416

ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_ASCII|LIBNDR_FLAG_STR_NULLTERM);

417

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_service_name));

418

if (_ptr_service_name) {

419

NDR_PULL_ALLOC(ndr, r->service_name);

420

NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->service_name, _ptr_service_name));

421

} else {

422

r->service_name = NULL;

423

}

424

ndr->flags = _flags_save_string;

425

}

426

{

427

uint32_t _flags_save_string = ndr->flags;

428

ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_ASCII|LIBNDR_FLAG_STR_NULLTERM);

429

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_display_name));

430

if (_ptr_display_name) {

431

NDR_PULL_ALLOC(ndr, r->display_name);

432

NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->display_name, _ptr_display_name));

433

} else {

434

r->display_name = NULL;

435

}

436

ndr->flags = _flags_save_string;

437

}

438

NDR_CHECK(ndr_pull_SERVICE_STATUS(ndr, NDR_SCALARS, &r->status));

439

NDR_CHECK(ndr_pull_trailer_align(ndr, 5));

440

}

441

if (ndr_flags & NDR_BUFFERS) {

442

{

443

uint32_t _flags_save_string = ndr->flags;

444

ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_ASCII|LIBNDR_FLAG_STR_NULLTERM);

445

if (r->service_name) {

446

uint32_t _relative_save_offset;

447

_relative_save_offset = ndr->offset;

448

NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->service_name));

449

_mem_save_service_name_0 = NDR_PULL_GET_MEM_CTX(ndr);

450

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

451

NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->service_name));

452

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_service_name_0, 0);

453

ndr->offset = _relative_save_offset;

454

}

455

ndr->flags = _flags_save_string;

456

}

457

{

458

uint32_t _flags_save_string = ndr->flags;

459

ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_ASCII|LIBNDR_FLAG_STR_NULLTERM);

460

if (r->display_name) {

461

uint32_t _relative_save_offset;

462

_relative_save_offset = ndr->offset;

463

NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->display_name));

464

_mem_save_display_name_0 = NDR_PULL_GET_MEM_CTX(ndr);

465

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

466

NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->display_name));

467

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_display_name_0, 0);

468

ndr->offset = _relative_save_offset;

469

}

470

ndr->flags = _flags_save_string;

471

}

472

}

473

return NDR_ERR_SUCCESS;

474

}

475

476

_PUBLIC_ void ndr_print_ENUM_SERVICE_STATUSA(struct ndr_print *ndr, const char *name, const struct ENUM_SERVICE_STATUSA *r)

477

{

478

ndr_print_struct(ndr, name, "ENUM_SERVICE_STATUSA");

479

ndr->depth++;

480

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

481

ndr->depth++;

482

if (r->service_name) {

483

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

484

}

485

ndr->depth--;

486

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

487

ndr->depth++;

488

if (r->display_name) {

489

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

490

}

491

ndr->depth--;

492

ndr_print_SERVICE_STATUS(ndr, "status", &r->status);

493

ndr->depth--;

494

}

495

496

_PUBLIC_ size_t ndr_size_ENUM_SERVICE_STATUSA(const struct ENUM_SERVICE_STATUSA *r, struct smb_iconv_convenience *ic, int flags)

497

{

498

return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_ENUM_SERVICE_STATUSA, ic);

499

}

500

501

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

502

{

503

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

504

return NDR_ERR_SUCCESS;

505

}

506

507

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

508

{

509

uint32_t v;

510

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

511

*r = v;

512

return NDR_ERR_SUCCESS;

513

}

514

515

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

516

{

517

ndr_print_uint32(ndr, name, r);

518

ndr->depth++;

519

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

520

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

521

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

522

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

523

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

524

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

525

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

526

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

527

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

528

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

529

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

530

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

531

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

532

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

533

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

534

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

535

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

536

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

537

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

538

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

539

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

540

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

541

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

542

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

543

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

544

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

545

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

546

ndr->depth--;

547

}

548

549

static enum ndr_err_code ndr_push_SERVICE_CONTROL(struct ndr_push *ndr, int ndr_flags, enum SERVICE_CONTROL r)

550

{

551

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

552

return NDR_ERR_SUCCESS;

553

}

554

555

static enum ndr_err_code ndr_pull_SERVICE_CONTROL(struct ndr_pull *ndr, int ndr_flags, enum SERVICE_CONTROL *r)

556

{

557

uint32_t v;

558

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

559

*r = v;

560

return NDR_ERR_SUCCESS;

561

}

562

563

_PUBLIC_ void ndr_print_SERVICE_CONTROL(struct ndr_print *ndr, const char *name, enum SERVICE_CONTROL r)

564

{

565

const char *val = NULL;

566

567

switch (r) {

568

case SVCCTL_CONTROL_STOP: val = "SVCCTL_CONTROL_STOP"; break;

569

case SVCCTL_CONTROL_PAUSE: val = "SVCCTL_CONTROL_PAUSE"; break;

570

case SVCCTL_CONTROL_CONTINUE: val = "SVCCTL_CONTROL_CONTINUE"; break;

571

case SVCCTL_CONTROL_INTERROGATE: val = "SVCCTL_CONTROL_INTERROGATE"; break;

572

case SVCCTL_CONTROL_SHUTDOWN: val = "SVCCTL_CONTROL_SHUTDOWN"; break;

573

}

574

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

575

}

576

577

static enum ndr_err_code ndr_push_svcctl_ErrorControl(struct ndr_push *ndr, int ndr_flags, enum svcctl_ErrorControl r)

578

{

579

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

580

return NDR_ERR_SUCCESS;

581

}

582

583

static enum ndr_err_code ndr_pull_svcctl_ErrorControl(struct ndr_pull *ndr, int ndr_flags, enum svcctl_ErrorControl *r)

584

{

585

uint32_t v;

586

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

587

*r = v;

588

return NDR_ERR_SUCCESS;

589

}

590

591

_PUBLIC_ void ndr_print_svcctl_ErrorControl(struct ndr_print *ndr, const char *name, enum svcctl_ErrorControl r)

592

{

593

const char *val = NULL;

594

595

switch (r) {

596

case SVCCTL_SVC_ERROR_IGNORE: val = "SVCCTL_SVC_ERROR_IGNORE"; break;

597

case SVCCTL_SVC_ERROR_NORMAL: val = "SVCCTL_SVC_ERROR_NORMAL"; break;

598

case SVCCTL_SVC_ERROR_CRITICAL: val = "SVCCTL_SVC_ERROR_CRITICAL"; break;

599

case SVCCTL_SVC_ERROR_SEVERE: val = "SVCCTL_SVC_ERROR_SEVERE"; break;

600

}

601

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

602

}

603

604

static enum ndr_err_code ndr_push_svcctl_StartType(struct ndr_push *ndr, int ndr_flags, enum svcctl_StartType r)

605

{

606

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

607

return NDR_ERR_SUCCESS;

608

}

609

610

static enum ndr_err_code ndr_pull_svcctl_StartType(struct ndr_pull *ndr, int ndr_flags, enum svcctl_StartType *r)

611

{

612

uint32_t v;

613

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

614

*r = v;

615

return NDR_ERR_SUCCESS;

616

}

617

618

_PUBLIC_ void ndr_print_svcctl_StartType(struct ndr_print *ndr, const char *name, enum svcctl_StartType r)

619

{

620

const char *val = NULL;

621

622

switch (r) {

623

case SVCCTL_BOOT_START: val = "SVCCTL_BOOT_START"; break;

624

case SVCCTL_SYSTEM_START: val = "SVCCTL_SYSTEM_START"; break;

625

case SVCCTL_AUTO_START: val = "SVCCTL_AUTO_START"; break;

626

case SVCCTL_DEMAND_START: val = "SVCCTL_DEMAND_START"; break;

627

case SVCCTL_DISABLED: val = "SVCCTL_DISABLED"; break;

628

}

629

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

630

}

631

632

static enum ndr_err_code ndr_push_svcctl_ServiceState(struct ndr_push *ndr, int ndr_flags, enum svcctl_ServiceState r)

633

{

634

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

635

return NDR_ERR_SUCCESS;

636

}

637

638

static enum ndr_err_code ndr_pull_svcctl_ServiceState(struct ndr_pull *ndr, int ndr_flags, enum svcctl_ServiceState *r)

639

{

640

uint32_t v;

641

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

642

*r = v;

643

return NDR_ERR_SUCCESS;

644

}

645

646

_PUBLIC_ void ndr_print_svcctl_ServiceState(struct ndr_print *ndr, const char *name, enum svcctl_ServiceState r)

647

{

648

const char *val = NULL;

649

650

switch (r) {

651

case SERVICE_STATE_ACTIVE: val = "SERVICE_STATE_ACTIVE"; break;

652

case SERVICE_STATE_INACTIVE: val = "SERVICE_STATE_INACTIVE"; break;

653

case SERVICE_STATE_ALL: val = "SERVICE_STATE_ALL"; break;

654

}

655

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

656

}

657

658

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

659

{

660

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

661

return NDR_ERR_SUCCESS;

662

}

663

664

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

665

{

666

uint32_t v;

667

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

668

*r = v;

669

return NDR_ERR_SUCCESS;

670

}

671

672

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

673

{

674

ndr_print_uint32(ndr, name, r);

675

ndr->depth++;

676

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

677

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

678

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

679

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

680

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

681

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

682

ndr->depth--;

683

}

684

685

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

686

{

687

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

688

return NDR_ERR_SUCCESS;

689

}

690

691

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

692

{

693

uint32_t v;

694

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

695

*r = v;

696

return NDR_ERR_SUCCESS;

697

}

698

699

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

700

{

701

ndr_print_uint32(ndr, name, r);

702

ndr->depth++;

703

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

704

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

705

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

706

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

707

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

708

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

709

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

710

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

711

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

712

ndr->depth--;

713

}

714

715

_PUBLIC_ enum ndr_err_code ndr_push_QUERY_SERVICE_CONFIG(struct ndr_push *ndr, int ndr_flags, const struct QUERY_SERVICE_CONFIG *r)

716

{

717

if (ndr_flags & NDR_SCALARS) {

718

NDR_CHECK(ndr_push_align(ndr, 5));

719

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

720

NDR_CHECK(ndr_push_svcctl_StartType(ndr, NDR_SCALARS, r->start_type));

721

NDR_CHECK(ndr_push_svcctl_ErrorControl(ndr, NDR_SCALARS, r->error_control));

722

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

723

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

724

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

725

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

726

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

727

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

728

NDR_CHECK(ndr_push_trailer_align(ndr, 5));

729

}

730

if (ndr_flags & NDR_BUFFERS) {

731

if (r->executablepath) {

732

NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->executablepath, CH_UTF16)));

733

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

734

NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->executablepath, CH_UTF16)));

735

NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->executablepath, ndr_charset_length(r->executablepath, CH_UTF16), sizeof(uint16_t), CH_UTF16));

736

}

737

if (r->loadordergroup) {

738

NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->loadordergroup, CH_UTF16)));

739

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

740

NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->loadordergroup, CH_UTF16)));

741

NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->loadordergroup, ndr_charset_length(r->loadordergroup, CH_UTF16), sizeof(uint16_t), CH_UTF16));

742

}

743

if (r->dependencies) {

744

NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->dependencies, CH_UTF16)));

745

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

746

NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->dependencies, CH_UTF16)));

747

NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->dependencies, ndr_charset_length(r->dependencies, CH_UTF16), sizeof(uint16_t), CH_UTF16));

748

}

749

if (r->startname) {

750

NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->startname, CH_UTF16)));

751

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

752

NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->startname, CH_UTF16)));

753

NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->startname, ndr_charset_length(r->startname, CH_UTF16), sizeof(uint16_t), CH_UTF16));

754

}

755

if (r->displayname) {

756

NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->displayname, CH_UTF16)));

757

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

758

NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->displayname, CH_UTF16)));

759

NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->displayname, ndr_charset_length(r->displayname, CH_UTF16), sizeof(uint16_t), CH_UTF16));

760

}

761

}

762

return NDR_ERR_SUCCESS;

763

}

764

765

_PUBLIC_ enum ndr_err_code ndr_pull_QUERY_SERVICE_CONFIG(struct ndr_pull *ndr, int ndr_flags, struct QUERY_SERVICE_CONFIG *r)

766

{

767

uint32_t _ptr_executablepath;

768

TALLOC_CTX *_mem_save_executablepath_0;

769

uint32_t _ptr_loadordergroup;

770

TALLOC_CTX *_mem_save_loadordergroup_0;

771

uint32_t _ptr_dependencies;

772

TALLOC_CTX *_mem_save_dependencies_0;

773

uint32_t _ptr_startname;

774

TALLOC_CTX *_mem_save_startname_0;

775

uint32_t _ptr_displayname;

776

TALLOC_CTX *_mem_save_displayname_0;

777

if (ndr_flags & NDR_SCALARS) {

778

NDR_CHECK(ndr_pull_align(ndr, 5));

779

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

780

NDR_CHECK(ndr_pull_svcctl_StartType(ndr, NDR_SCALARS, &r->start_type));

781

NDR_CHECK(ndr_pull_svcctl_ErrorControl(ndr, NDR_SCALARS, &r->error_control));

782

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_executablepath));

783

if (_ptr_executablepath) {

784

NDR_PULL_ALLOC(ndr, r->executablepath);

785

} else {

786

r->executablepath = NULL;

787

}

788

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_loadordergroup));

789

if (_ptr_loadordergroup) {

790

NDR_PULL_ALLOC(ndr, r->loadordergroup);

791

} else {

792

r->loadordergroup = NULL;

793

}

794

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

795

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dependencies));

796

if (_ptr_dependencies) {

797

NDR_PULL_ALLOC(ndr, r->dependencies);

798

} else {

799

r->dependencies = NULL;

800

}

801

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_startname));

802

if (_ptr_startname) {

803

NDR_PULL_ALLOC(ndr, r->startname);

804

} else {

805

r->startname = NULL;

806

}

807

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_displayname));

808

if (_ptr_displayname) {

809

NDR_PULL_ALLOC(ndr, r->displayname);

810

} else {

811

r->displayname = NULL;

812

}

813

NDR_CHECK(ndr_pull_trailer_align(ndr, 5));

814

}

815

if (ndr_flags & NDR_BUFFERS) {

816

if (r->executablepath) {

817

_mem_save_executablepath_0 = NDR_PULL_GET_MEM_CTX(ndr);

818

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

819

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

820

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

821

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

822

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

823

}

824

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

825

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

826

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_executablepath_0, 0);

827

}

828

if (r->loadordergroup) {

829

_mem_save_loadordergroup_0 = NDR_PULL_GET_MEM_CTX(ndr);

830

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

831

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

832

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

833

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

834

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

835

}

836

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

837

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

838

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_loadordergroup_0, 0);

839

}

840

if (r->dependencies) {

841

_mem_save_dependencies_0 = NDR_PULL_GET_MEM_CTX(ndr);

842

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

843

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

844

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

845

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

846

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

847

}

848

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

849

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

850

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dependencies_0, 0);

851

}

852

if (r->startname) {

853

_mem_save_startname_0 = NDR_PULL_GET_MEM_CTX(ndr);

854

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

855

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

856

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

857

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

858

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

859

}

860

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

861

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

862

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_startname_0, 0);

863

}

864

if (r->displayname) {

865

_mem_save_displayname_0 = NDR_PULL_GET_MEM_CTX(ndr);

866

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

867

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

868

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

869

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

870

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

871

}

872

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

873

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

874

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_displayname_0, 0);

875

}

876

}

877

return NDR_ERR_SUCCESS;

878

}

879

880

_PUBLIC_ void ndr_print_QUERY_SERVICE_CONFIG(struct ndr_print *ndr, const char *name, const struct QUERY_SERVICE_CONFIG *r)

881

{

882

ndr_print_struct(ndr, name, "QUERY_SERVICE_CONFIG");

883

ndr->depth++;

884

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

885

ndr_print_svcctl_StartType(ndr, "start_type", r->start_type);

886

ndr_print_svcctl_ErrorControl(ndr, "error_control", r->error_control);

887

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

888

ndr->depth++;

889

if (r->executablepath) {

890

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

891

}

892

ndr->depth--;

893

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

894

ndr->depth++;

895

if (r->loadordergroup) {

896

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

897

}

898

ndr->depth--;

899

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

900

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

901

ndr->depth++;

902

if (r->dependencies) {

903

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

904

}

905

ndr->depth--;

906

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

907

ndr->depth++;

908

if (r->startname) {

909

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

910

}

911

ndr->depth--;

912

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

913

ndr->depth++;

914

if (r->displayname) {

915

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

916

}

917

ndr->depth--;

918

ndr->depth--;

919

}

920

921

_PUBLIC_ size_t ndr_size_QUERY_SERVICE_CONFIG(const struct QUERY_SERVICE_CONFIG *r, struct smb_iconv_convenience *ic, int flags)

922

{

923

return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_QUERY_SERVICE_CONFIG, ic);

924

}

925

926

static enum ndr_err_code ndr_push_svcctl_ArgumentString(struct ndr_push *ndr, int ndr_flags, const struct svcctl_ArgumentString *r)

927

{

928

if (ndr_flags & NDR_SCALARS) {

929

NDR_CHECK(ndr_push_align(ndr, 5));

930

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

931

NDR_CHECK(ndr_push_trailer_align(ndr, 5));

932

}

933

if (ndr_flags & NDR_BUFFERS) {

934

if (r->string) {

935

NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->string, CH_UTF16)));

936

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

937

NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->string, CH_UTF16)));

938

NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->string, ndr_charset_length(r->string, CH_UTF16), sizeof(uint16_t), CH_UTF16));

939

}

940

}

941

return NDR_ERR_SUCCESS;

942

}

943

944

static enum ndr_err_code ndr_pull_svcctl_ArgumentString(struct ndr_pull *ndr, int ndr_flags, struct svcctl_ArgumentString *r)

945

{

946

uint32_t _ptr_string;

947

TALLOC_CTX *_mem_save_string_0;

948

if (ndr_flags & NDR_SCALARS) {

949

NDR_CHECK(ndr_pull_align(ndr, 5));

950

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_string));

951

if (_ptr_string) {

952

NDR_PULL_ALLOC(ndr, r->string);

953

} else {

954

r->string = NULL;

955

}

956

NDR_CHECK(ndr_pull_trailer_align(ndr, 5));

957

}

958

if (ndr_flags & NDR_BUFFERS) {

959

if (r->string) {

960

_mem_save_string_0 = NDR_PULL_GET_MEM_CTX(ndr);

961

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

962

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

963

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

964

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

965

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

966

}

967

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

968

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

969

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_string_0, 0);

970

}

971

}

972

return NDR_ERR_SUCCESS;

973

}

974

975

_PUBLIC_ void ndr_print_svcctl_ArgumentString(struct ndr_print *ndr, const char *name, const struct svcctl_ArgumentString *r)

976

{

977

ndr_print_struct(ndr, name, "svcctl_ArgumentString");

978

ndr->depth++;

979

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

980

ndr->depth++;

981

if (r->string) {

982

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

983

}

984

ndr->depth--;

985

ndr->depth--;

986

}

987

988

static enum ndr_err_code ndr_push_svcctl_ConfigLevel(struct ndr_push *ndr, int ndr_flags, enum svcctl_ConfigLevel r)

989

{

990

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

991

return NDR_ERR_SUCCESS;

992

}

993

994

static enum ndr_err_code ndr_pull_svcctl_ConfigLevel(struct ndr_pull *ndr, int ndr_flags, enum svcctl_ConfigLevel *r)

995

{

996

uint32_t v;

997

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

998

*r = v;

999

return NDR_ERR_SUCCESS;

1000

}

1001

1002

_PUBLIC_ void ndr_print_svcctl_ConfigLevel(struct ndr_print *ndr, const char *name, enum svcctl_ConfigLevel r)

1003

{

1004

const char *val = NULL;

1005

1006

switch (r) {

1007

case SERVICE_CONFIG_DESCRIPTION: val = "SERVICE_CONFIG_DESCRIPTION"; break;

1008

case SERVICE_CONFIG_FAILURE_ACTIONS: val = "SERVICE_CONFIG_FAILURE_ACTIONS"; break;

1009

}

1010

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

1011

}

1012

1013

_PUBLIC_ enum ndr_err_code ndr_push_SERVICE_DESCRIPTION(struct ndr_push *ndr, int ndr_flags, const struct SERVICE_DESCRIPTION *r)

1014

{

1015

if (ndr_flags & NDR_SCALARS) {

1016

NDR_CHECK(ndr_push_align(ndr, 5));

1017

{

1018

uint32_t _flags_save_string = ndr->flags;

1019

ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);

1020

NDR_CHECK(ndr_push_relative_ptr1(ndr, r->description));

1021

ndr->flags = _flags_save_string;

1022

}

1023

NDR_CHECK(ndr_push_trailer_align(ndr, 5));

1024

}

1025

if (ndr_flags & NDR_BUFFERS) {

1026

{

1027

uint32_t _flags_save_string = ndr->flags;

1028

ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);

1029

if (r->description) {

1030

NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->description));

1031

NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->description));

1032

NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->description));

1033

}

1034

ndr->flags = _flags_save_string;

1035

}

1036

}

1037

return NDR_ERR_SUCCESS;

1038

}

1039

1040

_PUBLIC_ enum ndr_err_code ndr_pull_SERVICE_DESCRIPTION(struct ndr_pull *ndr, int ndr_flags, struct SERVICE_DESCRIPTION *r)

1041

{

1042

uint32_t _ptr_description;

1043

TALLOC_CTX *_mem_save_description_0;

1044

if (ndr_flags & NDR_SCALARS) {

1045

NDR_CHECK(ndr_pull_align(ndr, 5));

1046

{

1047

uint32_t _flags_save_string = ndr->flags;

1048

ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);

1049

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_description));

1050

if (_ptr_description) {

1051

NDR_PULL_ALLOC(ndr, r->description);

1052

NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->description, _ptr_description));

1053

} else {

1054

r->description = NULL;

1055

}

1056

ndr->flags = _flags_save_string;

1057

}

1058

NDR_CHECK(ndr_pull_trailer_align(ndr, 5));

1059

}

1060

if (ndr_flags & NDR_BUFFERS) {

1061

{

1062

uint32_t _flags_save_string = ndr->flags;

1063

ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);

1064

if (r->description) {

1065

uint32_t _relative_save_offset;

1066

_relative_save_offset = ndr->offset;

1067

NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->description));

1068

_mem_save_description_0 = NDR_PULL_GET_MEM_CTX(ndr);

1069

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

1070

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

1071

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_description_0, 0);

1072

ndr->offset = _relative_save_offset;

1073

}

1074

ndr->flags = _flags_save_string;

1075

}

1076

}

1077

return NDR_ERR_SUCCESS;

1078

}

1079

1080

_PUBLIC_ void ndr_print_SERVICE_DESCRIPTION(struct ndr_print *ndr, const char *name, const struct SERVICE_DESCRIPTION *r)

1081

{

1082

ndr_print_struct(ndr, name, "SERVICE_DESCRIPTION");

1083

ndr->depth++;

1084

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

1085

ndr->depth++;

1086

if (r->description) {

1087

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

1088

}

1089

ndr->depth--;

1090

ndr->depth--;

1091

}

1092

1093

_PUBLIC_ size_t ndr_size_SERVICE_DESCRIPTION(const struct SERVICE_DESCRIPTION *r, struct smb_iconv_convenience *ic, int flags)

1094

{

1095

return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_SERVICE_DESCRIPTION, ic);

1096

}

1097

1098

static enum ndr_err_code ndr_push_SC_ACTION_TYPE(struct ndr_push *ndr, int ndr_flags, enum SC_ACTION_TYPE r)

1099

{

1100

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

1101

return NDR_ERR_SUCCESS;

1102

}

1103

1104

static enum ndr_err_code ndr_pull_SC_ACTION_TYPE(struct ndr_pull *ndr, int ndr_flags, enum SC_ACTION_TYPE *r)

1105

{

1106

uint32_t v;

1107

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

1108

*r = v;

1109

return NDR_ERR_SUCCESS;

1110

}

1111

1112

_PUBLIC_ void ndr_print_SC_ACTION_TYPE(struct ndr_print *ndr, const char *name, enum SC_ACTION_TYPE r)

1113

{

1114

const char *val = NULL;

1115

1116

switch (r) {

1117

case SC_ACTION_NONE: val = "SC_ACTION_NONE"; break;

1118

case SC_ACTION_RESTART: val = "SC_ACTION_RESTART"; break;

1119

case SC_ACTION_REBOOT: val = "SC_ACTION_REBOOT"; break;

1120

case SC_ACTION_RUN_COMMAND: val = "SC_ACTION_RUN_COMMAND"; break;

1121

}

1122

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

1123

}

1124

1125

static enum ndr_err_code ndr_push_SC_ACTION(struct ndr_push *ndr, int ndr_flags, const struct SC_ACTION *r)

1126

{

1127

if (ndr_flags & NDR_SCALARS) {

1128

NDR_CHECK(ndr_push_align(ndr, 4));

1129

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

1130

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

1131

NDR_CHECK(ndr_push_trailer_align(ndr, 4));

1132

}

1133

if (ndr_flags & NDR_BUFFERS) {

1134

}

1135

return NDR_ERR_SUCCESS;

1136

}

1137

1138

static enum ndr_err_code ndr_pull_SC_ACTION(struct ndr_pull *ndr, int ndr_flags, struct SC_ACTION *r)

1139

{

1140

if (ndr_flags & NDR_SCALARS) {

1141

NDR_CHECK(ndr_pull_align(ndr, 4));

1142

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

1143

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

1144

NDR_CHECK(ndr_pull_trailer_align(ndr, 4));

1145

}

1146

if (ndr_flags & NDR_BUFFERS) {

1147

}

1148

return NDR_ERR_SUCCESS;

1149

}

1150

1151

_PUBLIC_ void ndr_print_SC_ACTION(struct ndr_print *ndr, const char *name, const struct SC_ACTION *r)

1152

{

1153

ndr_print_struct(ndr, name, "SC_ACTION");

1154

ndr->depth++;

1155

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

1156

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

1157

ndr->depth--;

1158

}

1159

1160

_PUBLIC_ enum ndr_err_code ndr_push_SERVICE_FAILURE_ACTIONS(struct ndr_push *ndr, int ndr_flags, const struct SERVICE_FAILURE_ACTIONS *r)

1161

{

1162

uint32_t cntr_actions_1;

1163

if (ndr_flags & NDR_SCALARS) {

1164

NDR_CHECK(ndr_push_align(ndr, 5));

1165

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

1166

{

1167

uint32_t _flags_save_string = ndr->flags;

1168

ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);

1169

NDR_CHECK(ndr_push_relative_ptr1(ndr, r->rebootmsg));

1170

ndr->flags = _flags_save_string;

1171

}

1172

{

1173

uint32_t _flags_save_string = ndr->flags;

1174

ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);

1175

NDR_CHECK(ndr_push_relative_ptr1(ndr, r->command));

1176

ndr->flags = _flags_save_string;

1177

}

1178

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

1179

NDR_CHECK(ndr_push_relative_ptr1(ndr, r->actions));

1180

NDR_CHECK(ndr_push_trailer_align(ndr, 5));

1181

}

1182

if (ndr_flags & NDR_BUFFERS) {

1183

{

1184

uint32_t _flags_save_string = ndr->flags;

1185

ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);

1186

if (r->rebootmsg) {

1187

NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->rebootmsg));

1188

NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->rebootmsg));

1189

NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->rebootmsg));

1190

}

1191

ndr->flags = _flags_save_string;

1192

}

1193

{

1194

uint32_t _flags_save_string = ndr->flags;

1195

ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);

1196

if (r->command) {

1197

NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->command));

1198

NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->command));

1199

NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->command));

1200

}

1201

ndr->flags = _flags_save_string;

1202

}

1203

if (r->actions) {

1204

NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->actions));

1205

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

1206

for (cntr_actions_1 = 0; cntr_actions_1 < r->num_actions; cntr_actions_1++) {

1207

NDR_CHECK(ndr_push_SC_ACTION(ndr, NDR_SCALARS, &r->actions[cntr_actions_1]));

1208

}

1209

NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->actions));

1210

}

1211

}

1212

return NDR_ERR_SUCCESS;

1213

}

1214

1215

_PUBLIC_ enum ndr_err_code ndr_pull_SERVICE_FAILURE_ACTIONS(struct ndr_pull *ndr, int ndr_flags, struct SERVICE_FAILURE_ACTIONS *r)

1216

{

1217

uint32_t _ptr_rebootmsg;

1218

TALLOC_CTX *_mem_save_rebootmsg_0;

1219

uint32_t _ptr_command;

1220

TALLOC_CTX *_mem_save_command_0;

1221

uint32_t _ptr_actions;

1222

uint32_t cntr_actions_1;

1223

TALLOC_CTX *_mem_save_actions_0;

1224

TALLOC_CTX *_mem_save_actions_1;

1225

if (ndr_flags & NDR_SCALARS) {

1226

NDR_CHECK(ndr_pull_align(ndr, 5));

1227

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

1228

{

1229

uint32_t _flags_save_string = ndr->flags;

1230

ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);

1231

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_rebootmsg));

1232

if (_ptr_rebootmsg) {

1233

NDR_PULL_ALLOC(ndr, r->rebootmsg);

1234

NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->rebootmsg, _ptr_rebootmsg));

1235

} else {

1236

r->rebootmsg = NULL;

1237

}

1238

ndr->flags = _flags_save_string;

1239

}

1240

{

1241

uint32_t _flags_save_string = ndr->flags;

1242

ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);

1243

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_command));

1244

if (_ptr_command) {

1245

NDR_PULL_ALLOC(ndr, r->command);

1246

NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->command, _ptr_command));

1247

} else {

1248

r->command = NULL;

1249

}

1250

ndr->flags = _flags_save_string;

1251

}

1252

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

1253

if (r->num_actions > 1024) {

1254

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

1255

}

1256

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_actions));

1257

if (_ptr_actions) {

1258

NDR_PULL_ALLOC(ndr, r->actions);

1259

NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->actions, _ptr_actions));

1260

} else {

1261

r->actions = NULL;

1262

}

1263

NDR_CHECK(ndr_pull_trailer_align(ndr, 5));

1264

}

1265

if (ndr_flags & NDR_BUFFERS) {

1266

{

1267

uint32_t _flags_save_string = ndr->flags;

1268

ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);

1269

if (r->rebootmsg) {

1270

uint32_t _relative_save_offset;

1271

_relative_save_offset = ndr->offset;

1272

NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->rebootmsg));

1273

_mem_save_rebootmsg_0 = NDR_PULL_GET_MEM_CTX(ndr);

1274

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

1275

NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->rebootmsg));

1276

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_rebootmsg_0, 0);

1277

ndr->offset = _relative_save_offset;

1278

}

1279

ndr->flags = _flags_save_string;

1280

}

1281

{

1282

uint32_t _flags_save_string = ndr->flags;

1283

ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);

1284

if (r->command) {

1285

uint32_t _relative_save_offset;

1286

_relative_save_offset = ndr->offset;

1287

NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->command));

1288

_mem_save_command_0 = NDR_PULL_GET_MEM_CTX(ndr);

1289

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

1290

NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->command));

1291

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_command_0, 0);

1292

ndr->offset = _relative_save_offset;

1293

}

1294

ndr->flags = _flags_save_string;

1295

}

1296

if (r->actions) {

1297

uint32_t _relative_save_offset;

1298

_relative_save_offset = ndr->offset;

1299

NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->actions));

1300

_mem_save_actions_0 = NDR_PULL_GET_MEM_CTX(ndr);

1301

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

1302

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

1303

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

1304

_mem_save_actions_1 = NDR_PULL_GET_MEM_CTX(ndr);

1305

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

1306

for (cntr_actions_1 = 0; cntr_actions_1 < r->num_actions; cntr_actions_1++) {

1307

NDR_CHECK(ndr_pull_SC_ACTION(ndr, NDR_SCALARS, &r->actions[cntr_actions_1]));

1308

}

1309

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_actions_1, 0);

1310

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_actions_0, 0);

1311

ndr->offset = _relative_save_offset;

1312

}

1313

if (r->actions) {

1314

NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->actions, r->num_actions));

1315

}

1316

}

1317

return NDR_ERR_SUCCESS;

1318

}

1319

1320

_PUBLIC_ void ndr_print_SERVICE_FAILURE_ACTIONS(struct ndr_print *ndr, const char *name, const struct SERVICE_FAILURE_ACTIONS *r)

1321

{

1322

uint32_t cntr_actions_1;

1323

ndr_print_struct(ndr, name, "SERVICE_FAILURE_ACTIONS");

1324

ndr->depth++;

1325

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

1326

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

1327

ndr->depth++;

1328

if (r->rebootmsg) {

1329

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

1330

}

1331

ndr->depth--;

1332

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

1333

ndr->depth++;

1334

if (r->command) {

1335

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

1336

}

1337

ndr->depth--;

1338

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

1339

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

1340

ndr->depth++;

1341

if (r->actions) {

1342

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

1343

ndr->depth++;

1344

for (cntr_actions_1=0;cntr_actions_1<r->num_actions;cntr_actions_1++) {

1345

char *idx_1=NULL;

1346

if (asprintf(&idx_1, "[%d]", cntr_actions_1) != -1) {

1347

ndr_print_SC_ACTION(ndr, "actions", &r->actions[cntr_actions_1]);

1348

free(idx_1);

1349

}

1350

}

1351

ndr->depth--;

1352

}

1353

ndr->depth--;

1354

ndr->depth--;

1355

}

1356

1357

_PUBLIC_ size_t ndr_size_SERVICE_FAILURE_ACTIONS(const struct SERVICE_FAILURE_ACTIONS *r, struct smb_iconv_convenience *ic, int flags)

1358

{

1359

return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_SERVICE_FAILURE_ACTIONS, ic);

1360

}

1361

1362

static enum ndr_err_code ndr_push_svcctl_StatusLevel(struct ndr_push *ndr, int ndr_flags, enum svcctl_StatusLevel r)

1363

{

1364

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

1365

return NDR_ERR_SUCCESS;

1366

}

1367

1368

static enum ndr_err_code ndr_pull_svcctl_StatusLevel(struct ndr_pull *ndr, int ndr_flags, enum svcctl_StatusLevel *r)

1369

{

1370

uint32_t v;

1371

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

1372

*r = v;

1373

return NDR_ERR_SUCCESS;

1374

}

1375

1376

_PUBLIC_ void ndr_print_svcctl_StatusLevel(struct ndr_print *ndr, const char *name, enum svcctl_StatusLevel r)

1377

{

1378

const char *val = NULL;

1379

1380

switch (r) {

1381

case SVC_STATUS_PROCESS_INFO: val = "SVC_STATUS_PROCESS_INFO"; break;

1382

}

1383

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

1384

}

1385

1386

static enum ndr_err_code ndr_push_svcctl_CloseServiceHandle(struct ndr_push *ndr, int flags, const struct svcctl_CloseServiceHandle *r)

1387

{

1388

if (flags & NDR_IN) {

1389

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

1390

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

1391

}

1392

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

1393

}

1394

if (flags & NDR_OUT) {

1395

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

1396

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

1397

}

1398

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

1399

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

1400

}

1401

return NDR_ERR_SUCCESS;

1402

}

1403

1404

static enum ndr_err_code ndr_pull_svcctl_CloseServiceHandle(struct ndr_pull *ndr, int flags, struct svcctl_CloseServiceHandle *r)

1405

{

1406

TALLOC_CTX *_mem_save_handle_0;

1407

if (flags & NDR_IN) {

1408

ZERO_STRUCT(r->out);

1409

1410

if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {

1411

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

1412

}

1413

_mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);

1414

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

1415

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

1416

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);

1417

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

1418

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

1419

}

1420

if (flags & NDR_OUT) {

1421

if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {

1422

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

1423

}

1424

_mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);

1425

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

1426

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

1427

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);

1428

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

1429

}

1430

return NDR_ERR_SUCCESS;

1431

}

1432

1433

_PUBLIC_ void ndr_print_svcctl_CloseServiceHandle(struct ndr_print *ndr, const char *name, int flags, const struct svcctl_CloseServiceHandle *r)

1434

{

1435

ndr_print_struct(ndr, name, "svcctl_CloseServiceHandle");

1436

ndr->depth++;

1437

if (flags & NDR_SET_VALUES) {

1438

ndr->flags |= LIBNDR_PRINT_SET_VALUES;

1439

}

1440

if (flags & NDR_IN) {

1441

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

1442

ndr->depth++;

1443

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

1444

ndr->depth++;

1445

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

1446

ndr->depth--;

1447

ndr->depth--;

1448

}

1449

if (flags & NDR_OUT) {

1450

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

1451

ndr->depth++;

1452

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

1453

ndr->depth++;

1454

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

1455

ndr->depth--;

1456

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

1457

ndr->depth--;

1458

}

1459

ndr->depth--;

1460

}

1461

1462

static enum ndr_err_code ndr_push_svcctl_ControlService(struct ndr_push *ndr, int flags, const struct svcctl_ControlService *r)

1463

{

1464

if (flags & NDR_IN) {

1465

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

1466

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

1467

}

1468

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

1469

NDR_CHECK(ndr_push_SERVICE_CONTROL(ndr, NDR_SCALARS, r->in.control));

1470

}

1471

if (flags & NDR_OUT) {

1472

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

1473

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

1474

}

1475

NDR_CHECK(ndr_push_SERVICE_STATUS(ndr, NDR_SCALARS, r->out.service_status));

1476

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

1477

}

1478

return NDR_ERR_SUCCESS;

1479

}

1480

1481

static enum ndr_err_code ndr_pull_svcctl_ControlService(struct ndr_pull *ndr, int flags, struct svcctl_ControlService *r)

1482

{

1483

TALLOC_CTX *_mem_save_handle_0;

1484

TALLOC_CTX *_mem_save_service_status_0;

1485

if (flags & NDR_IN) {

1486

ZERO_STRUCT(r->out);

1487

1488

if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {

1489

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

1490

}

1491

_mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);

1492

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

1493

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

1494

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);

1495

NDR_CHECK(ndr_pull_SERVICE_CONTROL(ndr, NDR_SCALARS, &r->in.control));

1496

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

1497

ZERO_STRUCTP(r->out.service_status);

1498

}

1499

if (flags & NDR_OUT) {

1500

if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {

1501

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

1502

}

1503

_mem_save_service_status_0 = NDR_PULL_GET_MEM_CTX(ndr);

1504

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

1505

NDR_CHECK(ndr_pull_SERVICE_STATUS(ndr, NDR_SCALARS, r->out.service_status));

1506

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_service_status_0, LIBNDR_FLAG_REF_ALLOC);

1507

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

1508

}

1509

return NDR_ERR_SUCCESS;

1510

}

1511

1512

_PUBLIC_ void ndr_print_svcctl_ControlService(struct ndr_print *ndr, const char *name, int flags, const struct svcctl_ControlService *r)

1513

{

1514

ndr_print_struct(ndr, name, "svcctl_ControlService");

1515

ndr->depth++;

1516

if (flags & NDR_SET_VALUES) {

1517

ndr->flags |= LIBNDR_PRINT_SET_VALUES;

1518

}

1519

if (flags & NDR_IN) {

1520

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

1521

ndr->depth++;

1522

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

1523

ndr->depth++;

1524

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

1525

ndr->depth--;

1526

ndr_print_SERVICE_CONTROL(ndr, "control", r->in.control);

1527

ndr->depth--;

1528

}

1529

if (flags & NDR_OUT) {

1530

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

1531

ndr->depth++;

1532

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

1533

ndr->depth++;

1534

ndr_print_SERVICE_STATUS(ndr, "service_status", r->out.service_status);

1535

ndr->depth--;

1536

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

1537

ndr->depth--;

1538

}

1539

ndr->depth--;

1540

}

1541

1542

static enum ndr_err_code ndr_push_svcctl_DeleteService(struct ndr_push *ndr, int flags, const struct svcctl_DeleteService *r)

1543

{

1544

if (flags & NDR_IN) {

1545

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

1546

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

1547

}

1548

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

1549

}

1550

if (flags & NDR_OUT) {

1551

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

1552

}

1553

return NDR_ERR_SUCCESS;

1554

}

1555

1556

static enum ndr_err_code ndr_pull_svcctl_DeleteService(struct ndr_pull *ndr, int flags, struct svcctl_DeleteService *r)

1557

{

1558

TALLOC_CTX *_mem_save_handle_0;

1559

if (flags & NDR_IN) {

1560

if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {

1561

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

1562

}

1563

_mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);

1564

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

1565

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

1566

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);

1567

}

1568

if (flags & NDR_OUT) {

1569

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

1570

}

1571

return NDR_ERR_SUCCESS;

1572

}

1573

1574

_PUBLIC_ void ndr_print_svcctl_DeleteService(struct ndr_print *ndr, const char *name, int flags, const struct svcctl_DeleteService *r)

1575

{

1576

ndr_print_struct(ndr, name, "svcctl_DeleteService");

1577

ndr->depth++;

1578

if (flags & NDR_SET_VALUES) {

1579

ndr->flags |= LIBNDR_PRINT_SET_VALUES;

1580

}

1581

if (flags & NDR_IN) {

1582

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

1583

ndr->depth++;

1584

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

1585

ndr->depth++;

1586

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

1587

ndr->depth--;

1588

ndr->depth--;

1589

}

1590

if (flags & NDR_OUT) {

1591

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

1592

ndr->depth++;

1593

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

1594

ndr->depth--;

1595

}

1596

ndr->depth--;

1597

}

1598

1599

static enum ndr_err_code ndr_push_svcctl_LockServiceDatabase(struct ndr_push *ndr, int flags, const struct svcctl_LockServiceDatabase *r)

1600

{

1601

if (flags & NDR_IN) {

1602

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

1603

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

1604

}

1605

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

1606

}

1607

if (flags & NDR_OUT) {

1608

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

1609

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

1610

}

1611

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

1612

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

1613

}

1614

return NDR_ERR_SUCCESS;

1615

}

1616

1617

static enum ndr_err_code ndr_pull_svcctl_LockServiceDatabase(struct ndr_pull *ndr, int flags, struct svcctl_LockServiceDatabase *r)

1618

{

1619

TALLOC_CTX *_mem_save_handle_0;

1620

TALLOC_CTX *_mem_save_lock_0;

1621

if (flags & NDR_IN) {

1622

ZERO_STRUCT(r->out);

1623

1624

if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {

1625

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

1626

}

1627

_mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);

1628

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

1629

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

1630

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);

1631

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

1632

ZERO_STRUCTP(r->out.lock);

1633

}

1634

if (flags & NDR_OUT) {

1635

if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {

1636

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

1637

}

1638

_mem_save_lock_0 = NDR_PULL_GET_MEM_CTX(ndr);

1639

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

1640

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

1641

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_lock_0, LIBNDR_FLAG_REF_ALLOC);

1642

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

1643

}

1644

return NDR_ERR_SUCCESS;

1645

}

1646

1647

_PUBLIC_ void ndr_print_svcctl_LockServiceDatabase(struct ndr_print *ndr, const char *name, int flags, const struct svcctl_LockServiceDatabase *r)

1648

{

1649

ndr_print_struct(ndr, name, "svcctl_LockServiceDatabase");

1650

ndr->depth++;

1651

if (flags & NDR_SET_VALUES) {

1652

ndr->flags |= LIBNDR_PRINT_SET_VALUES;

1653

}

1654

if (flags & NDR_IN) {

1655

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

1656

ndr->depth++;

1657

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

1658

ndr->depth++;

1659

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

1660

ndr->depth--;

1661

ndr->depth--;

1662

}

1663

if (flags & NDR_OUT) {

1664

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

1665

ndr->depth++;

1666

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

1667

ndr->depth++;

1668

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

1669

ndr->depth--;

1670

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

1671

ndr->depth--;

1672

}

1673

ndr->depth--;

1674

}

1675

1676

static enum ndr_err_code ndr_push_svcctl_QueryServiceObjectSecurity(struct ndr_push *ndr, int flags, const struct svcctl_QueryServiceObjectSecurity *r)

1677

{

1678

if (flags & NDR_IN) {

1679

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

1680

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

1681

}

1682

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

1683

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

1684

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

1685

}

1686

if (flags & NDR_OUT) {

1687

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

1688

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

1689

}

1690

NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->in.offered));

1691

NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->out.buffer, r->in.offered));

1692

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

1693

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

1694

}

1695

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

1696

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

1697

}

1698

return NDR_ERR_SUCCESS;

1699

}

1700

1701

static enum ndr_err_code ndr_pull_svcctl_QueryServiceObjectSecurity(struct ndr_pull *ndr, int flags, struct svcctl_QueryServiceObjectSecurity *r)

1702

{

1703

TALLOC_CTX *_mem_save_handle_0;

1704

TALLOC_CTX *_mem_save_needed_0;

1705

if (flags & NDR_IN) {

1706

ZERO_STRUCT(r->out);

1707

1708

if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {

1709

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

1710

}

1711

_mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);

1712

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

1713

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

1714

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);

1715

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

1716

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

1717

if (r->in.offered > 0x40000) {

1718

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

1719

}

1720

NDR_PULL_ALLOC_N(ndr, r->out.buffer, r->in.offered);

1721

memset(r->out.buffer, 0, (r->in.offered) * sizeof(*r->out.buffer));

1722

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

1723

ZERO_STRUCTP(r->out.needed);

1724

}

1725

if (flags & NDR_OUT) {

1726

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

1727

if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {

1728

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

1729

}

1730

NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->out.buffer, ndr_get_array_size(ndr, &r->out.buffer)));

1731

if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {

1732

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

1733

}

1734

_mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);

1735

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

1736

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

1737

if (*r->out.needed > 0x40000) {

1738

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

1739

}

1740

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);

1741

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

1742

if (r->out.buffer) {

1743

NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->out.buffer, r->in.offered));

1744

}

1745

}

1746

return NDR_ERR_SUCCESS;

1747

}

1748

1749

_PUBLIC_ void ndr_print_svcctl_QueryServiceObjectSecurity(struct ndr_print *ndr, const char *name, int flags, const struct svcctl_QueryServiceObjectSecurity *r)

1750

{

1751

ndr_print_struct(ndr, name, "svcctl_QueryServiceObjectSecurity");

1752

ndr->depth++;

1753

if (flags & NDR_SET_VALUES) {

1754

ndr->flags |= LIBNDR_PRINT_SET_VALUES;

1755

}

1756

if (flags & NDR_IN) {

1757

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

1758

ndr->depth++;

1759

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

1760

ndr->depth++;

1761

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

1762

ndr->depth--;

1763

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

1764

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

1765

ndr->depth--;

1766

}

1767

if (flags & NDR_OUT) {

1768

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

1769

ndr->depth++;

1770

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

1771

ndr->depth++;

1772

ndr_print_array_uint8(ndr, "buffer", r->out.buffer, r->in.offered);

1773

ndr->depth--;

1774

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

1775

ndr->depth++;

1776

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

1777

ndr->depth--;

1778

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

1779

ndr->depth--;

1780

}

1781

ndr->depth--;

1782

}

1783

1784

static enum ndr_err_code ndr_push_svcctl_SetServiceObjectSecurity(struct ndr_push *ndr, int flags, const struct svcctl_SetServiceObjectSecurity *r)

1785

{

1786

if (flags & NDR_IN) {

1787

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

1788

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

1789

}

1790

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

1791

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

1792

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

1793

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

1794

}

1795

NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->in.offered));

1796

NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->in.buffer, r->in.offered));

1797

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

1798

}

1799

if (flags & NDR_OUT) {

1800

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

1801

}

1802

return NDR_ERR_SUCCESS;

1803

}

1804

1805

static enum ndr_err_code ndr_pull_svcctl_SetServiceObjectSecurity(struct ndr_pull *ndr, int flags, struct svcctl_SetServiceObjectSecurity *r)

1806

{

1807

TALLOC_CTX *_mem_save_handle_0;

1808

if (flags & NDR_IN) {

1809

if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {

1810

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

1811

}

1812

_mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);

1813

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

1814

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

1815

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);

1816

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

1817

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

1818

if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {

1819

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

1820

}

1821

NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->in.buffer, ndr_get_array_size(ndr, &r->in.buffer)));

1822

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

1823

if (r->in.buffer) {

1824

NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->in.buffer, r->in.offered));

1825

}

1826

}

1827

if (flags & NDR_OUT) {

1828

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

1829

}

1830

return NDR_ERR_SUCCESS;

1831

}

1832

1833

_PUBLIC_ void ndr_print_svcctl_SetServiceObjectSecurity(struct ndr_print *ndr, const char *name, int flags, const struct svcctl_SetServiceObjectSecurity *r)

1834

{

1835

ndr_print_struct(ndr, name, "svcctl_SetServiceObjectSecurity");

1836

ndr->depth++;

1837

if (flags & NDR_SET_VALUES) {

1838

ndr->flags |= LIBNDR_PRINT_SET_VALUES;

1839

}

1840

if (flags & NDR_IN) {

1841

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

1842

ndr->depth++;

1843

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

1844

ndr->depth++;

1845

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

1846

ndr->depth--;

1847

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

1848

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

1849

ndr->depth++;

1850

ndr_print_array_uint8(ndr, "buffer", r->in.buffer, r->in.offered);

1851

ndr->depth--;

1852

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

1853

ndr->depth--;

1854

}

1855

if (flags & NDR_OUT) {

1856

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

1857

ndr->depth++;

1858

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

1859

ndr->depth--;

1860

}

1861

ndr->depth--;

1862

}

1863

1864

static enum ndr_err_code ndr_push_svcctl_QueryServiceStatus(struct ndr_push *ndr, int flags, const struct svcctl_QueryServiceStatus *r)

1865

{

1866

if (flags & NDR_IN) {

1867

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

1868

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

1869

}

1870

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

1871

}

1872

if (flags & NDR_OUT) {

1873

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

1874

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

1875

}

1876

NDR_CHECK(ndr_push_SERVICE_STATUS(ndr, NDR_SCALARS, r->out.service_status));

1877

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

1878

}

1879

return NDR_ERR_SUCCESS;

1880

}

1881

1882

static enum ndr_err_code ndr_pull_svcctl_QueryServiceStatus(struct ndr_pull *ndr, int flags, struct svcctl_QueryServiceStatus *r)

1883

{

1884

TALLOC_CTX *_mem_save_handle_0;

1885

TALLOC_CTX *_mem_save_service_status_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_PULL_ALLOC(ndr, r->out.service_status);

1897

ZERO_STRUCTP(r->out.service_status);

1898

}

1899

if (flags & NDR_OUT) {

1900

if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {

1901

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

1902

}

1903

_mem_save_service_status_0 = NDR_PULL_GET_MEM_CTX(ndr);

1904

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

1905

NDR_CHECK(ndr_pull_SERVICE_STATUS(ndr, NDR_SCALARS, r->out.service_status));

1906

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_service_status_0, LIBNDR_FLAG_REF_ALLOC);

1907

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

1908

}

1909

return NDR_ERR_SUCCESS;

1910

}

1911

1912

_PUBLIC_ void ndr_print_svcctl_QueryServiceStatus(struct ndr_print *ndr, const char *name, int flags, const struct svcctl_QueryServiceStatus *r)

1913

{

1914

ndr_print_struct(ndr, name, "svcctl_QueryServiceStatus");

1915

ndr->depth++;

1916

if (flags & NDR_SET_VALUES) {

1917

ndr->flags |= LIBNDR_PRINT_SET_VALUES;

1918

}

1919

if (flags & NDR_IN) {

1920

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

1921

ndr->depth++;

1922

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

1923

ndr->depth++;

1924

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

1925

ndr->depth--;

1926

ndr->depth--;

1927

}

1928

if (flags & NDR_OUT) {

1929

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

1930

ndr->depth++;

1931

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

1932

ndr->depth++;

1933

ndr_print_SERVICE_STATUS(ndr, "service_status", r->out.service_status);

1934

ndr->depth--;

1935

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

1936

ndr->depth--;

1937

}

1938

ndr->depth--;

1939

}

1940

1941

static enum ndr_err_code ndr_push_svcctl_SetServiceStatus(struct ndr_push *ndr, int flags, const struct svcctl_SetServiceStatus *r)

1942

{

1943

if (flags & NDR_IN) {

1944

}

1945

if (flags & NDR_OUT) {

1946

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

1947

}

1948

return NDR_ERR_SUCCESS;

1949

}

1950

1951

static enum ndr_err_code ndr_pull_svcctl_SetServiceStatus(struct ndr_pull *ndr, int flags, struct svcctl_SetServiceStatus *r)

1952

{

1953

if (flags & NDR_IN) {

1954

}

1955

if (flags & NDR_OUT) {

1956

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

1957

}

1958

return NDR_ERR_SUCCESS;

1959

}

1960

1961

_PUBLIC_ void ndr_print_svcctl_SetServiceStatus(struct ndr_print *ndr, const char *name, int flags, const struct svcctl_SetServiceStatus *r)

1962

{

1963

ndr_print_struct(ndr, name, "svcctl_SetServiceStatus");

1964

ndr->depth++;

1965

if (flags & NDR_SET_VALUES) {

1966

ndr->flags |= LIBNDR_PRINT_SET_VALUES;

1967

}

1968

if (flags & NDR_IN) {

1969

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

1970

ndr->depth++;

1971

ndr->depth--;

1972

}

1973

if (flags & NDR_OUT) {

1974

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

1975

ndr->depth++;

1976

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

1977

ndr->depth--;

1978

}

1979

ndr->depth--;

1980

}

1981

1982

static enum ndr_err_code ndr_push_svcctl_UnlockServiceDatabase(struct ndr_push *ndr, int flags, const struct svcctl_UnlockServiceDatabase *r)

1983

{

1984

if (flags & NDR_IN) {

1985

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

1986

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

1987

}

1988

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

1989

}

1990

if (flags & NDR_OUT) {

1991

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

1992

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

1993

}

1994

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

1995

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

1996

}

1997

return NDR_ERR_SUCCESS;

1998

}

1999

2000

static enum ndr_err_code ndr_pull_svcctl_UnlockServiceDatabase(struct ndr_pull *ndr, int flags, struct svcctl_UnlockServiceDatabase *r)

2001

{

2002

TALLOC_CTX *_mem_save_lock_0;

2003

if (flags & NDR_IN) {

2004

ZERO_STRUCT(r->out);

2005

2006

if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {

2007

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

2008

}

2009

_mem_save_lock_0 = NDR_PULL_GET_MEM_CTX(ndr);

2010

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

2011

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

2012

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_lock_0, LIBNDR_FLAG_REF_ALLOC);

2013

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

2014

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

2015

}

2016

if (flags & NDR_OUT) {

2017

if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {

2018

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

2019

}

2020

_mem_save_lock_0 = NDR_PULL_GET_MEM_CTX(ndr);

2021

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

2022

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

2023

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_lock_0, LIBNDR_FLAG_REF_ALLOC);

2024

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

2025

}

2026

return NDR_ERR_SUCCESS;

2027

}

2028

2029

_PUBLIC_ void ndr_print_svcctl_UnlockServiceDatabase(struct ndr_print *ndr, const char *name, int flags, const struct svcctl_UnlockServiceDatabase *r)

2030

{

2031

ndr_print_struct(ndr, name, "svcctl_UnlockServiceDatabase");

2032

ndr->depth++;

2033

if (flags & NDR_SET_VALUES) {

2034

ndr->flags |= LIBNDR_PRINT_SET_VALUES;

2035

}

2036

if (flags & NDR_IN) {

2037

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

2038

ndr->depth++;

2039

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

2040

ndr->depth++;

2041

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

2042

ndr->depth--;

2043

ndr->depth--;

2044

}

2045

if (flags & NDR_OUT) {

2046

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

2047

ndr->depth++;

2048

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

2049

ndr->depth++;

2050

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

2051

ndr->depth--;

2052

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

2053

ndr->depth--;

2054

}

2055

ndr->depth--;

2056

}

2057

2058

static enum ndr_err_code ndr_push_svcctl_NotifyBootConfigStatus(struct ndr_push *ndr, int flags, const struct svcctl_NotifyBootConfigStatus *r)

2059

{

2060

if (flags & NDR_IN) {

2061

}

2062

if (flags & NDR_OUT) {

2063

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

2064

}

2065

return NDR_ERR_SUCCESS;

2066

}

2067

2068

static enum ndr_err_code ndr_pull_svcctl_NotifyBootConfigStatus(struct ndr_pull *ndr, int flags, struct svcctl_NotifyBootConfigStatus *r)

2069

{

2070

if (flags & NDR_IN) {

2071

}

2072

if (flags & NDR_OUT) {

2073

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

2074

}

2075

return NDR_ERR_SUCCESS;

2076

}

2077

2078

_PUBLIC_ void ndr_print_svcctl_NotifyBootConfigStatus(struct ndr_print *ndr, const char *name, int flags, const struct svcctl_NotifyBootConfigStatus *r)

2079

{

2080

ndr_print_struct(ndr, name, "svcctl_NotifyBootConfigStatus");

2081

ndr->depth++;

2082

if (flags & NDR_SET_VALUES) {

2083

ndr->flags |= LIBNDR_PRINT_SET_VALUES;

2084

}

2085

if (flags & NDR_IN) {

2086

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

2087

ndr->depth++;

2088

ndr->depth--;

2089

}

2090

if (flags & NDR_OUT) {

2091

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

2092

ndr->depth++;

2093

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

2094

ndr->depth--;

2095

}

2096

ndr->depth--;

2097

}

2098

2099

static enum ndr_err_code ndr_push_svcctl_SCSetServiceBitsW(struct ndr_push *ndr, int flags, const struct svcctl_SCSetServiceBitsW *r)

2100

{

2101

if (flags & NDR_IN) {

2102

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

2103

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

2104

}

2105

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

2106

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

2107

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

2108

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

2109

}

2110

if (flags & NDR_OUT) {

2111

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

2112

}

2113

return NDR_ERR_SUCCESS;

2114

}

2115

2116

static enum ndr_err_code ndr_pull_svcctl_SCSetServiceBitsW(struct ndr_pull *ndr, int flags, struct svcctl_SCSetServiceBitsW *r)

2117

{

2118

TALLOC_CTX *_mem_save_handle_0;

2119

if (flags & NDR_IN) {

2120

if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {

2121

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

2122

}

2123

_mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);

2124

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

2125

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

2126

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);

2127

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

2128

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

2129

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

2130

}

2131

if (flags & NDR_OUT) {

2132

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

2133

}

2134

return NDR_ERR_SUCCESS;

2135

}

2136

2137

_PUBLIC_ void ndr_print_svcctl_SCSetServiceBitsW(struct ndr_print *ndr, const char *name, int flags, const struct svcctl_SCSetServiceBitsW *r)

2138

{

2139

ndr_print_struct(ndr, name, "svcctl_SCSetServiceBitsW");

2140

ndr->depth++;

2141

if (flags & NDR_SET_VALUES) {

2142

ndr->flags |= LIBNDR_PRINT_SET_VALUES;

2143

}

2144

if (flags & NDR_IN) {

2145

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

2146

ndr->depth++;

2147

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

2148

ndr->depth++;

2149

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

2150

ndr->depth--;

2151

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

2152

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

2153

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

2154

ndr->depth--;

2155

}

2156

if (flags & NDR_OUT) {

2157

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

2158

ndr->depth++;

2159

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

2160

ndr->depth--;

2161

}

2162

ndr->depth--;

2163

}

2164

2165

static enum ndr_err_code ndr_push_svcctl_ChangeServiceConfigW(struct ndr_push *ndr, int flags, const struct svcctl_ChangeServiceConfigW *r)

2166

{

2167

if (flags & NDR_IN) {

2168

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

2169

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

2170

}

2171

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

2172

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

2173

NDR_CHECK(ndr_push_svcctl_StartType(ndr, NDR_SCALARS, r->in.start_type));

2174

NDR_CHECK(ndr_push_svcctl_ErrorControl(ndr, NDR_SCALARS, r->in.error_control));

2175

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

2176

if (r->in.binary_path) {

2177

NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.binary_path, CH_UTF16)));

2178

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

2179

NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.binary_path, CH_UTF16)));

2180

NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.binary_path, ndr_charset_length(r->in.binary_path, CH_UTF16), sizeof(uint16_t), CH_UTF16));

2181

}

2182

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

2183

if (r->in.load_order_group) {

2184

NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.load_order_group, CH_UTF16)));

2185

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

2186

NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.load_order_group, CH_UTF16)));

2187

NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.load_order_group, ndr_charset_length(r->in.load_order_group, CH_UTF16), sizeof(uint16_t), CH_UTF16));

2188

}

2189

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

2190

if (r->in.dependencies) {

2191

NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.dependencies, CH_UTF16)));

2192

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

2193

NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.dependencies, CH_UTF16)));

2194

NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.dependencies, ndr_charset_length(r->in.dependencies, CH_UTF16), sizeof(uint16_t), CH_UTF16));

2195

}

2196

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

2197

if (r->in.service_start_name) {

2198

NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.service_start_name, CH_UTF16)));

2199

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

2200

NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.service_start_name, CH_UTF16)));

2201

NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.service_start_name, ndr_charset_length(r->in.service_start_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));

2202

}

2203

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

2204

if (r->in.password) {

2205

NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.password, CH_UTF16)));

2206

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

2207

NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.password, CH_UTF16)));

2208

NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.password, ndr_charset_length(r->in.password, CH_UTF16), sizeof(uint16_t), CH_UTF16));

2209

}

2210

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

2211

if (r->in.display_name) {

2212

NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.display_name, CH_UTF16)));

2213

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

2214

NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.display_name, CH_UTF16)));

2215

NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.display_name, ndr_charset_length(r->in.display_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));

2216

}

2217

}

2218

if (flags & NDR_OUT) {

2219

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

2220

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

2221

}

2222

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

2223

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

2224

}

2225

return NDR_ERR_SUCCESS;

2226

}

2227

2228

static enum ndr_err_code ndr_pull_svcctl_ChangeServiceConfigW(struct ndr_pull *ndr, int flags, struct svcctl_ChangeServiceConfigW *r)

2229

{

2230

uint32_t _ptr_binary_path;

2231

uint32_t _ptr_load_order_group;

2232

uint32_t _ptr_dependencies;

2233

uint32_t _ptr_service_start_name;

2234

uint32_t _ptr_password;

2235

uint32_t _ptr_display_name;

2236

TALLOC_CTX *_mem_save_handle_0;

2237

TALLOC_CTX *_mem_save_binary_path_0;

2238

TALLOC_CTX *_mem_save_load_order_group_0;

2239

TALLOC_CTX *_mem_save_tag_id_0;

2240

TALLOC_CTX *_mem_save_dependencies_0;

2241

TALLOC_CTX *_mem_save_service_start_name_0;

2242

TALLOC_CTX *_mem_save_password_0;

2243

TALLOC_CTX *_mem_save_display_name_0;

2244

if (flags & NDR_IN) {

2245

ZERO_STRUCT(r->out);

2246

2247

if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {

2248

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

2249

}

2250

_mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);

2251

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

2252

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

2253

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);

2254

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

2255

NDR_CHECK(ndr_pull_svcctl_StartType(ndr, NDR_SCALARS, &r->in.start_type));

2256

NDR_CHECK(ndr_pull_svcctl_ErrorControl(ndr, NDR_SCALARS, &r->in.error_control));

2257

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_binary_path));

2258

if (_ptr_binary_path) {

2259

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

2260

} else {

2261

r->in.binary_path = NULL;

2262

}

2263

if (r->in.binary_path) {

2264

_mem_save_binary_path_0 = NDR_PULL_GET_MEM_CTX(ndr);

2265

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

2266

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

2267

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

2268

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

2269

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

2270

}

2271

NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.binary_path), sizeof(uint16_t)));

2272

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

2273

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_binary_path_0, 0);

2274

}

2275

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_load_order_group));

2276

if (_ptr_load_order_group) {

2277

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

2278

} else {

2279

r->in.load_order_group = NULL;

2280

}

2281

if (r->in.load_order_group) {

2282

_mem_save_load_order_group_0 = NDR_PULL_GET_MEM_CTX(ndr);

2283

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

2284

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

2285

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

2286

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

2287

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

2288

}

2289

NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.load_order_group), sizeof(uint16_t)));

2290

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

2291

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_load_order_group_0, 0);

2292

}

2293

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dependencies));

2294

if (_ptr_dependencies) {

2295

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

2296

} else {

2297

r->in.dependencies = NULL;

2298

}

2299

if (r->in.dependencies) {

2300

_mem_save_dependencies_0 = NDR_PULL_GET_MEM_CTX(ndr);

2301

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

2302

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

2303

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

2304

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

2305

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

2306

}

2307

NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.dependencies), sizeof(uint16_t)));

2308

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

2309

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dependencies_0, 0);

2310

}

2311

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_service_start_name));

2312

if (_ptr_service_start_name) {

2313

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

2314

} else {

2315

r->in.service_start_name = NULL;

2316

}

2317

if (r->in.service_start_name) {

2318

_mem_save_service_start_name_0 = NDR_PULL_GET_MEM_CTX(ndr);

2319

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

2320

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

2321

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

2322

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

2323

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

2324

}

2325

NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.service_start_name), sizeof(uint16_t)));

2326

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

2327

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_service_start_name_0, 0);

2328

}

2329

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_password));

2330

if (_ptr_password) {

2331

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

2332

} else {

2333

r->in.password = NULL;

2334

}

2335

if (r->in.password) {

2336

_mem_save_password_0 = NDR_PULL_GET_MEM_CTX(ndr);

2337

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

2338

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

2339

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

2340

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

2341

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

2342

}

2343

NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.password), sizeof(uint16_t)));

2344

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

2345

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_password_0, 0);

2346

}

2347

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_display_name));

2348

if (_ptr_display_name) {

2349

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

2350

} else {

2351

r->in.display_name = NULL;

2352

}

2353

if (r->in.display_name) {

2354

_mem_save_display_name_0 = NDR_PULL_GET_MEM_CTX(ndr);

2355

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

2356

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

2357

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

2358

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

2359

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

2360

}

2361

NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.display_name), sizeof(uint16_t)));

2362

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

2363

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_display_name_0, 0);

2364

}

2365

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

2366

ZERO_STRUCTP(r->out.tag_id);

2367

}

2368

if (flags & NDR_OUT) {

2369

if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {

2370

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

2371

}

2372

_mem_save_tag_id_0 = NDR_PULL_GET_MEM_CTX(ndr);

2373

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

2374

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

2375

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_tag_id_0, LIBNDR_FLAG_REF_ALLOC);

2376

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

2377

}

2378

return NDR_ERR_SUCCESS;

2379

}

2380

2381

_PUBLIC_ void ndr_print_svcctl_ChangeServiceConfigW(struct ndr_print *ndr, const char *name, int flags, const struct svcctl_ChangeServiceConfigW *r)

2382

{

2383

ndr_print_struct(ndr, name, "svcctl_ChangeServiceConfigW");

2384

ndr->depth++;

2385

if (flags & NDR_SET_VALUES) {

2386

ndr->flags |= LIBNDR_PRINT_SET_VALUES;

2387

}

2388

if (flags & NDR_IN) {

2389

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

2390

ndr->depth++;

2391

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

2392

ndr->depth++;

2393

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

2394

ndr->depth--;

2395

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

2396

ndr_print_svcctl_StartType(ndr, "start_type", r->in.start_type);

2397

ndr_print_svcctl_ErrorControl(ndr, "error_control", r->in.error_control);

2398

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

2399

ndr->depth++;

2400

if (r->in.binary_path) {

2401

ndr_print_string(ndr, "binary_path", r->in.binary_path);

2402

}

2403

ndr->depth--;

2404

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

2405

ndr->depth++;

2406

if (r->in.load_order_group) {

2407

ndr_print_string(ndr, "load_order_group", r->in.load_order_group);

2408

}

2409

ndr->depth--;

2410

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

2411

ndr->depth++;

2412

if (r->in.dependencies) {

2413

ndr_print_string(ndr, "dependencies", r->in.dependencies);

2414

}

2415

ndr->depth--;

2416

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

2417

ndr->depth++;

2418

if (r->in.service_start_name) {

2419

ndr_print_string(ndr, "service_start_name", r->in.service_start_name);

2420

}

2421

ndr->depth--;

2422

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

2423

ndr->depth++;

2424

if (r->in.password) {

2425

ndr_print_string(ndr, "password", r->in.password);

2426

}

2427

ndr->depth--;

2428

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

2429

ndr->depth++;

2430

if (r->in.display_name) {

2431

ndr_print_string(ndr, "display_name", r->in.display_name);

2432

}

2433

ndr->depth--;

2434

ndr->depth--;

2435

}

2436

if (flags & NDR_OUT) {

2437

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

2438

ndr->depth++;

2439

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

2440

ndr->depth++;

2441

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

2442

ndr->depth--;

2443

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

2444

ndr->depth--;

2445

}

2446

ndr->depth--;

2447

}

2448

2449

static enum ndr_err_code ndr_push_svcctl_CreateServiceW(struct ndr_push *ndr, int flags, const struct svcctl_CreateServiceW *r)

2450

{

2451

if (flags & NDR_IN) {

2452

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

2453

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

2454

}

2455

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

2456

NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.ServiceName, CH_UTF16)));

2457

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

2458

NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.ServiceName, CH_UTF16)));

2459

NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.ServiceName, ndr_charset_length(r->in.ServiceName, CH_UTF16), sizeof(uint16_t), CH_UTF16));

2460

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

2461

if (r->in.DisplayName) {

2462

NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.DisplayName, CH_UTF16)));

2463

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

2464

NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.DisplayName, CH_UTF16)));

2465

NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.DisplayName, ndr_charset_length(r->in.DisplayName, CH_UTF16), sizeof(uint16_t), CH_UTF16));

2466

}

2467

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

2468

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

2469

NDR_CHECK(ndr_push_svcctl_StartType(ndr, NDR_SCALARS, r->in.start_type));

2470

NDR_CHECK(ndr_push_svcctl_ErrorControl(ndr, NDR_SCALARS, r->in.error_control));

2471

NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.binary_path, CH_UTF16)));

2472

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

2473

NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.binary_path, CH_UTF16)));

2474

NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.binary_path, ndr_charset_length(r->in.binary_path, CH_UTF16), sizeof(uint16_t), CH_UTF16));

2475

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

2476

if (r->in.LoadOrderGroupKey) {

2477

NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.LoadOrderGroupKey, CH_UTF16)));

2478

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

2479

NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.LoadOrderGroupKey, CH_UTF16)));

2480

NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.LoadOrderGroupKey, ndr_charset_length(r->in.LoadOrderGroupKey, CH_UTF16), sizeof(uint16_t), CH_UTF16));

2481

}

2482

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

2483

if (r->in.TagId) {

2484

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

2485

}

2486

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

2487

if (r->in.dependencies) {

2488

NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->in.dependencies_size));

2489

NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->in.dependencies, r->in.dependencies_size));

2490

}

2491

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

2492

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

2493

if (r->in.service_start_name) {

2494

NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.service_start_name, CH_UTF16)));

2495

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

2496

NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.service_start_name, CH_UTF16)));

2497

NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.service_start_name, ndr_charset_length(r->in.service_start_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));

2498

}

2499

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

2500

if (r->in.password) {

2501

NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->in.password_size));

2502

NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->in.password, r->in.password_size));

2503

}

2504

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

2505

}

2506

if (flags & NDR_OUT) {

2507

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

2508

if (r->out.TagId) {

2509

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

2510

}

2511

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

2512

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

2513

}

2514

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

2515

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

2516

}

2517

return NDR_ERR_SUCCESS;

2518

}

2519

2520

static enum ndr_err_code ndr_pull_svcctl_CreateServiceW(struct ndr_pull *ndr, int flags, struct svcctl_CreateServiceW *r)

2521

{

2522

uint32_t _ptr_DisplayName;

2523

uint32_t _ptr_LoadOrderGroupKey;

2524

uint32_t _ptr_TagId;

2525

uint32_t _ptr_dependencies;

2526

uint32_t _ptr_service_start_name;

2527

uint32_t _ptr_password;

2528

TALLOC_CTX *_mem_save_scmanager_handle_0;

2529

TALLOC_CTX *_mem_save_DisplayName_0;

2530

TALLOC_CTX *_mem_save_LoadOrderGroupKey_0;

2531

TALLOC_CTX *_mem_save_TagId_0;

2532

TALLOC_CTX *_mem_save_dependencies_0;

2533

TALLOC_CTX *_mem_save_service_start_name_0;

2534

TALLOC_CTX *_mem_save_password_0;

2535

TALLOC_CTX *_mem_save_handle_0;

2536

if (flags & NDR_IN) {

2537

ZERO_STRUCT(r->out);

2538

2539

if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {

2540

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

2541

}

2542

_mem_save_scmanager_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);

2543

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

2544

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

2545

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_scmanager_handle_0, LIBNDR_FLAG_REF_ALLOC);

2546

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

2547

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

2548

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

2549

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

2550

}

2551

NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.ServiceName), sizeof(uint16_t)));

2552

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

2553

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_DisplayName));

2554

if (_ptr_DisplayName) {

2555

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

2556

} else {

2557

r->in.DisplayName = NULL;

2558

}

2559

if (r->in.DisplayName) {

2560

_mem_save_DisplayName_0 = NDR_PULL_GET_MEM_CTX(ndr);

2561

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

2562

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

2563

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

2564

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

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

2566

}

2567

NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.DisplayName), sizeof(uint16_t)));

2568

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

2569

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_DisplayName_0, 0);

2570

}

2571

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

2572

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

2573

NDR_CHECK(ndr_pull_svcctl_StartType(ndr, NDR_SCALARS, &r->in.start_type));

2574

NDR_CHECK(ndr_pull_svcctl_ErrorControl(ndr, NDR_SCALARS, &r->in.error_control));

2575

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

2576

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

2577

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

2578

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

2579

}

2580

NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.binary_path), sizeof(uint16_t)));

2581

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

2582

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_LoadOrderGroupKey));

2583

if (_ptr_LoadOrderGroupKey) {

2584

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

2585

} else {

2586

r->in.LoadOrderGroupKey = NULL;

2587

}

2588

if (r->in.LoadOrderGroupKey) {

2589

_mem_save_LoadOrderGroupKey_0 = NDR_PULL_GET_MEM_CTX(ndr);

2590

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

2591

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

2592

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

2593

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

2594

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

2595

}

2596

NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.LoadOrderGroupKey), sizeof(uint16_t)));

2597

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

2598

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_LoadOrderGroupKey_0, 0);

2599

}

2600

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_TagId));

2601

if (_ptr_TagId) {

2602

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

2603

} else {

2604

r->in.TagId = NULL;

2605

}

2606

if (r->in.TagId) {

2607

_mem_save_TagId_0 = NDR_PULL_GET_MEM_CTX(ndr);

2608

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

2609

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

2610

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_TagId_0, 0);

2611

}

2612

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dependencies));

2613

if (_ptr_dependencies) {

2614

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

2615

} else {

2616

r->in.dependencies = NULL;

2617

}

2618

if (r->in.dependencies) {

2619

_mem_save_dependencies_0 = NDR_PULL_GET_MEM_CTX(ndr);

2620

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

2621

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

2622

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

2623

NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->in.dependencies, ndr_get_array_size(ndr, &r->in.dependencies)));

2624

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dependencies_0, 0);

2625

}

2626

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

2627

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_service_start_name));

2628

if (_ptr_service_start_name) {

2629

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

2630

} else {

2631

r->in.service_start_name = NULL;

2632

}

2633

if (r->in.service_start_name) {

2634

_mem_save_service_start_name_0 = NDR_PULL_GET_MEM_CTX(ndr);

2635

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

2636

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

2637

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

2638

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

2639

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

2640

}

2641

NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.service_start_name), sizeof(uint16_t)));

2642

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

2643

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_service_start_name_0, 0);

2644

}

2645

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_password));

2646

if (_ptr_password) {

2647

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

2648

} else {

2649

r->in.password = NULL;

2650

}

2651

if (r->in.password) {

2652

_mem_save_password_0 = NDR_PULL_GET_MEM_CTX(ndr);

2653

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

2654

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

2655

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

2656

NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->in.password, ndr_get_array_size(ndr, &r->in.password)));

2657

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_password_0, 0);

2658

}

2659

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

2660

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

2661

ZERO_STRUCTP(r->out.handle);

2662

if (r->in.dependencies) {

2663

NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->in.dependencies, r->in.dependencies_size));

2664

}

2665

if (r->in.password) {

2666

NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->in.password, r->in.password_size));

2667

}

2668

}

2669

if (flags & NDR_OUT) {

2670

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_TagId));

2671

if (_ptr_TagId) {

2672

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

2673

} else {

2674

r->out.TagId = NULL;

2675

}

2676

if (r->out.TagId) {

2677

_mem_save_TagId_0 = NDR_PULL_GET_MEM_CTX(ndr);

2678

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

2679

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

2680

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_TagId_0, 0);

2681

}

2682

if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {

2683

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

2684

}

2685

_mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);

2686

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

2687

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

2688

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);

2689

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

2690

}

2691

return NDR_ERR_SUCCESS;

2692

}

2693

2694

_PUBLIC_ void ndr_print_svcctl_CreateServiceW(struct ndr_print *ndr, const char *name, int flags, const struct svcctl_CreateServiceW *r)

2695

{

2696

ndr_print_struct(ndr, name, "svcctl_CreateServiceW");

2697

ndr->depth++;

2698

if (flags & NDR_SET_VALUES) {

2699

ndr->flags |= LIBNDR_PRINT_SET_VALUES;

2700

}

2701

if (flags & NDR_IN) {

2702

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

2703

ndr->depth++;

2704

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

2705

ndr->depth++;

2706

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

2707

ndr->depth--;

2708

ndr_print_string(ndr, "ServiceName", r->in.ServiceName);

2709

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

2710

ndr->depth++;

2711

if (r->in.DisplayName) {

2712

ndr_print_string(ndr, "DisplayName", r->in.DisplayName);

2713

}

2714

ndr->depth--;

2715

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

2716

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

2717

ndr_print_svcctl_StartType(ndr, "start_type", r->in.start_type);

2718

ndr_print_svcctl_ErrorControl(ndr, "error_control", r->in.error_control);

2719

ndr_print_string(ndr, "binary_path", r->in.binary_path);

2720

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

2721

ndr->depth++;

2722

if (r->in.LoadOrderGroupKey) {

2723

ndr_print_string(ndr, "LoadOrderGroupKey", r->in.LoadOrderGroupKey);

2724

}

2725

ndr->depth--;

2726

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

2727

ndr->depth++;

2728

if (r->in.TagId) {

2729

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

2730

}

2731

ndr->depth--;

2732

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

2733

ndr->depth++;

2734

if (r->in.dependencies) {

2735

ndr_print_array_uint8(ndr, "dependencies", r->in.dependencies, r->in.dependencies_size);

2736

}

2737

ndr->depth--;

2738

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

2739

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

2740

ndr->depth++;

2741

if (r->in.service_start_name) {

2742

ndr_print_string(ndr, "service_start_name", r->in.service_start_name);

2743

}

2744

ndr->depth--;

2745

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

2746

ndr->depth++;

2747

if (r->in.password) {

2748

ndr_print_array_uint8(ndr, "password", r->in.password, r->in.password_size);

2749

}

2750

ndr->depth--;

2751

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

2752

ndr->depth--;

2753

}

2754

if (flags & NDR_OUT) {

2755

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

2756

ndr->depth++;

2757

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

2758

ndr->depth++;

2759

if (r->out.TagId) {

2760

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

2761

}

2762

ndr->depth--;

2763

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

2764

ndr->depth++;

2765

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

2766

ndr->depth--;

2767

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

2768

ndr->depth--;

2769

}

2770

ndr->depth--;

2771

}

2772

2773

static enum ndr_err_code ndr_push_svcctl_EnumDependentServicesW(struct ndr_push *ndr, int flags, const struct svcctl_EnumDependentServicesW *r)

2774

{

2775

if (flags & NDR_IN) {

2776

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

2777

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

2778

}

2779

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

2780

NDR_CHECK(ndr_push_svcctl_ServiceState(ndr, NDR_SCALARS, r->in.state));

2781

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

2782

}

2783

if (flags & NDR_OUT) {

2784

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

2785

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

2786

}

2787

NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->in.offered));

2788

NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->out.service_status, r->in.offered));

2789

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

2790

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

2791

}

2792

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

2793

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

2794

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

2795

}

2796

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

2797

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

2798

}

2799

return NDR_ERR_SUCCESS;

2800

}

2801

2802

static enum ndr_err_code ndr_pull_svcctl_EnumDependentServicesW(struct ndr_pull *ndr, int flags, struct svcctl_EnumDependentServicesW *r)

2803

{

2804

TALLOC_CTX *_mem_save_service_0;

2805

TALLOC_CTX *_mem_save_needed_0;

2806

TALLOC_CTX *_mem_save_services_returned_0;

2807

if (flags & NDR_IN) {

2808

ZERO_STRUCT(r->out);

2809

2810

if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {

2811

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

2812

}

2813

_mem_save_service_0 = NDR_PULL_GET_MEM_CTX(ndr);

2814

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

2815

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

2816

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_service_0, LIBNDR_FLAG_REF_ALLOC);

2817

NDR_CHECK(ndr_pull_svcctl_ServiceState(ndr, NDR_SCALARS, &r->in.state));

2818

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

2819

if (r->in.offered > 0x40000) {

2820

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

2821

}

2822

NDR_PULL_ALLOC_N(ndr, r->out.service_status, r->in.offered);

2823

memset(r->out.service_status, 0, (r->in.offered) * sizeof(*r->out.service_status));

2824

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

2825

ZERO_STRUCTP(r->out.needed);

2826

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

2827

ZERO_STRUCTP(r->out.services_returned);

2828

}

2829

if (flags & NDR_OUT) {

2830

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

2831

if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {

2832

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

2833

}

2834

NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->out.service_status, ndr_get_array_size(ndr, &r->out.service_status)));

2835

if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {

2836

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

2837

}

2838

_mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);

2839

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

2840

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

2841

if (*r->out.needed > 0x40000) {

2842

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

2843

}

2844

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);

2845

if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {

2846

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

2847

}

2848

_mem_save_services_returned_0 = NDR_PULL_GET_MEM_CTX(ndr);

2849

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

2850

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

2851

if (*r->out.services_returned > 0x40000) {

2852

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

2853

}

2854

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_services_returned_0, LIBNDR_FLAG_REF_ALLOC);

2855

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

2856

if (r->out.service_status) {

2857

NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->out.service_status, r->in.offered));

2858

}

2859

}

2860

return NDR_ERR_SUCCESS;

2861

}

2862

2863

_PUBLIC_ void ndr_print_svcctl_EnumDependentServicesW(struct ndr_print *ndr, const char *name, int flags, const struct svcctl_EnumDependentServicesW *r)

2864

{

2865

ndr_print_struct(ndr, name, "svcctl_EnumDependentServicesW");

2866

ndr->depth++;

2867

if (flags & NDR_SET_VALUES) {

2868

ndr->flags |= LIBNDR_PRINT_SET_VALUES;

2869

}

2870

if (flags & NDR_IN) {

2871

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

2872

ndr->depth++;

2873

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

2874

ndr->depth++;

2875

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

2876

ndr->depth--;

2877

ndr_print_svcctl_ServiceState(ndr, "state", r->in.state);

2878

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

2879

ndr->depth--;

2880

}

2881

if (flags & NDR_OUT) {

2882

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

2883

ndr->depth++;

2884

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

2885

ndr->depth++;

2886

ndr_print_array_uint8(ndr, "service_status", r->out.service_status, r->in.offered);

2887

ndr->depth--;

2888

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

2889

ndr->depth++;

2890

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

2891

ndr->depth--;

2892

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

2893

ndr->depth++;

2894

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

2895

ndr->depth--;

2896

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

2897

ndr->depth--;

2898

}

2899

ndr->depth--;

2900

}

2901

2902

static enum ndr_err_code ndr_push_svcctl_EnumServicesStatusW(struct ndr_push *ndr, int flags, const struct svcctl_EnumServicesStatusW *r)

2903

{

2904

if (flags & NDR_IN) {

2905

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

2906

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

2907

}

2908

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

2909

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

2910

NDR_CHECK(ndr_push_svcctl_ServiceState(ndr, NDR_SCALARS, r->in.state));

2911

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

2912

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

2913

if (r->in.resume_handle) {

2914

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

2915

}

2916

}

2917

if (flags & NDR_OUT) {

2918

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

2919

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

2920

}

2921

NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->in.offered));

2922

NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->out.service, r->in.offered));

2923

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

2924

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

2925

}

2926

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

2927

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

2928

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

2929

}

2930

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

2931

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

2932

if (r->out.resume_handle) {

2933

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

2934

}

2935

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

2936

}

2937

return NDR_ERR_SUCCESS;

2938

}

2939

2940

static enum ndr_err_code ndr_pull_svcctl_EnumServicesStatusW(struct ndr_pull *ndr, int flags, struct svcctl_EnumServicesStatusW *r)

2941

{

2942

uint32_t _ptr_resume_handle;

2943

TALLOC_CTX *_mem_save_handle_0;

2944

TALLOC_CTX *_mem_save_needed_0;

2945

TALLOC_CTX *_mem_save_services_returned_0;

2946

TALLOC_CTX *_mem_save_resume_handle_0;

2947

if (flags & NDR_IN) {

2948

ZERO_STRUCT(r->out);

2949

2950

if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {

2951

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

2952

}

2953

_mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);

2954

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

2955

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

2956

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);

2957

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

2958

NDR_CHECK(ndr_pull_svcctl_ServiceState(ndr, NDR_SCALARS, &r->in.state));

2959

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

2960

if (r->in.offered > 0x40000) {

2961

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

2962

}

2963

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_resume_handle));

2964

if (_ptr_resume_handle) {

2965

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

2966

} else {

2967

r->in.resume_handle = NULL;

2968

}

2969

if (r->in.resume_handle) {

2970

_mem_save_resume_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);

2971

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

2972

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

2973

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_resume_handle_0, 0);

2974

}

2975

NDR_PULL_ALLOC_N(ndr, r->out.service, r->in.offered);

2976

memset(r->out.service, 0, (r->in.offered) * sizeof(*r->out.service));

2977

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

2978

ZERO_STRUCTP(r->out.needed);

2979

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

2980

ZERO_STRUCTP(r->out.services_returned);

2981

}

2982

if (flags & NDR_OUT) {

2983

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

2984

if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {

2985

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

2986

}

2987

NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->out.service, ndr_get_array_size(ndr, &r->out.service)));

2988

if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {

2989

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

2990

}

2991

_mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);

2992

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

2993

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

2994

if (*r->out.needed > 0x40000) {

2995

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

2996

}

2997

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);

2998

if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {

2999

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

3000

}

3001

_mem_save_services_returned_0 = NDR_PULL_GET_MEM_CTX(ndr);

3002

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

3003

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

3004

if (*r->out.services_returned > 0x40000) {

3005

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

3006

}

3007

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_services_returned_0, LIBNDR_FLAG_REF_ALLOC);

3008

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_resume_handle));

3009

if (_ptr_resume_handle) {

3010

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

3011

} else {

3012

r->out.resume_handle = NULL;

3013

}

3014

if (r->out.resume_handle) {

3015

_mem_save_resume_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);

3016

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

3017

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

3018

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_resume_handle_0, 0);

3019

}

3020

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

3021

if (r->out.service) {

3022

NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->out.service, r->in.offered));

3023

}

3024

}

3025

return NDR_ERR_SUCCESS;

3026

}

3027

3028

_PUBLIC_ void ndr_print_svcctl_EnumServicesStatusW(struct ndr_print *ndr, const char *name, int flags, const struct svcctl_EnumServicesStatusW *r)

3029

{

3030

ndr_print_struct(ndr, name, "svcctl_EnumServicesStatusW");

3031

ndr->depth++;

3032

if (flags & NDR_SET_VALUES) {

3033

ndr->flags |= LIBNDR_PRINT_SET_VALUES;

3034

}

3035

if (flags & NDR_IN) {

3036

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

3037

ndr->depth++;

3038

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

3039

ndr->depth++;

3040

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

3041

ndr->depth--;

3042

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

3043

ndr_print_svcctl_ServiceState(ndr, "state", r->in.state);

3044

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

3045

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

3046

ndr->depth++;

3047

if (r->in.resume_handle) {

3048

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

3049

}

3050

ndr->depth--;

3051

ndr->depth--;

3052

}

3053

if (flags & NDR_OUT) {

3054

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

3055

ndr->depth++;

3056

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

3057

ndr->depth++;

3058

ndr_print_array_uint8(ndr, "service", r->out.service, r->in.offered);

3059

ndr->depth--;

3060

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

3061

ndr->depth++;

3062

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

3063

ndr->depth--;

3064

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

3065

ndr->depth++;

3066

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

3067

ndr->depth--;

3068

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

3069

ndr->depth++;

3070

if (r->out.resume_handle) {

3071

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

3072

}

3073

ndr->depth--;

3074

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

3075

ndr->depth--;

3076

}

3077

ndr->depth--;

3078

}

3079

3080

static enum ndr_err_code ndr_push_svcctl_OpenSCManagerW(struct ndr_push *ndr, int flags, const struct svcctl_OpenSCManagerW *r)

3081

{

3082

if (flags & NDR_IN) {

3083

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

3084

if (r->in.MachineName) {

3085

NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.MachineName, CH_UTF16)));

3086

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

3087

NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.MachineName, CH_UTF16)));

3088

NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.MachineName, ndr_charset_length(r->in.MachineName, CH_UTF16), sizeof(uint16_t), CH_UTF16));

3089

}

3090

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

3091

if (r->in.DatabaseName) {

3092

NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.DatabaseName, CH_UTF16)));

3093

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

3094

NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.DatabaseName, CH_UTF16)));

3095

NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.DatabaseName, ndr_charset_length(r->in.DatabaseName, CH_UTF16), sizeof(uint16_t), CH_UTF16));

3096

}

3097

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

3098

}

3099

if (flags & NDR_OUT) {

3100

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

3101

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

3102

}

3103

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

3104

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

3105

}

3106

return NDR_ERR_SUCCESS;

3107

}

3108

3109

static enum ndr_err_code ndr_pull_svcctl_OpenSCManagerW(struct ndr_pull *ndr, int flags, struct svcctl_OpenSCManagerW *r)

3110

{

3111

uint32_t _ptr_MachineName;

3112

uint32_t _ptr_DatabaseName;

3113

TALLOC_CTX *_mem_save_MachineName_0;

3114

TALLOC_CTX *_mem_save_DatabaseName_0;

3115

TALLOC_CTX *_mem_save_handle_0;

3116

if (flags & NDR_IN) {

3117

ZERO_STRUCT(r->out);

3118

3119

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_MachineName));

3120

if (_ptr_MachineName) {

3121

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

3122

} else {

3123

r->in.MachineName = NULL;

3124

}

3125

if (r->in.MachineName) {

3126

_mem_save_MachineName_0 = NDR_PULL_GET_MEM_CTX(ndr);

3127

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

3128

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

3129

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

3130

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

3131

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

3132

}

3133

NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.MachineName), sizeof(uint16_t)));

3134

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

3135

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_MachineName_0, 0);

3136

}

3137

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_DatabaseName));

3138

if (_ptr_DatabaseName) {

3139

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

3140

} else {

3141

r->in.DatabaseName = NULL;

3142

}

3143

if (r->in.DatabaseName) {

3144

_mem_save_DatabaseName_0 = NDR_PULL_GET_MEM_CTX(ndr);

3145

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

3146

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

3147

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

3148

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

3149

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

3150

}

3151

NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.DatabaseName), sizeof(uint16_t)));

3152

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

3153

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_DatabaseName_0, 0);

3154

}

3155

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

3156

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

3157

ZERO_STRUCTP(r->out.handle);

3158

}

3159

if (flags & NDR_OUT) {

3160

if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {

3161

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

3162

}

3163

_mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);

3164

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

3165

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

3166

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);

3167

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

3168

}

3169

return NDR_ERR_SUCCESS;

3170

}

3171

3172

_PUBLIC_ void ndr_print_svcctl_OpenSCManagerW(struct ndr_print *ndr, const char *name, int flags, const struct svcctl_OpenSCManagerW *r)

3173

{

3174

ndr_print_struct(ndr, name, "svcctl_OpenSCManagerW");

3175

ndr->depth++;

3176

if (flags & NDR_SET_VALUES) {

3177

ndr->flags |= LIBNDR_PRINT_SET_VALUES;

3178

}

3179

if (flags & NDR_IN) {

3180

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

3181

ndr->depth++;

3182

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

3183

ndr->depth++;

3184

if (r->in.MachineName) {

3185

ndr_print_string(ndr, "MachineName", r->in.MachineName);

3186

}

3187

ndr->depth--;

3188

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

3189

ndr->depth++;

3190

if (r->in.DatabaseName) {

3191

ndr_print_string(ndr, "DatabaseName", r->in.DatabaseName);

3192

}

3193

ndr->depth--;

3194

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

3195

ndr->depth--;

3196

}

3197

if (flags & NDR_OUT) {

3198

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

3199

ndr->depth++;

3200

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

3201

ndr->depth++;

3202

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

3203

ndr->depth--;

3204

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

3205

ndr->depth--;

3206

}

3207

ndr->depth--;

3208

}

3209

3210

static enum ndr_err_code ndr_push_svcctl_OpenServiceW(struct ndr_push *ndr, int flags, const struct svcctl_OpenServiceW *r)

3211

{

3212

if (flags & NDR_IN) {

3213

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

3214

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

3215

}

3216

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

3217

NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.ServiceName, CH_UTF16)));

3218

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

3219

NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.ServiceName, CH_UTF16)));

3220

NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.ServiceName, ndr_charset_length(r->in.ServiceName, CH_UTF16), sizeof(uint16_t), CH_UTF16));

3221

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

3222

}

3223

if (flags & NDR_OUT) {

3224

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

3225

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

3226

}

3227

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

3228

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

3229

}

3230

return NDR_ERR_SUCCESS;

3231

}

3232

3233

static enum ndr_err_code ndr_pull_svcctl_OpenServiceW(struct ndr_pull *ndr, int flags, struct svcctl_OpenServiceW *r)

3234

{

3235

TALLOC_CTX *_mem_save_scmanager_handle_0;

3236

TALLOC_CTX *_mem_save_handle_0;

3237

if (flags & NDR_IN) {

3238

ZERO_STRUCT(r->out);

3239

3240

if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {

3241

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

3242

}

3243

_mem_save_scmanager_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);

3244

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

3245

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

3246

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_scmanager_handle_0, LIBNDR_FLAG_REF_ALLOC);

3247

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

3248

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

3249

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

3250

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

3251

}

3252

NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.ServiceName), sizeof(uint16_t)));

3253

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

3254

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

3255

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

3256

ZERO_STRUCTP(r->out.handle);

3257

}

3258

if (flags & NDR_OUT) {

3259

if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {

3260

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

3261

}

3262

_mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);

3263

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

3264

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

3265

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);

3266

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

3267

}

3268

return NDR_ERR_SUCCESS;

3269

}

3270

3271

_PUBLIC_ void ndr_print_svcctl_OpenServiceW(struct ndr_print *ndr, const char *name, int flags, const struct svcctl_OpenServiceW *r)

3272

{

3273

ndr_print_struct(ndr, name, "svcctl_OpenServiceW");

3274

ndr->depth++;

3275

if (flags & NDR_SET_VALUES) {

3276

ndr->flags |= LIBNDR_PRINT_SET_VALUES;

3277

}

3278

if (flags & NDR_IN) {

3279

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

3280

ndr->depth++;

3281

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

3282

ndr->depth++;

3283

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

3284

ndr->depth--;

3285

ndr_print_string(ndr, "ServiceName", r->in.ServiceName);

3286

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

3287

ndr->depth--;

3288

}

3289

if (flags & NDR_OUT) {

3290

ndr_print_struct(ndr, "out", "svcctl_OpenServiceW");

3291

ndr->depth++;

3292

ndr_print_ptr(ndr, "handle", r->out.handle);

3293

ndr->depth++;

3294

ndr_print_policy_handle(ndr, "handle", r->out.handle);

3295

ndr->depth--;

3296

ndr_print_WERROR(ndr, "result", r->out.result);

3297

ndr->depth--;

3298

}

3299

ndr->depth--;

3300

}

3301

3302

static enum ndr_err_code ndr_push_svcctl_QueryServiceConfigW(struct ndr_push *ndr, int flags, const struct svcctl_QueryServiceConfigW *r)

3303

{

3304

if (flags & NDR_IN) {

3305

if (r->in.handle == NULL) {

3306

return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");

3307

}

3308

NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));

3309

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));

3310

}

3311

if (flags & NDR_OUT) {

3312

if (r->out.query == NULL) {

3313

return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");

3314

}

3315

NDR_CHECK(ndr_push_QUERY_SERVICE_CONFIG(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.query));

3316

if (r->out.needed == NULL) {

3317

return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");

3318

}

3319

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));

3320

NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));

3321

}

3322

return NDR_ERR_SUCCESS;

3323

}

3324

3325

static enum ndr_err_code ndr_pull_svcctl_QueryServiceConfigW(struct ndr_pull *ndr, int flags, struct svcctl_QueryServiceConfigW *r)

3326

{

3327

TALLOC_CTX *_mem_save_handle_0;

3328

TALLOC_CTX *_mem_save_query_0;

3329

TALLOC_CTX *_mem_save_needed_0;

3330

if (flags & NDR_IN) {

3331

ZERO_STRUCT(r->out);

3332

3333

if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {

3334

NDR_PULL_ALLOC(ndr, r->in.handle);

3335

}

3336

_mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);

3337

NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);

3338

NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));

3339

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);

3340

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));

3341

if (r->in.offered > 8192) {

3342

return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");

3343

}

3344

NDR_PULL_ALLOC(ndr, r->out.query);

3345

ZERO_STRUCTP(r->out.query);

3346

NDR_PULL_ALLOC(ndr, r->out.needed);

3347

ZERO_STRUCTP(r->out.needed);

3348

}

3349

if (flags & NDR_OUT) {

3350

if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {

3351

NDR_PULL_ALLOC(ndr, r->out.query);

3352

}

3353

_mem_save_query_0 = NDR_PULL_GET_MEM_CTX(ndr);

3354

NDR_PULL_SET_MEM_CTX(ndr, r->out.query, LIBNDR_FLAG_REF_ALLOC);

3355

NDR_CHECK(ndr_pull_QUERY_SERVICE_CONFIG(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.query));

3356

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_query_0, LIBNDR_FLAG_REF_ALLOC);

3357

if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {

3358

NDR_PULL_ALLOC(ndr, r->out.needed);

3359

}

3360

_mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);

3361

NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);

3362

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));

3363

if (*r->out.needed > 8192) {

3364

return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");

3365

}

3366

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);

3367

NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));

3368

}

3369

return NDR_ERR_SUCCESS;

3370

}

3371

3372

_PUBLIC_ void ndr_print_svcctl_QueryServiceConfigW(struct ndr_print *ndr, const char *name, int flags, const struct svcctl_QueryServiceConfigW *r)

3373

{

3374

ndr_print_struct(ndr, name, "svcctl_QueryServiceConfigW");

3375

ndr->depth++;

3376

if (flags & NDR_SET_VALUES) {

3377

ndr->flags |= LIBNDR_PRINT_SET_VALUES;

3378

}

3379

if (flags & NDR_IN) {

3380

ndr_print_struct(ndr, "in", "svcctl_QueryServiceConfigW");

3381

ndr->depth++;

3382

ndr_print_ptr(ndr, "handle", r->in.handle);

3383

ndr->depth++;

3384

ndr_print_policy_handle(ndr, "handle", r->in.handle);

3385

ndr->depth--;

3386

ndr_print_uint32(ndr, "offered", r->in.offered);

3387

ndr->depth--;

3388

}

3389

if (flags & NDR_OUT) {

3390

ndr_print_struct(ndr, "out", "svcctl_QueryServiceConfigW");

3391

ndr->depth++;

3392

ndr_print_ptr(ndr, "query", r->out.query);

3393

ndr->depth++;

3394

ndr_print_QUERY_SERVICE_CONFIG(ndr, "query", r->out.query);

3395

ndr->depth--;

3396

ndr_print_ptr(ndr, "needed", r->out.needed);

3397

ndr->depth++;

3398

ndr_print_uint32(ndr, "needed", *r->out.needed);

3399

ndr->depth--;

3400

ndr_print_WERROR(ndr, "result", r->out.result);

3401

ndr->depth--;

3402

}

3403

ndr->depth--;

3404

}

3405

3406

static enum ndr_err_code ndr_push_svcctl_QueryServiceLockStatusW(struct ndr_push *ndr, int flags, const struct svcctl_QueryServiceLockStatusW *r)

3407

{

3408

if (flags & NDR_IN) {

3409

if (r->in.handle == NULL) {

3410

return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");

3411

}

3412

NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));

3413

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));

3414

}

3415

if (flags & NDR_OUT) {

3416

if (r->out.lock_status == NULL) {

3417

return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");

3418

}

3419

NDR_CHECK(ndr_push_SERVICE_LOCK_STATUS(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.lock_status));

3420

if (r->out.needed == NULL) {

3421

return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");

3422

}

3423

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));

3424

NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));

3425

}

3426

return NDR_ERR_SUCCESS;

3427

}

3428

3429

static enum ndr_err_code ndr_pull_svcctl_QueryServiceLockStatusW(struct ndr_pull *ndr, int flags, struct svcctl_QueryServiceLockStatusW *r)

3430

{

3431

TALLOC_CTX *_mem_save_handle_0;

3432

TALLOC_CTX *_mem_save_lock_status_0;

3433

TALLOC_CTX *_mem_save_needed_0;

3434

if (flags & NDR_IN) {

3435

ZERO_STRUCT(r->out);

3436

3437

if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {

3438

NDR_PULL_ALLOC(ndr, r->in.handle);

3439

}

3440

_mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);

3441

NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);

3442

NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));

3443

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);

3444

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));

3445

NDR_PULL_ALLOC(ndr, r->out.lock_status);

3446

ZERO_STRUCTP(r->out.lock_status);

3447

NDR_PULL_ALLOC(ndr, r->out.needed);

3448

ZERO_STRUCTP(r->out.needed);

3449

}

3450

if (flags & NDR_OUT) {

3451

if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {

3452

NDR_PULL_ALLOC(ndr, r->out.lock_status);

3453

}

3454

_mem_save_lock_status_0 = NDR_PULL_GET_MEM_CTX(ndr);

3455

NDR_PULL_SET_MEM_CTX(ndr, r->out.lock_status, LIBNDR_FLAG_REF_ALLOC);

3456

NDR_CHECK(ndr_pull_SERVICE_LOCK_STATUS(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.lock_status));

3457

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_lock_status_0, LIBNDR_FLAG_REF_ALLOC);

3458

if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {

3459

NDR_PULL_ALLOC(ndr, r->out.needed);

3460

}

3461

_mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);

3462

NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);

3463

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));

3464

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);

3465

NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));

3466

}

3467

return NDR_ERR_SUCCESS;

3468

}

3469

3470

_PUBLIC_ void ndr_print_svcctl_QueryServiceLockStatusW(struct ndr_print *ndr, const char *name, int flags, const struct svcctl_QueryServiceLockStatusW *r)

3471

{

3472

ndr_print_struct(ndr, name, "svcctl_QueryServiceLockStatusW");

3473

ndr->depth++;

3474

if (flags & NDR_SET_VALUES) {

3475

ndr->flags |= LIBNDR_PRINT_SET_VALUES;

3476

}

3477

if (flags & NDR_IN) {

3478

ndr_print_struct(ndr, "in", "svcctl_QueryServiceLockStatusW");

3479

ndr->depth++;

3480

ndr_print_ptr(ndr, "handle", r->in.handle);

3481

ndr->depth++;

3482

ndr_print_policy_handle(ndr, "handle", r->in.handle);

3483

ndr->depth--;

3484

ndr_print_uint32(ndr, "offered", r->in.offered);

3485

ndr->depth--;

3486

}

3487

if (flags & NDR_OUT) {

3488

ndr_print_struct(ndr, "out", "svcctl_QueryServiceLockStatusW");

3489

ndr->depth++;

3490

ndr_print_ptr(ndr, "lock_status", r->out.lock_status);

3491

ndr->depth++;

3492

ndr_print_SERVICE_LOCK_STATUS(ndr, "lock_status", r->out.lock_status);

3493

ndr->depth--;

3494

ndr_print_ptr(ndr, "needed", r->out.needed);

3495

ndr->depth++;

3496

ndr_print_uint32(ndr, "needed", *r->out.needed);

3497

ndr->depth--;

3498

ndr_print_WERROR(ndr, "result", r->out.result);

3499

ndr->depth--;

3500

}

3501

ndr->depth--;

3502

}

3503

3504

static enum ndr_err_code ndr_push_svcctl_StartServiceW(struct ndr_push *ndr, int flags, const struct svcctl_StartServiceW *r)

3505

{

3506

uint32_t cntr_Arguments_1;

3507

if (flags & NDR_IN) {

3508

if (r->in.handle == NULL) {

3509

return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");

3510

}

3511

NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));

3512

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.NumArgs));

3513

NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.Arguments));

3514

if (r->in.Arguments) {

3515

NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->in.NumArgs));

3516

for (cntr_Arguments_1 = 0; cntr_Arguments_1 < r->in.NumArgs; cntr_Arguments_1++) {

3517

NDR_CHECK(ndr_push_svcctl_ArgumentString(ndr, NDR_SCALARS, &r->in.Arguments[cntr_Arguments_1]));

3518

}

3519

for (cntr_Arguments_1 = 0; cntr_Arguments_1 < r->in.NumArgs; cntr_Arguments_1++) {

3520

NDR_CHECK(ndr_push_svcctl_ArgumentString(ndr, NDR_BUFFERS, &r->in.Arguments[cntr_Arguments_1]));

3521

}

3522

}

3523

}

3524

if (flags & NDR_OUT) {

3525

NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));

3526

}

3527

return NDR_ERR_SUCCESS;

3528

}

3529

3530

static enum ndr_err_code ndr_pull_svcctl_StartServiceW(struct ndr_pull *ndr, int flags, struct svcctl_StartServiceW *r)

3531

{

3532

uint32_t _ptr_Arguments;

3533

uint32_t cntr_Arguments_1;

3534

TALLOC_CTX *_mem_save_handle_0;

3535

TALLOC_CTX *_mem_save_Arguments_0;

3536

TALLOC_CTX *_mem_save_Arguments_1;

3537

if (flags & NDR_IN) {

3538

if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {

3539

NDR_PULL_ALLOC(ndr, r->in.handle);

3540

}

3541

_mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);

3542

NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);

3543

NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));

3544

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);

3545

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.NumArgs));

3546

if (r->in.NumArgs > SC_MAX_ARGUMENTS) {

3547

return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");

3548

}

3549

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_Arguments));

3550

if (_ptr_Arguments) {

3551

NDR_PULL_ALLOC(ndr, r->in.Arguments);

3552

} else {

3553

r->in.Arguments = NULL;

3554

}

3555

if (r->in.Arguments) {

3556

_mem_save_Arguments_0 = NDR_PULL_GET_MEM_CTX(ndr);

3557

NDR_PULL_SET_MEM_CTX(ndr, r->in.Arguments, 0);

3558

NDR_CHECK(ndr_pull_array_size(ndr, &r->in.Arguments));

3559

NDR_PULL_ALLOC_N(ndr, r->in.Arguments, ndr_get_array_size(ndr, &r->in.Arguments));

3560

_mem_save_Arguments_1 = NDR_PULL_GET_MEM_CTX(ndr);

3561

NDR_PULL_SET_MEM_CTX(ndr, r->in.Arguments, 0);

3562

for (cntr_Arguments_1 = 0; cntr_Arguments_1 < r->in.NumArgs; cntr_Arguments_1++) {

3563

NDR_CHECK(ndr_pull_svcctl_ArgumentString(ndr, NDR_SCALARS, &r->in.Arguments[cntr_Arguments_1]));

3564

}

3565

for (cntr_Arguments_1 = 0; cntr_Arguments_1 < r->in.NumArgs; cntr_Arguments_1++) {

3566

NDR_CHECK(ndr_pull_svcctl_ArgumentString(ndr, NDR_BUFFERS, &r->in.Arguments[cntr_Arguments_1]));

3567

}

3568

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_Arguments_1, 0);

3569

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_Arguments_0, 0);

3570

}

3571

if (r->in.Arguments) {

3572

NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->in.Arguments, r->in.NumArgs));

3573

}

3574

}

3575

if (flags & NDR_OUT) {

3576

NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));

3577

}

3578

return NDR_ERR_SUCCESS;

3579

}

3580

3581

_PUBLIC_ void ndr_print_svcctl_StartServiceW(struct ndr_print *ndr, const char *name, int flags, const struct svcctl_StartServiceW *r)

3582

{

3583

uint32_t cntr_Arguments_1;

3584

ndr_print_struct(ndr, name, "svcctl_StartServiceW");

3585

ndr->depth++;

3586

if (flags & NDR_SET_VALUES) {

3587

ndr->flags |= LIBNDR_PRINT_SET_VALUES;

3588

}

3589

if (flags & NDR_IN) {

3590

ndr_print_struct(ndr, "in", "svcctl_StartServiceW");

3591

ndr->depth++;

3592

ndr_print_ptr(ndr, "handle", r->in.handle);

3593

ndr->depth++;

3594

ndr_print_policy_handle(ndr, "handle", r->in.handle);

3595

ndr->depth--;

3596

ndr_print_uint32(ndr, "NumArgs", r->in.NumArgs);

3597

ndr_print_ptr(ndr, "Arguments", r->in.Arguments);

3598

ndr->depth++;

3599

if (r->in.Arguments) {

3600

ndr->print(ndr, "%s: ARRAY(%d)", "Arguments", (int)r->in.NumArgs);

3601

ndr->depth++;

3602

for (cntr_Arguments_1=0;cntr_Arguments_1<r->in.NumArgs;cntr_Arguments_1++) {

3603

char *idx_1=NULL;

3604

if (asprintf(&idx_1, "[%d]", cntr_Arguments_1) != -1) {

3605

ndr_print_svcctl_ArgumentString(ndr, "Arguments", &r->in.Arguments[cntr_Arguments_1]);

3606

free(idx_1);

3607

}

3608

}

3609

ndr->depth--;

3610

}

3611

ndr->depth--;

3612

ndr->depth--;

3613

}

3614

if (flags & NDR_OUT) {

3615

ndr_print_struct(ndr, "out", "svcctl_StartServiceW");

3616

ndr->depth++;

3617

ndr_print_WERROR(ndr, "result", r->out.result);

3618

ndr->depth--;

3619

}

3620

ndr->depth--;

3621

}

3622

3623

static enum ndr_err_code ndr_push_svcctl_GetServiceDisplayNameW(struct ndr_push *ndr, int flags, const struct svcctl_GetServiceDisplayNameW *r)

3624

{

3625

if (flags & NDR_IN) {

3626

if (r->in.handle == NULL) {

3627

return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");

3628

}

3629

NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));

3630

NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.service_name));

3631

if (r->in.service_name) {

3632

NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.service_name, CH_UTF16)));

3633

NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));

3634

NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.service_name, CH_UTF16)));

3635

NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.service_name, ndr_charset_length(r->in.service_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));

3636

}

3637

NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.display_name_length));

3638

if (r->in.display_name_length) {

3639

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->in.display_name_length));

3640

}

3641

}

3642

if (flags & NDR_OUT) {

3643

if (r->out.display_name == NULL) {

3644

return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");

3645

}

3646

NDR_CHECK(ndr_push_unique_ptr(ndr, *r->out.display_name));

3647

if (*r->out.display_name) {

3648

NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(*r->out.display_name, CH_UTF16)));

3649

NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));

3650

NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(*r->out.display_name, CH_UTF16)));

3651

NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, *r->out.display_name, ndr_charset_length(*r->out.display_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));

3652

}

3653

NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.display_name_length));

3654

if (r->out.display_name_length) {

3655

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.display_name_length));

3656

}

3657

NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));

3658

}

3659

return NDR_ERR_SUCCESS;

3660

}

3661

3662

static enum ndr_err_code ndr_pull_svcctl_GetServiceDisplayNameW(struct ndr_pull *ndr, int flags, struct svcctl_GetServiceDisplayNameW *r)

3663

{

3664

uint32_t _ptr_service_name;

3665

uint32_t _ptr_display_name;

3666

uint32_t _ptr_display_name_length;

3667

TALLOC_CTX *_mem_save_handle_0;

3668

TALLOC_CTX *_mem_save_service_name_0;

3669

TALLOC_CTX *_mem_save_display_name_0;

3670

TALLOC_CTX *_mem_save_display_name_1;

3671

TALLOC_CTX *_mem_save_display_name_length_0;

3672

if (flags & NDR_IN) {

3673

ZERO_STRUCT(r->out);

3674

3675

if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {

3676

NDR_PULL_ALLOC(ndr, r->in.handle);

3677

}

3678

_mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);

3679

NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);

3680

NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));

3681

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);

3682

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_service_name));

3683

if (_ptr_service_name) {

3684

NDR_PULL_ALLOC(ndr, r->in.service_name);

3685

} else {

3686

r->in.service_name = NULL;

3687

}

3688

if (r->in.service_name) {

3689

_mem_save_service_name_0 = NDR_PULL_GET_MEM_CTX(ndr);

3690

NDR_PULL_SET_MEM_CTX(ndr, r->in.service_name, 0);

3691

NDR_CHECK(ndr_pull_array_size(ndr, &r->in.service_name));

3692

NDR_CHECK(ndr_pull_array_length(ndr, &r->in.service_name));

3693

if (ndr_get_array_length(ndr, &r->in.service_name) > ndr_get_array_size(ndr, &r->in.service_name)) {

3694

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.service_name), ndr_get_array_length(ndr, &r->in.service_name));

3695

}

3696

NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.service_name), sizeof(uint16_t)));

3697

NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.service_name, ndr_get_array_length(ndr, &r->in.service_name), sizeof(uint16_t), CH_UTF16));

3698

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_service_name_0, 0);

3699

}

3700

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_display_name_length));

3701

if (_ptr_display_name_length) {

3702

NDR_PULL_ALLOC(ndr, r->in.display_name_length);

3703

} else {

3704

r->in.display_name_length = NULL;

3705

}

3706

if (r->in.display_name_length) {

3707

_mem_save_display_name_length_0 = NDR_PULL_GET_MEM_CTX(ndr);

3708

NDR_PULL_SET_MEM_CTX(ndr, r->in.display_name_length, 0);

3709

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->in.display_name_length));

3710

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_display_name_length_0, 0);

3711

}

3712

NDR_PULL_ALLOC(ndr, r->out.display_name);

3713

ZERO_STRUCTP(r->out.display_name);

3714

}

3715

if (flags & NDR_OUT) {

3716

if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {

3717

NDR_PULL_ALLOC(ndr, r->out.display_name);

3718

}

3719

_mem_save_display_name_0 = NDR_PULL_GET_MEM_CTX(ndr);

3720

NDR_PULL_SET_MEM_CTX(ndr, r->out.display_name, LIBNDR_FLAG_REF_ALLOC);

3721

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_display_name));

3722

if (_ptr_display_name) {

3723

NDR_PULL_ALLOC(ndr, *r->out.display_name);

3724

} else {

3725

*r->out.display_name = NULL;

3726

}

3727

if (*r->out.display_name) {

3728

_mem_save_display_name_1 = NDR_PULL_GET_MEM_CTX(ndr);

3729

NDR_PULL_SET_MEM_CTX(ndr, *r->out.display_name, 0);

3730

NDR_CHECK(ndr_pull_array_size(ndr, r->out.display_name));

3731

NDR_CHECK(ndr_pull_array_length(ndr, r->out.display_name));

3732

if (ndr_get_array_length(ndr, r->out.display_name) > ndr_get_array_size(ndr, r->out.display_name)) {

3733

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.display_name), ndr_get_array_length(ndr, r->out.display_name));

3734

}

3735

NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, r->out.display_name), sizeof(uint16_t)));

3736

NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, r->out.display_name, ndr_get_array_length(ndr, r->out.display_name), sizeof(uint16_t), CH_UTF16));

3737

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_display_name_1, 0);

3738

}

3739

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_display_name_0, LIBNDR_FLAG_REF_ALLOC);

3740

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_display_name_length));

3741

if (_ptr_display_name_length) {

3742

NDR_PULL_ALLOC(ndr, r->out.display_name_length);

3743

} else {

3744

r->out.display_name_length = NULL;

3745

}

3746

if (r->out.display_name_length) {

3747

_mem_save_display_name_length_0 = NDR_PULL_GET_MEM_CTX(ndr);

3748

NDR_PULL_SET_MEM_CTX(ndr, r->out.display_name_length, 0);

3749

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.display_name_length));

3750

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_display_name_length_0, 0);

3751

}

3752

NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));

3753

}

3754

return NDR_ERR_SUCCESS;

3755

}

3756

3757

_PUBLIC_ void ndr_print_svcctl_GetServiceDisplayNameW(struct ndr_print *ndr, const char *name, int flags, const struct svcctl_GetServiceDisplayNameW *r)

3758

{

3759

ndr_print_struct(ndr, name, "svcctl_GetServiceDisplayNameW");

3760

ndr->depth++;

3761

if (flags & NDR_SET_VALUES) {

3762

ndr->flags |= LIBNDR_PRINT_SET_VALUES;

3763

}

3764

if (flags & NDR_IN) {

3765

ndr_print_struct(ndr, "in", "svcctl_GetServiceDisplayNameW");

3766

ndr->depth++;

3767

ndr_print_ptr(ndr, "handle", r->in.handle);

3768

ndr->depth++;

3769

ndr_print_policy_handle(ndr, "handle", r->in.handle);

3770

ndr->depth--;

3771

ndr_print_ptr(ndr, "service_name", r->in.service_name);

3772

ndr->depth++;

3773

if (r->in.service_name) {

3774

ndr_print_string(ndr, "service_name", r->in.service_name);

3775

}

3776

ndr->depth--;

3777

ndr_print_ptr(ndr, "display_name_length", r->in.display_name_length);

3778

ndr->depth++;

3779

if (r->in.display_name_length) {

3780

ndr_print_uint32(ndr, "display_name_length", *r->in.display_name_length);

3781

}

3782

ndr->depth--;

3783

ndr->depth--;

3784

}

3785

if (flags & NDR_OUT) {

3786

ndr_print_struct(ndr, "out", "svcctl_GetServiceDisplayNameW");

3787

ndr->depth++;

3788

ndr_print_ptr(ndr, "display_name", r->out.display_name);

3789

ndr->depth++;

3790

ndr_print_ptr(ndr, "display_name", *r->out.display_name);

3791

ndr->depth++;

3792

if (*r->out.display_name) {

3793

ndr_print_string(ndr, "display_name", *r->out.display_name);

3794

}

3795

ndr->depth--;

3796

ndr->depth--;

3797

ndr_print_ptr(ndr, "display_name_length", r->out.display_name_length);

3798

ndr->depth++;

3799

if (r->out.display_name_length) {

3800

ndr_print_uint32(ndr, "display_name_length", *r->out.display_name_length);

3801

}

3802

ndr->depth--;

3803

ndr_print_WERROR(ndr, "result", r->out.result);

3804

ndr->depth--;

3805

}

3806

ndr->depth--;

3807

}

3808

3809

static enum ndr_err_code ndr_push_svcctl_GetServiceKeyNameW(struct ndr_push *ndr, int flags, const struct svcctl_GetServiceKeyNameW *r)

3810

{

3811

if (flags & NDR_IN) {

3812

if (r->in.handle == NULL) {

3813

return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");

3814

}

3815

NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));

3816

NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.service_name));

3817

if (r->in.service_name) {

3818

NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.service_name, CH_UTF16)));

3819

NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));

3820

NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.service_name, CH_UTF16)));

3821

NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.service_name, ndr_charset_length(r->in.service_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));

3822

}

3823

NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.display_name_length));

3824

if (r->in.display_name_length) {

3825

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->in.display_name_length));

3826

}

3827

}

3828

if (flags & NDR_OUT) {

3829

if (r->out.key_name == NULL) {

3830

return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");

3831

}

3832

NDR_CHECK(ndr_push_unique_ptr(ndr, *r->out.key_name));

3833

if (*r->out.key_name) {

3834

NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(*r->out.key_name, CH_UTF16)));

3835

NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));

3836

NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(*r->out.key_name, CH_UTF16)));

3837

NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, *r->out.key_name, ndr_charset_length(*r->out.key_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));

3838

}

3839

NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.display_name_length));

3840

if (r->out.display_name_length) {

3841

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.display_name_length));

3842

}

3843

NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));

3844

}

3845

return NDR_ERR_SUCCESS;

3846

}

3847

3848

static enum ndr_err_code ndr_pull_svcctl_GetServiceKeyNameW(struct ndr_pull *ndr, int flags, struct svcctl_GetServiceKeyNameW *r)

3849

{

3850

uint32_t _ptr_service_name;

3851

uint32_t _ptr_key_name;

3852

uint32_t _ptr_display_name_length;

3853

TALLOC_CTX *_mem_save_handle_0;

3854

TALLOC_CTX *_mem_save_service_name_0;

3855

TALLOC_CTX *_mem_save_key_name_0;

3856

TALLOC_CTX *_mem_save_key_name_1;

3857

TALLOC_CTX *_mem_save_display_name_length_0;

3858

if (flags & NDR_IN) {

3859

ZERO_STRUCT(r->out);

3860

3861

if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {

3862

NDR_PULL_ALLOC(ndr, r->in.handle);

3863

}

3864

_mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);

3865

NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);

3866

NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));

3867

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);

3868

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_service_name));

3869

if (_ptr_service_name) {

3870

NDR_PULL_ALLOC(ndr, r->in.service_name);

3871

} else {

3872

r->in.service_name = NULL;

3873

}

3874

if (r->in.service_name) {

3875

_mem_save_service_name_0 = NDR_PULL_GET_MEM_CTX(ndr);

3876

NDR_PULL_SET_MEM_CTX(ndr, r->in.service_name, 0);

3877

NDR_CHECK(ndr_pull_array_size(ndr, &r->in.service_name));

3878

NDR_CHECK(ndr_pull_array_length(ndr, &r->in.service_name));

3879

if (ndr_get_array_length(ndr, &r->in.service_name) > ndr_get_array_size(ndr, &r->in.service_name)) {

3880

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.service_name), ndr_get_array_length(ndr, &r->in.service_name));

3881

}

3882

NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.service_name), sizeof(uint16_t)));

3883

NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.service_name, ndr_get_array_length(ndr, &r->in.service_name), sizeof(uint16_t), CH_UTF16));

3884

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_service_name_0, 0);

3885

}

3886

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_display_name_length));

3887

if (_ptr_display_name_length) {

3888

NDR_PULL_ALLOC(ndr, r->in.display_name_length);

3889

} else {

3890

r->in.display_name_length = NULL;

3891

}

3892

if (r->in.display_name_length) {

3893

_mem_save_display_name_length_0 = NDR_PULL_GET_MEM_CTX(ndr);

3894

NDR_PULL_SET_MEM_CTX(ndr, r->in.display_name_length, 0);

3895

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->in.display_name_length));

3896

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_display_name_length_0, 0);

3897

}

3898

NDR_PULL_ALLOC(ndr, r->out.key_name);

3899

ZERO_STRUCTP(r->out.key_name);

3900

}

3901

if (flags & NDR_OUT) {

3902

if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {

3903

NDR_PULL_ALLOC(ndr, r->out.key_name);

3904

}

3905

_mem_save_key_name_0 = NDR_PULL_GET_MEM_CTX(ndr);

3906

NDR_PULL_SET_MEM_CTX(ndr, r->out.key_name, LIBNDR_FLAG_REF_ALLOC);

3907

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_key_name));

3908

if (_ptr_key_name) {

3909

NDR_PULL_ALLOC(ndr, *r->out.key_name);

3910

} else {

3911

*r->out.key_name = NULL;

3912

}

3913

if (*r->out.key_name) {

3914

_mem_save_key_name_1 = NDR_PULL_GET_MEM_CTX(ndr);

3915

NDR_PULL_SET_MEM_CTX(ndr, *r->out.key_name, 0);

3916

NDR_CHECK(ndr_pull_array_size(ndr, r->out.key_name));

3917

NDR_CHECK(ndr_pull_array_length(ndr, r->out.key_name));

3918

if (ndr_get_array_length(ndr, r->out.key_name) > ndr_get_array_size(ndr, r->out.key_name)) {

3919

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.key_name), ndr_get_array_length(ndr, r->out.key_name));

3920

}

3921

NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, r->out.key_name), sizeof(uint16_t)));

3922

NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, r->out.key_name, ndr_get_array_length(ndr, r->out.key_name), sizeof(uint16_t), CH_UTF16));

3923

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_key_name_1, 0);

3924

}

3925

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_key_name_0, LIBNDR_FLAG_REF_ALLOC);

3926

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_display_name_length));

3927

if (_ptr_display_name_length) {

3928

NDR_PULL_ALLOC(ndr, r->out.display_name_length);

3929

} else {

3930

r->out.display_name_length = NULL;

3931

}

3932

if (r->out.display_name_length) {

3933

_mem_save_display_name_length_0 = NDR_PULL_GET_MEM_CTX(ndr);

3934

NDR_PULL_SET_MEM_CTX(ndr, r->out.display_name_length, 0);

3935

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.display_name_length));

3936

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_display_name_length_0, 0);

3937

}

3938

NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));

3939

}

3940

return NDR_ERR_SUCCESS;

3941

}

3942

3943

_PUBLIC_ void ndr_print_svcctl_GetServiceKeyNameW(struct ndr_print *ndr, const char *name, int flags, const struct svcctl_GetServiceKeyNameW *r)

3944

{

3945

ndr_print_struct(ndr, name, "svcctl_GetServiceKeyNameW");

3946

ndr->depth++;

3947

if (flags & NDR_SET_VALUES) {

3948

ndr->flags |= LIBNDR_PRINT_SET_VALUES;

3949

}

3950

if (flags & NDR_IN) {

3951

ndr_print_struct(ndr, "in", "svcctl_GetServiceKeyNameW");

3952

ndr->depth++;

3953

ndr_print_ptr(ndr, "handle", r->in.handle);

3954

ndr->depth++;

3955

ndr_print_policy_handle(ndr, "handle", r->in.handle);

3956

ndr->depth--;

3957

ndr_print_ptr(ndr, "service_name", r->in.service_name);

3958

ndr->depth++;

3959

if (r->in.service_name) {

3960

ndr_print_string(ndr, "service_name", r->in.service_name);

3961

}

3962

ndr->depth--;

3963

ndr_print_ptr(ndr, "display_name_length", r->in.display_name_length);

3964

ndr->depth++;

3965

if (r->in.display_name_length) {

3966

ndr_print_uint32(ndr, "display_name_length", *r->in.display_name_length);

3967

}

3968

ndr->depth--;

3969

ndr->depth--;

3970

}

3971

if (flags & NDR_OUT) {

3972

ndr_print_struct(ndr, "out", "svcctl_GetServiceKeyNameW");

3973

ndr->depth++;

3974

ndr_print_ptr(ndr, "key_name", r->out.key_name);

3975

ndr->depth++;

3976

ndr_print_ptr(ndr, "key_name", *r->out.key_name);

3977

ndr->depth++;

3978

if (*r->out.key_name) {

3979

ndr_print_string(ndr, "key_name", *r->out.key_name);

3980

}

3981

ndr->depth--;

3982

ndr->depth--;

3983

ndr_print_ptr(ndr, "display_name_length", r->out.display_name_length);

3984

ndr->depth++;

3985

if (r->out.display_name_length) {

3986

ndr_print_uint32(ndr, "display_name_length", *r->out.display_name_length);

3987

}

3988

ndr->depth--;

3989

ndr_print_WERROR(ndr, "result", r->out.result);

3990

ndr->depth--;

3991

}

3992

ndr->depth--;

3993

}

3994

3995

static enum ndr_err_code ndr_push_svcctl_SCSetServiceBitsA(struct ndr_push *ndr, int flags, const struct svcctl_SCSetServiceBitsA *r)

3996

{

3997

if (flags & NDR_IN) {

3998

if (r->in.handle == NULL) {

3999

return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");

4000

}

4001

NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));

4002

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.bits));

4003

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.bitson));

4004

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.immediate));

4005

}

4006

if (flags & NDR_OUT) {

4007

NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));

4008

}

4009

return NDR_ERR_SUCCESS;

4010

}

4011

4012

static enum ndr_err_code ndr_pull_svcctl_SCSetServiceBitsA(struct ndr_pull *ndr, int flags, struct svcctl_SCSetServiceBitsA *r)

4013

{

4014

TALLOC_CTX *_mem_save_handle_0;

4015

if (flags & NDR_IN) {

4016

if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {

4017

NDR_PULL_ALLOC(ndr, r->in.handle);

4018

}

4019

_mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);

4020

NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);

4021

NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));

4022

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);

4023

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.bits));

4024

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.bitson));

4025

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.immediate));

4026

}

4027

if (flags & NDR_OUT) {

4028

NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));

4029

}

4030

return NDR_ERR_SUCCESS;

4031

}

4032

4033

_PUBLIC_ void ndr_print_svcctl_SCSetServiceBitsA(struct ndr_print *ndr, const char *name, int flags, const struct svcctl_SCSetServiceBitsA *r)

4034

{

4035

ndr_print_struct(ndr, name, "svcctl_SCSetServiceBitsA");

4036

ndr->depth++;

4037

if (flags & NDR_SET_VALUES) {

4038

ndr->flags |= LIBNDR_PRINT_SET_VALUES;

4039

}

4040

if (flags & NDR_IN) {

4041

ndr_print_struct(ndr, "in", "svcctl_SCSetServiceBitsA");

4042

ndr->depth++;

4043

ndr_print_ptr(ndr, "handle", r->in.handle);

4044

ndr->depth++;

4045

ndr_print_policy_handle(ndr, "handle", r->in.handle);

4046

ndr->depth--;

4047

ndr_print_uint32(ndr, "bits", r->in.bits);

4048

ndr_print_uint32(ndr, "bitson", r->in.bitson);

4049

ndr_print_uint32(ndr, "immediate", r->in.immediate);

4050

ndr->depth--;

4051

}

4052

if (flags & NDR_OUT) {

4053

ndr_print_struct(ndr, "out", "svcctl_SCSetServiceBitsA");

4054

ndr->depth++;

4055

ndr_print_WERROR(ndr, "result", r->out.result);

4056

ndr->depth--;

4057

}

4058

ndr->depth--;

4059

}

4060

4061

static enum ndr_err_code ndr_push_svcctl_ChangeServiceConfigA(struct ndr_push *ndr, int flags, const struct svcctl_ChangeServiceConfigA *r)

4062

{

4063

if (flags & NDR_IN) {

4064

if (r->in.handle == NULL) {

4065

return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");

4066

}

4067

NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));

4068

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.type));

4069

NDR_CHECK(ndr_push_svcctl_StartType(ndr, NDR_SCALARS, r->in.start_type));

4070

NDR_CHECK(ndr_push_svcctl_ErrorControl(ndr, NDR_SCALARS, r->in.error_control));

4071

NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.binary_path));

4072

if (r->in.binary_path) {

4073

NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.binary_path, CH_UTF16)));

4074

NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));

4075

NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.binary_path, CH_UTF16)));

4076

NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.binary_path, ndr_charset_length(r->in.binary_path, CH_UTF16), sizeof(uint16_t), CH_UTF16));

4077

}

4078

NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.load_order_group));

4079

if (r->in.load_order_group) {

4080

NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.load_order_group, CH_UTF16)));

4081

NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));

4082

NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.load_order_group, CH_UTF16)));

4083

NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.load_order_group, ndr_charset_length(r->in.load_order_group, CH_UTF16), sizeof(uint16_t), CH_UTF16));

4084

}

4085

NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.dependencies));

4086

if (r->in.dependencies) {

4087

NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.dependencies, CH_UTF16)));

4088

NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));

4089

NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.dependencies, CH_UTF16)));

4090

NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.dependencies, ndr_charset_length(r->in.dependencies, CH_UTF16), sizeof(uint16_t), CH_UTF16));

4091

}

4092

NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.service_start_name));

4093

if (r->in.service_start_name) {

4094

NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.service_start_name, CH_UTF16)));

4095

NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));

4096

NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.service_start_name, CH_UTF16)));

4097

NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.service_start_name, ndr_charset_length(r->in.service_start_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));

4098

}

4099

NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.password));

4100

if (r->in.password) {

4101

NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.password, CH_UTF16)));

4102

NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));

4103

NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.password, CH_UTF16)));

4104

NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.password, ndr_charset_length(r->in.password, CH_UTF16), sizeof(uint16_t), CH_UTF16));

4105

}

4106

NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.display_name));

4107

if (r->in.display_name) {

4108

NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.display_name, CH_UTF16)));

4109

NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));

4110

NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.display_name, CH_UTF16)));

4111

NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.display_name, ndr_charset_length(r->in.display_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));

4112

}

4113

}

4114

if (flags & NDR_OUT) {

4115

if (r->out.tag_id == NULL) {

4116

return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");

4117

}

4118

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.tag_id));

4119

NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));

4120

}

4121

return NDR_ERR_SUCCESS;

4122

}

4123

4124

static enum ndr_err_code ndr_pull_svcctl_ChangeServiceConfigA(struct ndr_pull *ndr, int flags, struct svcctl_ChangeServiceConfigA *r)

4125

{

4126

uint32_t _ptr_binary_path;

4127

uint32_t _ptr_load_order_group;

4128

uint32_t _ptr_dependencies;

4129

uint32_t _ptr_service_start_name;

4130

uint32_t _ptr_password;

4131

uint32_t _ptr_display_name;

4132

TALLOC_CTX *_mem_save_handle_0;

4133

TALLOC_CTX *_mem_save_binary_path_0;

4134

TALLOC_CTX *_mem_save_load_order_group_0;

4135

TALLOC_CTX *_mem_save_tag_id_0;

4136

TALLOC_CTX *_mem_save_dependencies_0;

4137

TALLOC_CTX *_mem_save_service_start_name_0;

4138

TALLOC_CTX *_mem_save_password_0;

4139

TALLOC_CTX *_mem_save_display_name_0;

4140

if (flags & NDR_IN) {

4141

ZERO_STRUCT(r->out);

4142

4143

if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {

4144

NDR_PULL_ALLOC(ndr, r->in.handle);

4145

}

4146

_mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);

4147

NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);

4148

NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));

4149

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);

4150

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.type));

4151

NDR_CHECK(ndr_pull_svcctl_StartType(ndr, NDR_SCALARS, &r->in.start_type));

4152

NDR_CHECK(ndr_pull_svcctl_ErrorControl(ndr, NDR_SCALARS, &r->in.error_control));

4153

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_binary_path));

4154

if (_ptr_binary_path) {

4155

NDR_PULL_ALLOC(ndr, r->in.binary_path);

4156

} else {

4157

r->in.binary_path = NULL;

4158

}

4159

if (r->in.binary_path) {

4160

_mem_save_binary_path_0 = NDR_PULL_GET_MEM_CTX(ndr);

4161

NDR_PULL_SET_MEM_CTX(ndr, r->in.binary_path, 0);

4162

NDR_CHECK(ndr_pull_array_size(ndr, &r->in.binary_path));

4163

NDR_CHECK(ndr_pull_array_length(ndr, &r->in.binary_path));

4164

if (ndr_get_array_length(ndr, &r->in.binary_path) > ndr_get_array_size(ndr, &r->in.binary_path)) {

4165

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.binary_path), ndr_get_array_length(ndr, &r->in.binary_path));

4166

}

4167

NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.binary_path), sizeof(uint16_t)));

4168

NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.binary_path, ndr_get_array_length(ndr, &r->in.binary_path), sizeof(uint16_t), CH_UTF16));

4169

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_binary_path_0, 0);

4170

}

4171

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_load_order_group));

4172

if (_ptr_load_order_group) {

4173

NDR_PULL_ALLOC(ndr, r->in.load_order_group);

4174

} else {

4175

r->in.load_order_group = NULL;

4176

}

4177

if (r->in.load_order_group) {

4178

_mem_save_load_order_group_0 = NDR_PULL_GET_MEM_CTX(ndr);

4179

NDR_PULL_SET_MEM_CTX(ndr, r->in.load_order_group, 0);

4180

NDR_CHECK(ndr_pull_array_size(ndr, &r->in.load_order_group));

4181

NDR_CHECK(ndr_pull_array_length(ndr, &r->in.load_order_group));

4182

if (ndr_get_array_length(ndr, &r->in.load_order_group) > ndr_get_array_size(ndr, &r->in.load_order_group)) {

4183

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.load_order_group), ndr_get_array_length(ndr, &r->in.load_order_group));

4184

}

4185

NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.load_order_group), sizeof(uint16_t)));

4186

NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.load_order_group, ndr_get_array_length(ndr, &r->in.load_order_group), sizeof(uint16_t), CH_UTF16));

4187

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_load_order_group_0, 0);

4188

}

4189

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dependencies));

4190

if (_ptr_dependencies) {

4191

NDR_PULL_ALLOC(ndr, r->in.dependencies);

4192

} else {

4193

r->in.dependencies = NULL;

4194

}

4195

if (r->in.dependencies) {

4196

_mem_save_dependencies_0 = NDR_PULL_GET_MEM_CTX(ndr);

4197

NDR_PULL_SET_MEM_CTX(ndr, r->in.dependencies, 0);

4198

NDR_CHECK(ndr_pull_array_size(ndr, &r->in.dependencies));

4199

NDR_CHECK(ndr_pull_array_length(ndr, &r->in.dependencies));

4200

if (ndr_get_array_length(ndr, &r->in.dependencies) > ndr_get_array_size(ndr, &r->in.dependencies)) {

4201

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.dependencies), ndr_get_array_length(ndr, &r->in.dependencies));

4202

}

4203

NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.dependencies), sizeof(uint16_t)));

4204

NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.dependencies, ndr_get_array_length(ndr, &r->in.dependencies), sizeof(uint16_t), CH_UTF16));

4205

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dependencies_0, 0);

4206

}

4207

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_service_start_name));

4208

if (_ptr_service_start_name) {

4209

NDR_PULL_ALLOC(ndr, r->in.service_start_name);

4210

} else {

4211

r->in.service_start_name = NULL;

4212

}

4213

if (r->in.service_start_name) {

4214

_mem_save_service_start_name_0 = NDR_PULL_GET_MEM_CTX(ndr);

4215

NDR_PULL_SET_MEM_CTX(ndr, r->in.service_start_name, 0);

4216

NDR_CHECK(ndr_pull_array_size(ndr, &r->in.service_start_name));

4217

NDR_CHECK(ndr_pull_array_length(ndr, &r->in.service_start_name));

4218

if (ndr_get_array_length(ndr, &r->in.service_start_name) > ndr_get_array_size(ndr, &r->in.service_start_name)) {

4219

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.service_start_name), ndr_get_array_length(ndr, &r->in.service_start_name));

4220

}

4221

NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.service_start_name), sizeof(uint16_t)));

4222

NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.service_start_name, ndr_get_array_length(ndr, &r->in.service_start_name), sizeof(uint16_t), CH_UTF16));

4223

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_service_start_name_0, 0);

4224

}

4225

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_password));

4226

if (_ptr_password) {

4227

NDR_PULL_ALLOC(ndr, r->in.password);

4228

} else {

4229

r->in.password = NULL;

4230

}

4231

if (r->in.password) {

4232

_mem_save_password_0 = NDR_PULL_GET_MEM_CTX(ndr);

4233

NDR_PULL_SET_MEM_CTX(ndr, r->in.password, 0);

4234

NDR_CHECK(ndr_pull_array_size(ndr, &r->in.password));

4235

NDR_CHECK(ndr_pull_array_length(ndr, &r->in.password));

4236

if (ndr_get_array_length(ndr, &r->in.password) > ndr_get_array_size(ndr, &r->in.password)) {

4237

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.password), ndr_get_array_length(ndr, &r->in.password));

4238

}

4239

NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.password), sizeof(uint16_t)));

4240

NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.password, ndr_get_array_length(ndr, &r->in.password), sizeof(uint16_t), CH_UTF16));

4241

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_password_0, 0);

4242

}

4243

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_display_name));

4244

if (_ptr_display_name) {

4245

NDR_PULL_ALLOC(ndr, r->in.display_name);

4246

} else {

4247

r->in.display_name = NULL;

4248

}

4249

if (r->in.display_name) {

4250

_mem_save_display_name_0 = NDR_PULL_GET_MEM_CTX(ndr);

4251

NDR_PULL_SET_MEM_CTX(ndr, r->in.display_name, 0);

4252

NDR_CHECK(ndr_pull_array_size(ndr, &r->in.display_name));

4253

NDR_CHECK(ndr_pull_array_length(ndr, &r->in.display_name));

4254

if (ndr_get_array_length(ndr, &r->in.display_name) > ndr_get_array_size(ndr, &r->in.display_name)) {

4255

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.display_name), ndr_get_array_length(ndr, &r->in.display_name));

4256

}

4257

NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.display_name), sizeof(uint16_t)));

4258

NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.display_name, ndr_get_array_length(ndr, &r->in.display_name), sizeof(uint16_t), CH_UTF16));

4259

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_display_name_0, 0);

4260

}

4261

NDR_PULL_ALLOC(ndr, r->out.tag_id);

4262

ZERO_STRUCTP(r->out.tag_id);

4263

}

4264

if (flags & NDR_OUT) {

4265

if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {

4266

NDR_PULL_ALLOC(ndr, r->out.tag_id);

4267

}

4268

_mem_save_tag_id_0 = NDR_PULL_GET_MEM_CTX(ndr);

4269

NDR_PULL_SET_MEM_CTX(ndr, r->out.tag_id, LIBNDR_FLAG_REF_ALLOC);

4270

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.tag_id));

4271

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_tag_id_0, LIBNDR_FLAG_REF_ALLOC);

4272

NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));

4273

}

4274

return NDR_ERR_SUCCESS;

4275

}

4276

4277

_PUBLIC_ void ndr_print_svcctl_ChangeServiceConfigA(struct ndr_print *ndr, const char *name, int flags, const struct svcctl_ChangeServiceConfigA *r)

4278

{

4279

ndr_print_struct(ndr, name, "svcctl_ChangeServiceConfigA");

4280

ndr->depth++;

4281

if (flags & NDR_SET_VALUES) {

4282

ndr->flags |= LIBNDR_PRINT_SET_VALUES;

4283

}

4284

if (flags & NDR_IN) {

4285

ndr_print_struct(ndr, "in", "svcctl_ChangeServiceConfigA");

4286

ndr->depth++;

4287

ndr_print_ptr(ndr, "handle", r->in.handle);

4288

ndr->depth++;

4289

ndr_print_policy_handle(ndr, "handle", r->in.handle);

4290

ndr->depth--;

4291

ndr_print_uint32(ndr, "type", r->in.type);

4292

ndr_print_svcctl_StartType(ndr, "start_type", r->in.start_type);

4293

ndr_print_svcctl_ErrorControl(ndr, "error_control", r->in.error_control);

4294

ndr_print_ptr(ndr, "binary_path", r->in.binary_path);

4295

ndr->depth++;

4296

if (r->in.binary_path) {

4297

ndr_print_string(ndr, "binary_path", r->in.binary_path);

4298

}

4299

ndr->depth--;

4300

ndr_print_ptr(ndr, "load_order_group", r->in.load_order_group);

4301

ndr->depth++;

4302

if (r->in.load_order_group) {

4303

ndr_print_string(ndr, "load_order_group", r->in.load_order_group);

4304

}

4305

ndr->depth--;

4306

ndr_print_ptr(ndr, "dependencies", r->in.dependencies);

4307

ndr->depth++;

4308

if (r->in.dependencies) {

4309

ndr_print_string(ndr, "dependencies", r->in.dependencies);

4310

}

4311

ndr->depth--;

4312

ndr_print_ptr(ndr, "service_start_name", r->in.service_start_name);

4313

ndr->depth++;

4314

if (r->in.service_start_name) {

4315

ndr_print_string(ndr, "service_start_name", r->in.service_start_name);

4316

}

4317

ndr->depth--;

4318

ndr_print_ptr(ndr, "password", r->in.password);

4319

ndr->depth++;

4320

if (r->in.password) {

4321

ndr_print_string(ndr, "password", r->in.password);

4322

}

4323

ndr->depth--;

4324

ndr_print_ptr(ndr, "display_name", r->in.display_name);

4325

ndr->depth++;

4326

if (r->in.display_name) {

4327

ndr_print_string(ndr, "display_name", r->in.display_name);

4328

}

4329

ndr->depth--;

4330

ndr->depth--;

4331

}

4332

if (flags & NDR_OUT) {

4333

ndr_print_struct(ndr, "out", "svcctl_ChangeServiceConfigA");

4334

ndr->depth++;

4335

ndr_print_ptr(ndr, "tag_id", r->out.tag_id);

4336

ndr->depth++;

4337

ndr_print_uint32(ndr, "tag_id", *r->out.tag_id);

4338

ndr->depth--;

4339

ndr_print_WERROR(ndr, "result", r->out.result);

4340

ndr->depth--;

4341

}

4342

ndr->depth--;

4343

}

4344

4345

static enum ndr_err_code ndr_push_svcctl_CreateServiceA(struct ndr_push *ndr, int flags, const struct svcctl_CreateServiceA *r)

4346

{

4347

if (flags & NDR_IN) {

4348

if (r->in.handle == NULL) {

4349

return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");

4350

}

4351

NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));

4352

NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.ServiceName));

4353

if (r->in.ServiceName) {

4354

NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.ServiceName, CH_UTF16)));

4355

NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));

4356

NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.ServiceName, CH_UTF16)));

4357

NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.ServiceName, ndr_charset_length(r->in.ServiceName, CH_UTF16), sizeof(uint16_t), CH_UTF16));

4358

}

4359

NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.DisplayName));

4360

if (r->in.DisplayName) {

4361

NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.DisplayName, CH_UTF16)));

4362

NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));

4363

NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.DisplayName, CH_UTF16)));

4364

NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.DisplayName, ndr_charset_length(r->in.DisplayName, CH_UTF16), sizeof(uint16_t), CH_UTF16));

4365

}

4366

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.desired_access));

4367

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.type));

4368

NDR_CHECK(ndr_push_svcctl_StartType(ndr, NDR_SCALARS, r->in.start_type));

4369

NDR_CHECK(ndr_push_svcctl_ErrorControl(ndr, NDR_SCALARS, r->in.error_control));

4370

NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.binary_path));

4371

if (r->in.binary_path) {

4372

NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.binary_path, CH_UTF16)));

4373

NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));

4374

NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.binary_path, CH_UTF16)));

4375

NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.binary_path, ndr_charset_length(r->in.binary_path, CH_UTF16), sizeof(uint16_t), CH_UTF16));

4376

}

4377

NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.LoadOrderGroupKey));

4378

if (r->in.LoadOrderGroupKey) {

4379

NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.LoadOrderGroupKey, CH_UTF16)));

4380

NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));

4381

NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.LoadOrderGroupKey, CH_UTF16)));

4382

NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.LoadOrderGroupKey, ndr_charset_length(r->in.LoadOrderGroupKey, CH_UTF16), sizeof(uint16_t), CH_UTF16));

4383

}

4384

NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.dependencies));

4385

if (r->in.dependencies) {

4386

NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.dependencies, CH_UTF16)));

4387

NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));

4388

NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.dependencies, CH_UTF16)));

4389

NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.dependencies, ndr_charset_length(r->in.dependencies, CH_UTF16), sizeof(uint16_t), CH_UTF16));

4390

}

4391

NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.service_start_name));

4392

if (r->in.service_start_name) {

4393

NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.service_start_name, CH_UTF16)));

4394

NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));

4395

NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.service_start_name, CH_UTF16)));

4396

NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.service_start_name, ndr_charset_length(r->in.service_start_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));

4397

}

4398

NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.password));

4399

if (r->in.password) {

4400

NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.password, CH_UTF16)));

4401

NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));

4402

NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.password, CH_UTF16)));

4403

NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.password, ndr_charset_length(r->in.password, CH_UTF16), sizeof(uint16_t), CH_UTF16));

4404

}

4405

}

4406

if (flags & NDR_OUT) {

4407

NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.TagId));

4408

if (r->out.TagId) {

4409

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.TagId));

4410

}

4411

NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));

4412

}

4413

return NDR_ERR_SUCCESS;

4414

}

4415

4416

static enum ndr_err_code ndr_pull_svcctl_CreateServiceA(struct ndr_pull *ndr, int flags, struct svcctl_CreateServiceA *r)

4417

{

4418

uint32_t _ptr_ServiceName;

4419

uint32_t _ptr_DisplayName;

4420

uint32_t _ptr_binary_path;

4421

uint32_t _ptr_LoadOrderGroupKey;

4422

uint32_t _ptr_TagId;

4423

uint32_t _ptr_dependencies;

4424

uint32_t _ptr_service_start_name;

4425

uint32_t _ptr_password;

4426

TALLOC_CTX *_mem_save_handle_0;

4427

TALLOC_CTX *_mem_save_ServiceName_0;

4428

TALLOC_CTX *_mem_save_DisplayName_0;

4429

TALLOC_CTX *_mem_save_binary_path_0;

4430

TALLOC_CTX *_mem_save_LoadOrderGroupKey_0;

4431

TALLOC_CTX *_mem_save_TagId_0;

4432

TALLOC_CTX *_mem_save_dependencies_0;

4433

TALLOC_CTX *_mem_save_service_start_name_0;

4434

TALLOC_CTX *_mem_save_password_0;

4435

if (flags & NDR_IN) {

4436

ZERO_STRUCT(r->out);

4437

4438

if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {

4439

NDR_PULL_ALLOC(ndr, r->in.handle);

4440

}

4441

_mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);

4442

NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);

4443

NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));

4444

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);

4445

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_ServiceName));

4446

if (_ptr_ServiceName) {

4447

NDR_PULL_ALLOC(ndr, r->in.ServiceName);

4448

} else {

4449

r->in.ServiceName = NULL;

4450

}

4451

if (r->in.ServiceName) {

4452

_mem_save_ServiceName_0 = NDR_PULL_GET_MEM_CTX(ndr);

4453

NDR_PULL_SET_MEM_CTX(ndr, r->in.ServiceName, 0);

4454

NDR_CHECK(ndr_pull_array_size(ndr, &r->in.ServiceName));

4455

NDR_CHECK(ndr_pull_array_length(ndr, &r->in.ServiceName));

4456

if (ndr_get_array_length(ndr, &r->in.ServiceName) > ndr_get_array_size(ndr, &r->in.ServiceName)) {

4457

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.ServiceName), ndr_get_array_length(ndr, &r->in.ServiceName));

4458

}

4459

NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.ServiceName), sizeof(uint16_t)));

4460

NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.ServiceName, ndr_get_array_length(ndr, &r->in.ServiceName), sizeof(uint16_t), CH_UTF16));

4461

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ServiceName_0, 0);

4462

}

4463

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_DisplayName));

4464

if (_ptr_DisplayName) {

4465

NDR_PULL_ALLOC(ndr, r->in.DisplayName);

4466

} else {

4467

r->in.DisplayName = NULL;

4468

}

4469

if (r->in.DisplayName) {

4470

_mem_save_DisplayName_0 = NDR_PULL_GET_MEM_CTX(ndr);

4471

NDR_PULL_SET_MEM_CTX(ndr, r->in.DisplayName, 0);

4472

NDR_CHECK(ndr_pull_array_size(ndr, &r->in.DisplayName));

4473

NDR_CHECK(ndr_pull_array_length(ndr, &r->in.DisplayName));

4474

if (ndr_get_array_length(ndr, &r->in.DisplayName) > ndr_get_array_size(ndr, &r->in.DisplayName)) {

4475

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.DisplayName), ndr_get_array_length(ndr, &r->in.DisplayName));

4476

}

4477

NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.DisplayName), sizeof(uint16_t)));

4478

NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.DisplayName, ndr_get_array_length(ndr, &r->in.DisplayName), sizeof(uint16_t), CH_UTF16));

4479

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_DisplayName_0, 0);

4480

}

4481

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.desired_access));

4482

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.type));

4483

NDR_CHECK(ndr_pull_svcctl_StartType(ndr, NDR_SCALARS, &r->in.start_type));

4484

NDR_CHECK(ndr_pull_svcctl_ErrorControl(ndr, NDR_SCALARS, &r->in.error_control));

4485

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_binary_path));

4486

if (_ptr_binary_path) {

4487

NDR_PULL_ALLOC(ndr, r->in.binary_path);

4488

} else {

4489

r->in.binary_path = NULL;

4490

}

4491

if (r->in.binary_path) {

4492

_mem_save_binary_path_0 = NDR_PULL_GET_MEM_CTX(ndr);

4493

NDR_PULL_SET_MEM_CTX(ndr, r->in.binary_path, 0);

4494

NDR_CHECK(ndr_pull_array_size(ndr, &r->in.binary_path));

4495

NDR_CHECK(ndr_pull_array_length(ndr, &r->in.binary_path));

4496

if (ndr_get_array_length(ndr, &r->in.binary_path) > ndr_get_array_size(ndr, &r->in.binary_path)) {

4497

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.binary_path), ndr_get_array_length(ndr, &r->in.binary_path));

4498

}

4499

NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.binary_path), sizeof(uint16_t)));

4500

NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.binary_path, ndr_get_array_length(ndr, &r->in.binary_path), sizeof(uint16_t), CH_UTF16));

4501

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_binary_path_0, 0);

4502

}

4503

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_LoadOrderGroupKey));

4504

if (_ptr_LoadOrderGroupKey) {

4505

NDR_PULL_ALLOC(ndr, r->in.LoadOrderGroupKey);

4506

} else {

4507

r->in.LoadOrderGroupKey = NULL;

4508

}

4509

if (r->in.LoadOrderGroupKey) {

4510

_mem_save_LoadOrderGroupKey_0 = NDR_PULL_GET_MEM_CTX(ndr);

4511

NDR_PULL_SET_MEM_CTX(ndr, r->in.LoadOrderGroupKey, 0);

4512

NDR_CHECK(ndr_pull_array_size(ndr, &r->in.LoadOrderGroupKey));

4513

NDR_CHECK(ndr_pull_array_length(ndr, &r->in.LoadOrderGroupKey));

4514

if (ndr_get_array_length(ndr, &r->in.LoadOrderGroupKey) > ndr_get_array_size(ndr, &r->in.LoadOrderGroupKey)) {

4515

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.LoadOrderGroupKey), ndr_get_array_length(ndr, &r->in.LoadOrderGroupKey));

4516

}

4517

NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.LoadOrderGroupKey), sizeof(uint16_t)));

4518

NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.LoadOrderGroupKey, ndr_get_array_length(ndr, &r->in.LoadOrderGroupKey), sizeof(uint16_t), CH_UTF16));

4519

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_LoadOrderGroupKey_0, 0);

4520

}

4521

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dependencies));

4522

if (_ptr_dependencies) {

4523

NDR_PULL_ALLOC(ndr, r->in.dependencies);

4524

} else {

4525

r->in.dependencies = NULL;

4526

}

4527

if (r->in.dependencies) {

4528

_mem_save_dependencies_0 = NDR_PULL_GET_MEM_CTX(ndr);

4529

NDR_PULL_SET_MEM_CTX(ndr, r->in.dependencies, 0);

4530

NDR_CHECK(ndr_pull_array_size(ndr, &r->in.dependencies));

4531

NDR_CHECK(ndr_pull_array_length(ndr, &r->in.dependencies));

4532

if (ndr_get_array_length(ndr, &r->in.dependencies) > ndr_get_array_size(ndr, &r->in.dependencies)) {

4533

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.dependencies), ndr_get_array_length(ndr, &r->in.dependencies));

4534

}

4535

NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.dependencies), sizeof(uint16_t)));

4536

NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.dependencies, ndr_get_array_length(ndr, &r->in.dependencies), sizeof(uint16_t), CH_UTF16));

4537

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dependencies_0, 0);

4538

}

4539

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_service_start_name));

4540

if (_ptr_service_start_name) {

4541

NDR_PULL_ALLOC(ndr, r->in.service_start_name);

4542

} else {

4543

r->in.service_start_name = NULL;

4544

}

4545

if (r->in.service_start_name) {

4546

_mem_save_service_start_name_0 = NDR_PULL_GET_MEM_CTX(ndr);

4547

NDR_PULL_SET_MEM_CTX(ndr, r->in.service_start_name, 0);

4548

NDR_CHECK(ndr_pull_array_size(ndr, &r->in.service_start_name));

4549

NDR_CHECK(ndr_pull_array_length(ndr, &r->in.service_start_name));

4550

if (ndr_get_array_length(ndr, &r->in.service_start_name) > ndr_get_array_size(ndr, &r->in.service_start_name)) {

4551

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.service_start_name), ndr_get_array_length(ndr, &r->in.service_start_name));

4552

}

4553

NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.service_start_name), sizeof(uint16_t)));

4554

NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.service_start_name, ndr_get_array_length(ndr, &r->in.service_start_name), sizeof(uint16_t), CH_UTF16));

4555

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_service_start_name_0, 0);

4556

}

4557

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_password));

4558

if (_ptr_password) {

4559

NDR_PULL_ALLOC(ndr, r->in.password);

4560

} else {

4561

r->in.password = NULL;

4562

}

4563

if (r->in.password) {

4564

_mem_save_password_0 = NDR_PULL_GET_MEM_CTX(ndr);

4565

NDR_PULL_SET_MEM_CTX(ndr, r->in.password, 0);

4566

NDR_CHECK(ndr_pull_array_size(ndr, &r->in.password));

4567

NDR_CHECK(ndr_pull_array_length(ndr, &r->in.password));

4568

if (ndr_get_array_length(ndr, &r->in.password) > ndr_get_array_size(ndr, &r->in.password)) {

4569

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.password), ndr_get_array_length(ndr, &r->in.password));

4570

}

4571

NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.password), sizeof(uint16_t)));

4572

NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.password, ndr_get_array_length(ndr, &r->in.password), sizeof(uint16_t), CH_UTF16));

4573

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_password_0, 0);

4574

}

4575

}

4576

if (flags & NDR_OUT) {

4577

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_TagId));

4578

if (_ptr_TagId) {

4579

NDR_PULL_ALLOC(ndr, r->out.TagId);

4580

} else {

4581

r->out.TagId = NULL;

4582

}

4583

if (r->out.TagId) {

4584

_mem_save_TagId_0 = NDR_PULL_GET_MEM_CTX(ndr);

4585

NDR_PULL_SET_MEM_CTX(ndr, r->out.TagId, 0);

4586

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.TagId));

4587

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_TagId_0, 0);

4588

}

4589

NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));

4590

}

4591

return NDR_ERR_SUCCESS;

4592

}

4593

4594

_PUBLIC_ void ndr_print_svcctl_CreateServiceA(struct ndr_print *ndr, const char *name, int flags, const struct svcctl_CreateServiceA *r)

4595

{

4596

ndr_print_struct(ndr, name, "svcctl_CreateServiceA");

4597

ndr->depth++;

4598

if (flags & NDR_SET_VALUES) {

4599

ndr->flags |= LIBNDR_PRINT_SET_VALUES;

4600

}

4601

if (flags & NDR_IN) {

4602

ndr_print_struct(ndr, "in", "svcctl_CreateServiceA");

4603

ndr->depth++;

4604

ndr_print_ptr(ndr, "handle", r->in.handle);

4605

ndr->depth++;

4606

ndr_print_policy_handle(ndr, "handle", r->in.handle);

4607

ndr->depth--;

4608

ndr_print_ptr(ndr, "ServiceName", r->in.ServiceName);

4609

ndr->depth++;

4610

if (r->in.ServiceName) {

4611

ndr_print_string(ndr, "ServiceName", r->in.ServiceName);

4612

}

4613

ndr->depth--;

4614

ndr_print_ptr(ndr, "DisplayName", r->in.DisplayName);

4615

ndr->depth++;

4616

if (r->in.DisplayName) {

4617

ndr_print_string(ndr, "DisplayName", r->in.DisplayName);

4618

}

4619

ndr->depth--;

4620

ndr_print_uint32(ndr, "desired_access", r->in.desired_access);

4621

ndr_print_uint32(ndr, "type", r->in.type);

4622

ndr_print_svcctl_StartType(ndr, "start_type", r->in.start_type);

4623

ndr_print_svcctl_ErrorControl(ndr, "error_control", r->in.error_control);

4624

ndr_print_ptr(ndr, "binary_path", r->in.binary_path);

4625

ndr->depth++;

4626

if (r->in.binary_path) {

4627

ndr_print_string(ndr, "binary_path", r->in.binary_path);

4628

}

4629

ndr->depth--;

4630

ndr_print_ptr(ndr, "LoadOrderGroupKey", r->in.LoadOrderGroupKey);

4631

ndr->depth++;

4632

if (r->in.LoadOrderGroupKey) {

4633

ndr_print_string(ndr, "LoadOrderGroupKey", r->in.LoadOrderGroupKey);

4634

}

4635

ndr->depth--;

4636

ndr_print_ptr(ndr, "dependencies", r->in.dependencies);

4637

ndr->depth++;

4638

if (r->in.dependencies) {

4639

ndr_print_string(ndr, "dependencies", r->in.dependencies);

4640

}

4641

ndr->depth--;

4642

ndr_print_ptr(ndr, "service_start_name", r->in.service_start_name);

4643

ndr->depth++;

4644

if (r->in.service_start_name) {

4645

ndr_print_string(ndr, "service_start_name", r->in.service_start_name);

4646

}

4647

ndr->depth--;

4648

ndr_print_ptr(ndr, "password", r->in.password);

4649

ndr->depth++;

4650

if (r->in.password) {

4651

ndr_print_string(ndr, "password", r->in.password);

4652

}

4653

ndr->depth--;

4654

ndr->depth--;

4655

}

4656

if (flags & NDR_OUT) {

4657

ndr_print_struct(ndr, "out", "svcctl_CreateServiceA");

4658

ndr->depth++;

4659

ndr_print_ptr(ndr, "TagId", r->out.TagId);

4660

ndr->depth++;

4661

if (r->out.TagId) {

4662

ndr_print_uint32(ndr, "TagId", *r->out.TagId);

4663

}

4664

ndr->depth--;

4665

ndr_print_WERROR(ndr, "result", r->out.result);

4666

ndr->depth--;

4667

}

4668

ndr->depth--;

4669

}

4670

4671

static enum ndr_err_code ndr_push_svcctl_EnumDependentServicesA(struct ndr_push *ndr, int flags, const struct svcctl_EnumDependentServicesA *r)

4672

{

4673

if (flags & NDR_IN) {

4674

if (r->in.service == NULL) {

4675

return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");

4676

}

4677

NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.service));

4678

NDR_CHECK(ndr_push_svcctl_ServiceState(ndr, NDR_SCALARS, r->in.state));

4679

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));

4680

}

4681

if (flags & NDR_OUT) {

4682

NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.service_status));

4683

if (r->out.service_status) {

4684

NDR_CHECK(ndr_push_ENUM_SERVICE_STATUSA(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.service_status));

4685

}

4686

if (r->out.needed == NULL) {

4687

return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");

4688

}

4689

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));

4690

if (r->out.services_returned == NULL) {

4691

return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");

4692

}

4693

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.services_returned));

4694

NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));

4695

}

4696

return NDR_ERR_SUCCESS;

4697

}

4698

4699

static enum ndr_err_code ndr_pull_svcctl_EnumDependentServicesA(struct ndr_pull *ndr, int flags, struct svcctl_EnumDependentServicesA *r)

4700

{

4701

uint32_t _ptr_service_status;

4702

TALLOC_CTX *_mem_save_service_0;

4703

TALLOC_CTX *_mem_save_service_status_0;

4704

TALLOC_CTX *_mem_save_needed_0;

4705

TALLOC_CTX *_mem_save_services_returned_0;

4706

if (flags & NDR_IN) {

4707

ZERO_STRUCT(r->out);

4708

4709

if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {

4710

NDR_PULL_ALLOC(ndr, r->in.service);

4711

}

4712

_mem_save_service_0 = NDR_PULL_GET_MEM_CTX(ndr);

4713

NDR_PULL_SET_MEM_CTX(ndr, r->in.service, LIBNDR_FLAG_REF_ALLOC);

4714

NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.service));

4715

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_service_0, LIBNDR_FLAG_REF_ALLOC);

4716

NDR_CHECK(ndr_pull_svcctl_ServiceState(ndr, NDR_SCALARS, &r->in.state));

4717

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));

4718

NDR_PULL_ALLOC(ndr, r->out.needed);

4719

ZERO_STRUCTP(r->out.needed);

4720

NDR_PULL_ALLOC(ndr, r->out.services_returned);

4721

ZERO_STRUCTP(r->out.services_returned);

4722

}

4723

if (flags & NDR_OUT) {

4724

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_service_status));

4725

if (_ptr_service_status) {

4726

NDR_PULL_ALLOC(ndr, r->out.service_status);

4727

} else {

4728

r->out.service_status = NULL;

4729

}

4730

if (r->out.service_status) {

4731

_mem_save_service_status_0 = NDR_PULL_GET_MEM_CTX(ndr);

4732

NDR_PULL_SET_MEM_CTX(ndr, r->out.service_status, 0);

4733

NDR_CHECK(ndr_pull_ENUM_SERVICE_STATUSA(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.service_status));

4734

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_service_status_0, 0);

4735

}

4736

if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {

4737

NDR_PULL_ALLOC(ndr, r->out.needed);

4738

}

4739

_mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);

4740

NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);

4741

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));

4742

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);

4743

if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {

4744

NDR_PULL_ALLOC(ndr, r->out.services_returned);

4745

}

4746

_mem_save_services_returned_0 = NDR_PULL_GET_MEM_CTX(ndr);

4747

NDR_PULL_SET_MEM_CTX(ndr, r->out.services_returned, LIBNDR_FLAG_REF_ALLOC);

4748

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.services_returned));

4749

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_services_returned_0, LIBNDR_FLAG_REF_ALLOC);

4750

NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));

4751

}

4752

return NDR_ERR_SUCCESS;

4753

}

4754

4755

_PUBLIC_ void ndr_print_svcctl_EnumDependentServicesA(struct ndr_print *ndr, const char *name, int flags, const struct svcctl_EnumDependentServicesA *r)

4756

{

4757

ndr_print_struct(ndr, name, "svcctl_EnumDependentServicesA");

4758

ndr->depth++;

4759

if (flags & NDR_SET_VALUES) {

4760

ndr->flags |= LIBNDR_PRINT_SET_VALUES;

4761

}

4762

if (flags & NDR_IN) {

4763

ndr_print_struct(ndr, "in", "svcctl_EnumDependentServicesA");

4764

ndr->depth++;

4765

ndr_print_ptr(ndr, "service", r->in.service);

4766

ndr->depth++;

4767

ndr_print_policy_handle(ndr, "service", r->in.service);

4768

ndr->depth--;

4769

ndr_print_svcctl_ServiceState(ndr, "state", r->in.state);

4770

ndr_print_uint32(ndr, "offered", r->in.offered);

4771

ndr->depth--;

4772

}

4773

if (flags & NDR_OUT) {

4774

ndr_print_struct(ndr, "out", "svcctl_EnumDependentServicesA");

4775

ndr->depth++;

4776

ndr_print_ptr(ndr, "service_status", r->out.service_status);

4777

ndr->depth++;

4778

if (r->out.service_status) {

4779

ndr_print_ENUM_SERVICE_STATUSA(ndr, "service_status", r->out.service_status);

4780

}

4781

ndr->depth--;

4782

ndr_print_ptr(ndr, "needed", r->out.needed);

4783

ndr->depth++;

4784

ndr_print_uint32(ndr, "needed", *r->out.needed);

4785

ndr->depth--;

4786

ndr_print_ptr(ndr, "services_returned", r->out.services_returned);

4787

ndr->depth++;

4788

ndr_print_uint32(ndr, "services_returned", *r->out.services_returned);

4789

ndr->depth--;

4790

ndr_print_WERROR(ndr, "result", r->out.result);

4791

ndr->depth--;

4792

}

4793

ndr->depth--;

4794

}

4795

4796

static enum ndr_err_code ndr_push_svcctl_EnumServicesStatusA(struct ndr_push *ndr, int flags, const struct svcctl_EnumServicesStatusA *r)

4797

{

4798

if (flags & NDR_IN) {

4799

if (r->in.handle == NULL) {

4800

return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");

4801

}

4802

NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));

4803

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.type));

4804

NDR_CHECK(ndr_push_svcctl_ServiceState(ndr, NDR_SCALARS, r->in.state));

4805

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));

4806

NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.resume_handle));

4807

if (r->in.resume_handle) {

4808

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->in.resume_handle));

4809

}

4810

}

4811

if (flags & NDR_OUT) {

4812

NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->in.offered));

4813

NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->out.service, r->in.offered));

4814

if (r->out.needed == NULL) {

4815

return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");

4816

}

4817

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));

4818

if (r->out.services_returned == NULL) {

4819

return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");

4820

}

4821

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.services_returned));

4822

NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.resume_handle));

4823

if (r->out.resume_handle) {

4824

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.resume_handle));

4825

}

4826

NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));

4827

}

4828

return NDR_ERR_SUCCESS;

4829

}

4830

4831

static enum ndr_err_code ndr_pull_svcctl_EnumServicesStatusA(struct ndr_pull *ndr, int flags, struct svcctl_EnumServicesStatusA *r)

4832

{

4833

uint32_t _ptr_resume_handle;

4834

TALLOC_CTX *_mem_save_handle_0;

4835

TALLOC_CTX *_mem_save_needed_0;

4836

TALLOC_CTX *_mem_save_services_returned_0;

4837

TALLOC_CTX *_mem_save_resume_handle_0;

4838

if (flags & NDR_IN) {

4839

ZERO_STRUCT(r->out);

4840

4841

if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {

4842

NDR_PULL_ALLOC(ndr, r->in.handle);

4843

}

4844

_mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);

4845

NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);

4846

NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));

4847

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);

4848

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.type));

4849

NDR_CHECK(ndr_pull_svcctl_ServiceState(ndr, NDR_SCALARS, &r->in.state));

4850

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));

4851

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_resume_handle));

4852

if (_ptr_resume_handle) {

4853

NDR_PULL_ALLOC(ndr, r->in.resume_handle);

4854

} else {

4855

r->in.resume_handle = NULL;

4856

}

4857

if (r->in.resume_handle) {

4858

_mem_save_resume_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);

4859

NDR_PULL_SET_MEM_CTX(ndr, r->in.resume_handle, 0);

4860

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->in.resume_handle));

4861

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_resume_handle_0, 0);

4862

}

4863

NDR_PULL_ALLOC(ndr, r->out.needed);

4864

ZERO_STRUCTP(r->out.needed);

4865

NDR_PULL_ALLOC(ndr, r->out.services_returned);

4866

ZERO_STRUCTP(r->out.services_returned);

4867

}

4868

if (flags & NDR_OUT) {

4869

NDR_CHECK(ndr_pull_array_size(ndr, &r->out.service));

4870

NDR_PULL_ALLOC_N(ndr, r->out.service, ndr_get_array_size(ndr, &r->out.service));

4871

NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->out.service, ndr_get_array_size(ndr, &r->out.service)));

4872

if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {

4873

NDR_PULL_ALLOC(ndr, r->out.needed);

4874

}

4875

_mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);

4876

NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);

4877

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));

4878

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);

4879

if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {

4880

NDR_PULL_ALLOC(ndr, r->out.services_returned);

4881

}

4882

_mem_save_services_returned_0 = NDR_PULL_GET_MEM_CTX(ndr);

4883

NDR_PULL_SET_MEM_CTX(ndr, r->out.services_returned, LIBNDR_FLAG_REF_ALLOC);

4884

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.services_returned));

4885

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_services_returned_0, LIBNDR_FLAG_REF_ALLOC);

4886

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_resume_handle));

4887

if (_ptr_resume_handle) {

4888

NDR_PULL_ALLOC(ndr, r->out.resume_handle);

4889

} else {

4890

r->out.resume_handle = NULL;

4891

}

4892

if (r->out.resume_handle) {

4893

_mem_save_resume_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);

4894

NDR_PULL_SET_MEM_CTX(ndr, r->out.resume_handle, 0);

4895

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.resume_handle));

4896

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_resume_handle_0, 0);

4897

}

4898

NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));

4899

if (r->out.service) {

4900

NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->out.service, r->in.offered));

4901

}

4902

}

4903

return NDR_ERR_SUCCESS;

4904

}

4905

4906

_PUBLIC_ void ndr_print_svcctl_EnumServicesStatusA(struct ndr_print *ndr, const char *name, int flags, const struct svcctl_EnumServicesStatusA *r)

4907

{

4908

ndr_print_struct(ndr, name, "svcctl_EnumServicesStatusA");

4909

ndr->depth++;

4910

if (flags & NDR_SET_VALUES) {

4911

ndr->flags |= LIBNDR_PRINT_SET_VALUES;

4912

}

4913

if (flags & NDR_IN) {

4914

ndr_print_struct(ndr, "in", "svcctl_EnumServicesStatusA");

4915

ndr->depth++;

4916

ndr_print_ptr(ndr, "handle", r->in.handle);

4917

ndr->depth++;

4918

ndr_print_policy_handle(ndr, "handle", r->in.handle);

4919

ndr->depth--;

4920

ndr_print_uint32(ndr, "type", r->in.type);

4921

ndr_print_svcctl_ServiceState(ndr, "state", r->in.state);

4922

ndr_print_uint32(ndr, "offered", r->in.offered);

4923

ndr_print_ptr(ndr, "resume_handle", r->in.resume_handle);

4924

ndr->depth++;

4925

if (r->in.resume_handle) {

4926

ndr_print_uint32(ndr, "resume_handle", *r->in.resume_handle);

4927

}

4928

ndr->depth--;

4929

ndr->depth--;

4930

}

4931

if (flags & NDR_OUT) {

4932

ndr_print_struct(ndr, "out", "svcctl_EnumServicesStatusA");

4933

ndr->depth++;

4934

ndr_print_array_uint8(ndr, "service", r->out.service, r->in.offered);

4935

ndr_print_ptr(ndr, "needed", r->out.needed);

4936

ndr->depth++;

4937

ndr_print_uint32(ndr, "needed", *r->out.needed);

4938

ndr->depth--;

4939

ndr_print_ptr(ndr, "services_returned", r->out.services_returned);

4940

ndr->depth++;

4941

ndr_print_uint32(ndr, "services_returned", *r->out.services_returned);

4942

ndr->depth--;

4943

ndr_print_ptr(ndr, "resume_handle", r->out.resume_handle);

4944

ndr->depth++;

4945

if (r->out.resume_handle) {

4946

ndr_print_uint32(ndr, "resume_handle", *r->out.resume_handle);

4947

}

4948

ndr->depth--;

4949

ndr_print_WERROR(ndr, "result", r->out.result);

4950

ndr->depth--;

4951

}

4952

ndr->depth--;

4953

}

4954

4955

static enum ndr_err_code ndr_push_svcctl_OpenSCManagerA(struct ndr_push *ndr, int flags, const struct svcctl_OpenSCManagerA *r)

4956

{

4957

if (flags & NDR_IN) {

4958

NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.MachineName));

4959

if (r->in.MachineName) {

4960

NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.MachineName, CH_UTF16)));

4961

NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));

4962

NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.MachineName, CH_UTF16)));

4963

NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.MachineName, ndr_charset_length(r->in.MachineName, CH_UTF16), sizeof(uint16_t), CH_UTF16));

4964

}

4965

NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.DatabaseName));

4966

if (r->in.DatabaseName) {

4967

NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.DatabaseName, CH_UTF16)));

4968

NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));

4969

NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.DatabaseName, CH_UTF16)));

4970

NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.DatabaseName, ndr_charset_length(r->in.DatabaseName, CH_UTF16), sizeof(uint16_t), CH_UTF16));

4971

}

4972

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.access_mask));

4973

}

4974

if (flags & NDR_OUT) {

4975

if (r->out.handle == NULL) {

4976

return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");

4977

}

4978

NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.handle));

4979

NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));

4980

}

4981

return NDR_ERR_SUCCESS;

4982

}

4983

4984

static enum ndr_err_code ndr_pull_svcctl_OpenSCManagerA(struct ndr_pull *ndr, int flags, struct svcctl_OpenSCManagerA *r)

4985

{

4986

uint32_t _ptr_MachineName;

4987

uint32_t _ptr_DatabaseName;

4988

TALLOC_CTX *_mem_save_MachineName_0;

4989

TALLOC_CTX *_mem_save_DatabaseName_0;

4990

TALLOC_CTX *_mem_save_handle_0;

4991

if (flags & NDR_IN) {

4992

ZERO_STRUCT(r->out);

4993

4994

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_MachineName));

4995

if (_ptr_MachineName) {

4996

NDR_PULL_ALLOC(ndr, r->in.MachineName);

4997

} else {

4998

r->in.MachineName = NULL;

4999

}

5000

if (r->in.MachineName) {

5001

_mem_save_MachineName_0 = NDR_PULL_GET_MEM_CTX(ndr);

5002

NDR_PULL_SET_MEM_CTX(ndr, r->in.MachineName, 0);

5003

NDR_CHECK(ndr_pull_array_size(ndr, &r->in.MachineName));

5004

NDR_CHECK(ndr_pull_array_length(ndr, &r->in.MachineName));

5005

if (ndr_get_array_length(ndr, &r->in.MachineName) > ndr_get_array_size(ndr, &r->in.MachineName)) {

5006

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.MachineName), ndr_get_array_length(ndr, &r->in.MachineName));

5007

}

5008

NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.MachineName), sizeof(uint16_t)));

5009

NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.MachineName, ndr_get_array_length(ndr, &r->in.MachineName), sizeof(uint16_t), CH_UTF16));

5010

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_MachineName_0, 0);

5011

}

5012

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_DatabaseName));

5013

if (_ptr_DatabaseName) {

5014

NDR_PULL_ALLOC(ndr, r->in.DatabaseName);

5015

} else {

5016

r->in.DatabaseName = NULL;

5017

}

5018

if (r->in.DatabaseName) {

5019

_mem_save_DatabaseName_0 = NDR_PULL_GET_MEM_CTX(ndr);

5020

NDR_PULL_SET_MEM_CTX(ndr, r->in.DatabaseName, 0);

5021

NDR_CHECK(ndr_pull_array_size(ndr, &r->in.DatabaseName));

5022

NDR_CHECK(ndr_pull_array_length(ndr, &r->in.DatabaseName));

5023

if (ndr_get_array_length(ndr, &r->in.DatabaseName) > ndr_get_array_size(ndr, &r->in.DatabaseName)) {

5024

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.DatabaseName), ndr_get_array_length(ndr, &r->in.DatabaseName));

5025

}

5026

NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.DatabaseName), sizeof(uint16_t)));

5027

NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.DatabaseName, ndr_get_array_length(ndr, &r->in.DatabaseName), sizeof(uint16_t), CH_UTF16));

5028

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_DatabaseName_0, 0);

5029

}

5030

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.access_mask));

5031

NDR_PULL_ALLOC(ndr, r->out.handle);

5032

ZERO_STRUCTP(r->out.handle);

5033

}

5034

if (flags & NDR_OUT) {

5035

if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {

5036

NDR_PULL_ALLOC(ndr, r->out.handle);

5037

}

5038

_mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);

5039

NDR_PULL_SET_MEM_CTX(ndr, r->out.handle, LIBNDR_FLAG_REF_ALLOC);

5040

NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.handle));

5041

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);

5042

NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));

5043

}

5044

return NDR_ERR_SUCCESS;

5045

}

5046

5047

_PUBLIC_ void ndr_print_svcctl_OpenSCManagerA(struct ndr_print *ndr, const char *name, int flags, const struct svcctl_OpenSCManagerA *r)

5048

{

5049

ndr_print_struct(ndr, name, "svcctl_OpenSCManagerA");

5050

ndr->depth++;

5051

if (flags & NDR_SET_VALUES) {

5052

ndr->flags |= LIBNDR_PRINT_SET_VALUES;

5053

}

5054

if (flags & NDR_IN) {

5055

ndr_print_struct(ndr, "in", "svcctl_OpenSCManagerA");

5056

ndr->depth++;

5057

ndr_print_ptr(ndr, "MachineName", r->in.MachineName);

5058

ndr->depth++;

5059

if (r->in.MachineName) {

5060

ndr_print_string(ndr, "MachineName", r->in.MachineName);

5061

}

5062

ndr->depth--;

5063

ndr_print_ptr(ndr, "DatabaseName", r->in.DatabaseName);

5064

ndr->depth++;

5065

if (r->in.DatabaseName) {

5066

ndr_print_string(ndr, "DatabaseName", r->in.DatabaseName);

5067

}

5068

ndr->depth--;

5069

ndr_print_uint32(ndr, "access_mask", r->in.access_mask);

5070

ndr->depth--;

5071

}

5072

if (flags & NDR_OUT) {

5073

ndr_print_struct(ndr, "out", "svcctl_OpenSCManagerA");

5074

ndr->depth++;

5075

ndr_print_ptr(ndr, "handle", r->out.handle);

5076

ndr->depth++;

5077

ndr_print_policy_handle(ndr, "handle", r->out.handle);

5078

ndr->depth--;

5079

ndr_print_WERROR(ndr, "result", r->out.result);

5080

ndr->depth--;

5081

}

5082

ndr->depth--;

5083

}

5084

5085

static enum ndr_err_code ndr_push_svcctl_OpenServiceA(struct ndr_push *ndr, int flags, const struct svcctl_OpenServiceA *r)

5086

{

5087

if (flags & NDR_IN) {

5088

if (r->in.scmanager_handle == NULL) {

5089

return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");

5090

}

5091

NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.scmanager_handle));

5092

NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.ServiceName));

5093

if (r->in.ServiceName) {

5094

NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.ServiceName, CH_UTF16)));

5095

NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));

5096

NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.ServiceName, CH_UTF16)));

5097

NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.ServiceName, ndr_charset_length(r->in.ServiceName, CH_UTF16), sizeof(uint16_t), CH_UTF16));

5098

}

5099

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.access_mask));

5100

}

5101

if (flags & NDR_OUT) {

5102

NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));

5103

}

5104

return NDR_ERR_SUCCESS;

5105

}

5106

5107

static enum ndr_err_code ndr_pull_svcctl_OpenServiceA(struct ndr_pull *ndr, int flags, struct svcctl_OpenServiceA *r)

5108

{

5109

uint32_t _ptr_ServiceName;

5110

TALLOC_CTX *_mem_save_scmanager_handle_0;

5111

TALLOC_CTX *_mem_save_ServiceName_0;

5112

if (flags & NDR_IN) {

5113

if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {

5114

NDR_PULL_ALLOC(ndr, r->in.scmanager_handle);

5115

}

5116

_mem_save_scmanager_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);

5117

NDR_PULL_SET_MEM_CTX(ndr, r->in.scmanager_handle, LIBNDR_FLAG_REF_ALLOC);

5118

NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.scmanager_handle));

5119

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_scmanager_handle_0, LIBNDR_FLAG_REF_ALLOC);

5120

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_ServiceName));

5121

if (_ptr_ServiceName) {

5122

NDR_PULL_ALLOC(ndr, r->in.ServiceName);

5123

} else {

5124

r->in.ServiceName = NULL;

5125

}

5126

if (r->in.ServiceName) {

5127

_mem_save_ServiceName_0 = NDR_PULL_GET_MEM_CTX(ndr);

5128

NDR_PULL_SET_MEM_CTX(ndr, r->in.ServiceName, 0);

5129

NDR_CHECK(ndr_pull_array_size(ndr, &r->in.ServiceName));

5130

NDR_CHECK(ndr_pull_array_length(ndr, &r->in.ServiceName));

5131

if (ndr_get_array_length(ndr, &r->in.ServiceName) > ndr_get_array_size(ndr, &r->in.ServiceName)) {

5132

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.ServiceName), ndr_get_array_length(ndr, &r->in.ServiceName));

5133

}

5134

NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.ServiceName), sizeof(uint16_t)));

5135

NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.ServiceName, ndr_get_array_length(ndr, &r->in.ServiceName), sizeof(uint16_t), CH_UTF16));

5136

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ServiceName_0, 0);

5137

}

5138

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.access_mask));

5139

}

5140

if (flags & NDR_OUT) {

5141

NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));

5142

}

5143

return NDR_ERR_SUCCESS;

5144

}

5145

5146

_PUBLIC_ void ndr_print_svcctl_OpenServiceA(struct ndr_print *ndr, const char *name, int flags, const struct svcctl_OpenServiceA *r)

5147

{

5148

ndr_print_struct(ndr, name, "svcctl_OpenServiceA");

5149

ndr->depth++;

5150

if (flags & NDR_SET_VALUES) {

5151

ndr->flags |= LIBNDR_PRINT_SET_VALUES;

5152

}

5153

if (flags & NDR_IN) {

5154

ndr_print_struct(ndr, "in", "svcctl_OpenServiceA");

5155

ndr->depth++;

5156

ndr_print_ptr(ndr, "scmanager_handle", r->in.scmanager_handle);

5157

ndr->depth++;

5158

ndr_print_policy_handle(ndr, "scmanager_handle", r->in.scmanager_handle);

5159

ndr->depth--;

5160

ndr_print_ptr(ndr, "ServiceName", r->in.ServiceName);

5161

ndr->depth++;

5162

if (r->in.ServiceName) {

5163

ndr_print_string(ndr, "ServiceName", r->in.ServiceName);

5164

}

5165

ndr->depth--;

5166

ndr_print_uint32(ndr, "access_mask", r->in.access_mask);

5167

ndr->depth--;

5168

}

5169

if (flags & NDR_OUT) {

5170

ndr_print_struct(ndr, "out", "svcctl_OpenServiceA");

5171

ndr->depth++;

5172

ndr_print_WERROR(ndr, "result", r->out.result);

5173

ndr->depth--;

5174

}

5175

ndr->depth--;

5176

}

5177

5178

static enum ndr_err_code ndr_push_svcctl_QueryServiceConfigA(struct ndr_push *ndr, int flags, const struct svcctl_QueryServiceConfigA *r)

5179

{

5180

if (flags & NDR_IN) {

5181

if (r->in.handle == NULL) {

5182

return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");

5183

}

5184

NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));

5185

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));

5186

}

5187

if (flags & NDR_OUT) {

5188

NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->out.query, r->in.offered));

5189

if (r->out.needed == NULL) {

5190

return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");

5191

}

5192

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));

5193

NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));

5194

}

5195

return NDR_ERR_SUCCESS;

5196

}

5197

5198

static enum ndr_err_code ndr_pull_svcctl_QueryServiceConfigA(struct ndr_pull *ndr, int flags, struct svcctl_QueryServiceConfigA *r)

5199

{

5200

TALLOC_CTX *_mem_save_handle_0;

5201

TALLOC_CTX *_mem_save_needed_0;

5202

if (flags & NDR_IN) {

5203

ZERO_STRUCT(r->out);

5204

5205

if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {

5206

NDR_PULL_ALLOC(ndr, r->in.handle);

5207

}

5208

_mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);

5209

NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);

5210

NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));

5211

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);

5212

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));

5213

NDR_PULL_ALLOC(ndr, r->out.needed);

5214

ZERO_STRUCTP(r->out.needed);

5215

}

5216

if (flags & NDR_OUT) {

5217

NDR_PULL_ALLOC_N(ndr, r->out.query, r->in.offered);

5218

NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->out.query, r->in.offered));

5219

if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {

5220

NDR_PULL_ALLOC(ndr, r->out.needed);

5221

}

5222

_mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);

5223

NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);

5224

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));

5225

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);

5226

NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));

5227

}

5228

return NDR_ERR_SUCCESS;

5229

}

5230

5231

_PUBLIC_ void ndr_print_svcctl_QueryServiceConfigA(struct ndr_print *ndr, const char *name, int flags, const struct svcctl_QueryServiceConfigA *r)

5232

{

5233

ndr_print_struct(ndr, name, "svcctl_QueryServiceConfigA");

5234

ndr->depth++;

5235

if (flags & NDR_SET_VALUES) {

5236

ndr->flags |= LIBNDR_PRINT_SET_VALUES;

5237

}

5238

if (flags & NDR_IN) {

5239

ndr_print_struct(ndr, "in", "svcctl_QueryServiceConfigA");

5240

ndr->depth++;

5241

ndr_print_ptr(ndr, "handle", r->in.handle);

5242

ndr->depth++;

5243

ndr_print_policy_handle(ndr, "handle", r->in.handle);

5244

ndr->depth--;

5245

ndr_print_uint32(ndr, "offered", r->in.offered);

5246

ndr->depth--;

5247

}

5248

if (flags & NDR_OUT) {

5249

ndr_print_struct(ndr, "out", "svcctl_QueryServiceConfigA");

5250

ndr->depth++;

5251

ndr_print_array_uint8(ndr, "query", r->out.query, r->in.offered);

5252

ndr_print_ptr(ndr, "needed", r->out.needed);

5253

ndr->depth++;

5254

ndr_print_uint32(ndr, "needed", *r->out.needed);

5255

ndr->depth--;

5256

ndr_print_WERROR(ndr, "result", r->out.result);

5257

ndr->depth--;

5258

}

5259

ndr->depth--;

5260

}

5261

5262

static enum ndr_err_code ndr_push_svcctl_QueryServiceLockStatusA(struct ndr_push *ndr, int flags, const struct svcctl_QueryServiceLockStatusA *r)

5263

{

5264

if (flags & NDR_IN) {

5265

if (r->in.handle == NULL) {

5266

return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");

5267

}

5268

NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));

5269

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));

5270

}

5271

if (flags & NDR_OUT) {

5272

if (r->out.lock_status == NULL) {

5273

return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");

5274

}

5275

NDR_CHECK(ndr_push_SERVICE_LOCK_STATUS(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.lock_status));

5276

if (r->out.needed == NULL) {

5277

return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");

5278

}

5279

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));

5280

NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));

5281

}

5282

return NDR_ERR_SUCCESS;

5283

}

5284

5285

static enum ndr_err_code ndr_pull_svcctl_QueryServiceLockStatusA(struct ndr_pull *ndr, int flags, struct svcctl_QueryServiceLockStatusA *r)

5286

{

5287

TALLOC_CTX *_mem_save_handle_0;

5288

TALLOC_CTX *_mem_save_lock_status_0;

5289

TALLOC_CTX *_mem_save_needed_0;

5290

if (flags & NDR_IN) {

5291

ZERO_STRUCT(r->out);

5292

5293

if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {

5294

NDR_PULL_ALLOC(ndr, r->in.handle);

5295

}

5296

_mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);

5297

NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);

5298

NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));

5299

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);

5300

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));

5301

NDR_PULL_ALLOC(ndr, r->out.lock_status);

5302

ZERO_STRUCTP(r->out.lock_status);

5303

NDR_PULL_ALLOC(ndr, r->out.needed);

5304

ZERO_STRUCTP(r->out.needed);

5305

}

5306

if (flags & NDR_OUT) {

5307

if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {

5308

NDR_PULL_ALLOC(ndr, r->out.lock_status);

5309

}

5310

_mem_save_lock_status_0 = NDR_PULL_GET_MEM_CTX(ndr);

5311

NDR_PULL_SET_MEM_CTX(ndr, r->out.lock_status, LIBNDR_FLAG_REF_ALLOC);

5312

NDR_CHECK(ndr_pull_SERVICE_LOCK_STATUS(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.lock_status));

5313

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_lock_status_0, LIBNDR_FLAG_REF_ALLOC);

5314

if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {

5315

NDR_PULL_ALLOC(ndr, r->out.needed);

5316

}

5317

_mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);

5318

NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);

5319

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));

5320

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);

5321

NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));

5322

}

5323

return NDR_ERR_SUCCESS;

5324

}

5325

5326

_PUBLIC_ void ndr_print_svcctl_QueryServiceLockStatusA(struct ndr_print *ndr, const char *name, int flags, const struct svcctl_QueryServiceLockStatusA *r)

5327

{

5328

ndr_print_struct(ndr, name, "svcctl_QueryServiceLockStatusA");

5329

ndr->depth++;

5330

if (flags & NDR_SET_VALUES) {

5331

ndr->flags |= LIBNDR_PRINT_SET_VALUES;

5332

}

5333

if (flags & NDR_IN) {

5334

ndr_print_struct(ndr, "in", "svcctl_QueryServiceLockStatusA");

5335

ndr->depth++;

5336

ndr_print_ptr(ndr, "handle", r->in.handle);

5337

ndr->depth++;

5338

ndr_print_policy_handle(ndr, "handle", r->in.handle);

5339

ndr->depth--;

5340

ndr_print_uint32(ndr, "offered", r->in.offered);

5341

ndr->depth--;

5342

}

5343

if (flags & NDR_OUT) {

5344

ndr_print_struct(ndr, "out", "svcctl_QueryServiceLockStatusA");

5345

ndr->depth++;

5346

ndr_print_ptr(ndr, "lock_status", r->out.lock_status);

5347

ndr->depth++;

5348

ndr_print_SERVICE_LOCK_STATUS(ndr, "lock_status", r->out.lock_status);

5349

ndr->depth--;

5350

ndr_print_ptr(ndr, "needed", r->out.needed);

5351

ndr->depth++;

5352

ndr_print_uint32(ndr, "needed", *r->out.needed);

5353

ndr->depth--;

5354

ndr_print_WERROR(ndr, "result", r->out.result);

5355

ndr->depth--;

5356

}

5357

ndr->depth--;

5358

}

5359

5360

static enum ndr_err_code ndr_push_svcctl_StartServiceA(struct ndr_push *ndr, int flags, const struct svcctl_StartServiceA *r)

5361

{

5362

if (flags & NDR_IN) {

5363

if (r->in.handle == NULL) {

5364

return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");

5365

}

5366

NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));

5367

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.NumArgs));

5368

NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.Arguments));

5369

if (r->in.Arguments) {

5370

NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.Arguments, CH_UTF16)));

5371

NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));

5372

NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.Arguments, CH_UTF16)));

5373

NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.Arguments, ndr_charset_length(r->in.Arguments, CH_UTF16), sizeof(uint16_t), CH_UTF16));

5374

}

5375

}

5376

if (flags & NDR_OUT) {

5377

NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));

5378

}

5379

return NDR_ERR_SUCCESS;

5380

}

5381

5382

static enum ndr_err_code ndr_pull_svcctl_StartServiceA(struct ndr_pull *ndr, int flags, struct svcctl_StartServiceA *r)

5383

{

5384

uint32_t _ptr_Arguments;

5385

TALLOC_CTX *_mem_save_handle_0;

5386

TALLOC_CTX *_mem_save_Arguments_0;

5387

if (flags & NDR_IN) {

5388

if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {

5389

NDR_PULL_ALLOC(ndr, r->in.handle);

5390

}

5391

_mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);

5392

NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);

5393

NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));

5394

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);

5395

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.NumArgs));

5396

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_Arguments));

5397

if (_ptr_Arguments) {

5398

NDR_PULL_ALLOC(ndr, r->in.Arguments);

5399

} else {

5400

r->in.Arguments = NULL;

5401

}

5402

if (r->in.Arguments) {

5403

_mem_save_Arguments_0 = NDR_PULL_GET_MEM_CTX(ndr);

5404

NDR_PULL_SET_MEM_CTX(ndr, r->in.Arguments, 0);

5405

NDR_CHECK(ndr_pull_array_size(ndr, &r->in.Arguments));

5406

NDR_CHECK(ndr_pull_array_length(ndr, &r->in.Arguments));

5407

if (ndr_get_array_length(ndr, &r->in.Arguments) > ndr_get_array_size(ndr, &r->in.Arguments)) {

5408

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.Arguments), ndr_get_array_length(ndr, &r->in.Arguments));

5409

}

5410

NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.Arguments), sizeof(uint16_t)));

5411

NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.Arguments, ndr_get_array_length(ndr, &r->in.Arguments), sizeof(uint16_t), CH_UTF16));

5412

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_Arguments_0, 0);

5413

}

5414

}

5415

if (flags & NDR_OUT) {

5416

NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));

5417

}

5418

return NDR_ERR_SUCCESS;

5419

}

5420

5421

_PUBLIC_ void ndr_print_svcctl_StartServiceA(struct ndr_print *ndr, const char *name, int flags, const struct svcctl_StartServiceA *r)

5422

{

5423

ndr_print_struct(ndr, name, "svcctl_StartServiceA");

5424

ndr->depth++;

5425

if (flags & NDR_SET_VALUES) {

5426

ndr->flags |= LIBNDR_PRINT_SET_VALUES;

5427

}

5428

if (flags & NDR_IN) {

5429

ndr_print_struct(ndr, "in", "svcctl_StartServiceA");

5430

ndr->depth++;

5431

ndr_print_ptr(ndr, "handle", r->in.handle);

5432

ndr->depth++;

5433

ndr_print_policy_handle(ndr, "handle", r->in.handle);

5434

ndr->depth--;

5435

ndr_print_uint32(ndr, "NumArgs", r->in.NumArgs);

5436

ndr_print_ptr(ndr, "Arguments", r->in.Arguments);

5437

ndr->depth++;

5438

if (r->in.Arguments) {

5439

ndr_print_string(ndr, "Arguments", r->in.Arguments);

5440

}

5441

ndr->depth--;

5442

ndr->depth--;

5443

}

5444

if (flags & NDR_OUT) {

5445

ndr_print_struct(ndr, "out", "svcctl_StartServiceA");

5446

ndr->depth++;

5447

ndr_print_WERROR(ndr, "result", r->out.result);

5448

ndr->depth--;

5449

}

5450

ndr->depth--;

5451

}

5452

5453

static enum ndr_err_code ndr_push_svcctl_GetServiceDisplayNameA(struct ndr_push *ndr, int flags, const struct svcctl_GetServiceDisplayNameA *r)

5454

{

5455

if (flags & NDR_IN) {

5456

if (r->in.handle == NULL) {

5457

return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");

5458

}

5459

NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));

5460

NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.service_name));

5461

if (r->in.service_name) {

5462

NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.service_name, CH_UTF16)));

5463

NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));

5464

NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.service_name, CH_UTF16)));

5465

NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.service_name, ndr_charset_length(r->in.service_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));

5466

}

5467

NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.display_name_length));

5468

if (r->in.display_name_length) {

5469

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->in.display_name_length));

5470

}

5471

}

5472

if (flags & NDR_OUT) {

5473

if (r->out.display_name == NULL) {

5474

return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");

5475

}

5476

NDR_CHECK(ndr_push_unique_ptr(ndr, *r->out.display_name));

5477

if (*r->out.display_name) {

5478

NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(*r->out.display_name, CH_UTF16)));

5479

NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));

5480

NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(*r->out.display_name, CH_UTF16)));

5481

NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, *r->out.display_name, ndr_charset_length(*r->out.display_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));

5482

}

5483

NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.display_name_length));

5484

if (r->out.display_name_length) {

5485

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.display_name_length));

5486

}

5487

NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));

5488

}

5489

return NDR_ERR_SUCCESS;

5490

}

5491

5492

static enum ndr_err_code ndr_pull_svcctl_GetServiceDisplayNameA(struct ndr_pull *ndr, int flags, struct svcctl_GetServiceDisplayNameA *r)

5493

{

5494

uint32_t _ptr_service_name;

5495

uint32_t _ptr_display_name;

5496

uint32_t _ptr_display_name_length;

5497

TALLOC_CTX *_mem_save_handle_0;

5498

TALLOC_CTX *_mem_save_service_name_0;

5499

TALLOC_CTX *_mem_save_display_name_0;

5500

TALLOC_CTX *_mem_save_display_name_1;

5501

TALLOC_CTX *_mem_save_display_name_length_0;

5502

if (flags & NDR_IN) {

5503

ZERO_STRUCT(r->out);

5504

5505

if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {

5506

NDR_PULL_ALLOC(ndr, r->in.handle);

5507

}

5508

_mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);

5509

NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);

5510

NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));

5511

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);

5512

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_service_name));

5513

if (_ptr_service_name) {

5514

NDR_PULL_ALLOC(ndr, r->in.service_name);

5515

} else {

5516

r->in.service_name = NULL;

5517

}

5518

if (r->in.service_name) {

5519

_mem_save_service_name_0 = NDR_PULL_GET_MEM_CTX(ndr);

5520

NDR_PULL_SET_MEM_CTX(ndr, r->in.service_name, 0);

5521

NDR_CHECK(ndr_pull_array_size(ndr, &r->in.service_name));

5522

NDR_CHECK(ndr_pull_array_length(ndr, &r->in.service_name));

5523

if (ndr_get_array_length(ndr, &r->in.service_name) > ndr_get_array_size(ndr, &r->in.service_name)) {

5524

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.service_name), ndr_get_array_length(ndr, &r->in.service_name));

5525

}

5526

NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.service_name), sizeof(uint16_t)));

5527

NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.service_name, ndr_get_array_length(ndr, &r->in.service_name), sizeof(uint16_t), CH_UTF16));

5528

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_service_name_0, 0);

5529

}

5530

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_display_name_length));

5531

if (_ptr_display_name_length) {

5532

NDR_PULL_ALLOC(ndr, r->in.display_name_length);

5533

} else {

5534

r->in.display_name_length = NULL;

5535

}

5536

if (r->in.display_name_length) {

5537

_mem_save_display_name_length_0 = NDR_PULL_GET_MEM_CTX(ndr);

5538

NDR_PULL_SET_MEM_CTX(ndr, r->in.display_name_length, 0);

5539

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->in.display_name_length));

5540

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_display_name_length_0, 0);

5541

}

5542

NDR_PULL_ALLOC(ndr, r->out.display_name);

5543

ZERO_STRUCTP(r->out.display_name);

5544

}

5545

if (flags & NDR_OUT) {

5546

if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {

5547

NDR_PULL_ALLOC(ndr, r->out.display_name);

5548

}

5549

_mem_save_display_name_0 = NDR_PULL_GET_MEM_CTX(ndr);

5550

NDR_PULL_SET_MEM_CTX(ndr, r->out.display_name, LIBNDR_FLAG_REF_ALLOC);

5551

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_display_name));

5552

if (_ptr_display_name) {

5553

NDR_PULL_ALLOC(ndr, *r->out.display_name);

5554

} else {

5555

*r->out.display_name = NULL;

5556

}

5557

if (*r->out.display_name) {

5558

_mem_save_display_name_1 = NDR_PULL_GET_MEM_CTX(ndr);

5559

NDR_PULL_SET_MEM_CTX(ndr, *r->out.display_name, 0);

5560

NDR_CHECK(ndr_pull_array_size(ndr, r->out.display_name));

5561

NDR_CHECK(ndr_pull_array_length(ndr, r->out.display_name));

5562

if (ndr_get_array_length(ndr, r->out.display_name) > ndr_get_array_size(ndr, r->out.display_name)) {

5563

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.display_name), ndr_get_array_length(ndr, r->out.display_name));

5564

}

5565

NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, r->out.display_name), sizeof(uint16_t)));

5566

NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, r->out.display_name, ndr_get_array_length(ndr, r->out.display_name), sizeof(uint16_t), CH_UTF16));

5567

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_display_name_1, 0);

5568

}

5569

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_display_name_0, LIBNDR_FLAG_REF_ALLOC);

5570

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_display_name_length));

5571

if (_ptr_display_name_length) {

5572

NDR_PULL_ALLOC(ndr, r->out.display_name_length);

5573

} else {

5574

r->out.display_name_length = NULL;

5575

}

5576

if (r->out.display_name_length) {

5577

_mem_save_display_name_length_0 = NDR_PULL_GET_MEM_CTX(ndr);

5578

NDR_PULL_SET_MEM_CTX(ndr, r->out.display_name_length, 0);

5579

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.display_name_length));

5580

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_display_name_length_0, 0);

5581

}

5582

NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));

5583

}

5584

return NDR_ERR_SUCCESS;

5585

}

5586

5587

_PUBLIC_ void ndr_print_svcctl_GetServiceDisplayNameA(struct ndr_print *ndr, const char *name, int flags, const struct svcctl_GetServiceDisplayNameA *r)

5588

{

5589

ndr_print_struct(ndr, name, "svcctl_GetServiceDisplayNameA");

5590

ndr->depth++;

5591

if (flags & NDR_SET_VALUES) {

5592

ndr->flags |= LIBNDR_PRINT_SET_VALUES;

5593

}

5594

if (flags & NDR_IN) {

5595

ndr_print_struct(ndr, "in", "svcctl_GetServiceDisplayNameA");

5596

ndr->depth++;

5597

ndr_print_ptr(ndr, "handle", r->in.handle);

5598

ndr->depth++;

5599

ndr_print_policy_handle(ndr, "handle", r->in.handle);

5600

ndr->depth--;

5601

ndr_print_ptr(ndr, "service_name", r->in.service_name);

5602

ndr->depth++;

5603

if (r->in.service_name) {

5604

ndr_print_string(ndr, "service_name", r->in.service_name);

5605

}

5606

ndr->depth--;

5607

ndr_print_ptr(ndr, "display_name_length", r->in.display_name_length);

5608

ndr->depth++;

5609

if (r->in.display_name_length) {

5610

ndr_print_uint32(ndr, "display_name_length", *r->in.display_name_length);

5611

}

5612

ndr->depth--;

5613

ndr->depth--;

5614

}

5615

if (flags & NDR_OUT) {

5616

ndr_print_struct(ndr, "out", "svcctl_GetServiceDisplayNameA");

5617

ndr->depth++;

5618

ndr_print_ptr(ndr, "display_name", r->out.display_name);

5619

ndr->depth++;

5620

ndr_print_ptr(ndr, "display_name", *r->out.display_name);

5621

ndr->depth++;

5622

if (*r->out.display_name) {

5623

ndr_print_string(ndr, "display_name", *r->out.display_name);

5624

}

5625

ndr->depth--;

5626

ndr->depth--;

5627

ndr_print_ptr(ndr, "display_name_length", r->out.display_name_length);

5628

ndr->depth++;

5629

if (r->out.display_name_length) {

5630

ndr_print_uint32(ndr, "display_name_length", *r->out.display_name_length);

5631

}

5632

ndr->depth--;

5633

ndr_print_WERROR(ndr, "result", r->out.result);

5634

ndr->depth--;

5635

}

5636

ndr->depth--;

5637

}

5638

5639

static enum ndr_err_code ndr_push_svcctl_GetServiceKeyNameA(struct ndr_push *ndr, int flags, const struct svcctl_GetServiceKeyNameA *r)

5640

{

5641

if (flags & NDR_IN) {

5642

if (r->in.handle == NULL) {

5643

return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");

5644

}

5645

NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));

5646

NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.service_name));

5647

if (r->in.service_name) {

5648

NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.service_name, CH_UTF16)));

5649

NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));

5650

NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.service_name, CH_UTF16)));

5651

NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.service_name, ndr_charset_length(r->in.service_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));

5652

}

5653

NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.display_name_length));

5654

if (r->in.display_name_length) {

5655

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->in.display_name_length));

5656

}

5657

}

5658

if (flags & NDR_OUT) {

5659

if (r->out.key_name == NULL) {

5660

return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");

5661

}

5662

NDR_CHECK(ndr_push_unique_ptr(ndr, *r->out.key_name));

5663

if (*r->out.key_name) {

5664

NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(*r->out.key_name, CH_UTF16)));

5665

NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));

5666

NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(*r->out.key_name, CH_UTF16)));

5667

NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, *r->out.key_name, ndr_charset_length(*r->out.key_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));

5668

}

5669

NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.display_name_length));

5670

if (r->out.display_name_length) {

5671

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.display_name_length));

5672

}

5673

NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));

5674

}

5675

return NDR_ERR_SUCCESS;

5676

}

5677

5678

static enum ndr_err_code ndr_pull_svcctl_GetServiceKeyNameA(struct ndr_pull *ndr, int flags, struct svcctl_GetServiceKeyNameA *r)

5679

{

5680

uint32_t _ptr_service_name;

5681

uint32_t _ptr_key_name;

5682

uint32_t _ptr_display_name_length;

5683

TALLOC_CTX *_mem_save_handle_0;

5684

TALLOC_CTX *_mem_save_service_name_0;

5685

TALLOC_CTX *_mem_save_key_name_0;

5686

TALLOC_CTX *_mem_save_key_name_1;

5687

TALLOC_CTX *_mem_save_display_name_length_0;

5688

if (flags & NDR_IN) {

5689

ZERO_STRUCT(r->out);

5690

5691

if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {

5692

NDR_PULL_ALLOC(ndr, r->in.handle);

5693

}

5694

_mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);

5695

NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);

5696

NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));

5697

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);

5698

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_service_name));

5699

if (_ptr_service_name) {

5700

NDR_PULL_ALLOC(ndr, r->in.service_name);

5701

} else {

5702

r->in.service_name = NULL;

5703

}

5704

if (r->in.service_name) {

5705

_mem_save_service_name_0 = NDR_PULL_GET_MEM_CTX(ndr);

5706

NDR_PULL_SET_MEM_CTX(ndr, r->in.service_name, 0);

5707

NDR_CHECK(ndr_pull_array_size(ndr, &r->in.service_name));

5708

NDR_CHECK(ndr_pull_array_length(ndr, &r->in.service_name));

5709

if (ndr_get_array_length(ndr, &r->in.service_name) > ndr_get_array_size(ndr, &r->in.service_name)) {

5710

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.service_name), ndr_get_array_length(ndr, &r->in.service_name));

5711

}

5712

NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.service_name), sizeof(uint16_t)));

5713

NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.service_name, ndr_get_array_length(ndr, &r->in.service_name), sizeof(uint16_t), CH_UTF16));

5714

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_service_name_0, 0);

5715

}

5716

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_display_name_length));

5717

if (_ptr_display_name_length) {

5718

NDR_PULL_ALLOC(ndr, r->in.display_name_length);

5719

} else {

5720

r->in.display_name_length = NULL;

5721

}

5722

if (r->in.display_name_length) {

5723

_mem_save_display_name_length_0 = NDR_PULL_GET_MEM_CTX(ndr);

5724

NDR_PULL_SET_MEM_CTX(ndr, r->in.display_name_length, 0);

5725

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->in.display_name_length));

5726

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_display_name_length_0, 0);

5727

}

5728

NDR_PULL_ALLOC(ndr, r->out.key_name);

5729

ZERO_STRUCTP(r->out.key_name);

5730

}

5731

if (flags & NDR_OUT) {

5732

if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {

5733

NDR_PULL_ALLOC(ndr, r->out.key_name);

5734

}

5735

_mem_save_key_name_0 = NDR_PULL_GET_MEM_CTX(ndr);

5736

NDR_PULL_SET_MEM_CTX(ndr, r->out.key_name, LIBNDR_FLAG_REF_ALLOC);

5737

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_key_name));

5738

if (_ptr_key_name) {

5739

NDR_PULL_ALLOC(ndr, *r->out.key_name);

5740

} else {

5741

*r->out.key_name = NULL;

5742

}

5743

if (*r->out.key_name) {

5744

_mem_save_key_name_1 = NDR_PULL_GET_MEM_CTX(ndr);

5745

NDR_PULL_SET_MEM_CTX(ndr, *r->out.key_name, 0);

5746

NDR_CHECK(ndr_pull_array_size(ndr, r->out.key_name));

5747

NDR_CHECK(ndr_pull_array_length(ndr, r->out.key_name));

5748

if (ndr_get_array_length(ndr, r->out.key_name) > ndr_get_array_size(ndr, r->out.key_name)) {

5749

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.key_name), ndr_get_array_length(ndr, r->out.key_name));

5750

}

5751

NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, r->out.key_name), sizeof(uint16_t)));

5752

NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, r->out.key_name, ndr_get_array_length(ndr, r->out.key_name), sizeof(uint16_t), CH_UTF16));

5753

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_key_name_1, 0);

5754

}

5755

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_key_name_0, LIBNDR_FLAG_REF_ALLOC);

5756

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_display_name_length));

5757

if (_ptr_display_name_length) {

5758

NDR_PULL_ALLOC(ndr, r->out.display_name_length);

5759

} else {

5760

r->out.display_name_length = NULL;

5761

}

5762

if (r->out.display_name_length) {

5763

_mem_save_display_name_length_0 = NDR_PULL_GET_MEM_CTX(ndr);

5764

NDR_PULL_SET_MEM_CTX(ndr, r->out.display_name_length, 0);

5765

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.display_name_length));

5766

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_display_name_length_0, 0);

5767

}

5768

NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));

5769

}

5770

return NDR_ERR_SUCCESS;

5771

}

5772

5773

_PUBLIC_ void ndr_print_svcctl_GetServiceKeyNameA(struct ndr_print *ndr, const char *name, int flags, const struct svcctl_GetServiceKeyNameA *r)

5774

{

5775

ndr_print_struct(ndr, name, "svcctl_GetServiceKeyNameA");

5776

ndr->depth++;

5777

if (flags & NDR_SET_VALUES) {

5778

ndr->flags |= LIBNDR_PRINT_SET_VALUES;

5779

}

5780

if (flags & NDR_IN) {

5781

ndr_print_struct(ndr, "in", "svcctl_GetServiceKeyNameA");

5782

ndr->depth++;

5783

ndr_print_ptr(ndr, "handle", r->in.handle);

5784

ndr->depth++;

5785

ndr_print_policy_handle(ndr, "handle", r->in.handle);

5786

ndr->depth--;

5787

ndr_print_ptr(ndr, "service_name", r->in.service_name);

5788

ndr->depth++;

5789

if (r->in.service_name) {

5790

ndr_print_string(ndr, "service_name", r->in.service_name);

5791

}

5792

ndr->depth--;

5793

ndr_print_ptr(ndr, "display_name_length", r->in.display_name_length);

5794

ndr->depth++;

5795

if (r->in.display_name_length) {

5796

ndr_print_uint32(ndr, "display_name_length", *r->in.display_name_length);

5797

}

5798

ndr->depth--;

5799

ndr->depth--;

5800

}

5801

if (flags & NDR_OUT) {

5802

ndr_print_struct(ndr, "out", "svcctl_GetServiceKeyNameA");

5803

ndr->depth++;

5804

ndr_print_ptr(ndr, "key_name", r->out.key_name);

5805

ndr->depth++;

5806

ndr_print_ptr(ndr, "key_name", *r->out.key_name);

5807

ndr->depth++;

5808

if (*r->out.key_name) {

5809

ndr_print_string(ndr, "key_name", *r->out.key_name);

5810

}

5811

ndr->depth--;

5812

ndr->depth--;

5813

ndr_print_ptr(ndr, "display_name_length", r->out.display_name_length);

5814

ndr->depth++;

5815

if (r->out.display_name_length) {

5816

ndr_print_uint32(ndr, "display_name_length", *r->out.display_name_length);

5817

}

5818

ndr->depth--;

5819

ndr_print_WERROR(ndr, "result", r->out.result);

5820

ndr->depth--;

5821

}

5822

ndr->depth--;

5823

}

5824

5825

static enum ndr_err_code ndr_push_svcctl_GetCurrentGroupeStateW(struct ndr_push *ndr, int flags, const struct svcctl_GetCurrentGroupeStateW *r)

5826

{

5827

if (flags & NDR_IN) {

5828

}

5829

if (flags & NDR_OUT) {

5830

NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));

5831

}

5832

return NDR_ERR_SUCCESS;

5833

}

5834

5835

static enum ndr_err_code ndr_pull_svcctl_GetCurrentGroupeStateW(struct ndr_pull *ndr, int flags, struct svcctl_GetCurrentGroupeStateW *r)

5836

{

5837

if (flags & NDR_IN) {

5838

}

5839

if (flags & NDR_OUT) {

5840

NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));

5841

}

5842

return NDR_ERR_SUCCESS;

5843

}

5844

5845

_PUBLIC_ void ndr_print_svcctl_GetCurrentGroupeStateW(struct ndr_print *ndr, const char *name, int flags, const struct svcctl_GetCurrentGroupeStateW *r)

5846

{

5847

ndr_print_struct(ndr, name, "svcctl_GetCurrentGroupeStateW");

5848

ndr->depth++;

5849

if (flags & NDR_SET_VALUES) {

5850

ndr->flags |= LIBNDR_PRINT_SET_VALUES;

5851

}

5852

if (flags & NDR_IN) {

5853

ndr_print_struct(ndr, "in", "svcctl_GetCurrentGroupeStateW");

5854

ndr->depth++;

5855

ndr->depth--;

5856

}

5857

if (flags & NDR_OUT) {

5858

ndr_print_struct(ndr, "out", "svcctl_GetCurrentGroupeStateW");

5859

ndr->depth++;

5860

ndr_print_WERROR(ndr, "result", r->out.result);

5861

ndr->depth--;

5862

}

5863

ndr->depth--;

5864

}

5865

5866

static enum ndr_err_code ndr_push_svcctl_EnumServiceGroupW(struct ndr_push *ndr, int flags, const struct svcctl_EnumServiceGroupW *r)

5867

{

5868

if (flags & NDR_IN) {

5869

}

5870

if (flags & NDR_OUT) {

5871

NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));

5872

}

5873

return NDR_ERR_SUCCESS;

5874

}

5875

5876

static enum ndr_err_code ndr_pull_svcctl_EnumServiceGroupW(struct ndr_pull *ndr, int flags, struct svcctl_EnumServiceGroupW *r)

5877

{

5878

if (flags & NDR_IN) {

5879

}

5880

if (flags & NDR_OUT) {

5881

NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));

5882

}

5883

return NDR_ERR_SUCCESS;

5884

}

5885

5886

_PUBLIC_ void ndr_print_svcctl_EnumServiceGroupW(struct ndr_print *ndr, const char *name, int flags, const struct svcctl_EnumServiceGroupW *r)

5887

{

5888

ndr_print_struct(ndr, name, "svcctl_EnumServiceGroupW");

5889

ndr->depth++;

5890

if (flags & NDR_SET_VALUES) {

5891

ndr->flags |= LIBNDR_PRINT_SET_VALUES;

5892

}

5893

if (flags & NDR_IN) {

5894

ndr_print_struct(ndr, "in", "svcctl_EnumServiceGroupW");

5895

ndr->depth++;

5896

ndr->depth--;

5897

}

5898

if (flags & NDR_OUT) {

5899

ndr_print_struct(ndr, "out", "svcctl_EnumServiceGroupW");

5900

ndr->depth++;

5901

ndr_print_WERROR(ndr, "result", r->out.result);

5902

ndr->depth--;

5903

}

5904

ndr->depth--;

5905

}

5906

5907

static enum ndr_err_code ndr_push_svcctl_ChangeServiceConfig2A(struct ndr_push *ndr, int flags, const struct svcctl_ChangeServiceConfig2A *r)

5908

{

5909

if (flags & NDR_IN) {

5910

if (r->in.handle == NULL) {

5911

return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");

5912

}

5913

NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));

5914

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.info_level));

5915

NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.info));

5916

if (r->in.info) {

5917

NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, *r->in.info));

5918

}

5919

}

5920

if (flags & NDR_OUT) {

5921

NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));

5922

}

5923

return NDR_ERR_SUCCESS;

5924

}

5925

5926

static enum ndr_err_code ndr_pull_svcctl_ChangeServiceConfig2A(struct ndr_pull *ndr, int flags, struct svcctl_ChangeServiceConfig2A *r)

5927

{

5928

uint32_t _ptr_info;

5929

TALLOC_CTX *_mem_save_handle_0;

5930

TALLOC_CTX *_mem_save_info_0;

5931

if (flags & NDR_IN) {

5932

if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {

5933

NDR_PULL_ALLOC(ndr, r->in.handle);

5934

}

5935

_mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);

5936

NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);

5937

NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));

5938

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);

5939

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.info_level));

5940

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));

5941

if (_ptr_info) {

5942

NDR_PULL_ALLOC(ndr, r->in.info);

5943

} else {

5944

r->in.info = NULL;

5945

}

5946

if (r->in.info) {

5947

_mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);

5948

NDR_PULL_SET_MEM_CTX(ndr, r->in.info, 0);

5949

NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, r->in.info));

5950

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);

5951

}

5952

}

5953

if (flags & NDR_OUT) {

5954

NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));

5955

}

5956

return NDR_ERR_SUCCESS;

5957

}

5958

5959

_PUBLIC_ void ndr_print_svcctl_ChangeServiceConfig2A(struct ndr_print *ndr, const char *name, int flags, const struct svcctl_ChangeServiceConfig2A *r)

5960

{

5961

ndr_print_struct(ndr, name, "svcctl_ChangeServiceConfig2A");

5962

ndr->depth++;

5963

if (flags & NDR_SET_VALUES) {

5964

ndr->flags |= LIBNDR_PRINT_SET_VALUES;

5965

}

5966

if (flags & NDR_IN) {

5967

ndr_print_struct(ndr, "in", "svcctl_ChangeServiceConfig2A");

5968

ndr->depth++;

5969

ndr_print_ptr(ndr, "handle", r->in.handle);

5970

ndr->depth++;

5971

ndr_print_policy_handle(ndr, "handle", r->in.handle);

5972

ndr->depth--;

5973

ndr_print_uint32(ndr, "info_level", r->in.info_level);

5974

ndr_print_ptr(ndr, "info", r->in.info);

5975

ndr->depth++;

5976

if (r->in.info) {

5977

ndr_print_uint8(ndr, "info", *r->in.info);

5978

}

5979

ndr->depth--;

5980

ndr->depth--;

5981

}

5982

if (flags & NDR_OUT) {

5983

ndr_print_struct(ndr, "out", "svcctl_ChangeServiceConfig2A");

5984

ndr->depth++;

5985

ndr_print_WERROR(ndr, "result", r->out.result);

5986

ndr->depth--;

5987

}

5988

ndr->depth--;

5989

}

5990

5991

static enum ndr_err_code ndr_push_svcctl_ChangeServiceConfig2W(struct ndr_push *ndr, int flags, const struct svcctl_ChangeServiceConfig2W *r)

5992

{

5993

if (flags & NDR_IN) {

5994

if (r->in.handle == NULL) {

5995

return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");

5996

}

5997

NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));

5998

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.info_level));

5999

NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.info));

6000

if (r->in.info) {

6001

NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, *r->in.info));

6002

}

6003

}

6004

if (flags & NDR_OUT) {

6005

NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));

6006

}

6007

return NDR_ERR_SUCCESS;

6008

}

6009

6010

static enum ndr_err_code ndr_pull_svcctl_ChangeServiceConfig2W(struct ndr_pull *ndr, int flags, struct svcctl_ChangeServiceConfig2W *r)

6011

{

6012

uint32_t _ptr_info;

6013

TALLOC_CTX *_mem_save_handle_0;

6014

TALLOC_CTX *_mem_save_info_0;

6015

if (flags & NDR_IN) {

6016

if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {

6017

NDR_PULL_ALLOC(ndr, r->in.handle);

6018

}

6019

_mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);

6020

NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);

6021

NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));

6022

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);

6023

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.info_level));

6024

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));

6025

if (_ptr_info) {

6026

NDR_PULL_ALLOC(ndr, r->in.info);

6027

} else {

6028

r->in.info = NULL;

6029

}

6030

if (r->in.info) {

6031

_mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);

6032

NDR_PULL_SET_MEM_CTX(ndr, r->in.info, 0);

6033

NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, r->in.info));

6034

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);

6035

}

6036

}

6037

if (flags & NDR_OUT) {

6038

NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));

6039

}

6040

return NDR_ERR_SUCCESS;

6041

}

6042

6043

_PUBLIC_ void ndr_print_svcctl_ChangeServiceConfig2W(struct ndr_print *ndr, const char *name, int flags, const struct svcctl_ChangeServiceConfig2W *r)

6044

{

6045

ndr_print_struct(ndr, name, "svcctl_ChangeServiceConfig2W");

6046

ndr->depth++;

6047

if (flags & NDR_SET_VALUES) {

6048

ndr->flags |= LIBNDR_PRINT_SET_VALUES;

6049

}

6050

if (flags & NDR_IN) {

6051

ndr_print_struct(ndr, "in", "svcctl_ChangeServiceConfig2W");

6052

ndr->depth++;

6053

ndr_print_ptr(ndr, "handle", r->in.handle);

6054

ndr->depth++;

6055

ndr_print_policy_handle(ndr, "handle", r->in.handle);

6056

ndr->depth--;

6057

ndr_print_uint32(ndr, "info_level", r->in.info_level);

6058

ndr_print_ptr(ndr, "info", r->in.info);

6059

ndr->depth++;

6060

if (r->in.info) {

6061

ndr_print_uint8(ndr, "info", *r->in.info);

6062

}

6063

ndr->depth--;

6064

ndr->depth--;

6065

}

6066

if (flags & NDR_OUT) {

6067

ndr_print_struct(ndr, "out", "svcctl_ChangeServiceConfig2W");

6068

ndr->depth++;

6069

ndr_print_WERROR(ndr, "result", r->out.result);

6070

ndr->depth--;

6071

}

6072

ndr->depth--;

6073

}

6074

6075

static enum ndr_err_code ndr_push_svcctl_QueryServiceConfig2A(struct ndr_push *ndr, int flags, const struct svcctl_QueryServiceConfig2A *r)

6076

{

6077

if (flags & NDR_IN) {

6078

if (r->in.handle == NULL) {

6079

return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");

6080

}

6081

NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));

6082

NDR_CHECK(ndr_push_svcctl_ConfigLevel(ndr, NDR_SCALARS, r->in.info_level));

6083

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));

6084

}

6085

if (flags & NDR_OUT) {

6086

NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->out.buffer, r->in.offered));

6087

if (r->out.needed == NULL) {

6088

return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");

6089

}

6090

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));

6091

NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));

6092

}

6093

return NDR_ERR_SUCCESS;

6094

}

6095

6096

static enum ndr_err_code ndr_pull_svcctl_QueryServiceConfig2A(struct ndr_pull *ndr, int flags, struct svcctl_QueryServiceConfig2A *r)

6097

{

6098

TALLOC_CTX *_mem_save_handle_0;

6099

TALLOC_CTX *_mem_save_needed_0;

6100

if (flags & NDR_IN) {

6101

ZERO_STRUCT(r->out);

6102

6103

if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {

6104

NDR_PULL_ALLOC(ndr, r->in.handle);

6105

}

6106

_mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);

6107

NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);

6108

NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));

6109

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);

6110

NDR_CHECK(ndr_pull_svcctl_ConfigLevel(ndr, NDR_SCALARS, &r->in.info_level));

6111

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));

6112

NDR_PULL_ALLOC(ndr, r->out.needed);

6113

ZERO_STRUCTP(r->out.needed);

6114

}

6115

if (flags & NDR_OUT) {

6116

NDR_PULL_ALLOC_N(ndr, r->out.buffer, r->in.offered);

6117

NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->out.buffer, r->in.offered));

6118

if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {

6119

NDR_PULL_ALLOC(ndr, r->out.needed);

6120

}

6121

_mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);

6122

NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);

6123

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));

6124

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);

6125

NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));

6126

}

6127

return NDR_ERR_SUCCESS;

6128

}

6129

6130

_PUBLIC_ void ndr_print_svcctl_QueryServiceConfig2A(struct ndr_print *ndr, const char *name, int flags, const struct svcctl_QueryServiceConfig2A *r)

6131

{

6132

ndr_print_struct(ndr, name, "svcctl_QueryServiceConfig2A");

6133

ndr->depth++;

6134

if (flags & NDR_SET_VALUES) {

6135

ndr->flags |= LIBNDR_PRINT_SET_VALUES;

6136

}

6137

if (flags & NDR_IN) {

6138

ndr_print_struct(ndr, "in", "svcctl_QueryServiceConfig2A");

6139

ndr->depth++;

6140

ndr_print_ptr(ndr, "handle", r->in.handle);

6141

ndr->depth++;

6142

ndr_print_policy_handle(ndr, "handle", r->in.handle);

6143

ndr->depth--;

6144

ndr_print_svcctl_ConfigLevel(ndr, "info_level", r->in.info_level);

6145

ndr_print_uint32(ndr, "offered", r->in.offered);

6146

ndr->depth--;

6147

}

6148

if (flags & NDR_OUT) {

6149

ndr_print_struct(ndr, "out", "svcctl_QueryServiceConfig2A");

6150

ndr->depth++;

6151

ndr_print_array_uint8(ndr, "buffer", r->out.buffer, r->in.offered);

6152

ndr_print_ptr(ndr, "needed", r->out.needed);

6153

ndr->depth++;

6154

ndr_print_uint32(ndr, "needed", *r->out.needed);

6155

ndr->depth--;

6156

ndr_print_WERROR(ndr, "result", r->out.result);

6157

ndr->depth--;

6158

}

6159

ndr->depth--;

6160

}

6161

6162

static enum ndr_err_code ndr_push_svcctl_QueryServiceConfig2W(struct ndr_push *ndr, int flags, const struct svcctl_QueryServiceConfig2W *r)

6163

{

6164

if (flags & NDR_IN) {

6165

if (r->in.handle == NULL) {

6166

return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");

6167

}

6168

NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));

6169

NDR_CHECK(ndr_push_svcctl_ConfigLevel(ndr, NDR_SCALARS, r->in.info_level));

6170

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));

6171

}

6172

if (flags & NDR_OUT) {

6173

if (r->out.buffer == NULL) {

6174

return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");

6175

}

6176

NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->in.offered));

6177

NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->out.buffer, r->in.offered));

6178

if (r->out.needed == NULL) {

6179

return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");

6180

}

6181

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));

6182

NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));

6183

}

6184

return NDR_ERR_SUCCESS;

6185

}

6186

6187

static enum ndr_err_code ndr_pull_svcctl_QueryServiceConfig2W(struct ndr_pull *ndr, int flags, struct svcctl_QueryServiceConfig2W *r)

6188

{

6189

TALLOC_CTX *_mem_save_handle_0;

6190

TALLOC_CTX *_mem_save_needed_0;

6191

if (flags & NDR_IN) {

6192

ZERO_STRUCT(r->out);

6193

6194

if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {

6195

NDR_PULL_ALLOC(ndr, r->in.handle);

6196

}

6197

_mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);

6198

NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);

6199

NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));

6200

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);

6201

NDR_CHECK(ndr_pull_svcctl_ConfigLevel(ndr, NDR_SCALARS, &r->in.info_level));

6202

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));

6203

if (r->in.offered > 8192) {

6204

return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");

6205

}

6206

NDR_PULL_ALLOC_N(ndr, r->out.buffer, r->in.offered);

6207

memset(r->out.buffer, 0, (r->in.offered) * sizeof(*r->out.buffer));

6208

NDR_PULL_ALLOC(ndr, r->out.needed);

6209

ZERO_STRUCTP(r->out.needed);

6210

}

6211

if (flags & NDR_OUT) {

6212

NDR_CHECK(ndr_pull_array_size(ndr, &r->out.buffer));

6213

if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {

6214

NDR_PULL_ALLOC_N(ndr, r->out.buffer, ndr_get_array_size(ndr, &r->out.buffer));

6215

}

6216

NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->out.buffer, ndr_get_array_size(ndr, &r->out.buffer)));

6217

if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {

6218

NDR_PULL_ALLOC(ndr, r->out.needed);

6219

}

6220

_mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);

6221

NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);

6222

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));

6223

if (*r->out.needed > 8192) {

6224

return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");

6225

}

6226

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);

6227

NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));

6228

if (r->out.buffer) {

6229

NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->out.buffer, r->in.offered));

6230

}

6231

}

6232

return NDR_ERR_SUCCESS;

6233

}

6234

6235

_PUBLIC_ void ndr_print_svcctl_QueryServiceConfig2W(struct ndr_print *ndr, const char *name, int flags, const struct svcctl_QueryServiceConfig2W *r)

6236

{

6237

ndr_print_struct(ndr, name, "svcctl_QueryServiceConfig2W");

6238

ndr->depth++;

6239

if (flags & NDR_SET_VALUES) {

6240

ndr->flags |= LIBNDR_PRINT_SET_VALUES;

6241

}

6242

if (flags & NDR_IN) {

6243

ndr_print_struct(ndr, "in", "svcctl_QueryServiceConfig2W");

6244

ndr->depth++;

6245

ndr_print_ptr(ndr, "handle", r->in.handle);

6246

ndr->depth++;

6247

ndr_print_policy_handle(ndr, "handle", r->in.handle);

6248

ndr->depth--;

6249

ndr_print_svcctl_ConfigLevel(ndr, "info_level", r->in.info_level);

6250

ndr_print_uint32(ndr, "offered", r->in.offered);

6251

ndr->depth--;

6252

}

6253

if (flags & NDR_OUT) {

6254

ndr_print_struct(ndr, "out", "svcctl_QueryServiceConfig2W");

6255

ndr->depth++;

6256

ndr_print_ptr(ndr, "buffer", r->out.buffer);

6257

ndr->depth++;

6258

ndr_print_array_uint8(ndr, "buffer", r->out.buffer, r->in.offered);

6259

ndr->depth--;

6260

ndr_print_ptr(ndr, "needed", r->out.needed);

6261

ndr->depth++;

6262

ndr_print_uint32(ndr, "needed", *r->out.needed);

6263

ndr->depth--;

6264

ndr_print_WERROR(ndr, "result", r->out.result);

6265

ndr->depth--;

6266

}

6267

ndr->depth--;

6268

}

6269

6270

static enum ndr_err_code ndr_push_svcctl_QueryServiceStatusEx(struct ndr_push *ndr, int flags, const struct svcctl_QueryServiceStatusEx *r)

6271

{

6272

if (flags & NDR_IN) {

6273

if (r->in.handle == NULL) {

6274

return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");

6275

}

6276

NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));

6277

NDR_CHECK(ndr_push_svcctl_StatusLevel(ndr, NDR_SCALARS, r->in.info_level));

6278

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));

6279

}

6280

if (flags & NDR_OUT) {

6281

if (r->out.buffer == NULL) {

6282

return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");

6283

}

6284

NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->in.offered));

6285

NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->out.buffer, r->in.offered));

6286

if (r->out.needed == NULL) {

6287

return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");

6288

}

6289

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));

6290

NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));

6291

}

6292

return NDR_ERR_SUCCESS;

6293

}

6294

6295

static enum ndr_err_code ndr_pull_svcctl_QueryServiceStatusEx(struct ndr_pull *ndr, int flags, struct svcctl_QueryServiceStatusEx *r)

6296

{

6297

TALLOC_CTX *_mem_save_handle_0;

6298

TALLOC_CTX *_mem_save_needed_0;

6299

if (flags & NDR_IN) {

6300

ZERO_STRUCT(r->out);

6301

6302

if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {

6303

NDR_PULL_ALLOC(ndr, r->in.handle);

6304

}

6305

_mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);

6306

NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);

6307

NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));

6308

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);

6309

NDR_CHECK(ndr_pull_svcctl_StatusLevel(ndr, NDR_SCALARS, &r->in.info_level));

6310

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));

6311

if (r->in.offered > 8192) {

6312

return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");

6313

}

6314

NDR_PULL_ALLOC_N(ndr, r->out.buffer, r->in.offered);

6315

memset(r->out.buffer, 0, (r->in.offered) * sizeof(*r->out.buffer));

6316

NDR_PULL_ALLOC(ndr, r->out.needed);

6317

ZERO_STRUCTP(r->out.needed);

6318

}

6319

if (flags & NDR_OUT) {

6320

NDR_CHECK(ndr_pull_array_size(ndr, &r->out.buffer));

6321

if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {

6322

NDR_PULL_ALLOC_N(ndr, r->out.buffer, ndr_get_array_size(ndr, &r->out.buffer));

6323

}

6324

NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->out.buffer, ndr_get_array_size(ndr, &r->out.buffer)));

6325

if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {

6326

NDR_PULL_ALLOC(ndr, r->out.needed);

6327

}

6328

_mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);

6329

NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);

6330

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));

6331

if (*r->out.needed > 8192) {

6332

return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");

6333

}

6334

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);

6335

NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));

6336

if (r->out.buffer) {

6337

NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->out.buffer, r->in.offered));

6338

}

6339

}

6340

return NDR_ERR_SUCCESS;

6341

}

6342

6343

_PUBLIC_ void ndr_print_svcctl_QueryServiceStatusEx(struct ndr_print *ndr, const char *name, int flags, const struct svcctl_QueryServiceStatusEx *r)

6344

{

6345

ndr_print_struct(ndr, name, "svcctl_QueryServiceStatusEx");

6346

ndr->depth++;

6347

if (flags & NDR_SET_VALUES) {

6348

ndr->flags |= LIBNDR_PRINT_SET_VALUES;

6349

}

6350

if (flags & NDR_IN) {

6351

ndr_print_struct(ndr, "in", "svcctl_QueryServiceStatusEx");

6352

ndr->depth++;

6353

ndr_print_ptr(ndr, "handle", r->in.handle);

6354

ndr->depth++;

6355

ndr_print_policy_handle(ndr, "handle", r->in.handle);

6356

ndr->depth--;

6357

ndr_print_svcctl_StatusLevel(ndr, "info_level", r->in.info_level);

6358

ndr_print_uint32(ndr, "offered", r->in.offered);

6359

ndr->depth--;

6360

}

6361

if (flags & NDR_OUT) {

6362

ndr_print_struct(ndr, "out", "svcctl_QueryServiceStatusEx");

6363

ndr->depth++;

6364

ndr_print_ptr(ndr, "buffer", r->out.buffer);

6365

ndr->depth++;

6366

ndr_print_array_uint8(ndr, "buffer", r->out.buffer, r->in.offered);

6367

ndr->depth--;

6368

ndr_print_ptr(ndr, "needed", r->out.needed);

6369

ndr->depth++;

6370

ndr_print_uint32(ndr, "needed", *r->out.needed);

6371

ndr->depth--;

6372

ndr_print_WERROR(ndr, "result", r->out.result);

6373

ndr->depth--;

6374

}

6375

ndr->depth--;

6376

}

6377

6378

static enum ndr_err_code ndr_push_EnumServicesStatusExA(struct ndr_push *ndr, int flags, const struct EnumServicesStatusExA *r)

6379

{

6380

if (flags & NDR_IN) {

6381

if (r->in.scmanager == NULL) {

6382

return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");

6383

}

6384

NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.scmanager));

6385

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.info_level));

6386

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.type));

6387

NDR_CHECK(ndr_push_svcctl_ServiceState(ndr, NDR_SCALARS, r->in.state));

6388

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));

6389

NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.resume_handle));

6390

if (r->in.resume_handle) {

6391

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->in.resume_handle));

6392

}

6393

}

6394

if (flags & NDR_OUT) {

6395

NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->out.services, r->in.offered));

6396

if (r->out.needed == NULL) {

6397

return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");

6398

}

6399

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));

6400

if (r->out.service_returned == NULL) {

6401

return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");

6402

}

6403

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.service_returned));

6404

NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.resume_handle));

6405

if (r->out.resume_handle) {

6406

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.resume_handle));

6407

}

6408

if (r->out.group_name == NULL) {

6409

return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");

6410

}

6411

NDR_CHECK(ndr_push_unique_ptr(ndr, *r->out.group_name));

6412

if (*r->out.group_name) {

6413

NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(*r->out.group_name, CH_UTF16)));

6414

NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));

6415

NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(*r->out.group_name, CH_UTF16)));

6416

NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, *r->out.group_name, ndr_charset_length(*r->out.group_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));

6417

}

6418

NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));

6419

}

6420

return NDR_ERR_SUCCESS;

6421

}

6422

6423

static enum ndr_err_code ndr_pull_EnumServicesStatusExA(struct ndr_pull *ndr, int flags, struct EnumServicesStatusExA *r)

6424

{

6425

uint32_t _ptr_resume_handle;

6426

uint32_t _ptr_group_name;

6427

TALLOC_CTX *_mem_save_scmanager_0;

6428

TALLOC_CTX *_mem_save_needed_0;

6429

TALLOC_CTX *_mem_save_service_returned_0;

6430

TALLOC_CTX *_mem_save_resume_handle_0;

6431

TALLOC_CTX *_mem_save_group_name_0;

6432

TALLOC_CTX *_mem_save_group_name_1;

6433

if (flags & NDR_IN) {

6434

ZERO_STRUCT(r->out);

6435

6436

if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {

6437

NDR_PULL_ALLOC(ndr, r->in.scmanager);

6438

}

6439

_mem_save_scmanager_0 = NDR_PULL_GET_MEM_CTX(ndr);

6440

NDR_PULL_SET_MEM_CTX(ndr, r->in.scmanager, LIBNDR_FLAG_REF_ALLOC);

6441

NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.scmanager));

6442

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_scmanager_0, LIBNDR_FLAG_REF_ALLOC);

6443

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.info_level));

6444

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.type));

6445

NDR_CHECK(ndr_pull_svcctl_ServiceState(ndr, NDR_SCALARS, &r->in.state));

6446

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));

6447

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_resume_handle));

6448

if (_ptr_resume_handle) {

6449

NDR_PULL_ALLOC(ndr, r->in.resume_handle);

6450

} else {

6451

r->in.resume_handle = NULL;

6452

}

6453

if (r->in.resume_handle) {

6454

_mem_save_resume_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);

6455

NDR_PULL_SET_MEM_CTX(ndr, r->in.resume_handle, 0);

6456

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->in.resume_handle));

6457

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_resume_handle_0, 0);

6458

}

6459

NDR_PULL_ALLOC(ndr, r->out.needed);

6460

ZERO_STRUCTP(r->out.needed);

6461

NDR_PULL_ALLOC(ndr, r->out.service_returned);

6462

ZERO_STRUCTP(r->out.service_returned);

6463

NDR_PULL_ALLOC(ndr, r->out.group_name);

6464

ZERO_STRUCTP(r->out.group_name);

6465

}

6466

if (flags & NDR_OUT) {

6467

NDR_PULL_ALLOC_N(ndr, r->out.services, r->in.offered);

6468

NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->out.services, r->in.offered));

6469

if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {

6470

NDR_PULL_ALLOC(ndr, r->out.needed);

6471

}

6472

_mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);

6473

NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);

6474

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));

6475

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);

6476

if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {

6477

NDR_PULL_ALLOC(ndr, r->out.service_returned);

6478

}

6479

_mem_save_service_returned_0 = NDR_PULL_GET_MEM_CTX(ndr);

6480

NDR_PULL_SET_MEM_CTX(ndr, r->out.service_returned, LIBNDR_FLAG_REF_ALLOC);

6481

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.service_returned));

6482

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_service_returned_0, LIBNDR_FLAG_REF_ALLOC);

6483

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_resume_handle));

6484

if (_ptr_resume_handle) {

6485

NDR_PULL_ALLOC(ndr, r->out.resume_handle);

6486

} else {

6487

r->out.resume_handle = NULL;

6488

}

6489

if (r->out.resume_handle) {

6490

_mem_save_resume_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);

6491

NDR_PULL_SET_MEM_CTX(ndr, r->out.resume_handle, 0);

6492

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.resume_handle));

6493

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_resume_handle_0, 0);

6494

}

6495

if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {

6496

NDR_PULL_ALLOC(ndr, r->out.group_name);

6497

}

6498

_mem_save_group_name_0 = NDR_PULL_GET_MEM_CTX(ndr);

6499

NDR_PULL_SET_MEM_CTX(ndr, r->out.group_name, LIBNDR_FLAG_REF_ALLOC);

6500

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_group_name));

6501

if (_ptr_group_name) {

6502

NDR_PULL_ALLOC(ndr, *r->out.group_name);

6503

} else {

6504

*r->out.group_name = NULL;

6505

}

6506

if (*r->out.group_name) {

6507

_mem_save_group_name_1 = NDR_PULL_GET_MEM_CTX(ndr);

6508

NDR_PULL_SET_MEM_CTX(ndr, *r->out.group_name, 0);

6509

NDR_CHECK(ndr_pull_array_size(ndr, r->out.group_name));

6510

NDR_CHECK(ndr_pull_array_length(ndr, r->out.group_name));

6511

if (ndr_get_array_length(ndr, r->out.group_name) > ndr_get_array_size(ndr, r->out.group_name)) {

6512

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.group_name), ndr_get_array_length(ndr, r->out.group_name));

6513

}

6514

NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, r->out.group_name), sizeof(uint16_t)));

6515

NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, r->out.group_name, ndr_get_array_length(ndr, r->out.group_name), sizeof(uint16_t), CH_UTF16));

6516

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_group_name_1, 0);

6517

}

6518

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_group_name_0, LIBNDR_FLAG_REF_ALLOC);

6519

NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));

6520

}

6521

return NDR_ERR_SUCCESS;

6522

}

6523

6524

_PUBLIC_ void ndr_print_EnumServicesStatusExA(struct ndr_print *ndr, const char *name, int flags, const struct EnumServicesStatusExA *r)

6525

{

6526

ndr_print_struct(ndr, name, "EnumServicesStatusExA");

6527

ndr->depth++;

6528

if (flags & NDR_SET_VALUES) {

6529

ndr->flags |= LIBNDR_PRINT_SET_VALUES;

6530

}

6531

if (flags & NDR_IN) {

6532

ndr_print_struct(ndr, "in", "EnumServicesStatusExA");

6533

ndr->depth++;

6534

ndr_print_ptr(ndr, "scmanager", r->in.scmanager);

6535

ndr->depth++;

6536

ndr_print_policy_handle(ndr, "scmanager", r->in.scmanager);

6537

ndr->depth--;

6538

ndr_print_uint32(ndr, "info_level", r->in.info_level);

6539

ndr_print_uint32(ndr, "type", r->in.type);

6540

ndr_print_svcctl_ServiceState(ndr, "state", r->in.state);

6541

ndr_print_uint32(ndr, "offered", r->in.offered);

6542

ndr_print_ptr(ndr, "resume_handle", r->in.resume_handle);

6543

ndr->depth++;

6544

if (r->in.resume_handle) {

6545

ndr_print_uint32(ndr, "resume_handle", *r->in.resume_handle);

6546

}

6547

ndr->depth--;

6548

ndr->depth--;

6549

}

6550

if (flags & NDR_OUT) {

6551

ndr_print_struct(ndr, "out", "EnumServicesStatusExA");

6552

ndr->depth++;

6553

ndr_print_array_uint8(ndr, "services", r->out.services, r->in.offered);

6554

ndr_print_ptr(ndr, "needed", r->out.needed);

6555

ndr->depth++;

6556

ndr_print_uint32(ndr, "needed", *r->out.needed);

6557

ndr->depth--;

6558

ndr_print_ptr(ndr, "service_returned", r->out.service_returned);

6559

ndr->depth++;

6560

ndr_print_uint32(ndr, "service_returned", *r->out.service_returned);

6561

ndr->depth--;

6562

ndr_print_ptr(ndr, "resume_handle", r->out.resume_handle);

6563

ndr->depth++;

6564

if (r->out.resume_handle) {

6565

ndr_print_uint32(ndr, "resume_handle", *r->out.resume_handle);

6566

}

6567

ndr->depth--;

6568

ndr_print_ptr(ndr, "group_name", r->out.group_name);

6569

ndr->depth++;

6570

ndr_print_ptr(ndr, "group_name", *r->out.group_name);

6571

ndr->depth++;

6572

if (*r->out.group_name) {

6573

ndr_print_string(ndr, "group_name", *r->out.group_name);

6574

}

6575

ndr->depth--;

6576

ndr->depth--;

6577

ndr_print_WERROR(ndr, "result", r->out.result);

6578

ndr->depth--;

6579

}

6580

ndr->depth--;

6581

}

6582

6583

static enum ndr_err_code ndr_push_EnumServicesStatusExW(struct ndr_push *ndr, int flags, const struct EnumServicesStatusExW *r)

6584

{

6585

if (flags & NDR_IN) {

6586

if (r->in.scmanager == NULL) {

6587

return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");

6588

}

6589

NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.scmanager));

6590

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.info_level));

6591

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.type));

6592

NDR_CHECK(ndr_push_svcctl_ServiceState(ndr, NDR_SCALARS, r->in.state));

6593

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));

6594

NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.resume_handle));

6595

if (r->in.resume_handle) {

6596

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->in.resume_handle));

6597

}

6598

NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.group_name));

6599

if (r->in.group_name) {

6600

NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.group_name, CH_UTF16)));

6601

NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));

6602

NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.group_name, CH_UTF16)));

6603

NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.group_name, ndr_charset_length(r->in.group_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));

6604

}

6605

}

6606

if (flags & NDR_OUT) {

6607

if (r->out.services == NULL) {

6608

return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");

6609

}

6610

NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->in.offered));

6611

NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->out.services, r->in.offered));

6612

if (r->out.needed == NULL) {

6613

return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");

6614

}

6615

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));

6616

if (r->out.service_returned == NULL) {

6617

return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");

6618

}

6619

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.service_returned));

6620

NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.resume_handle));

6621

if (r->out.resume_handle) {

6622

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.resume_handle));

6623

}

6624

NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));

6625

}

6626

return NDR_ERR_SUCCESS;

6627

}

6628

6629

static enum ndr_err_code ndr_pull_EnumServicesStatusExW(struct ndr_pull *ndr, int flags, struct EnumServicesStatusExW *r)

6630

{

6631

uint32_t _ptr_resume_handle;

6632

uint32_t _ptr_group_name;

6633

TALLOC_CTX *_mem_save_scmanager_0;

6634

TALLOC_CTX *_mem_save_needed_0;

6635

TALLOC_CTX *_mem_save_service_returned_0;

6636

TALLOC_CTX *_mem_save_resume_handle_0;

6637

TALLOC_CTX *_mem_save_group_name_0;

6638

if (flags & NDR_IN) {

6639

ZERO_STRUCT(r->out);

6640

6641

if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {

6642

NDR_PULL_ALLOC(ndr, r->in.scmanager);

6643

}

6644

_mem_save_scmanager_0 = NDR_PULL_GET_MEM_CTX(ndr);

6645

NDR_PULL_SET_MEM_CTX(ndr, r->in.scmanager, LIBNDR_FLAG_REF_ALLOC);

6646

NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.scmanager));

6647

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_scmanager_0, LIBNDR_FLAG_REF_ALLOC);

6648

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.info_level));

6649

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.type));

6650

NDR_CHECK(ndr_pull_svcctl_ServiceState(ndr, NDR_SCALARS, &r->in.state));

6651

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));

6652

if (r->in.offered > 0x40000) {

6653

return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");

6654

}

6655

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_resume_handle));

6656

if (_ptr_resume_handle) {

6657

NDR_PULL_ALLOC(ndr, r->in.resume_handle);

6658

} else {

6659

r->in.resume_handle = NULL;

6660

}

6661

if (r->in.resume_handle) {

6662

_mem_save_resume_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);

6663

NDR_PULL_SET_MEM_CTX(ndr, r->in.resume_handle, 0);

6664

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->in.resume_handle));

6665

if (*r->in.resume_handle > 0x40000) {

6666

return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");

6667

}

6668

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_resume_handle_0, 0);

6669

}

6670

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_group_name));

6671

if (_ptr_group_name) {

6672

NDR_PULL_ALLOC(ndr, r->in.group_name);

6673

} else {

6674

r->in.group_name = NULL;

6675

}

6676

if (r->in.group_name) {

6677

_mem_save_group_name_0 = NDR_PULL_GET_MEM_CTX(ndr);

6678

NDR_PULL_SET_MEM_CTX(ndr, r->in.group_name, 0);

6679

NDR_CHECK(ndr_pull_array_size(ndr, &r->in.group_name));

6680

NDR_CHECK(ndr_pull_array_length(ndr, &r->in.group_name));

6681

if (ndr_get_array_length(ndr, &r->in.group_name) > ndr_get_array_size(ndr, &r->in.group_name)) {

6682

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.group_name), ndr_get_array_length(ndr, &r->in.group_name));

6683

}

6684

NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.group_name), sizeof(uint16_t)));

6685

NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.group_name, ndr_get_array_length(ndr, &r->in.group_name), sizeof(uint16_t), CH_UTF16));

6686

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_group_name_0, 0);

6687

}

6688

NDR_PULL_ALLOC_N(ndr, r->out.services, r->in.offered);

6689

memset(r->out.services, 0, (r->in.offered) * sizeof(*r->out.services));

6690

NDR_PULL_ALLOC(ndr, r->out.needed);

6691

ZERO_STRUCTP(r->out.needed);

6692

NDR_PULL_ALLOC(ndr, r->out.service_returned);

6693

ZERO_STRUCTP(r->out.service_returned);

6694

}

6695

if (flags & NDR_OUT) {

6696

NDR_CHECK(ndr_pull_array_size(ndr, &r->out.services));

6697

if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {

6698

NDR_PULL_ALLOC_N(ndr, r->out.services, ndr_get_array_size(ndr, &r->out.services));

6699

}

6700

NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->out.services, ndr_get_array_size(ndr, &r->out.services)));

6701

if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {

6702

NDR_PULL_ALLOC(ndr, r->out.needed);

6703

}

6704

_mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);

6705

NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);

6706

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));

6707

if (*r->out.needed > 0x40000) {

6708

return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");

6709

}

6710

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);

6711

if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {

6712

NDR_PULL_ALLOC(ndr, r->out.service_returned);

6713

}

6714

_mem_save_service_returned_0 = NDR_PULL_GET_MEM_CTX(ndr);

6715

NDR_PULL_SET_MEM_CTX(ndr, r->out.service_returned, LIBNDR_FLAG_REF_ALLOC);

6716

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.service_returned));

6717

if (*r->out.service_returned > 0x40000) {

6718

return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");

6719

}

6720

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_service_returned_0, LIBNDR_FLAG_REF_ALLOC);

6721

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_resume_handle));

6722

if (_ptr_resume_handle) {

6723

NDR_PULL_ALLOC(ndr, r->out.resume_handle);

6724

} else {

6725

r->out.resume_handle = NULL;

6726

}

6727

if (r->out.resume_handle) {

6728

_mem_save_resume_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);

6729

NDR_PULL_SET_MEM_CTX(ndr, r->out.resume_handle, 0);

6730

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.resume_handle));

6731

if (*r->out.resume_handle > 0x40000) {

6732

return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");

6733

}

6734

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_resume_handle_0, 0);

6735

}

6736

NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));

6737

if (r->out.services) {

6738

NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->out.services, r->in.offered));

6739

}

6740

}

6741

return NDR_ERR_SUCCESS;

6742

}

6743

6744

_PUBLIC_ void ndr_print_EnumServicesStatusExW(struct ndr_print *ndr, const char *name, int flags, const struct EnumServicesStatusExW *r)

6745

{

6746

ndr_print_struct(ndr, name, "EnumServicesStatusExW");

6747

ndr->depth++;

6748

if (flags & NDR_SET_VALUES) {

6749

ndr->flags |= LIBNDR_PRINT_SET_VALUES;

6750

}

6751

if (flags & NDR_IN) {

6752

ndr_print_struct(ndr, "in", "EnumServicesStatusExW");

6753

ndr->depth++;

6754

ndr_print_ptr(ndr, "scmanager", r->in.scmanager);

6755

ndr->depth++;

6756

ndr_print_policy_handle(ndr, "scmanager", r->in.scmanager);

6757

ndr->depth--;

6758

ndr_print_uint32(ndr, "info_level", r->in.info_level);

6759

ndr_print_uint32(ndr, "type", r->in.type);

6760

ndr_print_svcctl_ServiceState(ndr, "state", r->in.state);

6761

ndr_print_uint32(ndr, "offered", r->in.offered);

6762

ndr_print_ptr(ndr, "resume_handle", r->in.resume_handle);

6763

ndr->depth++;

6764

if (r->in.resume_handle) {

6765

ndr_print_uint32(ndr, "resume_handle", *r->in.resume_handle);

6766

}

6767

ndr->depth--;

6768

ndr_print_ptr(ndr, "group_name", r->in.group_name);

6769

ndr->depth++;

6770

if (r->in.group_name) {

6771

ndr_print_string(ndr, "group_name", r->in.group_name);

6772

}

6773

ndr->depth--;

6774

ndr->depth--;

6775

}

6776

if (flags & NDR_OUT) {

6777

ndr_print_struct(ndr, "out", "EnumServicesStatusExW");

6778

ndr->depth++;

6779

ndr_print_ptr(ndr, "services", r->out.services);

6780

ndr->depth++;

6781

ndr_print_array_uint8(ndr, "services", r->out.services, r->in.offered);

6782

ndr->depth--;

6783

ndr_print_ptr(ndr, "needed", r->out.needed);

6784

ndr->depth++;

6785

ndr_print_uint32(ndr, "needed", *r->out.needed);

6786

ndr->depth--;

6787

ndr_print_ptr(ndr, "service_returned", r->out.service_returned);

6788

ndr->depth++;

6789

ndr_print_uint32(ndr, "service_returned", *r->out.service_returned);

6790

ndr->depth--;

6791

ndr_print_ptr(ndr, "resume_handle", r->out.resume_handle);

6792

ndr->depth++;

6793

if (r->out.resume_handle) {

6794

ndr_print_uint32(ndr, "resume_handle", *r->out.resume_handle);

6795

}

6796

ndr->depth--;

6797

ndr_print_WERROR(ndr, "result", r->out.result);

6798

ndr->depth--;

6799

}

6800

ndr->depth--;

6801

}

6802

6803

static enum ndr_err_code ndr_push_svcctl_SCSendTSMessage(struct ndr_push *ndr, int flags, const struct svcctl_SCSendTSMessage *r)

6804

{

6805

if (flags & NDR_IN) {

6806

}

6807

if (flags & NDR_OUT) {

6808

NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));

6809

}

6810

return NDR_ERR_SUCCESS;

6811

}

6812

6813

static enum ndr_err_code ndr_pull_svcctl_SCSendTSMessage(struct ndr_pull *ndr, int flags, struct svcctl_SCSendTSMessage *r)

6814

{

6815

if (flags & NDR_IN) {

6816

}

6817

if (flags & NDR_OUT) {

6818

NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));

6819

}

6820

return NDR_ERR_SUCCESS;

6821

}

6822

6823

_PUBLIC_ void ndr_print_svcctl_SCSendTSMessage(struct ndr_print *ndr, const char *name, int flags, const struct svcctl_SCSendTSMessage *r)

6824

{

6825

ndr_print_struct(ndr, name, "svcctl_SCSendTSMessage");

6826

ndr->depth++;

6827

if (flags & NDR_SET_VALUES) {

6828

ndr->flags |= LIBNDR_PRINT_SET_VALUES;

6829

}

6830

if (flags & NDR_IN) {

6831

ndr_print_struct(ndr, "in", "svcctl_SCSendTSMessage");

6832

ndr->depth++;

6833

ndr->depth--;

6834

}

6835

if (flags & NDR_OUT) {

6836

ndr_print_struct(ndr, "out", "svcctl_SCSendTSMessage");

6837

ndr->depth++;

6838

ndr_print_WERROR(ndr, "result", r->out.result);

6839

ndr->depth--;

6840

}

6841

ndr->depth--;

6842

}

6843

6844

static const struct ndr_interface_call svcctl_calls[] = {

6845

{

6846

"svcctl_CloseServiceHandle",

6847

sizeof(struct svcctl_CloseServiceHandle),

6848

(ndr_push_flags_fn_t) ndr_push_svcctl_CloseServiceHandle,

6849

(ndr_pull_flags_fn_t) ndr_pull_svcctl_CloseServiceHandle,

6850

(ndr_print_function_t) ndr_print_svcctl_CloseServiceHandle,

6851

false,

6852

},

6853

{

6854

"svcctl_ControlService",

6855

sizeof(struct svcctl_ControlService),

6856

(ndr_push_flags_fn_t) ndr_push_svcctl_ControlService,

6857

(ndr_pull_flags_fn_t) ndr_pull_svcctl_ControlService,

6858

(ndr_print_function_t) ndr_print_svcctl_ControlService,

6859

false,

6860

},

6861

{

6862

"svcctl_DeleteService",

6863

sizeof(struct svcctl_DeleteService),

6864

(ndr_push_flags_fn_t) ndr_push_svcctl_DeleteService,

6865

(ndr_pull_flags_fn_t) ndr_pull_svcctl_DeleteService,

6866

(ndr_print_function_t) ndr_print_svcctl_DeleteService,

6867

false,

6868

},

6869

{

6870

"svcctl_LockServiceDatabase",

6871

sizeof(struct svcctl_LockServiceDatabase),

6872

(ndr_push_flags_fn_t) ndr_push_svcctl_LockServiceDatabase,

6873

(ndr_pull_flags_fn_t) ndr_pull_svcctl_LockServiceDatabase,

6874

(ndr_print_function_t) ndr_print_svcctl_LockServiceDatabase,

6875

false,

6876

},

6877

{

6878

"svcctl_QueryServiceObjectSecurity",

6879

sizeof(struct svcctl_QueryServiceObjectSecurity),

6880

(ndr_push_flags_fn_t) ndr_push_svcctl_QueryServiceObjectSecurity,

6881

(ndr_pull_flags_fn_t) ndr_pull_svcctl_QueryServiceObjectSecurity,

6882

(ndr_print_function_t) ndr_print_svcctl_QueryServiceObjectSecurity,

6883

false,

6884

},

6885

{

6886

"svcctl_SetServiceObjectSecurity",

6887

sizeof(struct svcctl_SetServiceObjectSecurity),

6888

(ndr_push_flags_fn_t) ndr_push_svcctl_SetServiceObjectSecurity,

6889

(ndr_pull_flags_fn_t) ndr_pull_svcctl_SetServiceObjectSecurity,

6890

(ndr_print_function_t) ndr_print_svcctl_SetServiceObjectSecurity,

6891

false,

6892

},

6893

{

6894

"svcctl_QueryServiceStatus",

6895

sizeof(struct svcctl_QueryServiceStatus),

6896

(ndr_push_flags_fn_t) ndr_push_svcctl_QueryServiceStatus,

6897

(ndr_pull_flags_fn_t) ndr_pull_svcctl_QueryServiceStatus,

6898

(ndr_print_function_t) ndr_print_svcctl_QueryServiceStatus,

6899

false,

6900

},

6901

{

6902

"svcctl_SetServiceStatus",

6903

sizeof(struct svcctl_SetServiceStatus),

6904

(ndr_push_flags_fn_t) ndr_push_svcctl_SetServiceStatus,

6905

(ndr_pull_flags_fn_t) ndr_pull_svcctl_SetServiceStatus,

6906

(ndr_print_function_t) ndr_print_svcctl_SetServiceStatus,

6907

false,

6908

},

6909

{

6910

"svcctl_UnlockServiceDatabase",

6911

sizeof(struct svcctl_UnlockServiceDatabase),

6912

(ndr_push_flags_fn_t) ndr_push_svcctl_UnlockServiceDatabase,

6913

(ndr_pull_flags_fn_t) ndr_pull_svcctl_UnlockServiceDatabase,

6914

(ndr_print_function_t) ndr_print_svcctl_UnlockServiceDatabase,

6915

false,

6916

},

6917

{

6918

"svcctl_NotifyBootConfigStatus",

6919

sizeof(struct svcctl_NotifyBootConfigStatus),

6920

(ndr_push_flags_fn_t) ndr_push_svcctl_NotifyBootConfigStatus,

6921

(ndr_pull_flags_fn_t) ndr_pull_svcctl_NotifyBootConfigStatus,

6922

(ndr_print_function_t) ndr_print_svcctl_NotifyBootConfigStatus,

6923

false,

6924

},

6925

{

6926

"svcctl_SCSetServiceBitsW",

6927

sizeof(struct svcctl_SCSetServiceBitsW),

6928

(ndr_push_flags_fn_t) ndr_push_svcctl_SCSetServiceBitsW,

6929

(ndr_pull_flags_fn_t) ndr_pull_svcctl_SCSetServiceBitsW,

6930

(ndr_print_function_t) ndr_print_svcctl_SCSetServiceBitsW,

6931

false,

6932

},

6933

{

6934

"svcctl_ChangeServiceConfigW",

6935

sizeof(struct svcctl_ChangeServiceConfigW),

6936

(ndr_push_flags_fn_t) ndr_push_svcctl_ChangeServiceConfigW,

6937

(ndr_pull_flags_fn_t) ndr_pull_svcctl_ChangeServiceConfigW,

6938

(ndr_print_function_t) ndr_print_svcctl_ChangeServiceConfigW,

6939

false,

6940

},

6941

{

6942

"svcctl_CreateServiceW",

6943

sizeof(struct svcctl_CreateServiceW),

6944

(ndr_push_flags_fn_t) ndr_push_svcctl_CreateServiceW,

6945

(ndr_pull_flags_fn_t) ndr_pull_svcctl_CreateServiceW,

6946

(ndr_print_function_t) ndr_print_svcctl_CreateServiceW,

6947

false,

6948

},

6949

{

6950

"svcctl_EnumDependentServicesW",

6951

sizeof(struct svcctl_EnumDependentServicesW),

6952

(ndr_push_flags_fn_t) ndr_push_svcctl_EnumDependentServicesW,

6953

(ndr_pull_flags_fn_t) ndr_pull_svcctl_EnumDependentServicesW,

6954

(ndr_print_function_t) ndr_print_svcctl_EnumDependentServicesW,

6955

false,

6956

},

6957

{

6958

"svcctl_EnumServicesStatusW",

6959

sizeof(struct svcctl_EnumServicesStatusW),

6960

(ndr_push_flags_fn_t) ndr_push_svcctl_EnumServicesStatusW,

6961

(ndr_pull_flags_fn_t) ndr_pull_svcctl_EnumServicesStatusW,

6962

(ndr_print_function_t) ndr_print_svcctl_EnumServicesStatusW,

6963

false,

6964

},

6965

{

6966

"svcctl_OpenSCManagerW",

6967

sizeof(struct svcctl_OpenSCManagerW),

6968

(ndr_push_flags_fn_t) ndr_push_svcctl_OpenSCManagerW,

6969

(ndr_pull_flags_fn_t) ndr_pull_svcctl_OpenSCManagerW,

6970

(ndr_print_function_t) ndr_print_svcctl_OpenSCManagerW,

6971

false,

6972

},

6973

{

6974

"svcctl_OpenServiceW",

6975

sizeof(struct svcctl_OpenServiceW),

6976

(ndr_push_flags_fn_t) ndr_push_svcctl_OpenServiceW,

6977

(ndr_pull_flags_fn_t) ndr_pull_svcctl_OpenServiceW,

6978

(ndr_print_function_t) ndr_print_svcctl_OpenServiceW,

6979

false,

6980

},

6981

{

6982

"svcctl_QueryServiceConfigW",

6983

sizeof(struct svcctl_QueryServiceConfigW),

6984

(ndr_push_flags_fn_t) ndr_push_svcctl_QueryServiceConfigW,

6985

(ndr_pull_flags_fn_t) ndr_pull_svcctl_QueryServiceConfigW,

6986

(ndr_print_function_t) ndr_print_svcctl_QueryServiceConfigW,

6987

false,

6988

},

6989

{

6990

"svcctl_QueryServiceLockStatusW",

6991

sizeof(struct svcctl_QueryServiceLockStatusW),

6992

(ndr_push_flags_fn_t) ndr_push_svcctl_QueryServiceLockStatusW,

6993

(ndr_pull_flags_fn_t) ndr_pull_svcctl_QueryServiceLockStatusW,

6994

(ndr_print_function_t) ndr_print_svcctl_QueryServiceLockStatusW,

6995

false,

6996

},

6997

{

6998

"svcctl_StartServiceW",

6999

sizeof(struct svcctl_StartServiceW),

7000

(ndr_push_flags_fn_t) ndr_push_svcctl_StartServiceW,

7001

(ndr_pull_flags_fn_t) ndr_pull_svcctl_StartServiceW,

7002

(ndr_print_function_t) ndr_print_svcctl_StartServiceW,

7003

false,

7004

},

7005

{

7006

"svcctl_GetServiceDisplayNameW",

7007

sizeof(struct svcctl_GetServiceDisplayNameW),

7008

(ndr_push_flags_fn_t) ndr_push_svcctl_GetServiceDisplayNameW,

7009

(ndr_pull_flags_fn_t) ndr_pull_svcctl_GetServiceDisplayNameW,

7010

(ndr_print_function_t) ndr_print_svcctl_GetServiceDisplayNameW,

7011

false,

7012

},

7013

{

7014

"svcctl_GetServiceKeyNameW",

7015

sizeof(struct svcctl_GetServiceKeyNameW),

7016

(ndr_push_flags_fn_t) ndr_push_svcctl_GetServiceKeyNameW,

7017

(ndr_pull_flags_fn_t) ndr_pull_svcctl_GetServiceKeyNameW,

7018

(ndr_print_function_t) ndr_print_svcctl_GetServiceKeyNameW,

7019

false,

7020

},

7021

{

7022

"svcctl_SCSetServiceBitsA",

7023

sizeof(struct svcctl_SCSetServiceBitsA),

7024

(ndr_push_flags_fn_t) ndr_push_svcctl_SCSetServiceBitsA,

7025

(ndr_pull_flags_fn_t) ndr_pull_svcctl_SCSetServiceBitsA,

7026

(ndr_print_function_t) ndr_print_svcctl_SCSetServiceBitsA,

7027

false,

7028

},

7029

{

7030

"svcctl_ChangeServiceConfigA",

7031

sizeof(struct svcctl_ChangeServiceConfigA),

7032

(ndr_push_flags_fn_t) ndr_push_svcctl_ChangeServiceConfigA,

7033

(ndr_pull_flags_fn_t) ndr_pull_svcctl_ChangeServiceConfigA,

7034

(ndr_print_function_t) ndr_print_svcctl_ChangeServiceConfigA,

7035

false,

7036

},

7037

{

7038

"svcctl_CreateServiceA",

7039

sizeof(struct svcctl_CreateServiceA),

7040

(ndr_push_flags_fn_t) ndr_push_svcctl_CreateServiceA,

7041

(ndr_pull_flags_fn_t) ndr_pull_svcctl_CreateServiceA,

7042

(ndr_print_function_t) ndr_print_svcctl_CreateServiceA,

7043

false,

7044

},

7045

{

7046

"svcctl_EnumDependentServicesA",

7047

sizeof(struct svcctl_EnumDependentServicesA),

7048

(ndr_push_flags_fn_t) ndr_push_svcctl_EnumDependentServicesA,

7049

(ndr_pull_flags_fn_t) ndr_pull_svcctl_EnumDependentServicesA,

7050

(ndr_print_function_t) ndr_print_svcctl_EnumDependentServicesA,

7051

false,

7052

},

7053

{

7054

"svcctl_EnumServicesStatusA",

7055

sizeof(struct svcctl_EnumServicesStatusA),

7056

(ndr_push_flags_fn_t) ndr_push_svcctl_EnumServicesStatusA,

7057

(ndr_pull_flags_fn_t) ndr_pull_svcctl_EnumServicesStatusA,

7058

(ndr_print_function_t) ndr_print_svcctl_EnumServicesStatusA,

7059

false,

7060

},

7061

{

7062

"svcctl_OpenSCManagerA",

7063

sizeof(struct svcctl_OpenSCManagerA),

7064

(ndr_push_flags_fn_t) ndr_push_svcctl_OpenSCManagerA,

7065

(ndr_pull_flags_fn_t) ndr_pull_svcctl_OpenSCManagerA,

7066

(ndr_print_function_t) ndr_print_svcctl_OpenSCManagerA,

7067

false,

7068

},

7069

{

7070

"svcctl_OpenServiceA",

7071

sizeof(struct svcctl_OpenServiceA),

7072

(ndr_push_flags_fn_t) ndr_push_svcctl_OpenServiceA,

7073

(ndr_pull_flags_fn_t) ndr_pull_svcctl_OpenServiceA,

7074

(ndr_print_function_t) ndr_print_svcctl_OpenServiceA,

7075

false,

7076

},

7077

{

7078

"svcctl_QueryServiceConfigA",

7079

sizeof(struct svcctl_QueryServiceConfigA),

7080

(ndr_push_flags_fn_t) ndr_push_svcctl_QueryServiceConfigA,

7081

(ndr_pull_flags_fn_t) ndr_pull_svcctl_QueryServiceConfigA,

7082

(ndr_print_function_t) ndr_print_svcctl_QueryServiceConfigA,

7083

false,

7084

},

7085

{

7086

"svcctl_QueryServiceLockStatusA",

7087

sizeof(struct svcctl_QueryServiceLockStatusA),

7088

(ndr_push_flags_fn_t) ndr_push_svcctl_QueryServiceLockStatusA,

7089

(ndr_pull_flags_fn_t) ndr_pull_svcctl_QueryServiceLockStatusA,

7090

(ndr_print_function_t) ndr_print_svcctl_QueryServiceLockStatusA,

7091

false,

7092

},

7093

{

7094

"svcctl_StartServiceA",

7095

sizeof(struct svcctl_StartServiceA),

7096

(ndr_push_flags_fn_t) ndr_push_svcctl_StartServiceA,

7097

(ndr_pull_flags_fn_t) ndr_pull_svcctl_StartServiceA,

7098

(ndr_print_function_t) ndr_print_svcctl_StartServiceA,

7099

false,

7100

},

7101

{

7102

"svcctl_GetServiceDisplayNameA",

7103

sizeof(struct svcctl_GetServiceDisplayNameA),

7104

(ndr_push_flags_fn_t) ndr_push_svcctl_GetServiceDisplayNameA,

7105

(ndr_pull_flags_fn_t) ndr_pull_svcctl_GetServiceDisplayNameA,

7106

(ndr_print_function_t) ndr_print_svcctl_GetServiceDisplayNameA,

7107

false,

7108

},

7109

{

7110

"svcctl_GetServiceKeyNameA",

7111

sizeof(struct svcctl_GetServiceKeyNameA),

7112

(ndr_push_flags_fn_t) ndr_push_svcctl_GetServiceKeyNameA,

7113

(ndr_pull_flags_fn_t) ndr_pull_svcctl_GetServiceKeyNameA,

7114

(ndr_print_function_t) ndr_print_svcctl_GetServiceKeyNameA,

7115

false,

7116

},

7117

{

7118

"svcctl_GetCurrentGroupeStateW",

7119

sizeof(struct svcctl_GetCurrentGroupeStateW),

7120

(ndr_push_flags_fn_t) ndr_push_svcctl_GetCurrentGroupeStateW,

7121

(ndr_pull_flags_fn_t) ndr_pull_svcctl_GetCurrentGroupeStateW,

7122

(ndr_print_function_t) ndr_print_svcctl_GetCurrentGroupeStateW,

7123

false,

7124

},

7125

{

7126

"svcctl_EnumServiceGroupW",

7127

sizeof(struct svcctl_EnumServiceGroupW),

7128

(ndr_push_flags_fn_t) ndr_push_svcctl_EnumServiceGroupW,

7129

(ndr_pull_flags_fn_t) ndr_pull_svcctl_EnumServiceGroupW,

7130

(ndr_print_function_t) ndr_print_svcctl_EnumServiceGroupW,

7131

false,

7132

},

7133

{

7134

"svcctl_ChangeServiceConfig2A",

7135

sizeof(struct svcctl_ChangeServiceConfig2A),

7136

(ndr_push_flags_fn_t) ndr_push_svcctl_ChangeServiceConfig2A,

7137

(ndr_pull_flags_fn_t) ndr_pull_svcctl_ChangeServiceConfig2A,

7138

(ndr_print_function_t) ndr_print_svcctl_ChangeServiceConfig2A,

7139

false,

7140

},

7141

{

7142

"svcctl_ChangeServiceConfig2W",

7143

sizeof(struct svcctl_ChangeServiceConfig2W),

7144

(ndr_push_flags_fn_t) ndr_push_svcctl_ChangeServiceConfig2W,

7145

(ndr_pull_flags_fn_t) ndr_pull_svcctl_ChangeServiceConfig2W,

7146

(ndr_print_function_t) ndr_print_svcctl_ChangeServiceConfig2W,

7147

false,

7148

},

7149

{

7150

"svcctl_QueryServiceConfig2A",

7151

sizeof(struct svcctl_QueryServiceConfig2A),

7152

(ndr_push_flags_fn_t) ndr_push_svcctl_QueryServiceConfig2A,

7153

(ndr_pull_flags_fn_t) ndr_pull_svcctl_QueryServiceConfig2A,

7154

(ndr_print_function_t) ndr_print_svcctl_QueryServiceConfig2A,

7155

false,

7156

},

7157

{

7158

"svcctl_QueryServiceConfig2W",

7159

sizeof(struct svcctl_QueryServiceConfig2W),

7160

(ndr_push_flags_fn_t) ndr_push_svcctl_QueryServiceConfig2W,

7161

(ndr_pull_flags_fn_t) ndr_pull_svcctl_QueryServiceConfig2W,

7162

(ndr_print_function_t) ndr_print_svcctl_QueryServiceConfig2W,

7163

false,

7164

},

7165

{

7166

"svcctl_QueryServiceStatusEx",

7167

sizeof(struct svcctl_QueryServiceStatusEx),

7168

(ndr_push_flags_fn_t) ndr_push_svcctl_QueryServiceStatusEx,

7169

(ndr_pull_flags_fn_t) ndr_pull_svcctl_QueryServiceStatusEx,

7170

(ndr_print_function_t) ndr_print_svcctl_QueryServiceStatusEx,

7171

false,

7172

},

7173

{

7174

"EnumServicesStatusExA",

7175

sizeof(struct EnumServicesStatusExA),

7176

(ndr_push_flags_fn_t) ndr_push_EnumServicesStatusExA,

7177

(ndr_pull_flags_fn_t) ndr_pull_EnumServicesStatusExA,

7178

(ndr_print_function_t) ndr_print_EnumServicesStatusExA,

7179

false,

7180

},

7181

{

7182

"EnumServicesStatusExW",

7183

sizeof(struct EnumServicesStatusExW),

7184

(ndr_push_flags_fn_t) ndr_push_EnumServicesStatusExW,

7185

(ndr_pull_flags_fn_t) ndr_pull_EnumServicesStatusExW,

7186

(ndr_print_function_t) ndr_print_EnumServicesStatusExW,

7187

false,

7188

},

7189

{

7190

"svcctl_SCSendTSMessage",

7191

sizeof(struct svcctl_SCSendTSMessage),

7192

(ndr_push_flags_fn_t) ndr_push_svcctl_SCSendTSMessage,

7193

(ndr_pull_flags_fn_t) ndr_pull_svcctl_SCSendTSMessage,

7194

(ndr_print_function_t) ndr_print_svcctl_SCSendTSMessage,

7195

false,

7196

},

7197

{ NULL, 0, NULL, NULL, NULL, false }

7198

};

7199

7200

static const char * const svcctl_endpoint_strings[] = {

7201

"ncacn_np:[\\pipe\\svcctl]",

7202

"ncalrpc:",

7203

};

7204

7205

static const struct ndr_interface_string_array svcctl_endpoints = {

7206

.count = 2,

7207

.names = svcctl_endpoint_strings

7208

};

7209

7210

static const char * const svcctl_authservice_strings[] = {

7211

"host",

7212

};

7213

7214

static const struct ndr_interface_string_array svcctl_authservices = {

7215

.count = 1,

7216

.names = svcctl_authservice_strings

7217

};

7218

7219

7220

const struct ndr_interface_table ndr_table_svcctl = {

7221

.name = "svcctl",

7222

.syntax_id = {

7223

{0x367abb81,0x9844,0x35f1,{0xad,0x32},{0x98,0xf0,0x38,0x00,0x10,0x03}},

7224

NDR_SVCCTL_VERSION

7225

},

7226

.helpstring = NDR_SVCCTL_HELPSTRING,

7227

.num_calls = 44,

7228

.calls = svcctl_calls,

7229

.endpoints = &svcctl_endpoints,

7230

.authservices = &svcctl_authservices

7231

};

7232