~zulcss/samba/server-dailies-3.4

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

}

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

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

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_device_0, 0);

}

return NDR_ERR_SUCCESS;

}

_PUBLIC_ void ndr_print_srvsvc_NetCharDevInfo0(struct ndr_print *ndr, const char *name, const struct srvsvc_NetCharDevInfo0 *r)

{

ndr_print_struct(ndr, name, "srvsvc_NetCharDevInfo0");

ndr->depth++;

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

ndr->depth++;

if (r->device) {

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

}

ndr->depth--;

}

static enum ndr_err_code ndr_push_srvsvc_NetCharDevCtr0(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetCharDevCtr0 *r)

{

uint32_t cntr_array_1;

if (ndr_flags & NDR_SCALARS) {

NDR_CHECK(ndr_push_align(ndr, 4));

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

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

}

if (ndr_flags & NDR_BUFFERS) {

if (r->array) {

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

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

NDR_CHECK(ndr_push_srvsvc_NetCharDevInfo0(ndr, NDR_SCALARS, &r->array[cntr_array_1]));

}

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

NDR_CHECK(ndr_push_srvsvc_NetCharDevInfo0(ndr, NDR_BUFFERS, &r->array[cntr_array_1]));

}

return NDR_ERR_SUCCESS;

}

static enum ndr_err_code ndr_pull_srvsvc_NetCharDevCtr0(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetCharDevCtr0 *r)

{

uint32_t _ptr_array;

uint32_t cntr_array_1;

TALLOC_CTX *_mem_save_array_0;

TALLOC_CTX *_mem_save_array_1;

if (ndr_flags & NDR_SCALARS) {

NDR_CHECK(ndr_pull_align(ndr, 4));

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

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_array));

100

if (_ptr_array) {

101

NDR_PULL_ALLOC(ndr, r->array);

102

} else {

103

r->array = NULL;

104

}

105

}

106

if (ndr_flags & NDR_BUFFERS) {

107

if (r->array) {

108

_mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);

109

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

110

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

111

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

112

_mem_save_array_1 = NDR_PULL_GET_MEM_CTX(ndr);

113

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

114

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

115

NDR_CHECK(ndr_pull_srvsvc_NetCharDevInfo0(ndr, NDR_SCALARS, &r->array[cntr_array_1]));

116

}

117

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

118

NDR_CHECK(ndr_pull_srvsvc_NetCharDevInfo0(ndr, NDR_BUFFERS, &r->array[cntr_array_1]));

119

}

120

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_1, 0);

121

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);

122

}

123

if (r->array) {

124

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

125

}

126

}

127

return NDR_ERR_SUCCESS;

128

}

129

130

_PUBLIC_ void ndr_print_srvsvc_NetCharDevCtr0(struct ndr_print *ndr, const char *name, const struct srvsvc_NetCharDevCtr0 *r)

131

{

132

uint32_t cntr_array_1;

133

ndr_print_struct(ndr, name, "srvsvc_NetCharDevCtr0");

134

ndr->depth++;

135

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

136

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

137

ndr->depth++;

138

if (r->array) {

139

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

140

ndr->depth++;

141

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

142

char *idx_1=NULL;

143

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

144

ndr_print_srvsvc_NetCharDevInfo0(ndr, "array", &r->array[cntr_array_1]);

145

free(idx_1);

146

}

147

}

148

ndr->depth--;

149

}

150

ndr->depth--;

151

ndr->depth--;

152

}

153

154

static enum ndr_err_code ndr_push_srvsvc_NetCharDevInfo1(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetCharDevInfo1 *r)

155

{

156

if (ndr_flags & NDR_SCALARS) {

157

NDR_CHECK(ndr_push_align(ndr, 4));

158

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

159

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

160

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

161

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

162

}

163

if (ndr_flags & NDR_BUFFERS) {

164

if (r->device) {

165

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->device, CH_UTF16)));

166

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

167

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->device, CH_UTF16)));

168

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

169

}

170

if (r->user) {

171

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->user, CH_UTF16)));

172

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

173

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->user, CH_UTF16)));

174

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

175

}

176

}

177

return NDR_ERR_SUCCESS;

178

}

179

180

static enum ndr_err_code ndr_pull_srvsvc_NetCharDevInfo1(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetCharDevInfo1 *r)

181

{

182

uint32_t _ptr_device;

183

TALLOC_CTX *_mem_save_device_0;

184

uint32_t _ptr_user;

185

TALLOC_CTX *_mem_save_user_0;

186

if (ndr_flags & NDR_SCALARS) {

187

NDR_CHECK(ndr_pull_align(ndr, 4));

188

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_device));

189

if (_ptr_device) {

190

NDR_PULL_ALLOC(ndr, r->device);

191

} else {

192

r->device = NULL;

193

}

194

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

195

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_user));

196

if (_ptr_user) {

197

NDR_PULL_ALLOC(ndr, r->user);

198

} else {

199

r->user = NULL;

200

}

201

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

202

}

203

if (ndr_flags & NDR_BUFFERS) {

204

if (r->device) {

205

_mem_save_device_0 = NDR_PULL_GET_MEM_CTX(ndr);

206

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

207

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

208

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

209

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

210

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

211

}

212

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

213

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

214

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_device_0, 0);

215

}

216

if (r->user) {

217

_mem_save_user_0 = NDR_PULL_GET_MEM_CTX(ndr);

218

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

219

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

220

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

221

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

222

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

223

}

224

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

225

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

226

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_0, 0);

227

}

228

}

229

return NDR_ERR_SUCCESS;

230

}

231

232

_PUBLIC_ void ndr_print_srvsvc_NetCharDevInfo1(struct ndr_print *ndr, const char *name, const struct srvsvc_NetCharDevInfo1 *r)

233

{

234

ndr_print_struct(ndr, name, "srvsvc_NetCharDevInfo1");

235

ndr->depth++;

236

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

237

ndr->depth++;

238

if (r->device) {

239

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

240

}

241

ndr->depth--;

242

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

243

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

244

ndr->depth++;

245

if (r->user) {

246

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

247

}

248

ndr->depth--;

249

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

250

ndr->depth--;

251

}

252

253

static enum ndr_err_code ndr_push_srvsvc_NetCharDevCtr1(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetCharDevCtr1 *r)

254

{

255

uint32_t cntr_array_1;

256

if (ndr_flags & NDR_SCALARS) {

257

NDR_CHECK(ndr_push_align(ndr, 4));

258

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

259

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

260

}

261

if (ndr_flags & NDR_BUFFERS) {

262

if (r->array) {

263

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

264

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

265

NDR_CHECK(ndr_push_srvsvc_NetCharDevInfo1(ndr, NDR_SCALARS, &r->array[cntr_array_1]));

266

}

267

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

268

NDR_CHECK(ndr_push_srvsvc_NetCharDevInfo1(ndr, NDR_BUFFERS, &r->array[cntr_array_1]));

269

}

270

}

271

}

272

return NDR_ERR_SUCCESS;

273

}

274

275

static enum ndr_err_code ndr_pull_srvsvc_NetCharDevCtr1(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetCharDevCtr1 *r)

276

{

277

uint32_t _ptr_array;

278

uint32_t cntr_array_1;

279

TALLOC_CTX *_mem_save_array_0;

280

TALLOC_CTX *_mem_save_array_1;

281

if (ndr_flags & NDR_SCALARS) {

282

NDR_CHECK(ndr_pull_align(ndr, 4));

283

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

284

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_array));

285

if (_ptr_array) {

286

NDR_PULL_ALLOC(ndr, r->array);

287

} else {

288

r->array = NULL;

289

}

290

}

291

if (ndr_flags & NDR_BUFFERS) {

292

if (r->array) {

293

_mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);

294

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

295

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

296

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

297

_mem_save_array_1 = NDR_PULL_GET_MEM_CTX(ndr);

298

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

299

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

300

NDR_CHECK(ndr_pull_srvsvc_NetCharDevInfo1(ndr, NDR_SCALARS, &r->array[cntr_array_1]));

301

}

302

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

303

NDR_CHECK(ndr_pull_srvsvc_NetCharDevInfo1(ndr, NDR_BUFFERS, &r->array[cntr_array_1]));

304

}

305

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_1, 0);

306

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);

307

}

308

if (r->array) {

309

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

310

}

311

}

312

return NDR_ERR_SUCCESS;

313

}

314

315

_PUBLIC_ void ndr_print_srvsvc_NetCharDevCtr1(struct ndr_print *ndr, const char *name, const struct srvsvc_NetCharDevCtr1 *r)

316

{

317

uint32_t cntr_array_1;

318

ndr_print_struct(ndr, name, "srvsvc_NetCharDevCtr1");

319

ndr->depth++;

320

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

321

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

322

ndr->depth++;

323

if (r->array) {

324

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

325

ndr->depth++;

326

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

327

char *idx_1=NULL;

328

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

329

ndr_print_srvsvc_NetCharDevInfo1(ndr, "array", &r->array[cntr_array_1]);

330

free(idx_1);

331

}

332

}

333

ndr->depth--;

334

}

335

ndr->depth--;

336

ndr->depth--;

337

}

338

339

static enum ndr_err_code ndr_push_srvsvc_NetCharDevInfo(struct ndr_push *ndr, int ndr_flags, const union srvsvc_NetCharDevInfo *r)

340

{

341

if (ndr_flags & NDR_SCALARS) {

342

int level = ndr_push_get_switch_value(ndr, r);

343

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

344

switch (level) {

345

case 0: {

346

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

347

break; }

348

349

case 1: {

350

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

351

break; }

352

353

default: {

354

break; }

355

356

}

357

}

358

if (ndr_flags & NDR_BUFFERS) {

359

int level = ndr_push_get_switch_value(ndr, r);

360

switch (level) {

361

case 0:

362

if (r->info0) {

363

NDR_CHECK(ndr_push_srvsvc_NetCharDevInfo0(ndr, NDR_SCALARS|NDR_BUFFERS, r->info0));

364

}

365

break;

366

367

case 1:

368

if (r->info1) {

369

NDR_CHECK(ndr_push_srvsvc_NetCharDevInfo1(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1));

370

}

371

break;

372

373

default:

374

break;

375

376

}

377

}

378

return NDR_ERR_SUCCESS;

379

}

380

381

static enum ndr_err_code ndr_pull_srvsvc_NetCharDevInfo(struct ndr_pull *ndr, int ndr_flags, union srvsvc_NetCharDevInfo *r)

382

{

383

int level;

384

uint32_t _level;

385

TALLOC_CTX *_mem_save_info0_0;

386

TALLOC_CTX *_mem_save_info1_0;

387

level = ndr_pull_get_switch_value(ndr, r);

388

if (ndr_flags & NDR_SCALARS) {

389

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

390

if (_level != level) {

391

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

392

}

393

switch (level) {

394

case 0: {

395

uint32_t _ptr_info0;

396

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info0));

397

if (_ptr_info0) {

398

NDR_PULL_ALLOC(ndr, r->info0);

399

} else {

400

r->info0 = NULL;

401

}

402

break; }

403

404

case 1: {

405

uint32_t _ptr_info1;

406

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1));

407

if (_ptr_info1) {

408

NDR_PULL_ALLOC(ndr, r->info1);

409

} else {

410

r->info1 = NULL;

411

}

412

break; }

413

414

default: {

415

break; }

416

417

}

418

}

419

if (ndr_flags & NDR_BUFFERS) {

420

switch (level) {

421

case 0:

422

if (r->info0) {

423

_mem_save_info0_0 = NDR_PULL_GET_MEM_CTX(ndr);

424

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

425

NDR_CHECK(ndr_pull_srvsvc_NetCharDevInfo0(ndr, NDR_SCALARS|NDR_BUFFERS, r->info0));

426

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info0_0, 0);

427

}

428

break;

429

430

case 1:

431

if (r->info1) {

432

_mem_save_info1_0 = NDR_PULL_GET_MEM_CTX(ndr);

433

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

434

NDR_CHECK(ndr_pull_srvsvc_NetCharDevInfo1(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1));

435

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1_0, 0);

436

}

437

break;

438

439

default:

440

break;

441

442

}

443

}

444

return NDR_ERR_SUCCESS;

445

}

446

447

_PUBLIC_ void ndr_print_srvsvc_NetCharDevInfo(struct ndr_print *ndr, const char *name, const union srvsvc_NetCharDevInfo *r)

448

{

449

int level;

450

level = ndr_print_get_switch_value(ndr, r);

451

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

452

switch (level) {

453

case 0:

454

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

455

ndr->depth++;

456

if (r->info0) {

457

ndr_print_srvsvc_NetCharDevInfo0(ndr, "info0", r->info0);

458

}

459

ndr->depth--;

460

break;

461

462

case 1:

463

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

464

ndr->depth++;

465

if (r->info1) {

466

ndr_print_srvsvc_NetCharDevInfo1(ndr, "info1", r->info1);

467

}

468

ndr->depth--;

469

break;

470

471

default:

472

break;

473

474

}

475

}

476

477

static enum ndr_err_code ndr_push_srvsvc_NetCharDevCtr(struct ndr_push *ndr, int ndr_flags, const union srvsvc_NetCharDevCtr *r)

478

{

479

if (ndr_flags & NDR_SCALARS) {

480

int level = ndr_push_get_switch_value(ndr, r);

481

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

482

switch (level) {

483

case 0: {

484

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

485

break; }

486

487

case 1: {

488

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

489

break; }

490

491

default: {

492

break; }

493

494

}

495

}

496

if (ndr_flags & NDR_BUFFERS) {

497

int level = ndr_push_get_switch_value(ndr, r);

498

switch (level) {

499

case 0:

500

if (r->ctr0) {

501

NDR_CHECK(ndr_push_srvsvc_NetCharDevCtr0(ndr, NDR_SCALARS|NDR_BUFFERS, r->ctr0));

502

}

503

break;

504

505

case 1:

506

if (r->ctr1) {

507

NDR_CHECK(ndr_push_srvsvc_NetCharDevCtr1(ndr, NDR_SCALARS|NDR_BUFFERS, r->ctr1));

508

}

509

break;

510

511

default:

512

break;

513

514

}

515

}

516

return NDR_ERR_SUCCESS;

517

}

518

519

static enum ndr_err_code ndr_pull_srvsvc_NetCharDevCtr(struct ndr_pull *ndr, int ndr_flags, union srvsvc_NetCharDevCtr *r)

520

{

521

int level;

522

uint32_t _level;

523

TALLOC_CTX *_mem_save_ctr0_0;

524

TALLOC_CTX *_mem_save_ctr1_0;

525

level = ndr_pull_get_switch_value(ndr, r);

526

if (ndr_flags & NDR_SCALARS) {

527

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

528

if (_level != level) {

529

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

530

}

531

switch (level) {

532

case 0: {

533

uint32_t _ptr_ctr0;

534

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_ctr0));

535

if (_ptr_ctr0) {

536

NDR_PULL_ALLOC(ndr, r->ctr0);

537

} else {

538

r->ctr0 = NULL;

539

}

540

break; }

541

542

case 1: {

543

uint32_t _ptr_ctr1;

544

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_ctr1));

545

if (_ptr_ctr1) {

546

NDR_PULL_ALLOC(ndr, r->ctr1);

547

} else {

548

r->ctr1 = NULL;

549

}

550

break; }

551

552

default: {

553

break; }

554

555

}

556

}

557

if (ndr_flags & NDR_BUFFERS) {

558

switch (level) {

559

case 0:

560

if (r->ctr0) {

561

_mem_save_ctr0_0 = NDR_PULL_GET_MEM_CTX(ndr);

562

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

563

NDR_CHECK(ndr_pull_srvsvc_NetCharDevCtr0(ndr, NDR_SCALARS|NDR_BUFFERS, r->ctr0));

564

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ctr0_0, 0);

565

}

566

break;

567

568

case 1:

569

if (r->ctr1) {

570

_mem_save_ctr1_0 = NDR_PULL_GET_MEM_CTX(ndr);

571

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

572

NDR_CHECK(ndr_pull_srvsvc_NetCharDevCtr1(ndr, NDR_SCALARS|NDR_BUFFERS, r->ctr1));

573

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ctr1_0, 0);

574

}

575

break;

576

577

default:

578

break;

579

580

}

581

}

582

return NDR_ERR_SUCCESS;

583

}

584

585

_PUBLIC_ void ndr_print_srvsvc_NetCharDevCtr(struct ndr_print *ndr, const char *name, const union srvsvc_NetCharDevCtr *r)

586

{

587

int level;

588

level = ndr_print_get_switch_value(ndr, r);

589

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

590

switch (level) {

591

case 0:

592

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

593

ndr->depth++;

594

if (r->ctr0) {

595

ndr_print_srvsvc_NetCharDevCtr0(ndr, "ctr0", r->ctr0);

596

}

597

ndr->depth--;

598

break;

599

600

case 1:

601

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

602

ndr->depth++;

603

if (r->ctr1) {

604

ndr_print_srvsvc_NetCharDevCtr1(ndr, "ctr1", r->ctr1);

605

}

606

ndr->depth--;

607

break;

608

609

default:

610

break;

611

612

}

613

}

614

615

static enum ndr_err_code ndr_push_srvsvc_NetCharDevInfoCtr(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetCharDevInfoCtr *r)

616

{

617

if (ndr_flags & NDR_SCALARS) {

618

NDR_CHECK(ndr_push_align(ndr, 4));

619

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

620

NDR_CHECK(ndr_push_set_switch_value(ndr, &r->ctr, r->level));

621

NDR_CHECK(ndr_push_srvsvc_NetCharDevCtr(ndr, NDR_SCALARS, &r->ctr));

622

}

623

if (ndr_flags & NDR_BUFFERS) {

624

NDR_CHECK(ndr_push_srvsvc_NetCharDevCtr(ndr, NDR_BUFFERS, &r->ctr));

625

}

626

return NDR_ERR_SUCCESS;

627

}

628

629

static enum ndr_err_code ndr_pull_srvsvc_NetCharDevInfoCtr(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetCharDevInfoCtr *r)

630

{

631

if (ndr_flags & NDR_SCALARS) {

632

NDR_CHECK(ndr_pull_align(ndr, 4));

633

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

634

NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->ctr, r->level));

635

NDR_CHECK(ndr_pull_srvsvc_NetCharDevCtr(ndr, NDR_SCALARS, &r->ctr));

636

}

637

if (ndr_flags & NDR_BUFFERS) {

638

NDR_CHECK(ndr_pull_srvsvc_NetCharDevCtr(ndr, NDR_BUFFERS, &r->ctr));

639

}

640

return NDR_ERR_SUCCESS;

641

}

642

643

_PUBLIC_ void ndr_print_srvsvc_NetCharDevInfoCtr(struct ndr_print *ndr, const char *name, const struct srvsvc_NetCharDevInfoCtr *r)

644

{

645

ndr_print_struct(ndr, name, "srvsvc_NetCharDevInfoCtr");

646

ndr->depth++;

647

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

648

ndr_print_set_switch_value(ndr, &r->ctr, r->level);

649

ndr_print_srvsvc_NetCharDevCtr(ndr, "ctr", &r->ctr);

650

ndr->depth--;

651

}

652

653

static enum ndr_err_code ndr_push_srvsvc_NetCharDevQInfo0(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetCharDevQInfo0 *r)

654

{

655

if (ndr_flags & NDR_SCALARS) {

656

NDR_CHECK(ndr_push_align(ndr, 4));

657

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

658

}

659

if (ndr_flags & NDR_BUFFERS) {

660

if (r->device) {

661

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->device, CH_UTF16)));

662

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

663

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->device, CH_UTF16)));

664

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

665

}

666

}

667

return NDR_ERR_SUCCESS;

668

}

669

670

static enum ndr_err_code ndr_pull_srvsvc_NetCharDevQInfo0(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetCharDevQInfo0 *r)

671

{

672

uint32_t _ptr_device;

673

TALLOC_CTX *_mem_save_device_0;

674

if (ndr_flags & NDR_SCALARS) {

675

NDR_CHECK(ndr_pull_align(ndr, 4));

676

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_device));

677

if (_ptr_device) {

678

NDR_PULL_ALLOC(ndr, r->device);

679

} else {

680

r->device = NULL;

681

}

682

}

683

if (ndr_flags & NDR_BUFFERS) {

684

if (r->device) {

685

_mem_save_device_0 = NDR_PULL_GET_MEM_CTX(ndr);

686

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

687

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

688

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

689

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

690

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

691

}

692

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

693

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

694

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_device_0, 0);

695

}

696

}

697

return NDR_ERR_SUCCESS;

698

}

699

700

_PUBLIC_ void ndr_print_srvsvc_NetCharDevQInfo0(struct ndr_print *ndr, const char *name, const struct srvsvc_NetCharDevQInfo0 *r)

701

{

702

ndr_print_struct(ndr, name, "srvsvc_NetCharDevQInfo0");

703

ndr->depth++;

704

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

705

ndr->depth++;

706

if (r->device) {

707

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

708

}

709

ndr->depth--;

710

ndr->depth--;

711

}

712

713

static enum ndr_err_code ndr_push_srvsvc_NetCharDevQCtr0(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetCharDevQCtr0 *r)

714

{

715

uint32_t cntr_array_1;

716

if (ndr_flags & NDR_SCALARS) {

717

NDR_CHECK(ndr_push_align(ndr, 4));

718

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

719

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

720

}

721

if (ndr_flags & NDR_BUFFERS) {

722

if (r->array) {

723

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

724

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

725

NDR_CHECK(ndr_push_srvsvc_NetCharDevQInfo0(ndr, NDR_SCALARS, &r->array[cntr_array_1]));

726

}

727

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

728

NDR_CHECK(ndr_push_srvsvc_NetCharDevQInfo0(ndr, NDR_BUFFERS, &r->array[cntr_array_1]));

729

}

730

}

731

}

732

return NDR_ERR_SUCCESS;

733

}

734

735

static enum ndr_err_code ndr_pull_srvsvc_NetCharDevQCtr0(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetCharDevQCtr0 *r)

736

{

737

uint32_t _ptr_array;

738

uint32_t cntr_array_1;

739

TALLOC_CTX *_mem_save_array_0;

740

TALLOC_CTX *_mem_save_array_1;

741

if (ndr_flags & NDR_SCALARS) {

742

NDR_CHECK(ndr_pull_align(ndr, 4));

743

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

744

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_array));

745

if (_ptr_array) {

746

NDR_PULL_ALLOC(ndr, r->array);

747

} else {

748

r->array = NULL;

749

}

750

}

751

if (ndr_flags & NDR_BUFFERS) {

752

if (r->array) {

753

_mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);

754

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

755

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

756

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

757

_mem_save_array_1 = NDR_PULL_GET_MEM_CTX(ndr);

758

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

759

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

760

NDR_CHECK(ndr_pull_srvsvc_NetCharDevQInfo0(ndr, NDR_SCALARS, &r->array[cntr_array_1]));

761

}

762

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

763

NDR_CHECK(ndr_pull_srvsvc_NetCharDevQInfo0(ndr, NDR_BUFFERS, &r->array[cntr_array_1]));

764

}

765

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_1, 0);

766

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);

767

}

768

if (r->array) {

769

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

770

}

771

}

772

return NDR_ERR_SUCCESS;

773

}

774

775

_PUBLIC_ void ndr_print_srvsvc_NetCharDevQCtr0(struct ndr_print *ndr, const char *name, const struct srvsvc_NetCharDevQCtr0 *r)

776

{

777

uint32_t cntr_array_1;

778

ndr_print_struct(ndr, name, "srvsvc_NetCharDevQCtr0");

779

ndr->depth++;

780

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

781

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

782

ndr->depth++;

783

if (r->array) {

784

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

785

ndr->depth++;

786

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

787

char *idx_1=NULL;

788

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

789

ndr_print_srvsvc_NetCharDevQInfo0(ndr, "array", &r->array[cntr_array_1]);

790

free(idx_1);

791

}

792

}

793

ndr->depth--;

794

}

795

ndr->depth--;

796

ndr->depth--;

797

}

798

799

static enum ndr_err_code ndr_push_srvsvc_NetCharDevQInfo1(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetCharDevQInfo1 *r)

800

{

801

if (ndr_flags & NDR_SCALARS) {

802

NDR_CHECK(ndr_push_align(ndr, 4));

803

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

804

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

805

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

806

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

807

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

808

}

809

if (ndr_flags & NDR_BUFFERS) {

810

if (r->device) {

811

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->device, CH_UTF16)));

812

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

813

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->device, CH_UTF16)));

814

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

815

}

816

if (r->devices) {

817

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->devices, CH_UTF16)));

818

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

819

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->devices, CH_UTF16)));

820

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

821

}

822

}

823

return NDR_ERR_SUCCESS;

824

}

825

826

static enum ndr_err_code ndr_pull_srvsvc_NetCharDevQInfo1(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetCharDevQInfo1 *r)

827

{

828

uint32_t _ptr_device;

829

TALLOC_CTX *_mem_save_device_0;

830

uint32_t _ptr_devices;

831

TALLOC_CTX *_mem_save_devices_0;

832

if (ndr_flags & NDR_SCALARS) {

833

NDR_CHECK(ndr_pull_align(ndr, 4));

834

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_device));

835

if (_ptr_device) {

836

NDR_PULL_ALLOC(ndr, r->device);

837

} else {

838

r->device = NULL;

839

}

840

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

841

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_devices));

842

if (_ptr_devices) {

843

NDR_PULL_ALLOC(ndr, r->devices);

844

} else {

845

r->devices = NULL;

846

}

847

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

848

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

849

}

850

if (ndr_flags & NDR_BUFFERS) {

851

if (r->device) {

852

_mem_save_device_0 = NDR_PULL_GET_MEM_CTX(ndr);

853

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

854

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

855

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

856

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

857

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

858

}

859

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

860

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

861

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_device_0, 0);

862

}

863

if (r->devices) {

864

_mem_save_devices_0 = NDR_PULL_GET_MEM_CTX(ndr);

865

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

866

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

867

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

868

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

869

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

870

}

871

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

872

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

873

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_devices_0, 0);

874

}

875

}

876

return NDR_ERR_SUCCESS;

877

}

878

879

_PUBLIC_ void ndr_print_srvsvc_NetCharDevQInfo1(struct ndr_print *ndr, const char *name, const struct srvsvc_NetCharDevQInfo1 *r)

880

{

881

ndr_print_struct(ndr, name, "srvsvc_NetCharDevQInfo1");

882

ndr->depth++;

883

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

884

ndr->depth++;

885

if (r->device) {

886

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

887

}

888

ndr->depth--;

889

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

890

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

891

ndr->depth++;

892

if (r->devices) {

893

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

894

}

895

ndr->depth--;

896

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

897

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

898

ndr->depth--;

899

}

900

901

static enum ndr_err_code ndr_push_srvsvc_NetCharDevQCtr1(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetCharDevQCtr1 *r)

902

{

903

uint32_t cntr_array_1;

904

if (ndr_flags & NDR_SCALARS) {

905

NDR_CHECK(ndr_push_align(ndr, 4));

906

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

907

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

908

}

909

if (ndr_flags & NDR_BUFFERS) {

910

if (r->array) {

911

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

912

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

913

NDR_CHECK(ndr_push_srvsvc_NetCharDevQInfo1(ndr, NDR_SCALARS, &r->array[cntr_array_1]));

914

}

915

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

916

NDR_CHECK(ndr_push_srvsvc_NetCharDevQInfo1(ndr, NDR_BUFFERS, &r->array[cntr_array_1]));

917

}

918

}

919

}

920

return NDR_ERR_SUCCESS;

921

}

922

923

static enum ndr_err_code ndr_pull_srvsvc_NetCharDevQCtr1(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetCharDevQCtr1 *r)

924

{

925

uint32_t _ptr_array;

926

uint32_t cntr_array_1;

927

TALLOC_CTX *_mem_save_array_0;

928

TALLOC_CTX *_mem_save_array_1;

929

if (ndr_flags & NDR_SCALARS) {

930

NDR_CHECK(ndr_pull_align(ndr, 4));

931

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

932

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_array));

933

if (_ptr_array) {

934

NDR_PULL_ALLOC(ndr, r->array);

935

} else {

936

r->array = NULL;

937

}

938

}

939

if (ndr_flags & NDR_BUFFERS) {

940

if (r->array) {

941

_mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);

942

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

943

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

944

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

945

_mem_save_array_1 = NDR_PULL_GET_MEM_CTX(ndr);

946

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

947

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

948

NDR_CHECK(ndr_pull_srvsvc_NetCharDevQInfo1(ndr, NDR_SCALARS, &r->array[cntr_array_1]));

949

}

950

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

951

NDR_CHECK(ndr_pull_srvsvc_NetCharDevQInfo1(ndr, NDR_BUFFERS, &r->array[cntr_array_1]));

952

}

953

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_1, 0);

954

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);

955

}

956

if (r->array) {

957

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

958

}

959

}

960

return NDR_ERR_SUCCESS;

961

}

962

963

_PUBLIC_ void ndr_print_srvsvc_NetCharDevQCtr1(struct ndr_print *ndr, const char *name, const struct srvsvc_NetCharDevQCtr1 *r)

964

{

965

uint32_t cntr_array_1;

966

ndr_print_struct(ndr, name, "srvsvc_NetCharDevQCtr1");

967

ndr->depth++;

968

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

969

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

970

ndr->depth++;

971

if (r->array) {

972

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

973

ndr->depth++;

974

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

975

char *idx_1=NULL;

976

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

977

ndr_print_srvsvc_NetCharDevQInfo1(ndr, "array", &r->array[cntr_array_1]);

978

free(idx_1);

979

}

980

}

981

ndr->depth--;

982

}

983

ndr->depth--;

984

ndr->depth--;

985

}

986

987

static enum ndr_err_code ndr_push_srvsvc_NetCharDevQInfo(struct ndr_push *ndr, int ndr_flags, const union srvsvc_NetCharDevQInfo *r)

988

{

989

if (ndr_flags & NDR_SCALARS) {

990

int level = ndr_push_get_switch_value(ndr, r);

991

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

992

switch (level) {

993

case 0: {

994

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

995

break; }

996

997

case 1: {

998

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

999

break; }

1000

1001

default: {

1002

break; }

1003

1004

}

1005

}

1006

if (ndr_flags & NDR_BUFFERS) {

1007

int level = ndr_push_get_switch_value(ndr, r);

1008

switch (level) {

1009

case 0:

1010

if (r->info0) {

1011

NDR_CHECK(ndr_push_srvsvc_NetCharDevQInfo0(ndr, NDR_SCALARS|NDR_BUFFERS, r->info0));

1012

}

1013

break;

1014

1015

case 1:

1016

if (r->info1) {

1017

NDR_CHECK(ndr_push_srvsvc_NetCharDevQInfo1(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1));

1018

}

1019

break;

1020

1021

default:

1022

break;

1023

1024

}

1025

}

1026

return NDR_ERR_SUCCESS;

1027

}

1028

1029

static enum ndr_err_code ndr_pull_srvsvc_NetCharDevQInfo(struct ndr_pull *ndr, int ndr_flags, union srvsvc_NetCharDevQInfo *r)

1030

{

1031

int level;

1032

uint32_t _level;

1033

TALLOC_CTX *_mem_save_info0_0;

1034

TALLOC_CTX *_mem_save_info1_0;

1035

level = ndr_pull_get_switch_value(ndr, r);

1036

if (ndr_flags & NDR_SCALARS) {

1037

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

1038

if (_level != level) {

1039

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

1040

}

1041

switch (level) {

1042

case 0: {

1043

uint32_t _ptr_info0;

1044

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info0));

1045

if (_ptr_info0) {

1046

NDR_PULL_ALLOC(ndr, r->info0);

1047

} else {

1048

r->info0 = NULL;

1049

}

1050

break; }

1051

1052

case 1: {

1053

uint32_t _ptr_info1;

1054

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1));

1055

if (_ptr_info1) {

1056

NDR_PULL_ALLOC(ndr, r->info1);

1057

} else {

1058

r->info1 = NULL;

1059

}

1060

break; }

1061

1062

default: {

1063

break; }

1064

1065

}

1066

}

1067

if (ndr_flags & NDR_BUFFERS) {

1068

switch (level) {

1069

case 0:

1070

if (r->info0) {

1071

_mem_save_info0_0 = NDR_PULL_GET_MEM_CTX(ndr);

1072

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

1073

NDR_CHECK(ndr_pull_srvsvc_NetCharDevQInfo0(ndr, NDR_SCALARS|NDR_BUFFERS, r->info0));

1074

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info0_0, 0);

1075

}

1076

break;

1077

1078

case 1:

1079

if (r->info1) {

1080

_mem_save_info1_0 = NDR_PULL_GET_MEM_CTX(ndr);

1081

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

1082

NDR_CHECK(ndr_pull_srvsvc_NetCharDevQInfo1(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1));

1083

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1_0, 0);

1084

}

1085

break;

1086

1087

default:

1088

break;

1089

1090

}

1091

}

1092

return NDR_ERR_SUCCESS;

1093

}

1094

1095

_PUBLIC_ void ndr_print_srvsvc_NetCharDevQInfo(struct ndr_print *ndr, const char *name, const union srvsvc_NetCharDevQInfo *r)

1096

{

1097

int level;

1098

level = ndr_print_get_switch_value(ndr, r);

1099

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

1100

switch (level) {

1101

case 0:

1102

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

1103

ndr->depth++;

1104

if (r->info0) {

1105

ndr_print_srvsvc_NetCharDevQInfo0(ndr, "info0", r->info0);

1106

}

1107

ndr->depth--;

1108

break;

1109

1110

case 1:

1111

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

1112

ndr->depth++;

1113

if (r->info1) {

1114

ndr_print_srvsvc_NetCharDevQInfo1(ndr, "info1", r->info1);

1115

}

1116

ndr->depth--;

1117

break;

1118

1119

default:

1120

break;

1121

1122

}

1123

}

1124

1125

static enum ndr_err_code ndr_push_srvsvc_NetCharDevQCtr(struct ndr_push *ndr, int ndr_flags, const union srvsvc_NetCharDevQCtr *r)

1126

{

1127

if (ndr_flags & NDR_SCALARS) {

1128

int level = ndr_push_get_switch_value(ndr, r);

1129

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

1130

switch (level) {

1131

case 0: {

1132

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

1133

break; }

1134

1135

case 1: {

1136

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

1137

break; }

1138

1139

default: {

1140

break; }

1141

1142

}

1143

}

1144

if (ndr_flags & NDR_BUFFERS) {

1145

int level = ndr_push_get_switch_value(ndr, r);

1146

switch (level) {

1147

case 0:

1148

if (r->ctr0) {

1149

NDR_CHECK(ndr_push_srvsvc_NetCharDevQCtr0(ndr, NDR_SCALARS|NDR_BUFFERS, r->ctr0));

1150

}

1151

break;

1152

1153

case 1:

1154

if (r->ctr1) {

1155

NDR_CHECK(ndr_push_srvsvc_NetCharDevQCtr1(ndr, NDR_SCALARS|NDR_BUFFERS, r->ctr1));

1156

}

1157

break;

1158

1159

default:

1160

break;

1161

1162

}

1163

}

1164

return NDR_ERR_SUCCESS;

1165

}

1166

1167

static enum ndr_err_code ndr_pull_srvsvc_NetCharDevQCtr(struct ndr_pull *ndr, int ndr_flags, union srvsvc_NetCharDevQCtr *r)

1168

{

1169

int level;

1170

uint32_t _level;

1171

TALLOC_CTX *_mem_save_ctr0_0;

1172

TALLOC_CTX *_mem_save_ctr1_0;

1173

level = ndr_pull_get_switch_value(ndr, r);

1174

if (ndr_flags & NDR_SCALARS) {

1175

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

1176

if (_level != level) {

1177

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

1178

}

1179

switch (level) {

1180

case 0: {

1181

uint32_t _ptr_ctr0;

1182

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_ctr0));

1183

if (_ptr_ctr0) {

1184

NDR_PULL_ALLOC(ndr, r->ctr0);

1185

} else {

1186

r->ctr0 = NULL;

1187

}

1188

break; }

1189

1190

case 1: {

1191

uint32_t _ptr_ctr1;

1192

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_ctr1));

1193

if (_ptr_ctr1) {

1194

NDR_PULL_ALLOC(ndr, r->ctr1);

1195

} else {

1196

r->ctr1 = NULL;

1197

}

1198

break; }

1199

1200

default: {

1201

break; }

1202

1203

}

1204

}

1205

if (ndr_flags & NDR_BUFFERS) {

1206

switch (level) {

1207

case 0:

1208

if (r->ctr0) {

1209

_mem_save_ctr0_0 = NDR_PULL_GET_MEM_CTX(ndr);

1210

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

1211

NDR_CHECK(ndr_pull_srvsvc_NetCharDevQCtr0(ndr, NDR_SCALARS|NDR_BUFFERS, r->ctr0));

1212

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ctr0_0, 0);

1213

}

1214

break;

1215

1216

case 1:

1217

if (r->ctr1) {

1218

_mem_save_ctr1_0 = NDR_PULL_GET_MEM_CTX(ndr);

1219

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

1220

NDR_CHECK(ndr_pull_srvsvc_NetCharDevQCtr1(ndr, NDR_SCALARS|NDR_BUFFERS, r->ctr1));

1221

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ctr1_0, 0);

1222

}

1223

break;

1224

1225

default:

1226

break;

1227

1228

}

1229

}

1230

return NDR_ERR_SUCCESS;

1231

}

1232

1233

_PUBLIC_ void ndr_print_srvsvc_NetCharDevQCtr(struct ndr_print *ndr, const char *name, const union srvsvc_NetCharDevQCtr *r)

1234

{

1235

int level;

1236

level = ndr_print_get_switch_value(ndr, r);

1237

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

1238

switch (level) {

1239

case 0:

1240

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

1241

ndr->depth++;

1242

if (r->ctr0) {

1243

ndr_print_srvsvc_NetCharDevQCtr0(ndr, "ctr0", r->ctr0);

1244

}

1245

ndr->depth--;

1246

break;

1247

1248

case 1:

1249

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

1250

ndr->depth++;

1251

if (r->ctr1) {

1252

ndr_print_srvsvc_NetCharDevQCtr1(ndr, "ctr1", r->ctr1);

1253

}

1254

ndr->depth--;

1255

break;

1256

1257

default:

1258

break;

1259

1260

}

1261

}

1262

1263

static enum ndr_err_code ndr_push_srvsvc_NetCharDevQInfoCtr(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetCharDevQInfoCtr *r)

1264

{

1265

if (ndr_flags & NDR_SCALARS) {

1266

NDR_CHECK(ndr_push_align(ndr, 4));

1267

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

1268

NDR_CHECK(ndr_push_set_switch_value(ndr, &r->ctr, r->level));

1269

NDR_CHECK(ndr_push_srvsvc_NetCharDevQCtr(ndr, NDR_SCALARS, &r->ctr));

1270

}

1271

if (ndr_flags & NDR_BUFFERS) {

1272

NDR_CHECK(ndr_push_srvsvc_NetCharDevQCtr(ndr, NDR_BUFFERS, &r->ctr));

1273

}

1274

return NDR_ERR_SUCCESS;

1275

}

1276

1277

static enum ndr_err_code ndr_pull_srvsvc_NetCharDevQInfoCtr(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetCharDevQInfoCtr *r)

1278

{

1279

if (ndr_flags & NDR_SCALARS) {

1280

NDR_CHECK(ndr_pull_align(ndr, 4));

1281

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

1282

NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->ctr, r->level));

1283

NDR_CHECK(ndr_pull_srvsvc_NetCharDevQCtr(ndr, NDR_SCALARS, &r->ctr));

1284

}

1285

if (ndr_flags & NDR_BUFFERS) {

1286

NDR_CHECK(ndr_pull_srvsvc_NetCharDevQCtr(ndr, NDR_BUFFERS, &r->ctr));

1287

}

1288

return NDR_ERR_SUCCESS;

1289

}

1290

1291

_PUBLIC_ void ndr_print_srvsvc_NetCharDevQInfoCtr(struct ndr_print *ndr, const char *name, const struct srvsvc_NetCharDevQInfoCtr *r)

1292

{

1293

ndr_print_struct(ndr, name, "srvsvc_NetCharDevQInfoCtr");

1294

ndr->depth++;

1295

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

1296

ndr_print_set_switch_value(ndr, &r->ctr, r->level);

1297

ndr_print_srvsvc_NetCharDevQCtr(ndr, "ctr", &r->ctr);

1298

ndr->depth--;

1299

}

1300

1301

static enum ndr_err_code ndr_push_srvsvc_NetConnInfo0(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetConnInfo0 *r)

1302

{

1303

if (ndr_flags & NDR_SCALARS) {

1304

NDR_CHECK(ndr_push_align(ndr, 4));

1305

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

1306

}

1307

if (ndr_flags & NDR_BUFFERS) {

1308

}

1309

return NDR_ERR_SUCCESS;

1310

}

1311

1312

static enum ndr_err_code ndr_pull_srvsvc_NetConnInfo0(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetConnInfo0 *r)

1313

{

1314

if (ndr_flags & NDR_SCALARS) {

1315

NDR_CHECK(ndr_pull_align(ndr, 4));

1316

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

1317

}

1318

if (ndr_flags & NDR_BUFFERS) {

1319

}

1320

return NDR_ERR_SUCCESS;

1321

}

1322

1323

_PUBLIC_ void ndr_print_srvsvc_NetConnInfo0(struct ndr_print *ndr, const char *name, const struct srvsvc_NetConnInfo0 *r)

1324

{

1325

ndr_print_struct(ndr, name, "srvsvc_NetConnInfo0");

1326

ndr->depth++;

1327

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

1328

ndr->depth--;

1329

}

1330

1331

static enum ndr_err_code ndr_push_srvsvc_NetConnCtr0(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetConnCtr0 *r)

1332

{

1333

uint32_t cntr_array_1;

1334

if (ndr_flags & NDR_SCALARS) {

1335

NDR_CHECK(ndr_push_align(ndr, 4));

1336

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

1337

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

1338

}

1339

if (ndr_flags & NDR_BUFFERS) {

1340

if (r->array) {

1341

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

1342

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

1343

NDR_CHECK(ndr_push_srvsvc_NetConnInfo0(ndr, NDR_SCALARS, &r->array[cntr_array_1]));

1344

}

1345

}

1346

}

1347

return NDR_ERR_SUCCESS;

1348

}

1349

1350

static enum ndr_err_code ndr_pull_srvsvc_NetConnCtr0(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetConnCtr0 *r)

1351

{

1352

uint32_t _ptr_array;

1353

uint32_t cntr_array_1;

1354

TALLOC_CTX *_mem_save_array_0;

1355

TALLOC_CTX *_mem_save_array_1;

1356

if (ndr_flags & NDR_SCALARS) {

1357

NDR_CHECK(ndr_pull_align(ndr, 4));

1358

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

1359

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_array));

1360

if (_ptr_array) {

1361

NDR_PULL_ALLOC(ndr, r->array);

1362

} else {

1363

r->array = NULL;

1364

}

1365

}

1366

if (ndr_flags & NDR_BUFFERS) {

1367

if (r->array) {

1368

_mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);

1369

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

1370

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

1371

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

1372

_mem_save_array_1 = NDR_PULL_GET_MEM_CTX(ndr);

1373

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

1374

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

1375

NDR_CHECK(ndr_pull_srvsvc_NetConnInfo0(ndr, NDR_SCALARS, &r->array[cntr_array_1]));

1376

}

1377

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_1, 0);

1378

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);

1379

}

1380

if (r->array) {

1381

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

1382

}

1383

}

1384

return NDR_ERR_SUCCESS;

1385

}

1386

1387

_PUBLIC_ void ndr_print_srvsvc_NetConnCtr0(struct ndr_print *ndr, const char *name, const struct srvsvc_NetConnCtr0 *r)

1388

{

1389

uint32_t cntr_array_1;

1390

ndr_print_struct(ndr, name, "srvsvc_NetConnCtr0");

1391

ndr->depth++;

1392

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

1393

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

1394

ndr->depth++;

1395

if (r->array) {

1396

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

1397

ndr->depth++;

1398

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

1399

char *idx_1=NULL;

1400

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

1401

ndr_print_srvsvc_NetConnInfo0(ndr, "array", &r->array[cntr_array_1]);

1402

free(idx_1);

1403

}

1404

}

1405

ndr->depth--;

1406

}

1407

ndr->depth--;

1408

ndr->depth--;

1409

}

1410

1411

static enum ndr_err_code ndr_push_srvsvc_NetConnInfo1(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetConnInfo1 *r)

1412

{

1413

if (ndr_flags & NDR_SCALARS) {

1414

NDR_CHECK(ndr_push_align(ndr, 4));

1415

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

1416

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

1417

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

1418

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

1419

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

1420

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

1421

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

1422

}

1423

if (ndr_flags & NDR_BUFFERS) {

1424

if (r->user) {

1425

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->user, CH_UTF16)));

1426

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

1427

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->user, CH_UTF16)));

1428

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

1429

}

1430

if (r->share) {

1431

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->share, CH_UTF16)));

1432

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

1433

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->share, CH_UTF16)));

1434

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

1435

}

1436

}

1437

return NDR_ERR_SUCCESS;

1438

}

1439

1440

static enum ndr_err_code ndr_pull_srvsvc_NetConnInfo1(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetConnInfo1 *r)

1441

{

1442

uint32_t _ptr_user;

1443

TALLOC_CTX *_mem_save_user_0;

1444

uint32_t _ptr_share;

1445

TALLOC_CTX *_mem_save_share_0;

1446

if (ndr_flags & NDR_SCALARS) {

1447

NDR_CHECK(ndr_pull_align(ndr, 4));

1448

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

1449

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

1450

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

1451

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

1452

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

1453

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_user));

1454

if (_ptr_user) {

1455

NDR_PULL_ALLOC(ndr, r->user);

1456

} else {

1457

r->user = NULL;

1458

}

1459

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_share));

1460

if (_ptr_share) {

1461

NDR_PULL_ALLOC(ndr, r->share);

1462

} else {

1463

r->share = NULL;

1464

}

1465

}

1466

if (ndr_flags & NDR_BUFFERS) {

1467

if (r->user) {

1468

_mem_save_user_0 = NDR_PULL_GET_MEM_CTX(ndr);

1469

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

1470

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

1471

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

1472

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

1473

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

1474

}

1475

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

1476

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

1477

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_0, 0);

1478

}

1479

if (r->share) {

1480

_mem_save_share_0 = NDR_PULL_GET_MEM_CTX(ndr);

1481

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

1482

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

1483

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

1484

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

1485

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

1486

}

1487

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

1488

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

1489

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_share_0, 0);

1490

}

1491

}

1492

return NDR_ERR_SUCCESS;

1493

}

1494

1495

_PUBLIC_ void ndr_print_srvsvc_NetConnInfo1(struct ndr_print *ndr, const char *name, const struct srvsvc_NetConnInfo1 *r)

1496

{

1497

ndr_print_struct(ndr, name, "srvsvc_NetConnInfo1");

1498

ndr->depth++;

1499

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

1500

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

1501

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

1502

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

1503

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

1504

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

1505

ndr->depth++;

1506

if (r->user) {

1507

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

1508

}

1509

ndr->depth--;

1510

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

1511

ndr->depth++;

1512

if (r->share) {

1513

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

1514

}

1515

ndr->depth--;

1516

ndr->depth--;

1517

}

1518

1519

static enum ndr_err_code ndr_push_srvsvc_NetConnCtr1(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetConnCtr1 *r)

1520

{

1521

uint32_t cntr_array_1;

1522

if (ndr_flags & NDR_SCALARS) {

1523

NDR_CHECK(ndr_push_align(ndr, 4));

1524

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

1525

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

1526

}

1527

if (ndr_flags & NDR_BUFFERS) {

1528

if (r->array) {

1529

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

1530

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

1531

NDR_CHECK(ndr_push_srvsvc_NetConnInfo1(ndr, NDR_SCALARS, &r->array[cntr_array_1]));

1532

}

1533

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

1534

NDR_CHECK(ndr_push_srvsvc_NetConnInfo1(ndr, NDR_BUFFERS, &r->array[cntr_array_1]));

1535

}

1536

}

1537

}

1538

return NDR_ERR_SUCCESS;

1539

}

1540

1541

static enum ndr_err_code ndr_pull_srvsvc_NetConnCtr1(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetConnCtr1 *r)

1542

{

1543

uint32_t _ptr_array;

1544

uint32_t cntr_array_1;

1545

TALLOC_CTX *_mem_save_array_0;

1546

TALLOC_CTX *_mem_save_array_1;

1547

if (ndr_flags & NDR_SCALARS) {

1548

NDR_CHECK(ndr_pull_align(ndr, 4));

1549

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

1550

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_array));

1551

if (_ptr_array) {

1552

NDR_PULL_ALLOC(ndr, r->array);

1553

} else {

1554

r->array = NULL;

1555

}

1556

}

1557

if (ndr_flags & NDR_BUFFERS) {

1558

if (r->array) {

1559

_mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);

1560

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

1561

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

1562

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

1563

_mem_save_array_1 = NDR_PULL_GET_MEM_CTX(ndr);

1564

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

1565

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

1566

NDR_CHECK(ndr_pull_srvsvc_NetConnInfo1(ndr, NDR_SCALARS, &r->array[cntr_array_1]));

1567

}

1568

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

1569

NDR_CHECK(ndr_pull_srvsvc_NetConnInfo1(ndr, NDR_BUFFERS, &r->array[cntr_array_1]));

1570

}

1571

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_1, 0);

1572

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);

1573

}

1574

if (r->array) {

1575

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

1576

}

1577

}

1578

return NDR_ERR_SUCCESS;

1579

}

1580

1581

_PUBLIC_ void ndr_print_srvsvc_NetConnCtr1(struct ndr_print *ndr, const char *name, const struct srvsvc_NetConnCtr1 *r)

1582

{

1583

uint32_t cntr_array_1;

1584

ndr_print_struct(ndr, name, "srvsvc_NetConnCtr1");

1585

ndr->depth++;

1586

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

1587

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

1588

ndr->depth++;

1589

if (r->array) {

1590

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

1591

ndr->depth++;

1592

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

1593

char *idx_1=NULL;

1594

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

1595

ndr_print_srvsvc_NetConnInfo1(ndr, "array", &r->array[cntr_array_1]);

1596

free(idx_1);

1597

}

1598

}

1599

ndr->depth--;

1600

}

1601

ndr->depth--;

1602

ndr->depth--;

1603

}

1604

1605

static enum ndr_err_code ndr_push_srvsvc_NetConnCtr(struct ndr_push *ndr, int ndr_flags, const union srvsvc_NetConnCtr *r)

1606

{

1607

if (ndr_flags & NDR_SCALARS) {

1608

int level = ndr_push_get_switch_value(ndr, r);

1609

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

1610

switch (level) {

1611

case 0: {

1612

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

1613

break; }

1614

1615

case 1: {

1616

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

1617

break; }

1618

1619

default: {

1620

break; }

1621

1622

}

1623

}

1624

if (ndr_flags & NDR_BUFFERS) {

1625

int level = ndr_push_get_switch_value(ndr, r);

1626

switch (level) {

1627

case 0:

1628

if (r->ctr0) {

1629

NDR_CHECK(ndr_push_srvsvc_NetConnCtr0(ndr, NDR_SCALARS|NDR_BUFFERS, r->ctr0));

1630

}

1631

break;

1632

1633

case 1:

1634

if (r->ctr1) {

1635

NDR_CHECK(ndr_push_srvsvc_NetConnCtr1(ndr, NDR_SCALARS|NDR_BUFFERS, r->ctr1));

1636

}

1637

break;

1638

1639

default:

1640

break;

1641

1642

}

1643

}

1644

return NDR_ERR_SUCCESS;

1645

}

1646

1647

static enum ndr_err_code ndr_pull_srvsvc_NetConnCtr(struct ndr_pull *ndr, int ndr_flags, union srvsvc_NetConnCtr *r)

1648

{

1649

int level;

1650

uint32_t _level;

1651

TALLOC_CTX *_mem_save_ctr0_0;

1652

TALLOC_CTX *_mem_save_ctr1_0;

1653

level = ndr_pull_get_switch_value(ndr, r);

1654

if (ndr_flags & NDR_SCALARS) {

1655

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

1656

if (_level != level) {

1657

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

1658

}

1659

switch (level) {

1660

case 0: {

1661

uint32_t _ptr_ctr0;

1662

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_ctr0));

1663

if (_ptr_ctr0) {

1664

NDR_PULL_ALLOC(ndr, r->ctr0);

1665

} else {

1666

r->ctr0 = NULL;

1667

}

1668

break; }

1669

1670

case 1: {

1671

uint32_t _ptr_ctr1;

1672

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_ctr1));

1673

if (_ptr_ctr1) {

1674

NDR_PULL_ALLOC(ndr, r->ctr1);

1675

} else {

1676

r->ctr1 = NULL;

1677

}

1678

break; }

1679

1680

default: {

1681

break; }

1682

1683

}

1684

}

1685

if (ndr_flags & NDR_BUFFERS) {

1686

switch (level) {

1687

case 0:

1688

if (r->ctr0) {

1689

_mem_save_ctr0_0 = NDR_PULL_GET_MEM_CTX(ndr);

1690

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

1691

NDR_CHECK(ndr_pull_srvsvc_NetConnCtr0(ndr, NDR_SCALARS|NDR_BUFFERS, r->ctr0));

1692

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ctr0_0, 0);

1693

}

1694

break;

1695

1696

case 1:

1697

if (r->ctr1) {

1698

_mem_save_ctr1_0 = NDR_PULL_GET_MEM_CTX(ndr);

1699

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

1700

NDR_CHECK(ndr_pull_srvsvc_NetConnCtr1(ndr, NDR_SCALARS|NDR_BUFFERS, r->ctr1));

1701

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ctr1_0, 0);

1702

}

1703

break;

1704

1705

default:

1706

break;

1707

1708

}

1709

}

1710

return NDR_ERR_SUCCESS;

1711

}

1712

1713

_PUBLIC_ void ndr_print_srvsvc_NetConnCtr(struct ndr_print *ndr, const char *name, const union srvsvc_NetConnCtr *r)

1714

{

1715

int level;

1716

level = ndr_print_get_switch_value(ndr, r);

1717

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

1718

switch (level) {

1719

case 0:

1720

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

1721

ndr->depth++;

1722

if (r->ctr0) {

1723

ndr_print_srvsvc_NetConnCtr0(ndr, "ctr0", r->ctr0);

1724

}

1725

ndr->depth--;

1726

break;

1727

1728

case 1:

1729

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

1730

ndr->depth++;

1731

if (r->ctr1) {

1732

ndr_print_srvsvc_NetConnCtr1(ndr, "ctr1", r->ctr1);

1733

}

1734

ndr->depth--;

1735

break;

1736

1737

default:

1738

break;

1739

1740

}

1741

}

1742

1743

static enum ndr_err_code ndr_push_srvsvc_NetConnInfoCtr(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetConnInfoCtr *r)

1744

{

1745

if (ndr_flags & NDR_SCALARS) {

1746

NDR_CHECK(ndr_push_align(ndr, 4));

1747

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

1748

NDR_CHECK(ndr_push_set_switch_value(ndr, &r->ctr, r->level));

1749

NDR_CHECK(ndr_push_srvsvc_NetConnCtr(ndr, NDR_SCALARS, &r->ctr));

1750

}

1751

if (ndr_flags & NDR_BUFFERS) {

1752

NDR_CHECK(ndr_push_srvsvc_NetConnCtr(ndr, NDR_BUFFERS, &r->ctr));

1753

}

1754

return NDR_ERR_SUCCESS;

1755

}

1756

1757

static enum ndr_err_code ndr_pull_srvsvc_NetConnInfoCtr(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetConnInfoCtr *r)

1758

{

1759

if (ndr_flags & NDR_SCALARS) {

1760

NDR_CHECK(ndr_pull_align(ndr, 4));

1761

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

1762

NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->ctr, r->level));

1763

NDR_CHECK(ndr_pull_srvsvc_NetConnCtr(ndr, NDR_SCALARS, &r->ctr));

1764

}

1765

if (ndr_flags & NDR_BUFFERS) {

1766

NDR_CHECK(ndr_pull_srvsvc_NetConnCtr(ndr, NDR_BUFFERS, &r->ctr));

1767

}

1768

return NDR_ERR_SUCCESS;

1769

}

1770

1771

_PUBLIC_ void ndr_print_srvsvc_NetConnInfoCtr(struct ndr_print *ndr, const char *name, const struct srvsvc_NetConnInfoCtr *r)

1772

{

1773

ndr_print_struct(ndr, name, "srvsvc_NetConnInfoCtr");

1774

ndr->depth++;

1775

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

1776

ndr_print_set_switch_value(ndr, &r->ctr, r->level);

1777

ndr_print_srvsvc_NetConnCtr(ndr, "ctr", &r->ctr);

1778

ndr->depth--;

1779

}

1780

1781

static enum ndr_err_code ndr_push_srvsvc_NetFileInfo2(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetFileInfo2 *r)

1782

{

1783

if (ndr_flags & NDR_SCALARS) {

1784

NDR_CHECK(ndr_push_align(ndr, 4));

1785

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

1786

}

1787

if (ndr_flags & NDR_BUFFERS) {

1788

}

1789

return NDR_ERR_SUCCESS;

1790

}

1791

1792

static enum ndr_err_code ndr_pull_srvsvc_NetFileInfo2(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetFileInfo2 *r)

1793

{

1794

if (ndr_flags & NDR_SCALARS) {

1795

NDR_CHECK(ndr_pull_align(ndr, 4));

1796

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

1797

}

1798

if (ndr_flags & NDR_BUFFERS) {

1799

}

1800

return NDR_ERR_SUCCESS;

1801

}

1802

1803

_PUBLIC_ void ndr_print_srvsvc_NetFileInfo2(struct ndr_print *ndr, const char *name, const struct srvsvc_NetFileInfo2 *r)

1804

{

1805

ndr_print_struct(ndr, name, "srvsvc_NetFileInfo2");

1806

ndr->depth++;

1807

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

1808

ndr->depth--;

1809

}

1810

1811

static enum ndr_err_code ndr_push_srvsvc_NetFileCtr2(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetFileCtr2 *r)

1812

{

1813

uint32_t cntr_array_1;

1814

if (ndr_flags & NDR_SCALARS) {

1815

NDR_CHECK(ndr_push_align(ndr, 4));

1816

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

1817

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

1818

}

1819

if (ndr_flags & NDR_BUFFERS) {

1820

if (r->array) {

1821

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

1822

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

1823

NDR_CHECK(ndr_push_srvsvc_NetFileInfo2(ndr, NDR_SCALARS, &r->array[cntr_array_1]));

1824

}

1825

}

1826

}

1827

return NDR_ERR_SUCCESS;

1828

}

1829

1830

static enum ndr_err_code ndr_pull_srvsvc_NetFileCtr2(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetFileCtr2 *r)

1831

{

1832

uint32_t _ptr_array;

1833

uint32_t cntr_array_1;

1834

TALLOC_CTX *_mem_save_array_0;

1835

TALLOC_CTX *_mem_save_array_1;

1836

if (ndr_flags & NDR_SCALARS) {

1837

NDR_CHECK(ndr_pull_align(ndr, 4));

1838

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

1839

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_array));

1840

if (_ptr_array) {

1841

NDR_PULL_ALLOC(ndr, r->array);

1842

} else {

1843

r->array = NULL;

1844

}

1845

}

1846

if (ndr_flags & NDR_BUFFERS) {

1847

if (r->array) {

1848

_mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);

1849

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

1850

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

1851

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

1852

_mem_save_array_1 = NDR_PULL_GET_MEM_CTX(ndr);

1853

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

1854

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

1855

NDR_CHECK(ndr_pull_srvsvc_NetFileInfo2(ndr, NDR_SCALARS, &r->array[cntr_array_1]));

1856

}

1857

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_1, 0);

1858

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);

1859

}

1860

if (r->array) {

1861

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

1862

}

1863

}

1864

return NDR_ERR_SUCCESS;

1865

}

1866

1867

_PUBLIC_ void ndr_print_srvsvc_NetFileCtr2(struct ndr_print *ndr, const char *name, const struct srvsvc_NetFileCtr2 *r)

1868

{

1869

uint32_t cntr_array_1;

1870

ndr_print_struct(ndr, name, "srvsvc_NetFileCtr2");

1871

ndr->depth++;

1872

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

1873

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

1874

ndr->depth++;

1875

if (r->array) {

1876

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

1877

ndr->depth++;

1878

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

1879

char *idx_1=NULL;

1880

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

1881

ndr_print_srvsvc_NetFileInfo2(ndr, "array", &r->array[cntr_array_1]);

1882

free(idx_1);

1883

}

1884

}

1885

ndr->depth--;

1886

}

1887

ndr->depth--;

1888

ndr->depth--;

1889

}

1890

1891

static enum ndr_err_code ndr_push_srvsvc_NetFileInfo3(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetFileInfo3 *r)

1892

{

1893

if (ndr_flags & NDR_SCALARS) {

1894

NDR_CHECK(ndr_push_align(ndr, 4));

1895

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

1896

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

1897

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

1898

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

1899

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

1900

}

1901

if (ndr_flags & NDR_BUFFERS) {

1902

if (r->path) {

1903

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->path, CH_UTF16)));

1904

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

1905

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->path, CH_UTF16)));

1906

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

1907

}

1908

if (r->user) {

1909

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->user, CH_UTF16)));

1910

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

1911

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->user, CH_UTF16)));

1912

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

1913

}

1914

}

1915

return NDR_ERR_SUCCESS;

1916

}

1917

1918

static enum ndr_err_code ndr_pull_srvsvc_NetFileInfo3(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetFileInfo3 *r)

1919

{

1920

uint32_t _ptr_path;

1921

TALLOC_CTX *_mem_save_path_0;

1922

uint32_t _ptr_user;

1923

TALLOC_CTX *_mem_save_user_0;

1924

if (ndr_flags & NDR_SCALARS) {

1925

NDR_CHECK(ndr_pull_align(ndr, 4));

1926

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

1927

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

1928

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

1929

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_path));

1930

if (_ptr_path) {

1931

NDR_PULL_ALLOC(ndr, r->path);

1932

} else {

1933

r->path = NULL;

1934

}

1935

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_user));

1936

if (_ptr_user) {

1937

NDR_PULL_ALLOC(ndr, r->user);

1938

} else {

1939

r->user = NULL;

1940

}

1941

}

1942

if (ndr_flags & NDR_BUFFERS) {

1943

if (r->path) {

1944

_mem_save_path_0 = NDR_PULL_GET_MEM_CTX(ndr);

1945

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

1946

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

1947

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

1948

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

1949

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

1950

}

1951

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

1952

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

1953

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_path_0, 0);

1954

}

1955

if (r->user) {

1956

_mem_save_user_0 = NDR_PULL_GET_MEM_CTX(ndr);

1957

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

1958

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

1959

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

1960

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

1961

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

1962

}

1963

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

1964

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

1965

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_0, 0);

1966

}

1967

}

1968

return NDR_ERR_SUCCESS;

1969

}

1970

1971

_PUBLIC_ void ndr_print_srvsvc_NetFileInfo3(struct ndr_print *ndr, const char *name, const struct srvsvc_NetFileInfo3 *r)

1972

{

1973

ndr_print_struct(ndr, name, "srvsvc_NetFileInfo3");

1974

ndr->depth++;

1975

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

1976

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

1977

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

1978

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

1979

ndr->depth++;

1980

if (r->path) {

1981

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

1982

}

1983

ndr->depth--;

1984

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

1985

ndr->depth++;

1986

if (r->user) {

1987

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

1988

}

1989

ndr->depth--;

1990

ndr->depth--;

1991

}

1992

1993

static enum ndr_err_code ndr_push_srvsvc_NetFileCtr3(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetFileCtr3 *r)

1994

{

1995

uint32_t cntr_array_1;

1996

if (ndr_flags & NDR_SCALARS) {

1997

NDR_CHECK(ndr_push_align(ndr, 4));

1998

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

1999

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

2000

}

2001

if (ndr_flags & NDR_BUFFERS) {

2002

if (r->array) {

2003

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

2004

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

2005

NDR_CHECK(ndr_push_srvsvc_NetFileInfo3(ndr, NDR_SCALARS, &r->array[cntr_array_1]));

2006

}

2007

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

2008

NDR_CHECK(ndr_push_srvsvc_NetFileInfo3(ndr, NDR_BUFFERS, &r->array[cntr_array_1]));

2009

}

2010

}

2011

}

2012

return NDR_ERR_SUCCESS;

2013

}

2014

2015

static enum ndr_err_code ndr_pull_srvsvc_NetFileCtr3(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetFileCtr3 *r)

2016

{

2017

uint32_t _ptr_array;

2018

uint32_t cntr_array_1;

2019

TALLOC_CTX *_mem_save_array_0;

2020

TALLOC_CTX *_mem_save_array_1;

2021

if (ndr_flags & NDR_SCALARS) {

2022

NDR_CHECK(ndr_pull_align(ndr, 4));

2023

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

2024

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_array));

2025

if (_ptr_array) {

2026

NDR_PULL_ALLOC(ndr, r->array);

2027

} else {

2028

r->array = NULL;

2029

}

2030

}

2031

if (ndr_flags & NDR_BUFFERS) {

2032

if (r->array) {

2033

_mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);

2034

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

2035

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

2036

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

2037

_mem_save_array_1 = NDR_PULL_GET_MEM_CTX(ndr);

2038

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

2039

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

2040

NDR_CHECK(ndr_pull_srvsvc_NetFileInfo3(ndr, NDR_SCALARS, &r->array[cntr_array_1]));

2041

}

2042

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

2043

NDR_CHECK(ndr_pull_srvsvc_NetFileInfo3(ndr, NDR_BUFFERS, &r->array[cntr_array_1]));

2044

}

2045

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_1, 0);

2046

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);

2047

}

2048

if (r->array) {

2049

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

2050

}

2051

}

2052

return NDR_ERR_SUCCESS;

2053

}

2054

2055

_PUBLIC_ void ndr_print_srvsvc_NetFileCtr3(struct ndr_print *ndr, const char *name, const struct srvsvc_NetFileCtr3 *r)

2056

{

2057

uint32_t cntr_array_1;

2058

ndr_print_struct(ndr, name, "srvsvc_NetFileCtr3");

2059

ndr->depth++;

2060

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

2061

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

2062

ndr->depth++;

2063

if (r->array) {

2064

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

2065

ndr->depth++;

2066

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

2067

char *idx_1=NULL;

2068

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

2069

ndr_print_srvsvc_NetFileInfo3(ndr, "array", &r->array[cntr_array_1]);

2070

free(idx_1);

2071

}

2072

}

2073

ndr->depth--;

2074

}

2075

ndr->depth--;

2076

ndr->depth--;

2077

}

2078

2079

static enum ndr_err_code ndr_push_srvsvc_NetFileInfo(struct ndr_push *ndr, int ndr_flags, const union srvsvc_NetFileInfo *r)

2080

{

2081

if (ndr_flags & NDR_SCALARS) {

2082

int level = ndr_push_get_switch_value(ndr, r);

2083

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

2084

switch (level) {

2085

case 2: {

2086

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

2087

break; }

2088

2089

case 3: {

2090

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

2091

break; }

2092

2093

default: {

2094

break; }

2095

2096

}

2097

}

2098

if (ndr_flags & NDR_BUFFERS) {

2099

int level = ndr_push_get_switch_value(ndr, r);

2100

switch (level) {

2101

case 2:

2102

if (r->info2) {

2103

NDR_CHECK(ndr_push_srvsvc_NetFileInfo2(ndr, NDR_SCALARS, r->info2));

2104

}

2105

break;

2106

2107

case 3:

2108

if (r->info3) {

2109

NDR_CHECK(ndr_push_srvsvc_NetFileInfo3(ndr, NDR_SCALARS|NDR_BUFFERS, r->info3));

2110

}

2111

break;

2112

2113

default:

2114

break;

2115

2116

}

2117

}

2118

return NDR_ERR_SUCCESS;

2119

}

2120

2121

static enum ndr_err_code ndr_pull_srvsvc_NetFileInfo(struct ndr_pull *ndr, int ndr_flags, union srvsvc_NetFileInfo *r)

2122

{

2123

int level;

2124

uint32_t _level;

2125

TALLOC_CTX *_mem_save_info2_0;

2126

TALLOC_CTX *_mem_save_info3_0;

2127

level = ndr_pull_get_switch_value(ndr, r);

2128

if (ndr_flags & NDR_SCALARS) {

2129

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

2130

if (_level != level) {

2131

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

2132

}

2133

switch (level) {

2134

case 2: {

2135

uint32_t _ptr_info2;

2136

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info2));

2137

if (_ptr_info2) {

2138

NDR_PULL_ALLOC(ndr, r->info2);

2139

} else {

2140

r->info2 = NULL;

2141

}

2142

break; }

2143

2144

case 3: {

2145

uint32_t _ptr_info3;

2146

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info3));

2147

if (_ptr_info3) {

2148

NDR_PULL_ALLOC(ndr, r->info3);

2149

} else {

2150

r->info3 = NULL;

2151

}

2152

break; }

2153

2154

default: {

2155

break; }

2156

2157

}

2158

}

2159

if (ndr_flags & NDR_BUFFERS) {

2160

switch (level) {

2161

case 2:

2162

if (r->info2) {

2163

_mem_save_info2_0 = NDR_PULL_GET_MEM_CTX(ndr);

2164

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

2165

NDR_CHECK(ndr_pull_srvsvc_NetFileInfo2(ndr, NDR_SCALARS, r->info2));

2166

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info2_0, 0);

2167

}

2168

break;

2169

2170

case 3:

2171

if (r->info3) {

2172

_mem_save_info3_0 = NDR_PULL_GET_MEM_CTX(ndr);

2173

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

2174

NDR_CHECK(ndr_pull_srvsvc_NetFileInfo3(ndr, NDR_SCALARS|NDR_BUFFERS, r->info3));

2175

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info3_0, 0);

2176

}

2177

break;

2178

2179

default:

2180

break;

2181

2182

}

2183

}

2184

return NDR_ERR_SUCCESS;

2185

}

2186

2187

_PUBLIC_ void ndr_print_srvsvc_NetFileInfo(struct ndr_print *ndr, const char *name, const union srvsvc_NetFileInfo *r)

2188

{

2189

int level;

2190

level = ndr_print_get_switch_value(ndr, r);

2191

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

2192

switch (level) {

2193

case 2:

2194

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

2195

ndr->depth++;

2196

if (r->info2) {

2197

ndr_print_srvsvc_NetFileInfo2(ndr, "info2", r->info2);

2198

}

2199

ndr->depth--;

2200

break;

2201

2202

case 3:

2203

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

2204

ndr->depth++;

2205

if (r->info3) {

2206

ndr_print_srvsvc_NetFileInfo3(ndr, "info3", r->info3);

2207

}

2208

ndr->depth--;

2209

break;

2210

2211

default:

2212

break;

2213

2214

}

2215

}

2216

2217

static enum ndr_err_code ndr_push_srvsvc_NetFileCtr(struct ndr_push *ndr, int ndr_flags, const union srvsvc_NetFileCtr *r)

2218

{

2219

if (ndr_flags & NDR_SCALARS) {

2220

int level = ndr_push_get_switch_value(ndr, r);

2221

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

2222

switch (level) {

2223

case 2: {

2224

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

2225

break; }

2226

2227

case 3: {

2228

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

2229

break; }

2230

2231

default: {

2232

break; }

2233

2234

}

2235

}

2236

if (ndr_flags & NDR_BUFFERS) {

2237

int level = ndr_push_get_switch_value(ndr, r);

2238

switch (level) {

2239

case 2:

2240

if (r->ctr2) {

2241

NDR_CHECK(ndr_push_srvsvc_NetFileCtr2(ndr, NDR_SCALARS|NDR_BUFFERS, r->ctr2));

2242

}

2243

break;

2244

2245

case 3:

2246

if (r->ctr3) {

2247

NDR_CHECK(ndr_push_srvsvc_NetFileCtr3(ndr, NDR_SCALARS|NDR_BUFFERS, r->ctr3));

2248

}

2249

break;

2250

2251

default:

2252

break;

2253

2254

}

2255

}

2256

return NDR_ERR_SUCCESS;

2257

}

2258

2259

static enum ndr_err_code ndr_pull_srvsvc_NetFileCtr(struct ndr_pull *ndr, int ndr_flags, union srvsvc_NetFileCtr *r)

2260

{

2261

int level;

2262

uint32_t _level;

2263

TALLOC_CTX *_mem_save_ctr2_0;

2264

TALLOC_CTX *_mem_save_ctr3_0;

2265

level = ndr_pull_get_switch_value(ndr, r);

2266

if (ndr_flags & NDR_SCALARS) {

2267

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

2268

if (_level != level) {

2269

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

2270

}

2271

switch (level) {

2272

case 2: {

2273

uint32_t _ptr_ctr2;

2274

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_ctr2));

2275

if (_ptr_ctr2) {

2276

NDR_PULL_ALLOC(ndr, r->ctr2);

2277

} else {

2278

r->ctr2 = NULL;

2279

}

2280

break; }

2281

2282

case 3: {

2283

uint32_t _ptr_ctr3;

2284

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_ctr3));

2285

if (_ptr_ctr3) {

2286

NDR_PULL_ALLOC(ndr, r->ctr3);

2287

} else {

2288

r->ctr3 = NULL;

2289

}

2290

break; }

2291

2292

default: {

2293

break; }

2294

2295

}

2296

}

2297

if (ndr_flags & NDR_BUFFERS) {

2298

switch (level) {

2299

case 2:

2300

if (r->ctr2) {

2301

_mem_save_ctr2_0 = NDR_PULL_GET_MEM_CTX(ndr);

2302

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

2303

NDR_CHECK(ndr_pull_srvsvc_NetFileCtr2(ndr, NDR_SCALARS|NDR_BUFFERS, r->ctr2));

2304

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ctr2_0, 0);

2305

}

2306

break;

2307

2308

case 3:

2309

if (r->ctr3) {

2310

_mem_save_ctr3_0 = NDR_PULL_GET_MEM_CTX(ndr);

2311

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

2312

NDR_CHECK(ndr_pull_srvsvc_NetFileCtr3(ndr, NDR_SCALARS|NDR_BUFFERS, r->ctr3));

2313

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ctr3_0, 0);

2314

}

2315

break;

2316

2317

default:

2318

break;

2319

2320

}

2321

}

2322

return NDR_ERR_SUCCESS;

2323

}

2324

2325

_PUBLIC_ void ndr_print_srvsvc_NetFileCtr(struct ndr_print *ndr, const char *name, const union srvsvc_NetFileCtr *r)

2326

{

2327

int level;

2328

level = ndr_print_get_switch_value(ndr, r);

2329

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

2330

switch (level) {

2331

case 2:

2332

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

2333

ndr->depth++;

2334

if (r->ctr2) {

2335

ndr_print_srvsvc_NetFileCtr2(ndr, "ctr2", r->ctr2);

2336

}

2337

ndr->depth--;

2338

break;

2339

2340

case 3:

2341

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

2342

ndr->depth++;

2343

if (r->ctr3) {

2344

ndr_print_srvsvc_NetFileCtr3(ndr, "ctr3", r->ctr3);

2345

}

2346

ndr->depth--;

2347

break;

2348

2349

default:

2350

break;

2351

2352

}

2353

}

2354

2355

static enum ndr_err_code ndr_push_srvsvc_NetFileInfoCtr(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetFileInfoCtr *r)

2356

{

2357

if (ndr_flags & NDR_SCALARS) {

2358

NDR_CHECK(ndr_push_align(ndr, 4));

2359

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

2360

NDR_CHECK(ndr_push_set_switch_value(ndr, &r->ctr, r->level));

2361

NDR_CHECK(ndr_push_srvsvc_NetFileCtr(ndr, NDR_SCALARS, &r->ctr));

2362

}

2363

if (ndr_flags & NDR_BUFFERS) {

2364

NDR_CHECK(ndr_push_srvsvc_NetFileCtr(ndr, NDR_BUFFERS, &r->ctr));

2365

}

2366

return NDR_ERR_SUCCESS;

2367

}

2368

2369

static enum ndr_err_code ndr_pull_srvsvc_NetFileInfoCtr(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetFileInfoCtr *r)

2370

{

2371

if (ndr_flags & NDR_SCALARS) {

2372

NDR_CHECK(ndr_pull_align(ndr, 4));

2373

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

2374

NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->ctr, r->level));

2375

NDR_CHECK(ndr_pull_srvsvc_NetFileCtr(ndr, NDR_SCALARS, &r->ctr));

2376

}

2377

if (ndr_flags & NDR_BUFFERS) {

2378

NDR_CHECK(ndr_pull_srvsvc_NetFileCtr(ndr, NDR_BUFFERS, &r->ctr));

2379

}

2380

return NDR_ERR_SUCCESS;

2381

}

2382

2383

_PUBLIC_ void ndr_print_srvsvc_NetFileInfoCtr(struct ndr_print *ndr, const char *name, const struct srvsvc_NetFileInfoCtr *r)

2384

{

2385

ndr_print_struct(ndr, name, "srvsvc_NetFileInfoCtr");

2386

ndr->depth++;

2387

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

2388

ndr_print_set_switch_value(ndr, &r->ctr, r->level);

2389

ndr_print_srvsvc_NetFileCtr(ndr, "ctr", &r->ctr);

2390

ndr->depth--;

2391

}

2392

2393

static enum ndr_err_code ndr_push_srvsvc_NetSessInfo0(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetSessInfo0 *r)

2394

{

2395

if (ndr_flags & NDR_SCALARS) {

2396

NDR_CHECK(ndr_push_align(ndr, 4));

2397

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

2398

}

2399

if (ndr_flags & NDR_BUFFERS) {

2400

if (r->client) {

2401

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->client, CH_UTF16)));

2402

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

2403

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->client, CH_UTF16)));

2404

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

2405

}

2406

}

2407

return NDR_ERR_SUCCESS;

2408

}

2409

2410

static enum ndr_err_code ndr_pull_srvsvc_NetSessInfo0(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetSessInfo0 *r)

2411

{

2412

uint32_t _ptr_client;

2413

TALLOC_CTX *_mem_save_client_0;

2414

if (ndr_flags & NDR_SCALARS) {

2415

NDR_CHECK(ndr_pull_align(ndr, 4));

2416

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_client));

2417

if (_ptr_client) {

2418

NDR_PULL_ALLOC(ndr, r->client);

2419

} else {

2420

r->client = NULL;

2421

}

2422

}

2423

if (ndr_flags & NDR_BUFFERS) {

2424

if (r->client) {

2425

_mem_save_client_0 = NDR_PULL_GET_MEM_CTX(ndr);

2426

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

2427

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

2428

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

2429

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

2430

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

2431

}

2432

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

2433

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

2434

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_client_0, 0);

2435

}

2436

}

2437

return NDR_ERR_SUCCESS;

2438

}

2439

2440

_PUBLIC_ void ndr_print_srvsvc_NetSessInfo0(struct ndr_print *ndr, const char *name, const struct srvsvc_NetSessInfo0 *r)

2441

{

2442

ndr_print_struct(ndr, name, "srvsvc_NetSessInfo0");

2443

ndr->depth++;

2444

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

2445

ndr->depth++;

2446

if (r->client) {

2447

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

2448

}

2449

ndr->depth--;

2450

ndr->depth--;

2451

}

2452

2453

static enum ndr_err_code ndr_push_srvsvc_NetSessCtr0(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetSessCtr0 *r)

2454

{

2455

uint32_t cntr_array_1;

2456

if (ndr_flags & NDR_SCALARS) {

2457

NDR_CHECK(ndr_push_align(ndr, 4));

2458

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

2459

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

2460

}

2461

if (ndr_flags & NDR_BUFFERS) {

2462

if (r->array) {

2463

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

2464

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

2465

NDR_CHECK(ndr_push_srvsvc_NetSessInfo0(ndr, NDR_SCALARS, &r->array[cntr_array_1]));

2466

}

2467

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

2468

NDR_CHECK(ndr_push_srvsvc_NetSessInfo0(ndr, NDR_BUFFERS, &r->array[cntr_array_1]));

2469

}

2470

}

2471

}

2472

return NDR_ERR_SUCCESS;

2473

}

2474

2475

static enum ndr_err_code ndr_pull_srvsvc_NetSessCtr0(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetSessCtr0 *r)

2476

{

2477

uint32_t _ptr_array;

2478

uint32_t cntr_array_1;

2479

TALLOC_CTX *_mem_save_array_0;

2480

TALLOC_CTX *_mem_save_array_1;

2481

if (ndr_flags & NDR_SCALARS) {

2482

NDR_CHECK(ndr_pull_align(ndr, 4));

2483

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

2484

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_array));

2485

if (_ptr_array) {

2486

NDR_PULL_ALLOC(ndr, r->array);

2487

} else {

2488

r->array = NULL;

2489

}

2490

}

2491

if (ndr_flags & NDR_BUFFERS) {

2492

if (r->array) {

2493

_mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);

2494

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

2495

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

2496

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

2497

_mem_save_array_1 = NDR_PULL_GET_MEM_CTX(ndr);

2498

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

2499

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

2500

NDR_CHECK(ndr_pull_srvsvc_NetSessInfo0(ndr, NDR_SCALARS, &r->array[cntr_array_1]));

2501

}

2502

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

2503

NDR_CHECK(ndr_pull_srvsvc_NetSessInfo0(ndr, NDR_BUFFERS, &r->array[cntr_array_1]));

2504

}

2505

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_1, 0);

2506

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);

2507

}

2508

if (r->array) {

2509

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

2510

}

2511

}

2512

return NDR_ERR_SUCCESS;

2513

}

2514

2515

_PUBLIC_ void ndr_print_srvsvc_NetSessCtr0(struct ndr_print *ndr, const char *name, const struct srvsvc_NetSessCtr0 *r)

2516

{

2517

uint32_t cntr_array_1;

2518

ndr_print_struct(ndr, name, "srvsvc_NetSessCtr0");

2519

ndr->depth++;

2520

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

2521

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

2522

ndr->depth++;

2523

if (r->array) {

2524

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

2525

ndr->depth++;

2526

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

2527

char *idx_1=NULL;

2528

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

2529

ndr_print_srvsvc_NetSessInfo0(ndr, "array", &r->array[cntr_array_1]);

2530

free(idx_1);

2531

}

2532

}

2533

ndr->depth--;

2534

}

2535

ndr->depth--;

2536

ndr->depth--;

2537

}

2538

2539

static enum ndr_err_code ndr_push_srvsvc_NetSessInfo1(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetSessInfo1 *r)

2540

{

2541

if (ndr_flags & NDR_SCALARS) {

2542

NDR_CHECK(ndr_push_align(ndr, 4));

2543

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

2544

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

2545

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

2546

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

2547

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

2548

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

2549

}

2550

if (ndr_flags & NDR_BUFFERS) {

2551

if (r->client) {

2552

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->client, CH_UTF16)));

2553

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

2554

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->client, CH_UTF16)));

2555

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

2556

}

2557

if (r->user) {

2558

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->user, CH_UTF16)));

2559

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

2560

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->user, CH_UTF16)));

2561

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

2562

}

2563

}

2564

return NDR_ERR_SUCCESS;

2565

}

2566

2567

static enum ndr_err_code ndr_pull_srvsvc_NetSessInfo1(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetSessInfo1 *r)

2568

{

2569

uint32_t _ptr_client;

2570

TALLOC_CTX *_mem_save_client_0;

2571

uint32_t _ptr_user;

2572

TALLOC_CTX *_mem_save_user_0;

2573

if (ndr_flags & NDR_SCALARS) {

2574

NDR_CHECK(ndr_pull_align(ndr, 4));

2575

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_client));

2576

if (_ptr_client) {

2577

NDR_PULL_ALLOC(ndr, r->client);

2578

} else {

2579

r->client = NULL;

2580

}

2581

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_user));

2582

if (_ptr_user) {

2583

NDR_PULL_ALLOC(ndr, r->user);

2584

} else {

2585

r->user = NULL;

2586

}

2587

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

2588

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

2589

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

2590

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

2591

}

2592

if (ndr_flags & NDR_BUFFERS) {

2593

if (r->client) {

2594

_mem_save_client_0 = NDR_PULL_GET_MEM_CTX(ndr);

2595

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

2596

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

2597

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

2598

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

2599

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

2600

}

2601

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

2602

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

2603

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_client_0, 0);

2604

}

2605

if (r->user) {

2606

_mem_save_user_0 = NDR_PULL_GET_MEM_CTX(ndr);

2607

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

2608

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

2609

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

2610

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

2611

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

2612

}

2613

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

2614

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

2615

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_0, 0);

2616

}

2617

}

2618

return NDR_ERR_SUCCESS;

2619

}

2620

2621

_PUBLIC_ void ndr_print_srvsvc_NetSessInfo1(struct ndr_print *ndr, const char *name, const struct srvsvc_NetSessInfo1 *r)

2622

{

2623

ndr_print_struct(ndr, name, "srvsvc_NetSessInfo1");

2624

ndr->depth++;

2625

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

2626

ndr->depth++;

2627

if (r->client) {

2628

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

2629

}

2630

ndr->depth--;

2631

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

2632

ndr->depth++;

2633

if (r->user) {

2634

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

2635

}

2636

ndr->depth--;

2637

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

2638

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

2639

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

2640

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

2641

ndr->depth--;

2642

}

2643

2644

static enum ndr_err_code ndr_push_srvsvc_NetSessCtr1(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetSessCtr1 *r)

2645

{

2646

uint32_t cntr_array_1;

2647

if (ndr_flags & NDR_SCALARS) {

2648

NDR_CHECK(ndr_push_align(ndr, 4));

2649

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

2650

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

2651

}

2652

if (ndr_flags & NDR_BUFFERS) {

2653

if (r->array) {

2654

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

2655

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

2656

NDR_CHECK(ndr_push_srvsvc_NetSessInfo1(ndr, NDR_SCALARS, &r->array[cntr_array_1]));

2657

}

2658

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

2659

NDR_CHECK(ndr_push_srvsvc_NetSessInfo1(ndr, NDR_BUFFERS, &r->array[cntr_array_1]));

2660

}

2661

}

2662

}

2663

return NDR_ERR_SUCCESS;

2664

}

2665

2666

static enum ndr_err_code ndr_pull_srvsvc_NetSessCtr1(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetSessCtr1 *r)

2667

{

2668

uint32_t _ptr_array;

2669

uint32_t cntr_array_1;

2670

TALLOC_CTX *_mem_save_array_0;

2671

TALLOC_CTX *_mem_save_array_1;

2672

if (ndr_flags & NDR_SCALARS) {

2673

NDR_CHECK(ndr_pull_align(ndr, 4));

2674

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

2675

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_array));

2676

if (_ptr_array) {

2677

NDR_PULL_ALLOC(ndr, r->array);

2678

} else {

2679

r->array = NULL;

2680

}

2681

}

2682

if (ndr_flags & NDR_BUFFERS) {

2683

if (r->array) {

2684

_mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);

2685

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

2686

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

2687

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

2688

_mem_save_array_1 = NDR_PULL_GET_MEM_CTX(ndr);

2689

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

2690

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

2691

NDR_CHECK(ndr_pull_srvsvc_NetSessInfo1(ndr, NDR_SCALARS, &r->array[cntr_array_1]));

2692

}

2693

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

2694

NDR_CHECK(ndr_pull_srvsvc_NetSessInfo1(ndr, NDR_BUFFERS, &r->array[cntr_array_1]));

2695

}

2696

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_1, 0);

2697

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);

2698

}

2699

if (r->array) {

2700

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

2701

}

2702

}

2703

return NDR_ERR_SUCCESS;

2704

}

2705

2706

_PUBLIC_ void ndr_print_srvsvc_NetSessCtr1(struct ndr_print *ndr, const char *name, const struct srvsvc_NetSessCtr1 *r)

2707

{

2708

uint32_t cntr_array_1;

2709

ndr_print_struct(ndr, name, "srvsvc_NetSessCtr1");

2710

ndr->depth++;

2711

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

2712

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

2713

ndr->depth++;

2714

if (r->array) {

2715

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

2716

ndr->depth++;

2717

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

2718

char *idx_1=NULL;

2719

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

2720

ndr_print_srvsvc_NetSessInfo1(ndr, "array", &r->array[cntr_array_1]);

2721

free(idx_1);

2722

}

2723

}

2724

ndr->depth--;

2725

}

2726

ndr->depth--;

2727

ndr->depth--;

2728

}

2729

2730

static enum ndr_err_code ndr_push_srvsvc_NetSessInfo2(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetSessInfo2 *r)

2731

{

2732

if (ndr_flags & NDR_SCALARS) {

2733

NDR_CHECK(ndr_push_align(ndr, 4));

2734

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

2735

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

2736

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

2737

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

2738

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

2739

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

2740

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

2741

}

2742

if (ndr_flags & NDR_BUFFERS) {

2743

if (r->client) {

2744

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->client, CH_UTF16)));

2745

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

2746

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->client, CH_UTF16)));

2747

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

2748

}

2749

if (r->user) {

2750

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->user, CH_UTF16)));

2751

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

2752

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->user, CH_UTF16)));

2753

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

2754

}

2755

if (r->client_type) {

2756

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->client_type, CH_UTF16)));

2757

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

2758

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->client_type, CH_UTF16)));

2759

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

2760

}

2761

}

2762

return NDR_ERR_SUCCESS;

2763

}

2764

2765

static enum ndr_err_code ndr_pull_srvsvc_NetSessInfo2(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetSessInfo2 *r)

2766

{

2767

uint32_t _ptr_client;

2768

TALLOC_CTX *_mem_save_client_0;

2769

uint32_t _ptr_user;

2770

TALLOC_CTX *_mem_save_user_0;

2771

uint32_t _ptr_client_type;

2772

TALLOC_CTX *_mem_save_client_type_0;

2773

if (ndr_flags & NDR_SCALARS) {

2774

NDR_CHECK(ndr_pull_align(ndr, 4));

2775

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_client));

2776

if (_ptr_client) {

2777

NDR_PULL_ALLOC(ndr, r->client);

2778

} else {

2779

r->client = NULL;

2780

}

2781

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_user));

2782

if (_ptr_user) {

2783

NDR_PULL_ALLOC(ndr, r->user);

2784

} else {

2785

r->user = NULL;

2786

}

2787

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

2788

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

2789

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

2790

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

2791

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_client_type));

2792

if (_ptr_client_type) {

2793

NDR_PULL_ALLOC(ndr, r->client_type);

2794

} else {

2795

r->client_type = NULL;

2796

}

2797

}

2798

if (ndr_flags & NDR_BUFFERS) {

2799

if (r->client) {

2800

_mem_save_client_0 = NDR_PULL_GET_MEM_CTX(ndr);

2801

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

2802

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

2803

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

2804

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

2805

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

2806

}

2807

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

2808

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

2809

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_client_0, 0);

2810

}

2811

if (r->user) {

2812

_mem_save_user_0 = NDR_PULL_GET_MEM_CTX(ndr);

2813

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

2814

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

2815

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

2816

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

2817

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

2818

}

2819

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

2820

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

2821

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_0, 0);

2822

}

2823

if (r->client_type) {

2824

_mem_save_client_type_0 = NDR_PULL_GET_MEM_CTX(ndr);

2825

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

2826

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

2827

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

2828

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

2829

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

2830

}

2831

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

2832

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

2833

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_client_type_0, 0);

2834

}

2835

}

2836

return NDR_ERR_SUCCESS;

2837

}

2838

2839

_PUBLIC_ void ndr_print_srvsvc_NetSessInfo2(struct ndr_print *ndr, const char *name, const struct srvsvc_NetSessInfo2 *r)

2840

{

2841

ndr_print_struct(ndr, name, "srvsvc_NetSessInfo2");

2842

ndr->depth++;

2843

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

2844

ndr->depth++;

2845

if (r->client) {

2846

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

2847

}

2848

ndr->depth--;

2849

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

2850

ndr->depth++;

2851

if (r->user) {

2852

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

2853

}

2854

ndr->depth--;

2855

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

2856

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

2857

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

2858

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

2859

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

2860

ndr->depth++;

2861

if (r->client_type) {

2862

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

2863

}

2864

ndr->depth--;

2865

ndr->depth--;

2866

}

2867

2868

static enum ndr_err_code ndr_push_srvsvc_NetSessCtr2(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetSessCtr2 *r)

2869

{

2870

uint32_t cntr_array_1;

2871

if (ndr_flags & NDR_SCALARS) {

2872

NDR_CHECK(ndr_push_align(ndr, 4));

2873

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

2874

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

2875

}

2876

if (ndr_flags & NDR_BUFFERS) {

2877

if (r->array) {

2878

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

2879

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

2880

NDR_CHECK(ndr_push_srvsvc_NetSessInfo2(ndr, NDR_SCALARS, &r->array[cntr_array_1]));

2881

}

2882

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

2883

NDR_CHECK(ndr_push_srvsvc_NetSessInfo2(ndr, NDR_BUFFERS, &r->array[cntr_array_1]));

2884

}

2885

}

2886

}

2887

return NDR_ERR_SUCCESS;

2888

}

2889

2890

static enum ndr_err_code ndr_pull_srvsvc_NetSessCtr2(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetSessCtr2 *r)

2891

{

2892

uint32_t _ptr_array;

2893

uint32_t cntr_array_1;

2894

TALLOC_CTX *_mem_save_array_0;

2895

TALLOC_CTX *_mem_save_array_1;

2896

if (ndr_flags & NDR_SCALARS) {

2897

NDR_CHECK(ndr_pull_align(ndr, 4));

2898

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

2899

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_array));

2900

if (_ptr_array) {

2901

NDR_PULL_ALLOC(ndr, r->array);

2902

} else {

2903

r->array = NULL;

2904

}

2905

}

2906

if (ndr_flags & NDR_BUFFERS) {

2907

if (r->array) {

2908

_mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);

2909

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

2910

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

2911

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

2912

_mem_save_array_1 = NDR_PULL_GET_MEM_CTX(ndr);

2913

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

2914

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

2915

NDR_CHECK(ndr_pull_srvsvc_NetSessInfo2(ndr, NDR_SCALARS, &r->array[cntr_array_1]));

2916

}

2917

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

2918

NDR_CHECK(ndr_pull_srvsvc_NetSessInfo2(ndr, NDR_BUFFERS, &r->array[cntr_array_1]));

2919

}

2920

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_1, 0);

2921

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);

2922

}

2923

if (r->array) {

2924

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

2925

}

2926

}

2927

return NDR_ERR_SUCCESS;

2928

}

2929

2930

_PUBLIC_ void ndr_print_srvsvc_NetSessCtr2(struct ndr_print *ndr, const char *name, const struct srvsvc_NetSessCtr2 *r)

2931

{

2932

uint32_t cntr_array_1;

2933

ndr_print_struct(ndr, name, "srvsvc_NetSessCtr2");

2934

ndr->depth++;

2935

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

2936

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

2937

ndr->depth++;

2938

if (r->array) {

2939

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

2940

ndr->depth++;

2941

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

2942

char *idx_1=NULL;

2943

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

2944

ndr_print_srvsvc_NetSessInfo2(ndr, "array", &r->array[cntr_array_1]);

2945

free(idx_1);

2946

}

2947

}

2948

ndr->depth--;

2949

}

2950

ndr->depth--;

2951

ndr->depth--;

2952

}

2953

2954

static enum ndr_err_code ndr_push_srvsvc_NetSessInfo10(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetSessInfo10 *r)

2955

{

2956

if (ndr_flags & NDR_SCALARS) {

2957

NDR_CHECK(ndr_push_align(ndr, 4));

2958

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

2959

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

2960

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

2961

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

2962

}

2963

if (ndr_flags & NDR_BUFFERS) {

2964

if (r->client) {

2965

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->client, CH_UTF16)));

2966

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

2967

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->client, CH_UTF16)));

2968

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

2969

}

2970

if (r->user) {

2971

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->user, CH_UTF16)));

2972

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

2973

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->user, CH_UTF16)));

2974

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

2975

}

2976

}

2977

return NDR_ERR_SUCCESS;

2978

}

2979

2980

static enum ndr_err_code ndr_pull_srvsvc_NetSessInfo10(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetSessInfo10 *r)

2981

{

2982

uint32_t _ptr_client;

2983

TALLOC_CTX *_mem_save_client_0;

2984

uint32_t _ptr_user;

2985

TALLOC_CTX *_mem_save_user_0;

2986

if (ndr_flags & NDR_SCALARS) {

2987

NDR_CHECK(ndr_pull_align(ndr, 4));

2988

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_client));

2989

if (_ptr_client) {

2990

NDR_PULL_ALLOC(ndr, r->client);

2991

} else {

2992

r->client = NULL;

2993

}

2994

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_user));

2995

if (_ptr_user) {

2996

NDR_PULL_ALLOC(ndr, r->user);

2997

} else {

2998

r->user = NULL;

2999

}

3000

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

3001

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

3002

}

3003

if (ndr_flags & NDR_BUFFERS) {

3004

if (r->client) {

3005

_mem_save_client_0 = NDR_PULL_GET_MEM_CTX(ndr);

3006

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

3007

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

3008

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

3009

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

3010

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

3011

}

3012

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

3013

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

3014

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_client_0, 0);

3015

}

3016

if (r->user) {

3017

_mem_save_user_0 = NDR_PULL_GET_MEM_CTX(ndr);

3018

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

3019

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

3020

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

3021

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

3022

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

3023

}

3024

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

3025

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

3026

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_0, 0);

3027

}

3028

}

3029

return NDR_ERR_SUCCESS;

3030

}

3031

3032

_PUBLIC_ void ndr_print_srvsvc_NetSessInfo10(struct ndr_print *ndr, const char *name, const struct srvsvc_NetSessInfo10 *r)

3033

{

3034

ndr_print_struct(ndr, name, "srvsvc_NetSessInfo10");

3035

ndr->depth++;

3036

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

3037

ndr->depth++;

3038

if (r->client) {

3039

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

3040

}

3041

ndr->depth--;

3042

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

3043

ndr->depth++;

3044

if (r->user) {

3045

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

3046

}

3047

ndr->depth--;

3048

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

3049

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

3050

ndr->depth--;

3051

}

3052

3053

static enum ndr_err_code ndr_push_srvsvc_NetSessCtr10(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetSessCtr10 *r)

3054

{

3055

uint32_t cntr_array_1;

3056

if (ndr_flags & NDR_SCALARS) {

3057

NDR_CHECK(ndr_push_align(ndr, 4));

3058

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

3059

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

3060

}

3061

if (ndr_flags & NDR_BUFFERS) {

3062

if (r->array) {

3063

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

3064

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

3065

NDR_CHECK(ndr_push_srvsvc_NetSessInfo10(ndr, NDR_SCALARS, &r->array[cntr_array_1]));

3066

}

3067

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

3068

NDR_CHECK(ndr_push_srvsvc_NetSessInfo10(ndr, NDR_BUFFERS, &r->array[cntr_array_1]));

3069

}

3070

}

3071

}

3072

return NDR_ERR_SUCCESS;

3073

}

3074

3075

static enum ndr_err_code ndr_pull_srvsvc_NetSessCtr10(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetSessCtr10 *r)

3076

{

3077

uint32_t _ptr_array;

3078

uint32_t cntr_array_1;

3079

TALLOC_CTX *_mem_save_array_0;

3080

TALLOC_CTX *_mem_save_array_1;

3081

if (ndr_flags & NDR_SCALARS) {

3082

NDR_CHECK(ndr_pull_align(ndr, 4));

3083

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

3084

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_array));

3085

if (_ptr_array) {

3086

NDR_PULL_ALLOC(ndr, r->array);

3087

} else {

3088

r->array = NULL;

3089

}

3090

}

3091

if (ndr_flags & NDR_BUFFERS) {

3092

if (r->array) {

3093

_mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);

3094

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

3095

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

3096

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

3097

_mem_save_array_1 = NDR_PULL_GET_MEM_CTX(ndr);

3098

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

3099

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

3100

NDR_CHECK(ndr_pull_srvsvc_NetSessInfo10(ndr, NDR_SCALARS, &r->array[cntr_array_1]));

3101

}

3102

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

3103

NDR_CHECK(ndr_pull_srvsvc_NetSessInfo10(ndr, NDR_BUFFERS, &r->array[cntr_array_1]));

3104

}

3105

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_1, 0);

3106

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);

3107

}

3108

if (r->array) {

3109

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

3110

}

3111

}

3112

return NDR_ERR_SUCCESS;

3113

}

3114

3115

_PUBLIC_ void ndr_print_srvsvc_NetSessCtr10(struct ndr_print *ndr, const char *name, const struct srvsvc_NetSessCtr10 *r)

3116

{

3117

uint32_t cntr_array_1;

3118

ndr_print_struct(ndr, name, "srvsvc_NetSessCtr10");

3119

ndr->depth++;

3120

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

3121

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

3122

ndr->depth++;

3123

if (r->array) {

3124

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

3125

ndr->depth++;

3126

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

3127

char *idx_1=NULL;

3128

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

3129

ndr_print_srvsvc_NetSessInfo10(ndr, "array", &r->array[cntr_array_1]);

3130

free(idx_1);

3131

}

3132

}

3133

ndr->depth--;

3134

}

3135

ndr->depth--;

3136

ndr->depth--;

3137

}

3138

3139

static enum ndr_err_code ndr_push_srvsvc_NetSessInfo502(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetSessInfo502 *r)

3140

{

3141

if (ndr_flags & NDR_SCALARS) {

3142

NDR_CHECK(ndr_push_align(ndr, 4));

3143

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

3144

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

3145

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

3146

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

3147

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

3148

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

3149

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

3150

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

3151

}

3152

if (ndr_flags & NDR_BUFFERS) {

3153

if (r->client) {

3154

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->client, CH_UTF16)));

3155

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

3156

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->client, CH_UTF16)));

3157

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

3158

}

3159

if (r->user) {

3160

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->user, CH_UTF16)));

3161

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

3162

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->user, CH_UTF16)));

3163

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

3164

}

3165

if (r->client_type) {

3166

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->client_type, CH_UTF16)));

3167

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

3168

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->client_type, CH_UTF16)));

3169

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

3170

}

3171

if (r->transport) {

3172

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->transport, CH_UTF16)));

3173

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

3174

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->transport, CH_UTF16)));

3175

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

3176

}

3177

}

3178

return NDR_ERR_SUCCESS;

3179

}

3180

3181

static enum ndr_err_code ndr_pull_srvsvc_NetSessInfo502(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetSessInfo502 *r)

3182

{

3183

uint32_t _ptr_client;

3184

TALLOC_CTX *_mem_save_client_0;

3185

uint32_t _ptr_user;

3186

TALLOC_CTX *_mem_save_user_0;

3187

uint32_t _ptr_client_type;

3188

TALLOC_CTX *_mem_save_client_type_0;

3189

uint32_t _ptr_transport;

3190

TALLOC_CTX *_mem_save_transport_0;

3191

if (ndr_flags & NDR_SCALARS) {

3192

NDR_CHECK(ndr_pull_align(ndr, 4));

3193

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_client));

3194

if (_ptr_client) {

3195

NDR_PULL_ALLOC(ndr, r->client);

3196

} else {

3197

r->client = NULL;

3198

}

3199

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_user));

3200

if (_ptr_user) {

3201

NDR_PULL_ALLOC(ndr, r->user);

3202

} else {

3203

r->user = NULL;

3204

}

3205

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

3206

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

3207

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

3208

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

3209

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_client_type));

3210

if (_ptr_client_type) {

3211

NDR_PULL_ALLOC(ndr, r->client_type);

3212

} else {

3213

r->client_type = NULL;

3214

}

3215

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_transport));

3216

if (_ptr_transport) {

3217

NDR_PULL_ALLOC(ndr, r->transport);

3218

} else {

3219

r->transport = NULL;

3220

}

3221

}

3222

if (ndr_flags & NDR_BUFFERS) {

3223

if (r->client) {

3224

_mem_save_client_0 = NDR_PULL_GET_MEM_CTX(ndr);

3225

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

3226

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

3227

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

3228

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

3229

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

3230

}

3231

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

3232

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

3233

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_client_0, 0);

3234

}

3235

if (r->user) {

3236

_mem_save_user_0 = NDR_PULL_GET_MEM_CTX(ndr);

3237

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

3238

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

3239

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

3240

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

3241

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

3242

}

3243

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

3244

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

3245

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_0, 0);

3246

}

3247

if (r->client_type) {

3248

_mem_save_client_type_0 = NDR_PULL_GET_MEM_CTX(ndr);

3249

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

3250

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

3251

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

3252

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

3253

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

3254

}

3255

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

3256

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

3257

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_client_type_0, 0);

3258

}

3259

if (r->transport) {

3260

_mem_save_transport_0 = NDR_PULL_GET_MEM_CTX(ndr);

3261

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

3262

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

3263

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

3264

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

3265

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

3266

}

3267

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

3268

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

3269

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_transport_0, 0);

3270

}

3271

}

3272

return NDR_ERR_SUCCESS;

3273

}

3274

3275

_PUBLIC_ void ndr_print_srvsvc_NetSessInfo502(struct ndr_print *ndr, const char *name, const struct srvsvc_NetSessInfo502 *r)

3276

{

3277

ndr_print_struct(ndr, name, "srvsvc_NetSessInfo502");

3278

ndr->depth++;

3279

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

3280

ndr->depth++;

3281

if (r->client) {

3282

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

3283

}

3284

ndr->depth--;

3285

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

3286

ndr->depth++;

3287

if (r->user) {

3288

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

3289

}

3290

ndr->depth--;

3291

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

3292

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

3293

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

3294

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

3295

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

3296

ndr->depth++;

3297

if (r->client_type) {

3298

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

3299

}

3300

ndr->depth--;

3301

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

3302

ndr->depth++;

3303

if (r->transport) {

3304

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

3305

}

3306

ndr->depth--;

3307

ndr->depth--;

3308

}

3309

3310

static enum ndr_err_code ndr_push_srvsvc_NetSessCtr502(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetSessCtr502 *r)

3311

{

3312

uint32_t cntr_array_1;

3313

if (ndr_flags & NDR_SCALARS) {

3314

NDR_CHECK(ndr_push_align(ndr, 4));

3315

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

3316

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

3317

}

3318

if (ndr_flags & NDR_BUFFERS) {

3319

if (r->array) {

3320

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

3321

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

3322

NDR_CHECK(ndr_push_srvsvc_NetSessInfo502(ndr, NDR_SCALARS, &r->array[cntr_array_1]));

3323

}

3324

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

3325

NDR_CHECK(ndr_push_srvsvc_NetSessInfo502(ndr, NDR_BUFFERS, &r->array[cntr_array_1]));

3326

}

3327

}

3328

}

3329

return NDR_ERR_SUCCESS;

3330

}

3331

3332

static enum ndr_err_code ndr_pull_srvsvc_NetSessCtr502(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetSessCtr502 *r)

3333

{

3334

uint32_t _ptr_array;

3335

uint32_t cntr_array_1;

3336

TALLOC_CTX *_mem_save_array_0;

3337

TALLOC_CTX *_mem_save_array_1;

3338

if (ndr_flags & NDR_SCALARS) {

3339

NDR_CHECK(ndr_pull_align(ndr, 4));

3340

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

3341

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_array));

3342

if (_ptr_array) {

3343

NDR_PULL_ALLOC(ndr, r->array);

3344

} else {

3345

r->array = NULL;

3346

}

3347

}

3348

if (ndr_flags & NDR_BUFFERS) {

3349

if (r->array) {

3350

_mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);

3351

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

3352

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

3353

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

3354

_mem_save_array_1 = NDR_PULL_GET_MEM_CTX(ndr);

3355

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

3356

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

3357

NDR_CHECK(ndr_pull_srvsvc_NetSessInfo502(ndr, NDR_SCALARS, &r->array[cntr_array_1]));

3358

}

3359

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

3360

NDR_CHECK(ndr_pull_srvsvc_NetSessInfo502(ndr, NDR_BUFFERS, &r->array[cntr_array_1]));

3361

}

3362

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_1, 0);

3363

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);

3364

}

3365

if (r->array) {

3366

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

3367

}

3368

}

3369

return NDR_ERR_SUCCESS;

3370

}

3371

3372

_PUBLIC_ void ndr_print_srvsvc_NetSessCtr502(struct ndr_print *ndr, const char *name, const struct srvsvc_NetSessCtr502 *r)

3373

{

3374

uint32_t cntr_array_1;

3375

ndr_print_struct(ndr, name, "srvsvc_NetSessCtr502");

3376

ndr->depth++;

3377

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

3378

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

3379

ndr->depth++;

3380

if (r->array) {

3381

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

3382

ndr->depth++;

3383

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

3384

char *idx_1=NULL;

3385

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

3386

ndr_print_srvsvc_NetSessInfo502(ndr, "array", &r->array[cntr_array_1]);

3387

free(idx_1);

3388

}

3389

}

3390

ndr->depth--;

3391

}

3392

ndr->depth--;

3393

ndr->depth--;

3394

}

3395

3396

static enum ndr_err_code ndr_push_srvsvc_NetSessCtr(struct ndr_push *ndr, int ndr_flags, const union srvsvc_NetSessCtr *r)

3397

{

3398

if (ndr_flags & NDR_SCALARS) {

3399

int level = ndr_push_get_switch_value(ndr, r);

3400

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

3401

switch (level) {

3402

case 0: {

3403

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

3404

break; }

3405

3406

case 1: {

3407

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

3408

break; }

3409

3410

case 2: {

3411

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

3412

break; }

3413

3414

case 10: {

3415

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

3416

break; }

3417

3418

case 502: {

3419

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

3420

break; }

3421

3422

default: {

3423

break; }

3424

3425

}

3426

}

3427

if (ndr_flags & NDR_BUFFERS) {

3428

int level = ndr_push_get_switch_value(ndr, r);

3429

switch (level) {

3430

case 0:

3431

if (r->ctr0) {

3432

NDR_CHECK(ndr_push_srvsvc_NetSessCtr0(ndr, NDR_SCALARS|NDR_BUFFERS, r->ctr0));

3433

}

3434

break;

3435

3436

case 1:

3437

if (r->ctr1) {

3438

NDR_CHECK(ndr_push_srvsvc_NetSessCtr1(ndr, NDR_SCALARS|NDR_BUFFERS, r->ctr1));

3439

}

3440

break;

3441

3442

case 2:

3443

if (r->ctr2) {

3444

NDR_CHECK(ndr_push_srvsvc_NetSessCtr2(ndr, NDR_SCALARS|NDR_BUFFERS, r->ctr2));

3445

}

3446

break;

3447

3448

case 10:

3449

if (r->ctr10) {

3450

NDR_CHECK(ndr_push_srvsvc_NetSessCtr10(ndr, NDR_SCALARS|NDR_BUFFERS, r->ctr10));

3451

}

3452

break;

3453

3454

case 502:

3455

if (r->ctr502) {

3456

NDR_CHECK(ndr_push_srvsvc_NetSessCtr502(ndr, NDR_SCALARS|NDR_BUFFERS, r->ctr502));

3457

}

3458

break;

3459

3460

default:

3461

break;

3462

3463

}

3464

}

3465

return NDR_ERR_SUCCESS;

3466

}

3467

3468

static enum ndr_err_code ndr_pull_srvsvc_NetSessCtr(struct ndr_pull *ndr, int ndr_flags, union srvsvc_NetSessCtr *r)

3469

{

3470

int level;

3471

uint32_t _level;

3472

TALLOC_CTX *_mem_save_ctr0_0;

3473

TALLOC_CTX *_mem_save_ctr1_0;

3474

TALLOC_CTX *_mem_save_ctr2_0;

3475

TALLOC_CTX *_mem_save_ctr10_0;

3476

TALLOC_CTX *_mem_save_ctr502_0;

3477

level = ndr_pull_get_switch_value(ndr, r);

3478

if (ndr_flags & NDR_SCALARS) {

3479

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

3480

if (_level != level) {

3481

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

3482

}

3483

switch (level) {

3484

case 0: {

3485

uint32_t _ptr_ctr0;

3486

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_ctr0));

3487

if (_ptr_ctr0) {

3488

NDR_PULL_ALLOC(ndr, r->ctr0);

3489

} else {

3490

r->ctr0 = NULL;

3491

}

3492

break; }

3493

3494

case 1: {

3495

uint32_t _ptr_ctr1;

3496

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_ctr1));

3497

if (_ptr_ctr1) {

3498

NDR_PULL_ALLOC(ndr, r->ctr1);

3499

} else {

3500

r->ctr1 = NULL;

3501

}

3502

break; }

3503

3504

case 2: {

3505

uint32_t _ptr_ctr2;

3506

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_ctr2));

3507

if (_ptr_ctr2) {

3508

NDR_PULL_ALLOC(ndr, r->ctr2);

3509

} else {

3510

r->ctr2 = NULL;

3511

}

3512

break; }

3513

3514

case 10: {

3515

uint32_t _ptr_ctr10;

3516

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_ctr10));

3517

if (_ptr_ctr10) {

3518

NDR_PULL_ALLOC(ndr, r->ctr10);

3519

} else {

3520

r->ctr10 = NULL;

3521

}

3522

break; }

3523

3524

case 502: {

3525

uint32_t _ptr_ctr502;

3526

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_ctr502));

3527

if (_ptr_ctr502) {

3528

NDR_PULL_ALLOC(ndr, r->ctr502);

3529

} else {

3530

r->ctr502 = NULL;

3531

}

3532

break; }

3533

3534

default: {

3535

break; }

3536

3537

}

3538

}

3539

if (ndr_flags & NDR_BUFFERS) {

3540

switch (level) {

3541

case 0:

3542

if (r->ctr0) {

3543

_mem_save_ctr0_0 = NDR_PULL_GET_MEM_CTX(ndr);

3544

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

3545

NDR_CHECK(ndr_pull_srvsvc_NetSessCtr0(ndr, NDR_SCALARS|NDR_BUFFERS, r->ctr0));

3546

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ctr0_0, 0);

3547

}

3548

break;

3549

3550

case 1:

3551

if (r->ctr1) {

3552

_mem_save_ctr1_0 = NDR_PULL_GET_MEM_CTX(ndr);

3553

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

3554

NDR_CHECK(ndr_pull_srvsvc_NetSessCtr1(ndr, NDR_SCALARS|NDR_BUFFERS, r->ctr1));

3555

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ctr1_0, 0);

3556

}

3557

break;

3558

3559

case 2:

3560

if (r->ctr2) {

3561

_mem_save_ctr2_0 = NDR_PULL_GET_MEM_CTX(ndr);

3562

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

3563

NDR_CHECK(ndr_pull_srvsvc_NetSessCtr2(ndr, NDR_SCALARS|NDR_BUFFERS, r->ctr2));

3564

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ctr2_0, 0);

3565

}

3566

break;

3567

3568

case 10:

3569

if (r->ctr10) {

3570

_mem_save_ctr10_0 = NDR_PULL_GET_MEM_CTX(ndr);

3571

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

3572

NDR_CHECK(ndr_pull_srvsvc_NetSessCtr10(ndr, NDR_SCALARS|NDR_BUFFERS, r->ctr10));

3573

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ctr10_0, 0);

3574

}

3575

break;

3576

3577

case 502:

3578

if (r->ctr502) {

3579

_mem_save_ctr502_0 = NDR_PULL_GET_MEM_CTX(ndr);

3580

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

3581

NDR_CHECK(ndr_pull_srvsvc_NetSessCtr502(ndr, NDR_SCALARS|NDR_BUFFERS, r->ctr502));

3582

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ctr502_0, 0);

3583

}

3584

break;

3585

3586

default:

3587

break;

3588

3589

}

3590

}

3591

return NDR_ERR_SUCCESS;

3592

}

3593

3594

_PUBLIC_ void ndr_print_srvsvc_NetSessCtr(struct ndr_print *ndr, const char *name, const union srvsvc_NetSessCtr *r)

3595

{

3596

int level;

3597

level = ndr_print_get_switch_value(ndr, r);

3598

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

3599

switch (level) {

3600

case 0:

3601

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

3602

ndr->depth++;

3603

if (r->ctr0) {

3604

ndr_print_srvsvc_NetSessCtr0(ndr, "ctr0", r->ctr0);

3605

}

3606

ndr->depth--;

3607

break;

3608

3609

case 1:

3610

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

3611

ndr->depth++;

3612

if (r->ctr1) {

3613

ndr_print_srvsvc_NetSessCtr1(ndr, "ctr1", r->ctr1);

3614

}

3615

ndr->depth--;

3616

break;

3617

3618

case 2:

3619

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

3620

ndr->depth++;

3621

if (r->ctr2) {

3622

ndr_print_srvsvc_NetSessCtr2(ndr, "ctr2", r->ctr2);

3623

}

3624

ndr->depth--;

3625

break;

3626

3627

case 10:

3628

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

3629

ndr->depth++;

3630

if (r->ctr10) {

3631

ndr_print_srvsvc_NetSessCtr10(ndr, "ctr10", r->ctr10);

3632

}

3633

ndr->depth--;

3634

break;

3635

3636

case 502:

3637

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

3638

ndr->depth++;

3639

if (r->ctr502) {

3640

ndr_print_srvsvc_NetSessCtr502(ndr, "ctr502", r->ctr502);

3641

}

3642

ndr->depth--;

3643

break;

3644

3645

default:

3646

break;

3647

3648

}

3649

}

3650

3651

static enum ndr_err_code ndr_push_srvsvc_NetSessInfoCtr(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetSessInfoCtr *r)

3652

{

3653

if (ndr_flags & NDR_SCALARS) {

3654

NDR_CHECK(ndr_push_align(ndr, 4));

3655

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

3656

NDR_CHECK(ndr_push_set_switch_value(ndr, &r->ctr, r->level));

3657

NDR_CHECK(ndr_push_srvsvc_NetSessCtr(ndr, NDR_SCALARS, &r->ctr));

3658

}

3659

if (ndr_flags & NDR_BUFFERS) {

3660

NDR_CHECK(ndr_push_srvsvc_NetSessCtr(ndr, NDR_BUFFERS, &r->ctr));

3661

}

3662

return NDR_ERR_SUCCESS;

3663

}

3664

3665

static enum ndr_err_code ndr_pull_srvsvc_NetSessInfoCtr(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetSessInfoCtr *r)

3666

{

3667

if (ndr_flags & NDR_SCALARS) {

3668

NDR_CHECK(ndr_pull_align(ndr, 4));

3669

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

3670

NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->ctr, r->level));

3671

NDR_CHECK(ndr_pull_srvsvc_NetSessCtr(ndr, NDR_SCALARS, &r->ctr));

3672

}

3673

if (ndr_flags & NDR_BUFFERS) {

3674

NDR_CHECK(ndr_pull_srvsvc_NetSessCtr(ndr, NDR_BUFFERS, &r->ctr));

3675

}

3676

return NDR_ERR_SUCCESS;

3677

}

3678

3679

_PUBLIC_ void ndr_print_srvsvc_NetSessInfoCtr(struct ndr_print *ndr, const char *name, const struct srvsvc_NetSessInfoCtr *r)

3680

{

3681

ndr_print_struct(ndr, name, "srvsvc_NetSessInfoCtr");

3682

ndr->depth++;

3683

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

3684

ndr_print_set_switch_value(ndr, &r->ctr, r->level);

3685

ndr_print_srvsvc_NetSessCtr(ndr, "ctr", &r->ctr);

3686

ndr->depth--;

3687

}

3688

3689

static enum ndr_err_code ndr_push_srvsvc_ShareType(struct ndr_push *ndr, int ndr_flags, enum srvsvc_ShareType r)

3690

{

3691

{

3692

uint32_t _flags_save_ENUM = ndr->flags;

3693

ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);

3694

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

3695

ndr->flags = _flags_save_ENUM;

3696

}

3697

return NDR_ERR_SUCCESS;

3698

}

3699

3700

static enum ndr_err_code ndr_pull_srvsvc_ShareType(struct ndr_pull *ndr, int ndr_flags, enum srvsvc_ShareType *r)

3701

{

3702

uint32_t v;

3703

{

3704

uint32_t _flags_save_ENUM = ndr->flags;

3705

ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);

3706

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

3707

*r = v;

3708

ndr->flags = _flags_save_ENUM;

3709

}

3710

return NDR_ERR_SUCCESS;

3711

}

3712

3713

_PUBLIC_ void ndr_print_srvsvc_ShareType(struct ndr_print *ndr, const char *name, enum srvsvc_ShareType r)

3714

{

3715

const char *val = NULL;

3716

3717

{

3718

uint32_t _flags_save_ENUM = ndr->flags;

3719

ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);

3720

switch (r) {

3721

case STYPE_DISKTREE: val = "STYPE_DISKTREE"; break;

3722

case STYPE_DISKTREE_TEMPORARY: val = "STYPE_DISKTREE_TEMPORARY"; break;

3723

case STYPE_DISKTREE_HIDDEN: val = "STYPE_DISKTREE_HIDDEN"; break;

3724

case STYPE_PRINTQ: val = "STYPE_PRINTQ"; break;

3725

case STYPE_PRINTQ_TEMPORARY: val = "STYPE_PRINTQ_TEMPORARY"; break;

3726

case STYPE_PRINTQ_HIDDEN: val = "STYPE_PRINTQ_HIDDEN"; break;

3727

case STYPE_DEVICE: val = "STYPE_DEVICE"; break;

3728

case STYPE_DEVICE_TEMPORARY: val = "STYPE_DEVICE_TEMPORARY"; break;

3729

case STYPE_DEVICE_HIDDEN: val = "STYPE_DEVICE_HIDDEN"; break;

3730

case STYPE_IPC: val = "STYPE_IPC"; break;

3731

case STYPE_IPC_TEMPORARY: val = "STYPE_IPC_TEMPORARY"; break;

3732

case STYPE_IPC_HIDDEN: val = "STYPE_IPC_HIDDEN"; break;

3733

}

3734

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

3735

ndr->flags = _flags_save_ENUM;

3736

}

3737

}

3738

3739

static enum ndr_err_code ndr_push_srvsvc_NetShareInfo0(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetShareInfo0 *r)

3740

{

3741

if (ndr_flags & NDR_SCALARS) {

3742

NDR_CHECK(ndr_push_align(ndr, 4));

3743

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

3744

}

3745

if (ndr_flags & NDR_BUFFERS) {

3746

if (r->name) {

3747

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->name, CH_UTF16)));

3748

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

3749

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->name, CH_UTF16)));

3750

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

3751

}

3752

}

3753

return NDR_ERR_SUCCESS;

3754

}

3755

3756

static enum ndr_err_code ndr_pull_srvsvc_NetShareInfo0(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetShareInfo0 *r)

3757

{

3758

uint32_t _ptr_name;

3759

TALLOC_CTX *_mem_save_name_0;

3760

if (ndr_flags & NDR_SCALARS) {

3761

NDR_CHECK(ndr_pull_align(ndr, 4));

3762

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_name));

3763

if (_ptr_name) {

3764

NDR_PULL_ALLOC(ndr, r->name);

3765

} else {

3766

r->name = NULL;

3767

}

3768

}

3769

if (ndr_flags & NDR_BUFFERS) {

3770

if (r->name) {

3771

_mem_save_name_0 = NDR_PULL_GET_MEM_CTX(ndr);

3772

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

3773

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

3774

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

3775

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

3776

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

3777

}

3778

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

3779

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

3780

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_name_0, 0);

3781

}

3782

}

3783

return NDR_ERR_SUCCESS;

3784

}

3785

3786

_PUBLIC_ void ndr_print_srvsvc_NetShareInfo0(struct ndr_print *ndr, const char *name, const struct srvsvc_NetShareInfo0 *r)

3787

{

3788

ndr_print_struct(ndr, name, "srvsvc_NetShareInfo0");

3789

ndr->depth++;

3790

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

3791

ndr->depth++;

3792

if (r->name) {

3793

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

3794

}

3795

ndr->depth--;

3796

ndr->depth--;

3797

}

3798

3799

static enum ndr_err_code ndr_push_srvsvc_NetShareCtr0(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetShareCtr0 *r)

3800

{

3801

uint32_t cntr_array_1;

3802

if (ndr_flags & NDR_SCALARS) {

3803

NDR_CHECK(ndr_push_align(ndr, 4));

3804

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

3805

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

3806

}

3807

if (ndr_flags & NDR_BUFFERS) {

3808

if (r->array) {

3809

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

3810

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

3811

NDR_CHECK(ndr_push_srvsvc_NetShareInfo0(ndr, NDR_SCALARS, &r->array[cntr_array_1]));

3812

}

3813

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

3814

NDR_CHECK(ndr_push_srvsvc_NetShareInfo0(ndr, NDR_BUFFERS, &r->array[cntr_array_1]));

3815

}

3816

}

3817

}

3818

return NDR_ERR_SUCCESS;

3819

}

3820

3821

static enum ndr_err_code ndr_pull_srvsvc_NetShareCtr0(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetShareCtr0 *r)

3822

{

3823

uint32_t _ptr_array;

3824

uint32_t cntr_array_1;

3825

TALLOC_CTX *_mem_save_array_0;

3826

TALLOC_CTX *_mem_save_array_1;

3827

if (ndr_flags & NDR_SCALARS) {

3828

NDR_CHECK(ndr_pull_align(ndr, 4));

3829

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

3830

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_array));

3831

if (_ptr_array) {

3832

NDR_PULL_ALLOC(ndr, r->array);

3833

} else {

3834

r->array = NULL;

3835

}

3836

}

3837

if (ndr_flags & NDR_BUFFERS) {

3838

if (r->array) {

3839

_mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);

3840

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

3841

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

3842

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

3843

_mem_save_array_1 = NDR_PULL_GET_MEM_CTX(ndr);

3844

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

3845

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

3846

NDR_CHECK(ndr_pull_srvsvc_NetShareInfo0(ndr, NDR_SCALARS, &r->array[cntr_array_1]));

3847

}

3848

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

3849

NDR_CHECK(ndr_pull_srvsvc_NetShareInfo0(ndr, NDR_BUFFERS, &r->array[cntr_array_1]));

3850

}

3851

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_1, 0);

3852

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);

3853

}

3854

if (r->array) {

3855

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

3856

}

3857

}

3858

return NDR_ERR_SUCCESS;

3859

}

3860

3861

_PUBLIC_ void ndr_print_srvsvc_NetShareCtr0(struct ndr_print *ndr, const char *name, const struct srvsvc_NetShareCtr0 *r)

3862

{

3863

uint32_t cntr_array_1;

3864

ndr_print_struct(ndr, name, "srvsvc_NetShareCtr0");

3865

ndr->depth++;

3866

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

3867

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

3868

ndr->depth++;

3869

if (r->array) {

3870

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

3871

ndr->depth++;

3872

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

3873

char *idx_1=NULL;

3874

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

3875

ndr_print_srvsvc_NetShareInfo0(ndr, "array", &r->array[cntr_array_1]);

3876

free(idx_1);

3877

}

3878

}

3879

ndr->depth--;

3880

}

3881

ndr->depth--;

3882

ndr->depth--;

3883

}

3884

3885

static enum ndr_err_code ndr_push_srvsvc_NetShareInfo1(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetShareInfo1 *r)

3886

{

3887

if (ndr_flags & NDR_SCALARS) {

3888

NDR_CHECK(ndr_push_align(ndr, 4));

3889

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

3890

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

3891

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

3892

}

3893

if (ndr_flags & NDR_BUFFERS) {

3894

if (r->name) {

3895

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->name, CH_UTF16)));

3896

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

3897

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->name, CH_UTF16)));

3898

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

3899

}

3900

if (r->comment) {

3901

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->comment, CH_UTF16)));

3902

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

3903

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->comment, CH_UTF16)));

3904

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

3905

}

3906

}

3907

return NDR_ERR_SUCCESS;

3908

}

3909

3910

static enum ndr_err_code ndr_pull_srvsvc_NetShareInfo1(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetShareInfo1 *r)

3911

{

3912

uint32_t _ptr_name;

3913

TALLOC_CTX *_mem_save_name_0;

3914

uint32_t _ptr_comment;

3915

TALLOC_CTX *_mem_save_comment_0;

3916

if (ndr_flags & NDR_SCALARS) {

3917

NDR_CHECK(ndr_pull_align(ndr, 4));

3918

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_name));

3919

if (_ptr_name) {

3920

NDR_PULL_ALLOC(ndr, r->name);

3921

} else {

3922

r->name = NULL;

3923

}

3924

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

3925

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_comment));

3926

if (_ptr_comment) {

3927

NDR_PULL_ALLOC(ndr, r->comment);

3928

} else {

3929

r->comment = NULL;

3930

}

3931

}

3932

if (ndr_flags & NDR_BUFFERS) {

3933

if (r->name) {

3934

_mem_save_name_0 = NDR_PULL_GET_MEM_CTX(ndr);

3935

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

3936

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

3937

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

3938

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

3939

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

3940

}

3941

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

3942

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

3943

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_name_0, 0);

3944

}

3945

if (r->comment) {

3946

_mem_save_comment_0 = NDR_PULL_GET_MEM_CTX(ndr);

3947

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

3948

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

3949

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

3950

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

3951

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

3952

}

3953

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

3954

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

3955

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_comment_0, 0);

3956

}

3957

}

3958

return NDR_ERR_SUCCESS;

3959

}

3960

3961

_PUBLIC_ void ndr_print_srvsvc_NetShareInfo1(struct ndr_print *ndr, const char *name, const struct srvsvc_NetShareInfo1 *r)

3962

{

3963

ndr_print_struct(ndr, name, "srvsvc_NetShareInfo1");

3964

ndr->depth++;

3965

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

3966

ndr->depth++;

3967

if (r->name) {

3968

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

3969

}

3970

ndr->depth--;

3971

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

3972

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

3973

ndr->depth++;

3974

if (r->comment) {

3975

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

3976

}

3977

ndr->depth--;

3978

ndr->depth--;

3979

}

3980

3981

static enum ndr_err_code ndr_push_srvsvc_NetShareCtr1(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetShareCtr1 *r)

3982

{

3983

uint32_t cntr_array_1;

3984

if (ndr_flags & NDR_SCALARS) {

3985

NDR_CHECK(ndr_push_align(ndr, 4));

3986

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

3987

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

3988

}

3989

if (ndr_flags & NDR_BUFFERS) {

3990

if (r->array) {

3991

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

3992

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

3993

NDR_CHECK(ndr_push_srvsvc_NetShareInfo1(ndr, NDR_SCALARS, &r->array[cntr_array_1]));

3994

}

3995

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

3996

NDR_CHECK(ndr_push_srvsvc_NetShareInfo1(ndr, NDR_BUFFERS, &r->array[cntr_array_1]));

3997

}

3998

}

3999

}

4000

return NDR_ERR_SUCCESS;

4001

}

4002

4003

static enum ndr_err_code ndr_pull_srvsvc_NetShareCtr1(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetShareCtr1 *r)

4004

{

4005

uint32_t _ptr_array;

4006

uint32_t cntr_array_1;

4007

TALLOC_CTX *_mem_save_array_0;

4008

TALLOC_CTX *_mem_save_array_1;

4009

if (ndr_flags & NDR_SCALARS) {

4010

NDR_CHECK(ndr_pull_align(ndr, 4));

4011

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

4012

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_array));

4013

if (_ptr_array) {

4014

NDR_PULL_ALLOC(ndr, r->array);

4015

} else {

4016

r->array = NULL;

4017

}

4018

}

4019

if (ndr_flags & NDR_BUFFERS) {

4020

if (r->array) {

4021

_mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);

4022

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

4023

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

4024

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

4025

_mem_save_array_1 = NDR_PULL_GET_MEM_CTX(ndr);

4026

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

4027

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

4028

NDR_CHECK(ndr_pull_srvsvc_NetShareInfo1(ndr, NDR_SCALARS, &r->array[cntr_array_1]));

4029

}

4030

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

4031

NDR_CHECK(ndr_pull_srvsvc_NetShareInfo1(ndr, NDR_BUFFERS, &r->array[cntr_array_1]));

4032

}

4033

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_1, 0);

4034

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);

4035

}

4036

if (r->array) {

4037

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

4038

}

4039

}

4040

return NDR_ERR_SUCCESS;

4041

}

4042

4043

_PUBLIC_ void ndr_print_srvsvc_NetShareCtr1(struct ndr_print *ndr, const char *name, const struct srvsvc_NetShareCtr1 *r)

4044

{

4045

uint32_t cntr_array_1;

4046

ndr_print_struct(ndr, name, "srvsvc_NetShareCtr1");

4047

ndr->depth++;

4048

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

4049

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

4050

ndr->depth++;

4051

if (r->array) {

4052

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

4053

ndr->depth++;

4054

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

4055

char *idx_1=NULL;

4056

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

4057

ndr_print_srvsvc_NetShareInfo1(ndr, "array", &r->array[cntr_array_1]);

4058

free(idx_1);

4059

}

4060

}

4061

ndr->depth--;

4062

}

4063

ndr->depth--;

4064

ndr->depth--;

4065

}

4066

4067

static enum ndr_err_code ndr_push_srvsvc_NetShareInfo2(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetShareInfo2 *r)

4068

{

4069

if (ndr_flags & NDR_SCALARS) {

4070

NDR_CHECK(ndr_push_align(ndr, 4));

4071

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

4072

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

4073

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

4074

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

4075

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

4076

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

4077

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

4078

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

4079

}

4080

if (ndr_flags & NDR_BUFFERS) {

4081

if (r->name) {

4082

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->name, CH_UTF16)));

4083

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

4084

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->name, CH_UTF16)));

4085

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

4086

}

4087

if (r->comment) {

4088

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->comment, CH_UTF16)));

4089

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

4090

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->comment, CH_UTF16)));

4091

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

4092

}

4093

if (r->path) {

4094

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->path, CH_UTF16)));

4095

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

4096

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->path, CH_UTF16)));

4097

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

4098

}

4099

if (r->password) {

4100

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->password, CH_UTF16)));

4101

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

4102

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->password, CH_UTF16)));

4103

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

4104

}

4105

}

4106

return NDR_ERR_SUCCESS;

4107

}

4108

4109

static enum ndr_err_code ndr_pull_srvsvc_NetShareInfo2(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetShareInfo2 *r)

4110

{

4111

uint32_t _ptr_name;

4112

TALLOC_CTX *_mem_save_name_0;

4113

uint32_t _ptr_comment;

4114

TALLOC_CTX *_mem_save_comment_0;

4115

uint32_t _ptr_path;

4116

TALLOC_CTX *_mem_save_path_0;

4117

uint32_t _ptr_password;

4118

TALLOC_CTX *_mem_save_password_0;

4119

if (ndr_flags & NDR_SCALARS) {

4120

NDR_CHECK(ndr_pull_align(ndr, 4));

4121

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_name));

4122

if (_ptr_name) {

4123

NDR_PULL_ALLOC(ndr, r->name);

4124

} else {

4125

r->name = NULL;

4126

}

4127

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

4128

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_comment));

4129

if (_ptr_comment) {

4130

NDR_PULL_ALLOC(ndr, r->comment);

4131

} else {

4132

r->comment = NULL;

4133

}

4134

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

4135

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

4136

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

4137

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_path));

4138

if (_ptr_path) {

4139

NDR_PULL_ALLOC(ndr, r->path);

4140

} else {

4141

r->path = NULL;

4142

}

4143

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_password));

4144

if (_ptr_password) {

4145

NDR_PULL_ALLOC(ndr, r->password);

4146

} else {

4147

r->password = NULL;

4148

}

4149

}

4150

if (ndr_flags & NDR_BUFFERS) {

4151

if (r->name) {

4152

_mem_save_name_0 = NDR_PULL_GET_MEM_CTX(ndr);

4153

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

4154

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

4155

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

4156

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

4157

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

4158

}

4159

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

4160

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

4161

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_name_0, 0);

4162

}

4163

if (r->comment) {

4164

_mem_save_comment_0 = NDR_PULL_GET_MEM_CTX(ndr);

4165

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

4166

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

4167

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

4168

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

4169

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

4170

}

4171

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

4172

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

4173

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_comment_0, 0);

4174

}

4175

if (r->path) {

4176

_mem_save_path_0 = NDR_PULL_GET_MEM_CTX(ndr);

4177

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

4178

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

4179

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

4180

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

4181

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

4182

}

4183

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

4184

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

4185

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_path_0, 0);

4186

}

4187

if (r->password) {

4188

_mem_save_password_0 = NDR_PULL_GET_MEM_CTX(ndr);

4189

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

4190

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

4191

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

4192

if (ndr_get_array_length(ndr, &r->password) > ndr_get_array_size(ndr, &r->password)) {

4193

return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->password), ndr_get_array_length(ndr, &r->password));

4194

}

4195

NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->password), sizeof(uint16_t)));

4196

NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->password, ndr_get_array_length(ndr, &r->password), sizeof(uint16_t), CH_UTF16));

4197

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_password_0, 0);

4198

}

4199

}

4200

return NDR_ERR_SUCCESS;

4201

}

4202

4203

_PUBLIC_ void ndr_print_srvsvc_NetShareInfo2(struct ndr_print *ndr, const char *name, const struct srvsvc_NetShareInfo2 *r)

4204

{

4205

ndr_print_struct(ndr, name, "srvsvc_NetShareInfo2");

4206

ndr->depth++;

4207

ndr_print_ptr(ndr, "name", r->name);

4208

ndr->depth++;

4209

if (r->name) {

4210

ndr_print_string(ndr, "name", r->name);

4211

}

4212

ndr->depth--;

4213

ndr_print_srvsvc_ShareType(ndr, "type", r->type);

4214

ndr_print_ptr(ndr, "comment", r->comment);

4215

ndr->depth++;

4216

if (r->comment) {

4217

ndr_print_string(ndr, "comment", r->comment);

4218

}

4219

ndr->depth--;

4220

ndr_print_uint32(ndr, "permissions", r->permissions);

4221

ndr_print_uint32(ndr, "max_users", r->max_users);

4222

ndr_print_uint32(ndr, "current_users", r->current_users);

4223

ndr_print_ptr(ndr, "path", r->path);

4224

ndr->depth++;

4225

if (r->path) {

4226

ndr_print_string(ndr, "path", r->path);

4227

}

4228

ndr->depth--;

4229

ndr_print_ptr(ndr, "password", r->password);

4230

ndr->depth++;

4231

if (r->password) {

4232

ndr_print_string(ndr, "password", r->password);

4233

}

4234

ndr->depth--;

4235

ndr->depth--;

4236

}

4237

4238

static enum ndr_err_code ndr_push_srvsvc_NetShareCtr2(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetShareCtr2 *r)

4239

{

4240

uint32_t cntr_array_1;

4241

if (ndr_flags & NDR_SCALARS) {

4242

NDR_CHECK(ndr_push_align(ndr, 4));

4243

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));

4244

NDR_CHECK(ndr_push_unique_ptr(ndr, r->array));

4245

}

4246

if (ndr_flags & NDR_BUFFERS) {

4247

if (r->array) {

4248

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));

4249

for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {

4250

NDR_CHECK(ndr_push_srvsvc_NetShareInfo2(ndr, NDR_SCALARS, &r->array[cntr_array_1]));

4251

}

4252

for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {

4253

NDR_CHECK(ndr_push_srvsvc_NetShareInfo2(ndr, NDR_BUFFERS, &r->array[cntr_array_1]));

4254

}

4255

}

4256

}

4257

return NDR_ERR_SUCCESS;

4258

}

4259

4260

static enum ndr_err_code ndr_pull_srvsvc_NetShareCtr2(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetShareCtr2 *r)

4261

{

4262

uint32_t _ptr_array;

4263

uint32_t cntr_array_1;

4264

TALLOC_CTX *_mem_save_array_0;

4265

TALLOC_CTX *_mem_save_array_1;

4266

if (ndr_flags & NDR_SCALARS) {

4267

NDR_CHECK(ndr_pull_align(ndr, 4));

4268

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));

4269

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_array));

4270

if (_ptr_array) {

4271

NDR_PULL_ALLOC(ndr, r->array);

4272

} else {

4273

r->array = NULL;

4274

}

4275

}

4276

if (ndr_flags & NDR_BUFFERS) {

4277

if (r->array) {

4278

_mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);

4279

NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);

4280

NDR_CHECK(ndr_pull_array_size(ndr, &r->array));

4281

NDR_PULL_ALLOC_N(ndr, r->array, ndr_get_array_size(ndr, &r->array));

4282

_mem_save_array_1 = NDR_PULL_GET_MEM_CTX(ndr);

4283

NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);

4284

for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {

4285

NDR_CHECK(ndr_pull_srvsvc_NetShareInfo2(ndr, NDR_SCALARS, &r->array[cntr_array_1]));

4286

}

4287

for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {

4288

NDR_CHECK(ndr_pull_srvsvc_NetShareInfo2(ndr, NDR_BUFFERS, &r->array[cntr_array_1]));

4289

}

4290

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_1, 0);

4291

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);

4292

}

4293

if (r->array) {

4294

NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->array, r->count));

4295

}

4296

}

4297

return NDR_ERR_SUCCESS;

4298

}

4299

4300

_PUBLIC_ void ndr_print_srvsvc_NetShareCtr2(struct ndr_print *ndr, const char *name, const struct srvsvc_NetShareCtr2 *r)

4301

{

4302

uint32_t cntr_array_1;

4303

ndr_print_struct(ndr, name, "srvsvc_NetShareCtr2");

4304

ndr->depth++;

4305

ndr_print_uint32(ndr, "count", r->count);

4306

ndr_print_ptr(ndr, "array", r->array);

4307

ndr->depth++;

4308

if (r->array) {

4309

ndr->print(ndr, "%s: ARRAY(%d)", "array", (int)r->count);

4310

ndr->depth++;

4311

for (cntr_array_1=0;cntr_array_1<r->count;cntr_array_1++) {

4312

char *idx_1=NULL;

4313

if (asprintf(&idx_1, "[%d]", cntr_array_1) != -1) {

4314

ndr_print_srvsvc_NetShareInfo2(ndr, "array", &r->array[cntr_array_1]);

4315

free(idx_1);

4316

}

4317

}

4318

ndr->depth--;

4319

}

4320

ndr->depth--;

4321

ndr->depth--;

4322

}

4323

4324

static enum ndr_err_code ndr_push_srvsvc_NetShareInfo501(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetShareInfo501 *r)

4325

{

4326

if (ndr_flags & NDR_SCALARS) {

4327

NDR_CHECK(ndr_push_align(ndr, 4));

4328

NDR_CHECK(ndr_push_unique_ptr(ndr, r->name));

4329

NDR_CHECK(ndr_push_srvsvc_ShareType(ndr, NDR_SCALARS, r->type));

4330

NDR_CHECK(ndr_push_unique_ptr(ndr, r->comment));

4331

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->csc_policy));

4332

}

4333

if (ndr_flags & NDR_BUFFERS) {

4334

if (r->name) {

4335

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->name, CH_UTF16)));

4336

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));

4337

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->name, CH_UTF16)));

4338

NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->name, ndr_charset_length(r->name, CH_UTF16), sizeof(uint16_t), CH_UTF16));

4339

}

4340

if (r->comment) {

4341

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->comment, CH_UTF16)));

4342

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));

4343

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->comment, CH_UTF16)));

4344

NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->comment, ndr_charset_length(r->comment, CH_UTF16), sizeof(uint16_t), CH_UTF16));

4345

}

4346

}

4347

return NDR_ERR_SUCCESS;

4348

}

4349

4350

static enum ndr_err_code ndr_pull_srvsvc_NetShareInfo501(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetShareInfo501 *r)

4351

{

4352

uint32_t _ptr_name;

4353

TALLOC_CTX *_mem_save_name_0;

4354

uint32_t _ptr_comment;

4355

TALLOC_CTX *_mem_save_comment_0;

4356

if (ndr_flags & NDR_SCALARS) {

4357

NDR_CHECK(ndr_pull_align(ndr, 4));

4358

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_name));

4359

if (_ptr_name) {

4360

NDR_PULL_ALLOC(ndr, r->name);

4361

} else {

4362

r->name = NULL;

4363

}

4364

NDR_CHECK(ndr_pull_srvsvc_ShareType(ndr, NDR_SCALARS, &r->type));

4365

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_comment));

4366

if (_ptr_comment) {

4367

NDR_PULL_ALLOC(ndr, r->comment);

4368

} else {

4369

r->comment = NULL;

4370

}

4371

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->csc_policy));

4372

}

4373

if (ndr_flags & NDR_BUFFERS) {

4374

if (r->name) {

4375

_mem_save_name_0 = NDR_PULL_GET_MEM_CTX(ndr);

4376

NDR_PULL_SET_MEM_CTX(ndr, r->name, 0);

4377

NDR_CHECK(ndr_pull_array_size(ndr, &r->name));

4378

NDR_CHECK(ndr_pull_array_length(ndr, &r->name));

4379

if (ndr_get_array_length(ndr, &r->name) > ndr_get_array_size(ndr, &r->name)) {

4380

return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->name), ndr_get_array_length(ndr, &r->name));

4381

}

4382

NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->name), sizeof(uint16_t)));

4383

NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->name, ndr_get_array_length(ndr, &r->name), sizeof(uint16_t), CH_UTF16));

4384

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_name_0, 0);

4385

}

4386

if (r->comment) {

4387

_mem_save_comment_0 = NDR_PULL_GET_MEM_CTX(ndr);

4388

NDR_PULL_SET_MEM_CTX(ndr, r->comment, 0);

4389

NDR_CHECK(ndr_pull_array_size(ndr, &r->comment));

4390

NDR_CHECK(ndr_pull_array_length(ndr, &r->comment));

4391

if (ndr_get_array_length(ndr, &r->comment) > ndr_get_array_size(ndr, &r->comment)) {

4392

return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->comment), ndr_get_array_length(ndr, &r->comment));

4393

}

4394

NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->comment), sizeof(uint16_t)));

4395

NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->comment, ndr_get_array_length(ndr, &r->comment), sizeof(uint16_t), CH_UTF16));

4396

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_comment_0, 0);

4397

}

4398

}

4399

return NDR_ERR_SUCCESS;

4400

}

4401

4402

_PUBLIC_ void ndr_print_srvsvc_NetShareInfo501(struct ndr_print *ndr, const char *name, const struct srvsvc_NetShareInfo501 *r)

4403

{

4404

ndr_print_struct(ndr, name, "srvsvc_NetShareInfo501");

4405

ndr->depth++;

4406

ndr_print_ptr(ndr, "name", r->name);

4407

ndr->depth++;

4408

if (r->name) {

4409

ndr_print_string(ndr, "name", r->name);

4410

}

4411

ndr->depth--;

4412

ndr_print_srvsvc_ShareType(ndr, "type", r->type);

4413

ndr_print_ptr(ndr, "comment", r->comment);

4414

ndr->depth++;

4415

if (r->comment) {

4416

ndr_print_string(ndr, "comment", r->comment);

4417

}

4418

ndr->depth--;

4419

ndr_print_uint32(ndr, "csc_policy", r->csc_policy);

4420

ndr->depth--;

4421

}

4422

4423

static enum ndr_err_code ndr_push_srvsvc_NetShareCtr501(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetShareCtr501 *r)

4424

{

4425

uint32_t cntr_array_1;

4426

if (ndr_flags & NDR_SCALARS) {

4427

NDR_CHECK(ndr_push_align(ndr, 4));

4428

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));

4429

NDR_CHECK(ndr_push_unique_ptr(ndr, r->array));

4430

}

4431

if (ndr_flags & NDR_BUFFERS) {

4432

if (r->array) {

4433

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));

4434

for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {

4435

NDR_CHECK(ndr_push_srvsvc_NetShareInfo501(ndr, NDR_SCALARS, &r->array[cntr_array_1]));

4436

}

4437

for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {

4438

NDR_CHECK(ndr_push_srvsvc_NetShareInfo501(ndr, NDR_BUFFERS, &r->array[cntr_array_1]));

4439

}

4440

}

4441

}

4442

return NDR_ERR_SUCCESS;

4443

}

4444

4445

static enum ndr_err_code ndr_pull_srvsvc_NetShareCtr501(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetShareCtr501 *r)

4446

{

4447

uint32_t _ptr_array;

4448

uint32_t cntr_array_1;

4449

TALLOC_CTX *_mem_save_array_0;

4450

TALLOC_CTX *_mem_save_array_1;

4451

if (ndr_flags & NDR_SCALARS) {

4452

NDR_CHECK(ndr_pull_align(ndr, 4));

4453

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));

4454

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_array));

4455

if (_ptr_array) {

4456

NDR_PULL_ALLOC(ndr, r->array);

4457

} else {

4458

r->array = NULL;

4459

}

4460

}

4461

if (ndr_flags & NDR_BUFFERS) {

4462

if (r->array) {

4463

_mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);

4464

NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);

4465

NDR_CHECK(ndr_pull_array_size(ndr, &r->array));

4466

NDR_PULL_ALLOC_N(ndr, r->array, ndr_get_array_size(ndr, &r->array));

4467

_mem_save_array_1 = NDR_PULL_GET_MEM_CTX(ndr);

4468

NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);

4469

for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {

4470

NDR_CHECK(ndr_pull_srvsvc_NetShareInfo501(ndr, NDR_SCALARS, &r->array[cntr_array_1]));

4471

}

4472

for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {

4473

NDR_CHECK(ndr_pull_srvsvc_NetShareInfo501(ndr, NDR_BUFFERS, &r->array[cntr_array_1]));

4474

}

4475

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_1, 0);

4476

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);

4477

}

4478

if (r->array) {

4479

NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->array, r->count));

4480

}

4481

}

4482

return NDR_ERR_SUCCESS;

4483

}

4484

4485

_PUBLIC_ void ndr_print_srvsvc_NetShareCtr501(struct ndr_print *ndr, const char *name, const struct srvsvc_NetShareCtr501 *r)

4486

{

4487

uint32_t cntr_array_1;

4488

ndr_print_struct(ndr, name, "srvsvc_NetShareCtr501");

4489

ndr->depth++;

4490

ndr_print_uint32(ndr, "count", r->count);

4491

ndr_print_ptr(ndr, "array", r->array);

4492

ndr->depth++;

4493

if (r->array) {

4494

ndr->print(ndr, "%s: ARRAY(%d)", "array", (int)r->count);

4495

ndr->depth++;

4496

for (cntr_array_1=0;cntr_array_1<r->count;cntr_array_1++) {

4497

char *idx_1=NULL;

4498

if (asprintf(&idx_1, "[%d]", cntr_array_1) != -1) {

4499

ndr_print_srvsvc_NetShareInfo501(ndr, "array", &r->array[cntr_array_1]);

4500

free(idx_1);

4501

}

4502

}

4503

ndr->depth--;

4504

}

4505

ndr->depth--;

4506

ndr->depth--;

4507

}

4508

4509

static enum ndr_err_code ndr_push_srvsvc_NetShareInfo502(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetShareInfo502 *r)

4510

{

4511

if (ndr_flags & NDR_SCALARS) {

4512

NDR_CHECK(ndr_push_align(ndr, 4));

4513

NDR_CHECK(ndr_push_unique_ptr(ndr, r->name));

4514

NDR_CHECK(ndr_push_srvsvc_ShareType(ndr, NDR_SCALARS, r->type));

4515

NDR_CHECK(ndr_push_unique_ptr(ndr, r->comment));

4516

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->permissions));

4517

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->max_users));

4518

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->current_users));

4519

NDR_CHECK(ndr_push_unique_ptr(ndr, r->path));

4520

NDR_CHECK(ndr_push_unique_ptr(ndr, r->password));

4521

NDR_CHECK(ndr_push_sec_desc_buf(ndr, NDR_SCALARS, &r->sd_buf));

4522

}

4523

if (ndr_flags & NDR_BUFFERS) {

4524

if (r->name) {

4525

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->name, CH_UTF16)));

4526

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));

4527

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->name, CH_UTF16)));

4528

NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->name, ndr_charset_length(r->name, CH_UTF16), sizeof(uint16_t), CH_UTF16));

4529

}

4530

if (r->comment) {

4531

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->comment, CH_UTF16)));

4532

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));

4533

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->comment, CH_UTF16)));

4534

NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->comment, ndr_charset_length(r->comment, CH_UTF16), sizeof(uint16_t), CH_UTF16));

4535

}

4536

if (r->path) {

4537

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->path, CH_UTF16)));

4538

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));

4539

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->path, CH_UTF16)));

4540

NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->path, ndr_charset_length(r->path, CH_UTF16), sizeof(uint16_t), CH_UTF16));

4541

}

4542

if (r->password) {

4543

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->password, CH_UTF16)));

4544

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));

4545

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->password, CH_UTF16)));

4546

NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->password, ndr_charset_length(r->password, CH_UTF16), sizeof(uint16_t), CH_UTF16));

4547

}

4548

NDR_CHECK(ndr_push_sec_desc_buf(ndr, NDR_BUFFERS, &r->sd_buf));

4549

}

4550

return NDR_ERR_SUCCESS;

4551

}

4552

4553

static enum ndr_err_code ndr_pull_srvsvc_NetShareInfo502(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetShareInfo502 *r)

4554

{

4555

uint32_t _ptr_name;

4556

TALLOC_CTX *_mem_save_name_0;

4557

uint32_t _ptr_comment;

4558

TALLOC_CTX *_mem_save_comment_0;

4559

uint32_t _ptr_path;

4560

TALLOC_CTX *_mem_save_path_0;

4561

uint32_t _ptr_password;

4562

TALLOC_CTX *_mem_save_password_0;

4563

if (ndr_flags & NDR_SCALARS) {

4564

NDR_CHECK(ndr_pull_align(ndr, 4));

4565

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_name));

4566

if (_ptr_name) {

4567

NDR_PULL_ALLOC(ndr, r->name);

4568

} else {

4569

r->name = NULL;

4570

}

4571

NDR_CHECK(ndr_pull_srvsvc_ShareType(ndr, NDR_SCALARS, &r->type));

4572

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_comment));

4573

if (_ptr_comment) {

4574

NDR_PULL_ALLOC(ndr, r->comment);

4575

} else {

4576

r->comment = NULL;

4577

}

4578

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->permissions));

4579

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->max_users));

4580

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->current_users));

4581

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_path));

4582

if (_ptr_path) {

4583

NDR_PULL_ALLOC(ndr, r->path);

4584

} else {

4585

r->path = NULL;

4586

}

4587

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_password));

4588

if (_ptr_password) {

4589

NDR_PULL_ALLOC(ndr, r->password);

4590

} else {

4591

r->password = NULL;

4592

}

4593

NDR_CHECK(ndr_pull_sec_desc_buf(ndr, NDR_SCALARS, &r->sd_buf));

4594

}

4595

if (ndr_flags & NDR_BUFFERS) {

4596

if (r->name) {

4597

_mem_save_name_0 = NDR_PULL_GET_MEM_CTX(ndr);

4598

NDR_PULL_SET_MEM_CTX(ndr, r->name, 0);

4599

NDR_CHECK(ndr_pull_array_size(ndr, &r->name));

4600

NDR_CHECK(ndr_pull_array_length(ndr, &r->name));

4601

if (ndr_get_array_length(ndr, &r->name) > ndr_get_array_size(ndr, &r->name)) {

4602

return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->name), ndr_get_array_length(ndr, &r->name));

4603

}

4604

NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->name), sizeof(uint16_t)));

4605

NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->name, ndr_get_array_length(ndr, &r->name), sizeof(uint16_t), CH_UTF16));

4606

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_name_0, 0);

4607

}

4608

if (r->comment) {

4609

_mem_save_comment_0 = NDR_PULL_GET_MEM_CTX(ndr);

4610

NDR_PULL_SET_MEM_CTX(ndr, r->comment, 0);

4611

NDR_CHECK(ndr_pull_array_size(ndr, &r->comment));

4612

NDR_CHECK(ndr_pull_array_length(ndr, &r->comment));

4613

if (ndr_get_array_length(ndr, &r->comment) > ndr_get_array_size(ndr, &r->comment)) {

4614

return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->comment), ndr_get_array_length(ndr, &r->comment));

4615

}

4616

NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->comment), sizeof(uint16_t)));

4617

NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->comment, ndr_get_array_length(ndr, &r->comment), sizeof(uint16_t), CH_UTF16));

4618

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_comment_0, 0);

4619

}

4620

if (r->path) {

4621

_mem_save_path_0 = NDR_PULL_GET_MEM_CTX(ndr);

4622

NDR_PULL_SET_MEM_CTX(ndr, r->path, 0);

4623

NDR_CHECK(ndr_pull_array_size(ndr, &r->path));

4624

NDR_CHECK(ndr_pull_array_length(ndr, &r->path));

4625

if (ndr_get_array_length(ndr, &r->path) > ndr_get_array_size(ndr, &r->path)) {

4626

return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->path), ndr_get_array_length(ndr, &r->path));

4627

}

4628

NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->path), sizeof(uint16_t)));

4629

NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->path, ndr_get_array_length(ndr, &r->path), sizeof(uint16_t), CH_UTF16));

4630

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_path_0, 0);

4631

}

4632

if (r->password) {

4633

_mem_save_password_0 = NDR_PULL_GET_MEM_CTX(ndr);

4634

NDR_PULL_SET_MEM_CTX(ndr, r->password, 0);

4635

NDR_CHECK(ndr_pull_array_size(ndr, &r->password));

4636

NDR_CHECK(ndr_pull_array_length(ndr, &r->password));

4637

if (ndr_get_array_length(ndr, &r->password) > ndr_get_array_size(ndr, &r->password)) {

4638

return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->password), ndr_get_array_length(ndr, &r->password));

4639

}

4640

NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->password), sizeof(uint16_t)));

4641

NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->password, ndr_get_array_length(ndr, &r->password), sizeof(uint16_t), CH_UTF16));

4642

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_password_0, 0);

4643

}

4644

NDR_CHECK(ndr_pull_sec_desc_buf(ndr, NDR_BUFFERS, &r->sd_buf));

4645

}

4646

return NDR_ERR_SUCCESS;

4647

}

4648

4649

_PUBLIC_ void ndr_print_srvsvc_NetShareInfo502(struct ndr_print *ndr, const char *name, const struct srvsvc_NetShareInfo502 *r)

4650

{

4651

ndr_print_struct(ndr, name, "srvsvc_NetShareInfo502");

4652

ndr->depth++;

4653

ndr_print_ptr(ndr, "name", r->name);

4654

ndr->depth++;

4655

if (r->name) {

4656

ndr_print_string(ndr, "name", r->name);

4657

}

4658

ndr->depth--;

4659

ndr_print_srvsvc_ShareType(ndr, "type", r->type);

4660

ndr_print_ptr(ndr, "comment", r->comment);

4661

ndr->depth++;

4662

if (r->comment) {

4663

ndr_print_string(ndr, "comment", r->comment);

4664

}

4665

ndr->depth--;

4666

ndr_print_uint32(ndr, "permissions", r->permissions);

4667

ndr_print_uint32(ndr, "max_users", r->max_users);

4668

ndr_print_uint32(ndr, "current_users", r->current_users);

4669

ndr_print_ptr(ndr, "path", r->path);

4670

ndr->depth++;

4671

if (r->path) {

4672

ndr_print_string(ndr, "path", r->path);

4673

}

4674

ndr->depth--;

4675

ndr_print_ptr(ndr, "password", r->password);

4676

ndr->depth++;

4677

if (r->password) {

4678

ndr_print_string(ndr, "password", r->password);

4679

}

4680

ndr->depth--;

4681

ndr_print_sec_desc_buf(ndr, "sd_buf", &r->sd_buf);

4682

ndr->depth--;

4683

}

4684

4685

static enum ndr_err_code ndr_push_srvsvc_NetShareCtr502(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetShareCtr502 *r)

4686

{

4687

uint32_t cntr_array_1;

4688

if (ndr_flags & NDR_SCALARS) {

4689

NDR_CHECK(ndr_push_align(ndr, 4));

4690

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));

4691

NDR_CHECK(ndr_push_unique_ptr(ndr, r->array));

4692

}

4693

if (ndr_flags & NDR_BUFFERS) {

4694

if (r->array) {

4695

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));

4696

for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {

4697

NDR_CHECK(ndr_push_srvsvc_NetShareInfo502(ndr, NDR_SCALARS, &r->array[cntr_array_1]));

4698

}

4699

for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {

4700

NDR_CHECK(ndr_push_srvsvc_NetShareInfo502(ndr, NDR_BUFFERS, &r->array[cntr_array_1]));

4701

}

4702

}

4703

}

4704

return NDR_ERR_SUCCESS;

4705

}

4706

4707

static enum ndr_err_code ndr_pull_srvsvc_NetShareCtr502(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetShareCtr502 *r)

4708

{

4709

uint32_t _ptr_array;

4710

uint32_t cntr_array_1;

4711

TALLOC_CTX *_mem_save_array_0;

4712

TALLOC_CTX *_mem_save_array_1;

4713

if (ndr_flags & NDR_SCALARS) {

4714

NDR_CHECK(ndr_pull_align(ndr, 4));

4715

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));

4716

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_array));

4717

if (_ptr_array) {

4718

NDR_PULL_ALLOC(ndr, r->array);

4719

} else {

4720

r->array = NULL;

4721

}

4722

}

4723

if (ndr_flags & NDR_BUFFERS) {

4724

if (r->array) {

4725

_mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);

4726

NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);

4727

NDR_CHECK(ndr_pull_array_size(ndr, &r->array));

4728

NDR_PULL_ALLOC_N(ndr, r->array, ndr_get_array_size(ndr, &r->array));

4729

_mem_save_array_1 = NDR_PULL_GET_MEM_CTX(ndr);

4730

NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);

4731

for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {

4732

NDR_CHECK(ndr_pull_srvsvc_NetShareInfo502(ndr, NDR_SCALARS, &r->array[cntr_array_1]));

4733

}

4734

for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {

4735

NDR_CHECK(ndr_pull_srvsvc_NetShareInfo502(ndr, NDR_BUFFERS, &r->array[cntr_array_1]));

4736

}

4737

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_1, 0);

4738

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);

4739

}

4740

if (r->array) {

4741

NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->array, r->count));

4742

}

4743

}

4744

return NDR_ERR_SUCCESS;

4745

}

4746

4747

_PUBLIC_ void ndr_print_srvsvc_NetShareCtr502(struct ndr_print *ndr, const char *name, const struct srvsvc_NetShareCtr502 *r)

4748

{

4749

uint32_t cntr_array_1;

4750

ndr_print_struct(ndr, name, "srvsvc_NetShareCtr502");

4751

ndr->depth++;

4752

ndr_print_uint32(ndr, "count", r->count);

4753

ndr_print_ptr(ndr, "array", r->array);

4754

ndr->depth++;

4755

if (r->array) {

4756

ndr->print(ndr, "%s: ARRAY(%d)", "array", (int)r->count);

4757

ndr->depth++;

4758

for (cntr_array_1=0;cntr_array_1<r->count;cntr_array_1++) {

4759

char *idx_1=NULL;

4760

if (asprintf(&idx_1, "[%d]", cntr_array_1) != -1) {

4761

ndr_print_srvsvc_NetShareInfo502(ndr, "array", &r->array[cntr_array_1]);

4762

free(idx_1);

4763

}

4764

}

4765

ndr->depth--;

4766

}

4767

ndr->depth--;

4768

ndr->depth--;

4769

}

4770

4771

static enum ndr_err_code ndr_push_srvsvc_NetShareInfo1004(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetShareInfo1004 *r)

4772

{

4773

if (ndr_flags & NDR_SCALARS) {

4774

NDR_CHECK(ndr_push_align(ndr, 4));

4775

NDR_CHECK(ndr_push_unique_ptr(ndr, r->comment));

4776

}

4777

if (ndr_flags & NDR_BUFFERS) {

4778

if (r->comment) {

4779

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->comment, CH_UTF16)));

4780

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));

4781

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->comment, CH_UTF16)));

4782

NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->comment, ndr_charset_length(r->comment, CH_UTF16), sizeof(uint16_t), CH_UTF16));

4783

}

4784

}

4785

return NDR_ERR_SUCCESS;

4786

}

4787

4788

static enum ndr_err_code ndr_pull_srvsvc_NetShareInfo1004(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetShareInfo1004 *r)

4789

{

4790

uint32_t _ptr_comment;

4791

TALLOC_CTX *_mem_save_comment_0;

4792

if (ndr_flags & NDR_SCALARS) {

4793

NDR_CHECK(ndr_pull_align(ndr, 4));

4794

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_comment));

4795

if (_ptr_comment) {

4796

NDR_PULL_ALLOC(ndr, r->comment);

4797

} else {

4798

r->comment = NULL;

4799

}

4800

}

4801

if (ndr_flags & NDR_BUFFERS) {

4802

if (r->comment) {

4803

_mem_save_comment_0 = NDR_PULL_GET_MEM_CTX(ndr);

4804

NDR_PULL_SET_MEM_CTX(ndr, r->comment, 0);

4805

NDR_CHECK(ndr_pull_array_size(ndr, &r->comment));

4806

NDR_CHECK(ndr_pull_array_length(ndr, &r->comment));

4807

if (ndr_get_array_length(ndr, &r->comment) > ndr_get_array_size(ndr, &r->comment)) {

4808

return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->comment), ndr_get_array_length(ndr, &r->comment));

4809

}

4810

NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->comment), sizeof(uint16_t)));

4811

NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->comment, ndr_get_array_length(ndr, &r->comment), sizeof(uint16_t), CH_UTF16));

4812

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_comment_0, 0);

4813

}

4814

}

4815

return NDR_ERR_SUCCESS;

4816

}

4817

4818

_PUBLIC_ void ndr_print_srvsvc_NetShareInfo1004(struct ndr_print *ndr, const char *name, const struct srvsvc_NetShareInfo1004 *r)

4819

{

4820

ndr_print_struct(ndr, name, "srvsvc_NetShareInfo1004");

4821

ndr->depth++;

4822

ndr_print_ptr(ndr, "comment", r->comment);

4823

ndr->depth++;

4824

if (r->comment) {

4825

ndr_print_string(ndr, "comment", r->comment);

4826

}

4827

ndr->depth--;

4828

ndr->depth--;

4829

}

4830

4831

static enum ndr_err_code ndr_push_srvsvc_NetShareCtr1004(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetShareCtr1004 *r)

4832

{

4833

uint32_t cntr_array_1;

4834

if (ndr_flags & NDR_SCALARS) {

4835

NDR_CHECK(ndr_push_align(ndr, 4));

4836

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));

4837

NDR_CHECK(ndr_push_unique_ptr(ndr, r->array));

4838

}

4839

if (ndr_flags & NDR_BUFFERS) {

4840

if (r->array) {

4841

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));

4842

for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {

4843

NDR_CHECK(ndr_push_srvsvc_NetShareInfo1004(ndr, NDR_SCALARS, &r->array[cntr_array_1]));

4844

}

4845

for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {

4846

NDR_CHECK(ndr_push_srvsvc_NetShareInfo1004(ndr, NDR_BUFFERS, &r->array[cntr_array_1]));

4847

}

4848

}

4849

}

4850

return NDR_ERR_SUCCESS;

4851

}

4852

4853

static enum ndr_err_code ndr_pull_srvsvc_NetShareCtr1004(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetShareCtr1004 *r)

4854

{

4855

uint32_t _ptr_array;

4856

uint32_t cntr_array_1;

4857

TALLOC_CTX *_mem_save_array_0;

4858

TALLOC_CTX *_mem_save_array_1;

4859

if (ndr_flags & NDR_SCALARS) {

4860

NDR_CHECK(ndr_pull_align(ndr, 4));

4861

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));

4862

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_array));

4863

if (_ptr_array) {

4864

NDR_PULL_ALLOC(ndr, r->array);

4865

} else {

4866

r->array = NULL;

4867

}

4868

}

4869

if (ndr_flags & NDR_BUFFERS) {

4870

if (r->array) {

4871

_mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);

4872

NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);

4873

NDR_CHECK(ndr_pull_array_size(ndr, &r->array));

4874

NDR_PULL_ALLOC_N(ndr, r->array, ndr_get_array_size(ndr, &r->array));

4875

_mem_save_array_1 = NDR_PULL_GET_MEM_CTX(ndr);

4876

NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);

4877

for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {

4878

NDR_CHECK(ndr_pull_srvsvc_NetShareInfo1004(ndr, NDR_SCALARS, &r->array[cntr_array_1]));

4879

}

4880

for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {

4881

NDR_CHECK(ndr_pull_srvsvc_NetShareInfo1004(ndr, NDR_BUFFERS, &r->array[cntr_array_1]));

4882

}

4883

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_1, 0);

4884

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);

4885

}

4886

if (r->array) {

4887

NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->array, r->count));

4888

}

4889

}

4890

return NDR_ERR_SUCCESS;

4891

}

4892

4893

_PUBLIC_ void ndr_print_srvsvc_NetShareCtr1004(struct ndr_print *ndr, const char *name, const struct srvsvc_NetShareCtr1004 *r)

4894

{

4895

uint32_t cntr_array_1;

4896

ndr_print_struct(ndr, name, "srvsvc_NetShareCtr1004");

4897

ndr->depth++;

4898

ndr_print_uint32(ndr, "count", r->count);

4899

ndr_print_ptr(ndr, "array", r->array);

4900

ndr->depth++;

4901

if (r->array) {

4902

ndr->print(ndr, "%s: ARRAY(%d)", "array", (int)r->count);

4903

ndr->depth++;

4904

for (cntr_array_1=0;cntr_array_1<r->count;cntr_array_1++) {

4905

char *idx_1=NULL;

4906

if (asprintf(&idx_1, "[%d]", cntr_array_1) != -1) {

4907

ndr_print_srvsvc_NetShareInfo1004(ndr, "array", &r->array[cntr_array_1]);

4908

free(idx_1);

4909

}

4910

}

4911

ndr->depth--;

4912

}

4913

ndr->depth--;

4914

ndr->depth--;

4915

}

4916

4917

static enum ndr_err_code ndr_push_NetShareInfo1005Flags(struct ndr_push *ndr, int ndr_flags, uint32_t r)

4918

{

4919

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));

4920

return NDR_ERR_SUCCESS;

4921

}

4922

4923

static enum ndr_err_code ndr_pull_NetShareInfo1005Flags(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)

4924

{

4925

uint32_t v;

4926

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));

4927

*r = v;

4928

return NDR_ERR_SUCCESS;

4929

}

4930

4931

_PUBLIC_ void ndr_print_NetShareInfo1005Flags(struct ndr_print *ndr, const char *name, uint32_t r)

4932

{

4933

ndr_print_uint32(ndr, name, r);

4934

ndr->depth++;

4935

ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SHARE_1005_IN_DFS", SHARE_1005_IN_DFS, r);

4936

ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SHARE_1005_DFS_ROOT", SHARE_1005_DFS_ROOT, r);

4937

ndr->depth--;

4938

}

4939

4940

static enum ndr_err_code ndr_push_srvsvc_NetShareInfo1005(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetShareInfo1005 *r)

4941

{

4942

if (ndr_flags & NDR_SCALARS) {

4943

NDR_CHECK(ndr_push_align(ndr, 4));

4944

NDR_CHECK(ndr_push_NetShareInfo1005Flags(ndr, NDR_SCALARS, r->dfs_flags));

4945

}

4946

if (ndr_flags & NDR_BUFFERS) {

4947

}

4948

return NDR_ERR_SUCCESS;

4949

}

4950

4951

static enum ndr_err_code ndr_pull_srvsvc_NetShareInfo1005(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetShareInfo1005 *r)

4952

{

4953

if (ndr_flags & NDR_SCALARS) {

4954

NDR_CHECK(ndr_pull_align(ndr, 4));

4955

NDR_CHECK(ndr_pull_NetShareInfo1005Flags(ndr, NDR_SCALARS, &r->dfs_flags));

4956

}

4957

if (ndr_flags & NDR_BUFFERS) {

4958

}

4959

return NDR_ERR_SUCCESS;

4960

}

4961

4962

_PUBLIC_ void ndr_print_srvsvc_NetShareInfo1005(struct ndr_print *ndr, const char *name, const struct srvsvc_NetShareInfo1005 *r)

4963

{

4964

ndr_print_struct(ndr, name, "srvsvc_NetShareInfo1005");

4965

ndr->depth++;

4966

ndr_print_NetShareInfo1005Flags(ndr, "dfs_flags", r->dfs_flags);

4967

ndr->depth--;

4968

}

4969

4970

static enum ndr_err_code ndr_push_srvsvc_NetShareCtr1005(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetShareCtr1005 *r)

4971

{

4972

uint32_t cntr_array_1;

4973

if (ndr_flags & NDR_SCALARS) {

4974

NDR_CHECK(ndr_push_align(ndr, 4));

4975

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));

4976

NDR_CHECK(ndr_push_unique_ptr(ndr, r->array));

4977

}

4978

if (ndr_flags & NDR_BUFFERS) {

4979

if (r->array) {

4980

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));

4981

for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {

4982

NDR_CHECK(ndr_push_srvsvc_NetShareInfo1005(ndr, NDR_SCALARS, &r->array[cntr_array_1]));

4983

}

4984

}

4985

}

4986

return NDR_ERR_SUCCESS;

4987

}

4988

4989

static enum ndr_err_code ndr_pull_srvsvc_NetShareCtr1005(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetShareCtr1005 *r)

4990

{

4991

uint32_t _ptr_array;

4992

uint32_t cntr_array_1;

4993

TALLOC_CTX *_mem_save_array_0;

4994

TALLOC_CTX *_mem_save_array_1;

4995

if (ndr_flags & NDR_SCALARS) {

4996

NDR_CHECK(ndr_pull_align(ndr, 4));

4997

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));

4998

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_array));

4999

if (_ptr_array) {

5000

NDR_PULL_ALLOC(ndr, r->array);

5001

} else {

5002

r->array = NULL;

5003

}

5004

}

5005

if (ndr_flags & NDR_BUFFERS) {

5006

if (r->array) {

5007

_mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);

5008

NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);

5009

NDR_CHECK(ndr_pull_array_size(ndr, &r->array));

5010

NDR_PULL_ALLOC_N(ndr, r->array, ndr_get_array_size(ndr, &r->array));

5011

_mem_save_array_1 = NDR_PULL_GET_MEM_CTX(ndr);

5012

NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);

5013

for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {

5014

NDR_CHECK(ndr_pull_srvsvc_NetShareInfo1005(ndr, NDR_SCALARS, &r->array[cntr_array_1]));

5015

}

5016

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_1, 0);

5017

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);

5018

}

5019

if (r->array) {

5020

NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->array, r->count));

5021

}

5022

}

5023

return NDR_ERR_SUCCESS;

5024

}

5025

5026

_PUBLIC_ void ndr_print_srvsvc_NetShareCtr1005(struct ndr_print *ndr, const char *name, const struct srvsvc_NetShareCtr1005 *r)

5027

{

5028

uint32_t cntr_array_1;

5029

ndr_print_struct(ndr, name, "srvsvc_NetShareCtr1005");

5030

ndr->depth++;

5031

ndr_print_uint32(ndr, "count", r->count);

5032

ndr_print_ptr(ndr, "array", r->array);

5033

ndr->depth++;

5034

if (r->array) {

5035

ndr->print(ndr, "%s: ARRAY(%d)", "array", (int)r->count);

5036

ndr->depth++;

5037

for (cntr_array_1=0;cntr_array_1<r->count;cntr_array_1++) {

5038

char *idx_1=NULL;

5039

if (asprintf(&idx_1, "[%d]", cntr_array_1) != -1) {

5040

ndr_print_srvsvc_NetShareInfo1005(ndr, "array", &r->array[cntr_array_1]);

5041

free(idx_1);

5042

}

5043

}

5044

ndr->depth--;

5045

}

5046

ndr->depth--;

5047

ndr->depth--;

5048

}

5049

5050

static enum ndr_err_code ndr_push_srvsvc_NetShareInfo1006(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetShareInfo1006 *r)

5051

{

5052

if (ndr_flags & NDR_SCALARS) {

5053

NDR_CHECK(ndr_push_align(ndr, 4));

5054

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->max_users));

5055

}

5056

if (ndr_flags & NDR_BUFFERS) {

5057

}

5058

return NDR_ERR_SUCCESS;

5059

}

5060

5061

static enum ndr_err_code ndr_pull_srvsvc_NetShareInfo1006(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetShareInfo1006 *r)

5062

{

5063

if (ndr_flags & NDR_SCALARS) {

5064

NDR_CHECK(ndr_pull_align(ndr, 4));

5065

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->max_users));

5066

}

5067

if (ndr_flags & NDR_BUFFERS) {

5068

}

5069

return NDR_ERR_SUCCESS;

5070

}

5071

5072

_PUBLIC_ void ndr_print_srvsvc_NetShareInfo1006(struct ndr_print *ndr, const char *name, const struct srvsvc_NetShareInfo1006 *r)

5073

{

5074

ndr_print_struct(ndr, name, "srvsvc_NetShareInfo1006");

5075

ndr->depth++;

5076

ndr_print_uint32(ndr, "max_users", r->max_users);

5077

ndr->depth--;

5078

}

5079

5080

static enum ndr_err_code ndr_push_srvsvc_NetShareCtr1006(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetShareCtr1006 *r)

5081

{

5082

uint32_t cntr_array_1;

5083

if (ndr_flags & NDR_SCALARS) {

5084

NDR_CHECK(ndr_push_align(ndr, 4));

5085

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));

5086

NDR_CHECK(ndr_push_unique_ptr(ndr, r->array));

5087

}

5088

if (ndr_flags & NDR_BUFFERS) {

5089

if (r->array) {

5090

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));

5091

for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {

5092

NDR_CHECK(ndr_push_srvsvc_NetShareInfo1006(ndr, NDR_SCALARS, &r->array[cntr_array_1]));

5093

}

5094

}

5095

}

5096

return NDR_ERR_SUCCESS;

5097

}

5098

5099

static enum ndr_err_code ndr_pull_srvsvc_NetShareCtr1006(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetShareCtr1006 *r)

5100

{

5101

uint32_t _ptr_array;

5102

uint32_t cntr_array_1;

5103

TALLOC_CTX *_mem_save_array_0;

5104

TALLOC_CTX *_mem_save_array_1;

5105

if (ndr_flags & NDR_SCALARS) {

5106

NDR_CHECK(ndr_pull_align(ndr, 4));

5107

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));

5108

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_array));

5109

if (_ptr_array) {

5110

NDR_PULL_ALLOC(ndr, r->array);

5111

} else {

5112

r->array = NULL;

5113

}

5114

}

5115

if (ndr_flags & NDR_BUFFERS) {

5116

if (r->array) {

5117

_mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);

5118

NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);

5119

NDR_CHECK(ndr_pull_array_size(ndr, &r->array));

5120

NDR_PULL_ALLOC_N(ndr, r->array, ndr_get_array_size(ndr, &r->array));

5121

_mem_save_array_1 = NDR_PULL_GET_MEM_CTX(ndr);

5122

NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);

5123

for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {

5124

NDR_CHECK(ndr_pull_srvsvc_NetShareInfo1006(ndr, NDR_SCALARS, &r->array[cntr_array_1]));

5125

}

5126

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_1, 0);

5127

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);

5128

}

5129

if (r->array) {

5130

NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->array, r->count));

5131

}

5132

}

5133

return NDR_ERR_SUCCESS;

5134

}

5135

5136

_PUBLIC_ void ndr_print_srvsvc_NetShareCtr1006(struct ndr_print *ndr, const char *name, const struct srvsvc_NetShareCtr1006 *r)

5137

{

5138

uint32_t cntr_array_1;

5139

ndr_print_struct(ndr, name, "srvsvc_NetShareCtr1006");

5140

ndr->depth++;

5141

ndr_print_uint32(ndr, "count", r->count);

5142

ndr_print_ptr(ndr, "array", r->array);

5143

ndr->depth++;

5144

if (r->array) {

5145

ndr->print(ndr, "%s: ARRAY(%d)", "array", (int)r->count);

5146

ndr->depth++;

5147

for (cntr_array_1=0;cntr_array_1<r->count;cntr_array_1++) {

5148

char *idx_1=NULL;

5149

if (asprintf(&idx_1, "[%d]", cntr_array_1) != -1) {

5150

ndr_print_srvsvc_NetShareInfo1006(ndr, "array", &r->array[cntr_array_1]);

5151

free(idx_1);

5152

}

5153

}

5154

ndr->depth--;

5155

}

5156

ndr->depth--;

5157

ndr->depth--;

5158

}

5159

5160

static enum ndr_err_code ndr_push_srvsvc_NetShareInfo1007(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetShareInfo1007 *r)

5161

{

5162

if (ndr_flags & NDR_SCALARS) {

5163

NDR_CHECK(ndr_push_align(ndr, 4));

5164

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->flags));

5165

NDR_CHECK(ndr_push_unique_ptr(ndr, r->alternate_directory_name));

5166

}

5167

if (ndr_flags & NDR_BUFFERS) {

5168

if (r->alternate_directory_name) {

5169

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->alternate_directory_name, CH_UTF16)));

5170

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));

5171

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->alternate_directory_name, CH_UTF16)));

5172

NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->alternate_directory_name, ndr_charset_length(r->alternate_directory_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));

5173

}

5174

}

5175

return NDR_ERR_SUCCESS;

5176

}

5177

5178

static enum ndr_err_code ndr_pull_srvsvc_NetShareInfo1007(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetShareInfo1007 *r)

5179

{

5180

uint32_t _ptr_alternate_directory_name;

5181

TALLOC_CTX *_mem_save_alternate_directory_name_0;

5182

if (ndr_flags & NDR_SCALARS) {

5183

NDR_CHECK(ndr_pull_align(ndr, 4));

5184

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->flags));

5185

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_alternate_directory_name));

5186

if (_ptr_alternate_directory_name) {

5187

NDR_PULL_ALLOC(ndr, r->alternate_directory_name);

5188

} else {

5189

r->alternate_directory_name = NULL;

5190

}

5191

}

5192

if (ndr_flags & NDR_BUFFERS) {

5193

if (r->alternate_directory_name) {

5194

_mem_save_alternate_directory_name_0 = NDR_PULL_GET_MEM_CTX(ndr);

5195

NDR_PULL_SET_MEM_CTX(ndr, r->alternate_directory_name, 0);

5196

NDR_CHECK(ndr_pull_array_size(ndr, &r->alternate_directory_name));

5197

NDR_CHECK(ndr_pull_array_length(ndr, &r->alternate_directory_name));

5198

if (ndr_get_array_length(ndr, &r->alternate_directory_name) > ndr_get_array_size(ndr, &r->alternate_directory_name)) {

5199

return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->alternate_directory_name), ndr_get_array_length(ndr, &r->alternate_directory_name));

5200

}

5201

NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->alternate_directory_name), sizeof(uint16_t)));

5202

NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->alternate_directory_name, ndr_get_array_length(ndr, &r->alternate_directory_name), sizeof(uint16_t), CH_UTF16));

5203

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_alternate_directory_name_0, 0);

5204

}

5205

}

5206

return NDR_ERR_SUCCESS;

5207

}

5208

5209

_PUBLIC_ void ndr_print_srvsvc_NetShareInfo1007(struct ndr_print *ndr, const char *name, const struct srvsvc_NetShareInfo1007 *r)

5210

{

5211

ndr_print_struct(ndr, name, "srvsvc_NetShareInfo1007");

5212

ndr->depth++;

5213

ndr_print_uint32(ndr, "flags", r->flags);

5214

ndr_print_ptr(ndr, "alternate_directory_name", r->alternate_directory_name);

5215

ndr->depth++;

5216

if (r->alternate_directory_name) {

5217

ndr_print_string(ndr, "alternate_directory_name", r->alternate_directory_name);

5218

}

5219

ndr->depth--;

5220

ndr->depth--;

5221

}

5222

5223

static enum ndr_err_code ndr_push_srvsvc_NetShareCtr1007(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetShareCtr1007 *r)

5224

{

5225

uint32_t cntr_array_1;

5226

if (ndr_flags & NDR_SCALARS) {

5227

NDR_CHECK(ndr_push_align(ndr, 4));

5228

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));

5229

NDR_CHECK(ndr_push_unique_ptr(ndr, r->array));

5230

}

5231

if (ndr_flags & NDR_BUFFERS) {

5232

if (r->array) {

5233

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));

5234

for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {

5235

NDR_CHECK(ndr_push_srvsvc_NetShareInfo1007(ndr, NDR_SCALARS, &r->array[cntr_array_1]));

5236

}

5237

for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {

5238

NDR_CHECK(ndr_push_srvsvc_NetShareInfo1007(ndr, NDR_BUFFERS, &r->array[cntr_array_1]));

5239

}

5240

}

5241

}

5242

return NDR_ERR_SUCCESS;

5243

}

5244

5245

static enum ndr_err_code ndr_pull_srvsvc_NetShareCtr1007(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetShareCtr1007 *r)

5246

{

5247

uint32_t _ptr_array;

5248

uint32_t cntr_array_1;

5249

TALLOC_CTX *_mem_save_array_0;

5250

TALLOC_CTX *_mem_save_array_1;

5251

if (ndr_flags & NDR_SCALARS) {

5252

NDR_CHECK(ndr_pull_align(ndr, 4));

5253

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));

5254

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_array));

5255

if (_ptr_array) {

5256

NDR_PULL_ALLOC(ndr, r->array);

5257

} else {

5258

r->array = NULL;

5259

}

5260

}

5261

if (ndr_flags & NDR_BUFFERS) {

5262

if (r->array) {

5263

_mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);

5264

NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);

5265

NDR_CHECK(ndr_pull_array_size(ndr, &r->array));

5266

NDR_PULL_ALLOC_N(ndr, r->array, ndr_get_array_size(ndr, &r->array));

5267

_mem_save_array_1 = NDR_PULL_GET_MEM_CTX(ndr);

5268

NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);

5269

for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {

5270

NDR_CHECK(ndr_pull_srvsvc_NetShareInfo1007(ndr, NDR_SCALARS, &r->array[cntr_array_1]));

5271

}

5272

for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {

5273

NDR_CHECK(ndr_pull_srvsvc_NetShareInfo1007(ndr, NDR_BUFFERS, &r->array[cntr_array_1]));

5274

}

5275

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_1, 0);

5276

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);

5277

}

5278

if (r->array) {

5279

NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->array, r->count));

5280

}

5281

}

5282

return NDR_ERR_SUCCESS;

5283

}

5284

5285

_PUBLIC_ void ndr_print_srvsvc_NetShareCtr1007(struct ndr_print *ndr, const char *name, const struct srvsvc_NetShareCtr1007 *r)

5286

{

5287

uint32_t cntr_array_1;

5288

ndr_print_struct(ndr, name, "srvsvc_NetShareCtr1007");

5289

ndr->depth++;

5290

ndr_print_uint32(ndr, "count", r->count);

5291

ndr_print_ptr(ndr, "array", r->array);

5292

ndr->depth++;

5293

if (r->array) {

5294

ndr->print(ndr, "%s: ARRAY(%d)", "array", (int)r->count);

5295

ndr->depth++;

5296

for (cntr_array_1=0;cntr_array_1<r->count;cntr_array_1++) {

5297

char *idx_1=NULL;

5298

if (asprintf(&idx_1, "[%d]", cntr_array_1) != -1) {

5299

ndr_print_srvsvc_NetShareInfo1007(ndr, "array", &r->array[cntr_array_1]);

5300

free(idx_1);

5301

}

5302

}

5303

ndr->depth--;

5304

}

5305

ndr->depth--;

5306

ndr->depth--;

5307

}

5308

5309

static enum ndr_err_code ndr_push_srvsvc_NetShareCtr1501(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetShareCtr1501 *r)

5310

{

5311

uint32_t cntr_array_1;

5312

if (ndr_flags & NDR_SCALARS) {

5313

NDR_CHECK(ndr_push_align(ndr, 4));

5314

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));

5315

NDR_CHECK(ndr_push_unique_ptr(ndr, r->array));

5316

}

5317

if (ndr_flags & NDR_BUFFERS) {

5318

if (r->array) {

5319

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));

5320

for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {

5321

NDR_CHECK(ndr_push_sec_desc_buf(ndr, NDR_SCALARS, &r->array[cntr_array_1]));

5322

}

5323

for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {

5324

NDR_CHECK(ndr_push_sec_desc_buf(ndr, NDR_BUFFERS, &r->array[cntr_array_1]));

5325

}

5326

}

5327

}

5328

return NDR_ERR_SUCCESS;

5329

}

5330

5331

static enum ndr_err_code ndr_pull_srvsvc_NetShareCtr1501(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetShareCtr1501 *r)

5332

{

5333

uint32_t _ptr_array;

5334

uint32_t cntr_array_1;

5335

TALLOC_CTX *_mem_save_array_0;

5336

TALLOC_CTX *_mem_save_array_1;

5337

if (ndr_flags & NDR_SCALARS) {

5338

NDR_CHECK(ndr_pull_align(ndr, 4));

5339

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));

5340

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_array));

5341

if (_ptr_array) {

5342

NDR_PULL_ALLOC(ndr, r->array);

5343

} else {

5344

r->array = NULL;

5345

}

5346

}

5347

if (ndr_flags & NDR_BUFFERS) {

5348

if (r->array) {

5349

_mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);

5350

NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);

5351

NDR_CHECK(ndr_pull_array_size(ndr, &r->array));

5352

NDR_PULL_ALLOC_N(ndr, r->array, ndr_get_array_size(ndr, &r->array));

5353

_mem_save_array_1 = NDR_PULL_GET_MEM_CTX(ndr);

5354

NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);

5355

for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {

5356

NDR_CHECK(ndr_pull_sec_desc_buf(ndr, NDR_SCALARS, &r->array[cntr_array_1]));

5357

}

5358

for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {

5359

NDR_CHECK(ndr_pull_sec_desc_buf(ndr, NDR_BUFFERS, &r->array[cntr_array_1]));

5360

}

5361

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_1, 0);

5362

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);

5363

}

5364

if (r->array) {

5365

NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->array, r->count));

5366

}

5367

}

5368

return NDR_ERR_SUCCESS;

5369

}

5370

5371

_PUBLIC_ void ndr_print_srvsvc_NetShareCtr1501(struct ndr_print *ndr, const char *name, const struct srvsvc_NetShareCtr1501 *r)

5372

{

5373

uint32_t cntr_array_1;

5374

ndr_print_struct(ndr, name, "srvsvc_NetShareCtr1501");

5375

ndr->depth++;

5376

ndr_print_uint32(ndr, "count", r->count);

5377

ndr_print_ptr(ndr, "array", r->array);

5378

ndr->depth++;

5379

if (r->array) {

5380

ndr->print(ndr, "%s: ARRAY(%d)", "array", (int)r->count);

5381

ndr->depth++;

5382

for (cntr_array_1=0;cntr_array_1<r->count;cntr_array_1++) {

5383

char *idx_1=NULL;

5384

if (asprintf(&idx_1, "[%d]", cntr_array_1) != -1) {

5385

ndr_print_sec_desc_buf(ndr, "array", &r->array[cntr_array_1]);

5386

free(idx_1);

5387

}

5388

}

5389

ndr->depth--;

5390

}

5391

ndr->depth--;

5392

ndr->depth--;

5393

}

5394

5395

static enum ndr_err_code ndr_push_srvsvc_NetShareInfo(struct ndr_push *ndr, int ndr_flags, const union srvsvc_NetShareInfo *r)

5396

{

5397

if (ndr_flags & NDR_SCALARS) {

5398

int level = ndr_push_get_switch_value(ndr, r);

5399

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));

5400

switch (level) {

5401

case 0: {

5402

NDR_CHECK(ndr_push_unique_ptr(ndr, r->info0));

5403

break; }

5404

5405

case 1: {

5406

NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1));

5407

break; }

5408

5409

case 2: {

5410

NDR_CHECK(ndr_push_unique_ptr(ndr, r->info2));

5411

break; }

5412

5413

case 501: {

5414

NDR_CHECK(ndr_push_unique_ptr(ndr, r->info501));

5415

break; }

5416

5417

case 502: {

5418

NDR_CHECK(ndr_push_unique_ptr(ndr, r->info502));

5419

break; }

5420

5421

case 1004: {

5422

NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1004));

5423

break; }

5424

5425

case 1005: {

5426

NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1005));

5427

break; }

5428

5429

case 1006: {

5430

NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1006));

5431

break; }

5432

5433

case 1007: {

5434

NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1007));

5435

break; }

5436

5437

case 1501: {

5438

NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1501));

5439

break; }

5440

5441

default: {

5442

break; }

5443

5444

}

5445

}

5446

if (ndr_flags & NDR_BUFFERS) {

5447

int level = ndr_push_get_switch_value(ndr, r);

5448

switch (level) {

5449

case 0:

5450

if (r->info0) {

5451

NDR_CHECK(ndr_push_srvsvc_NetShareInfo0(ndr, NDR_SCALARS|NDR_BUFFERS, r->info0));

5452

}

5453

break;

5454

5455

case 1:

5456

if (r->info1) {

5457

NDR_CHECK(ndr_push_srvsvc_NetShareInfo1(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1));

5458

}

5459

break;

5460

5461

case 2:

5462

if (r->info2) {

5463

NDR_CHECK(ndr_push_srvsvc_NetShareInfo2(ndr, NDR_SCALARS|NDR_BUFFERS, r->info2));

5464

}

5465

break;

5466

5467

case 501:

5468

if (r->info501) {

5469

NDR_CHECK(ndr_push_srvsvc_NetShareInfo501(ndr, NDR_SCALARS|NDR_BUFFERS, r->info501));

5470

}

5471

break;

5472

5473

case 502:

5474

if (r->info502) {

5475

NDR_CHECK(ndr_push_srvsvc_NetShareInfo502(ndr, NDR_SCALARS|NDR_BUFFERS, r->info502));

5476

}

5477

break;

5478

5479

case 1004:

5480

if (r->info1004) {

5481

NDR_CHECK(ndr_push_srvsvc_NetShareInfo1004(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1004));

5482

}

5483

break;

5484

5485

case 1005:

5486

if (r->info1005) {

5487

NDR_CHECK(ndr_push_srvsvc_NetShareInfo1005(ndr, NDR_SCALARS, r->info1005));

5488

}

5489

break;

5490

5491

case 1006:

5492

if (r->info1006) {

5493

NDR_CHECK(ndr_push_srvsvc_NetShareInfo1006(ndr, NDR_SCALARS, r->info1006));

5494

}

5495

break;

5496

5497

case 1007:

5498

if (r->info1007) {

5499

NDR_CHECK(ndr_push_srvsvc_NetShareInfo1007(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1007));

5500

}

5501

break;

5502

5503

case 1501:

5504

if (r->info1501) {

5505

NDR_CHECK(ndr_push_sec_desc_buf(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1501));

5506

}

5507

break;

5508

5509

default:

5510

break;

5511

5512

}

5513

}

5514

return NDR_ERR_SUCCESS;

5515

}

5516

5517

static enum ndr_err_code ndr_pull_srvsvc_NetShareInfo(struct ndr_pull *ndr, int ndr_flags, union srvsvc_NetShareInfo *r)

5518

{

5519

int level;

5520

uint32_t _level;

5521

TALLOC_CTX *_mem_save_info0_0;

5522

TALLOC_CTX *_mem_save_info1_0;

5523

TALLOC_CTX *_mem_save_info2_0;

5524

TALLOC_CTX *_mem_save_info501_0;

5525

TALLOC_CTX *_mem_save_info502_0;

5526

TALLOC_CTX *_mem_save_info1004_0;

5527

TALLOC_CTX *_mem_save_info1005_0;

5528

TALLOC_CTX *_mem_save_info1006_0;

5529

TALLOC_CTX *_mem_save_info1007_0;

5530

TALLOC_CTX *_mem_save_info1501_0;

5531

level = ndr_pull_get_switch_value(ndr, r);

5532

if (ndr_flags & NDR_SCALARS) {

5533

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));

5534

if (_level != level) {

5535

return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r", _level);

5536

}

5537

switch (level) {

5538

case 0: {

5539

uint32_t _ptr_info0;

5540

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info0));

5541

if (_ptr_info0) {

5542

NDR_PULL_ALLOC(ndr, r->info0);

5543

} else {

5544

r->info0 = NULL;

5545

}

5546

break; }

5547

5548

case 1: {

5549

uint32_t _ptr_info1;

5550

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1));

5551

if (_ptr_info1) {

5552

NDR_PULL_ALLOC(ndr, r->info1);

5553

} else {

5554

r->info1 = NULL;

5555

}

5556

break; }

5557

5558

case 2: {

5559

uint32_t _ptr_info2;

5560

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info2));

5561

if (_ptr_info2) {

5562

NDR_PULL_ALLOC(ndr, r->info2);

5563

} else {

5564

r->info2 = NULL;

5565

}

5566

break; }

5567

5568

case 501: {

5569

uint32_t _ptr_info501;

5570

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info501));

5571

if (_ptr_info501) {

5572

NDR_PULL_ALLOC(ndr, r->info501);

5573

} else {

5574

r->info501 = NULL;

5575

}

5576

break; }

5577

5578

case 502: {

5579

uint32_t _ptr_info502;

5580

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info502));

5581

if (_ptr_info502) {

5582

NDR_PULL_ALLOC(ndr, r->info502);

5583

} else {

5584

r->info502 = NULL;

5585

}

5586

break; }

5587

5588

case 1004: {

5589

uint32_t _ptr_info1004;

5590

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1004));

5591

if (_ptr_info1004) {

5592

NDR_PULL_ALLOC(ndr, r->info1004);

5593

} else {

5594

r->info1004 = NULL;

5595

}

5596

break; }

5597

5598

case 1005: {

5599

uint32_t _ptr_info1005;

5600

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1005));

5601

if (_ptr_info1005) {

5602

NDR_PULL_ALLOC(ndr, r->info1005);

5603

} else {

5604

r->info1005 = NULL;

5605

}

5606

break; }

5607

5608

case 1006: {

5609

uint32_t _ptr_info1006;

5610

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1006));

5611

if (_ptr_info1006) {

5612

NDR_PULL_ALLOC(ndr, r->info1006);

5613

} else {

5614

r->info1006 = NULL;

5615

}

5616

break; }

5617

5618

case 1007: {

5619

uint32_t _ptr_info1007;

5620

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1007));

5621

if (_ptr_info1007) {

5622

NDR_PULL_ALLOC(ndr, r->info1007);

5623

} else {

5624

r->info1007 = NULL;

5625

}

5626

break; }

5627

5628

case 1501: {

5629

uint32_t _ptr_info1501;

5630

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1501));

5631

if (_ptr_info1501) {

5632

NDR_PULL_ALLOC(ndr, r->info1501);

5633

} else {

5634

r->info1501 = NULL;

5635

}

5636

break; }

5637

5638

default: {

5639

break; }

5640

5641

}

5642

}

5643

if (ndr_flags & NDR_BUFFERS) {

5644

switch (level) {

5645

case 0:

5646

if (r->info0) {

5647

_mem_save_info0_0 = NDR_PULL_GET_MEM_CTX(ndr);

5648

NDR_PULL_SET_MEM_CTX(ndr, r->info0, 0);

5649

NDR_CHECK(ndr_pull_srvsvc_NetShareInfo0(ndr, NDR_SCALARS|NDR_BUFFERS, r->info0));

5650

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info0_0, 0);

5651

}

5652

break;

5653

5654

case 1:

5655

if (r->info1) {

5656

_mem_save_info1_0 = NDR_PULL_GET_MEM_CTX(ndr);

5657

NDR_PULL_SET_MEM_CTX(ndr, r->info1, 0);

5658

NDR_CHECK(ndr_pull_srvsvc_NetShareInfo1(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1));

5659

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1_0, 0);

5660

}

5661

break;

5662

5663

case 2:

5664

if (r->info2) {

5665

_mem_save_info2_0 = NDR_PULL_GET_MEM_CTX(ndr);

5666

NDR_PULL_SET_MEM_CTX(ndr, r->info2, 0);

5667

NDR_CHECK(ndr_pull_srvsvc_NetShareInfo2(ndr, NDR_SCALARS|NDR_BUFFERS, r->info2));

5668

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info2_0, 0);

5669

}

5670

break;

5671

5672

case 501:

5673

if (r->info501) {

5674

_mem_save_info501_0 = NDR_PULL_GET_MEM_CTX(ndr);

5675

NDR_PULL_SET_MEM_CTX(ndr, r->info501, 0);

5676

NDR_CHECK(ndr_pull_srvsvc_NetShareInfo501(ndr, NDR_SCALARS|NDR_BUFFERS, r->info501));

5677

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info501_0, 0);

5678

}

5679

break;

5680

5681

case 502:

5682

if (r->info502) {

5683

_mem_save_info502_0 = NDR_PULL_GET_MEM_CTX(ndr);

5684

NDR_PULL_SET_MEM_CTX(ndr, r->info502, 0);

5685

NDR_CHECK(ndr_pull_srvsvc_NetShareInfo502(ndr, NDR_SCALARS|NDR_BUFFERS, r->info502));

5686

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info502_0, 0);

5687

}

5688

break;

5689

5690

case 1004:

5691

if (r->info1004) {

5692

_mem_save_info1004_0 = NDR_PULL_GET_MEM_CTX(ndr);

5693

NDR_PULL_SET_MEM_CTX(ndr, r->info1004, 0);

5694

NDR_CHECK(ndr_pull_srvsvc_NetShareInfo1004(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1004));

5695

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1004_0, 0);

5696

}

5697

break;

5698

5699

case 1005:

5700

if (r->info1005) {

5701

_mem_save_info1005_0 = NDR_PULL_GET_MEM_CTX(ndr);

5702

NDR_PULL_SET_MEM_CTX(ndr, r->info1005, 0);

5703

NDR_CHECK(ndr_pull_srvsvc_NetShareInfo1005(ndr, NDR_SCALARS, r->info1005));

5704

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1005_0, 0);

5705

}

5706

break;

5707

5708

case 1006:

5709

if (r->info1006) {

5710

_mem_save_info1006_0 = NDR_PULL_GET_MEM_CTX(ndr);

5711

NDR_PULL_SET_MEM_CTX(ndr, r->info1006, 0);

5712

NDR_CHECK(ndr_pull_srvsvc_NetShareInfo1006(ndr, NDR_SCALARS, r->info1006));

5713

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1006_0, 0);

5714

}

5715

break;

5716

5717

case 1007:

5718

if (r->info1007) {

5719

_mem_save_info1007_0 = NDR_PULL_GET_MEM_CTX(ndr);

5720

NDR_PULL_SET_MEM_CTX(ndr, r->info1007, 0);

5721

NDR_CHECK(ndr_pull_srvsvc_NetShareInfo1007(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1007));

5722

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1007_0, 0);

5723

}

5724

break;

5725

5726

case 1501:

5727

if (r->info1501) {

5728

_mem_save_info1501_0 = NDR_PULL_GET_MEM_CTX(ndr);

5729

NDR_PULL_SET_MEM_CTX(ndr, r->info1501, 0);

5730

NDR_CHECK(ndr_pull_sec_desc_buf(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1501));

5731

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1501_0, 0);

5732

}

5733

break;

5734

5735

default:

5736

break;

5737

5738

}

5739

}

5740

return NDR_ERR_SUCCESS;

5741

}

5742

5743

_PUBLIC_ void ndr_print_srvsvc_NetShareInfo(struct ndr_print *ndr, const char *name, const union srvsvc_NetShareInfo *r)

5744

{

5745

int level;

5746

level = ndr_print_get_switch_value(ndr, r);

5747

ndr_print_union(ndr, name, level, "srvsvc_NetShareInfo");

5748

switch (level) {

5749

case 0:

5750

ndr_print_ptr(ndr, "info0", r->info0);

5751

ndr->depth++;

5752

if (r->info0) {

5753

ndr_print_srvsvc_NetShareInfo0(ndr, "info0", r->info0);

5754

}

5755

ndr->depth--;

5756

break;

5757

5758

case 1:

5759

ndr_print_ptr(ndr, "info1", r->info1);

5760

ndr->depth++;

5761

if (r->info1) {

5762

ndr_print_srvsvc_NetShareInfo1(ndr, "info1", r->info1);

5763

}

5764

ndr->depth--;

5765

break;

5766

5767

case 2:

5768

ndr_print_ptr(ndr, "info2", r->info2);

5769

ndr->depth++;

5770

if (r->info2) {

5771

ndr_print_srvsvc_NetShareInfo2(ndr, "info2", r->info2);

5772

}

5773

ndr->depth--;

5774

break;

5775

5776

case 501:

5777

ndr_print_ptr(ndr, "info501", r->info501);

5778

ndr->depth++;

5779

if (r->info501) {

5780

ndr_print_srvsvc_NetShareInfo501(ndr, "info501", r->info501);

5781

}

5782

ndr->depth--;

5783

break;

5784

5785

case 502:

5786

ndr_print_ptr(ndr, "info502", r->info502);

5787

ndr->depth++;

5788

if (r->info502) {

5789

ndr_print_srvsvc_NetShareInfo502(ndr, "info502", r->info502);

5790

}

5791

ndr->depth--;

5792

break;

5793

5794

case 1004:

5795

ndr_print_ptr(ndr, "info1004", r->info1004);

5796

ndr->depth++;

5797

if (r->info1004) {

5798

ndr_print_srvsvc_NetShareInfo1004(ndr, "info1004", r->info1004);

5799

}

5800

ndr->depth--;

5801

break;

5802

5803

case 1005:

5804

ndr_print_ptr(ndr, "info1005", r->info1005);

5805

ndr->depth++;

5806

if (r->info1005) {

5807

ndr_print_srvsvc_NetShareInfo1005(ndr, "info1005", r->info1005);

5808

}

5809

ndr->depth--;

5810

break;

5811

5812

case 1006:

5813

ndr_print_ptr(ndr, "info1006", r->info1006);

5814

ndr->depth++;

5815

if (r->info1006) {

5816

ndr_print_srvsvc_NetShareInfo1006(ndr, "info1006", r->info1006);

5817

}

5818

ndr->depth--;

5819

break;

5820

5821

case 1007:

5822

ndr_print_ptr(ndr, "info1007", r->info1007);

5823

ndr->depth++;

5824

if (r->info1007) {

5825

ndr_print_srvsvc_NetShareInfo1007(ndr, "info1007", r->info1007);

5826

}

5827

ndr->depth--;

5828

break;

5829

5830

case 1501:

5831

ndr_print_ptr(ndr, "info1501", r->info1501);

5832

ndr->depth++;

5833

if (r->info1501) {

5834

ndr_print_sec_desc_buf(ndr, "info1501", r->info1501);

5835

}

5836

ndr->depth--;

5837

break;

5838

5839

default:

5840

break;

5841

5842

}

5843

}

5844

5845

static enum ndr_err_code ndr_push_srvsvc_NetShareCtr(struct ndr_push *ndr, int ndr_flags, const union srvsvc_NetShareCtr *r)

5846

{

5847

if (ndr_flags & NDR_SCALARS) {

5848

int level = ndr_push_get_switch_value(ndr, r);

5849

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));

5850

switch (level) {

5851

case 0: {

5852

NDR_CHECK(ndr_push_unique_ptr(ndr, r->ctr0));

5853

break; }

5854

5855

case 1: {

5856

NDR_CHECK(ndr_push_unique_ptr(ndr, r->ctr1));

5857

break; }

5858

5859

case 2: {

5860

NDR_CHECK(ndr_push_unique_ptr(ndr, r->ctr2));

5861

break; }

5862

5863

case 501: {

5864

NDR_CHECK(ndr_push_unique_ptr(ndr, r->ctr501));

5865

break; }

5866

5867

case 502: {

5868

NDR_CHECK(ndr_push_unique_ptr(ndr, r->ctr502));

5869

break; }

5870

5871

case 1004: {

5872

NDR_CHECK(ndr_push_unique_ptr(ndr, r->ctr1004));

5873

break; }

5874

5875

case 1005: {

5876

NDR_CHECK(ndr_push_unique_ptr(ndr, r->ctr1005));

5877

break; }

5878

5879

case 1006: {

5880

NDR_CHECK(ndr_push_unique_ptr(ndr, r->ctr1006));

5881

break; }

5882

5883

case 1007: {

5884

NDR_CHECK(ndr_push_unique_ptr(ndr, r->ctr1007));

5885

break; }

5886

5887

case 1501: {

5888

NDR_CHECK(ndr_push_unique_ptr(ndr, r->ctr1501));

5889

break; }

5890

5891

default: {

5892

break; }

5893

5894

}

5895

}

5896

if (ndr_flags & NDR_BUFFERS) {

5897

int level = ndr_push_get_switch_value(ndr, r);

5898

switch (level) {

5899

case 0:

5900

if (r->ctr0) {

5901

NDR_CHECK(ndr_push_srvsvc_NetShareCtr0(ndr, NDR_SCALARS|NDR_BUFFERS, r->ctr0));

5902

}

5903

break;

5904

5905

case 1:

5906

if (r->ctr1) {

5907

NDR_CHECK(ndr_push_srvsvc_NetShareCtr1(ndr, NDR_SCALARS|NDR_BUFFERS, r->ctr1));

5908

}

5909

break;

5910

5911

case 2:

5912

if (r->ctr2) {

5913

NDR_CHECK(ndr_push_srvsvc_NetShareCtr2(ndr, NDR_SCALARS|NDR_BUFFERS, r->ctr2));

5914

}

5915

break;

5916

5917

case 501:

5918

if (r->ctr501) {

5919

NDR_CHECK(ndr_push_srvsvc_NetShareCtr501(ndr, NDR_SCALARS|NDR_BUFFERS, r->ctr501));

5920

}

5921

break;

5922

5923

case 502:

5924

if (r->ctr502) {

5925

NDR_CHECK(ndr_push_srvsvc_NetShareCtr502(ndr, NDR_SCALARS|NDR_BUFFERS, r->ctr502));

5926

}

5927

break;

5928

5929

case 1004:

5930

if (r->ctr1004) {

5931

NDR_CHECK(ndr_push_srvsvc_NetShareCtr1004(ndr, NDR_SCALARS|NDR_BUFFERS, r->ctr1004));

5932

}

5933

break;

5934

5935

case 1005:

5936

if (r->ctr1005) {

5937

NDR_CHECK(ndr_push_srvsvc_NetShareCtr1005(ndr, NDR_SCALARS|NDR_BUFFERS, r->ctr1005));

5938

}

5939

break;

5940

5941

case 1006:

5942

if (r->ctr1006) {

5943

NDR_CHECK(ndr_push_srvsvc_NetShareCtr1006(ndr, NDR_SCALARS|NDR_BUFFERS, r->ctr1006));

5944

}

5945

break;

5946

5947

case 1007:

5948

if (r->ctr1007) {

5949

NDR_CHECK(ndr_push_srvsvc_NetShareCtr1007(ndr, NDR_SCALARS|NDR_BUFFERS, r->ctr1007));

5950

}

5951

break;

5952

5953

case 1501:

5954

if (r->ctr1501) {

5955

NDR_CHECK(ndr_push_srvsvc_NetShareCtr1501(ndr, NDR_SCALARS|NDR_BUFFERS, r->ctr1501));

5956

}

5957

break;

5958

5959

default:

5960

break;

5961

5962

}

5963

}

5964

return NDR_ERR_SUCCESS;

5965

}

5966

5967

static enum ndr_err_code ndr_pull_srvsvc_NetShareCtr(struct ndr_pull *ndr, int ndr_flags, union srvsvc_NetShareCtr *r)

5968

{

5969

int level;

5970

uint32_t _level;

5971

TALLOC_CTX *_mem_save_ctr0_0;

5972

TALLOC_CTX *_mem_save_ctr1_0;

5973

TALLOC_CTX *_mem_save_ctr2_0;

5974

TALLOC_CTX *_mem_save_ctr501_0;

5975

TALLOC_CTX *_mem_save_ctr502_0;

5976

TALLOC_CTX *_mem_save_ctr1004_0;

5977

TALLOC_CTX *_mem_save_ctr1005_0;

5978

TALLOC_CTX *_mem_save_ctr1006_0;

5979

TALLOC_CTX *_mem_save_ctr1007_0;

5980

TALLOC_CTX *_mem_save_ctr1501_0;

5981

level = ndr_pull_get_switch_value(ndr, r);

5982

if (ndr_flags & NDR_SCALARS) {

5983

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));

5984

if (_level != level) {

5985

return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r", _level);

5986

}

5987

switch (level) {

5988

case 0: {

5989

uint32_t _ptr_ctr0;

5990

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_ctr0));

5991

if (_ptr_ctr0) {

5992

NDR_PULL_ALLOC(ndr, r->ctr0);

5993

} else {

5994

r->ctr0 = NULL;

5995

}

5996

break; }

5997

5998

case 1: {

5999

uint32_t _ptr_ctr1;

6000

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_ctr1));

6001

if (_ptr_ctr1) {

6002

NDR_PULL_ALLOC(ndr, r->ctr1);

6003

} else {

6004

r->ctr1 = NULL;

6005

}

6006

break; }

6007

6008

case 2: {

6009

uint32_t _ptr_ctr2;

6010

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_ctr2));

6011

if (_ptr_ctr2) {

6012

NDR_PULL_ALLOC(ndr, r->ctr2);

6013

} else {

6014

r->ctr2 = NULL;

6015

}

6016

break; }

6017

6018

case 501: {

6019

uint32_t _ptr_ctr501;

6020

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_ctr501));

6021

if (_ptr_ctr501) {

6022

NDR_PULL_ALLOC(ndr, r->ctr501);

6023

} else {

6024

r->ctr501 = NULL;

6025

}

6026

break; }

6027

6028

case 502: {

6029

uint32_t _ptr_ctr502;

6030

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_ctr502));

6031

if (_ptr_ctr502) {

6032

NDR_PULL_ALLOC(ndr, r->ctr502);

6033

} else {

6034

r->ctr502 = NULL;

6035

}

6036

break; }

6037

6038

case 1004: {

6039

uint32_t _ptr_ctr1004;

6040

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_ctr1004));

6041

if (_ptr_ctr1004) {

6042

NDR_PULL_ALLOC(ndr, r->ctr1004);

6043

} else {

6044

r->ctr1004 = NULL;

6045

}

6046

break; }

6047

6048

case 1005: {

6049

uint32_t _ptr_ctr1005;

6050

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_ctr1005));

6051

if (_ptr_ctr1005) {

6052

NDR_PULL_ALLOC(ndr, r->ctr1005);

6053

} else {

6054

r->ctr1005 = NULL;

6055

}

6056

break; }

6057

6058

case 1006: {

6059

uint32_t _ptr_ctr1006;

6060

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_ctr1006));

6061

if (_ptr_ctr1006) {

6062

NDR_PULL_ALLOC(ndr, r->ctr1006);

6063

} else {

6064

r->ctr1006 = NULL;

6065

}

6066

break; }

6067

6068

case 1007: {

6069

uint32_t _ptr_ctr1007;

6070

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_ctr1007));

6071

if (_ptr_ctr1007) {

6072

NDR_PULL_ALLOC(ndr, r->ctr1007);

6073

} else {

6074

r->ctr1007 = NULL;

6075

}

6076

break; }

6077

6078

case 1501: {

6079

uint32_t _ptr_ctr1501;

6080

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_ctr1501));

6081

if (_ptr_ctr1501) {

6082

NDR_PULL_ALLOC(ndr, r->ctr1501);

6083

} else {

6084

r->ctr1501 = NULL;

6085

}

6086

break; }

6087

6088

default: {

6089

break; }

6090

6091

}

6092

}

6093

if (ndr_flags & NDR_BUFFERS) {

6094

switch (level) {

6095

case 0:

6096

if (r->ctr0) {

6097

_mem_save_ctr0_0 = NDR_PULL_GET_MEM_CTX(ndr);

6098

NDR_PULL_SET_MEM_CTX(ndr, r->ctr0, 0);

6099

NDR_CHECK(ndr_pull_srvsvc_NetShareCtr0(ndr, NDR_SCALARS|NDR_BUFFERS, r->ctr0));

6100

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ctr0_0, 0);

6101

}

6102

break;

6103

6104

case 1:

6105

if (r->ctr1) {

6106

_mem_save_ctr1_0 = NDR_PULL_GET_MEM_CTX(ndr);

6107

NDR_PULL_SET_MEM_CTX(ndr, r->ctr1, 0);

6108

NDR_CHECK(ndr_pull_srvsvc_NetShareCtr1(ndr, NDR_SCALARS|NDR_BUFFERS, r->ctr1));

6109

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ctr1_0, 0);

6110

}

6111

break;

6112

6113

case 2:

6114

if (r->ctr2) {

6115

_mem_save_ctr2_0 = NDR_PULL_GET_MEM_CTX(ndr);

6116

NDR_PULL_SET_MEM_CTX(ndr, r->ctr2, 0);

6117

NDR_CHECK(ndr_pull_srvsvc_NetShareCtr2(ndr, NDR_SCALARS|NDR_BUFFERS, r->ctr2));

6118

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ctr2_0, 0);

6119

}

6120

break;

6121

6122

case 501:

6123

if (r->ctr501) {

6124

_mem_save_ctr501_0 = NDR_PULL_GET_MEM_CTX(ndr);

6125

NDR_PULL_SET_MEM_CTX(ndr, r->ctr501, 0);

6126

NDR_CHECK(ndr_pull_srvsvc_NetShareCtr501(ndr, NDR_SCALARS|NDR_BUFFERS, r->ctr501));

6127

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ctr501_0, 0);

6128

}

6129

break;

6130

6131

case 502:

6132

if (r->ctr502) {

6133

_mem_save_ctr502_0 = NDR_PULL_GET_MEM_CTX(ndr);

6134

NDR_PULL_SET_MEM_CTX(ndr, r->ctr502, 0);

6135

NDR_CHECK(ndr_pull_srvsvc_NetShareCtr502(ndr, NDR_SCALARS|NDR_BUFFERS, r->ctr502));

6136

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ctr502_0, 0);

6137

}

6138

break;

6139

6140

case 1004:

6141

if (r->ctr1004) {

6142

_mem_save_ctr1004_0 = NDR_PULL_GET_MEM_CTX(ndr);

6143

NDR_PULL_SET_MEM_CTX(ndr, r->ctr1004, 0);

6144

NDR_CHECK(ndr_pull_srvsvc_NetShareCtr1004(ndr, NDR_SCALARS|NDR_BUFFERS, r->ctr1004));

6145

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ctr1004_0, 0);

6146

}

6147

break;

6148

6149

case 1005:

6150

if (r->ctr1005) {

6151

_mem_save_ctr1005_0 = NDR_PULL_GET_MEM_CTX(ndr);

6152

NDR_PULL_SET_MEM_CTX(ndr, r->ctr1005, 0);

6153

NDR_CHECK(ndr_pull_srvsvc_NetShareCtr1005(ndr, NDR_SCALARS|NDR_BUFFERS, r->ctr1005));

6154

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ctr1005_0, 0);

6155

}

6156

break;

6157

6158

case 1006:

6159

if (r->ctr1006) {

6160

_mem_save_ctr1006_0 = NDR_PULL_GET_MEM_CTX(ndr);

6161

NDR_PULL_SET_MEM_CTX(ndr, r->ctr1006, 0);

6162

NDR_CHECK(ndr_pull_srvsvc_NetShareCtr1006(ndr, NDR_SCALARS|NDR_BUFFERS, r->ctr1006));

6163

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ctr1006_0, 0);

6164

}

6165

break;

6166

6167

case 1007:

6168

if (r->ctr1007) {

6169

_mem_save_ctr1007_0 = NDR_PULL_GET_MEM_CTX(ndr);

6170

NDR_PULL_SET_MEM_CTX(ndr, r->ctr1007, 0);

6171

NDR_CHECK(ndr_pull_srvsvc_NetShareCtr1007(ndr, NDR_SCALARS|NDR_BUFFERS, r->ctr1007));

6172

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ctr1007_0, 0);

6173

}

6174

break;

6175

6176

case 1501:

6177

if (r->ctr1501) {

6178

_mem_save_ctr1501_0 = NDR_PULL_GET_MEM_CTX(ndr);

6179

NDR_PULL_SET_MEM_CTX(ndr, r->ctr1501, 0);

6180

NDR_CHECK(ndr_pull_srvsvc_NetShareCtr1501(ndr, NDR_SCALARS|NDR_BUFFERS, r->ctr1501));

6181

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ctr1501_0, 0);

6182

}

6183

break;

6184

6185

default:

6186

break;

6187

6188

}

6189

}

6190

return NDR_ERR_SUCCESS;

6191

}

6192

6193

_PUBLIC_ void ndr_print_srvsvc_NetShareCtr(struct ndr_print *ndr, const char *name, const union srvsvc_NetShareCtr *r)

6194

{

6195

int level;

6196

level = ndr_print_get_switch_value(ndr, r);

6197

ndr_print_union(ndr, name, level, "srvsvc_NetShareCtr");

6198

switch (level) {

6199

case 0:

6200

ndr_print_ptr(ndr, "ctr0", r->ctr0);

6201

ndr->depth++;

6202

if (r->ctr0) {

6203

ndr_print_srvsvc_NetShareCtr0(ndr, "ctr0", r->ctr0);

6204

}

6205

ndr->depth--;

6206

break;

6207

6208

case 1:

6209

ndr_print_ptr(ndr, "ctr1", r->ctr1);

6210

ndr->depth++;

6211

if (r->ctr1) {

6212

ndr_print_srvsvc_NetShareCtr1(ndr, "ctr1", r->ctr1);

6213

}

6214

ndr->depth--;

6215

break;

6216

6217

case 2:

6218

ndr_print_ptr(ndr, "ctr2", r->ctr2);

6219

ndr->depth++;

6220

if (r->ctr2) {

6221

ndr_print_srvsvc_NetShareCtr2(ndr, "ctr2", r->ctr2);

6222

}

6223

ndr->depth--;

6224

break;

6225

6226

case 501:

6227

ndr_print_ptr(ndr, "ctr501", r->ctr501);

6228

ndr->depth++;

6229

if (r->ctr501) {

6230

ndr_print_srvsvc_NetShareCtr501(ndr, "ctr501", r->ctr501);

6231

}

6232

ndr->depth--;

6233

break;

6234

6235

case 502:

6236

ndr_print_ptr(ndr, "ctr502", r->ctr502);

6237

ndr->depth++;

6238

if (r->ctr502) {

6239

ndr_print_srvsvc_NetShareCtr502(ndr, "ctr502", r->ctr502);

6240

}

6241

ndr->depth--;

6242

break;

6243

6244

case 1004:

6245

ndr_print_ptr(ndr, "ctr1004", r->ctr1004);

6246

ndr->depth++;

6247

if (r->ctr1004) {

6248

ndr_print_srvsvc_NetShareCtr1004(ndr, "ctr1004", r->ctr1004);

6249

}

6250

ndr->depth--;

6251

break;

6252

6253

case 1005:

6254

ndr_print_ptr(ndr, "ctr1005", r->ctr1005);

6255

ndr->depth++;

6256

if (r->ctr1005) {

6257

ndr_print_srvsvc_NetShareCtr1005(ndr, "ctr1005", r->ctr1005);

6258

}

6259

ndr->depth--;

6260

break;

6261

6262

case 1006:

6263

ndr_print_ptr(ndr, "ctr1006", r->ctr1006);

6264

ndr->depth++;

6265

if (r->ctr1006) {

6266

ndr_print_srvsvc_NetShareCtr1006(ndr, "ctr1006", r->ctr1006);

6267

}

6268

ndr->depth--;

6269

break;

6270

6271

case 1007:

6272

ndr_print_ptr(ndr, "ctr1007", r->ctr1007);

6273

ndr->depth++;

6274

if (r->ctr1007) {

6275

ndr_print_srvsvc_NetShareCtr1007(ndr, "ctr1007", r->ctr1007);

6276

}

6277

ndr->depth--;

6278

break;

6279

6280

case 1501:

6281

ndr_print_ptr(ndr, "ctr1501", r->ctr1501);

6282

ndr->depth++;

6283

if (r->ctr1501) {

6284

ndr_print_srvsvc_NetShareCtr1501(ndr, "ctr1501", r->ctr1501);

6285

}

6286

ndr->depth--;

6287

break;

6288

6289

default:

6290

break;

6291

6292

}

6293

}

6294

6295

static enum ndr_err_code ndr_push_srvsvc_NetShareInfoCtr(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetShareInfoCtr *r)

6296

{

6297

if (ndr_flags & NDR_SCALARS) {

6298

NDR_CHECK(ndr_push_align(ndr, 4));

6299

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->level));

6300

NDR_CHECK(ndr_push_set_switch_value(ndr, &r->ctr, r->level));

6301

NDR_CHECK(ndr_push_srvsvc_NetShareCtr(ndr, NDR_SCALARS, &r->ctr));

6302

}

6303

if (ndr_flags & NDR_BUFFERS) {

6304

NDR_CHECK(ndr_push_srvsvc_NetShareCtr(ndr, NDR_BUFFERS, &r->ctr));

6305

}

6306

return NDR_ERR_SUCCESS;

6307

}

6308

6309

static enum ndr_err_code ndr_pull_srvsvc_NetShareInfoCtr(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetShareInfoCtr *r)

6310

{

6311

if (ndr_flags & NDR_SCALARS) {

6312

NDR_CHECK(ndr_pull_align(ndr, 4));

6313

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->level));

6314

NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->ctr, r->level));

6315

NDR_CHECK(ndr_pull_srvsvc_NetShareCtr(ndr, NDR_SCALARS, &r->ctr));

6316

}

6317

if (ndr_flags & NDR_BUFFERS) {

6318

NDR_CHECK(ndr_pull_srvsvc_NetShareCtr(ndr, NDR_BUFFERS, &r->ctr));

6319

}

6320

return NDR_ERR_SUCCESS;

6321

}

6322

6323

_PUBLIC_ void ndr_print_srvsvc_NetShareInfoCtr(struct ndr_print *ndr, const char *name, const struct srvsvc_NetShareInfoCtr *r)

6324

{

6325

ndr_print_struct(ndr, name, "srvsvc_NetShareInfoCtr");

6326

ndr->depth++;

6327

ndr_print_uint32(ndr, "level", r->level);

6328

ndr_print_set_switch_value(ndr, &r->ctr, r->level);

6329

ndr_print_srvsvc_NetShareCtr(ndr, "ctr", &r->ctr);

6330

ndr->depth--;

6331

}

6332

6333

_PUBLIC_ enum ndr_err_code ndr_push_srvsvc_PlatformId(struct ndr_push *ndr, int ndr_flags, enum srvsvc_PlatformId r)

6334

{

6335

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));

6336

return NDR_ERR_SUCCESS;

6337

}

6338

6339

_PUBLIC_ enum ndr_err_code ndr_pull_srvsvc_PlatformId(struct ndr_pull *ndr, int ndr_flags, enum srvsvc_PlatformId *r)

6340

{

6341

uint32_t v;

6342

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));

6343

*r = v;

6344

return NDR_ERR_SUCCESS;

6345

}

6346

6347

_PUBLIC_ void ndr_print_srvsvc_PlatformId(struct ndr_print *ndr, const char *name, enum srvsvc_PlatformId r)

6348

{

6349

const char *val = NULL;

6350

6351

switch (r) {

6352

case PLATFORM_ID_DOS: val = "PLATFORM_ID_DOS"; break;

6353

case PLATFORM_ID_OS2: val = "PLATFORM_ID_OS2"; break;

6354

case PLATFORM_ID_NT: val = "PLATFORM_ID_NT"; break;

6355

case PLATFORM_ID_OSF: val = "PLATFORM_ID_OSF"; break;

6356

case PLATFORM_ID_VMS: val = "PLATFORM_ID_VMS"; break;

6357

}

6358

ndr_print_enum(ndr, name, "ENUM", val, r);

6359

}

6360

6361

_PUBLIC_ enum ndr_err_code ndr_push_srvsvc_NetSrvInfo100(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetSrvInfo100 *r)

6362

{

6363

if (ndr_flags & NDR_SCALARS) {

6364

NDR_CHECK(ndr_push_align(ndr, 4));

6365

NDR_CHECK(ndr_push_srvsvc_PlatformId(ndr, NDR_SCALARS, r->platform_id));

6366

NDR_CHECK(ndr_push_unique_ptr(ndr, r->server_name));

6367

}

6368

if (ndr_flags & NDR_BUFFERS) {

6369

if (r->server_name) {

6370

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->server_name, CH_UTF16)));

6371

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));

6372

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->server_name, CH_UTF16)));

6373

NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->server_name, ndr_charset_length(r->server_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));

6374

}

6375

}

6376

return NDR_ERR_SUCCESS;

6377

}

6378

6379

_PUBLIC_ enum ndr_err_code ndr_pull_srvsvc_NetSrvInfo100(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetSrvInfo100 *r)

6380

{

6381

uint32_t _ptr_server_name;

6382

TALLOC_CTX *_mem_save_server_name_0;

6383

if (ndr_flags & NDR_SCALARS) {

6384

NDR_CHECK(ndr_pull_align(ndr, 4));

6385

NDR_CHECK(ndr_pull_srvsvc_PlatformId(ndr, NDR_SCALARS, &r->platform_id));

6386

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_name));

6387

if (_ptr_server_name) {

6388

NDR_PULL_ALLOC(ndr, r->server_name);

6389

} else {

6390

r->server_name = NULL;

6391

}

6392

}

6393

if (ndr_flags & NDR_BUFFERS) {

6394

if (r->server_name) {

6395

_mem_save_server_name_0 = NDR_PULL_GET_MEM_CTX(ndr);

6396

NDR_PULL_SET_MEM_CTX(ndr, r->server_name, 0);

6397

NDR_CHECK(ndr_pull_array_size(ndr, &r->server_name));

6398

NDR_CHECK(ndr_pull_array_length(ndr, &r->server_name));

6399

if (ndr_get_array_length(ndr, &r->server_name) > ndr_get_array_size(ndr, &r->server_name)) {

6400

return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->server_name), ndr_get_array_length(ndr, &r->server_name));

6401

}

6402

NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->server_name), sizeof(uint16_t)));

6403

NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->server_name, ndr_get_array_length(ndr, &r->server_name), sizeof(uint16_t), CH_UTF16));

6404

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_name_0, 0);

6405

}

6406

}

6407

return NDR_ERR_SUCCESS;

6408

}

6409

6410

_PUBLIC_ void ndr_print_srvsvc_NetSrvInfo100(struct ndr_print *ndr, const char *name, const struct srvsvc_NetSrvInfo100 *r)

6411

{

6412

ndr_print_struct(ndr, name, "srvsvc_NetSrvInfo100");

6413

ndr->depth++;

6414

ndr_print_srvsvc_PlatformId(ndr, "platform_id", r->platform_id);

6415

ndr_print_ptr(ndr, "server_name", r->server_name);

6416

ndr->depth++;

6417

if (r->server_name) {

6418

ndr_print_string(ndr, "server_name", r->server_name);

6419

}

6420

ndr->depth--;

6421

ndr->depth--;

6422

}

6423

6424

_PUBLIC_ enum ndr_err_code ndr_push_srvsvc_NetSrvInfo101(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetSrvInfo101 *r)

6425

{

6426

if (ndr_flags & NDR_SCALARS) {

6427

NDR_CHECK(ndr_push_align(ndr, 4));

6428

NDR_CHECK(ndr_push_srvsvc_PlatformId(ndr, NDR_SCALARS, r->platform_id));

6429

NDR_CHECK(ndr_push_unique_ptr(ndr, r->server_name));

6430

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->version_major));

6431

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->version_minor));

6432

NDR_CHECK(ndr_push_svcctl_ServerType(ndr, NDR_SCALARS, r->server_type));

6433

NDR_CHECK(ndr_push_unique_ptr(ndr, r->comment));

6434

}

6435

if (ndr_flags & NDR_BUFFERS) {

6436

if (r->server_name) {

6437

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->server_name, CH_UTF16)));

6438

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));

6439

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->server_name, CH_UTF16)));

6440

NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->server_name, ndr_charset_length(r->server_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));

6441

}

6442

if (r->comment) {

6443

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->comment, CH_UTF16)));

6444

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));

6445

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->comment, CH_UTF16)));

6446

NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->comment, ndr_charset_length(r->comment, CH_UTF16), sizeof(uint16_t), CH_UTF16));

6447

}

6448

}

6449

return NDR_ERR_SUCCESS;

6450

}

6451

6452

_PUBLIC_ enum ndr_err_code ndr_pull_srvsvc_NetSrvInfo101(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetSrvInfo101 *r)

6453

{

6454

uint32_t _ptr_server_name;

6455

TALLOC_CTX *_mem_save_server_name_0;

6456

uint32_t _ptr_comment;

6457

TALLOC_CTX *_mem_save_comment_0;

6458

if (ndr_flags & NDR_SCALARS) {

6459

NDR_CHECK(ndr_pull_align(ndr, 4));

6460

NDR_CHECK(ndr_pull_srvsvc_PlatformId(ndr, NDR_SCALARS, &r->platform_id));

6461

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_name));

6462

if (_ptr_server_name) {

6463

NDR_PULL_ALLOC(ndr, r->server_name);

6464

} else {

6465

r->server_name = NULL;

6466

}

6467

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version_major));

6468

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version_minor));

6469

NDR_CHECK(ndr_pull_svcctl_ServerType(ndr, NDR_SCALARS, &r->server_type));

6470

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_comment));

6471

if (_ptr_comment) {

6472

NDR_PULL_ALLOC(ndr, r->comment);

6473

} else {

6474

r->comment = NULL;

6475

}

6476

}

6477

if (ndr_flags & NDR_BUFFERS) {

6478

if (r->server_name) {

6479

_mem_save_server_name_0 = NDR_PULL_GET_MEM_CTX(ndr);

6480

NDR_PULL_SET_MEM_CTX(ndr, r->server_name, 0);

6481

NDR_CHECK(ndr_pull_array_size(ndr, &r->server_name));

6482

NDR_CHECK(ndr_pull_array_length(ndr, &r->server_name));

6483

if (ndr_get_array_length(ndr, &r->server_name) > ndr_get_array_size(ndr, &r->server_name)) {

6484

return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->server_name), ndr_get_array_length(ndr, &r->server_name));

6485

}

6486

NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->server_name), sizeof(uint16_t)));

6487

NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->server_name, ndr_get_array_length(ndr, &r->server_name), sizeof(uint16_t), CH_UTF16));

6488

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_name_0, 0);

6489

}

6490

if (r->comment) {

6491

_mem_save_comment_0 = NDR_PULL_GET_MEM_CTX(ndr);

6492

NDR_PULL_SET_MEM_CTX(ndr, r->comment, 0);

6493

NDR_CHECK(ndr_pull_array_size(ndr, &r->comment));

6494

NDR_CHECK(ndr_pull_array_length(ndr, &r->comment));

6495

if (ndr_get_array_length(ndr, &r->comment) > ndr_get_array_size(ndr, &r->comment)) {

6496

return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->comment), ndr_get_array_length(ndr, &r->comment));

6497

}

6498

NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->comment), sizeof(uint16_t)));

6499

NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->comment, ndr_get_array_length(ndr, &r->comment), sizeof(uint16_t), CH_UTF16));

6500

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_comment_0, 0);

6501

}

6502

}

6503

return NDR_ERR_SUCCESS;

6504

}

6505

6506

_PUBLIC_ void ndr_print_srvsvc_NetSrvInfo101(struct ndr_print *ndr, const char *name, const struct srvsvc_NetSrvInfo101 *r)

6507

{

6508

ndr_print_struct(ndr, name, "srvsvc_NetSrvInfo101");

6509

ndr->depth++;

6510

ndr_print_srvsvc_PlatformId(ndr, "platform_id", r->platform_id);

6511

ndr_print_ptr(ndr, "server_name", r->server_name);

6512

ndr->depth++;

6513

if (r->server_name) {

6514

ndr_print_string(ndr, "server_name", r->server_name);

6515

}

6516

ndr->depth--;

6517

ndr_print_uint32(ndr, "version_major", r->version_major);

6518

ndr_print_uint32(ndr, "version_minor", r->version_minor);

6519

ndr_print_svcctl_ServerType(ndr, "server_type", r->server_type);

6520

ndr_print_ptr(ndr, "comment", r->comment);

6521

ndr->depth++;

6522

if (r->comment) {

6523

ndr_print_string(ndr, "comment", r->comment);

6524

}

6525

ndr->depth--;

6526

ndr->depth--;

6527

}

6528

6529

static enum ndr_err_code ndr_push_srvsvc_NetSrvInfo102(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetSrvInfo102 *r)

6530

{

6531

if (ndr_flags & NDR_SCALARS) {

6532

NDR_CHECK(ndr_push_align(ndr, 4));

6533

NDR_CHECK(ndr_push_srvsvc_PlatformId(ndr, NDR_SCALARS, r->platform_id));

6534

NDR_CHECK(ndr_push_unique_ptr(ndr, r->server_name));

6535

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->version_major));

6536

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->version_minor));

6537

NDR_CHECK(ndr_push_svcctl_ServerType(ndr, NDR_SCALARS, r->server_type));

6538

NDR_CHECK(ndr_push_unique_ptr(ndr, r->comment));

6539

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->users));

6540

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->disc));

6541

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->hidden));

6542

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->announce));

6543

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->anndelta));

6544

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->licenses));

6545

NDR_CHECK(ndr_push_unique_ptr(ndr, r->userpath));

6546

}

6547

if (ndr_flags & NDR_BUFFERS) {

6548

if (r->server_name) {

6549

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->server_name, CH_UTF16)));

6550

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));

6551

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->server_name, CH_UTF16)));

6552

NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->server_name, ndr_charset_length(r->server_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));

6553

}

6554

if (r->comment) {

6555

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->comment, CH_UTF16)));

6556

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));

6557

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->comment, CH_UTF16)));

6558

NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->comment, ndr_charset_length(r->comment, CH_UTF16), sizeof(uint16_t), CH_UTF16));

6559

}

6560

if (r->userpath) {

6561

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->userpath, CH_UTF16)));

6562

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));

6563

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->userpath, CH_UTF16)));

6564

NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->userpath, ndr_charset_length(r->userpath, CH_UTF16), sizeof(uint16_t), CH_UTF16));

6565

}

6566

}

6567

return NDR_ERR_SUCCESS;

6568

}

6569

6570

static enum ndr_err_code ndr_pull_srvsvc_NetSrvInfo102(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetSrvInfo102 *r)

6571

{

6572

uint32_t _ptr_server_name;

6573

TALLOC_CTX *_mem_save_server_name_0;

6574

uint32_t _ptr_comment;

6575

TALLOC_CTX *_mem_save_comment_0;

6576

uint32_t _ptr_userpath;

6577

TALLOC_CTX *_mem_save_userpath_0;

6578

if (ndr_flags & NDR_SCALARS) {

6579

NDR_CHECK(ndr_pull_align(ndr, 4));

6580

NDR_CHECK(ndr_pull_srvsvc_PlatformId(ndr, NDR_SCALARS, &r->platform_id));

6581

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_name));

6582

if (_ptr_server_name) {

6583

NDR_PULL_ALLOC(ndr, r->server_name);

6584

} else {

6585

r->server_name = NULL;

6586

}

6587

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version_major));

6588

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version_minor));

6589

NDR_CHECK(ndr_pull_svcctl_ServerType(ndr, NDR_SCALARS, &r->server_type));

6590

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_comment));

6591

if (_ptr_comment) {

6592

NDR_PULL_ALLOC(ndr, r->comment);

6593

} else {

6594

r->comment = NULL;

6595

}

6596

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->users));

6597

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->disc));

6598

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->hidden));

6599

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->announce));

6600

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->anndelta));

6601

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->licenses));

6602

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_userpath));

6603

if (_ptr_userpath) {

6604

NDR_PULL_ALLOC(ndr, r->userpath);

6605

} else {

6606

r->userpath = NULL;

6607

}

6608

}

6609

if (ndr_flags & NDR_BUFFERS) {

6610

if (r->server_name) {

6611

_mem_save_server_name_0 = NDR_PULL_GET_MEM_CTX(ndr);

6612

NDR_PULL_SET_MEM_CTX(ndr, r->server_name, 0);

6613

NDR_CHECK(ndr_pull_array_size(ndr, &r->server_name));

6614

NDR_CHECK(ndr_pull_array_length(ndr, &r->server_name));

6615

if (ndr_get_array_length(ndr, &r->server_name) > ndr_get_array_size(ndr, &r->server_name)) {

6616

return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->server_name), ndr_get_array_length(ndr, &r->server_name));

6617

}

6618

NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->server_name), sizeof(uint16_t)));

6619

NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->server_name, ndr_get_array_length(ndr, &r->server_name), sizeof(uint16_t), CH_UTF16));

6620

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_name_0, 0);

6621

}

6622

if (r->comment) {

6623

_mem_save_comment_0 = NDR_PULL_GET_MEM_CTX(ndr);

6624

NDR_PULL_SET_MEM_CTX(ndr, r->comment, 0);

6625

NDR_CHECK(ndr_pull_array_size(ndr, &r->comment));

6626

NDR_CHECK(ndr_pull_array_length(ndr, &r->comment));

6627

if (ndr_get_array_length(ndr, &r->comment) > ndr_get_array_size(ndr, &r->comment)) {

6628

return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->comment), ndr_get_array_length(ndr, &r->comment));

6629

}

6630

NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->comment), sizeof(uint16_t)));

6631

NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->comment, ndr_get_array_length(ndr, &r->comment), sizeof(uint16_t), CH_UTF16));

6632

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_comment_0, 0);

6633

}

6634

if (r->userpath) {

6635

_mem_save_userpath_0 = NDR_PULL_GET_MEM_CTX(ndr);

6636

NDR_PULL_SET_MEM_CTX(ndr, r->userpath, 0);

6637

NDR_CHECK(ndr_pull_array_size(ndr, &r->userpath));

6638

NDR_CHECK(ndr_pull_array_length(ndr, &r->userpath));

6639

if (ndr_get_array_length(ndr, &r->userpath) > ndr_get_array_size(ndr, &r->userpath)) {

6640

return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->userpath), ndr_get_array_length(ndr, &r->userpath));

6641

}

6642

NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->userpath), sizeof(uint16_t)));

6643

NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->userpath, ndr_get_array_length(ndr, &r->userpath), sizeof(uint16_t), CH_UTF16));

6644

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_userpath_0, 0);

6645

}

6646

}

6647

return NDR_ERR_SUCCESS;

6648

}

6649

6650

_PUBLIC_ void ndr_print_srvsvc_NetSrvInfo102(struct ndr_print *ndr, const char *name, const struct srvsvc_NetSrvInfo102 *r)

6651

{

6652

ndr_print_struct(ndr, name, "srvsvc_NetSrvInfo102");

6653

ndr->depth++;

6654

ndr_print_srvsvc_PlatformId(ndr, "platform_id", r->platform_id);

6655

ndr_print_ptr(ndr, "server_name", r->server_name);

6656

ndr->depth++;

6657

if (r->server_name) {

6658

ndr_print_string(ndr, "server_name", r->server_name);

6659

}

6660

ndr->depth--;

6661

ndr_print_uint32(ndr, "version_major", r->version_major);

6662

ndr_print_uint32(ndr, "version_minor", r->version_minor);

6663

ndr_print_svcctl_ServerType(ndr, "server_type", r->server_type);

6664

ndr_print_ptr(ndr, "comment", r->comment);

6665

ndr->depth++;

6666

if (r->comment) {

6667

ndr_print_string(ndr, "comment", r->comment);

6668

}

6669

ndr->depth--;

6670

ndr_print_uint32(ndr, "users", r->users);

6671

ndr_print_uint32(ndr, "disc", r->disc);

6672

ndr_print_uint32(ndr, "hidden", r->hidden);

6673

ndr_print_uint32(ndr, "announce", r->announce);

6674

ndr_print_uint32(ndr, "anndelta", r->anndelta);

6675

ndr_print_uint32(ndr, "licenses", r->licenses);

6676

ndr_print_ptr(ndr, "userpath", r->userpath);

6677

ndr->depth++;

6678

if (r->userpath) {

6679

ndr_print_string(ndr, "userpath", r->userpath);

6680

}

6681

ndr->depth--;

6682

ndr->depth--;

6683

}

6684

6685

static enum ndr_err_code ndr_push_srvsvc_NetSrvInfo402(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetSrvInfo402 *r)

6686

{

6687

if (ndr_flags & NDR_SCALARS) {

6688

NDR_CHECK(ndr_push_align(ndr, 4));

6689

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->ulist_mtime));

6690

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->glist_mtime));

6691

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->alist_mtime));

6692

NDR_CHECK(ndr_push_unique_ptr(ndr, r->alerts));

6693

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->security));

6694

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->numadmin));

6695

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->lanmask));

6696

NDR_CHECK(ndr_push_unique_ptr(ndr, r->guestaccount));

6697

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->chdevs));

6698

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->chdevqs));

6699

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->chdevjobs));

6700

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->connections));

6701

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->shares));

6702

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->openfiles));

6703

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->sessopen));

6704

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->sesssvc));

6705

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->sessreqs));

6706

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->opensearch));

6707

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->activelocks));

6708

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->numreqbufs));

6709

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->sizereqbufs));

6710

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->numbigbufs));

6711

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->numfiletasks));

6712

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->alertsched));

6713

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->erroralert));

6714

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->logonalert));

6715

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->accessalert));

6716

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->diskalert));

6717

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->netioalert));

6718

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->maxaudits));

6719

NDR_CHECK(ndr_push_unique_ptr(ndr, r->srvheuristics));

6720

}

6721

if (ndr_flags & NDR_BUFFERS) {

6722

if (r->alerts) {

6723

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->alerts, CH_UTF16)));

6724

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));

6725

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->alerts, CH_UTF16)));

6726

NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->alerts, ndr_charset_length(r->alerts, CH_UTF16), sizeof(uint16_t), CH_UTF16));

6727

}

6728

if (r->guestaccount) {

6729

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->guestaccount, CH_UTF16)));

6730

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));

6731

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->guestaccount, CH_UTF16)));

6732

NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->guestaccount, ndr_charset_length(r->guestaccount, CH_UTF16), sizeof(uint16_t), CH_UTF16));

6733

}

6734

if (r->srvheuristics) {

6735

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->srvheuristics, CH_UTF16)));

6736

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));

6737

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->srvheuristics, CH_UTF16)));

6738

NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->srvheuristics, ndr_charset_length(r->srvheuristics, CH_UTF16), sizeof(uint16_t), CH_UTF16));

6739

}

6740

}

6741

return NDR_ERR_SUCCESS;

6742

}

6743

6744

static enum ndr_err_code ndr_pull_srvsvc_NetSrvInfo402(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetSrvInfo402 *r)

6745

{

6746

uint32_t _ptr_alerts;

6747

TALLOC_CTX *_mem_save_alerts_0;

6748

uint32_t _ptr_guestaccount;

6749

TALLOC_CTX *_mem_save_guestaccount_0;

6750

uint32_t _ptr_srvheuristics;

6751

TALLOC_CTX *_mem_save_srvheuristics_0;

6752

if (ndr_flags & NDR_SCALARS) {

6753

NDR_CHECK(ndr_pull_align(ndr, 4));

6754

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->ulist_mtime));

6755

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->glist_mtime));

6756

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->alist_mtime));

6757

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_alerts));

6758

if (_ptr_alerts) {

6759

NDR_PULL_ALLOC(ndr, r->alerts);

6760

} else {

6761

r->alerts = NULL;

6762

}

6763

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->security));

6764

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->numadmin));

6765

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->lanmask));

6766

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_guestaccount));

6767

if (_ptr_guestaccount) {

6768

NDR_PULL_ALLOC(ndr, r->guestaccount);

6769

} else {

6770

r->guestaccount = NULL;

6771

}

6772

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->chdevs));

6773

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->chdevqs));

6774

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->chdevjobs));

6775

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->connections));

6776

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->shares));

6777

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->openfiles));

6778

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->sessopen));

6779

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->sesssvc));

6780

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->sessreqs));

6781

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->opensearch));

6782

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->activelocks));

6783

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->numreqbufs));

6784

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->sizereqbufs));

6785

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->numbigbufs));

6786

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->numfiletasks));

6787

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->alertsched));

6788

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->erroralert));

6789

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->logonalert));

6790

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->accessalert));

6791

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->diskalert));

6792

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->netioalert));

6793

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->maxaudits));

6794

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_srvheuristics));

6795

if (_ptr_srvheuristics) {

6796

NDR_PULL_ALLOC(ndr, r->srvheuristics);

6797

} else {

6798

r->srvheuristics = NULL;

6799

}

6800

}

6801

if (ndr_flags & NDR_BUFFERS) {

6802

if (r->alerts) {

6803

_mem_save_alerts_0 = NDR_PULL_GET_MEM_CTX(ndr);

6804

NDR_PULL_SET_MEM_CTX(ndr, r->alerts, 0);

6805

NDR_CHECK(ndr_pull_array_size(ndr, &r->alerts));

6806

NDR_CHECK(ndr_pull_array_length(ndr, &r->alerts));

6807

if (ndr_get_array_length(ndr, &r->alerts) > ndr_get_array_size(ndr, &r->alerts)) {

6808

return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->alerts), ndr_get_array_length(ndr, &r->alerts));

6809

}

6810

NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->alerts), sizeof(uint16_t)));

6811

NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->alerts, ndr_get_array_length(ndr, &r->alerts), sizeof(uint16_t), CH_UTF16));

6812

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_alerts_0, 0);

6813

}

6814

if (r->guestaccount) {

6815

_mem_save_guestaccount_0 = NDR_PULL_GET_MEM_CTX(ndr);

6816

NDR_PULL_SET_MEM_CTX(ndr, r->guestaccount, 0);

6817

NDR_CHECK(ndr_pull_array_size(ndr, &r->guestaccount));

6818

NDR_CHECK(ndr_pull_array_length(ndr, &r->guestaccount));

6819

if (ndr_get_array_length(ndr, &r->guestaccount) > ndr_get_array_size(ndr, &r->guestaccount)) {

6820

return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->guestaccount), ndr_get_array_length(ndr, &r->guestaccount));

6821

}

6822

NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->guestaccount), sizeof(uint16_t)));

6823

NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->guestaccount, ndr_get_array_length(ndr, &r->guestaccount), sizeof(uint16_t), CH_UTF16));

6824

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_guestaccount_0, 0);

6825

}

6826

if (r->srvheuristics) {

6827

_mem_save_srvheuristics_0 = NDR_PULL_GET_MEM_CTX(ndr);

6828

NDR_PULL_SET_MEM_CTX(ndr, r->srvheuristics, 0);

6829

NDR_CHECK(ndr_pull_array_size(ndr, &r->srvheuristics));

6830

NDR_CHECK(ndr_pull_array_length(ndr, &r->srvheuristics));

6831

if (ndr_get_array_length(ndr, &r->srvheuristics) > ndr_get_array_size(ndr, &r->srvheuristics)) {

6832

return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->srvheuristics), ndr_get_array_length(ndr, &r->srvheuristics));

6833

}

6834

NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->srvheuristics), sizeof(uint16_t)));

6835

NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->srvheuristics, ndr_get_array_length(ndr, &r->srvheuristics), sizeof(uint16_t), CH_UTF16));

6836

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_srvheuristics_0, 0);

6837

}

6838

}

6839

return NDR_ERR_SUCCESS;

6840

}

6841

6842

_PUBLIC_ void ndr_print_srvsvc_NetSrvInfo402(struct ndr_print *ndr, const char *name, const struct srvsvc_NetSrvInfo402 *r)

6843

{

6844

ndr_print_struct(ndr, name, "srvsvc_NetSrvInfo402");

6845

ndr->depth++;

6846

ndr_print_uint32(ndr, "ulist_mtime", r->ulist_mtime);

6847

ndr_print_uint32(ndr, "glist_mtime", r->glist_mtime);

6848

ndr_print_uint32(ndr, "alist_mtime", r->alist_mtime);

6849

ndr_print_ptr(ndr, "alerts", r->alerts);

6850

ndr->depth++;

6851

if (r->alerts) {

6852

ndr_print_string(ndr, "alerts", r->alerts);

6853

}

6854

ndr->depth--;

6855

ndr_print_uint32(ndr, "security", r->security);

6856

ndr_print_uint32(ndr, "numadmin", r->numadmin);

6857

ndr_print_uint32(ndr, "lanmask", r->lanmask);

6858

ndr_print_ptr(ndr, "guestaccount", r->guestaccount);

6859

ndr->depth++;

6860

if (r->guestaccount) {

6861

ndr_print_string(ndr, "guestaccount", r->guestaccount);

6862

}

6863

ndr->depth--;

6864

ndr_print_uint32(ndr, "chdevs", r->chdevs);

6865

ndr_print_uint32(ndr, "chdevqs", r->chdevqs);

6866

ndr_print_uint32(ndr, "chdevjobs", r->chdevjobs);

6867

ndr_print_uint32(ndr, "connections", r->connections);

6868

ndr_print_uint32(ndr, "shares", r->shares);

6869

ndr_print_uint32(ndr, "openfiles", r->openfiles);

6870

ndr_print_uint32(ndr, "sessopen", r->sessopen);

6871

ndr_print_uint32(ndr, "sesssvc", r->sesssvc);

6872

ndr_print_uint32(ndr, "sessreqs", r->sessreqs);

6873

ndr_print_uint32(ndr, "opensearch", r->opensearch);

6874

ndr_print_uint32(ndr, "activelocks", r->activelocks);

6875

ndr_print_uint32(ndr, "numreqbufs", r->numreqbufs);

6876

ndr_print_uint32(ndr, "sizereqbufs", r->sizereqbufs);

6877

ndr_print_uint32(ndr, "numbigbufs", r->numbigbufs);

6878

ndr_print_uint32(ndr, "numfiletasks", r->numfiletasks);

6879

ndr_print_uint32(ndr, "alertsched", r->alertsched);

6880

ndr_print_uint32(ndr, "erroralert", r->erroralert);

6881

ndr_print_uint32(ndr, "logonalert", r->logonalert);

6882

ndr_print_uint32(ndr, "accessalert", r->accessalert);

6883

ndr_print_uint32(ndr, "diskalert", r->diskalert);

6884

ndr_print_uint32(ndr, "netioalert", r->netioalert);

6885

ndr_print_uint32(ndr, "maxaudits", r->maxaudits);

6886

ndr_print_ptr(ndr, "srvheuristics", r->srvheuristics);

6887

ndr->depth++;

6888

if (r->srvheuristics) {

6889

ndr_print_string(ndr, "srvheuristics", r->srvheuristics);

6890

}

6891

ndr->depth--;

6892

ndr->depth--;

6893

}

6894

6895

static enum ndr_err_code ndr_push_srvsvc_NetSrvInfo403(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetSrvInfo403 *r)

6896

{

6897

if (ndr_flags & NDR_SCALARS) {

6898

NDR_CHECK(ndr_push_align(ndr, 4));

6899

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->ulist_mtime));

6900

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->glist_mtime));

6901

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->alist_mtime));

6902

NDR_CHECK(ndr_push_unique_ptr(ndr, r->alerts));

6903

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->security));

6904

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->numadmin));

6905

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->lanmask));

6906

NDR_CHECK(ndr_push_unique_ptr(ndr, r->guestaccount));

6907

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->chdevs));

6908

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->chdevqs));

6909

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->chdevjobs));

6910

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->connections));

6911

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->shares));

6912

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->openfiles));

6913

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->sessopen));

6914

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->sesssvc));

6915

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->sessreqs));

6916

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->opensearch));

6917

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->activelocks));

6918

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->numreqbufs));

6919

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->sizereqbufs));

6920

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->numbigbufs));

6921

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->numfiletasks));

6922

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->alertsched));

6923

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->erroralert));

6924

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->logonalert));

6925

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->accessalert));

6926

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->diskalert));

6927

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->netioalert));

6928

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->maxaudits));

6929

NDR_CHECK(ndr_push_unique_ptr(ndr, r->srvheuristics));

6930

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->auditedevents));

6931

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->auditprofile));

6932

NDR_CHECK(ndr_push_unique_ptr(ndr, r->autopath));

6933

}

6934

if (ndr_flags & NDR_BUFFERS) {

6935

if (r->alerts) {

6936

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->alerts, CH_UTF16)));

6937

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));

6938

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->alerts, CH_UTF16)));

6939

NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->alerts, ndr_charset_length(r->alerts, CH_UTF16), sizeof(uint16_t), CH_UTF16));

6940

}

6941

if (r->guestaccount) {

6942

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->guestaccount, CH_UTF16)));

6943

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));

6944

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->guestaccount, CH_UTF16)));

6945

NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->guestaccount, ndr_charset_length(r->guestaccount, CH_UTF16), sizeof(uint16_t), CH_UTF16));

6946

}

6947

if (r->srvheuristics) {

6948

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->srvheuristics, CH_UTF16)));

6949

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));

6950

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->srvheuristics, CH_UTF16)));

6951

NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->srvheuristics, ndr_charset_length(r->srvheuristics, CH_UTF16), sizeof(uint16_t), CH_UTF16));

6952

}

6953

if (r->autopath) {

6954

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->autopath, CH_UTF16)));

6955

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));

6956

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->autopath, CH_UTF16)));

6957

NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->autopath, ndr_charset_length(r->autopath, CH_UTF16), sizeof(uint16_t), CH_UTF16));

6958

}

6959

}

6960

return NDR_ERR_SUCCESS;

6961

}

6962

6963

static enum ndr_err_code ndr_pull_srvsvc_NetSrvInfo403(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetSrvInfo403 *r)

6964

{

6965

uint32_t _ptr_alerts;

6966

TALLOC_CTX *_mem_save_alerts_0;

6967

uint32_t _ptr_guestaccount;

6968

TALLOC_CTX *_mem_save_guestaccount_0;

6969

uint32_t _ptr_srvheuristics;

6970

TALLOC_CTX *_mem_save_srvheuristics_0;

6971

uint32_t _ptr_autopath;

6972

TALLOC_CTX *_mem_save_autopath_0;

6973

if (ndr_flags & NDR_SCALARS) {

6974

NDR_CHECK(ndr_pull_align(ndr, 4));

6975

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->ulist_mtime));

6976

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->glist_mtime));

6977

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->alist_mtime));

6978

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_alerts));

6979

if (_ptr_alerts) {

6980

NDR_PULL_ALLOC(ndr, r->alerts);

6981

} else {

6982

r->alerts = NULL;

6983

}

6984

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->security));

6985

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->numadmin));

6986

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->lanmask));

6987

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_guestaccount));

6988

if (_ptr_guestaccount) {

6989

NDR_PULL_ALLOC(ndr, r->guestaccount);

6990

} else {

6991

r->guestaccount = NULL;

6992

}

6993

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->chdevs));

6994

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->chdevqs));

6995

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->chdevjobs));

6996

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->connections));

6997

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->shares));

6998

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->openfiles));

6999

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->sessopen));

7000

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->sesssvc));

7001

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->sessreqs));

7002

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->opensearch));

7003

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->activelocks));

7004

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->numreqbufs));

7005

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->sizereqbufs));

7006

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->numbigbufs));

7007

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->numfiletasks));

7008

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->alertsched));

7009

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->erroralert));

7010

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->logonalert));

7011

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->accessalert));

7012

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->diskalert));

7013

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->netioalert));

7014

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->maxaudits));

7015

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_srvheuristics));

7016

if (_ptr_srvheuristics) {

7017

NDR_PULL_ALLOC(ndr, r->srvheuristics);

7018

} else {

7019

r->srvheuristics = NULL;

7020

}

7021

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->auditedevents));

7022

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->auditprofile));

7023

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_autopath));

7024

if (_ptr_autopath) {

7025

NDR_PULL_ALLOC(ndr, r->autopath);

7026

} else {

7027

r->autopath = NULL;

7028

}

7029

}

7030

if (ndr_flags & NDR_BUFFERS) {

7031

if (r->alerts) {

7032

_mem_save_alerts_0 = NDR_PULL_GET_MEM_CTX(ndr);

7033

NDR_PULL_SET_MEM_CTX(ndr, r->alerts, 0);

7034

NDR_CHECK(ndr_pull_array_size(ndr, &r->alerts));

7035

NDR_CHECK(ndr_pull_array_length(ndr, &r->alerts));

7036

if (ndr_get_array_length(ndr, &r->alerts) > ndr_get_array_size(ndr, &r->alerts)) {

7037

return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->alerts), ndr_get_array_length(ndr, &r->alerts));

7038

}

7039

NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->alerts), sizeof(uint16_t)));

7040

NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->alerts, ndr_get_array_length(ndr, &r->alerts), sizeof(uint16_t), CH_UTF16));

7041

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_alerts_0, 0);

7042

}

7043

if (r->guestaccount) {

7044

_mem_save_guestaccount_0 = NDR_PULL_GET_MEM_CTX(ndr);

7045

NDR_PULL_SET_MEM_CTX(ndr, r->guestaccount, 0);

7046

NDR_CHECK(ndr_pull_array_size(ndr, &r->guestaccount));

7047

NDR_CHECK(ndr_pull_array_length(ndr, &r->guestaccount));

7048

if (ndr_get_array_length(ndr, &r->guestaccount) > ndr_get_array_size(ndr, &r->guestaccount)) {

7049

return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->guestaccount), ndr_get_array_length(ndr, &r->guestaccount));

7050

}

7051

NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->guestaccount), sizeof(uint16_t)));

7052

NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->guestaccount, ndr_get_array_length(ndr, &r->guestaccount), sizeof(uint16_t), CH_UTF16));

7053

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_guestaccount_0, 0);

7054

}

7055

if (r->srvheuristics) {

7056

_mem_save_srvheuristics_0 = NDR_PULL_GET_MEM_CTX(ndr);

7057

NDR_PULL_SET_MEM_CTX(ndr, r->srvheuristics, 0);

7058

NDR_CHECK(ndr_pull_array_size(ndr, &r->srvheuristics));

7059

NDR_CHECK(ndr_pull_array_length(ndr, &r->srvheuristics));

7060

if (ndr_get_array_length(ndr, &r->srvheuristics) > ndr_get_array_size(ndr, &r->srvheuristics)) {

7061

return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->srvheuristics), ndr_get_array_length(ndr, &r->srvheuristics));

7062

}

7063

NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->srvheuristics), sizeof(uint16_t)));

7064

NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->srvheuristics, ndr_get_array_length(ndr, &r->srvheuristics), sizeof(uint16_t), CH_UTF16));

7065

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_srvheuristics_0, 0);

7066

}

7067

if (r->autopath) {

7068

_mem_save_autopath_0 = NDR_PULL_GET_MEM_CTX(ndr);

7069

NDR_PULL_SET_MEM_CTX(ndr, r->autopath, 0);

7070

NDR_CHECK(ndr_pull_array_size(ndr, &r->autopath));

7071

NDR_CHECK(ndr_pull_array_length(ndr, &r->autopath));

7072

if (ndr_get_array_length(ndr, &r->autopath) > ndr_get_array_size(ndr, &r->autopath)) {

7073

return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->autopath), ndr_get_array_length(ndr, &r->autopath));

7074

}

7075

NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->autopath), sizeof(uint16_t)));

7076

NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->autopath, ndr_get_array_length(ndr, &r->autopath), sizeof(uint16_t), CH_UTF16));

7077

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_autopath_0, 0);

7078

}

7079

}

7080

return NDR_ERR_SUCCESS;

7081

}

7082

7083

_PUBLIC_ void ndr_print_srvsvc_NetSrvInfo403(struct ndr_print *ndr, const char *name, const struct srvsvc_NetSrvInfo403 *r)

7084

{

7085

ndr_print_struct(ndr, name, "srvsvc_NetSrvInfo403");

7086

ndr->depth++;

7087

ndr_print_uint32(ndr, "ulist_mtime", r->ulist_mtime);

7088

ndr_print_uint32(ndr, "glist_mtime", r->glist_mtime);

7089

ndr_print_uint32(ndr, "alist_mtime", r->alist_mtime);

7090

ndr_print_ptr(ndr, "alerts", r->alerts);

7091

ndr->depth++;

7092

if (r->alerts) {

7093

ndr_print_string(ndr, "alerts", r->alerts);

7094

}

7095

ndr->depth--;

7096

ndr_print_uint32(ndr, "security", r->security);

7097

ndr_print_uint32(ndr, "numadmin", r->numadmin);

7098

ndr_print_uint32(ndr, "lanmask", r->lanmask);

7099

ndr_print_ptr(ndr, "guestaccount", r->guestaccount);

7100

ndr->depth++;

7101

if (r->guestaccount) {

7102

ndr_print_string(ndr, "guestaccount", r->guestaccount);

7103

}

7104

ndr->depth--;

7105

ndr_print_uint32(ndr, "chdevs", r->chdevs);

7106

ndr_print_uint32(ndr, "chdevqs", r->chdevqs);

7107

ndr_print_uint32(ndr, "chdevjobs", r->chdevjobs);

7108

ndr_print_uint32(ndr, "connections", r->connections);

7109

ndr_print_uint32(ndr, "shares", r->shares);

7110

ndr_print_uint32(ndr, "openfiles", r->openfiles);

7111

ndr_print_uint32(ndr, "sessopen", r->sessopen);

7112

ndr_print_uint32(ndr, "sesssvc", r->sesssvc);

7113

ndr_print_uint32(ndr, "sessreqs", r->sessreqs);

7114

ndr_print_uint32(ndr, "opensearch", r->opensearch);

7115

ndr_print_uint32(ndr, "activelocks", r->activelocks);

7116

ndr_print_uint32(ndr, "numreqbufs", r->numreqbufs);

7117

ndr_print_uint32(ndr, "sizereqbufs", r->sizereqbufs);

7118

ndr_print_uint32(ndr, "numbigbufs", r->numbigbufs);

7119

ndr_print_uint32(ndr, "numfiletasks", r->numfiletasks);

7120

ndr_print_uint32(ndr, "alertsched", r->alertsched);

7121

ndr_print_uint32(ndr, "erroralert", r->erroralert);

7122

ndr_print_uint32(ndr, "logonalert", r->logonalert);

7123

ndr_print_uint32(ndr, "accessalert", r->accessalert);

7124

ndr_print_uint32(ndr, "diskalert", r->diskalert);

7125

ndr_print_uint32(ndr, "netioalert", r->netioalert);

7126

ndr_print_uint32(ndr, "maxaudits", r->maxaudits);

7127

ndr_print_ptr(ndr, "srvheuristics", r->srvheuristics);

7128

ndr->depth++;

7129

if (r->srvheuristics) {

7130

ndr_print_string(ndr, "srvheuristics", r->srvheuristics);

7131

}

7132

ndr->depth--;

7133

ndr_print_uint32(ndr, "auditedevents", r->auditedevents);

7134

ndr_print_uint32(ndr, "auditprofile", r->auditprofile);

7135

ndr_print_ptr(ndr, "autopath", r->autopath);

7136

ndr->depth++;

7137

if (r->autopath) {

7138

ndr_print_string(ndr, "autopath", r->autopath);

7139

}

7140

ndr->depth--;

7141

ndr->depth--;

7142

}

7143

7144

static enum ndr_err_code ndr_push_srvsvc_NetSrvInfo502(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetSrvInfo502 *r)

7145

{

7146

if (ndr_flags & NDR_SCALARS) {

7147

NDR_CHECK(ndr_push_align(ndr, 4));

7148

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->sessopen));

7149

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->sesssvc));

7150

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->opensearch));

7151

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->sizereqbufs));

7152

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->initworkitems));

7153

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->maxworkitems));

7154

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->rawworkitems));

7155

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->irpstacksize));

7156

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->maxrawbuflen));

7157

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->sessusers));

7158

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->sessconns));

7159

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->maxpagedmemoryusage));

7160

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->maxnonpagedmemoryusage));

7161

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->enablesoftcompat));

7162

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->enableforcedlogoff));

7163

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->timesource));

7164

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->acceptdownlevelapis));

7165

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->lmannounce));

7166

}

7167

if (ndr_flags & NDR_BUFFERS) {

7168

}

7169

return NDR_ERR_SUCCESS;

7170

}

7171

7172

static enum ndr_err_code ndr_pull_srvsvc_NetSrvInfo502(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetSrvInfo502 *r)

7173

{

7174

if (ndr_flags & NDR_SCALARS) {

7175

NDR_CHECK(ndr_pull_align(ndr, 4));

7176

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->sessopen));

7177

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->sesssvc));

7178

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->opensearch));

7179

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->sizereqbufs));

7180

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->initworkitems));

7181

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->maxworkitems));

7182

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->rawworkitems));

7183

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->irpstacksize));

7184

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->maxrawbuflen));

7185

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->sessusers));

7186

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->sessconns));

7187

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->maxpagedmemoryusage));

7188

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->maxnonpagedmemoryusage));

7189

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->enablesoftcompat));

7190

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->enableforcedlogoff));

7191

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->timesource));

7192

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->acceptdownlevelapis));

7193

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->lmannounce));

7194

}

7195

if (ndr_flags & NDR_BUFFERS) {

7196

}

7197

return NDR_ERR_SUCCESS;

7198

}

7199

7200

_PUBLIC_ void ndr_print_srvsvc_NetSrvInfo502(struct ndr_print *ndr, const char *name, const struct srvsvc_NetSrvInfo502 *r)

7201

{

7202

ndr_print_struct(ndr, name, "srvsvc_NetSrvInfo502");

7203

ndr->depth++;

7204

ndr_print_uint32(ndr, "sessopen", r->sessopen);

7205

ndr_print_uint32(ndr, "sesssvc", r->sesssvc);

7206

ndr_print_uint32(ndr, "opensearch", r->opensearch);

7207

ndr_print_uint32(ndr, "sizereqbufs", r->sizereqbufs);

7208

ndr_print_uint32(ndr, "initworkitems", r->initworkitems);

7209

ndr_print_uint32(ndr, "maxworkitems", r->maxworkitems);

7210

ndr_print_uint32(ndr, "rawworkitems", r->rawworkitems);

7211

ndr_print_uint32(ndr, "irpstacksize", r->irpstacksize);

7212

ndr_print_uint32(ndr, "maxrawbuflen", r->maxrawbuflen);

7213

ndr_print_uint32(ndr, "sessusers", r->sessusers);

7214

ndr_print_uint32(ndr, "sessconns", r->sessconns);

7215

ndr_print_uint32(ndr, "maxpagedmemoryusage", r->maxpagedmemoryusage);

7216

ndr_print_uint32(ndr, "maxnonpagedmemoryusage", r->maxnonpagedmemoryusage);

7217

ndr_print_uint32(ndr, "enablesoftcompat", r->enablesoftcompat);

7218

ndr_print_uint32(ndr, "enableforcedlogoff", r->enableforcedlogoff);

7219

ndr_print_uint32(ndr, "timesource", r->timesource);

7220

ndr_print_uint32(ndr, "acceptdownlevelapis", r->acceptdownlevelapis);

7221

ndr_print_uint32(ndr, "lmannounce", r->lmannounce);

7222

ndr->depth--;

7223

}

7224

7225

static enum ndr_err_code ndr_push_srvsvc_NetSrvInfo503(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetSrvInfo503 *r)

7226

{

7227

if (ndr_flags & NDR_SCALARS) {

7228

NDR_CHECK(ndr_push_align(ndr, 4));

7229

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->sessopen));

7230

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->sesssvc));

7231

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->opensearch));

7232

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->sizereqbufs));

7233

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->initworkitems));

7234

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->maxworkitems));

7235

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->rawworkitems));

7236

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->irpstacksize));

7237

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->maxrawbuflen));

7238

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->sessusers));

7239

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->sessconns));

7240

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->maxpagedmemoryusage));

7241

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->maxnonpagedmemoryusage));

7242

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->enablesoftcompat));

7243

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->enableforcedlogoff));

7244

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->timesource));

7245

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->acceptdownlevelapis));

7246

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->lmannounce));

7247

NDR_CHECK(ndr_push_unique_ptr(ndr, r->domain));

7248

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->maxcopyreadlen));

7249

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->maxcopywritelen));

7250

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->minkeepsearch));

7251

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->maxkeepsearch));

7252

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->minkeepcomplsearch));

7253

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->maxkeepcomplsearch));

7254

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->threadcountadd));

7255

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->numlockthreads));

7256

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->scavtimeout));

7257

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->minrcvqueue));

7258

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->minfreeworkitems));

7259

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->xactmemsize));

7260

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->threadpriority));

7261

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->maxmpxct));

7262

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->oplockbreakwait));

7263

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->oplockbreakresponsewait));

7264

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->enableoplocks));

7265

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->enableoplockforceclose));

7266

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->enablefcbopens));

7267

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->enableraw));

7268

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->enablesharednetdrives));

7269

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->minfreeconnections));

7270

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->maxfreeconnections));

7271

}

7272

if (ndr_flags & NDR_BUFFERS) {

7273

if (r->domain) {

7274

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->domain, CH_UTF16)));

7275

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));

7276

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->domain, CH_UTF16)));

7277

NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->domain, ndr_charset_length(r->domain, CH_UTF16), sizeof(uint16_t), CH_UTF16));

7278

}

7279

}

7280

return NDR_ERR_SUCCESS;

7281

}

7282

7283

static enum ndr_err_code ndr_pull_srvsvc_NetSrvInfo503(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetSrvInfo503 *r)

7284

{

7285

uint32_t _ptr_domain;

7286

TALLOC_CTX *_mem_save_domain_0;

7287

if (ndr_flags & NDR_SCALARS) {

7288

NDR_CHECK(ndr_pull_align(ndr, 4));

7289

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->sessopen));

7290

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->sesssvc));

7291

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->opensearch));

7292

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->sizereqbufs));

7293

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->initworkitems));

7294

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->maxworkitems));

7295

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->rawworkitems));

7296

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->irpstacksize));

7297

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->maxrawbuflen));

7298

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->sessusers));

7299

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->sessconns));

7300

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->maxpagedmemoryusage));

7301

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->maxnonpagedmemoryusage));

7302

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->enablesoftcompat));

7303

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->enableforcedlogoff));

7304

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->timesource));

7305

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->acceptdownlevelapis));

7306

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->lmannounce));

7307

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_domain));

7308

if (_ptr_domain) {

7309

NDR_PULL_ALLOC(ndr, r->domain);

7310

} else {

7311

r->domain = NULL;

7312

}

7313

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->maxcopyreadlen));

7314

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->maxcopywritelen));

7315

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->minkeepsearch));

7316

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->maxkeepsearch));

7317

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->minkeepcomplsearch));

7318

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->maxkeepcomplsearch));

7319

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->threadcountadd));

7320

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->numlockthreads));

7321

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->scavtimeout));

7322

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->minrcvqueue));

7323

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->minfreeworkitems));

7324

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->xactmemsize));

7325

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->threadpriority));

7326

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->maxmpxct));

7327

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->oplockbreakwait));

7328

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->oplockbreakresponsewait));

7329

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->enableoplocks));

7330

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->enableoplockforceclose));

7331

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->enablefcbopens));

7332

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->enableraw));

7333

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->enablesharednetdrives));

7334

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->minfreeconnections));

7335

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->maxfreeconnections));

7336

}

7337

if (ndr_flags & NDR_BUFFERS) {

7338

if (r->domain) {

7339

_mem_save_domain_0 = NDR_PULL_GET_MEM_CTX(ndr);

7340

NDR_PULL_SET_MEM_CTX(ndr, r->domain, 0);

7341

NDR_CHECK(ndr_pull_array_size(ndr, &r->domain));

7342

NDR_CHECK(ndr_pull_array_length(ndr, &r->domain));

7343

if (ndr_get_array_length(ndr, &r->domain) > ndr_get_array_size(ndr, &r->domain)) {

7344

return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->domain), ndr_get_array_length(ndr, &r->domain));

7345

}

7346

NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->domain), sizeof(uint16_t)));

7347

NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->domain, ndr_get_array_length(ndr, &r->domain), sizeof(uint16_t), CH_UTF16));

7348

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domain_0, 0);

7349

}

7350

}

7351

return NDR_ERR_SUCCESS;

7352

}

7353

7354

_PUBLIC_ void ndr_print_srvsvc_NetSrvInfo503(struct ndr_print *ndr, const char *name, const struct srvsvc_NetSrvInfo503 *r)

7355

{

7356

ndr_print_struct(ndr, name, "srvsvc_NetSrvInfo503");

7357

ndr->depth++;

7358

ndr_print_uint32(ndr, "sessopen", r->sessopen);

7359

ndr_print_uint32(ndr, "sesssvc", r->sesssvc);

7360

ndr_print_uint32(ndr, "opensearch", r->opensearch);

7361

ndr_print_uint32(ndr, "sizereqbufs", r->sizereqbufs);

7362

ndr_print_uint32(ndr, "initworkitems", r->initworkitems);

7363

ndr_print_uint32(ndr, "maxworkitems", r->maxworkitems);

7364

ndr_print_uint32(ndr, "rawworkitems", r->rawworkitems);

7365

ndr_print_uint32(ndr, "irpstacksize", r->irpstacksize);

7366

ndr_print_uint32(ndr, "maxrawbuflen", r->maxrawbuflen);

7367

ndr_print_uint32(ndr, "sessusers", r->sessusers);

7368

ndr_print_uint32(ndr, "sessconns", r->sessconns);

7369

ndr_print_uint32(ndr, "maxpagedmemoryusage", r->maxpagedmemoryusage);

7370

ndr_print_uint32(ndr, "maxnonpagedmemoryusage", r->maxnonpagedmemoryusage);

7371

ndr_print_uint32(ndr, "enablesoftcompat", r->enablesoftcompat);

7372

ndr_print_uint32(ndr, "enableforcedlogoff", r->enableforcedlogoff);

7373

ndr_print_uint32(ndr, "timesource", r->timesource);

7374

ndr_print_uint32(ndr, "acceptdownlevelapis", r->acceptdownlevelapis);

7375

ndr_print_uint32(ndr, "lmannounce", r->lmannounce);

7376

ndr_print_ptr(ndr, "domain", r->domain);

7377

ndr->depth++;

7378

if (r->domain) {

7379

ndr_print_string(ndr, "domain", r->domain);

7380

}

7381

ndr->depth--;

7382

ndr_print_uint32(ndr, "maxcopyreadlen", r->maxcopyreadlen);

7383

ndr_print_uint32(ndr, "maxcopywritelen", r->maxcopywritelen);

7384

ndr_print_uint32(ndr, "minkeepsearch", r->minkeepsearch);

7385

ndr_print_uint32(ndr, "maxkeepsearch", r->maxkeepsearch);

7386

ndr_print_uint32(ndr, "minkeepcomplsearch", r->minkeepcomplsearch);

7387

ndr_print_uint32(ndr, "maxkeepcomplsearch", r->maxkeepcomplsearch);

7388

ndr_print_uint32(ndr, "threadcountadd", r->threadcountadd);

7389

ndr_print_uint32(ndr, "numlockthreads", r->numlockthreads);

7390

ndr_print_uint32(ndr, "scavtimeout", r->scavtimeout);

7391

ndr_print_uint32(ndr, "minrcvqueue", r->minrcvqueue);

7392

ndr_print_uint32(ndr, "minfreeworkitems", r->minfreeworkitems);

7393

ndr_print_uint32(ndr, "xactmemsize", r->xactmemsize);

7394

ndr_print_uint32(ndr, "threadpriority", r->threadpriority);

7395

ndr_print_uint32(ndr, "maxmpxct", r->maxmpxct);

7396

ndr_print_uint32(ndr, "oplockbreakwait", r->oplockbreakwait);

7397

ndr_print_uint32(ndr, "oplockbreakresponsewait", r->oplockbreakresponsewait);

7398

ndr_print_uint32(ndr, "enableoplocks", r->enableoplocks);

7399

ndr_print_uint32(ndr, "enableoplockforceclose", r->enableoplockforceclose);

7400

ndr_print_uint32(ndr, "enablefcbopens", r->enablefcbopens);

7401

ndr_print_uint32(ndr, "enableraw", r->enableraw);

7402

ndr_print_uint32(ndr, "enablesharednetdrives", r->enablesharednetdrives);

7403

ndr_print_uint32(ndr, "minfreeconnections", r->minfreeconnections);

7404

ndr_print_uint32(ndr, "maxfreeconnections", r->maxfreeconnections);

7405

ndr->depth--;

7406

}

7407

7408

static enum ndr_err_code ndr_push_srvsvc_NetSrvInfo599(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetSrvInfo599 *r)

7409

{

7410

if (ndr_flags & NDR_SCALARS) {

7411

NDR_CHECK(ndr_push_align(ndr, 4));

7412

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->sessopen));

7413

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->sesssvc));

7414

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->opensearch));

7415

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->sizereqbufs));

7416

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->initworkitems));

7417

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->maxworkitems));

7418

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->rawworkitems));

7419

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->irpstacksize));

7420

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->maxrawbuflen));

7421

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->sessusers));

7422

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->sessconns));

7423

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->maxpagedmemoryusage));

7424

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->maxnonpagedmemoryusage));

7425

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->enablesoftcompat));

7426

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->enableforcedlogoff));

7427

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->timesource));

7428

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->acceptdownlevelapis));

7429

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->lmannounce));

7430

NDR_CHECK(ndr_push_unique_ptr(ndr, r->domain));

7431

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->maxcopyreadlen));

7432

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->maxcopywritelen));

7433

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->minkeepsearch));

7434

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->minkeepcomplsearch));

7435

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->maxkeepcomplsearch));

7436

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->threadcountadd));

7437

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->numlockthreads));

7438

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->scavtimeout));

7439

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->minrcvqueue));

7440

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->minfreeworkitems));

7441

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->xactmemsize));

7442

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->threadpriority));

7443

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->maxmpxct));

7444

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->oplockbreakwait));

7445

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->oplockbreakresponsewait));

7446

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->enableoplocks));

7447

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->enableoplockforceclose));

7448

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->enablefcbopens));

7449

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->enableraw));

7450

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->enablesharednetdrives));

7451

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->minfreeconnections));

7452

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->maxfreeconnections));

7453

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->initsesstable));

7454

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->initconntable));

7455

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->initfiletable));

7456

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->initsearchtable));

7457

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->alertsched));

7458

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->errortreshold));

7459

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->networkerrortreshold));

7460

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->diskspacetreshold));

7461

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved));

7462

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->maxlinkdelay));

7463

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->minlinkthroughput));

7464

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->linkinfovalidtime));

7465

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->scavqosinfoupdatetime));

7466

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->maxworkitemidletime));

7467

}

7468

if (ndr_flags & NDR_BUFFERS) {

7469

if (r->domain) {

7470

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->domain, CH_UTF16)));

7471

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));

7472

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->domain, CH_UTF16)));

7473

NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->domain, ndr_charset_length(r->domain, CH_UTF16), sizeof(uint16_t), CH_UTF16));

7474

}

7475

}

7476

return NDR_ERR_SUCCESS;

7477

}

7478

7479

static enum ndr_err_code ndr_pull_srvsvc_NetSrvInfo599(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetSrvInfo599 *r)

7480

{

7481

uint32_t _ptr_domain;

7482

TALLOC_CTX *_mem_save_domain_0;

7483

if (ndr_flags & NDR_SCALARS) {

7484

NDR_CHECK(ndr_pull_align(ndr, 4));

7485

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->sessopen));

7486

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->sesssvc));

7487

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->opensearch));

7488

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->sizereqbufs));

7489

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->initworkitems));

7490

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->maxworkitems));

7491

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->rawworkitems));

7492

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->irpstacksize));

7493

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->maxrawbuflen));

7494

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->sessusers));

7495

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->sessconns));

7496

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->maxpagedmemoryusage));

7497

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->maxnonpagedmemoryusage));

7498

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->enablesoftcompat));

7499

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->enableforcedlogoff));

7500

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->timesource));

7501

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->acceptdownlevelapis));

7502

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->lmannounce));

7503

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_domain));

7504

if (_ptr_domain) {

7505

NDR_PULL_ALLOC(ndr, r->domain);

7506

} else {

7507

r->domain = NULL;

7508

}

7509

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->maxcopyreadlen));

7510

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->maxcopywritelen));

7511

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->minkeepsearch));

7512

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->minkeepcomplsearch));

7513

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->maxkeepcomplsearch));

7514

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->threadcountadd));

7515

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->numlockthreads));

7516

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->scavtimeout));

7517

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->minrcvqueue));

7518

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->minfreeworkitems));

7519

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->xactmemsize));

7520

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->threadpriority));

7521

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->maxmpxct));

7522

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->oplockbreakwait));

7523

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->oplockbreakresponsewait));

7524

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->enableoplocks));

7525

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->enableoplockforceclose));

7526

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->enablefcbopens));

7527

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->enableraw));

7528

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->enablesharednetdrives));

7529

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->minfreeconnections));

7530

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->maxfreeconnections));

7531

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->initsesstable));

7532

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->initconntable));

7533

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->initfiletable));

7534

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->initsearchtable));

7535

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->alertsched));

7536

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->errortreshold));

7537

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->networkerrortreshold));

7538

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->diskspacetreshold));

7539

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved));

7540

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->maxlinkdelay));

7541

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->minlinkthroughput));

7542

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->linkinfovalidtime));

7543

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->scavqosinfoupdatetime));

7544

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->maxworkitemidletime));

7545

}

7546

if (ndr_flags & NDR_BUFFERS) {

7547

if (r->domain) {

7548

_mem_save_domain_0 = NDR_PULL_GET_MEM_CTX(ndr);

7549

NDR_PULL_SET_MEM_CTX(ndr, r->domain, 0);

7550

NDR_CHECK(ndr_pull_array_size(ndr, &r->domain));

7551

NDR_CHECK(ndr_pull_array_length(ndr, &r->domain));

7552

if (ndr_get_array_length(ndr, &r->domain) > ndr_get_array_size(ndr, &r->domain)) {

7553

return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->domain), ndr_get_array_length(ndr, &r->domain));

7554

}

7555

NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->domain), sizeof(uint16_t)));

7556

NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->domain, ndr_get_array_length(ndr, &r->domain), sizeof(uint16_t), CH_UTF16));

7557

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domain_0, 0);

7558

}

7559

}

7560

return NDR_ERR_SUCCESS;

7561

}

7562

7563

_PUBLIC_ void ndr_print_srvsvc_NetSrvInfo599(struct ndr_print *ndr, const char *name, const struct srvsvc_NetSrvInfo599 *r)

7564

{

7565

ndr_print_struct(ndr, name, "srvsvc_NetSrvInfo599");

7566

ndr->depth++;

7567

ndr_print_uint32(ndr, "sessopen", r->sessopen);

7568

ndr_print_uint32(ndr, "sesssvc", r->sesssvc);

7569

ndr_print_uint32(ndr, "opensearch", r->opensearch);

7570

ndr_print_uint32(ndr, "sizereqbufs", r->sizereqbufs);

7571

ndr_print_uint32(ndr, "initworkitems", r->initworkitems);

7572

ndr_print_uint32(ndr, "maxworkitems", r->maxworkitems);

7573

ndr_print_uint32(ndr, "rawworkitems", r->rawworkitems);

7574

ndr_print_uint32(ndr, "irpstacksize", r->irpstacksize);

7575

ndr_print_uint32(ndr, "maxrawbuflen", r->maxrawbuflen);

7576

ndr_print_uint32(ndr, "sessusers", r->sessusers);

7577

ndr_print_uint32(ndr, "sessconns", r->sessconns);

7578

ndr_print_uint32(ndr, "maxpagedmemoryusage", r->maxpagedmemoryusage);

7579

ndr_print_uint32(ndr, "maxnonpagedmemoryusage", r->maxnonpagedmemoryusage);

7580

ndr_print_uint32(ndr, "enablesoftcompat", r->enablesoftcompat);

7581

ndr_print_uint32(ndr, "enableforcedlogoff", r->enableforcedlogoff);

7582

ndr_print_uint32(ndr, "timesource", r->timesource);

7583

ndr_print_uint32(ndr, "acceptdownlevelapis", r->acceptdownlevelapis);

7584

ndr_print_uint32(ndr, "lmannounce", r->lmannounce);

7585

ndr_print_ptr(ndr, "domain", r->domain);

7586

ndr->depth++;

7587

if (r->domain) {

7588

ndr_print_string(ndr, "domain", r->domain);

7589

}

7590

ndr->depth--;

7591

ndr_print_uint32(ndr, "maxcopyreadlen", r->maxcopyreadlen);

7592

ndr_print_uint32(ndr, "maxcopywritelen", r->maxcopywritelen);

7593

ndr_print_uint32(ndr, "minkeepsearch", r->minkeepsearch);

7594

ndr_print_uint32(ndr, "minkeepcomplsearch", r->minkeepcomplsearch);

7595

ndr_print_uint32(ndr, "maxkeepcomplsearch", r->maxkeepcomplsearch);

7596

ndr_print_uint32(ndr, "threadcountadd", r->threadcountadd);

7597

ndr_print_uint32(ndr, "numlockthreads", r->numlockthreads);

7598

ndr_print_uint32(ndr, "scavtimeout", r->scavtimeout);

7599

ndr_print_uint32(ndr, "minrcvqueue", r->minrcvqueue);

7600

ndr_print_uint32(ndr, "minfreeworkitems", r->minfreeworkitems);

7601

ndr_print_uint32(ndr, "xactmemsize", r->xactmemsize);

7602

ndr_print_uint32(ndr, "threadpriority", r->threadpriority);

7603

ndr_print_uint32(ndr, "maxmpxct", r->maxmpxct);

7604

ndr_print_uint32(ndr, "oplockbreakwait", r->oplockbreakwait);

7605

ndr_print_uint32(ndr, "oplockbreakresponsewait", r->oplockbreakresponsewait);

7606

ndr_print_uint32(ndr, "enableoplocks", r->enableoplocks);

7607

ndr_print_uint32(ndr, "enableoplockforceclose", r->enableoplockforceclose);

7608

ndr_print_uint32(ndr, "enablefcbopens", r->enablefcbopens);

7609

ndr_print_uint32(ndr, "enableraw", r->enableraw);

7610

ndr_print_uint32(ndr, "enablesharednetdrives", r->enablesharednetdrives);

7611

ndr_print_uint32(ndr, "minfreeconnections", r->minfreeconnections);

7612

ndr_print_uint32(ndr, "maxfreeconnections", r->maxfreeconnections);

7613

ndr_print_uint32(ndr, "initsesstable", r->initsesstable);

7614

ndr_print_uint32(ndr, "initconntable", r->initconntable);

7615

ndr_print_uint32(ndr, "initfiletable", r->initfiletable);

7616

ndr_print_uint32(ndr, "initsearchtable", r->initsearchtable);

7617

ndr_print_uint32(ndr, "alertsched", r->alertsched);

7618

ndr_print_uint32(ndr, "errortreshold", r->errortreshold);

7619

ndr_print_uint32(ndr, "networkerrortreshold", r->networkerrortreshold);

7620

ndr_print_uint32(ndr, "diskspacetreshold", r->diskspacetreshold);

7621

ndr_print_uint32(ndr, "reserved", r->reserved);

7622

ndr_print_uint32(ndr, "maxlinkdelay", r->maxlinkdelay);

7623

ndr_print_uint32(ndr, "minlinkthroughput", r->minlinkthroughput);

7624

ndr_print_uint32(ndr, "linkinfovalidtime", r->linkinfovalidtime);

7625

ndr_print_uint32(ndr, "scavqosinfoupdatetime", r->scavqosinfoupdatetime);

7626

ndr_print_uint32(ndr, "maxworkitemidletime", r->maxworkitemidletime);

7627

ndr->depth--;

7628

}

7629

7630

static enum ndr_err_code ndr_push_srvsvc_NetSrvInfo1005(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetSrvInfo1005 *r)

7631

{

7632

if (ndr_flags & NDR_SCALARS) {

7633

NDR_CHECK(ndr_push_align(ndr, 4));

7634

NDR_CHECK(ndr_push_unique_ptr(ndr, r->comment));

7635

}

7636

if (ndr_flags & NDR_BUFFERS) {

7637

if (r->comment) {

7638

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->comment, CH_UTF16)));

7639

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));

7640

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->comment, CH_UTF16)));

7641

NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->comment, ndr_charset_length(r->comment, CH_UTF16), sizeof(uint16_t), CH_UTF16));

7642

}

7643

}

7644

return NDR_ERR_SUCCESS;

7645

}

7646

7647

static enum ndr_err_code ndr_pull_srvsvc_NetSrvInfo1005(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetSrvInfo1005 *r)

7648

{

7649

uint32_t _ptr_comment;

7650

TALLOC_CTX *_mem_save_comment_0;

7651

if (ndr_flags & NDR_SCALARS) {

7652

NDR_CHECK(ndr_pull_align(ndr, 4));

7653

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_comment));

7654

if (_ptr_comment) {

7655

NDR_PULL_ALLOC(ndr, r->comment);

7656

} else {

7657

r->comment = NULL;

7658

}

7659

}

7660

if (ndr_flags & NDR_BUFFERS) {

7661

if (r->comment) {

7662

_mem_save_comment_0 = NDR_PULL_GET_MEM_CTX(ndr);

7663

NDR_PULL_SET_MEM_CTX(ndr, r->comment, 0);

7664

NDR_CHECK(ndr_pull_array_size(ndr, &r->comment));

7665

NDR_CHECK(ndr_pull_array_length(ndr, &r->comment));

7666

if (ndr_get_array_length(ndr, &r->comment) > ndr_get_array_size(ndr, &r->comment)) {

7667

return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->comment), ndr_get_array_length(ndr, &r->comment));

7668

}

7669

NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->comment), sizeof(uint16_t)));

7670

NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->comment, ndr_get_array_length(ndr, &r->comment), sizeof(uint16_t), CH_UTF16));

7671

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_comment_0, 0);

7672

}

7673

}

7674

return NDR_ERR_SUCCESS;

7675

}

7676

7677

_PUBLIC_ void ndr_print_srvsvc_NetSrvInfo1005(struct ndr_print *ndr, const char *name, const struct srvsvc_NetSrvInfo1005 *r)

7678

{

7679

ndr_print_struct(ndr, name, "srvsvc_NetSrvInfo1005");

7680

ndr->depth++;

7681

ndr_print_ptr(ndr, "comment", r->comment);

7682

ndr->depth++;

7683

if (r->comment) {

7684

ndr_print_string(ndr, "comment", r->comment);

7685

}

7686

ndr->depth--;

7687

ndr->depth--;

7688

}

7689

7690

static enum ndr_err_code ndr_push_srvsvc_NetSrvInfo1010(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetSrvInfo1010 *r)

7691

{

7692

if (ndr_flags & NDR_SCALARS) {

7693

NDR_CHECK(ndr_push_align(ndr, 4));

7694

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->disc));

7695

}

7696

if (ndr_flags & NDR_BUFFERS) {

7697

}

7698

return NDR_ERR_SUCCESS;

7699

}

7700

7701

static enum ndr_err_code ndr_pull_srvsvc_NetSrvInfo1010(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetSrvInfo1010 *r)

7702

{

7703

if (ndr_flags & NDR_SCALARS) {

7704

NDR_CHECK(ndr_pull_align(ndr, 4));

7705

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->disc));

7706

}

7707

if (ndr_flags & NDR_BUFFERS) {

7708

}

7709

return NDR_ERR_SUCCESS;

7710

}

7711

7712

_PUBLIC_ void ndr_print_srvsvc_NetSrvInfo1010(struct ndr_print *ndr, const char *name, const struct srvsvc_NetSrvInfo1010 *r)

7713

{

7714

ndr_print_struct(ndr, name, "srvsvc_NetSrvInfo1010");

7715

ndr->depth++;

7716

ndr_print_uint32(ndr, "disc", r->disc);

7717

ndr->depth--;

7718

}

7719

7720

static enum ndr_err_code ndr_push_srvsvc_NetSrvInfo1016(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetSrvInfo1016 *r)

7721

{

7722

if (ndr_flags & NDR_SCALARS) {

7723

NDR_CHECK(ndr_push_align(ndr, 4));

7724

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->hidden));

7725

}

7726

if (ndr_flags & NDR_BUFFERS) {

7727

}

7728

return NDR_ERR_SUCCESS;

7729

}

7730

7731

static enum ndr_err_code ndr_pull_srvsvc_NetSrvInfo1016(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetSrvInfo1016 *r)

7732

{

7733

if (ndr_flags & NDR_SCALARS) {

7734

NDR_CHECK(ndr_pull_align(ndr, 4));

7735

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->hidden));

7736

}

7737

if (ndr_flags & NDR_BUFFERS) {

7738

}

7739

return NDR_ERR_SUCCESS;

7740

}

7741

7742

_PUBLIC_ void ndr_print_srvsvc_NetSrvInfo1016(struct ndr_print *ndr, const char *name, const struct srvsvc_NetSrvInfo1016 *r)

7743

{

7744

ndr_print_struct(ndr, name, "srvsvc_NetSrvInfo1016");

7745

ndr->depth++;

7746

ndr_print_uint32(ndr, "hidden", r->hidden);

7747

ndr->depth--;

7748

}

7749

7750

static enum ndr_err_code ndr_push_srvsvc_NetSrvInfo1017(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetSrvInfo1017 *r)

7751

{

7752

if (ndr_flags & NDR_SCALARS) {

7753

NDR_CHECK(ndr_push_align(ndr, 4));

7754

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->announce));

7755

}

7756

if (ndr_flags & NDR_BUFFERS) {

7757

}

7758

return NDR_ERR_SUCCESS;

7759

}

7760

7761

static enum ndr_err_code ndr_pull_srvsvc_NetSrvInfo1017(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetSrvInfo1017 *r)

7762

{

7763

if (ndr_flags & NDR_SCALARS) {

7764

NDR_CHECK(ndr_pull_align(ndr, 4));

7765

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->announce));

7766

}

7767

if (ndr_flags & NDR_BUFFERS) {

7768

}

7769

return NDR_ERR_SUCCESS;

7770

}

7771

7772

_PUBLIC_ void ndr_print_srvsvc_NetSrvInfo1017(struct ndr_print *ndr, const char *name, const struct srvsvc_NetSrvInfo1017 *r)

7773

{

7774

ndr_print_struct(ndr, name, "srvsvc_NetSrvInfo1017");

7775

ndr->depth++;

7776

ndr_print_uint32(ndr, "announce", r->announce);

7777

ndr->depth--;

7778

}

7779

7780

static enum ndr_err_code ndr_push_srvsvc_NetSrvInfo1018(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetSrvInfo1018 *r)

7781

{

7782

if (ndr_flags & NDR_SCALARS) {

7783

NDR_CHECK(ndr_push_align(ndr, 4));

7784

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->anndelta));

7785

}

7786

if (ndr_flags & NDR_BUFFERS) {

7787

}

7788

return NDR_ERR_SUCCESS;

7789

}

7790

7791

static enum ndr_err_code ndr_pull_srvsvc_NetSrvInfo1018(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetSrvInfo1018 *r)

7792

{

7793

if (ndr_flags & NDR_SCALARS) {

7794

NDR_CHECK(ndr_pull_align(ndr, 4));

7795

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->anndelta));

7796

}

7797

if (ndr_flags & NDR_BUFFERS) {

7798

}

7799

return NDR_ERR_SUCCESS;

7800

}

7801

7802

_PUBLIC_ void ndr_print_srvsvc_NetSrvInfo1018(struct ndr_print *ndr, const char *name, const struct srvsvc_NetSrvInfo1018 *r)

7803

{

7804

ndr_print_struct(ndr, name, "srvsvc_NetSrvInfo1018");

7805

ndr->depth++;

7806

ndr_print_uint32(ndr, "anndelta", r->anndelta);

7807

ndr->depth--;

7808

}

7809

7810

static enum ndr_err_code ndr_push_srvsvc_NetSrvInfo1107(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetSrvInfo1107 *r)

7811

{

7812

if (ndr_flags & NDR_SCALARS) {

7813

NDR_CHECK(ndr_push_align(ndr, 4));

7814

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->users));

7815

}

7816

if (ndr_flags & NDR_BUFFERS) {

7817

}

7818

return NDR_ERR_SUCCESS;

7819

}

7820

7821

static enum ndr_err_code ndr_pull_srvsvc_NetSrvInfo1107(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetSrvInfo1107 *r)

7822

{

7823

if (ndr_flags & NDR_SCALARS) {

7824

NDR_CHECK(ndr_pull_align(ndr, 4));

7825

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->users));

7826

}

7827

if (ndr_flags & NDR_BUFFERS) {

7828

}

7829

return NDR_ERR_SUCCESS;

7830

}

7831

7832

_PUBLIC_ void ndr_print_srvsvc_NetSrvInfo1107(struct ndr_print *ndr, const char *name, const struct srvsvc_NetSrvInfo1107 *r)

7833

{

7834

ndr_print_struct(ndr, name, "srvsvc_NetSrvInfo1107");

7835

ndr->depth++;

7836

ndr_print_uint32(ndr, "users", r->users);

7837

ndr->depth--;

7838

}

7839

7840

static enum ndr_err_code ndr_push_srvsvc_NetSrvInfo1501(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetSrvInfo1501 *r)

7841

{

7842

if (ndr_flags & NDR_SCALARS) {

7843

NDR_CHECK(ndr_push_align(ndr, 4));

7844

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->sessopens));

7845

}

7846

if (ndr_flags & NDR_BUFFERS) {

7847

}

7848

return NDR_ERR_SUCCESS;

7849

}

7850

7851

static enum ndr_err_code ndr_pull_srvsvc_NetSrvInfo1501(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetSrvInfo1501 *r)

7852

{

7853

if (ndr_flags & NDR_SCALARS) {

7854

NDR_CHECK(ndr_pull_align(ndr, 4));

7855

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->sessopens));

7856

}

7857

if (ndr_flags & NDR_BUFFERS) {

7858

}

7859

return NDR_ERR_SUCCESS;

7860

}

7861

7862

_PUBLIC_ void ndr_print_srvsvc_NetSrvInfo1501(struct ndr_print *ndr, const char *name, const struct srvsvc_NetSrvInfo1501 *r)

7863

{

7864

ndr_print_struct(ndr, name, "srvsvc_NetSrvInfo1501");

7865

ndr->depth++;

7866

ndr_print_uint32(ndr, "sessopens", r->sessopens);

7867

ndr->depth--;

7868

}

7869

7870

static enum ndr_err_code ndr_push_srvsvc_NetSrvInfo1502(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetSrvInfo1502 *r)

7871

{

7872

if (ndr_flags & NDR_SCALARS) {

7873

NDR_CHECK(ndr_push_align(ndr, 4));

7874

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->sessvcs));

7875

}

7876

if (ndr_flags & NDR_BUFFERS) {

7877

}

7878

return NDR_ERR_SUCCESS;

7879

}

7880

7881

static enum ndr_err_code ndr_pull_srvsvc_NetSrvInfo1502(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetSrvInfo1502 *r)

7882

{

7883

if (ndr_flags & NDR_SCALARS) {

7884

NDR_CHECK(ndr_pull_align(ndr, 4));

7885

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->sessvcs));

7886

}

7887

if (ndr_flags & NDR_BUFFERS) {

7888

}

7889

return NDR_ERR_SUCCESS;

7890

}

7891

7892

_PUBLIC_ void ndr_print_srvsvc_NetSrvInfo1502(struct ndr_print *ndr, const char *name, const struct srvsvc_NetSrvInfo1502 *r)

7893

{

7894

ndr_print_struct(ndr, name, "srvsvc_NetSrvInfo1502");

7895

ndr->depth++;

7896

ndr_print_uint32(ndr, "sessvcs", r->sessvcs);

7897

ndr->depth--;

7898

}

7899

7900

static enum ndr_err_code ndr_push_srvsvc_NetSrvInfo1503(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetSrvInfo1503 *r)

7901

{

7902

if (ndr_flags & NDR_SCALARS) {

7903

NDR_CHECK(ndr_push_align(ndr, 4));

7904

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->opensearch));

7905

}

7906

if (ndr_flags & NDR_BUFFERS) {

7907

}

7908

return NDR_ERR_SUCCESS;

7909

}

7910

7911

static enum ndr_err_code ndr_pull_srvsvc_NetSrvInfo1503(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetSrvInfo1503 *r)

7912

{

7913

if (ndr_flags & NDR_SCALARS) {

7914

NDR_CHECK(ndr_pull_align(ndr, 4));

7915

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->opensearch));

7916

}

7917

if (ndr_flags & NDR_BUFFERS) {

7918

}

7919

return NDR_ERR_SUCCESS;

7920

}

7921

7922

_PUBLIC_ void ndr_print_srvsvc_NetSrvInfo1503(struct ndr_print *ndr, const char *name, const struct srvsvc_NetSrvInfo1503 *r)

7923

{

7924

ndr_print_struct(ndr, name, "srvsvc_NetSrvInfo1503");

7925

ndr->depth++;

7926

ndr_print_uint32(ndr, "opensearch", r->opensearch);

7927

ndr->depth--;

7928

}

7929

7930

static enum ndr_err_code ndr_push_srvsvc_NetSrvInfo1506(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetSrvInfo1506 *r)

7931

{

7932

if (ndr_flags & NDR_SCALARS) {

7933

NDR_CHECK(ndr_push_align(ndr, 4));

7934

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->maxworkitems));

7935

}

7936

if (ndr_flags & NDR_BUFFERS) {

7937

}

7938

return NDR_ERR_SUCCESS;

7939

}

7940

7941

static enum ndr_err_code ndr_pull_srvsvc_NetSrvInfo1506(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetSrvInfo1506 *r)

7942

{

7943

if (ndr_flags & NDR_SCALARS) {

7944

NDR_CHECK(ndr_pull_align(ndr, 4));

7945

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->maxworkitems));

7946

}

7947

if (ndr_flags & NDR_BUFFERS) {

7948

}

7949

return NDR_ERR_SUCCESS;

7950

}

7951

7952

_PUBLIC_ void ndr_print_srvsvc_NetSrvInfo1506(struct ndr_print *ndr, const char *name, const struct srvsvc_NetSrvInfo1506 *r)

7953

{

7954

ndr_print_struct(ndr, name, "srvsvc_NetSrvInfo1506");

7955

ndr->depth++;

7956

ndr_print_uint32(ndr, "maxworkitems", r->maxworkitems);

7957

ndr->depth--;

7958

}

7959

7960

static enum ndr_err_code ndr_push_srvsvc_NetSrvInfo1509(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetSrvInfo1509 *r)

7961

{

7962

if (ndr_flags & NDR_SCALARS) {

7963

NDR_CHECK(ndr_push_align(ndr, 4));

7964

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->maxrawbuflen));

7965

}

7966

if (ndr_flags & NDR_BUFFERS) {

7967

}

7968

return NDR_ERR_SUCCESS;

7969

}

7970

7971

static enum ndr_err_code ndr_pull_srvsvc_NetSrvInfo1509(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetSrvInfo1509 *r)

7972

{

7973

if (ndr_flags & NDR_SCALARS) {

7974

NDR_CHECK(ndr_pull_align(ndr, 4));

7975

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->maxrawbuflen));

7976

}

7977

if (ndr_flags & NDR_BUFFERS) {

7978

}

7979

return NDR_ERR_SUCCESS;

7980

}

7981

7982

_PUBLIC_ void ndr_print_srvsvc_NetSrvInfo1509(struct ndr_print *ndr, const char *name, const struct srvsvc_NetSrvInfo1509 *r)

7983

{

7984

ndr_print_struct(ndr, name, "srvsvc_NetSrvInfo1509");

7985

ndr->depth++;

7986

ndr_print_uint32(ndr, "maxrawbuflen", r->maxrawbuflen);

7987

ndr->depth--;

7988

}

7989

7990

static enum ndr_err_code ndr_push_srvsvc_NetSrvInfo1510(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetSrvInfo1510 *r)

7991

{

7992

if (ndr_flags & NDR_SCALARS) {

7993

NDR_CHECK(ndr_push_align(ndr, 4));

7994

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->sessusers));

7995

}

7996

if (ndr_flags & NDR_BUFFERS) {

7997

}

7998

return NDR_ERR_SUCCESS;

7999

}

8000

8001

static enum ndr_err_code ndr_pull_srvsvc_NetSrvInfo1510(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetSrvInfo1510 *r)

8002

{

8003

if (ndr_flags & NDR_SCALARS) {

8004

NDR_CHECK(ndr_pull_align(ndr, 4));

8005

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->sessusers));

8006

}

8007

if (ndr_flags & NDR_BUFFERS) {

8008

}

8009

return NDR_ERR_SUCCESS;

8010

}

8011

8012

_PUBLIC_ void ndr_print_srvsvc_NetSrvInfo1510(struct ndr_print *ndr, const char *name, const struct srvsvc_NetSrvInfo1510 *r)

8013

{

8014

ndr_print_struct(ndr, name, "srvsvc_NetSrvInfo1510");

8015

ndr->depth++;

8016

ndr_print_uint32(ndr, "sessusers", r->sessusers);

8017

ndr->depth--;

8018

}

8019

8020

static enum ndr_err_code ndr_push_srvsvc_NetSrvInfo1511(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetSrvInfo1511 *r)

8021

{

8022

if (ndr_flags & NDR_SCALARS) {

8023

NDR_CHECK(ndr_push_align(ndr, 4));

8024

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->sesscons));

8025

}

8026

if (ndr_flags & NDR_BUFFERS) {

8027

}

8028

return NDR_ERR_SUCCESS;

8029

}

8030

8031

static enum ndr_err_code ndr_pull_srvsvc_NetSrvInfo1511(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetSrvInfo1511 *r)

8032

{

8033

if (ndr_flags & NDR_SCALARS) {

8034

NDR_CHECK(ndr_pull_align(ndr, 4));

8035

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->sesscons));

8036

}

8037

if (ndr_flags & NDR_BUFFERS) {

8038

}

8039

return NDR_ERR_SUCCESS;

8040

}

8041

8042

_PUBLIC_ void ndr_print_srvsvc_NetSrvInfo1511(struct ndr_print *ndr, const char *name, const struct srvsvc_NetSrvInfo1511 *r)

8043

{

8044

ndr_print_struct(ndr, name, "srvsvc_NetSrvInfo1511");

8045

ndr->depth++;

8046

ndr_print_uint32(ndr, "sesscons", r->sesscons);

8047

ndr->depth--;

8048

}

8049

8050

static enum ndr_err_code ndr_push_srvsvc_NetSrvInfo1512(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetSrvInfo1512 *r)

8051

{

8052

if (ndr_flags & NDR_SCALARS) {

8053

NDR_CHECK(ndr_push_align(ndr, 4));

8054

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->maxnonpagedmemoryusage));

8055

}

8056

if (ndr_flags & NDR_BUFFERS) {

8057

}

8058

return NDR_ERR_SUCCESS;

8059

}

8060

8061

static enum ndr_err_code ndr_pull_srvsvc_NetSrvInfo1512(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetSrvInfo1512 *r)

8062

{

8063

if (ndr_flags & NDR_SCALARS) {

8064

NDR_CHECK(ndr_pull_align(ndr, 4));

8065

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->maxnonpagedmemoryusage));

8066

}

8067

if (ndr_flags & NDR_BUFFERS) {

8068

}

8069

return NDR_ERR_SUCCESS;

8070

}

8071

8072

_PUBLIC_ void ndr_print_srvsvc_NetSrvInfo1512(struct ndr_print *ndr, const char *name, const struct srvsvc_NetSrvInfo1512 *r)

8073

{

8074

ndr_print_struct(ndr, name, "srvsvc_NetSrvInfo1512");

8075

ndr->depth++;

8076

ndr_print_uint32(ndr, "maxnonpagedmemoryusage", r->maxnonpagedmemoryusage);

8077

ndr->depth--;

8078

}

8079

8080

static enum ndr_err_code ndr_push_srvsvc_NetSrvInfo1513(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetSrvInfo1513 *r)

8081

{

8082

if (ndr_flags & NDR_SCALARS) {

8083

NDR_CHECK(ndr_push_align(ndr, 4));

8084

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->maxpagedmemoryusage));

8085

}

8086

if (ndr_flags & NDR_BUFFERS) {

8087

}

8088

return NDR_ERR_SUCCESS;

8089

}

8090

8091

static enum ndr_err_code ndr_pull_srvsvc_NetSrvInfo1513(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetSrvInfo1513 *r)

8092

{

8093

if (ndr_flags & NDR_SCALARS) {

8094

NDR_CHECK(ndr_pull_align(ndr, 4));

8095

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->maxpagedmemoryusage));

8096

}

8097

if (ndr_flags & NDR_BUFFERS) {

8098

}

8099

return NDR_ERR_SUCCESS;

8100

}

8101

8102

_PUBLIC_ void ndr_print_srvsvc_NetSrvInfo1513(struct ndr_print *ndr, const char *name, const struct srvsvc_NetSrvInfo1513 *r)

8103

{

8104

ndr_print_struct(ndr, name, "srvsvc_NetSrvInfo1513");

8105

ndr->depth++;

8106

ndr_print_uint32(ndr, "maxpagedmemoryusage", r->maxpagedmemoryusage);

8107

ndr->depth--;

8108

}

8109

8110

static enum ndr_err_code ndr_push_srvsvc_NetSrvInfo1514(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetSrvInfo1514 *r)

8111

{

8112

if (ndr_flags & NDR_SCALARS) {

8113

NDR_CHECK(ndr_push_align(ndr, 4));

8114

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->enablesoftcompat));

8115

}

8116

if (ndr_flags & NDR_BUFFERS) {

8117

}

8118

return NDR_ERR_SUCCESS;

8119

}

8120

8121

static enum ndr_err_code ndr_pull_srvsvc_NetSrvInfo1514(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetSrvInfo1514 *r)

8122

{

8123

if (ndr_flags & NDR_SCALARS) {

8124

NDR_CHECK(ndr_pull_align(ndr, 4));

8125

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->enablesoftcompat));

8126

}

8127

if (ndr_flags & NDR_BUFFERS) {

8128

}

8129

return NDR_ERR_SUCCESS;

8130

}

8131

8132

_PUBLIC_ void ndr_print_srvsvc_NetSrvInfo1514(struct ndr_print *ndr, const char *name, const struct srvsvc_NetSrvInfo1514 *r)

8133

{

8134

ndr_print_struct(ndr, name, "srvsvc_NetSrvInfo1514");

8135

ndr->depth++;

8136

ndr_print_uint32(ndr, "enablesoftcompat", r->enablesoftcompat);

8137

ndr->depth--;

8138

}

8139

8140

static enum ndr_err_code ndr_push_srvsvc_NetSrvInfo1515(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetSrvInfo1515 *r)

8141

{

8142

if (ndr_flags & NDR_SCALARS) {

8143

NDR_CHECK(ndr_push_align(ndr, 4));

8144

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->enableforcedlogoff));

8145

}

8146

if (ndr_flags & NDR_BUFFERS) {

8147

}

8148

return NDR_ERR_SUCCESS;

8149

}

8150

8151

static enum ndr_err_code ndr_pull_srvsvc_NetSrvInfo1515(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetSrvInfo1515 *r)

8152

{

8153

if (ndr_flags & NDR_SCALARS) {

8154

NDR_CHECK(ndr_pull_align(ndr, 4));

8155

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->enableforcedlogoff));

8156

}

8157

if (ndr_flags & NDR_BUFFERS) {

8158

}

8159

return NDR_ERR_SUCCESS;

8160

}

8161

8162

_PUBLIC_ void ndr_print_srvsvc_NetSrvInfo1515(struct ndr_print *ndr, const char *name, const struct srvsvc_NetSrvInfo1515 *r)

8163

{

8164

ndr_print_struct(ndr, name, "srvsvc_NetSrvInfo1515");

8165

ndr->depth++;

8166

ndr_print_uint32(ndr, "enableforcedlogoff", r->enableforcedlogoff);

8167

ndr->depth--;

8168

}

8169

8170

static enum ndr_err_code ndr_push_srvsvc_NetSrvInfo1516(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetSrvInfo1516 *r)

8171

{

8172

if (ndr_flags & NDR_SCALARS) {

8173

NDR_CHECK(ndr_push_align(ndr, 4));

8174

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->timesource));

8175

}

8176

if (ndr_flags & NDR_BUFFERS) {

8177

}

8178

return NDR_ERR_SUCCESS;

8179

}

8180

8181

static enum ndr_err_code ndr_pull_srvsvc_NetSrvInfo1516(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetSrvInfo1516 *r)

8182

{

8183

if (ndr_flags & NDR_SCALARS) {

8184

NDR_CHECK(ndr_pull_align(ndr, 4));

8185

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->timesource));

8186

}

8187

if (ndr_flags & NDR_BUFFERS) {

8188

}

8189

return NDR_ERR_SUCCESS;

8190

}

8191

8192

_PUBLIC_ void ndr_print_srvsvc_NetSrvInfo1516(struct ndr_print *ndr, const char *name, const struct srvsvc_NetSrvInfo1516 *r)

8193

{

8194

ndr_print_struct(ndr, name, "srvsvc_NetSrvInfo1516");

8195

ndr->depth++;

8196

ndr_print_uint32(ndr, "timesource", r->timesource);

8197

ndr->depth--;

8198

}

8199

8200

static enum ndr_err_code ndr_push_srvsvc_NetSrvInfo1518(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetSrvInfo1518 *r)

8201

{

8202

if (ndr_flags & NDR_SCALARS) {

8203

NDR_CHECK(ndr_push_align(ndr, 4));

8204

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->lmannounce));

8205

}

8206

if (ndr_flags & NDR_BUFFERS) {

8207

}

8208

return NDR_ERR_SUCCESS;

8209

}

8210

8211

static enum ndr_err_code ndr_pull_srvsvc_NetSrvInfo1518(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetSrvInfo1518 *r)

8212

{

8213

if (ndr_flags & NDR_SCALARS) {

8214

NDR_CHECK(ndr_pull_align(ndr, 4));

8215

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->lmannounce));

8216

}

8217

if (ndr_flags & NDR_BUFFERS) {

8218

}

8219

return NDR_ERR_SUCCESS;

8220

}

8221

8222

_PUBLIC_ void ndr_print_srvsvc_NetSrvInfo1518(struct ndr_print *ndr, const char *name, const struct srvsvc_NetSrvInfo1518 *r)

8223

{

8224

ndr_print_struct(ndr, name, "srvsvc_NetSrvInfo1518");

8225

ndr->depth++;

8226

ndr_print_uint32(ndr, "lmannounce", r->lmannounce);

8227

ndr->depth--;

8228

}

8229

8230

static enum ndr_err_code ndr_push_srvsvc_NetSrvInfo1520(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetSrvInfo1520 *r)

8231

{

8232

if (ndr_flags & NDR_SCALARS) {

8233

NDR_CHECK(ndr_push_align(ndr, 4));

8234

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->maxcopyreadlen));

8235

}

8236

if (ndr_flags & NDR_BUFFERS) {

8237

}

8238

return NDR_ERR_SUCCESS;

8239

}

8240

8241

static enum ndr_err_code ndr_pull_srvsvc_NetSrvInfo1520(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetSrvInfo1520 *r)

8242

{

8243

if (ndr_flags & NDR_SCALARS) {

8244

NDR_CHECK(ndr_pull_align(ndr, 4));

8245

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->maxcopyreadlen));

8246

}

8247

if (ndr_flags & NDR_BUFFERS) {

8248

}

8249

return NDR_ERR_SUCCESS;

8250

}

8251

8252

_PUBLIC_ void ndr_print_srvsvc_NetSrvInfo1520(struct ndr_print *ndr, const char *name, const struct srvsvc_NetSrvInfo1520 *r)

8253

{

8254

ndr_print_struct(ndr, name, "srvsvc_NetSrvInfo1520");

8255

ndr->depth++;

8256

ndr_print_uint32(ndr, "maxcopyreadlen", r->maxcopyreadlen);

8257

ndr->depth--;

8258

}

8259

8260

static enum ndr_err_code ndr_push_srvsvc_NetSrvInfo1521(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetSrvInfo1521 *r)

8261

{

8262

if (ndr_flags & NDR_SCALARS) {

8263

NDR_CHECK(ndr_push_align(ndr, 4));

8264

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->maxcopywritelen));

8265

}

8266

if (ndr_flags & NDR_BUFFERS) {

8267

}

8268

return NDR_ERR_SUCCESS;

8269

}

8270

8271

static enum ndr_err_code ndr_pull_srvsvc_NetSrvInfo1521(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetSrvInfo1521 *r)

8272

{

8273

if (ndr_flags & NDR_SCALARS) {

8274

NDR_CHECK(ndr_pull_align(ndr, 4));

8275

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->maxcopywritelen));

8276

}

8277

if (ndr_flags & NDR_BUFFERS) {

8278

}

8279

return NDR_ERR_SUCCESS;

8280

}

8281

8282

_PUBLIC_ void ndr_print_srvsvc_NetSrvInfo1521(struct ndr_print *ndr, const char *name, const struct srvsvc_NetSrvInfo1521 *r)

8283

{

8284

ndr_print_struct(ndr, name, "srvsvc_NetSrvInfo1521");

8285

ndr->depth++;

8286

ndr_print_uint32(ndr, "maxcopywritelen", r->maxcopywritelen);

8287

ndr->depth--;

8288

}

8289

8290

static enum ndr_err_code ndr_push_srvsvc_NetSrvInfo1522(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetSrvInfo1522 *r)

8291

{

8292

if (ndr_flags & NDR_SCALARS) {

8293

NDR_CHECK(ndr_push_align(ndr, 4));

8294

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->minkeepsearch));

8295

}

8296

if (ndr_flags & NDR_BUFFERS) {

8297

}

8298

return NDR_ERR_SUCCESS;

8299

}

8300

8301

static enum ndr_err_code ndr_pull_srvsvc_NetSrvInfo1522(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetSrvInfo1522 *r)

8302

{

8303

if (ndr_flags & NDR_SCALARS) {

8304

NDR_CHECK(ndr_pull_align(ndr, 4));

8305

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->minkeepsearch));

8306

}

8307

if (ndr_flags & NDR_BUFFERS) {

8308

}

8309

return NDR_ERR_SUCCESS;

8310

}

8311

8312

_PUBLIC_ void ndr_print_srvsvc_NetSrvInfo1522(struct ndr_print *ndr, const char *name, const struct srvsvc_NetSrvInfo1522 *r)

8313

{

8314

ndr_print_struct(ndr, name, "srvsvc_NetSrvInfo1522");

8315

ndr->depth++;

8316

ndr_print_uint32(ndr, "minkeepsearch", r->minkeepsearch);

8317

ndr->depth--;

8318

}

8319

8320

static enum ndr_err_code ndr_push_srvsvc_NetSrvInfo1523(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetSrvInfo1523 *r)

8321

{

8322

if (ndr_flags & NDR_SCALARS) {

8323

NDR_CHECK(ndr_push_align(ndr, 4));

8324

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->maxkeepsearch));

8325

}

8326

if (ndr_flags & NDR_BUFFERS) {

8327

}

8328

return NDR_ERR_SUCCESS;

8329

}

8330

8331

static enum ndr_err_code ndr_pull_srvsvc_NetSrvInfo1523(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetSrvInfo1523 *r)

8332

{

8333

if (ndr_flags & NDR_SCALARS) {

8334

NDR_CHECK(ndr_pull_align(ndr, 4));

8335

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->maxkeepsearch));

8336

}

8337

if (ndr_flags & NDR_BUFFERS) {

8338

}

8339

return NDR_ERR_SUCCESS;

8340

}

8341

8342

_PUBLIC_ void ndr_print_srvsvc_NetSrvInfo1523(struct ndr_print *ndr, const char *name, const struct srvsvc_NetSrvInfo1523 *r)

8343

{

8344

ndr_print_struct(ndr, name, "srvsvc_NetSrvInfo1523");

8345

ndr->depth++;

8346

ndr_print_uint32(ndr, "maxkeepsearch", r->maxkeepsearch);

8347

ndr->depth--;

8348

}

8349

8350

static enum ndr_err_code ndr_push_srvsvc_NetSrvInfo1524(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetSrvInfo1524 *r)

8351

{

8352

if (ndr_flags & NDR_SCALARS) {

8353

NDR_CHECK(ndr_push_align(ndr, 4));

8354

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->minkeepcomplsearch));

8355

}

8356

if (ndr_flags & NDR_BUFFERS) {

8357

}

8358

return NDR_ERR_SUCCESS;

8359

}

8360

8361

static enum ndr_err_code ndr_pull_srvsvc_NetSrvInfo1524(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetSrvInfo1524 *r)

8362

{

8363

if (ndr_flags & NDR_SCALARS) {

8364

NDR_CHECK(ndr_pull_align(ndr, 4));

8365

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->minkeepcomplsearch));

8366

}

8367

if (ndr_flags & NDR_BUFFERS) {

8368

}

8369

return NDR_ERR_SUCCESS;

8370

}

8371

8372

_PUBLIC_ void ndr_print_srvsvc_NetSrvInfo1524(struct ndr_print *ndr, const char *name, const struct srvsvc_NetSrvInfo1524 *r)

8373

{

8374

ndr_print_struct(ndr, name, "srvsvc_NetSrvInfo1524");

8375

ndr->depth++;

8376

ndr_print_uint32(ndr, "minkeepcomplsearch", r->minkeepcomplsearch);

8377

ndr->depth--;

8378

}

8379

8380

static enum ndr_err_code ndr_push_srvsvc_NetSrvInfo1525(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetSrvInfo1525 *r)

8381

{

8382

if (ndr_flags & NDR_SCALARS) {

8383

NDR_CHECK(ndr_push_align(ndr, 4));

8384

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->maxkeepcomplsearch));

8385

}

8386

if (ndr_flags & NDR_BUFFERS) {

8387

}

8388

return NDR_ERR_SUCCESS;

8389

}

8390

8391

static enum ndr_err_code ndr_pull_srvsvc_NetSrvInfo1525(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetSrvInfo1525 *r)

8392

{

8393

if (ndr_flags & NDR_SCALARS) {

8394

NDR_CHECK(ndr_pull_align(ndr, 4));

8395

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->maxkeepcomplsearch));

8396

}

8397

if (ndr_flags & NDR_BUFFERS) {

8398

}

8399

return NDR_ERR_SUCCESS;

8400

}

8401

8402

_PUBLIC_ void ndr_print_srvsvc_NetSrvInfo1525(struct ndr_print *ndr, const char *name, const struct srvsvc_NetSrvInfo1525 *r)

8403

{

8404

ndr_print_struct(ndr, name, "srvsvc_NetSrvInfo1525");

8405

ndr->depth++;

8406

ndr_print_uint32(ndr, "maxkeepcomplsearch", r->maxkeepcomplsearch);

8407

ndr->depth--;

8408

}

8409

8410

static enum ndr_err_code ndr_push_srvsvc_NetSrvInfo1528(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetSrvInfo1528 *r)

8411

{

8412

if (ndr_flags & NDR_SCALARS) {

8413

NDR_CHECK(ndr_push_align(ndr, 4));

8414

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->scavtimeout));

8415

}

8416

if (ndr_flags & NDR_BUFFERS) {

8417

}

8418

return NDR_ERR_SUCCESS;

8419

}

8420

8421

static enum ndr_err_code ndr_pull_srvsvc_NetSrvInfo1528(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetSrvInfo1528 *r)

8422

{

8423

if (ndr_flags & NDR_SCALARS) {

8424

NDR_CHECK(ndr_pull_align(ndr, 4));

8425

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->scavtimeout));

8426

}

8427

if (ndr_flags & NDR_BUFFERS) {

8428

}

8429

return NDR_ERR_SUCCESS;

8430

}

8431

8432

_PUBLIC_ void ndr_print_srvsvc_NetSrvInfo1528(struct ndr_print *ndr, const char *name, const struct srvsvc_NetSrvInfo1528 *r)

8433

{

8434

ndr_print_struct(ndr, name, "srvsvc_NetSrvInfo1528");

8435

ndr->depth++;

8436

ndr_print_uint32(ndr, "scavtimeout", r->scavtimeout);

8437

ndr->depth--;

8438

}

8439

8440

static enum ndr_err_code ndr_push_srvsvc_NetSrvInfo1529(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetSrvInfo1529 *r)

8441

{

8442

if (ndr_flags & NDR_SCALARS) {

8443

NDR_CHECK(ndr_push_align(ndr, 4));

8444

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->minrcvqueue));

8445

}

8446

if (ndr_flags & NDR_BUFFERS) {

8447

}

8448

return NDR_ERR_SUCCESS;

8449

}

8450

8451

static enum ndr_err_code ndr_pull_srvsvc_NetSrvInfo1529(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetSrvInfo1529 *r)

8452

{

8453

if (ndr_flags & NDR_SCALARS) {

8454

NDR_CHECK(ndr_pull_align(ndr, 4));

8455

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->minrcvqueue));

8456

}

8457

if (ndr_flags & NDR_BUFFERS) {

8458

}

8459

return NDR_ERR_SUCCESS;

8460

}

8461

8462

_PUBLIC_ void ndr_print_srvsvc_NetSrvInfo1529(struct ndr_print *ndr, const char *name, const struct srvsvc_NetSrvInfo1529 *r)

8463

{

8464

ndr_print_struct(ndr, name, "srvsvc_NetSrvInfo1529");

8465

ndr->depth++;

8466

ndr_print_uint32(ndr, "minrcvqueue", r->minrcvqueue);

8467

ndr->depth--;

8468

}

8469

8470

static enum ndr_err_code ndr_push_srvsvc_NetSrvInfo1530(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetSrvInfo1530 *r)

8471

{

8472

if (ndr_flags & NDR_SCALARS) {

8473

NDR_CHECK(ndr_push_align(ndr, 4));

8474

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->minfreeworkitems));

8475

}

8476

if (ndr_flags & NDR_BUFFERS) {

8477

}

8478

return NDR_ERR_SUCCESS;

8479

}

8480

8481

static enum ndr_err_code ndr_pull_srvsvc_NetSrvInfo1530(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetSrvInfo1530 *r)

8482

{

8483

if (ndr_flags & NDR_SCALARS) {

8484

NDR_CHECK(ndr_pull_align(ndr, 4));

8485

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->minfreeworkitems));

8486

}

8487

if (ndr_flags & NDR_BUFFERS) {

8488

}

8489

return NDR_ERR_SUCCESS;

8490

}

8491

8492

_PUBLIC_ void ndr_print_srvsvc_NetSrvInfo1530(struct ndr_print *ndr, const char *name, const struct srvsvc_NetSrvInfo1530 *r)

8493

{

8494

ndr_print_struct(ndr, name, "srvsvc_NetSrvInfo1530");

8495

ndr->depth++;

8496

ndr_print_uint32(ndr, "minfreeworkitems", r->minfreeworkitems);

8497

ndr->depth--;

8498

}

8499

8500

static enum ndr_err_code ndr_push_srvsvc_NetSrvInfo1533(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetSrvInfo1533 *r)

8501

{

8502

if (ndr_flags & NDR_SCALARS) {

8503

NDR_CHECK(ndr_push_align(ndr, 4));

8504

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->maxmpxct));

8505

}

8506

if (ndr_flags & NDR_BUFFERS) {

8507

}

8508

return NDR_ERR_SUCCESS;

8509

}

8510

8511

static enum ndr_err_code ndr_pull_srvsvc_NetSrvInfo1533(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetSrvInfo1533 *r)

8512

{

8513

if (ndr_flags & NDR_SCALARS) {

8514

NDR_CHECK(ndr_pull_align(ndr, 4));

8515

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->maxmpxct));

8516

}

8517

if (ndr_flags & NDR_BUFFERS) {

8518

}

8519

return NDR_ERR_SUCCESS;

8520

}

8521

8522

_PUBLIC_ void ndr_print_srvsvc_NetSrvInfo1533(struct ndr_print *ndr, const char *name, const struct srvsvc_NetSrvInfo1533 *r)

8523

{

8524

ndr_print_struct(ndr, name, "srvsvc_NetSrvInfo1533");

8525

ndr->depth++;

8526

ndr_print_uint32(ndr, "maxmpxct", r->maxmpxct);

8527

ndr->depth--;

8528

}

8529

8530

static enum ndr_err_code ndr_push_srvsvc_NetSrvInfo1534(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetSrvInfo1534 *r)

8531

{

8532

if (ndr_flags & NDR_SCALARS) {

8533

NDR_CHECK(ndr_push_align(ndr, 4));

8534

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->oplockbreakwait));

8535

}

8536

if (ndr_flags & NDR_BUFFERS) {

8537

}

8538

return NDR_ERR_SUCCESS;

8539

}

8540

8541

static enum ndr_err_code ndr_pull_srvsvc_NetSrvInfo1534(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetSrvInfo1534 *r)

8542

{

8543

if (ndr_flags & NDR_SCALARS) {

8544

NDR_CHECK(ndr_pull_align(ndr, 4));

8545

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->oplockbreakwait));

8546

}

8547

if (ndr_flags & NDR_BUFFERS) {

8548

}

8549

return NDR_ERR_SUCCESS;

8550

}

8551

8552

_PUBLIC_ void ndr_print_srvsvc_NetSrvInfo1534(struct ndr_print *ndr, const char *name, const struct srvsvc_NetSrvInfo1534 *r)

8553

{

8554

ndr_print_struct(ndr, name, "srvsvc_NetSrvInfo1534");

8555

ndr->depth++;

8556

ndr_print_uint32(ndr, "oplockbreakwait", r->oplockbreakwait);

8557

ndr->depth--;

8558

}

8559

8560

static enum ndr_err_code ndr_push_srvsvc_NetSrvInfo1535(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetSrvInfo1535 *r)

8561

{

8562

if (ndr_flags & NDR_SCALARS) {

8563

NDR_CHECK(ndr_push_align(ndr, 4));

8564

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->oplockbreakresponsewait));

8565

}

8566

if (ndr_flags & NDR_BUFFERS) {

8567

}

8568

return NDR_ERR_SUCCESS;

8569

}

8570

8571

static enum ndr_err_code ndr_pull_srvsvc_NetSrvInfo1535(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetSrvInfo1535 *r)

8572

{

8573

if (ndr_flags & NDR_SCALARS) {

8574

NDR_CHECK(ndr_pull_align(ndr, 4));

8575

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->oplockbreakresponsewait));

8576

}

8577

if (ndr_flags & NDR_BUFFERS) {

8578

}

8579

return NDR_ERR_SUCCESS;

8580

}

8581

8582

_PUBLIC_ void ndr_print_srvsvc_NetSrvInfo1535(struct ndr_print *ndr, const char *name, const struct srvsvc_NetSrvInfo1535 *r)

8583

{

8584

ndr_print_struct(ndr, name, "srvsvc_NetSrvInfo1535");

8585

ndr->depth++;

8586

ndr_print_uint32(ndr, "oplockbreakresponsewait", r->oplockbreakresponsewait);

8587

ndr->depth--;

8588

}

8589

8590

static enum ndr_err_code ndr_push_srvsvc_NetSrvInfo1536(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetSrvInfo1536 *r)

8591

{

8592

if (ndr_flags & NDR_SCALARS) {

8593

NDR_CHECK(ndr_push_align(ndr, 4));

8594

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->enableoplocks));

8595

}

8596

if (ndr_flags & NDR_BUFFERS) {

8597

}

8598

return NDR_ERR_SUCCESS;

8599

}

8600

8601

static enum ndr_err_code ndr_pull_srvsvc_NetSrvInfo1536(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetSrvInfo1536 *r)

8602

{

8603

if (ndr_flags & NDR_SCALARS) {

8604

NDR_CHECK(ndr_pull_align(ndr, 4));

8605

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->enableoplocks));

8606

}

8607

if (ndr_flags & NDR_BUFFERS) {

8608

}

8609

return NDR_ERR_SUCCESS;

8610

}

8611

8612

_PUBLIC_ void ndr_print_srvsvc_NetSrvInfo1536(struct ndr_print *ndr, const char *name, const struct srvsvc_NetSrvInfo1536 *r)

8613

{

8614

ndr_print_struct(ndr, name, "srvsvc_NetSrvInfo1536");

8615

ndr->depth++;

8616

ndr_print_uint32(ndr, "enableoplocks", r->enableoplocks);

8617

ndr->depth--;

8618

}

8619

8620

static enum ndr_err_code ndr_push_srvsvc_NetSrvInfo1537(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetSrvInfo1537 *r)

8621

{

8622

if (ndr_flags & NDR_SCALARS) {

8623

NDR_CHECK(ndr_push_align(ndr, 4));

8624

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->enableoplockforceclose));

8625

}

8626

if (ndr_flags & NDR_BUFFERS) {

8627

}

8628

return NDR_ERR_SUCCESS;

8629

}

8630

8631

static enum ndr_err_code ndr_pull_srvsvc_NetSrvInfo1537(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetSrvInfo1537 *r)

8632

{

8633

if (ndr_flags & NDR_SCALARS) {

8634

NDR_CHECK(ndr_pull_align(ndr, 4));

8635

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->enableoplockforceclose));

8636

}

8637

if (ndr_flags & NDR_BUFFERS) {

8638

}

8639

return NDR_ERR_SUCCESS;

8640

}

8641

8642

_PUBLIC_ void ndr_print_srvsvc_NetSrvInfo1537(struct ndr_print *ndr, const char *name, const struct srvsvc_NetSrvInfo1537 *r)

8643

{

8644

ndr_print_struct(ndr, name, "srvsvc_NetSrvInfo1537");

8645

ndr->depth++;

8646

ndr_print_uint32(ndr, "enableoplockforceclose", r->enableoplockforceclose);

8647

ndr->depth--;

8648

}

8649

8650

static enum ndr_err_code ndr_push_srvsvc_NetSrvInfo1538(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetSrvInfo1538 *r)

8651

{

8652

if (ndr_flags & NDR_SCALARS) {

8653

NDR_CHECK(ndr_push_align(ndr, 4));

8654

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->enablefcbopens));

8655

}

8656

if (ndr_flags & NDR_BUFFERS) {

8657

}

8658

return NDR_ERR_SUCCESS;

8659

}

8660

8661

static enum ndr_err_code ndr_pull_srvsvc_NetSrvInfo1538(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetSrvInfo1538 *r)

8662

{

8663

if (ndr_flags & NDR_SCALARS) {

8664

NDR_CHECK(ndr_pull_align(ndr, 4));

8665

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->enablefcbopens));

8666

}

8667

if (ndr_flags & NDR_BUFFERS) {

8668

}

8669

return NDR_ERR_SUCCESS;

8670

}

8671

8672

_PUBLIC_ void ndr_print_srvsvc_NetSrvInfo1538(struct ndr_print *ndr, const char *name, const struct srvsvc_NetSrvInfo1538 *r)

8673

{

8674

ndr_print_struct(ndr, name, "srvsvc_NetSrvInfo1538");

8675

ndr->depth++;

8676

ndr_print_uint32(ndr, "enablefcbopens", r->enablefcbopens);

8677

ndr->depth--;

8678

}

8679

8680

static enum ndr_err_code ndr_push_srvsvc_NetSrvInfo1539(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetSrvInfo1539 *r)

8681

{

8682

if (ndr_flags & NDR_SCALARS) {

8683

NDR_CHECK(ndr_push_align(ndr, 4));

8684

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->enableraw));

8685

}

8686

if (ndr_flags & NDR_BUFFERS) {

8687

}

8688

return NDR_ERR_SUCCESS;

8689

}

8690

8691

static enum ndr_err_code ndr_pull_srvsvc_NetSrvInfo1539(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetSrvInfo1539 *r)

8692

{

8693

if (ndr_flags & NDR_SCALARS) {

8694

NDR_CHECK(ndr_pull_align(ndr, 4));

8695

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->enableraw));

8696

}

8697

if (ndr_flags & NDR_BUFFERS) {

8698

}

8699

return NDR_ERR_SUCCESS;

8700

}

8701

8702

_PUBLIC_ void ndr_print_srvsvc_NetSrvInfo1539(struct ndr_print *ndr, const char *name, const struct srvsvc_NetSrvInfo1539 *r)

8703

{

8704

ndr_print_struct(ndr, name, "srvsvc_NetSrvInfo1539");

8705

ndr->depth++;

8706

ndr_print_uint32(ndr, "enableraw", r->enableraw);

8707

ndr->depth--;

8708

}

8709

8710

static enum ndr_err_code ndr_push_srvsvc_NetSrvInfo1540(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetSrvInfo1540 *r)

8711

{

8712

if (ndr_flags & NDR_SCALARS) {

8713

NDR_CHECK(ndr_push_align(ndr, 4));

8714

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->enablesharednetdrives));

8715

}

8716

if (ndr_flags & NDR_BUFFERS) {

8717

}

8718

return NDR_ERR_SUCCESS;

8719

}

8720

8721

static enum ndr_err_code ndr_pull_srvsvc_NetSrvInfo1540(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetSrvInfo1540 *r)

8722

{

8723

if (ndr_flags & NDR_SCALARS) {

8724

NDR_CHECK(ndr_pull_align(ndr, 4));

8725

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->enablesharednetdrives));

8726

}

8727

if (ndr_flags & NDR_BUFFERS) {

8728

}

8729

return NDR_ERR_SUCCESS;

8730

}

8731

8732

_PUBLIC_ void ndr_print_srvsvc_NetSrvInfo1540(struct ndr_print *ndr, const char *name, const struct srvsvc_NetSrvInfo1540 *r)

8733

{

8734

ndr_print_struct(ndr, name, "srvsvc_NetSrvInfo1540");

8735

ndr->depth++;

8736

ndr_print_uint32(ndr, "enablesharednetdrives", r->enablesharednetdrives);

8737

ndr->depth--;

8738

}

8739

8740

static enum ndr_err_code ndr_push_srvsvc_NetSrvInfo1541(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetSrvInfo1541 *r)

8741

{

8742

if (ndr_flags & NDR_SCALARS) {

8743

NDR_CHECK(ndr_push_align(ndr, 4));

8744

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->minfreeconnections));

8745

}

8746

if (ndr_flags & NDR_BUFFERS) {

8747

}

8748

return NDR_ERR_SUCCESS;

8749

}

8750

8751

static enum ndr_err_code ndr_pull_srvsvc_NetSrvInfo1541(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetSrvInfo1541 *r)

8752

{

8753

if (ndr_flags & NDR_SCALARS) {

8754

NDR_CHECK(ndr_pull_align(ndr, 4));

8755

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->minfreeconnections));

8756

}

8757

if (ndr_flags & NDR_BUFFERS) {

8758

}

8759

return NDR_ERR_SUCCESS;

8760

}

8761

8762

_PUBLIC_ void ndr_print_srvsvc_NetSrvInfo1541(struct ndr_print *ndr, const char *name, const struct srvsvc_NetSrvInfo1541 *r)

8763

{

8764

ndr_print_struct(ndr, name, "srvsvc_NetSrvInfo1541");

8765

ndr->depth++;

8766

ndr_print_uint32(ndr, "minfreeconnections", r->minfreeconnections);

8767

ndr->depth--;

8768

}

8769

8770

static enum ndr_err_code ndr_push_srvsvc_NetSrvInfo1542(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetSrvInfo1542 *r)

8771

{

8772

if (ndr_flags & NDR_SCALARS) {

8773

NDR_CHECK(ndr_push_align(ndr, 4));

8774

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->maxfreeconnections));

8775

}

8776

if (ndr_flags & NDR_BUFFERS) {

8777

}

8778

return NDR_ERR_SUCCESS;

8779

}

8780

8781

static enum ndr_err_code ndr_pull_srvsvc_NetSrvInfo1542(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetSrvInfo1542 *r)

8782

{

8783

if (ndr_flags & NDR_SCALARS) {

8784

NDR_CHECK(ndr_pull_align(ndr, 4));

8785

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->maxfreeconnections));

8786

}

8787

if (ndr_flags & NDR_BUFFERS) {

8788

}

8789

return NDR_ERR_SUCCESS;

8790

}

8791

8792

_PUBLIC_ void ndr_print_srvsvc_NetSrvInfo1542(struct ndr_print *ndr, const char *name, const struct srvsvc_NetSrvInfo1542 *r)

8793

{

8794

ndr_print_struct(ndr, name, "srvsvc_NetSrvInfo1542");

8795

ndr->depth++;

8796

ndr_print_uint32(ndr, "maxfreeconnections", r->maxfreeconnections);

8797

ndr->depth--;

8798

}

8799

8800

static enum ndr_err_code ndr_push_srvsvc_NetSrvInfo1543(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetSrvInfo1543 *r)

8801

{

8802

if (ndr_flags & NDR_SCALARS) {

8803

NDR_CHECK(ndr_push_align(ndr, 4));

8804

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->initsesstable));

8805

}

8806

if (ndr_flags & NDR_BUFFERS) {

8807

}

8808

return NDR_ERR_SUCCESS;

8809

}

8810

8811

static enum ndr_err_code ndr_pull_srvsvc_NetSrvInfo1543(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetSrvInfo1543 *r)

8812

{

8813

if (ndr_flags & NDR_SCALARS) {

8814

NDR_CHECK(ndr_pull_align(ndr, 4));

8815

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->initsesstable));

8816

}

8817

if (ndr_flags & NDR_BUFFERS) {

8818

}

8819

return NDR_ERR_SUCCESS;

8820

}

8821

8822

_PUBLIC_ void ndr_print_srvsvc_NetSrvInfo1543(struct ndr_print *ndr, const char *name, const struct srvsvc_NetSrvInfo1543 *r)

8823

{

8824

ndr_print_struct(ndr, name, "srvsvc_NetSrvInfo1543");

8825

ndr->depth++;

8826

ndr_print_uint32(ndr, "initsesstable", r->initsesstable);

8827

ndr->depth--;

8828

}

8829

8830

static enum ndr_err_code ndr_push_srvsvc_NetSrvInfo1544(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetSrvInfo1544 *r)

8831

{

8832

if (ndr_flags & NDR_SCALARS) {

8833

NDR_CHECK(ndr_push_align(ndr, 4));

8834

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->initconntable));

8835

}

8836

if (ndr_flags & NDR_BUFFERS) {

8837

}

8838

return NDR_ERR_SUCCESS;

8839

}

8840

8841

static enum ndr_err_code ndr_pull_srvsvc_NetSrvInfo1544(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetSrvInfo1544 *r)

8842

{

8843

if (ndr_flags & NDR_SCALARS) {

8844

NDR_CHECK(ndr_pull_align(ndr, 4));

8845

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->initconntable));

8846

}

8847

if (ndr_flags & NDR_BUFFERS) {

8848

}

8849

return NDR_ERR_SUCCESS;

8850

}

8851

8852

_PUBLIC_ void ndr_print_srvsvc_NetSrvInfo1544(struct ndr_print *ndr, const char *name, const struct srvsvc_NetSrvInfo1544 *r)

8853

{

8854

ndr_print_struct(ndr, name, "srvsvc_NetSrvInfo1544");

8855

ndr->depth++;

8856

ndr_print_uint32(ndr, "initconntable", r->initconntable);

8857

ndr->depth--;

8858

}

8859

8860

static enum ndr_err_code ndr_push_srvsvc_NetSrvInfo1545(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetSrvInfo1545 *r)

8861

{

8862

if (ndr_flags & NDR_SCALARS) {

8863

NDR_CHECK(ndr_push_align(ndr, 4));

8864

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->initfiletable));

8865

}

8866

if (ndr_flags & NDR_BUFFERS) {

8867

}

8868

return NDR_ERR_SUCCESS;

8869

}

8870

8871

static enum ndr_err_code ndr_pull_srvsvc_NetSrvInfo1545(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetSrvInfo1545 *r)

8872

{

8873

if (ndr_flags & NDR_SCALARS) {

8874

NDR_CHECK(ndr_pull_align(ndr, 4));

8875

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->initfiletable));

8876

}

8877

if (ndr_flags & NDR_BUFFERS) {

8878

}

8879

return NDR_ERR_SUCCESS;

8880

}

8881

8882

_PUBLIC_ void ndr_print_srvsvc_NetSrvInfo1545(struct ndr_print *ndr, const char *name, const struct srvsvc_NetSrvInfo1545 *r)

8883

{

8884

ndr_print_struct(ndr, name, "srvsvc_NetSrvInfo1545");

8885

ndr->depth++;

8886

ndr_print_uint32(ndr, "initfiletable", r->initfiletable);

8887

ndr->depth--;

8888

}

8889

8890

static enum ndr_err_code ndr_push_srvsvc_NetSrvInfo1546(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetSrvInfo1546 *r)

8891

{

8892

if (ndr_flags & NDR_SCALARS) {

8893

NDR_CHECK(ndr_push_align(ndr, 4));

8894

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->initsearchtable));

8895

}

8896

if (ndr_flags & NDR_BUFFERS) {

8897

}

8898

return NDR_ERR_SUCCESS;

8899

}

8900

8901

static enum ndr_err_code ndr_pull_srvsvc_NetSrvInfo1546(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetSrvInfo1546 *r)

8902

{

8903

if (ndr_flags & NDR_SCALARS) {

8904

NDR_CHECK(ndr_pull_align(ndr, 4));

8905

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->initsearchtable));

8906

}

8907

if (ndr_flags & NDR_BUFFERS) {

8908

}

8909

return NDR_ERR_SUCCESS;

8910

}

8911

8912

_PUBLIC_ void ndr_print_srvsvc_NetSrvInfo1546(struct ndr_print *ndr, const char *name, const struct srvsvc_NetSrvInfo1546 *r)

8913

{

8914

ndr_print_struct(ndr, name, "srvsvc_NetSrvInfo1546");

8915

ndr->depth++;

8916

ndr_print_uint32(ndr, "initsearchtable", r->initsearchtable);

8917

ndr->depth--;

8918

}

8919

8920

static enum ndr_err_code ndr_push_srvsvc_NetSrvInfo1547(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetSrvInfo1547 *r)

8921

{

8922

if (ndr_flags & NDR_SCALARS) {

8923

NDR_CHECK(ndr_push_align(ndr, 4));

8924

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->alertsched));

8925

}

8926

if (ndr_flags & NDR_BUFFERS) {

8927

}

8928

return NDR_ERR_SUCCESS;

8929

}

8930

8931

static enum ndr_err_code ndr_pull_srvsvc_NetSrvInfo1547(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetSrvInfo1547 *r)

8932

{

8933

if (ndr_flags & NDR_SCALARS) {

8934

NDR_CHECK(ndr_pull_align(ndr, 4));

8935

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->alertsched));

8936

}

8937

if (ndr_flags & NDR_BUFFERS) {

8938

}

8939

return NDR_ERR_SUCCESS;

8940

}

8941

8942

_PUBLIC_ void ndr_print_srvsvc_NetSrvInfo1547(struct ndr_print *ndr, const char *name, const struct srvsvc_NetSrvInfo1547 *r)

8943

{

8944

ndr_print_struct(ndr, name, "srvsvc_NetSrvInfo1547");

8945

ndr->depth++;

8946

ndr_print_uint32(ndr, "alertsched", r->alertsched);

8947

ndr->depth--;

8948

}

8949

8950

static enum ndr_err_code ndr_push_srvsvc_NetSrvInfo1548(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetSrvInfo1548 *r)

8951

{

8952

if (ndr_flags & NDR_SCALARS) {

8953

NDR_CHECK(ndr_push_align(ndr, 4));

8954

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->errortreshold));

8955

}

8956

if (ndr_flags & NDR_BUFFERS) {

8957

}

8958

return NDR_ERR_SUCCESS;

8959

}

8960

8961

static enum ndr_err_code ndr_pull_srvsvc_NetSrvInfo1548(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetSrvInfo1548 *r)

8962

{

8963

if (ndr_flags & NDR_SCALARS) {

8964

NDR_CHECK(ndr_pull_align(ndr, 4));

8965

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->errortreshold));

8966

}

8967

if (ndr_flags & NDR_BUFFERS) {

8968

}

8969

return NDR_ERR_SUCCESS;

8970

}

8971

8972

_PUBLIC_ void ndr_print_srvsvc_NetSrvInfo1548(struct ndr_print *ndr, const char *name, const struct srvsvc_NetSrvInfo1548 *r)

8973

{

8974

ndr_print_struct(ndr, name, "srvsvc_NetSrvInfo1548");

8975

ndr->depth++;

8976

ndr_print_uint32(ndr, "errortreshold", r->errortreshold);

8977

ndr->depth--;

8978

}

8979

8980

static enum ndr_err_code ndr_push_srvsvc_NetSrvInfo1549(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetSrvInfo1549 *r)

8981

{

8982

if (ndr_flags & NDR_SCALARS) {

8983

NDR_CHECK(ndr_push_align(ndr, 4));

8984

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->networkerrortreshold));

8985

}

8986

if (ndr_flags & NDR_BUFFERS) {

8987

}

8988

return NDR_ERR_SUCCESS;

8989

}

8990

8991

static enum ndr_err_code ndr_pull_srvsvc_NetSrvInfo1549(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetSrvInfo1549 *r)

8992

{

8993

if (ndr_flags & NDR_SCALARS) {

8994

NDR_CHECK(ndr_pull_align(ndr, 4));

8995

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->networkerrortreshold));

8996

}

8997

if (ndr_flags & NDR_BUFFERS) {

8998

}

8999

return NDR_ERR_SUCCESS;

9000

}

9001

9002

_PUBLIC_ void ndr_print_srvsvc_NetSrvInfo1549(struct ndr_print *ndr, const char *name, const struct srvsvc_NetSrvInfo1549 *r)

9003

{

9004

ndr_print_struct(ndr, name, "srvsvc_NetSrvInfo1549");

9005

ndr->depth++;

9006

ndr_print_uint32(ndr, "networkerrortreshold", r->networkerrortreshold);

9007

ndr->depth--;

9008

}

9009

9010

static enum ndr_err_code ndr_push_srvsvc_NetSrvInfo1550(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetSrvInfo1550 *r)

9011

{

9012

if (ndr_flags & NDR_SCALARS) {

9013

NDR_CHECK(ndr_push_align(ndr, 4));

9014

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->diskspacetreshold));

9015

}

9016

if (ndr_flags & NDR_BUFFERS) {

9017

}

9018

return NDR_ERR_SUCCESS;

9019

}

9020

9021

static enum ndr_err_code ndr_pull_srvsvc_NetSrvInfo1550(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetSrvInfo1550 *r)

9022

{

9023

if (ndr_flags & NDR_SCALARS) {

9024

NDR_CHECK(ndr_pull_align(ndr, 4));

9025

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->diskspacetreshold));

9026

}

9027

if (ndr_flags & NDR_BUFFERS) {

9028

}

9029

return NDR_ERR_SUCCESS;

9030

}

9031

9032

_PUBLIC_ void ndr_print_srvsvc_NetSrvInfo1550(struct ndr_print *ndr, const char *name, const struct srvsvc_NetSrvInfo1550 *r)

9033

{

9034

ndr_print_struct(ndr, name, "srvsvc_NetSrvInfo1550");

9035

ndr->depth++;

9036

ndr_print_uint32(ndr, "diskspacetreshold", r->diskspacetreshold);

9037

ndr->depth--;

9038

}

9039

9040

static enum ndr_err_code ndr_push_srvsvc_NetSrvInfo1552(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetSrvInfo1552 *r)

9041

{

9042

if (ndr_flags & NDR_SCALARS) {

9043

NDR_CHECK(ndr_push_align(ndr, 4));

9044

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->maxlinkdelay));

9045

}

9046

if (ndr_flags & NDR_BUFFERS) {

9047

}

9048

return NDR_ERR_SUCCESS;

9049

}

9050

9051

static enum ndr_err_code ndr_pull_srvsvc_NetSrvInfo1552(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetSrvInfo1552 *r)

9052

{

9053

if (ndr_flags & NDR_SCALARS) {

9054

NDR_CHECK(ndr_pull_align(ndr, 4));

9055

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->maxlinkdelay));

9056

}

9057

if (ndr_flags & NDR_BUFFERS) {

9058

}

9059

return NDR_ERR_SUCCESS;

9060

}

9061

9062

_PUBLIC_ void ndr_print_srvsvc_NetSrvInfo1552(struct ndr_print *ndr, const char *name, const struct srvsvc_NetSrvInfo1552 *r)

9063

{

9064

ndr_print_struct(ndr, name, "srvsvc_NetSrvInfo1552");

9065

ndr->depth++;

9066

ndr_print_uint32(ndr, "maxlinkdelay", r->maxlinkdelay);

9067

ndr->depth--;

9068

}

9069

9070

static enum ndr_err_code ndr_push_srvsvc_NetSrvInfo1553(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetSrvInfo1553 *r)

9071

{

9072

if (ndr_flags & NDR_SCALARS) {

9073

NDR_CHECK(ndr_push_align(ndr, 4));

9074

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->minlinkthroughput));

9075

}

9076

if (ndr_flags & NDR_BUFFERS) {

9077

}

9078

return NDR_ERR_SUCCESS;

9079

}

9080

9081

static enum ndr_err_code ndr_pull_srvsvc_NetSrvInfo1553(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetSrvInfo1553 *r)

9082

{

9083

if (ndr_flags & NDR_SCALARS) {

9084

NDR_CHECK(ndr_pull_align(ndr, 4));

9085

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->minlinkthroughput));

9086

}

9087

if (ndr_flags & NDR_BUFFERS) {

9088

}

9089

return NDR_ERR_SUCCESS;

9090

}

9091

9092

_PUBLIC_ void ndr_print_srvsvc_NetSrvInfo1553(struct ndr_print *ndr, const char *name, const struct srvsvc_NetSrvInfo1553 *r)

9093

{

9094

ndr_print_struct(ndr, name, "srvsvc_NetSrvInfo1553");

9095

ndr->depth++;

9096

ndr_print_uint32(ndr, "minlinkthroughput", r->minlinkthroughput);

9097

ndr->depth--;

9098

}

9099

9100

static enum ndr_err_code ndr_push_srvsvc_NetSrvInfo1554(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetSrvInfo1554 *r)

9101

{

9102

if (ndr_flags & NDR_SCALARS) {

9103

NDR_CHECK(ndr_push_align(ndr, 4));

9104

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->linkinfovalidtime));

9105

}

9106

if (ndr_flags & NDR_BUFFERS) {

9107

}

9108

return NDR_ERR_SUCCESS;

9109

}

9110

9111

static enum ndr_err_code ndr_pull_srvsvc_NetSrvInfo1554(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetSrvInfo1554 *r)

9112

{

9113

if (ndr_flags & NDR_SCALARS) {

9114

NDR_CHECK(ndr_pull_align(ndr, 4));

9115

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->linkinfovalidtime));

9116

}

9117

if (ndr_flags & NDR_BUFFERS) {

9118

}

9119

return NDR_ERR_SUCCESS;

9120

}

9121

9122

_PUBLIC_ void ndr_print_srvsvc_NetSrvInfo1554(struct ndr_print *ndr, const char *name, const struct srvsvc_NetSrvInfo1554 *r)

9123

{

9124

ndr_print_struct(ndr, name, "srvsvc_NetSrvInfo1554");

9125

ndr->depth++;

9126

ndr_print_uint32(ndr, "linkinfovalidtime", r->linkinfovalidtime);

9127

ndr->depth--;

9128

}

9129

9130

static enum ndr_err_code ndr_push_srvsvc_NetSrvInfo1555(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetSrvInfo1555 *r)

9131

{

9132

if (ndr_flags & NDR_SCALARS) {

9133

NDR_CHECK(ndr_push_align(ndr, 4));

9134

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->scavqosinfoupdatetime));

9135

}

9136

if (ndr_flags & NDR_BUFFERS) {

9137

}

9138

return NDR_ERR_SUCCESS;

9139

}

9140

9141

static enum ndr_err_code ndr_pull_srvsvc_NetSrvInfo1555(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetSrvInfo1555 *r)

9142

{

9143

if (ndr_flags & NDR_SCALARS) {

9144

NDR_CHECK(ndr_pull_align(ndr, 4));

9145

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->scavqosinfoupdatetime));

9146

}

9147

if (ndr_flags & NDR_BUFFERS) {

9148

}

9149

return NDR_ERR_SUCCESS;

9150

}

9151

9152

_PUBLIC_ void ndr_print_srvsvc_NetSrvInfo1555(struct ndr_print *ndr, const char *name, const struct srvsvc_NetSrvInfo1555 *r)

9153

{

9154

ndr_print_struct(ndr, name, "srvsvc_NetSrvInfo1555");

9155

ndr->depth++;

9156

ndr_print_uint32(ndr, "scavqosinfoupdatetime", r->scavqosinfoupdatetime);

9157

ndr->depth--;

9158

}

9159

9160

static enum ndr_err_code ndr_push_srvsvc_NetSrvInfo1556(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetSrvInfo1556 *r)

9161

{

9162

if (ndr_flags & NDR_SCALARS) {

9163

NDR_CHECK(ndr_push_align(ndr, 4));

9164

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->maxworkitemidletime));

9165

}

9166

if (ndr_flags & NDR_BUFFERS) {

9167

}

9168

return NDR_ERR_SUCCESS;

9169

}

9170

9171

static enum ndr_err_code ndr_pull_srvsvc_NetSrvInfo1556(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetSrvInfo1556 *r)

9172

{

9173

if (ndr_flags & NDR_SCALARS) {

9174

NDR_CHECK(ndr_pull_align(ndr, 4));

9175

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->maxworkitemidletime));

9176

}

9177

if (ndr_flags & NDR_BUFFERS) {

9178

}

9179

return NDR_ERR_SUCCESS;

9180

}

9181

9182

_PUBLIC_ void ndr_print_srvsvc_NetSrvInfo1556(struct ndr_print *ndr, const char *name, const struct srvsvc_NetSrvInfo1556 *r)

9183

{

9184

ndr_print_struct(ndr, name, "srvsvc_NetSrvInfo1556");

9185

ndr->depth++;

9186

ndr_print_uint32(ndr, "maxworkitemidletime", r->maxworkitemidletime);

9187

ndr->depth--;

9188

}

9189

9190

static enum ndr_err_code ndr_push_srvsvc_NetSrvInfo(struct ndr_push *ndr, int ndr_flags, const union srvsvc_NetSrvInfo *r)

9191

{

9192

if (ndr_flags & NDR_SCALARS) {

9193

int level = ndr_push_get_switch_value(ndr, r);

9194

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));

9195

switch (level) {

9196

case 100: {

9197

NDR_CHECK(ndr_push_unique_ptr(ndr, r->info100));

9198

break; }

9199

9200

case 101: {

9201

NDR_CHECK(ndr_push_unique_ptr(ndr, r->info101));

9202

break; }

9203

9204

case 102: {

9205

NDR_CHECK(ndr_push_unique_ptr(ndr, r->info102));

9206

break; }

9207

9208

case 402: {

9209

NDR_CHECK(ndr_push_unique_ptr(ndr, r->info402));

9210

break; }

9211

9212

case 403: {

9213

NDR_CHECK(ndr_push_unique_ptr(ndr, r->info403));

9214

break; }

9215

9216

case 502: {

9217

NDR_CHECK(ndr_push_unique_ptr(ndr, r->info502));

9218

break; }

9219

9220

case 503: {

9221

NDR_CHECK(ndr_push_unique_ptr(ndr, r->info503));

9222

break; }

9223

9224

case 599: {

9225

NDR_CHECK(ndr_push_unique_ptr(ndr, r->info599));

9226

break; }

9227

9228

case 1005: {

9229

NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1005));

9230

break; }

9231

9232

case 1010: {

9233

NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1010));

9234

break; }

9235

9236

case 1016: {

9237

NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1016));

9238

break; }

9239

9240

case 1017: {

9241

NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1017));

9242

break; }

9243

9244

case 1018: {

9245

NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1018));

9246

break; }

9247

9248

case 1107: {

9249

NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1107));

9250

break; }

9251

9252

case 1501: {

9253

NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1501));

9254

break; }

9255

9256

case 1502: {

9257

NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1502));

9258

break; }

9259

9260

case 1503: {

9261

NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1503));

9262

break; }

9263

9264

case 1506: {

9265

NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1506));

9266

break; }

9267

9268

case 1509: {

9269

NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1509));

9270

break; }

9271

9272

case 1510: {

9273

NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1510));

9274

break; }

9275

9276

case 1511: {

9277

NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1511));

9278

break; }

9279

9280

case 1512: {

9281

NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1512));

9282

break; }

9283

9284

case 1513: {

9285

NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1513));

9286

break; }

9287

9288

case 1514: {

9289

NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1514));

9290

break; }

9291

9292

case 1515: {

9293

NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1515));

9294

break; }

9295

9296

case 1516: {

9297

NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1516));

9298

break; }

9299

9300

case 1518: {

9301

NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1518));

9302

break; }

9303

9304

case 1520: {

9305

NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1520));

9306

break; }

9307

9308

case 1521: {

9309

NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1521));

9310

break; }

9311

9312

case 1522: {

9313

NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1522));

9314

break; }

9315

9316

case 1523: {

9317

NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1523));

9318

break; }

9319

9320

case 1524: {

9321

NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1524));

9322

break; }

9323

9324

case 1525: {

9325

NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1525));

9326

break; }

9327

9328

case 1528: {

9329

NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1528));

9330

break; }

9331

9332

case 1529: {

9333

NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1529));

9334

break; }

9335

9336

case 1530: {

9337

NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1530));

9338

break; }

9339

9340

case 1533: {

9341

NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1533));

9342

break; }

9343

9344

case 1534: {

9345

NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1534));

9346

break; }

9347

9348

case 1535: {

9349

NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1535));

9350

break; }

9351

9352

case 1536: {

9353

NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1536));

9354

break; }

9355

9356

case 1537: {

9357

NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1537));

9358

break; }

9359

9360

case 1538: {

9361

NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1538));

9362

break; }

9363

9364

case 1539: {

9365

NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1539));

9366

break; }

9367

9368

case 1540: {

9369

NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1540));

9370

break; }

9371

9372

case 1541: {

9373

NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1541));

9374

break; }

9375

9376

case 1542: {

9377

NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1542));

9378

break; }

9379

9380

case 1543: {

9381

NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1543));

9382

break; }

9383

9384

case 1544: {

9385

NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1544));

9386

break; }

9387

9388

case 1545: {

9389

NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1545));

9390

break; }

9391

9392

case 1546: {

9393

NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1546));

9394

break; }

9395

9396

case 1547: {

9397

NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1547));

9398

break; }

9399

9400

case 1548: {

9401

NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1548));

9402

break; }

9403

9404

case 1549: {

9405

NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1549));

9406

break; }

9407

9408

case 1550: {

9409

NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1550));

9410

break; }

9411

9412

case 1552: {

9413

NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1552));

9414

break; }

9415

9416

case 1553: {

9417

NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1553));

9418

break; }

9419

9420

case 1554: {

9421

NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1554));

9422

break; }

9423

9424

case 1555: {

9425

NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1555));

9426

break; }

9427

9428

case 1556: {

9429

NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1556));

9430

break; }

9431

9432

default: {

9433

break; }

9434

9435

}

9436

}

9437

if (ndr_flags & NDR_BUFFERS) {

9438

int level = ndr_push_get_switch_value(ndr, r);

9439

switch (level) {

9440

case 100:

9441

if (r->info100) {

9442

NDR_CHECK(ndr_push_srvsvc_NetSrvInfo100(ndr, NDR_SCALARS|NDR_BUFFERS, r->info100));

9443

}

9444

break;

9445

9446

case 101:

9447

if (r->info101) {

9448

NDR_CHECK(ndr_push_srvsvc_NetSrvInfo101(ndr, NDR_SCALARS|NDR_BUFFERS, r->info101));

9449

}

9450

break;

9451

9452

case 102:

9453

if (r->info102) {

9454

NDR_CHECK(ndr_push_srvsvc_NetSrvInfo102(ndr, NDR_SCALARS|NDR_BUFFERS, r->info102));

9455

}

9456

break;

9457

9458

case 402:

9459

if (r->info402) {

9460

NDR_CHECK(ndr_push_srvsvc_NetSrvInfo402(ndr, NDR_SCALARS|NDR_BUFFERS, r->info402));

9461

}

9462

break;

9463

9464

case 403:

9465

if (r->info403) {

9466

NDR_CHECK(ndr_push_srvsvc_NetSrvInfo403(ndr, NDR_SCALARS|NDR_BUFFERS, r->info403));

9467

}

9468

break;

9469

9470

case 502:

9471

if (r->info502) {

9472

NDR_CHECK(ndr_push_srvsvc_NetSrvInfo502(ndr, NDR_SCALARS, r->info502));

9473

}

9474

break;

9475

9476

case 503:

9477

if (r->info503) {

9478

NDR_CHECK(ndr_push_srvsvc_NetSrvInfo503(ndr, NDR_SCALARS|NDR_BUFFERS, r->info503));

9479

}

9480

break;

9481

9482

case 599:

9483

if (r->info599) {

9484

NDR_CHECK(ndr_push_srvsvc_NetSrvInfo599(ndr, NDR_SCALARS|NDR_BUFFERS, r->info599));

9485

}

9486

break;

9487

9488

case 1005:

9489

if (r->info1005) {

9490

NDR_CHECK(ndr_push_srvsvc_NetSrvInfo1005(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1005));

9491

}

9492

break;

9493

9494

case 1010:

9495

if (r->info1010) {

9496

NDR_CHECK(ndr_push_srvsvc_NetSrvInfo1010(ndr, NDR_SCALARS, r->info1010));

9497

}

9498

break;

9499

9500

case 1016:

9501

if (r->info1016) {

9502

NDR_CHECK(ndr_push_srvsvc_NetSrvInfo1016(ndr, NDR_SCALARS, r->info1016));

9503

}

9504

break;

9505

9506

case 1017:

9507

if (r->info1017) {

9508

NDR_CHECK(ndr_push_srvsvc_NetSrvInfo1017(ndr, NDR_SCALARS, r->info1017));

9509

}

9510

break;

9511

9512

case 1018:

9513

if (r->info1018) {

9514

NDR_CHECK(ndr_push_srvsvc_NetSrvInfo1018(ndr, NDR_SCALARS, r->info1018));

9515

}

9516

break;

9517

9518

case 1107:

9519

if (r->info1107) {

9520

NDR_CHECK(ndr_push_srvsvc_NetSrvInfo1107(ndr, NDR_SCALARS, r->info1107));

9521

}

9522

break;

9523

9524

case 1501:

9525

if (r->info1501) {

9526

NDR_CHECK(ndr_push_srvsvc_NetSrvInfo1501(ndr, NDR_SCALARS, r->info1501));

9527

}

9528

break;

9529

9530

case 1502:

9531

if (r->info1502) {

9532

NDR_CHECK(ndr_push_srvsvc_NetSrvInfo1502(ndr, NDR_SCALARS, r->info1502));

9533

}

9534

break;

9535

9536

case 1503:

9537

if (r->info1503) {

9538

NDR_CHECK(ndr_push_srvsvc_NetSrvInfo1503(ndr, NDR_SCALARS, r->info1503));

9539

}

9540

break;

9541

9542

case 1506:

9543

if (r->info1506) {

9544

NDR_CHECK(ndr_push_srvsvc_NetSrvInfo1506(ndr, NDR_SCALARS, r->info1506));

9545

}

9546

break;

9547

9548

case 1509:

9549

if (r->info1509) {

9550

NDR_CHECK(ndr_push_srvsvc_NetSrvInfo1509(ndr, NDR_SCALARS, r->info1509));

9551

}

9552

break;

9553

9554

case 1510:

9555

if (r->info1510) {

9556

NDR_CHECK(ndr_push_srvsvc_NetSrvInfo1510(ndr, NDR_SCALARS, r->info1510));

9557

}

9558

break;

9559

9560

case 1511:

9561

if (r->info1511) {

9562

NDR_CHECK(ndr_push_srvsvc_NetSrvInfo1511(ndr, NDR_SCALARS, r->info1511));

9563

}

9564

break;

9565

9566

case 1512:

9567

if (r->info1512) {

9568

NDR_CHECK(ndr_push_srvsvc_NetSrvInfo1512(ndr, NDR_SCALARS, r->info1512));

9569

}

9570

break;

9571

9572

case 1513:

9573

if (r->info1513) {

9574

NDR_CHECK(ndr_push_srvsvc_NetSrvInfo1513(ndr, NDR_SCALARS, r->info1513));

9575

}

9576

break;

9577

9578

case 1514:

9579

if (r->info1514) {

9580

NDR_CHECK(ndr_push_srvsvc_NetSrvInfo1514(ndr, NDR_SCALARS, r->info1514));

9581

}

9582

break;

9583

9584

case 1515:

9585

if (r->info1515) {

9586

NDR_CHECK(ndr_push_srvsvc_NetSrvInfo1515(ndr, NDR_SCALARS, r->info1515));

9587

}

9588

break;

9589

9590

case 1516:

9591

if (r->info1516) {

9592

NDR_CHECK(ndr_push_srvsvc_NetSrvInfo1516(ndr, NDR_SCALARS, r->info1516));

9593

}

9594

break;

9595

9596

case 1518:

9597

if (r->info1518) {

9598

NDR_CHECK(ndr_push_srvsvc_NetSrvInfo1518(ndr, NDR_SCALARS, r->info1518));

9599

}

9600

break;

9601

9602

case 1520:

9603

if (r->info1520) {

9604

NDR_CHECK(ndr_push_srvsvc_NetSrvInfo1520(ndr, NDR_SCALARS, r->info1520));

9605

}

9606

break;

9607

9608

case 1521:

9609

if (r->info1521) {

9610

NDR_CHECK(ndr_push_srvsvc_NetSrvInfo1521(ndr, NDR_SCALARS, r->info1521));

9611

}

9612

break;

9613

9614

case 1522:

9615

if (r->info1522) {

9616

NDR_CHECK(ndr_push_srvsvc_NetSrvInfo1522(ndr, NDR_SCALARS, r->info1522));

9617

}

9618

break;

9619

9620

case 1523:

9621

if (r->info1523) {

9622

NDR_CHECK(ndr_push_srvsvc_NetSrvInfo1523(ndr, NDR_SCALARS, r->info1523));

9623

}

9624

break;

9625

9626

case 1524:

9627

if (r->info1524) {

9628

NDR_CHECK(ndr_push_srvsvc_NetSrvInfo1524(ndr, NDR_SCALARS, r->info1524));

9629

}

9630

break;

9631

9632

case 1525:

9633

if (r->info1525) {

9634

NDR_CHECK(ndr_push_srvsvc_NetSrvInfo1525(ndr, NDR_SCALARS, r->info1525));

9635

}

9636

break;

9637

9638

case 1528:

9639

if (r->info1528) {

9640

NDR_CHECK(ndr_push_srvsvc_NetSrvInfo1528(ndr, NDR_SCALARS, r->info1528));

9641

}

9642

break;

9643

9644

case 1529:

9645

if (r->info1529) {

9646

NDR_CHECK(ndr_push_srvsvc_NetSrvInfo1529(ndr, NDR_SCALARS, r->info1529));

9647

}

9648

break;

9649

9650

case 1530:

9651

if (r->info1530) {

9652

NDR_CHECK(ndr_push_srvsvc_NetSrvInfo1530(ndr, NDR_SCALARS, r->info1530));

9653

}

9654

break;

9655

9656

case 1533:

9657

if (r->info1533) {

9658

NDR_CHECK(ndr_push_srvsvc_NetSrvInfo1533(ndr, NDR_SCALARS, r->info1533));

9659

}

9660

break;

9661

9662

case 1534:

9663

if (r->info1534) {

9664

NDR_CHECK(ndr_push_srvsvc_NetSrvInfo1534(ndr, NDR_SCALARS, r->info1534));

9665

}

9666

break;

9667

9668

case 1535:

9669

if (r->info1535) {

9670

NDR_CHECK(ndr_push_srvsvc_NetSrvInfo1535(ndr, NDR_SCALARS, r->info1535));

9671

}

9672

break;

9673

9674

case 1536:

9675

if (r->info1536) {

9676

NDR_CHECK(ndr_push_srvsvc_NetSrvInfo1536(ndr, NDR_SCALARS, r->info1536));

9677

}

9678

break;

9679

9680

case 1537:

9681

if (r->info1537) {

9682

NDR_CHECK(ndr_push_srvsvc_NetSrvInfo1537(ndr, NDR_SCALARS, r->info1537));

9683

}

9684

break;

9685

9686

case 1538:

9687

if (r->info1538) {

9688

NDR_CHECK(ndr_push_srvsvc_NetSrvInfo1538(ndr, NDR_SCALARS, r->info1538));

9689

}

9690

break;

9691

9692

case 1539:

9693

if (r->info1539) {

9694

NDR_CHECK(ndr_push_srvsvc_NetSrvInfo1539(ndr, NDR_SCALARS, r->info1539));

9695

}

9696

break;

9697

9698

case 1540:

9699

if (r->info1540) {

9700

NDR_CHECK(ndr_push_srvsvc_NetSrvInfo1540(ndr, NDR_SCALARS, r->info1540));

9701

}

9702

break;

9703

9704

case 1541:

9705

if (r->info1541) {

9706

NDR_CHECK(ndr_push_srvsvc_NetSrvInfo1541(ndr, NDR_SCALARS, r->info1541));

9707

}

9708

break;

9709

9710

case 1542:

9711

if (r->info1542) {

9712

NDR_CHECK(ndr_push_srvsvc_NetSrvInfo1542(ndr, NDR_SCALARS, r->info1542));

9713

}

9714

break;

9715

9716

case 1543:

9717

if (r->info1543) {

9718

NDR_CHECK(ndr_push_srvsvc_NetSrvInfo1543(ndr, NDR_SCALARS, r->info1543));

9719

}

9720

break;

9721

9722

case 1544:

9723

if (r->info1544) {

9724

NDR_CHECK(ndr_push_srvsvc_NetSrvInfo1544(ndr, NDR_SCALARS, r->info1544));

9725

}

9726

break;

9727

9728

case 1545:

9729

if (r->info1545) {

9730

NDR_CHECK(ndr_push_srvsvc_NetSrvInfo1545(ndr, NDR_SCALARS, r->info1545));

9731

}

9732

break;

9733

9734

case 1546:

9735

if (r->info1546) {

9736

NDR_CHECK(ndr_push_srvsvc_NetSrvInfo1546(ndr, NDR_SCALARS, r->info1546));

9737

}

9738

break;

9739

9740

case 1547:

9741

if (r->info1547) {

9742

NDR_CHECK(ndr_push_srvsvc_NetSrvInfo1547(ndr, NDR_SCALARS, r->info1547));

9743

}

9744

break;

9745

9746

case 1548:

9747

if (r->info1548) {

9748

NDR_CHECK(ndr_push_srvsvc_NetSrvInfo1548(ndr, NDR_SCALARS, r->info1548));

9749

}

9750

break;

9751

9752

case 1549:

9753

if (r->info1549) {

9754

NDR_CHECK(ndr_push_srvsvc_NetSrvInfo1549(ndr, NDR_SCALARS, r->info1549));

9755

}

9756

break;

9757

9758

case 1550:

9759

if (r->info1550) {

9760

NDR_CHECK(ndr_push_srvsvc_NetSrvInfo1550(ndr, NDR_SCALARS, r->info1550));

9761

}

9762

break;

9763

9764

case 1552:

9765

if (r->info1552) {

9766

NDR_CHECK(ndr_push_srvsvc_NetSrvInfo1552(ndr, NDR_SCALARS, r->info1552));

9767

}

9768

break;

9769

9770

case 1553:

9771

if (r->info1553) {

9772

NDR_CHECK(ndr_push_srvsvc_NetSrvInfo1553(ndr, NDR_SCALARS, r->info1553));

9773

}

9774

break;

9775

9776

case 1554:

9777

if (r->info1554) {

9778

NDR_CHECK(ndr_push_srvsvc_NetSrvInfo1554(ndr, NDR_SCALARS, r->info1554));

9779

}

9780

break;

9781

9782

case 1555:

9783

if (r->info1555) {

9784

NDR_CHECK(ndr_push_srvsvc_NetSrvInfo1555(ndr, NDR_SCALARS, r->info1555));

9785

}

9786

break;

9787

9788

case 1556:

9789

if (r->info1556) {

9790

NDR_CHECK(ndr_push_srvsvc_NetSrvInfo1556(ndr, NDR_SCALARS, r->info1556));

9791

}

9792

break;

9793

9794

default:

9795

break;

9796

9797

}

9798

}

9799

return NDR_ERR_SUCCESS;

9800

}

9801

9802

static enum ndr_err_code ndr_pull_srvsvc_NetSrvInfo(struct ndr_pull *ndr, int ndr_flags, union srvsvc_NetSrvInfo *r)

9803

{

9804

int level;

9805

uint32_t _level;

9806

TALLOC_CTX *_mem_save_info100_0;

9807

TALLOC_CTX *_mem_save_info101_0;

9808

TALLOC_CTX *_mem_save_info102_0;

9809

TALLOC_CTX *_mem_save_info402_0;

9810

TALLOC_CTX *_mem_save_info403_0;

9811

TALLOC_CTX *_mem_save_info502_0;

9812

TALLOC_CTX *_mem_save_info503_0;

9813

TALLOC_CTX *_mem_save_info599_0;

9814

TALLOC_CTX *_mem_save_info1005_0;

9815

TALLOC_CTX *_mem_save_info1010_0;

9816

TALLOC_CTX *_mem_save_info1016_0;

9817

TALLOC_CTX *_mem_save_info1017_0;

9818

TALLOC_CTX *_mem_save_info1018_0;

9819

TALLOC_CTX *_mem_save_info1107_0;

9820

TALLOC_CTX *_mem_save_info1501_0;

9821

TALLOC_CTX *_mem_save_info1502_0;

9822

TALLOC_CTX *_mem_save_info1503_0;

9823

TALLOC_CTX *_mem_save_info1506_0;

9824

TALLOC_CTX *_mem_save_info1509_0;

9825

TALLOC_CTX *_mem_save_info1510_0;

9826

TALLOC_CTX *_mem_save_info1511_0;

9827

TALLOC_CTX *_mem_save_info1512_0;

9828

TALLOC_CTX *_mem_save_info1513_0;

9829

TALLOC_CTX *_mem_save_info1514_0;

9830

TALLOC_CTX *_mem_save_info1515_0;

9831

TALLOC_CTX *_mem_save_info1516_0;

9832

TALLOC_CTX *_mem_save_info1518_0;

9833

TALLOC_CTX *_mem_save_info1520_0;

9834

TALLOC_CTX *_mem_save_info1521_0;

9835

TALLOC_CTX *_mem_save_info1522_0;

9836

TALLOC_CTX *_mem_save_info1523_0;

9837

TALLOC_CTX *_mem_save_info1524_0;

9838

TALLOC_CTX *_mem_save_info1525_0;

9839

TALLOC_CTX *_mem_save_info1528_0;

9840

TALLOC_CTX *_mem_save_info1529_0;

9841

TALLOC_CTX *_mem_save_info1530_0;

9842

TALLOC_CTX *_mem_save_info1533_0;

9843

TALLOC_CTX *_mem_save_info1534_0;

9844

TALLOC_CTX *_mem_save_info1535_0;

9845

TALLOC_CTX *_mem_save_info1536_0;

9846

TALLOC_CTX *_mem_save_info1537_0;

9847

TALLOC_CTX *_mem_save_info1538_0;

9848

TALLOC_CTX *_mem_save_info1539_0;

9849

TALLOC_CTX *_mem_save_info1540_0;

9850

TALLOC_CTX *_mem_save_info1541_0;

9851

TALLOC_CTX *_mem_save_info1542_0;

9852

TALLOC_CTX *_mem_save_info1543_0;

9853

TALLOC_CTX *_mem_save_info1544_0;

9854

TALLOC_CTX *_mem_save_info1545_0;

9855

TALLOC_CTX *_mem_save_info1546_0;

9856

TALLOC_CTX *_mem_save_info1547_0;

9857

TALLOC_CTX *_mem_save_info1548_0;

9858

TALLOC_CTX *_mem_save_info1549_0;

9859

TALLOC_CTX *_mem_save_info1550_0;

9860

TALLOC_CTX *_mem_save_info1552_0;

9861

TALLOC_CTX *_mem_save_info1553_0;

9862

TALLOC_CTX *_mem_save_info1554_0;

9863

TALLOC_CTX *_mem_save_info1555_0;

9864

TALLOC_CTX *_mem_save_info1556_0;

9865

level = ndr_pull_get_switch_value(ndr, r);

9866

if (ndr_flags & NDR_SCALARS) {

9867

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));

9868

if (_level != level) {

9869

return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r", _level);

9870

}

9871

switch (level) {

9872

case 100: {

9873

uint32_t _ptr_info100;

9874

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info100));

9875

if (_ptr_info100) {

9876

NDR_PULL_ALLOC(ndr, r->info100);

9877

} else {

9878

r->info100 = NULL;

9879

}

9880

break; }

9881

9882

case 101: {

9883

uint32_t _ptr_info101;

9884

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info101));

9885

if (_ptr_info101) {

9886

NDR_PULL_ALLOC(ndr, r->info101);

9887

} else {

9888

r->info101 = NULL;

9889

}

9890

break; }

9891

9892

case 102: {

9893

uint32_t _ptr_info102;

9894

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info102));

9895

if (_ptr_info102) {

9896

NDR_PULL_ALLOC(ndr, r->info102);

9897

} else {

9898

r->info102 = NULL;

9899

}

9900

break; }

9901

9902

case 402: {

9903

uint32_t _ptr_info402;

9904

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info402));

9905

if (_ptr_info402) {

9906

NDR_PULL_ALLOC(ndr, r->info402);

9907

} else {

9908

r->info402 = NULL;

9909

}

9910

break; }

9911

9912

case 403: {

9913

uint32_t _ptr_info403;

9914

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info403));

9915

if (_ptr_info403) {

9916

NDR_PULL_ALLOC(ndr, r->info403);

9917

} else {

9918

r->info403 = NULL;

9919

}

9920

break; }

9921

9922

case 502: {

9923

uint32_t _ptr_info502;

9924

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info502));

9925

if (_ptr_info502) {

9926

NDR_PULL_ALLOC(ndr, r->info502);

9927

} else {

9928

r->info502 = NULL;

9929

}

9930

break; }

9931

9932

case 503: {

9933

uint32_t _ptr_info503;

9934

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info503));

9935

if (_ptr_info503) {

9936

NDR_PULL_ALLOC(ndr, r->info503);

9937

} else {

9938

r->info503 = NULL;

9939

}

9940

break; }

9941

9942

case 599: {

9943

uint32_t _ptr_info599;

9944

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info599));

9945

if (_ptr_info599) {

9946

NDR_PULL_ALLOC(ndr, r->info599);

9947

} else {

9948

r->info599 = NULL;

9949

}

9950

break; }

9951

9952

case 1005: {

9953

uint32_t _ptr_info1005;

9954

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1005));

9955

if (_ptr_info1005) {

9956

NDR_PULL_ALLOC(ndr, r->info1005);

9957

} else {

9958

r->info1005 = NULL;

9959

}

9960

break; }

9961

9962

case 1010: {

9963

uint32_t _ptr_info1010;

9964

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1010));

9965

if (_ptr_info1010) {

9966

NDR_PULL_ALLOC(ndr, r->info1010);

9967

} else {

9968

r->info1010 = NULL;

9969

}

9970

break; }

9971

9972

case 1016: {

9973

uint32_t _ptr_info1016;

9974

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1016));

9975

if (_ptr_info1016) {

9976

NDR_PULL_ALLOC(ndr, r->info1016);

9977

} else {

9978

r->info1016 = NULL;

9979

}

9980

break; }

9981

9982

case 1017: {

9983

uint32_t _ptr_info1017;

9984

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1017));

9985

if (_ptr_info1017) {

9986

NDR_PULL_ALLOC(ndr, r->info1017);

9987

} else {

9988

r->info1017 = NULL;

9989

}

9990

break; }

9991

9992

case 1018: {

9993

uint32_t _ptr_info1018;

9994

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1018));

9995

if (_ptr_info1018) {

9996

NDR_PULL_ALLOC(ndr, r->info1018);

9997

} else {

9998

r->info1018 = NULL;

9999

}

10000

break; }

10001

10002

case 1107: {

10003

uint32_t _ptr_info1107;

10004

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1107));

10005

if (_ptr_info1107) {

10006

NDR_PULL_ALLOC(ndr, r->info1107);

10007

} else {

10008

r->info1107 = NULL;

10009

}

10010

break; }

10011

10012

case 1501: {

10013

uint32_t _ptr_info1501;

10014

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1501));

10015

if (_ptr_info1501) {

10016

NDR_PULL_ALLOC(ndr, r->info1501);

10017

} else {

10018

r->info1501 = NULL;

10019

}

10020

break; }

10021

10022

case 1502: {

10023

uint32_t _ptr_info1502;

10024

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1502));

10025

if (_ptr_info1502) {

10026

NDR_PULL_ALLOC(ndr, r->info1502);

10027

} else {

10028

r->info1502 = NULL;

10029

}

10030

break; }

10031

10032

case 1503: {

10033

uint32_t _ptr_info1503;

10034

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1503));

10035

if (_ptr_info1503) {

10036

NDR_PULL_ALLOC(ndr, r->info1503);

10037

} else {

10038

r->info1503 = NULL;

10039

}

10040

break; }

10041

10042

case 1506: {

10043

uint32_t _ptr_info1506;

10044

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1506));

10045

if (_ptr_info1506) {

10046

NDR_PULL_ALLOC(ndr, r->info1506);

10047

} else {

10048

r->info1506 = NULL;

10049

}

10050

break; }

10051

10052

case 1509: {

10053

uint32_t _ptr_info1509;

10054

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1509));

10055

if (_ptr_info1509) {

10056

NDR_PULL_ALLOC(ndr, r->info1509);

10057

} else {

10058

r->info1509 = NULL;

10059

}

10060

break; }

10061

10062

case 1510: {

10063

uint32_t _ptr_info1510;

10064

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1510));

10065

if (_ptr_info1510) {

10066

NDR_PULL_ALLOC(ndr, r->info1510);

10067

} else {

10068

r->info1510 = NULL;

10069

}

10070

break; }

10071

10072

case 1511: {

10073

uint32_t _ptr_info1511;

10074

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1511));

10075

if (_ptr_info1511) {

10076

NDR_PULL_ALLOC(ndr, r->info1511);

10077

} else {

10078

r->info1511 = NULL;

10079

}

10080

break; }

10081

10082

case 1512: {

10083

uint32_t _ptr_info1512;

10084

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1512));

10085

if (_ptr_info1512) {

10086

NDR_PULL_ALLOC(ndr, r->info1512);

10087

} else {

10088

r->info1512 = NULL;

10089

}

10090

break; }

10091

10092

case 1513: {

10093

uint32_t _ptr_info1513;

10094

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1513));

10095

if (_ptr_info1513) {

10096

NDR_PULL_ALLOC(ndr, r->info1513);

10097

} else {

10098

r->info1513 = NULL;

10099

}

10100

break; }

10101

10102

case 1514: {

10103

uint32_t _ptr_info1514;

10104

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1514));

10105

if (_ptr_info1514) {

10106

NDR_PULL_ALLOC(ndr, r->info1514);

10107

} else {

10108

r->info1514 = NULL;

10109

}

10110

break; }

10111

10112

case 1515: {

10113

uint32_t _ptr_info1515;

10114

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1515));

10115

if (_ptr_info1515) {

10116

NDR_PULL_ALLOC(ndr, r->info1515);

10117

} else {

10118

r->info1515 = NULL;

10119

}

10120

break; }

10121

10122

case 1516: {

10123

uint32_t _ptr_info1516;

10124

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1516));

10125

if (_ptr_info1516) {

10126

NDR_PULL_ALLOC(ndr, r->info1516);

10127

} else {

10128

r->info1516 = NULL;

10129

}

10130

break; }

10131

10132

case 1518: {

10133

uint32_t _ptr_info1518;

10134

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1518));

10135

if (_ptr_info1518) {

10136

NDR_PULL_ALLOC(ndr, r->info1518);

10137

} else {

10138

r->info1518 = NULL;

10139

}

10140

break; }

10141

10142

case 1520: {

10143

uint32_t _ptr_info1520;

10144

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1520));

10145

if (_ptr_info1520) {

10146

NDR_PULL_ALLOC(ndr, r->info1520);

10147

} else {

10148

r->info1520 = NULL;

10149

}

10150

break; }

10151

10152

case 1521: {

10153

uint32_t _ptr_info1521;

10154

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1521));

10155

if (_ptr_info1521) {

10156

NDR_PULL_ALLOC(ndr, r->info1521);

10157

} else {

10158

r->info1521 = NULL;

10159

}

10160

break; }

10161

10162

case 1522: {

10163

uint32_t _ptr_info1522;

10164

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1522));

10165

if (_ptr_info1522) {

10166

NDR_PULL_ALLOC(ndr, r->info1522);

10167

} else {

10168

r->info1522 = NULL;

10169

}

10170

break; }

10171

10172

case 1523: {

10173

uint32_t _ptr_info1523;

10174

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1523));

10175

if (_ptr_info1523) {

10176

NDR_PULL_ALLOC(ndr, r->info1523);

10177

} else {

10178

r->info1523 = NULL;

10179

}

10180

break; }

10181

10182

case 1524: {

10183

uint32_t _ptr_info1524;

10184

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1524));

10185

if (_ptr_info1524) {

10186

NDR_PULL_ALLOC(ndr, r->info1524);

10187

} else {

10188

r->info1524 = NULL;

10189

}

10190

break; }

10191

10192

case 1525: {

10193

uint32_t _ptr_info1525;

10194

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1525));

10195

if (_ptr_info1525) {

10196

NDR_PULL_ALLOC(ndr, r->info1525);

10197

} else {

10198

r->info1525 = NULL;

10199

}

10200

break; }

10201

10202

case 1528: {

10203

uint32_t _ptr_info1528;

10204

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1528));

10205

if (_ptr_info1528) {

10206

NDR_PULL_ALLOC(ndr, r->info1528);

10207

} else {

10208

r->info1528 = NULL;

10209

}

10210

break; }

10211

10212

case 1529: {

10213

uint32_t _ptr_info1529;

10214

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1529));

10215

if (_ptr_info1529) {

10216

NDR_PULL_ALLOC(ndr, r->info1529);

10217

} else {

10218

r->info1529 = NULL;

10219

}

10220

break; }

10221

10222

case 1530: {

10223

uint32_t _ptr_info1530;

10224

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1530));

10225

if (_ptr_info1530) {

10226

NDR_PULL_ALLOC(ndr, r->info1530);

10227

} else {

10228

r->info1530 = NULL;

10229

}

10230

break; }

10231

10232

case 1533: {

10233

uint32_t _ptr_info1533;

10234

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1533));

10235

if (_ptr_info1533) {

10236

NDR_PULL_ALLOC(ndr, r->info1533);

10237

} else {

10238

r->info1533 = NULL;

10239

}

10240

break; }

10241

10242

case 1534: {

10243

uint32_t _ptr_info1534;

10244

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1534));

10245

if (_ptr_info1534) {

10246

NDR_PULL_ALLOC(ndr, r->info1534);

10247

} else {

10248

r->info1534 = NULL;

10249

}

10250

break; }

10251

10252

case 1535: {

10253

uint32_t _ptr_info1535;

10254

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1535));

10255

if (_ptr_info1535) {

10256

NDR_PULL_ALLOC(ndr, r->info1535);

10257

} else {

10258

r->info1535 = NULL;

10259

}

10260

break; }

10261

10262

case 1536: {

10263

uint32_t _ptr_info1536;

10264

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1536));

10265

if (_ptr_info1536) {

10266

NDR_PULL_ALLOC(ndr, r->info1536);

10267

} else {

10268

r->info1536 = NULL;

10269

}

10270

break; }

10271

10272

case 1537: {

10273

uint32_t _ptr_info1537;

10274

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1537));

10275

if (_ptr_info1537) {

10276

NDR_PULL_ALLOC(ndr, r->info1537);

10277

} else {

10278

r->info1537 = NULL;

10279

}

10280

break; }

10281

10282

case 1538: {

10283

uint32_t _ptr_info1538;

10284

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1538));

10285

if (_ptr_info1538) {

10286

NDR_PULL_ALLOC(ndr, r->info1538);

10287

} else {

10288

r->info1538 = NULL;

10289

}

10290

break; }

10291

10292

case 1539: {

10293

uint32_t _ptr_info1539;

10294

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1539));

10295

if (_ptr_info1539) {

10296

NDR_PULL_ALLOC(ndr, r->info1539);

10297

} else {

10298

r->info1539 = NULL;

10299

}

10300

break; }

10301

10302

case 1540: {

10303

uint32_t _ptr_info1540;

10304

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1540));

10305

if (_ptr_info1540) {

10306

NDR_PULL_ALLOC(ndr, r->info1540);

10307

} else {

10308

r->info1540 = NULL;

10309

}

10310

break; }

10311

10312

case 1541: {

10313

uint32_t _ptr_info1541;

10314

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1541));

10315

if (_ptr_info1541) {

10316

NDR_PULL_ALLOC(ndr, r->info1541);

10317

} else {

10318

r->info1541 = NULL;

10319

}

10320

break; }

10321

10322

case 1542: {

10323

uint32_t _ptr_info1542;

10324

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1542));

10325

if (_ptr_info1542) {

10326

NDR_PULL_ALLOC(ndr, r->info1542);

10327

} else {

10328

r->info1542 = NULL;

10329

}

10330

break; }

10331

10332

case 1543: {

10333

uint32_t _ptr_info1543;

10334

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1543));

10335

if (_ptr_info1543) {

10336

NDR_PULL_ALLOC(ndr, r->info1543);

10337

} else {

10338

r->info1543 = NULL;

10339

}

10340

break; }

10341

10342

case 1544: {

10343

uint32_t _ptr_info1544;

10344

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1544));

10345

if (_ptr_info1544) {

10346

NDR_PULL_ALLOC(ndr, r->info1544);

10347

} else {

10348

r->info1544 = NULL;

10349

}

10350

break; }

10351

10352

case 1545: {

10353

uint32_t _ptr_info1545;

10354

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1545));

10355

if (_ptr_info1545) {

10356

NDR_PULL_ALLOC(ndr, r->info1545);

10357

} else {

10358

r->info1545 = NULL;

10359

}

10360

break; }

10361

10362

case 1546: {

10363

uint32_t _ptr_info1546;

10364

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1546));

10365

if (_ptr_info1546) {

10366

NDR_PULL_ALLOC(ndr, r->info1546);

10367

} else {

10368

r->info1546 = NULL;

10369

}

10370

break; }

10371

10372

case 1547: {

10373

uint32_t _ptr_info1547;

10374

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1547));

10375

if (_ptr_info1547) {

10376

NDR_PULL_ALLOC(ndr, r->info1547);

10377

} else {

10378

r->info1547 = NULL;

10379

}

10380

break; }

10381

10382

case 1548: {

10383

uint32_t _ptr_info1548;

10384

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1548));

10385

if (_ptr_info1548) {

10386

NDR_PULL_ALLOC(ndr, r->info1548);

10387

} else {

10388

r->info1548 = NULL;

10389

}

10390

break; }

10391

10392

case 1549: {

10393

uint32_t _ptr_info1549;

10394

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1549));

10395

if (_ptr_info1549) {

10396

NDR_PULL_ALLOC(ndr, r->info1549);

10397

} else {

10398

r->info1549 = NULL;

10399

}

10400

break; }

10401

10402

case 1550: {

10403

uint32_t _ptr_info1550;

10404

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1550));

10405

if (_ptr_info1550) {

10406

NDR_PULL_ALLOC(ndr, r->info1550);

10407

} else {

10408

r->info1550 = NULL;

10409

}

10410

break; }

10411

10412

case 1552: {

10413

uint32_t _ptr_info1552;

10414

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1552));

10415

if (_ptr_info1552) {

10416

NDR_PULL_ALLOC(ndr, r->info1552);

10417

} else {

10418

r->info1552 = NULL;

10419

}

10420

break; }

10421

10422

case 1553: {

10423

uint32_t _ptr_info1553;

10424

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1553));

10425

if (_ptr_info1553) {

10426

NDR_PULL_ALLOC(ndr, r->info1553);

10427

} else {

10428

r->info1553 = NULL;

10429

}

10430

break; }

10431

10432

case 1554: {

10433

uint32_t _ptr_info1554;

10434

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1554));

10435

if (_ptr_info1554) {

10436

NDR_PULL_ALLOC(ndr, r->info1554);

10437

} else {

10438

r->info1554 = NULL;

10439

}

10440

break; }

10441

10442

case 1555: {

10443

uint32_t _ptr_info1555;

10444

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1555));

10445

if (_ptr_info1555) {

10446

NDR_PULL_ALLOC(ndr, r->info1555);

10447

} else {

10448

r->info1555 = NULL;

10449

}

10450

break; }

10451

10452

case 1556: {

10453

uint32_t _ptr_info1556;

10454

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1556));

10455

if (_ptr_info1556) {

10456

NDR_PULL_ALLOC(ndr, r->info1556);

10457

} else {

10458

r->info1556 = NULL;

10459

}

10460

break; }

10461

10462

default: {

10463

break; }

10464

10465

}

10466

}

10467

if (ndr_flags & NDR_BUFFERS) {

10468

switch (level) {

10469

case 100:

10470

if (r->info100) {

10471

_mem_save_info100_0 = NDR_PULL_GET_MEM_CTX(ndr);

10472

NDR_PULL_SET_MEM_CTX(ndr, r->info100, 0);

10473

NDR_CHECK(ndr_pull_srvsvc_NetSrvInfo100(ndr, NDR_SCALARS|NDR_BUFFERS, r->info100));

10474

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info100_0, 0);

10475

}

10476

break;

10477

10478

case 101:

10479

if (r->info101) {

10480

_mem_save_info101_0 = NDR_PULL_GET_MEM_CTX(ndr);

10481

NDR_PULL_SET_MEM_CTX(ndr, r->info101, 0);

10482

NDR_CHECK(ndr_pull_srvsvc_NetSrvInfo101(ndr, NDR_SCALARS|NDR_BUFFERS, r->info101));

10483

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info101_0, 0);

10484

}

10485

break;

10486

10487

case 102:

10488

if (r->info102) {

10489

_mem_save_info102_0 = NDR_PULL_GET_MEM_CTX(ndr);

10490

NDR_PULL_SET_MEM_CTX(ndr, r->info102, 0);

10491

NDR_CHECK(ndr_pull_srvsvc_NetSrvInfo102(ndr, NDR_SCALARS|NDR_BUFFERS, r->info102));

10492

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info102_0, 0);

10493

}

10494

break;

10495

10496

case 402:

10497

if (r->info402) {

10498

_mem_save_info402_0 = NDR_PULL_GET_MEM_CTX(ndr);

10499

NDR_PULL_SET_MEM_CTX(ndr, r->info402, 0);

10500

NDR_CHECK(ndr_pull_srvsvc_NetSrvInfo402(ndr, NDR_SCALARS|NDR_BUFFERS, r->info402));

10501

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info402_0, 0);

10502

}

10503

break;

10504

10505

case 403:

10506

if (r->info403) {

10507

_mem_save_info403_0 = NDR_PULL_GET_MEM_CTX(ndr);

10508

NDR_PULL_SET_MEM_CTX(ndr, r->info403, 0);

10509

NDR_CHECK(ndr_pull_srvsvc_NetSrvInfo403(ndr, NDR_SCALARS|NDR_BUFFERS, r->info403));

10510

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info403_0, 0);

10511

}

10512

break;

10513

10514

case 502:

10515

if (r->info502) {

10516

_mem_save_info502_0 = NDR_PULL_GET_MEM_CTX(ndr);

10517

NDR_PULL_SET_MEM_CTX(ndr, r->info502, 0);

10518

NDR_CHECK(ndr_pull_srvsvc_NetSrvInfo502(ndr, NDR_SCALARS, r->info502));

10519

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info502_0, 0);

10520

}

10521

break;

10522

10523

case 503:

10524

if (r->info503) {

10525

_mem_save_info503_0 = NDR_PULL_GET_MEM_CTX(ndr);

10526

NDR_PULL_SET_MEM_CTX(ndr, r->info503, 0);

10527

NDR_CHECK(ndr_pull_srvsvc_NetSrvInfo503(ndr, NDR_SCALARS|NDR_BUFFERS, r->info503));

10528

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info503_0, 0);

10529

}

10530

break;

10531

10532

case 599:

10533

if (r->info599) {

10534

_mem_save_info599_0 = NDR_PULL_GET_MEM_CTX(ndr);

10535

NDR_PULL_SET_MEM_CTX(ndr, r->info599, 0);

10536

NDR_CHECK(ndr_pull_srvsvc_NetSrvInfo599(ndr, NDR_SCALARS|NDR_BUFFERS, r->info599));

10537

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info599_0, 0);

10538

}

10539

break;

10540

10541

case 1005:

10542

if (r->info1005) {

10543

_mem_save_info1005_0 = NDR_PULL_GET_MEM_CTX(ndr);

10544

NDR_PULL_SET_MEM_CTX(ndr, r->info1005, 0);

10545

NDR_CHECK(ndr_pull_srvsvc_NetSrvInfo1005(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1005));

10546

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1005_0, 0);

10547

}

10548

break;

10549

10550

case 1010:

10551

if (r->info1010) {

10552

_mem_save_info1010_0 = NDR_PULL_GET_MEM_CTX(ndr);

10553

NDR_PULL_SET_MEM_CTX(ndr, r->info1010, 0);

10554

NDR_CHECK(ndr_pull_srvsvc_NetSrvInfo1010(ndr, NDR_SCALARS, r->info1010));

10555

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1010_0, 0);

10556

}

10557

break;

10558

10559

case 1016:

10560

if (r->info1016) {

10561

_mem_save_info1016_0 = NDR_PULL_GET_MEM_CTX(ndr);

10562

NDR_PULL_SET_MEM_CTX(ndr, r->info1016, 0);

10563

NDR_CHECK(ndr_pull_srvsvc_NetSrvInfo1016(ndr, NDR_SCALARS, r->info1016));

10564

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1016_0, 0);

10565

}

10566

break;

10567

10568

case 1017:

10569

if (r->info1017) {

10570

_mem_save_info1017_0 = NDR_PULL_GET_MEM_CTX(ndr);

10571

NDR_PULL_SET_MEM_CTX(ndr, r->info1017, 0);

10572

NDR_CHECK(ndr_pull_srvsvc_NetSrvInfo1017(ndr, NDR_SCALARS, r->info1017));

10573

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1017_0, 0);

10574

}

10575

break;

10576

10577

case 1018:

10578

if (r->info1018) {

10579

_mem_save_info1018_0 = NDR_PULL_GET_MEM_CTX(ndr);

10580

NDR_PULL_SET_MEM_CTX(ndr, r->info1018, 0);

10581

NDR_CHECK(ndr_pull_srvsvc_NetSrvInfo1018(ndr, NDR_SCALARS, r->info1018));

10582

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1018_0, 0);

10583

}

10584

break;

10585

10586

case 1107:

10587

if (r->info1107) {

10588

_mem_save_info1107_0 = NDR_PULL_GET_MEM_CTX(ndr);

10589

NDR_PULL_SET_MEM_CTX(ndr, r->info1107, 0);

10590

NDR_CHECK(ndr_pull_srvsvc_NetSrvInfo1107(ndr, NDR_SCALARS, r->info1107));

10591

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1107_0, 0);

10592

}

10593

break;

10594

10595

case 1501:

10596

if (r->info1501) {

10597

_mem_save_info1501_0 = NDR_PULL_GET_MEM_CTX(ndr);

10598

NDR_PULL_SET_MEM_CTX(ndr, r->info1501, 0);

10599

NDR_CHECK(ndr_pull_srvsvc_NetSrvInfo1501(ndr, NDR_SCALARS, r->info1501));

10600

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1501_0, 0);

10601

}

10602

break;

10603

10604

case 1502:

10605

if (r->info1502) {

10606

_mem_save_info1502_0 = NDR_PULL_GET_MEM_CTX(ndr);

10607

NDR_PULL_SET_MEM_CTX(ndr, r->info1502, 0);

10608

NDR_CHECK(ndr_pull_srvsvc_NetSrvInfo1502(ndr, NDR_SCALARS, r->info1502));

10609

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1502_0, 0);

10610

}

10611

break;

10612

10613

case 1503:

10614

if (r->info1503) {

10615

_mem_save_info1503_0 = NDR_PULL_GET_MEM_CTX(ndr);

10616

NDR_PULL_SET_MEM_CTX(ndr, r->info1503, 0);

10617

NDR_CHECK(ndr_pull_srvsvc_NetSrvInfo1503(ndr, NDR_SCALARS, r->info1503));

10618

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1503_0, 0);

10619

}

10620

break;

10621

10622

case 1506:

10623

if (r->info1506) {

10624

_mem_save_info1506_0 = NDR_PULL_GET_MEM_CTX(ndr);

10625

NDR_PULL_SET_MEM_CTX(ndr, r->info1506, 0);

10626

NDR_CHECK(ndr_pull_srvsvc_NetSrvInfo1506(ndr, NDR_SCALARS, r->info1506));

10627

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1506_0, 0);

10628

}

10629

break;

10630

10631

case 1509:

10632

if (r->info1509) {

10633

_mem_save_info1509_0 = NDR_PULL_GET_MEM_CTX(ndr);

10634

NDR_PULL_SET_MEM_CTX(ndr, r->info1509, 0);

10635

NDR_CHECK(ndr_pull_srvsvc_NetSrvInfo1509(ndr, NDR_SCALARS, r->info1509));

10636

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1509_0, 0);

10637

}

10638

break;

10639

10640

case 1510:

10641

if (r->info1510) {

10642

_mem_save_info1510_0 = NDR_PULL_GET_MEM_CTX(ndr);

10643

NDR_PULL_SET_MEM_CTX(ndr, r->info1510, 0);

10644

NDR_CHECK(ndr_pull_srvsvc_NetSrvInfo1510(ndr, NDR_SCALARS, r->info1510));

10645

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1510_0, 0);

10646

}

10647

break;

10648

10649

case 1511:

10650

if (r->info1511) {

10651

_mem_save_info1511_0 = NDR_PULL_GET_MEM_CTX(ndr);

10652

NDR_PULL_SET_MEM_CTX(ndr, r->info1511, 0);

10653

NDR_CHECK(ndr_pull_srvsvc_NetSrvInfo1511(ndr, NDR_SCALARS, r->info1511));

10654

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1511_0, 0);

10655

}

10656

break;

10657

10658

case 1512:

10659

if (r->info1512) {

10660

_mem_save_info1512_0 = NDR_PULL_GET_MEM_CTX(ndr);

10661

NDR_PULL_SET_MEM_CTX(ndr, r->info1512, 0);

10662

NDR_CHECK(ndr_pull_srvsvc_NetSrvInfo1512(ndr, NDR_SCALARS, r->info1512));

10663

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1512_0, 0);

10664

}

10665

break;

10666

10667

case 1513:

10668

if (r->info1513) {

10669

_mem_save_info1513_0 = NDR_PULL_GET_MEM_CTX(ndr);

10670

NDR_PULL_SET_MEM_CTX(ndr, r->info1513, 0);

10671

NDR_CHECK(ndr_pull_srvsvc_NetSrvInfo1513(ndr, NDR_SCALARS, r->info1513));

10672

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1513_0, 0);

10673

}

10674

break;

10675

10676

case 1514:

10677

if (r->info1514) {

10678

_mem_save_info1514_0 = NDR_PULL_GET_MEM_CTX(ndr);

10679

NDR_PULL_SET_MEM_CTX(ndr, r->info1514, 0);

10680

NDR_CHECK(ndr_pull_srvsvc_NetSrvInfo1514(ndr, NDR_SCALARS, r->info1514));

10681

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1514_0, 0);

10682

}

10683

break;

10684

10685

case 1515:

10686

if (r->info1515) {

10687

_mem_save_info1515_0 = NDR_PULL_GET_MEM_CTX(ndr);

10688

NDR_PULL_SET_MEM_CTX(ndr, r->info1515, 0);

10689

NDR_CHECK(ndr_pull_srvsvc_NetSrvInfo1515(ndr, NDR_SCALARS, r->info1515));

10690

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1515_0, 0);

10691

}

10692

break;

10693

10694

case 1516:

10695

if (r->info1516) {

10696

_mem_save_info1516_0 = NDR_PULL_GET_MEM_CTX(ndr);

10697

NDR_PULL_SET_MEM_CTX(ndr, r->info1516, 0);

10698

NDR_CHECK(ndr_pull_srvsvc_NetSrvInfo1516(ndr, NDR_SCALARS, r->info1516));

10699

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1516_0, 0);

10700

}

10701

break;

10702

10703

case 1518:

10704

if (r->info1518) {

10705

_mem_save_info1518_0 = NDR_PULL_GET_MEM_CTX(ndr);

10706

NDR_PULL_SET_MEM_CTX(ndr, r->info1518, 0);

10707

NDR_CHECK(ndr_pull_srvsvc_NetSrvInfo1518(ndr, NDR_SCALARS, r->info1518));

10708

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1518_0, 0);

10709

}

10710

break;

10711

10712

case 1520:

10713

if (r->info1520) {

10714

_mem_save_info1520_0 = NDR_PULL_GET_MEM_CTX(ndr);

10715

NDR_PULL_SET_MEM_CTX(ndr, r->info1520, 0);

10716

NDR_CHECK(ndr_pull_srvsvc_NetSrvInfo1520(ndr, NDR_SCALARS, r->info1520));

10717

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1520_0, 0);

10718

}

10719

break;

10720

10721

case 1521:

10722

if (r->info1521) {

10723

_mem_save_info1521_0 = NDR_PULL_GET_MEM_CTX(ndr);

10724

NDR_PULL_SET_MEM_CTX(ndr, r->info1521, 0);

10725

NDR_CHECK(ndr_pull_srvsvc_NetSrvInfo1521(ndr, NDR_SCALARS, r->info1521));

10726

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1521_0, 0);

10727

}

10728

break;

10729

10730

case 1522:

10731

if (r->info1522) {

10732

_mem_save_info1522_0 = NDR_PULL_GET_MEM_CTX(ndr);

10733

NDR_PULL_SET_MEM_CTX(ndr, r->info1522, 0);

10734

NDR_CHECK(ndr_pull_srvsvc_NetSrvInfo1522(ndr, NDR_SCALARS, r->info1522));

10735

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1522_0, 0);

10736

}

10737

break;

10738

10739

case 1523:

10740

if (r->info1523) {

10741

_mem_save_info1523_0 = NDR_PULL_GET_MEM_CTX(ndr);

10742

NDR_PULL_SET_MEM_CTX(ndr, r->info1523, 0);

10743

NDR_CHECK(ndr_pull_srvsvc_NetSrvInfo1523(ndr, NDR_SCALARS, r->info1523));

10744

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1523_0, 0);

10745

}

10746

break;

10747

10748

case 1524:

10749

if (r->info1524) {

10750

_mem_save_info1524_0 = NDR_PULL_GET_MEM_CTX(ndr);

10751

NDR_PULL_SET_MEM_CTX(ndr, r->info1524, 0);

10752

NDR_CHECK(ndr_pull_srvsvc_NetSrvInfo1524(ndr, NDR_SCALARS, r->info1524));

10753

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1524_0, 0);

10754

}

10755

break;

10756

10757

case 1525:

10758

if (r->info1525) {

10759

_mem_save_info1525_0 = NDR_PULL_GET_MEM_CTX(ndr);

10760

NDR_PULL_SET_MEM_CTX(ndr, r->info1525, 0);

10761

NDR_CHECK(ndr_pull_srvsvc_NetSrvInfo1525(ndr, NDR_SCALARS, r->info1525));

10762

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1525_0, 0);

10763

}

10764

break;

10765

10766

case 1528:

10767

if (r->info1528) {

10768

_mem_save_info1528_0 = NDR_PULL_GET_MEM_CTX(ndr);

10769

NDR_PULL_SET_MEM_CTX(ndr, r->info1528, 0);

10770

NDR_CHECK(ndr_pull_srvsvc_NetSrvInfo1528(ndr, NDR_SCALARS, r->info1528));

10771

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1528_0, 0);

10772

}

10773

break;

10774

10775

case 1529:

10776

if (r->info1529) {

10777

_mem_save_info1529_0 = NDR_PULL_GET_MEM_CTX(ndr);

10778

NDR_PULL_SET_MEM_CTX(ndr, r->info1529, 0);

10779

NDR_CHECK(ndr_pull_srvsvc_NetSrvInfo1529(ndr, NDR_SCALARS, r->info1529));

10780

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1529_0, 0);

10781

}

10782

break;

10783

10784

case 1530:

10785

if (r->info1530) {

10786

_mem_save_info1530_0 = NDR_PULL_GET_MEM_CTX(ndr);

10787

NDR_PULL_SET_MEM_CTX(ndr, r->info1530, 0);

10788

NDR_CHECK(ndr_pull_srvsvc_NetSrvInfo1530(ndr, NDR_SCALARS, r->info1530));

10789

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1530_0, 0);

10790

}

10791

break;

10792

10793

case 1533:

10794

if (r->info1533) {

10795

_mem_save_info1533_0 = NDR_PULL_GET_MEM_CTX(ndr);

10796

NDR_PULL_SET_MEM_CTX(ndr, r->info1533, 0);

10797

NDR_CHECK(ndr_pull_srvsvc_NetSrvInfo1533(ndr, NDR_SCALARS, r->info1533));

10798

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1533_0, 0);

10799

}

10800

break;

10801

10802

case 1534:

10803

if (r->info1534) {

10804

_mem_save_info1534_0 = NDR_PULL_GET_MEM_CTX(ndr);

10805

NDR_PULL_SET_MEM_CTX(ndr, r->info1534, 0);

10806

NDR_CHECK(ndr_pull_srvsvc_NetSrvInfo1534(ndr, NDR_SCALARS, r->info1534));

10807

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1534_0, 0);

10808

}

10809

break;

10810

10811

case 1535:

10812

if (r->info1535) {

10813

_mem_save_info1535_0 = NDR_PULL_GET_MEM_CTX(ndr);

10814

NDR_PULL_SET_MEM_CTX(ndr, r->info1535, 0);

10815

NDR_CHECK(ndr_pull_srvsvc_NetSrvInfo1535(ndr, NDR_SCALARS, r->info1535));

10816

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1535_0, 0);

10817

}

10818

break;

10819

10820

case 1536:

10821

if (r->info1536) {

10822

_mem_save_info1536_0 = NDR_PULL_GET_MEM_CTX(ndr);

10823

NDR_PULL_SET_MEM_CTX(ndr, r->info1536, 0);

10824

NDR_CHECK(ndr_pull_srvsvc_NetSrvInfo1536(ndr, NDR_SCALARS, r->info1536));

10825

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1536_0, 0);

10826

}

10827

break;

10828

10829

case 1537:

10830

if (r->info1537) {

10831

_mem_save_info1537_0 = NDR_PULL_GET_MEM_CTX(ndr);

10832

NDR_PULL_SET_MEM_CTX(ndr, r->info1537, 0);

10833

NDR_CHECK(ndr_pull_srvsvc_NetSrvInfo1537(ndr, NDR_SCALARS, r->info1537));

10834

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1537_0, 0);

10835

}

10836

break;

10837

10838

case 1538:

10839

if (r->info1538) {

10840

_mem_save_info1538_0 = NDR_PULL_GET_MEM_CTX(ndr);

10841

NDR_PULL_SET_MEM_CTX(ndr, r->info1538, 0);

10842

NDR_CHECK(ndr_pull_srvsvc_NetSrvInfo1538(ndr, NDR_SCALARS, r->info1538));

10843

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1538_0, 0);

10844

}

10845

break;

10846

10847

case 1539:

10848

if (r->info1539) {

10849

_mem_save_info1539_0 = NDR_PULL_GET_MEM_CTX(ndr);

10850

NDR_PULL_SET_MEM_CTX(ndr, r->info1539, 0);

10851

NDR_CHECK(ndr_pull_srvsvc_NetSrvInfo1539(ndr, NDR_SCALARS, r->info1539));

10852

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1539_0, 0);

10853

}

10854

break;

10855

10856

case 1540:

10857

if (r->info1540) {

10858

_mem_save_info1540_0 = NDR_PULL_GET_MEM_CTX(ndr);

10859

NDR_PULL_SET_MEM_CTX(ndr, r->info1540, 0);

10860

NDR_CHECK(ndr_pull_srvsvc_NetSrvInfo1540(ndr, NDR_SCALARS, r->info1540));

10861

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1540_0, 0);

10862

}

10863

break;

10864

10865

case 1541:

10866

if (r->info1541) {

10867

_mem_save_info1541_0 = NDR_PULL_GET_MEM_CTX(ndr);

10868

NDR_PULL_SET_MEM_CTX(ndr, r->info1541, 0);

10869

NDR_CHECK(ndr_pull_srvsvc_NetSrvInfo1541(ndr, NDR_SCALARS, r->info1541));

10870

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1541_0, 0);

10871

}

10872

break;

10873

10874

case 1542:

10875

if (r->info1542) {

10876

_mem_save_info1542_0 = NDR_PULL_GET_MEM_CTX(ndr);

10877

NDR_PULL_SET_MEM_CTX(ndr, r->info1542, 0);

10878

NDR_CHECK(ndr_pull_srvsvc_NetSrvInfo1542(ndr, NDR_SCALARS, r->info1542));

10879

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1542_0, 0);

10880

}

10881

break;

10882

10883

case 1543:

10884

if (r->info1543) {

10885

_mem_save_info1543_0 = NDR_PULL_GET_MEM_CTX(ndr);

10886

NDR_PULL_SET_MEM_CTX(ndr, r->info1543, 0);

10887

NDR_CHECK(ndr_pull_srvsvc_NetSrvInfo1543(ndr, NDR_SCALARS, r->info1543));

10888

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1543_0, 0);

10889

}

10890

break;

10891

10892

case 1544:

10893

if (r->info1544) {

10894

_mem_save_info1544_0 = NDR_PULL_GET_MEM_CTX(ndr);

10895

NDR_PULL_SET_MEM_CTX(ndr, r->info1544, 0);

10896

NDR_CHECK(ndr_pull_srvsvc_NetSrvInfo1544(ndr, NDR_SCALARS, r->info1544));

10897

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1544_0, 0);

10898

}

10899

break;

10900

10901

case 1545:

10902

if (r->info1545) {

10903

_mem_save_info1545_0 = NDR_PULL_GET_MEM_CTX(ndr);

10904

NDR_PULL_SET_MEM_CTX(ndr, r->info1545, 0);

10905

NDR_CHECK(ndr_pull_srvsvc_NetSrvInfo1545(ndr, NDR_SCALARS, r->info1545));

10906

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1545_0, 0);

10907

}

10908

break;

10909

10910

case 1546:

10911

if (r->info1546) {

10912

_mem_save_info1546_0 = NDR_PULL_GET_MEM_CTX(ndr);

10913

NDR_PULL_SET_MEM_CTX(ndr, r->info1546, 0);

10914

NDR_CHECK(ndr_pull_srvsvc_NetSrvInfo1546(ndr, NDR_SCALARS, r->info1546));

10915

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1546_0, 0);

10916

}

10917

break;

10918

10919

case 1547:

10920

if (r->info1547) {

10921

_mem_save_info1547_0 = NDR_PULL_GET_MEM_CTX(ndr);

10922

NDR_PULL_SET_MEM_CTX(ndr, r->info1547, 0);

10923

NDR_CHECK(ndr_pull_srvsvc_NetSrvInfo1547(ndr, NDR_SCALARS, r->info1547));

10924

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1547_0, 0);

10925

}

10926

break;

10927

10928

case 1548:

10929

if (r->info1548) {

10930

_mem_save_info1548_0 = NDR_PULL_GET_MEM_CTX(ndr);

10931

NDR_PULL_SET_MEM_CTX(ndr, r->info1548, 0);

10932

NDR_CHECK(ndr_pull_srvsvc_NetSrvInfo1548(ndr, NDR_SCALARS, r->info1548));

10933

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1548_0, 0);

10934

}

10935

break;

10936

10937

case 1549:

10938

if (r->info1549) {

10939

_mem_save_info1549_0 = NDR_PULL_GET_MEM_CTX(ndr);

10940

NDR_PULL_SET_MEM_CTX(ndr, r->info1549, 0);

10941

NDR_CHECK(ndr_pull_srvsvc_NetSrvInfo1549(ndr, NDR_SCALARS, r->info1549));

10942

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1549_0, 0);

10943

}

10944

break;

10945

10946

case 1550:

10947

if (r->info1550) {

10948

_mem_save_info1550_0 = NDR_PULL_GET_MEM_CTX(ndr);

10949

NDR_PULL_SET_MEM_CTX(ndr, r->info1550, 0);

10950

NDR_CHECK(ndr_pull_srvsvc_NetSrvInfo1550(ndr, NDR_SCALARS, r->info1550));

10951

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1550_0, 0);

10952

}

10953

break;

10954

10955

case 1552:

10956

if (r->info1552) {

10957

_mem_save_info1552_0 = NDR_PULL_GET_MEM_CTX(ndr);

10958

NDR_PULL_SET_MEM_CTX(ndr, r->info1552, 0);

10959

NDR_CHECK(ndr_pull_srvsvc_NetSrvInfo1552(ndr, NDR_SCALARS, r->info1552));

10960

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1552_0, 0);

10961

}

10962

break;

10963

10964

case 1553:

10965

if (r->info1553) {

10966

_mem_save_info1553_0 = NDR_PULL_GET_MEM_CTX(ndr);

10967

NDR_PULL_SET_MEM_CTX(ndr, r->info1553, 0);

10968

NDR_CHECK(ndr_pull_srvsvc_NetSrvInfo1553(ndr, NDR_SCALARS, r->info1553));

10969

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1553_0, 0);

10970

}

10971

break;

10972

10973

case 1554:

10974

if (r->info1554) {

10975

_mem_save_info1554_0 = NDR_PULL_GET_MEM_CTX(ndr);

10976

NDR_PULL_SET_MEM_CTX(ndr, r->info1554, 0);

10977

NDR_CHECK(ndr_pull_srvsvc_NetSrvInfo1554(ndr, NDR_SCALARS, r->info1554));

10978

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1554_0, 0);

10979

}

10980

break;

10981

10982

case 1555:

10983

if (r->info1555) {

10984

_mem_save_info1555_0 = NDR_PULL_GET_MEM_CTX(ndr);

10985

NDR_PULL_SET_MEM_CTX(ndr, r->info1555, 0);

10986

NDR_CHECK(ndr_pull_srvsvc_NetSrvInfo1555(ndr, NDR_SCALARS, r->info1555));

10987

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1555_0, 0);

10988

}

10989

break;

10990

10991

case 1556:

10992

if (r->info1556) {

10993

_mem_save_info1556_0 = NDR_PULL_GET_MEM_CTX(ndr);

10994

NDR_PULL_SET_MEM_CTX(ndr, r->info1556, 0);

10995

NDR_CHECK(ndr_pull_srvsvc_NetSrvInfo1556(ndr, NDR_SCALARS, r->info1556));

10996

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1556_0, 0);

10997

}

10998

break;

10999

11000

default:

11001

break;

11002

11003

}

11004

}

11005

return NDR_ERR_SUCCESS;

11006

}

11007

11008

_PUBLIC_ void ndr_print_srvsvc_NetSrvInfo(struct ndr_print *ndr, const char *name, const union srvsvc_NetSrvInfo *r)

11009

{

11010

int level;

11011

level = ndr_print_get_switch_value(ndr, r);

11012

ndr_print_union(ndr, name, level, "srvsvc_NetSrvInfo");

11013

switch (level) {

11014

case 100:

11015

ndr_print_ptr(ndr, "info100", r->info100);

11016

ndr->depth++;

11017

if (r->info100) {

11018

ndr_print_srvsvc_NetSrvInfo100(ndr, "info100", r->info100);

11019

}

11020

ndr->depth--;

11021

break;

11022

11023

case 101:

11024

ndr_print_ptr(ndr, "info101", r->info101);

11025

ndr->depth++;

11026

if (r->info101) {

11027

ndr_print_srvsvc_NetSrvInfo101(ndr, "info101", r->info101);

11028

}

11029

ndr->depth--;

11030

break;

11031

11032

case 102:

11033

ndr_print_ptr(ndr, "info102", r->info102);

11034

ndr->depth++;

11035

if (r->info102) {

11036

ndr_print_srvsvc_NetSrvInfo102(ndr, "info102", r->info102);

11037

}

11038

ndr->depth--;

11039

break;

11040

11041

case 402:

11042

ndr_print_ptr(ndr, "info402", r->info402);

11043

ndr->depth++;

11044

if (r->info402) {

11045

ndr_print_srvsvc_NetSrvInfo402(ndr, "info402", r->info402);

11046

}

11047

ndr->depth--;

11048

break;

11049

11050

case 403:

11051

ndr_print_ptr(ndr, "info403", r->info403);

11052

ndr->depth++;

11053

if (r->info403) {

11054

ndr_print_srvsvc_NetSrvInfo403(ndr, "info403", r->info403);

11055

}

11056

ndr->depth--;

11057

break;

11058

11059

case 502:

11060

ndr_print_ptr(ndr, "info502", r->info502);

11061

ndr->depth++;

11062

if (r->info502) {

11063

ndr_print_srvsvc_NetSrvInfo502(ndr, "info502", r->info502);

11064

}

11065

ndr->depth--;

11066

break;

11067

11068

case 503:

11069

ndr_print_ptr(ndr, "info503", r->info503);

11070

ndr->depth++;

11071

if (r->info503) {

11072

ndr_print_srvsvc_NetSrvInfo503(ndr, "info503", r->info503);

11073

}

11074

ndr->depth--;

11075

break;

11076

11077

case 599:

11078

ndr_print_ptr(ndr, "info599", r->info599);

11079

ndr->depth++;

11080

if (r->info599) {

11081

ndr_print_srvsvc_NetSrvInfo599(ndr, "info599", r->info599);

11082

}

11083

ndr->depth--;

11084

break;

11085

11086

case 1005:

11087

ndr_print_ptr(ndr, "info1005", r->info1005);

11088

ndr->depth++;

11089

if (r->info1005) {

11090

ndr_print_srvsvc_NetSrvInfo1005(ndr, "info1005", r->info1005);

11091

}

11092

ndr->depth--;

11093

break;

11094

11095

case 1010:

11096

ndr_print_ptr(ndr, "info1010", r->info1010);

11097

ndr->depth++;

11098

if (r->info1010) {

11099

ndr_print_srvsvc_NetSrvInfo1010(ndr, "info1010", r->info1010);

11100

}

11101

ndr->depth--;

11102

break;

11103

11104

case 1016:

11105

ndr_print_ptr(ndr, "info1016", r->info1016);

11106

ndr->depth++;

11107

if (r->info1016) {

11108

ndr_print_srvsvc_NetSrvInfo1016(ndr, "info1016", r->info1016);

11109

}

11110

ndr->depth--;

11111

break;

11112

11113

case 1017:

11114

ndr_print_ptr(ndr, "info1017", r->info1017);

11115

ndr->depth++;

11116

if (r->info1017) {

11117

ndr_print_srvsvc_NetSrvInfo1017(ndr, "info1017", r->info1017);

11118

}

11119

ndr->depth--;

11120

break;

11121

11122

case 1018:

11123

ndr_print_ptr(ndr, "info1018", r->info1018);

11124

ndr->depth++;

11125

if (r->info1018) {

11126

ndr_print_srvsvc_NetSrvInfo1018(ndr, "info1018", r->info1018);

11127

}

11128

ndr->depth--;

11129

break;

11130

11131

case 1107:

11132

ndr_print_ptr(ndr, "info1107", r->info1107);

11133

ndr->depth++;

11134

if (r->info1107) {

11135

ndr_print_srvsvc_NetSrvInfo1107(ndr, "info1107", r->info1107);

11136

}

11137

ndr->depth--;

11138

break;

11139

11140

case 1501:

11141

ndr_print_ptr(ndr, "info1501", r->info1501);

11142

ndr->depth++;

11143

if (r->info1501) {

11144

ndr_print_srvsvc_NetSrvInfo1501(ndr, "info1501", r->info1501);

11145

}

11146

ndr->depth--;

11147

break;

11148

11149

case 1502:

11150

ndr_print_ptr(ndr, "info1502", r->info1502);

11151

ndr->depth++;

11152

if (r->info1502) {

11153

ndr_print_srvsvc_NetSrvInfo1502(ndr, "info1502", r->info1502);

11154

}

11155

ndr->depth--;

11156

break;

11157

11158

case 1503:

11159

ndr_print_ptr(ndr, "info1503", r->info1503);

11160

ndr->depth++;

11161

if (r->info1503) {

11162

ndr_print_srvsvc_NetSrvInfo1503(ndr, "info1503", r->info1503);

11163

}

11164

ndr->depth--;

11165

break;

11166

11167

case 1506:

11168

ndr_print_ptr(ndr, "info1506", r->info1506);

11169

ndr->depth++;

11170

if (r->info1506) {

11171

ndr_print_srvsvc_NetSrvInfo1506(ndr, "info1506", r->info1506);

11172

}

11173

ndr->depth--;

11174

break;

11175

11176

case 1509:

11177

ndr_print_ptr(ndr, "info1509", r->info1509);

11178

ndr->depth++;

11179

if (r->info1509) {

11180

ndr_print_srvsvc_NetSrvInfo1509(ndr, "info1509", r->info1509);

11181

}

11182

ndr->depth--;

11183

break;

11184

11185

case 1510:

11186

ndr_print_ptr(ndr, "info1510", r->info1510);

11187

ndr->depth++;

11188

if (r->info1510) {

11189

ndr_print_srvsvc_NetSrvInfo1510(ndr, "info1510", r->info1510);

11190

}

11191

ndr->depth--;

11192

break;

11193

11194

case 1511:

11195

ndr_print_ptr(ndr, "info1511", r->info1511);

11196

ndr->depth++;

11197

if (r->info1511) {

11198

ndr_print_srvsvc_NetSrvInfo1511(ndr, "info1511", r->info1511);

11199

}

11200

ndr->depth--;

11201

break;

11202

11203

case 1512:

11204

ndr_print_ptr(ndr, "info1512", r->info1512);

11205

ndr->depth++;

11206

if (r->info1512) {

11207

ndr_print_srvsvc_NetSrvInfo1512(ndr, "info1512", r->info1512);

11208

}

11209

ndr->depth--;

11210

break;

11211

11212

case 1513:

11213

ndr_print_ptr(ndr, "info1513", r->info1513);

11214

ndr->depth++;

11215

if (r->info1513) {

11216

ndr_print_srvsvc_NetSrvInfo1513(ndr, "info1513", r->info1513);

11217

}

11218

ndr->depth--;

11219

break;

11220

11221

case 1514:

11222

ndr_print_ptr(ndr, "info1514", r->info1514);

11223

ndr->depth++;

11224

if (r->info1514) {

11225

ndr_print_srvsvc_NetSrvInfo1514(ndr, "info1514", r->info1514);

11226

}

11227

ndr->depth--;

11228

break;

11229

11230

case 1515:

11231

ndr_print_ptr(ndr, "info1515", r->info1515);

11232

ndr->depth++;

11233

if (r->info1515) {

11234

ndr_print_srvsvc_NetSrvInfo1515(ndr, "info1515", r->info1515);

11235

}

11236

ndr->depth--;

11237

break;

11238

11239

case 1516:

11240

ndr_print_ptr(ndr, "info1516", r->info1516);

11241

ndr->depth++;

11242

if (r->info1516) {

11243

ndr_print_srvsvc_NetSrvInfo1516(ndr, "info1516", r->info1516);

11244

}

11245

ndr->depth--;

11246

break;

11247

11248

case 1518:

11249

ndr_print_ptr(ndr, "info1518", r->info1518);

11250

ndr->depth++;

11251

if (r->info1518) {

11252

ndr_print_srvsvc_NetSrvInfo1518(ndr, "info1518", r->info1518);

11253

}

11254

ndr->depth--;

11255

break;

11256

11257

case 1520:

11258

ndr_print_ptr(ndr, "info1520", r->info1520);

11259

ndr->depth++;

11260

if (r->info1520) {

11261

ndr_print_srvsvc_NetSrvInfo1520(ndr, "info1520", r->info1520);

11262

}

11263

ndr->depth--;

11264

break;

11265

11266

case 1521:

11267

ndr_print_ptr(ndr, "info1521", r->info1521);

11268

ndr->depth++;

11269

if (r->info1521) {

11270

ndr_print_srvsvc_NetSrvInfo1521(ndr, "info1521", r->info1521);

11271

}

11272

ndr->depth--;

11273

break;

11274

11275

case 1522:

11276

ndr_print_ptr(ndr, "info1522", r->info1522);

11277

ndr->depth++;

11278

if (r->info1522) {

11279

ndr_print_srvsvc_NetSrvInfo1522(ndr, "info1522", r->info1522);

11280

}

11281

ndr->depth--;

11282

break;

11283

11284

case 1523:

11285

ndr_print_ptr(ndr, "info1523", r->info1523);

11286

ndr->depth++;

11287

if (r->info1523) {

11288

ndr_print_srvsvc_NetSrvInfo1523(ndr, "info1523", r->info1523);

11289

}

11290

ndr->depth--;

11291

break;

11292

11293

case 1524:

11294

ndr_print_ptr(ndr, "info1524", r->info1524);

11295

ndr->depth++;

11296

if (r->info1524) {

11297

ndr_print_srvsvc_NetSrvInfo1524(ndr, "info1524", r->info1524);

11298

}

11299

ndr->depth--;

11300

break;

11301

11302

case 1525:

11303

ndr_print_ptr(ndr, "info1525", r->info1525);

11304

ndr->depth++;

11305

if (r->info1525) {

11306

ndr_print_srvsvc_NetSrvInfo1525(ndr, "info1525", r->info1525);

11307

}

11308

ndr->depth--;

11309

break;

11310

11311

case 1528:

11312

ndr_print_ptr(ndr, "info1528", r->info1528);

11313

ndr->depth++;

11314

if (r->info1528) {

11315

ndr_print_srvsvc_NetSrvInfo1528(ndr, "info1528", r->info1528);

11316

}

11317

ndr->depth--;

11318

break;

11319

11320

case 1529:

11321

ndr_print_ptr(ndr, "info1529", r->info1529);

11322

ndr->depth++;

11323

if (r->info1529) {

11324

ndr_print_srvsvc_NetSrvInfo1529(ndr, "info1529", r->info1529);

11325

}

11326

ndr->depth--;

11327

break;

11328

11329

case 1530:

11330

ndr_print_ptr(ndr, "info1530", r->info1530);

11331

ndr->depth++;

11332

if (r->info1530) {

11333

ndr_print_srvsvc_NetSrvInfo1530(ndr, "info1530", r->info1530);

11334

}

11335

ndr->depth--;

11336

break;

11337

11338

case 1533:

11339

ndr_print_ptr(ndr, "info1533", r->info1533);

11340

ndr->depth++;

11341

if (r->info1533) {

11342

ndr_print_srvsvc_NetSrvInfo1533(ndr, "info1533", r->info1533);

11343

}

11344

ndr->depth--;

11345

break;

11346

11347

case 1534:

11348

ndr_print_ptr(ndr, "info1534", r->info1534);

11349

ndr->depth++;

11350

if (r->info1534) {

11351

ndr_print_srvsvc_NetSrvInfo1534(ndr, "info1534", r->info1534);

11352

}

11353

ndr->depth--;

11354

break;

11355

11356

case 1535:

11357

ndr_print_ptr(ndr, "info1535", r->info1535);

11358

ndr->depth++;

11359

if (r->info1535) {

11360

ndr_print_srvsvc_NetSrvInfo1535(ndr, "info1535", r->info1535);

11361

}

11362

ndr->depth--;

11363

break;

11364

11365

case 1536:

11366

ndr_print_ptr(ndr, "info1536", r->info1536);

11367

ndr->depth++;

11368

if (r->info1536) {

11369

ndr_print_srvsvc_NetSrvInfo1536(ndr, "info1536", r->info1536);

11370

}

11371

ndr->depth--;

11372

break;

11373

11374

case 1537:

11375

ndr_print_ptr(ndr, "info1537", r->info1537);

11376

ndr->depth++;

11377

if (r->info1537) {

11378

ndr_print_srvsvc_NetSrvInfo1537(ndr, "info1537", r->info1537);

11379

}

11380

ndr->depth--;

11381

break;

11382

11383

case 1538:

11384

ndr_print_ptr(ndr, "info1538", r->info1538);

11385

ndr->depth++;

11386

if (r->info1538) {

11387

ndr_print_srvsvc_NetSrvInfo1538(ndr, "info1538", r->info1538);

11388

}

11389

ndr->depth--;

11390

break;

11391

11392

case 1539:

11393

ndr_print_ptr(ndr, "info1539", r->info1539);

11394

ndr->depth++;

11395

if (r->info1539) {

11396

ndr_print_srvsvc_NetSrvInfo1539(ndr, "info1539", r->info1539);

11397

}

11398

ndr->depth--;

11399

break;

11400

11401

case 1540:

11402

ndr_print_ptr(ndr, "info1540", r->info1540);

11403

ndr->depth++;

11404

if (r->info1540) {

11405

ndr_print_srvsvc_NetSrvInfo1540(ndr, "info1540", r->info1540);

11406

}

11407

ndr->depth--;

11408

break;

11409

11410

case 1541:

11411

ndr_print_ptr(ndr, "info1541", r->info1541);

11412

ndr->depth++;

11413

if (r->info1541) {

11414

ndr_print_srvsvc_NetSrvInfo1541(ndr, "info1541", r->info1541);

11415

}

11416

ndr->depth--;

11417

break;

11418

11419

case 1542:

11420

ndr_print_ptr(ndr, "info1542", r->info1542);

11421

ndr->depth++;

11422

if (r->info1542) {

11423

ndr_print_srvsvc_NetSrvInfo1542(ndr, "info1542", r->info1542);

11424

}

11425

ndr->depth--;

11426

break;

11427

11428

case 1543:

11429

ndr_print_ptr(ndr, "info1543", r->info1543);

11430

ndr->depth++;

11431

if (r->info1543) {

11432

ndr_print_srvsvc_NetSrvInfo1543(ndr, "info1543", r->info1543);

11433

}

11434

ndr->depth--;

11435

break;

11436

11437

case 1544:

11438

ndr_print_ptr(ndr, "info1544", r->info1544);

11439

ndr->depth++;

11440

if (r->info1544) {

11441

ndr_print_srvsvc_NetSrvInfo1544(ndr, "info1544", r->info1544);

11442

}

11443

ndr->depth--;

11444

break;

11445

11446

case 1545:

11447

ndr_print_ptr(ndr, "info1545", r->info1545);

11448

ndr->depth++;

11449

if (r->info1545) {

11450

ndr_print_srvsvc_NetSrvInfo1545(ndr, "info1545", r->info1545);

11451

}

11452

ndr->depth--;

11453

break;

11454

11455

case 1546:

11456

ndr_print_ptr(ndr, "info1546", r->info1546);

11457

ndr->depth++;

11458

if (r->info1546) {

11459

ndr_print_srvsvc_NetSrvInfo1546(ndr, "info1546", r->info1546);

11460

}

11461

ndr->depth--;

11462

break;

11463

11464

case 1547:

11465

ndr_print_ptr(ndr, "info1547", r->info1547);

11466

ndr->depth++;

11467

if (r->info1547) {

11468

ndr_print_srvsvc_NetSrvInfo1547(ndr, "info1547", r->info1547);

11469

}

11470

ndr->depth--;

11471

break;

11472

11473

case 1548:

11474

ndr_print_ptr(ndr, "info1548", r->info1548);

11475

ndr->depth++;

11476

if (r->info1548) {

11477

ndr_print_srvsvc_NetSrvInfo1548(ndr, "info1548", r->info1548);

11478

}

11479

ndr->depth--;

11480

break;

11481

11482

case 1549:

11483

ndr_print_ptr(ndr, "info1549", r->info1549);

11484

ndr->depth++;

11485

if (r->info1549) {

11486

ndr_print_srvsvc_NetSrvInfo1549(ndr, "info1549", r->info1549);

11487

}

11488

ndr->depth--;

11489

break;

11490

11491

case 1550:

11492

ndr_print_ptr(ndr, "info1550", r->info1550);

11493

ndr->depth++;

11494

if (r->info1550) {

11495

ndr_print_srvsvc_NetSrvInfo1550(ndr, "info1550", r->info1550);

11496

}

11497

ndr->depth--;

11498

break;

11499

11500

case 1552:

11501

ndr_print_ptr(ndr, "info1552", r->info1552);

11502

ndr->depth++;

11503

if (r->info1552) {

11504

ndr_print_srvsvc_NetSrvInfo1552(ndr, "info1552", r->info1552);

11505

}

11506

ndr->depth--;

11507

break;

11508

11509

case 1553:

11510

ndr_print_ptr(ndr, "info1553", r->info1553);

11511

ndr->depth++;

11512

if (r->info1553) {

11513

ndr_print_srvsvc_NetSrvInfo1553(ndr, "info1553", r->info1553);

11514

}

11515

ndr->depth--;

11516

break;

11517

11518

case 1554:

11519

ndr_print_ptr(ndr, "info1554", r->info1554);

11520

ndr->depth++;

11521

if (r->info1554) {

11522

ndr_print_srvsvc_NetSrvInfo1554(ndr, "info1554", r->info1554);

11523

}

11524

ndr->depth--;

11525

break;

11526

11527

case 1555:

11528

ndr_print_ptr(ndr, "info1555", r->info1555);

11529

ndr->depth++;

11530

if (r->info1555) {

11531

ndr_print_srvsvc_NetSrvInfo1555(ndr, "info1555", r->info1555);

11532

}

11533

ndr->depth--;

11534

break;

11535

11536

case 1556:

11537

ndr_print_ptr(ndr, "info1556", r->info1556);

11538

ndr->depth++;

11539

if (r->info1556) {

11540

ndr_print_srvsvc_NetSrvInfo1556(ndr, "info1556", r->info1556);

11541

}

11542

ndr->depth--;

11543

break;

11544

11545

default:

11546

break;

11547

11548

}

11549

}

11550

11551

static enum ndr_err_code ndr_push_srvsvc_NetDiskInfo0(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetDiskInfo0 *r)

11552

{

11553

if (ndr_flags & NDR_SCALARS) {

11554

NDR_CHECK(ndr_push_align(ndr, 4));

11555

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));

11556

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, strlen(r->disk) + 1));

11557

NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->disk, strlen(r->disk) + 1, sizeof(uint16_t), CH_UTF16));

11558

}

11559

if (ndr_flags & NDR_BUFFERS) {

11560

}

11561

return NDR_ERR_SUCCESS;

11562

}

11563

11564

static enum ndr_err_code ndr_pull_srvsvc_NetDiskInfo0(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetDiskInfo0 *r)

11565

{

11566

if (ndr_flags & NDR_SCALARS) {

11567

NDR_CHECK(ndr_pull_align(ndr, 4));

11568

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->__disk_offset));

11569

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->__disk_length));

11570

NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->disk, r->__disk_length, sizeof(uint16_t), CH_UTF16));

11571

}

11572

if (ndr_flags & NDR_BUFFERS) {

11573

}

11574

return NDR_ERR_SUCCESS;

11575

}

11576

11577

_PUBLIC_ void ndr_print_srvsvc_NetDiskInfo0(struct ndr_print *ndr, const char *name, const struct srvsvc_NetDiskInfo0 *r)

11578

{

11579

ndr_print_struct(ndr, name, "srvsvc_NetDiskInfo0");

11580

ndr->depth++;

11581

ndr_print_uint32(ndr, "__disk_offset", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?0:r->__disk_offset);

11582

ndr_print_uint32(ndr, "__disk_length", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?strlen(r->disk) + 1:r->__disk_length);

11583

ndr_print_string(ndr, "disk", r->disk);

11584

ndr->depth--;

11585

}

11586

11587

static enum ndr_err_code ndr_push_srvsvc_NetDiskInfo(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetDiskInfo *r)

11588

{

11589

uint32_t cntr_disks_1;

11590

if (ndr_flags & NDR_SCALARS) {

11591

NDR_CHECK(ndr_push_align(ndr, 4));

11592

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));

11593

NDR_CHECK(ndr_push_unique_ptr(ndr, r->disks));

11594

}

11595

if (ndr_flags & NDR_BUFFERS) {

11596

if (r->disks) {

11597

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));

11598

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));

11599

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));

11600

for (cntr_disks_1 = 0; cntr_disks_1 < r->count; cntr_disks_1++) {

11601

NDR_CHECK(ndr_push_srvsvc_NetDiskInfo0(ndr, NDR_SCALARS, &r->disks[cntr_disks_1]));

11602

}

11603

}

11604

}

11605

return NDR_ERR_SUCCESS;

11606

}

11607

11608

static enum ndr_err_code ndr_pull_srvsvc_NetDiskInfo(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetDiskInfo *r)

11609

{

11610

uint32_t _ptr_disks;

11611

uint32_t cntr_disks_1;

11612

TALLOC_CTX *_mem_save_disks_0;

11613

TALLOC_CTX *_mem_save_disks_1;

11614

if (ndr_flags & NDR_SCALARS) {

11615

NDR_CHECK(ndr_pull_align(ndr, 4));

11616

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));

11617

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_disks));

11618

if (_ptr_disks) {

11619

NDR_PULL_ALLOC(ndr, r->disks);

11620

} else {

11621

r->disks = NULL;

11622

}

11623

}

11624

if (ndr_flags & NDR_BUFFERS) {

11625

if (r->disks) {

11626

_mem_save_disks_0 = NDR_PULL_GET_MEM_CTX(ndr);

11627

NDR_PULL_SET_MEM_CTX(ndr, r->disks, 0);

11628

NDR_CHECK(ndr_pull_array_size(ndr, &r->disks));

11629

NDR_CHECK(ndr_pull_array_length(ndr, &r->disks));

11630

if (ndr_get_array_length(ndr, &r->disks) > ndr_get_array_size(ndr, &r->disks)) {

11631

return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->disks), ndr_get_array_length(ndr, &r->disks));

11632

}

11633

NDR_PULL_ALLOC_N(ndr, r->disks, ndr_get_array_size(ndr, &r->disks));

11634

_mem_save_disks_1 = NDR_PULL_GET_MEM_CTX(ndr);

11635

NDR_PULL_SET_MEM_CTX(ndr, r->disks, 0);

11636

for (cntr_disks_1 = 0; cntr_disks_1 < r->count; cntr_disks_1++) {

11637

NDR_CHECK(ndr_pull_srvsvc_NetDiskInfo0(ndr, NDR_SCALARS, &r->disks[cntr_disks_1]));

11638

}

11639

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_disks_1, 0);

11640

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_disks_0, 0);

11641

}

11642

if (r->disks) {

11643

NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->disks, r->count));

11644

}

11645

if (r->disks) {

11646

NDR_CHECK(ndr_check_array_length(ndr, (void*)&r->disks, r->count));

11647

}

11648

}

11649

return NDR_ERR_SUCCESS;

11650

}

11651

11652

_PUBLIC_ void ndr_print_srvsvc_NetDiskInfo(struct ndr_print *ndr, const char *name, const struct srvsvc_NetDiskInfo *r)

11653

{

11654

uint32_t cntr_disks_1;

11655

ndr_print_struct(ndr, name, "srvsvc_NetDiskInfo");

11656

ndr->depth++;

11657

ndr_print_uint32(ndr, "count", r->count);

11658

ndr_print_ptr(ndr, "disks", r->disks);

11659

ndr->depth++;

11660

if (r->disks) {

11661

ndr->print(ndr, "%s: ARRAY(%d)", "disks", (int)r->count);

11662

ndr->depth++;

11663

for (cntr_disks_1=0;cntr_disks_1<r->count;cntr_disks_1++) {

11664

char *idx_1=NULL;

11665

if (asprintf(&idx_1, "[%d]", cntr_disks_1) != -1) {

11666

ndr_print_srvsvc_NetDiskInfo0(ndr, "disks", &r->disks[cntr_disks_1]);

11667

free(idx_1);

11668

}

11669

}

11670

ndr->depth--;

11671

}

11672

ndr->depth--;

11673

ndr->depth--;

11674

}

11675

11676

static enum ndr_err_code ndr_push_srvsvc_Statistics(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_Statistics *r)

11677

{

11678

if (ndr_flags & NDR_SCALARS) {

11679

NDR_CHECK(ndr_push_align(ndr, 4));

11680

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->start));

11681

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->fopens));

11682

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->devopens));

11683

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->jobsqueued));

11684

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->sopens));

11685

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->stimeouts));

11686

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->serrorout));

11687

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->pwerrors));

11688

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->permerrors));

11689

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->syserrors));

11690

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->bytessent_low));

11691

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->bytessent_high));

11692

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->bytesrcvd_low));

11693

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->bytesrcvd_high));

11694

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->avresponse));

11695

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reqbufneed));

11696

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->bigbufneed));

11697

}

11698

if (ndr_flags & NDR_BUFFERS) {

11699

}

11700

return NDR_ERR_SUCCESS;

11701

}

11702

11703

static enum ndr_err_code ndr_pull_srvsvc_Statistics(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_Statistics *r)

11704

{

11705

if (ndr_flags & NDR_SCALARS) {

11706

NDR_CHECK(ndr_pull_align(ndr, 4));

11707

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->start));

11708

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->fopens));

11709

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->devopens));

11710

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->jobsqueued));

11711

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->sopens));

11712

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->stimeouts));

11713

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->serrorout));

11714

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->pwerrors));

11715

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->permerrors));

11716

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->syserrors));

11717

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->bytessent_low));

11718

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->bytessent_high));

11719

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->bytesrcvd_low));

11720

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->bytesrcvd_high));

11721

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->avresponse));

11722

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reqbufneed));

11723

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->bigbufneed));

11724

}

11725

if (ndr_flags & NDR_BUFFERS) {

11726

}

11727

return NDR_ERR_SUCCESS;

11728

}

11729

11730

_PUBLIC_ void ndr_print_srvsvc_Statistics(struct ndr_print *ndr, const char *name, const struct srvsvc_Statistics *r)

11731

{

11732

ndr_print_struct(ndr, name, "srvsvc_Statistics");

11733

ndr->depth++;

11734

ndr_print_uint32(ndr, "start", r->start);

11735

ndr_print_uint32(ndr, "fopens", r->fopens);

11736

ndr_print_uint32(ndr, "devopens", r->devopens);

11737

ndr_print_uint32(ndr, "jobsqueued", r->jobsqueued);

11738

ndr_print_uint32(ndr, "sopens", r->sopens);

11739

ndr_print_uint32(ndr, "stimeouts", r->stimeouts);

11740

ndr_print_uint32(ndr, "serrorout", r->serrorout);

11741

ndr_print_uint32(ndr, "pwerrors", r->pwerrors);

11742

ndr_print_uint32(ndr, "permerrors", r->permerrors);

11743

ndr_print_uint32(ndr, "syserrors", r->syserrors);

11744

ndr_print_uint32(ndr, "bytessent_low", r->bytessent_low);

11745

ndr_print_uint32(ndr, "bytessent_high", r->bytessent_high);

11746

ndr_print_uint32(ndr, "bytesrcvd_low", r->bytesrcvd_low);

11747

ndr_print_uint32(ndr, "bytesrcvd_high", r->bytesrcvd_high);

11748

ndr_print_uint32(ndr, "avresponse", r->avresponse);

11749

ndr_print_uint32(ndr, "reqbufneed", r->reqbufneed);

11750

ndr_print_uint32(ndr, "bigbufneed", r->bigbufneed);

11751

ndr->depth--;

11752

}

11753

11754

static enum ndr_err_code ndr_push_srvsvc_NetTransportInfo0(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetTransportInfo0 *r)

11755

{

11756

if (ndr_flags & NDR_SCALARS) {

11757

NDR_CHECK(ndr_push_align(ndr, 4));

11758

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->vcs));

11759

NDR_CHECK(ndr_push_unique_ptr(ndr, r->name));

11760

NDR_CHECK(ndr_push_unique_ptr(ndr, r->addr));

11761

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->addr_len));

11762

NDR_CHECK(ndr_push_unique_ptr(ndr, r->net_addr));

11763

}

11764

if (ndr_flags & NDR_BUFFERS) {

11765

if (r->name) {

11766

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->name, CH_UTF16)));

11767

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));

11768

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->name, CH_UTF16)));

11769

NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->name, ndr_charset_length(r->name, CH_UTF16), sizeof(uint16_t), CH_UTF16));

11770

}

11771

if (r->addr) {

11772

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->addr_len));

11773

NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->addr, r->addr_len));

11774

}

11775

if (r->net_addr) {

11776

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->net_addr, CH_UTF16)));

11777

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));

11778

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->net_addr, CH_UTF16)));

11779

NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->net_addr, ndr_charset_length(r->net_addr, CH_UTF16), sizeof(uint16_t), CH_UTF16));

11780

}

11781

}

11782

return NDR_ERR_SUCCESS;

11783

}

11784

11785

static enum ndr_err_code ndr_pull_srvsvc_NetTransportInfo0(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetTransportInfo0 *r)

11786

{

11787

uint32_t _ptr_name;

11788

TALLOC_CTX *_mem_save_name_0;

11789

uint32_t _ptr_addr;

11790

TALLOC_CTX *_mem_save_addr_0;

11791

uint32_t _ptr_net_addr;

11792

TALLOC_CTX *_mem_save_net_addr_0;

11793

if (ndr_flags & NDR_SCALARS) {

11794

NDR_CHECK(ndr_pull_align(ndr, 4));

11795

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->vcs));

11796

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_name));

11797

if (_ptr_name) {

11798

NDR_PULL_ALLOC(ndr, r->name);

11799

} else {

11800

r->name = NULL;

11801

}

11802

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_addr));

11803

if (_ptr_addr) {

11804

NDR_PULL_ALLOC(ndr, r->addr);

11805

} else {

11806

r->addr = NULL;

11807

}

11808

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->addr_len));

11809

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_net_addr));

11810

if (_ptr_net_addr) {

11811

NDR_PULL_ALLOC(ndr, r->net_addr);

11812

} else {

11813

r->net_addr = NULL;

11814

}

11815

}

11816

if (ndr_flags & NDR_BUFFERS) {

11817

if (r->name) {

11818

_mem_save_name_0 = NDR_PULL_GET_MEM_CTX(ndr);

11819

NDR_PULL_SET_MEM_CTX(ndr, r->name, 0);

11820

NDR_CHECK(ndr_pull_array_size(ndr, &r->name));

11821

NDR_CHECK(ndr_pull_array_length(ndr, &r->name));

11822

if (ndr_get_array_length(ndr, &r->name) > ndr_get_array_size(ndr, &r->name)) {

11823

return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->name), ndr_get_array_length(ndr, &r->name));

11824

}

11825

NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->name), sizeof(uint16_t)));

11826

NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->name, ndr_get_array_length(ndr, &r->name), sizeof(uint16_t), CH_UTF16));

11827

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_name_0, 0);

11828

}

11829

if (r->addr) {

11830

_mem_save_addr_0 = NDR_PULL_GET_MEM_CTX(ndr);

11831

NDR_PULL_SET_MEM_CTX(ndr, r->addr, 0);

11832

NDR_CHECK(ndr_pull_array_size(ndr, &r->addr));

11833

NDR_PULL_ALLOC_N(ndr, r->addr, ndr_get_array_size(ndr, &r->addr));

11834

NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->addr, ndr_get_array_size(ndr, &r->addr)));

11835

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_addr_0, 0);

11836

}

11837

if (r->net_addr) {

11838

_mem_save_net_addr_0 = NDR_PULL_GET_MEM_CTX(ndr);

11839

NDR_PULL_SET_MEM_CTX(ndr, r->net_addr, 0);

11840

NDR_CHECK(ndr_pull_array_size(ndr, &r->net_addr));

11841

NDR_CHECK(ndr_pull_array_length(ndr, &r->net_addr));

11842

if (ndr_get_array_length(ndr, &r->net_addr) > ndr_get_array_size(ndr, &r->net_addr)) {

11843

return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->net_addr), ndr_get_array_length(ndr, &r->net_addr));

11844

}

11845

NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->net_addr), sizeof(uint16_t)));

11846

NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->net_addr, ndr_get_array_length(ndr, &r->net_addr), sizeof(uint16_t), CH_UTF16));

11847

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_net_addr_0, 0);

11848

}

11849

if (r->addr) {

11850

NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->addr, r->addr_len));

11851

}

11852

}

11853

return NDR_ERR_SUCCESS;

11854

}

11855

11856

_PUBLIC_ void ndr_print_srvsvc_NetTransportInfo0(struct ndr_print *ndr, const char *name, const struct srvsvc_NetTransportInfo0 *r)

11857

{

11858

ndr_print_struct(ndr, name, "srvsvc_NetTransportInfo0");

11859

ndr->depth++;

11860

ndr_print_uint32(ndr, "vcs", r->vcs);

11861

ndr_print_ptr(ndr, "name", r->name);

11862

ndr->depth++;

11863

if (r->name) {

11864

ndr_print_string(ndr, "name", r->name);

11865

}

11866

ndr->depth--;

11867

ndr_print_ptr(ndr, "addr", r->addr);

11868

ndr->depth++;

11869

if (r->addr) {

11870

ndr_print_array_uint8(ndr, "addr", r->addr, r->addr_len);

11871

}

11872

ndr->depth--;

11873

ndr_print_uint32(ndr, "addr_len", r->addr_len);

11874

ndr_print_ptr(ndr, "net_addr", r->net_addr);

11875

ndr->depth++;

11876

if (r->net_addr) {

11877

ndr_print_string(ndr, "net_addr", r->net_addr);

11878

}

11879

ndr->depth--;

11880

ndr->depth--;

11881

}

11882

11883

static enum ndr_err_code ndr_push_srvsvc_NetTransportCtr0(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetTransportCtr0 *r)

11884

{

11885

uint32_t cntr_array_1;

11886

if (ndr_flags & NDR_SCALARS) {

11887

NDR_CHECK(ndr_push_align(ndr, 4));

11888

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));

11889

NDR_CHECK(ndr_push_unique_ptr(ndr, r->array));

11890

}

11891

if (ndr_flags & NDR_BUFFERS) {

11892

if (r->array) {

11893

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));

11894

for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {

11895

NDR_CHECK(ndr_push_srvsvc_NetTransportInfo0(ndr, NDR_SCALARS, &r->array[cntr_array_1]));

11896

}

11897

for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {

11898

NDR_CHECK(ndr_push_srvsvc_NetTransportInfo0(ndr, NDR_BUFFERS, &r->array[cntr_array_1]));

11899

}

11900

}

11901

}

11902

return NDR_ERR_SUCCESS;

11903

}

11904

11905

static enum ndr_err_code ndr_pull_srvsvc_NetTransportCtr0(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetTransportCtr0 *r)

11906

{

11907

uint32_t _ptr_array;

11908

uint32_t cntr_array_1;

11909

TALLOC_CTX *_mem_save_array_0;

11910

TALLOC_CTX *_mem_save_array_1;

11911

if (ndr_flags & NDR_SCALARS) {

11912

NDR_CHECK(ndr_pull_align(ndr, 4));

11913

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));

11914

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_array));

11915

if (_ptr_array) {

11916

NDR_PULL_ALLOC(ndr, r->array);

11917

} else {

11918

r->array = NULL;

11919

}

11920

}

11921

if (ndr_flags & NDR_BUFFERS) {

11922

if (r->array) {

11923

_mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);

11924

NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);

11925

NDR_CHECK(ndr_pull_array_size(ndr, &r->array));

11926

NDR_PULL_ALLOC_N(ndr, r->array, ndr_get_array_size(ndr, &r->array));

11927

_mem_save_array_1 = NDR_PULL_GET_MEM_CTX(ndr);

11928

NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);

11929

for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {

11930

NDR_CHECK(ndr_pull_srvsvc_NetTransportInfo0(ndr, NDR_SCALARS, &r->array[cntr_array_1]));

11931

}

11932

for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {

11933

NDR_CHECK(ndr_pull_srvsvc_NetTransportInfo0(ndr, NDR_BUFFERS, &r->array[cntr_array_1]));

11934

}

11935

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_1, 0);

11936

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);

11937

}

11938

if (r->array) {

11939

NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->array, r->count));

11940

}

11941

}

11942

return NDR_ERR_SUCCESS;

11943

}

11944

11945

_PUBLIC_ void ndr_print_srvsvc_NetTransportCtr0(struct ndr_print *ndr, const char *name, const struct srvsvc_NetTransportCtr0 *r)

11946

{

11947

uint32_t cntr_array_1;

11948

ndr_print_struct(ndr, name, "srvsvc_NetTransportCtr0");

11949

ndr->depth++;

11950

ndr_print_uint32(ndr, "count", r->count);

11951

ndr_print_ptr(ndr, "array", r->array);

11952

ndr->depth++;

11953

if (r->array) {

11954

ndr->print(ndr, "%s: ARRAY(%d)", "array", (int)r->count);

11955

ndr->depth++;

11956

for (cntr_array_1=0;cntr_array_1<r->count;cntr_array_1++) {

11957

char *idx_1=NULL;

11958

if (asprintf(&idx_1, "[%d]", cntr_array_1) != -1) {

11959

ndr_print_srvsvc_NetTransportInfo0(ndr, "array", &r->array[cntr_array_1]);

11960

free(idx_1);

11961

}

11962

}

11963

ndr->depth--;

11964

}

11965

ndr->depth--;

11966

ndr->depth--;

11967

}

11968

11969

static enum ndr_err_code ndr_push_srvsvc_NetTransportInfo1(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetTransportInfo1 *r)

11970

{

11971

if (ndr_flags & NDR_SCALARS) {

11972

NDR_CHECK(ndr_push_align(ndr, 4));

11973

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->vcs));

11974

NDR_CHECK(ndr_push_unique_ptr(ndr, r->name));

11975

NDR_CHECK(ndr_push_unique_ptr(ndr, r->addr));

11976

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->addr_len));

11977

NDR_CHECK(ndr_push_unique_ptr(ndr, r->net_addr));

11978

NDR_CHECK(ndr_push_unique_ptr(ndr, r->domain));

11979

}

11980

if (ndr_flags & NDR_BUFFERS) {

11981

if (r->name) {

11982

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->name, CH_UTF16)));

11983

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));

11984

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->name, CH_UTF16)));

11985

NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->name, ndr_charset_length(r->name, CH_UTF16), sizeof(uint16_t), CH_UTF16));

11986

}

11987

if (r->addr) {

11988

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->addr_len));

11989

NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->addr, r->addr_len));

11990

}

11991

if (r->net_addr) {

11992

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->net_addr, CH_UTF16)));

11993

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));

11994

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->net_addr, CH_UTF16)));

11995

NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->net_addr, ndr_charset_length(r->net_addr, CH_UTF16), sizeof(uint16_t), CH_UTF16));

11996

}

11997

if (r->domain) {

11998

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->domain, CH_UTF16)));

11999

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));

12000

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->domain, CH_UTF16)));

12001

NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->domain, ndr_charset_length(r->domain, CH_UTF16), sizeof(uint16_t), CH_UTF16));

12002

}

12003

}

12004

return NDR_ERR_SUCCESS;

12005

}

12006

12007

static enum ndr_err_code ndr_pull_srvsvc_NetTransportInfo1(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetTransportInfo1 *r)

12008

{

12009

uint32_t _ptr_name;

12010

TALLOC_CTX *_mem_save_name_0;

12011

uint32_t _ptr_addr;

12012

TALLOC_CTX *_mem_save_addr_0;

12013

uint32_t _ptr_net_addr;

12014

TALLOC_CTX *_mem_save_net_addr_0;

12015

uint32_t _ptr_domain;

12016

TALLOC_CTX *_mem_save_domain_0;

12017

if (ndr_flags & NDR_SCALARS) {

12018

NDR_CHECK(ndr_pull_align(ndr, 4));

12019

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->vcs));

12020

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_name));

12021

if (_ptr_name) {

12022

NDR_PULL_ALLOC(ndr, r->name);

12023

} else {

12024

r->name = NULL;

12025

}

12026

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_addr));

12027

if (_ptr_addr) {

12028

NDR_PULL_ALLOC(ndr, r->addr);

12029

} else {

12030

r->addr = NULL;

12031

}

12032

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->addr_len));

12033

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_net_addr));

12034

if (_ptr_net_addr) {

12035

NDR_PULL_ALLOC(ndr, r->net_addr);

12036

} else {

12037

r->net_addr = NULL;

12038

}

12039

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_domain));

12040

if (_ptr_domain) {

12041

NDR_PULL_ALLOC(ndr, r->domain);

12042

} else {

12043

r->domain = NULL;

12044

}

12045

}

12046

if (ndr_flags & NDR_BUFFERS) {

12047

if (r->name) {

12048

_mem_save_name_0 = NDR_PULL_GET_MEM_CTX(ndr);

12049

NDR_PULL_SET_MEM_CTX(ndr, r->name, 0);

12050

NDR_CHECK(ndr_pull_array_size(ndr, &r->name));

12051

NDR_CHECK(ndr_pull_array_length(ndr, &r->name));

12052

if (ndr_get_array_length(ndr, &r->name) > ndr_get_array_size(ndr, &r->name)) {

12053

return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->name), ndr_get_array_length(ndr, &r->name));

12054

}

12055

NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->name), sizeof(uint16_t)));

12056

NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->name, ndr_get_array_length(ndr, &r->name), sizeof(uint16_t), CH_UTF16));

12057

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_name_0, 0);

12058

}

12059

if (r->addr) {

12060

_mem_save_addr_0 = NDR_PULL_GET_MEM_CTX(ndr);

12061

NDR_PULL_SET_MEM_CTX(ndr, r->addr, 0);

12062

NDR_CHECK(ndr_pull_array_size(ndr, &r->addr));

12063

NDR_PULL_ALLOC_N(ndr, r->addr, ndr_get_array_size(ndr, &r->addr));

12064

NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->addr, ndr_get_array_size(ndr, &r->addr)));

12065

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_addr_0, 0);

12066

}

12067

if (r->net_addr) {

12068

_mem_save_net_addr_0 = NDR_PULL_GET_MEM_CTX(ndr);

12069

NDR_PULL_SET_MEM_CTX(ndr, r->net_addr, 0);

12070

NDR_CHECK(ndr_pull_array_size(ndr, &r->net_addr));

12071

NDR_CHECK(ndr_pull_array_length(ndr, &r->net_addr));

12072

if (ndr_get_array_length(ndr, &r->net_addr) > ndr_get_array_size(ndr, &r->net_addr)) {

12073

return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->net_addr), ndr_get_array_length(ndr, &r->net_addr));

12074

}

12075

NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->net_addr), sizeof(uint16_t)));

12076

NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->net_addr, ndr_get_array_length(ndr, &r->net_addr), sizeof(uint16_t), CH_UTF16));

12077

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_net_addr_0, 0);

12078

}

12079

if (r->domain) {

12080

_mem_save_domain_0 = NDR_PULL_GET_MEM_CTX(ndr);

12081

NDR_PULL_SET_MEM_CTX(ndr, r->domain, 0);

12082

NDR_CHECK(ndr_pull_array_size(ndr, &r->domain));

12083

NDR_CHECK(ndr_pull_array_length(ndr, &r->domain));

12084

if (ndr_get_array_length(ndr, &r->domain) > ndr_get_array_size(ndr, &r->domain)) {

12085

return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->domain), ndr_get_array_length(ndr, &r->domain));

12086

}

12087

NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->domain), sizeof(uint16_t)));

12088

NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->domain, ndr_get_array_length(ndr, &r->domain), sizeof(uint16_t), CH_UTF16));

12089

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domain_0, 0);

12090

}

12091

if (r->addr) {

12092

NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->addr, r->addr_len));

12093

}

12094

}

12095

return NDR_ERR_SUCCESS;

12096

}

12097

12098

_PUBLIC_ void ndr_print_srvsvc_NetTransportInfo1(struct ndr_print *ndr, const char *name, const struct srvsvc_NetTransportInfo1 *r)

12099

{

12100

ndr_print_struct(ndr, name, "srvsvc_NetTransportInfo1");

12101

ndr->depth++;

12102

ndr_print_uint32(ndr, "vcs", r->vcs);

12103

ndr_print_ptr(ndr, "name", r->name);

12104

ndr->depth++;

12105

if (r->name) {

12106

ndr_print_string(ndr, "name", r->name);

12107

}

12108

ndr->depth--;

12109

ndr_print_ptr(ndr, "addr", r->addr);

12110

ndr->depth++;

12111

if (r->addr) {

12112

ndr_print_array_uint8(ndr, "addr", r->addr, r->addr_len);

12113

}

12114

ndr->depth--;

12115

ndr_print_uint32(ndr, "addr_len", r->addr_len);

12116

ndr_print_ptr(ndr, "net_addr", r->net_addr);

12117

ndr->depth++;

12118

if (r->net_addr) {

12119

ndr_print_string(ndr, "net_addr", r->net_addr);

12120

}

12121

ndr->depth--;

12122

ndr_print_ptr(ndr, "domain", r->domain);

12123

ndr->depth++;

12124

if (r->domain) {

12125

ndr_print_string(ndr, "domain", r->domain);

12126

}

12127

ndr->depth--;

12128

ndr->depth--;

12129

}

12130

12131

static enum ndr_err_code ndr_push_srvsvc_NetTransportCtr1(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetTransportCtr1 *r)

12132

{

12133

uint32_t cntr_array_1;

12134

if (ndr_flags & NDR_SCALARS) {

12135

NDR_CHECK(ndr_push_align(ndr, 4));

12136

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));

12137

NDR_CHECK(ndr_push_unique_ptr(ndr, r->array));

12138

}

12139

if (ndr_flags & NDR_BUFFERS) {

12140

if (r->array) {

12141

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));

12142

for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {

12143

NDR_CHECK(ndr_push_srvsvc_NetTransportInfo1(ndr, NDR_SCALARS, &r->array[cntr_array_1]));

12144

}

12145

for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {

12146

NDR_CHECK(ndr_push_srvsvc_NetTransportInfo1(ndr, NDR_BUFFERS, &r->array[cntr_array_1]));

12147

}

12148

}

12149

}

12150

return NDR_ERR_SUCCESS;

12151

}

12152

12153

static enum ndr_err_code ndr_pull_srvsvc_NetTransportCtr1(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetTransportCtr1 *r)

12154

{

12155

uint32_t _ptr_array;

12156

uint32_t cntr_array_1;

12157

TALLOC_CTX *_mem_save_array_0;

12158

TALLOC_CTX *_mem_save_array_1;

12159

if (ndr_flags & NDR_SCALARS) {

12160

NDR_CHECK(ndr_pull_align(ndr, 4));

12161

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));

12162

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_array));

12163

if (_ptr_array) {

12164

NDR_PULL_ALLOC(ndr, r->array);

12165

} else {

12166

r->array = NULL;

12167

}

12168

}

12169

if (ndr_flags & NDR_BUFFERS) {

12170

if (r->array) {

12171

_mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);

12172

NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);

12173

NDR_CHECK(ndr_pull_array_size(ndr, &r->array));

12174

NDR_PULL_ALLOC_N(ndr, r->array, ndr_get_array_size(ndr, &r->array));

12175

_mem_save_array_1 = NDR_PULL_GET_MEM_CTX(ndr);

12176

NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);

12177

for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {

12178

NDR_CHECK(ndr_pull_srvsvc_NetTransportInfo1(ndr, NDR_SCALARS, &r->array[cntr_array_1]));

12179

}

12180

for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {

12181

NDR_CHECK(ndr_pull_srvsvc_NetTransportInfo1(ndr, NDR_BUFFERS, &r->array[cntr_array_1]));

12182

}

12183

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_1, 0);

12184

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);

12185

}

12186

if (r->array) {

12187

NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->array, r->count));

12188

}

12189

}

12190

return NDR_ERR_SUCCESS;

12191

}

12192

12193

_PUBLIC_ void ndr_print_srvsvc_NetTransportCtr1(struct ndr_print *ndr, const char *name, const struct srvsvc_NetTransportCtr1 *r)

12194

{

12195

uint32_t cntr_array_1;

12196

ndr_print_struct(ndr, name, "srvsvc_NetTransportCtr1");

12197

ndr->depth++;

12198

ndr_print_uint32(ndr, "count", r->count);

12199

ndr_print_ptr(ndr, "array", r->array);

12200

ndr->depth++;

12201

if (r->array) {

12202

ndr->print(ndr, "%s: ARRAY(%d)", "array", (int)r->count);

12203

ndr->depth++;

12204

for (cntr_array_1=0;cntr_array_1<r->count;cntr_array_1++) {

12205

char *idx_1=NULL;

12206

if (asprintf(&idx_1, "[%d]", cntr_array_1) != -1) {

12207

ndr_print_srvsvc_NetTransportInfo1(ndr, "array", &r->array[cntr_array_1]);

12208

free(idx_1);

12209

}

12210

}

12211

ndr->depth--;

12212

}

12213

ndr->depth--;

12214

ndr->depth--;

12215

}

12216

12217

static enum ndr_err_code ndr_push_srvsvc_NetTransportInfo2(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetTransportInfo2 *r)

12218

{

12219

if (ndr_flags & NDR_SCALARS) {

12220

NDR_CHECK(ndr_push_align(ndr, 4));

12221

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->vcs));

12222

NDR_CHECK(ndr_push_unique_ptr(ndr, r->name));

12223

NDR_CHECK(ndr_push_unique_ptr(ndr, r->addr));

12224

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->addr_len));

12225

NDR_CHECK(ndr_push_unique_ptr(ndr, r->net_addr));

12226

NDR_CHECK(ndr_push_unique_ptr(ndr, r->domain));

12227

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown));

12228

}

12229

if (ndr_flags & NDR_BUFFERS) {

12230

if (r->name) {

12231

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->name, CH_UTF16)));

12232

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));

12233

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->name, CH_UTF16)));

12234

NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->name, ndr_charset_length(r->name, CH_UTF16), sizeof(uint16_t), CH_UTF16));

12235

}

12236

if (r->addr) {

12237

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->addr_len));

12238

NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->addr, r->addr_len));

12239

}

12240

if (r->net_addr) {

12241

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->net_addr, CH_UTF16)));

12242

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));

12243

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->net_addr, CH_UTF16)));

12244

NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->net_addr, ndr_charset_length(r->net_addr, CH_UTF16), sizeof(uint16_t), CH_UTF16));

12245

}

12246

if (r->domain) {

12247

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->domain, CH_UTF16)));

12248

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));

12249

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->domain, CH_UTF16)));

12250

NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->domain, ndr_charset_length(r->domain, CH_UTF16), sizeof(uint16_t), CH_UTF16));

12251

}

12252

}

12253

return NDR_ERR_SUCCESS;

12254

}

12255

12256

static enum ndr_err_code ndr_pull_srvsvc_NetTransportInfo2(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetTransportInfo2 *r)

12257

{

12258

uint32_t _ptr_name;

12259

TALLOC_CTX *_mem_save_name_0;

12260

uint32_t _ptr_addr;

12261

TALLOC_CTX *_mem_save_addr_0;

12262

uint32_t _ptr_net_addr;

12263

TALLOC_CTX *_mem_save_net_addr_0;

12264

uint32_t _ptr_domain;

12265

TALLOC_CTX *_mem_save_domain_0;

12266

if (ndr_flags & NDR_SCALARS) {

12267

NDR_CHECK(ndr_pull_align(ndr, 4));

12268

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->vcs));

12269

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_name));

12270

if (_ptr_name) {

12271

NDR_PULL_ALLOC(ndr, r->name);

12272

} else {

12273

r->name = NULL;

12274

}

12275

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_addr));

12276

if (_ptr_addr) {

12277

NDR_PULL_ALLOC(ndr, r->addr);

12278

} else {

12279

r->addr = NULL;

12280

}

12281

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->addr_len));

12282

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_net_addr));

12283

if (_ptr_net_addr) {

12284

NDR_PULL_ALLOC(ndr, r->net_addr);

12285

} else {

12286

r->net_addr = NULL;

12287

}

12288

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_domain));

12289

if (_ptr_domain) {

12290

NDR_PULL_ALLOC(ndr, r->domain);

12291

} else {

12292

r->domain = NULL;

12293

}

12294

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown));

12295

}

12296

if (ndr_flags & NDR_BUFFERS) {

12297

if (r->name) {

12298

_mem_save_name_0 = NDR_PULL_GET_MEM_CTX(ndr);

12299

NDR_PULL_SET_MEM_CTX(ndr, r->name, 0);

12300

NDR_CHECK(ndr_pull_array_size(ndr, &r->name));

12301

NDR_CHECK(ndr_pull_array_length(ndr, &r->name));

12302

if (ndr_get_array_length(ndr, &r->name) > ndr_get_array_size(ndr, &r->name)) {

12303

return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->name), ndr_get_array_length(ndr, &r->name));

12304

}

12305

NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->name), sizeof(uint16_t)));

12306

NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->name, ndr_get_array_length(ndr, &r->name), sizeof(uint16_t), CH_UTF16));

12307

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_name_0, 0);

12308

}

12309

if (r->addr) {

12310

_mem_save_addr_0 = NDR_PULL_GET_MEM_CTX(ndr);

12311

NDR_PULL_SET_MEM_CTX(ndr, r->addr, 0);

12312

NDR_CHECK(ndr_pull_array_size(ndr, &r->addr));

12313

NDR_PULL_ALLOC_N(ndr, r->addr, ndr_get_array_size(ndr, &r->addr));

12314

NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->addr, ndr_get_array_size(ndr, &r->addr)));

12315

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_addr_0, 0);

12316

}

12317

if (r->net_addr) {

12318

_mem_save_net_addr_0 = NDR_PULL_GET_MEM_CTX(ndr);

12319

NDR_PULL_SET_MEM_CTX(ndr, r->net_addr, 0);

12320

NDR_CHECK(ndr_pull_array_size(ndr, &r->net_addr));

12321

NDR_CHECK(ndr_pull_array_length(ndr, &r->net_addr));

12322

if (ndr_get_array_length(ndr, &r->net_addr) > ndr_get_array_size(ndr, &r->net_addr)) {

12323

return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->net_addr), ndr_get_array_length(ndr, &r->net_addr));

12324

}

12325

NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->net_addr), sizeof(uint16_t)));

12326

NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->net_addr, ndr_get_array_length(ndr, &r->net_addr), sizeof(uint16_t), CH_UTF16));

12327

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_net_addr_0, 0);

12328

}

12329

if (r->domain) {

12330

_mem_save_domain_0 = NDR_PULL_GET_MEM_CTX(ndr);

12331

NDR_PULL_SET_MEM_CTX(ndr, r->domain, 0);

12332

NDR_CHECK(ndr_pull_array_size(ndr, &r->domain));

12333

NDR_CHECK(ndr_pull_array_length(ndr, &r->domain));

12334

if (ndr_get_array_length(ndr, &r->domain) > ndr_get_array_size(ndr, &r->domain)) {

12335

return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->domain), ndr_get_array_length(ndr, &r->domain));

12336

}

12337

NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->domain), sizeof(uint16_t)));

12338

NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->domain, ndr_get_array_length(ndr, &r->domain), sizeof(uint16_t), CH_UTF16));

12339

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domain_0, 0);

12340

}

12341

if (r->addr) {

12342

NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->addr, r->addr_len));

12343

}

12344

}

12345

return NDR_ERR_SUCCESS;

12346

}

12347

12348

_PUBLIC_ void ndr_print_srvsvc_NetTransportInfo2(struct ndr_print *ndr, const char *name, const struct srvsvc_NetTransportInfo2 *r)

12349

{

12350

ndr_print_struct(ndr, name, "srvsvc_NetTransportInfo2");

12351

ndr->depth++;

12352

ndr_print_uint32(ndr, "vcs", r->vcs);

12353

ndr_print_ptr(ndr, "name", r->name);

12354

ndr->depth++;

12355

if (r->name) {

12356

ndr_print_string(ndr, "name", r->name);

12357

}

12358

ndr->depth--;

12359

ndr_print_ptr(ndr, "addr", r->addr);

12360

ndr->depth++;

12361

if (r->addr) {

12362

ndr_print_array_uint8(ndr, "addr", r->addr, r->addr_len);

12363

}

12364

ndr->depth--;

12365

ndr_print_uint32(ndr, "addr_len", r->addr_len);

12366

ndr_print_ptr(ndr, "net_addr", r->net_addr);

12367

ndr->depth++;

12368

if (r->net_addr) {

12369

ndr_print_string(ndr, "net_addr", r->net_addr);

12370

}

12371

ndr->depth--;

12372

ndr_print_ptr(ndr, "domain", r->domain);

12373

ndr->depth++;

12374

if (r->domain) {

12375

ndr_print_string(ndr, "domain", r->domain);

12376

}

12377

ndr->depth--;

12378

ndr_print_uint32(ndr, "unknown", r->unknown);

12379

ndr->depth--;

12380

}

12381

12382

static enum ndr_err_code ndr_push_srvsvc_NetTransportCtr2(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetTransportCtr2 *r)

12383

{

12384

uint32_t cntr_array_1;

12385

if (ndr_flags & NDR_SCALARS) {

12386

NDR_CHECK(ndr_push_align(ndr, 4));

12387

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));

12388

NDR_CHECK(ndr_push_unique_ptr(ndr, r->array));

12389

}

12390

if (ndr_flags & NDR_BUFFERS) {

12391

if (r->array) {

12392

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));

12393

for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {

12394

NDR_CHECK(ndr_push_srvsvc_NetTransportInfo2(ndr, NDR_SCALARS, &r->array[cntr_array_1]));

12395

}

12396

for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {

12397

NDR_CHECK(ndr_push_srvsvc_NetTransportInfo2(ndr, NDR_BUFFERS, &r->array[cntr_array_1]));

12398

}

12399

}

12400

}

12401

return NDR_ERR_SUCCESS;

12402

}

12403

12404

static enum ndr_err_code ndr_pull_srvsvc_NetTransportCtr2(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetTransportCtr2 *r)

12405

{

12406

uint32_t _ptr_array;

12407

uint32_t cntr_array_1;

12408

TALLOC_CTX *_mem_save_array_0;

12409

TALLOC_CTX *_mem_save_array_1;

12410

if (ndr_flags & NDR_SCALARS) {

12411

NDR_CHECK(ndr_pull_align(ndr, 4));

12412

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));

12413

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_array));

12414

if (_ptr_array) {

12415

NDR_PULL_ALLOC(ndr, r->array);

12416

} else {

12417

r->array = NULL;

12418

}

12419

}

12420

if (ndr_flags & NDR_BUFFERS) {

12421

if (r->array) {

12422

_mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);

12423

NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);

12424

NDR_CHECK(ndr_pull_array_size(ndr, &r->array));

12425

NDR_PULL_ALLOC_N(ndr, r->array, ndr_get_array_size(ndr, &r->array));

12426

_mem_save_array_1 = NDR_PULL_GET_MEM_CTX(ndr);

12427

NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);

12428

for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {

12429

NDR_CHECK(ndr_pull_srvsvc_NetTransportInfo2(ndr, NDR_SCALARS, &r->array[cntr_array_1]));

12430

}

12431

for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {

12432

NDR_CHECK(ndr_pull_srvsvc_NetTransportInfo2(ndr, NDR_BUFFERS, &r->array[cntr_array_1]));

12433

}

12434

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_1, 0);

12435

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);

12436

}

12437

if (r->array) {

12438

NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->array, r->count));

12439

}

12440

}

12441

return NDR_ERR_SUCCESS;

12442

}

12443

12444

_PUBLIC_ void ndr_print_srvsvc_NetTransportCtr2(struct ndr_print *ndr, const char *name, const struct srvsvc_NetTransportCtr2 *r)

12445

{

12446

uint32_t cntr_array_1;

12447

ndr_print_struct(ndr, name, "srvsvc_NetTransportCtr2");

12448

ndr->depth++;

12449

ndr_print_uint32(ndr, "count", r->count);

12450

ndr_print_ptr(ndr, "array", r->array);

12451

ndr->depth++;

12452

if (r->array) {

12453

ndr->print(ndr, "%s: ARRAY(%d)", "array", (int)r->count);

12454

ndr->depth++;

12455

for (cntr_array_1=0;cntr_array_1<r->count;cntr_array_1++) {

12456

char *idx_1=NULL;

12457

if (asprintf(&idx_1, "[%d]", cntr_array_1) != -1) {

12458

ndr_print_srvsvc_NetTransportInfo2(ndr, "array", &r->array[cntr_array_1]);

12459

free(idx_1);

12460

}

12461

}

12462

ndr->depth--;

12463

}

12464

ndr->depth--;

12465

ndr->depth--;

12466

}

12467

12468

static enum ndr_err_code ndr_push_srvsvc_NetTransportInfo3(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetTransportInfo3 *r)

12469

{

12470

if (ndr_flags & NDR_SCALARS) {

12471

NDR_CHECK(ndr_push_align(ndr, 4));

12472

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->vcs));

12473

NDR_CHECK(ndr_push_unique_ptr(ndr, r->name));

12474

NDR_CHECK(ndr_push_unique_ptr(ndr, r->addr));

12475

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->addr_len));

12476

NDR_CHECK(ndr_push_unique_ptr(ndr, r->net_addr));

12477

NDR_CHECK(ndr_push_unique_ptr(ndr, r->domain));

12478

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown1));

12479

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown2));

12480

NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->unknown3, 256));

12481

}

12482

if (ndr_flags & NDR_BUFFERS) {

12483

if (r->name) {

12484

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->name, CH_UTF16)));

12485

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));

12486

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->name, CH_UTF16)));

12487

NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->name, ndr_charset_length(r->name, CH_UTF16), sizeof(uint16_t), CH_UTF16));

12488

}

12489

if (r->addr) {

12490

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->addr_len));

12491

NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->addr, r->addr_len));

12492

}

12493

if (r->net_addr) {

12494

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->net_addr, CH_UTF16)));

12495

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));

12496

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->net_addr, CH_UTF16)));

12497

NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->net_addr, ndr_charset_length(r->net_addr, CH_UTF16), sizeof(uint16_t), CH_UTF16));

12498

}

12499

if (r->domain) {

12500

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->domain, CH_UTF16)));

12501

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));

12502

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->domain, CH_UTF16)));

12503

NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->domain, ndr_charset_length(r->domain, CH_UTF16), sizeof(uint16_t), CH_UTF16));

12504

}

12505

}

12506

return NDR_ERR_SUCCESS;

12507

}

12508

12509

static enum ndr_err_code ndr_pull_srvsvc_NetTransportInfo3(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetTransportInfo3 *r)

12510

{

12511

uint32_t _ptr_name;

12512

TALLOC_CTX *_mem_save_name_0;

12513

uint32_t _ptr_addr;

12514

TALLOC_CTX *_mem_save_addr_0;

12515

uint32_t _ptr_net_addr;

12516

TALLOC_CTX *_mem_save_net_addr_0;

12517

uint32_t _ptr_domain;

12518

TALLOC_CTX *_mem_save_domain_0;

12519

if (ndr_flags & NDR_SCALARS) {

12520

NDR_CHECK(ndr_pull_align(ndr, 4));

12521

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->vcs));

12522

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_name));

12523

if (_ptr_name) {

12524

NDR_PULL_ALLOC(ndr, r->name);

12525

} else {

12526

r->name = NULL;

12527

}

12528

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_addr));

12529

if (_ptr_addr) {

12530

NDR_PULL_ALLOC(ndr, r->addr);

12531

} else {

12532

r->addr = NULL;

12533

}

12534

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->addr_len));

12535

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_net_addr));

12536

if (_ptr_net_addr) {

12537

NDR_PULL_ALLOC(ndr, r->net_addr);

12538

} else {

12539

r->net_addr = NULL;

12540

}

12541

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_domain));

12542

if (_ptr_domain) {

12543

NDR_PULL_ALLOC(ndr, r->domain);

12544

} else {

12545

r->domain = NULL;

12546

}

12547

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown1));

12548

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown2));

12549

NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->unknown3, 256));

12550

}

12551

if (ndr_flags & NDR_BUFFERS) {

12552

if (r->name) {

12553

_mem_save_name_0 = NDR_PULL_GET_MEM_CTX(ndr);

12554

NDR_PULL_SET_MEM_CTX(ndr, r->name, 0);

12555

NDR_CHECK(ndr_pull_array_size(ndr, &r->name));

12556

NDR_CHECK(ndr_pull_array_length(ndr, &r->name));

12557

if (ndr_get_array_length(ndr, &r->name) > ndr_get_array_size(ndr, &r->name)) {

12558

return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->name), ndr_get_array_length(ndr, &r->name));

12559

}

12560

NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->name), sizeof(uint16_t)));

12561

NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->name, ndr_get_array_length(ndr, &r->name), sizeof(uint16_t), CH_UTF16));

12562

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_name_0, 0);

12563

}

12564

if (r->addr) {

12565

_mem_save_addr_0 = NDR_PULL_GET_MEM_CTX(ndr);

12566

NDR_PULL_SET_MEM_CTX(ndr, r->addr, 0);

12567

NDR_CHECK(ndr_pull_array_size(ndr, &r->addr));

12568

NDR_PULL_ALLOC_N(ndr, r->addr, ndr_get_array_size(ndr, &r->addr));

12569

NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->addr, ndr_get_array_size(ndr, &r->addr)));

12570

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_addr_0, 0);

12571

}

12572

if (r->net_addr) {

12573

_mem_save_net_addr_0 = NDR_PULL_GET_MEM_CTX(ndr);

12574

NDR_PULL_SET_MEM_CTX(ndr, r->net_addr, 0);

12575

NDR_CHECK(ndr_pull_array_size(ndr, &r->net_addr));

12576

NDR_CHECK(ndr_pull_array_length(ndr, &r->net_addr));

12577

if (ndr_get_array_length(ndr, &r->net_addr) > ndr_get_array_size(ndr, &r->net_addr)) {

12578

return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->net_addr), ndr_get_array_length(ndr, &r->net_addr));

12579

}

12580

NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->net_addr), sizeof(uint16_t)));

12581

NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->net_addr, ndr_get_array_length(ndr, &r->net_addr), sizeof(uint16_t), CH_UTF16));

12582

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_net_addr_0, 0);

12583

}

12584

if (r->domain) {

12585

_mem_save_domain_0 = NDR_PULL_GET_MEM_CTX(ndr);

12586

NDR_PULL_SET_MEM_CTX(ndr, r->domain, 0);

12587

NDR_CHECK(ndr_pull_array_size(ndr, &r->domain));

12588

NDR_CHECK(ndr_pull_array_length(ndr, &r->domain));

12589

if (ndr_get_array_length(ndr, &r->domain) > ndr_get_array_size(ndr, &r->domain)) {

12590

return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->domain), ndr_get_array_length(ndr, &r->domain));

12591

}

12592

NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->domain), sizeof(uint16_t)));

12593

NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->domain, ndr_get_array_length(ndr, &r->domain), sizeof(uint16_t), CH_UTF16));

12594

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domain_0, 0);

12595

}

12596

if (r->addr) {

12597

NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->addr, r->addr_len));

12598

}

12599

}

12600

return NDR_ERR_SUCCESS;

12601

}

12602

12603

_PUBLIC_ void ndr_print_srvsvc_NetTransportInfo3(struct ndr_print *ndr, const char *name, const struct srvsvc_NetTransportInfo3 *r)

12604

{

12605

ndr_print_struct(ndr, name, "srvsvc_NetTransportInfo3");

12606

ndr->depth++;

12607

ndr_print_uint32(ndr, "vcs", r->vcs);

12608

ndr_print_ptr(ndr, "name", r->name);

12609

ndr->depth++;

12610

if (r->name) {

12611

ndr_print_string(ndr, "name", r->name);

12612

}

12613

ndr->depth--;

12614

ndr_print_ptr(ndr, "addr", r->addr);

12615

ndr->depth++;

12616

if (r->addr) {

12617

ndr_print_array_uint8(ndr, "addr", r->addr, r->addr_len);

12618

}

12619

ndr->depth--;

12620

ndr_print_uint32(ndr, "addr_len", r->addr_len);

12621

ndr_print_ptr(ndr, "net_addr", r->net_addr);

12622

ndr->depth++;

12623

if (r->net_addr) {

12624

ndr_print_string(ndr, "net_addr", r->net_addr);

12625

}

12626

ndr->depth--;

12627

ndr_print_ptr(ndr, "domain", r->domain);

12628

ndr->depth++;

12629

if (r->domain) {

12630

ndr_print_string(ndr, "domain", r->domain);

12631

}

12632

ndr->depth--;

12633

ndr_print_uint32(ndr, "unknown1", r->unknown1);

12634

ndr_print_uint32(ndr, "unknown2", r->unknown2);

12635

ndr_print_array_uint8(ndr, "unknown3", r->unknown3, 256);

12636

ndr->depth--;

12637

}

12638

12639

static enum ndr_err_code ndr_push_srvsvc_NetTransportCtr3(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetTransportCtr3 *r)

12640

{

12641

uint32_t cntr_array_1;

12642

if (ndr_flags & NDR_SCALARS) {

12643

NDR_CHECK(ndr_push_align(ndr, 4));

12644

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));

12645

NDR_CHECK(ndr_push_unique_ptr(ndr, r->array));

12646

}

12647

if (ndr_flags & NDR_BUFFERS) {

12648

if (r->array) {

12649

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));

12650

for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {

12651

NDR_CHECK(ndr_push_srvsvc_NetTransportInfo3(ndr, NDR_SCALARS, &r->array[cntr_array_1]));

12652

}

12653

for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {

12654

NDR_CHECK(ndr_push_srvsvc_NetTransportInfo3(ndr, NDR_BUFFERS, &r->array[cntr_array_1]));

12655

}

12656

}

12657

}

12658

return NDR_ERR_SUCCESS;

12659

}

12660

12661

static enum ndr_err_code ndr_pull_srvsvc_NetTransportCtr3(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetTransportCtr3 *r)

12662

{

12663

uint32_t _ptr_array;

12664

uint32_t cntr_array_1;

12665

TALLOC_CTX *_mem_save_array_0;

12666

TALLOC_CTX *_mem_save_array_1;

12667

if (ndr_flags & NDR_SCALARS) {

12668

NDR_CHECK(ndr_pull_align(ndr, 4));

12669

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));

12670

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_array));

12671

if (_ptr_array) {

12672

NDR_PULL_ALLOC(ndr, r->array);

12673

} else {

12674

r->array = NULL;

12675

}

12676

}

12677

if (ndr_flags & NDR_BUFFERS) {

12678

if (r->array) {

12679

_mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);

12680

NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);

12681

NDR_CHECK(ndr_pull_array_size(ndr, &r->array));

12682

NDR_PULL_ALLOC_N(ndr, r->array, ndr_get_array_size(ndr, &r->array));

12683

_mem_save_array_1 = NDR_PULL_GET_MEM_CTX(ndr);

12684

NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);

12685

for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {

12686

NDR_CHECK(ndr_pull_srvsvc_NetTransportInfo3(ndr, NDR_SCALARS, &r->array[cntr_array_1]));

12687

}

12688

for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {

12689

NDR_CHECK(ndr_pull_srvsvc_NetTransportInfo3(ndr, NDR_BUFFERS, &r->array[cntr_array_1]));

12690

}

12691

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_1, 0);

12692

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);

12693

}

12694

if (r->array) {

12695

NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->array, r->count));

12696

}

12697

}

12698

return NDR_ERR_SUCCESS;

12699

}

12700

12701

_PUBLIC_ void ndr_print_srvsvc_NetTransportCtr3(struct ndr_print *ndr, const char *name, const struct srvsvc_NetTransportCtr3 *r)

12702

{

12703

uint32_t cntr_array_1;

12704

ndr_print_struct(ndr, name, "srvsvc_NetTransportCtr3");

12705

ndr->depth++;

12706

ndr_print_uint32(ndr, "count", r->count);

12707

ndr_print_ptr(ndr, "array", r->array);

12708

ndr->depth++;

12709

if (r->array) {

12710

ndr->print(ndr, "%s: ARRAY(%d)", "array", (int)r->count);

12711

ndr->depth++;

12712

for (cntr_array_1=0;cntr_array_1<r->count;cntr_array_1++) {

12713

char *idx_1=NULL;

12714

if (asprintf(&idx_1, "[%d]", cntr_array_1) != -1) {

12715

ndr_print_srvsvc_NetTransportInfo3(ndr, "array", &r->array[cntr_array_1]);

12716

free(idx_1);

12717

}

12718

}

12719

ndr->depth--;

12720

}

12721

ndr->depth--;

12722

ndr->depth--;

12723

}

12724

12725

static enum ndr_err_code ndr_push_srvsvc_NetTransportCtr(struct ndr_push *ndr, int ndr_flags, const union srvsvc_NetTransportCtr *r)

12726

{

12727

if (ndr_flags & NDR_SCALARS) {

12728

int level = ndr_push_get_switch_value(ndr, r);

12729

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));

12730

switch (level) {

12731

case 0: {

12732

NDR_CHECK(ndr_push_unique_ptr(ndr, r->ctr0));

12733

break; }

12734

12735

case 1: {

12736

NDR_CHECK(ndr_push_unique_ptr(ndr, r->ctr1));

12737

break; }

12738

12739

case 2: {

12740

NDR_CHECK(ndr_push_unique_ptr(ndr, r->ctr2));

12741

break; }

12742

12743

case 3: {

12744

NDR_CHECK(ndr_push_unique_ptr(ndr, r->ctr3));

12745

break; }

12746

12747

default: {

12748

break; }

12749

12750

}

12751

}

12752

if (ndr_flags & NDR_BUFFERS) {

12753

int level = ndr_push_get_switch_value(ndr, r);

12754

switch (level) {

12755

case 0:

12756

if (r->ctr0) {

12757

NDR_CHECK(ndr_push_srvsvc_NetTransportCtr0(ndr, NDR_SCALARS|NDR_BUFFERS, r->ctr0));

12758

}

12759

break;

12760

12761

case 1:

12762

if (r->ctr1) {

12763

NDR_CHECK(ndr_push_srvsvc_NetTransportCtr1(ndr, NDR_SCALARS|NDR_BUFFERS, r->ctr1));

12764

}

12765

break;

12766

12767

case 2:

12768

if (r->ctr2) {

12769

NDR_CHECK(ndr_push_srvsvc_NetTransportCtr2(ndr, NDR_SCALARS|NDR_BUFFERS, r->ctr2));

12770

}

12771

break;

12772

12773

case 3:

12774

if (r->ctr3) {

12775

NDR_CHECK(ndr_push_srvsvc_NetTransportCtr3(ndr, NDR_SCALARS|NDR_BUFFERS, r->ctr3));

12776

}

12777

break;

12778

12779

default:

12780

break;

12781

12782

}

12783

}

12784

return NDR_ERR_SUCCESS;

12785

}

12786

12787

static enum ndr_err_code ndr_pull_srvsvc_NetTransportCtr(struct ndr_pull *ndr, int ndr_flags, union srvsvc_NetTransportCtr *r)

12788

{

12789

int level;

12790

uint32_t _level;

12791

TALLOC_CTX *_mem_save_ctr0_0;

12792

TALLOC_CTX *_mem_save_ctr1_0;

12793

TALLOC_CTX *_mem_save_ctr2_0;

12794

TALLOC_CTX *_mem_save_ctr3_0;

12795

level = ndr_pull_get_switch_value(ndr, r);

12796

if (ndr_flags & NDR_SCALARS) {

12797

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));

12798

if (_level != level) {

12799

return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r", _level);

12800

}

12801

switch (level) {

12802

case 0: {

12803

uint32_t _ptr_ctr0;

12804

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_ctr0));

12805

if (_ptr_ctr0) {

12806

NDR_PULL_ALLOC(ndr, r->ctr0);

12807

} else {

12808

r->ctr0 = NULL;

12809

}

12810

break; }

12811

12812

case 1: {

12813

uint32_t _ptr_ctr1;

12814

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_ctr1));

12815

if (_ptr_ctr1) {

12816

NDR_PULL_ALLOC(ndr, r->ctr1);

12817

} else {

12818

r->ctr1 = NULL;

12819

}

12820

break; }

12821

12822

case 2: {

12823

uint32_t _ptr_ctr2;

12824

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_ctr2));

12825

if (_ptr_ctr2) {

12826

NDR_PULL_ALLOC(ndr, r->ctr2);

12827

} else {

12828

r->ctr2 = NULL;

12829

}

12830

break; }

12831

12832

case 3: {

12833

uint32_t _ptr_ctr3;

12834

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_ctr3));

12835

if (_ptr_ctr3) {

12836

NDR_PULL_ALLOC(ndr, r->ctr3);

12837

} else {

12838

r->ctr3 = NULL;

12839

}

12840

break; }

12841

12842

default: {

12843

break; }

12844

12845

}

12846

}

12847

if (ndr_flags & NDR_BUFFERS) {

12848

switch (level) {

12849

case 0:

12850

if (r->ctr0) {

12851

_mem_save_ctr0_0 = NDR_PULL_GET_MEM_CTX(ndr);

12852

NDR_PULL_SET_MEM_CTX(ndr, r->ctr0, 0);

12853

NDR_CHECK(ndr_pull_srvsvc_NetTransportCtr0(ndr, NDR_SCALARS|NDR_BUFFERS, r->ctr0));

12854

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ctr0_0, 0);

12855

}

12856

break;

12857

12858

case 1:

12859

if (r->ctr1) {

12860

_mem_save_ctr1_0 = NDR_PULL_GET_MEM_CTX(ndr);

12861

NDR_PULL_SET_MEM_CTX(ndr, r->ctr1, 0);

12862

NDR_CHECK(ndr_pull_srvsvc_NetTransportCtr1(ndr, NDR_SCALARS|NDR_BUFFERS, r->ctr1));

12863

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ctr1_0, 0);

12864

}

12865

break;

12866

12867

case 2:

12868

if (r->ctr2) {

12869

_mem_save_ctr2_0 = NDR_PULL_GET_MEM_CTX(ndr);

12870

NDR_PULL_SET_MEM_CTX(ndr, r->ctr2, 0);

12871

NDR_CHECK(ndr_pull_srvsvc_NetTransportCtr2(ndr, NDR_SCALARS|NDR_BUFFERS, r->ctr2));

12872

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ctr2_0, 0);

12873

}

12874

break;

12875

12876

case 3:

12877

if (r->ctr3) {

12878

_mem_save_ctr3_0 = NDR_PULL_GET_MEM_CTX(ndr);

12879

NDR_PULL_SET_MEM_CTX(ndr, r->ctr3, 0);

12880

NDR_CHECK(ndr_pull_srvsvc_NetTransportCtr3(ndr, NDR_SCALARS|NDR_BUFFERS, r->ctr3));

12881

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ctr3_0, 0);

12882

}

12883

break;

12884

12885

default:

12886

break;

12887

12888

}

12889

}

12890

return NDR_ERR_SUCCESS;

12891

}

12892

12893

_PUBLIC_ void ndr_print_srvsvc_NetTransportCtr(struct ndr_print *ndr, const char *name, const union srvsvc_NetTransportCtr *r)

12894

{

12895

int level;

12896

level = ndr_print_get_switch_value(ndr, r);

12897

ndr_print_union(ndr, name, level, "srvsvc_NetTransportCtr");

12898

switch (level) {

12899

case 0:

12900

ndr_print_ptr(ndr, "ctr0", r->ctr0);

12901

ndr->depth++;

12902

if (r->ctr0) {

12903

ndr_print_srvsvc_NetTransportCtr0(ndr, "ctr0", r->ctr0);

12904

}

12905

ndr->depth--;

12906

break;

12907

12908

case 1:

12909

ndr_print_ptr(ndr, "ctr1", r->ctr1);

12910

ndr->depth++;

12911

if (r->ctr1) {

12912

ndr_print_srvsvc_NetTransportCtr1(ndr, "ctr1", r->ctr1);

12913

}

12914

ndr->depth--;

12915

break;

12916

12917

case 2:

12918

ndr_print_ptr(ndr, "ctr2", r->ctr2);

12919

ndr->depth++;

12920

if (r->ctr2) {

12921

ndr_print_srvsvc_NetTransportCtr2(ndr, "ctr2", r->ctr2);

12922

}

12923

ndr->depth--;

12924

break;

12925

12926

case 3:

12927

ndr_print_ptr(ndr, "ctr3", r->ctr3);

12928

ndr->depth++;

12929

if (r->ctr3) {

12930

ndr_print_srvsvc_NetTransportCtr3(ndr, "ctr3", r->ctr3);

12931

}

12932

ndr->depth--;

12933

break;

12934

12935

default:

12936

break;

12937

12938

}

12939

}

12940

12941

static enum ndr_err_code ndr_push_srvsvc_NetTransportInfoCtr(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetTransportInfoCtr *r)

12942

{

12943

if (ndr_flags & NDR_SCALARS) {

12944

NDR_CHECK(ndr_push_align(ndr, 4));

12945

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->level));

12946

NDR_CHECK(ndr_push_set_switch_value(ndr, &r->ctr, r->level));

12947

NDR_CHECK(ndr_push_srvsvc_NetTransportCtr(ndr, NDR_SCALARS, &r->ctr));

12948

}

12949

if (ndr_flags & NDR_BUFFERS) {

12950

NDR_CHECK(ndr_push_srvsvc_NetTransportCtr(ndr, NDR_BUFFERS, &r->ctr));

12951

}

12952

return NDR_ERR_SUCCESS;

12953

}

12954

12955

static enum ndr_err_code ndr_pull_srvsvc_NetTransportInfoCtr(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetTransportInfoCtr *r)

12956

{

12957

if (ndr_flags & NDR_SCALARS) {

12958

NDR_CHECK(ndr_pull_align(ndr, 4));

12959

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->level));

12960

NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->ctr, r->level));

12961

NDR_CHECK(ndr_pull_srvsvc_NetTransportCtr(ndr, NDR_SCALARS, &r->ctr));

12962

}

12963

if (ndr_flags & NDR_BUFFERS) {

12964

NDR_CHECK(ndr_pull_srvsvc_NetTransportCtr(ndr, NDR_BUFFERS, &r->ctr));

12965

}

12966

return NDR_ERR_SUCCESS;

12967

}

12968

12969

_PUBLIC_ void ndr_print_srvsvc_NetTransportInfoCtr(struct ndr_print *ndr, const char *name, const struct srvsvc_NetTransportInfoCtr *r)

12970

{

12971

ndr_print_struct(ndr, name, "srvsvc_NetTransportInfoCtr");

12972

ndr->depth++;

12973

ndr_print_uint32(ndr, "level", r->level);

12974

ndr_print_set_switch_value(ndr, &r->ctr, r->level);

12975

ndr_print_srvsvc_NetTransportCtr(ndr, "ctr", &r->ctr);

12976

ndr->depth--;

12977

}

12978

12979

static enum ndr_err_code ndr_push_srvsvc_NetRemoteTODInfo(struct ndr_push *ndr, int ndr_flags, const struct srvsvc_NetRemoteTODInfo *r)

12980

{

12981

if (ndr_flags & NDR_SCALARS) {

12982

NDR_CHECK(ndr_push_align(ndr, 4));

12983

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->elapsed));

12984

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->msecs));

12985

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->hours));

12986

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->mins));

12987

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->secs));

12988

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->hunds));

12989

NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, r->timezone));

12990

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->tinterval));

12991

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->day));

12992

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->month));

12993

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->year));

12994

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->weekday));

12995

}

12996

if (ndr_flags & NDR_BUFFERS) {

12997

}

12998

return NDR_ERR_SUCCESS;

12999

}

13000

13001

static enum ndr_err_code ndr_pull_srvsvc_NetRemoteTODInfo(struct ndr_pull *ndr, int ndr_flags, struct srvsvc_NetRemoteTODInfo *r)

13002

{

13003

if (ndr_flags & NDR_SCALARS) {

13004

NDR_CHECK(ndr_pull_align(ndr, 4));

13005

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->elapsed));

13006

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->msecs));

13007

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->hours));

13008

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->mins));

13009

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->secs));

13010

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->hunds));

13011

NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &r->timezone));

13012

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->tinterval));

13013

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->day));

13014

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->month));

13015

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->year));

13016

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->weekday));

13017

}

13018

if (ndr_flags & NDR_BUFFERS) {

13019

}

13020

return NDR_ERR_SUCCESS;

13021

}

13022

13023

_PUBLIC_ void ndr_print_srvsvc_NetRemoteTODInfo(struct ndr_print *ndr, const char *name, const struct srvsvc_NetRemoteTODInfo *r)

13024

{

13025

ndr_print_struct(ndr, name, "srvsvc_NetRemoteTODInfo");

13026

ndr->depth++;

13027

ndr_print_uint32(ndr, "elapsed", r->elapsed);

13028

ndr_print_uint32(ndr, "msecs", r->msecs);

13029

ndr_print_uint32(ndr, "hours", r->hours);

13030

ndr_print_uint32(ndr, "mins", r->mins);

13031

ndr_print_uint32(ndr, "secs", r->secs);

13032

ndr_print_uint32(ndr, "hunds", r->hunds);

13033

ndr_print_int32(ndr, "timezone", r->timezone);

13034

ndr_print_uint32(ndr, "tinterval", r->tinterval);

13035

ndr_print_uint32(ndr, "day", r->day);

13036

ndr_print_uint32(ndr, "month", r->month);

13037

ndr_print_uint32(ndr, "year", r->year);

13038

ndr_print_uint32(ndr, "weekday", r->weekday);

13039

ndr->depth--;

13040

}

13041

13042

static enum ndr_err_code ndr_push_srvsvc_NetTransportInfo(struct ndr_push *ndr, int ndr_flags, const union srvsvc_NetTransportInfo *r)

13043

{

13044

if (ndr_flags & NDR_SCALARS) {

13045

int level = ndr_push_get_switch_value(ndr, r);

13046

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));

13047

switch (level) {

13048

case 0: {

13049

NDR_CHECK(ndr_push_srvsvc_NetTransportInfo0(ndr, NDR_SCALARS, &r->info0));

13050

break; }

13051

13052

case 1: {

13053

NDR_CHECK(ndr_push_srvsvc_NetTransportInfo1(ndr, NDR_SCALARS, &r->info1));

13054

break; }

13055

13056

case 2: {

13057

NDR_CHECK(ndr_push_srvsvc_NetTransportInfo2(ndr, NDR_SCALARS, &r->info2));

13058

break; }

13059

13060

case 3: {

13061

NDR_CHECK(ndr_push_srvsvc_NetTransportInfo3(ndr, NDR_SCALARS, &r->info3));

13062

break; }

13063

13064

default:

13065

return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);

13066

}

13067

}

13068

if (ndr_flags & NDR_BUFFERS) {

13069

int level = ndr_push_get_switch_value(ndr, r);

13070

switch (level) {

13071

case 0:

13072

NDR_CHECK(ndr_push_srvsvc_NetTransportInfo0(ndr, NDR_BUFFERS, &r->info0));

13073

break;

13074

13075

case 1:

13076

NDR_CHECK(ndr_push_srvsvc_NetTransportInfo1(ndr, NDR_BUFFERS, &r->info1));

13077

break;

13078

13079

case 2:

13080

NDR_CHECK(ndr_push_srvsvc_NetTransportInfo2(ndr, NDR_BUFFERS, &r->info2));

13081

break;

13082

13083

case 3:

13084

NDR_CHECK(ndr_push_srvsvc_NetTransportInfo3(ndr, NDR_BUFFERS, &r->info3));

13085

break;

13086

13087

default:

13088

return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);

13089

}

13090

}

13091

return NDR_ERR_SUCCESS;

13092

}

13093

13094

static enum ndr_err_code ndr_pull_srvsvc_NetTransportInfo(struct ndr_pull *ndr, int ndr_flags, union srvsvc_NetTransportInfo *r)

13095

{

13096

int level;

13097

uint32_t _level;

13098

level = ndr_pull_get_switch_value(ndr, r);

13099

if (ndr_flags & NDR_SCALARS) {

13100

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));

13101

if (_level != level) {

13102

return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r", _level);

13103

}

13104

switch (level) {

13105

case 0: {

13106

NDR_CHECK(ndr_pull_srvsvc_NetTransportInfo0(ndr, NDR_SCALARS, &r->info0));

13107

break; }

13108

13109

case 1: {

13110

NDR_CHECK(ndr_pull_srvsvc_NetTransportInfo1(ndr, NDR_SCALARS, &r->info1));

13111

break; }

13112

13113

case 2: {

13114

NDR_CHECK(ndr_pull_srvsvc_NetTransportInfo2(ndr, NDR_SCALARS, &r->info2));

13115

break; }

13116

13117

case 3: {

13118

NDR_CHECK(ndr_pull_srvsvc_NetTransportInfo3(ndr, NDR_SCALARS, &r->info3));

13119

break; }

13120

13121

default:

13122

return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);

13123

}

13124

}

13125

if (ndr_flags & NDR_BUFFERS) {

13126

switch (level) {

13127

case 0:

13128

NDR_CHECK(ndr_pull_srvsvc_NetTransportInfo0(ndr, NDR_BUFFERS, &r->info0));

13129

break;

13130

13131

case 1:

13132

NDR_CHECK(ndr_pull_srvsvc_NetTransportInfo1(ndr, NDR_BUFFERS, &r->info1));

13133

break;

13134

13135

case 2:

13136

NDR_CHECK(ndr_pull_srvsvc_NetTransportInfo2(ndr, NDR_BUFFERS, &r->info2));

13137

break;

13138

13139

case 3:

13140

NDR_CHECK(ndr_pull_srvsvc_NetTransportInfo3(ndr, NDR_BUFFERS, &r->info3));

13141

break;

13142

13143

default:

13144

return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);

13145

}

13146

}

13147

return NDR_ERR_SUCCESS;

13148

}

13149

13150

_PUBLIC_ void ndr_print_srvsvc_NetTransportInfo(struct ndr_print *ndr, const char *name, const union srvsvc_NetTransportInfo *r)

13151

{

13152

int level;

13153

level = ndr_print_get_switch_value(ndr, r);

13154

ndr_print_union(ndr, name, level, "srvsvc_NetTransportInfo");

13155

switch (level) {

13156

case 0:

13157

ndr_print_srvsvc_NetTransportInfo0(ndr, "info0", &r->info0);

13158

break;

13159

13160

case 1:

13161

ndr_print_srvsvc_NetTransportInfo1(ndr, "info1", &r->info1);

13162

break;

13163

13164

case 2:

13165

ndr_print_srvsvc_NetTransportInfo2(ndr, "info2", &r->info2);

13166

break;

13167

13168

case 3:

13169

ndr_print_srvsvc_NetTransportInfo3(ndr, "info3", &r->info3);

13170

break;

13171

13172

default:

13173

ndr_print_bad_level(ndr, name, level);

13174

}

13175

}

13176

13177

static enum ndr_err_code ndr_push_srvsvc_NetCharDevEnum(struct ndr_push *ndr, int flags, const struct srvsvc_NetCharDevEnum *r)

13178

{

13179

if (flags & NDR_IN) {

13180

NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server_unc));

13181

if (r->in.server_unc) {

13182

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_unc, CH_UTF16)));

13183

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));

13184

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_unc, CH_UTF16)));

13185

NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server_unc, ndr_charset_length(r->in.server_unc, CH_UTF16), sizeof(uint16_t), CH_UTF16));

13186

}

13187

if (r->in.info_ctr == NULL) {

13188

return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");

13189

}

13190

NDR_CHECK(ndr_push_srvsvc_NetCharDevInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info_ctr));

13191

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.max_buffer));

13192

NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.resume_handle));

13193

if (r->in.resume_handle) {

13194

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->in.resume_handle));

13195

}

13196

}

13197

if (flags & NDR_OUT) {

13198

if (r->out.info_ctr == NULL) {

13199

return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");

13200

}

13201

NDR_CHECK(ndr_push_srvsvc_NetCharDevInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.info_ctr));

13202

if (r->out.totalentries == NULL) {

13203

return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");

13204

}

13205

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.totalentries));

13206

NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.resume_handle));

13207

if (r->out.resume_handle) {

13208

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.resume_handle));

13209

}

13210

NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));

13211

}

13212

return NDR_ERR_SUCCESS;

13213

}

13214

13215

static enum ndr_err_code ndr_pull_srvsvc_NetCharDevEnum(struct ndr_pull *ndr, int flags, struct srvsvc_NetCharDevEnum *r)

13216

{

13217

uint32_t _ptr_server_unc;

13218

uint32_t _ptr_resume_handle;

13219

TALLOC_CTX *_mem_save_server_unc_0;

13220

TALLOC_CTX *_mem_save_info_ctr_0;

13221

TALLOC_CTX *_mem_save_totalentries_0;

13222

TALLOC_CTX *_mem_save_resume_handle_0;

13223

if (flags & NDR_IN) {

13224

ZERO_STRUCT(r->out);

13225

13226

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_unc));

13227

if (_ptr_server_unc) {

13228

NDR_PULL_ALLOC(ndr, r->in.server_unc);

13229

} else {

13230

r->in.server_unc = NULL;

13231

}

13232

if (r->in.server_unc) {

13233

_mem_save_server_unc_0 = NDR_PULL_GET_MEM_CTX(ndr);

13234

NDR_PULL_SET_MEM_CTX(ndr, r->in.server_unc, 0);

13235

NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_unc));

13236

NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_unc));

13237

if (ndr_get_array_length(ndr, &r->in.server_unc) > ndr_get_array_size(ndr, &r->in.server_unc)) {

13238

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.server_unc), ndr_get_array_length(ndr, &r->in.server_unc));

13239

}

13240

NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server_unc), sizeof(uint16_t)));

13241

NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server_unc, ndr_get_array_length(ndr, &r->in.server_unc), sizeof(uint16_t), CH_UTF16));

13242

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_unc_0, 0);

13243

}

13244

if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {

13245

NDR_PULL_ALLOC(ndr, r->in.info_ctr);

13246

}

13247

_mem_save_info_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);

13248

NDR_PULL_SET_MEM_CTX(ndr, r->in.info_ctr, LIBNDR_FLAG_REF_ALLOC);

13249

NDR_CHECK(ndr_pull_srvsvc_NetCharDevInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info_ctr));

13250

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_ctr_0, LIBNDR_FLAG_REF_ALLOC);

13251

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.max_buffer));

13252

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_resume_handle));

13253

if (_ptr_resume_handle) {

13254

NDR_PULL_ALLOC(ndr, r->in.resume_handle);

13255

} else {

13256

r->in.resume_handle = NULL;

13257

}

13258

if (r->in.resume_handle) {

13259

_mem_save_resume_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);

13260

NDR_PULL_SET_MEM_CTX(ndr, r->in.resume_handle, 0);

13261

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->in.resume_handle));

13262

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_resume_handle_0, 0);

13263

}

13264

NDR_PULL_ALLOC(ndr, r->out.info_ctr);

13265

*r->out.info_ctr = *r->in.info_ctr;

13266

NDR_PULL_ALLOC(ndr, r->out.totalentries);

13267

ZERO_STRUCTP(r->out.totalentries);

13268

}

13269

if (flags & NDR_OUT) {

13270

if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {

13271

NDR_PULL_ALLOC(ndr, r->out.info_ctr);

13272

}

13273

_mem_save_info_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);

13274

NDR_PULL_SET_MEM_CTX(ndr, r->out.info_ctr, LIBNDR_FLAG_REF_ALLOC);

13275

NDR_CHECK(ndr_pull_srvsvc_NetCharDevInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.info_ctr));

13276

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_ctr_0, LIBNDR_FLAG_REF_ALLOC);

13277

if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {

13278

NDR_PULL_ALLOC(ndr, r->out.totalentries);

13279

}

13280

_mem_save_totalentries_0 = NDR_PULL_GET_MEM_CTX(ndr);

13281

NDR_PULL_SET_MEM_CTX(ndr, r->out.totalentries, LIBNDR_FLAG_REF_ALLOC);

13282

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.totalentries));

13283

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_totalentries_0, LIBNDR_FLAG_REF_ALLOC);

13284

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_resume_handle));

13285

if (_ptr_resume_handle) {

13286

NDR_PULL_ALLOC(ndr, r->out.resume_handle);

13287

} else {

13288

r->out.resume_handle = NULL;

13289

}

13290

if (r->out.resume_handle) {

13291

_mem_save_resume_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);

13292

NDR_PULL_SET_MEM_CTX(ndr, r->out.resume_handle, 0);

13293

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.resume_handle));

13294

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_resume_handle_0, 0);

13295

}

13296

NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));

13297

}

13298

return NDR_ERR_SUCCESS;

13299

}

13300

13301

_PUBLIC_ void ndr_print_srvsvc_NetCharDevEnum(struct ndr_print *ndr, const char *name, int flags, const struct srvsvc_NetCharDevEnum *r)

13302

{

13303

ndr_print_struct(ndr, name, "srvsvc_NetCharDevEnum");

13304

ndr->depth++;

13305

if (flags & NDR_SET_VALUES) {

13306

ndr->flags |= LIBNDR_PRINT_SET_VALUES;

13307

}

13308

if (flags & NDR_IN) {

13309

ndr_print_struct(ndr, "in", "srvsvc_NetCharDevEnum");

13310

ndr->depth++;

13311

ndr_print_ptr(ndr, "server_unc", r->in.server_unc);

13312

ndr->depth++;

13313

if (r->in.server_unc) {

13314

ndr_print_string(ndr, "server_unc", r->in.server_unc);

13315

}

13316

ndr->depth--;

13317

ndr_print_ptr(ndr, "info_ctr", r->in.info_ctr);

13318

ndr->depth++;

13319

ndr_print_srvsvc_NetCharDevInfoCtr(ndr, "info_ctr", r->in.info_ctr);

13320

ndr->depth--;

13321

ndr_print_uint32(ndr, "max_buffer", r->in.max_buffer);

13322

ndr_print_ptr(ndr, "resume_handle", r->in.resume_handle);

13323

ndr->depth++;

13324

if (r->in.resume_handle) {

13325

ndr_print_uint32(ndr, "resume_handle", *r->in.resume_handle);

13326

}

13327

ndr->depth--;

13328

ndr->depth--;

13329

}

13330

if (flags & NDR_OUT) {

13331

ndr_print_struct(ndr, "out", "srvsvc_NetCharDevEnum");

13332

ndr->depth++;

13333

ndr_print_ptr(ndr, "info_ctr", r->out.info_ctr);

13334

ndr->depth++;

13335

ndr_print_srvsvc_NetCharDevInfoCtr(ndr, "info_ctr", r->out.info_ctr);

13336

ndr->depth--;

13337

ndr_print_ptr(ndr, "totalentries", r->out.totalentries);

13338

ndr->depth++;

13339

ndr_print_uint32(ndr, "totalentries", *r->out.totalentries);

13340

ndr->depth--;

13341

ndr_print_ptr(ndr, "resume_handle", r->out.resume_handle);

13342

ndr->depth++;

13343

if (r->out.resume_handle) {

13344

ndr_print_uint32(ndr, "resume_handle", *r->out.resume_handle);

13345

}

13346

ndr->depth--;

13347

ndr_print_WERROR(ndr, "result", r->out.result);

13348

ndr->depth--;

13349

}

13350

ndr->depth--;

13351

}

13352

13353

static enum ndr_err_code ndr_push_srvsvc_NetCharDevGetInfo(struct ndr_push *ndr, int flags, const struct srvsvc_NetCharDevGetInfo *r)

13354

{

13355

if (flags & NDR_IN) {

13356

NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server_unc));

13357

if (r->in.server_unc) {

13358

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_unc, CH_UTF16)));

13359

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));

13360

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_unc, CH_UTF16)));

13361

NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server_unc, ndr_charset_length(r->in.server_unc, CH_UTF16), sizeof(uint16_t), CH_UTF16));

13362

}

13363

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.device_name, CH_UTF16)));

13364

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));

13365

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.device_name, CH_UTF16)));

13366

NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.device_name, ndr_charset_length(r->in.device_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));

13367

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));

13368

}

13369

if (flags & NDR_OUT) {

13370

if (r->out.info == NULL) {

13371

return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");

13372

}

13373

NDR_CHECK(ndr_push_set_switch_value(ndr, r->out.info, r->in.level));

13374

NDR_CHECK(ndr_push_srvsvc_NetCharDevInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.info));

13375

NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));

13376

}

13377

return NDR_ERR_SUCCESS;

13378

}

13379

13380

static enum ndr_err_code ndr_pull_srvsvc_NetCharDevGetInfo(struct ndr_pull *ndr, int flags, struct srvsvc_NetCharDevGetInfo *r)

13381

{

13382

uint32_t _ptr_server_unc;

13383

TALLOC_CTX *_mem_save_server_unc_0;

13384

TALLOC_CTX *_mem_save_info_0;

13385

if (flags & NDR_IN) {

13386

ZERO_STRUCT(r->out);

13387

13388

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_unc));

13389

if (_ptr_server_unc) {

13390

NDR_PULL_ALLOC(ndr, r->in.server_unc);

13391

} else {

13392

r->in.server_unc = NULL;

13393

}

13394

if (r->in.server_unc) {

13395

_mem_save_server_unc_0 = NDR_PULL_GET_MEM_CTX(ndr);

13396

NDR_PULL_SET_MEM_CTX(ndr, r->in.server_unc, 0);

13397

NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_unc));

13398

NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_unc));

13399

if (ndr_get_array_length(ndr, &r->in.server_unc) > ndr_get_array_size(ndr, &r->in.server_unc)) {

13400

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.server_unc), ndr_get_array_length(ndr, &r->in.server_unc));

13401

}

13402

NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server_unc), sizeof(uint16_t)));

13403

NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server_unc, ndr_get_array_length(ndr, &r->in.server_unc), sizeof(uint16_t), CH_UTF16));

13404

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_unc_0, 0);

13405

}

13406

NDR_CHECK(ndr_pull_array_size(ndr, &r->in.device_name));

13407

NDR_CHECK(ndr_pull_array_length(ndr, &r->in.device_name));

13408

if (ndr_get_array_length(ndr, &r->in.device_name) > ndr_get_array_size(ndr, &r->in.device_name)) {

13409

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.device_name), ndr_get_array_length(ndr, &r->in.device_name));

13410

}

13411

NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.device_name), sizeof(uint16_t)));

13412

NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.device_name, ndr_get_array_length(ndr, &r->in.device_name), sizeof(uint16_t), CH_UTF16));

13413

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));

13414

NDR_PULL_ALLOC(ndr, r->out.info);

13415

ZERO_STRUCTP(r->out.info);

13416

}

13417

if (flags & NDR_OUT) {

13418

if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {

13419

NDR_PULL_ALLOC(ndr, r->out.info);

13420

}

13421

_mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);

13422

NDR_PULL_SET_MEM_CTX(ndr, r->out.info, LIBNDR_FLAG_REF_ALLOC);

13423

NDR_CHECK(ndr_pull_set_switch_value(ndr, r->out.info, r->in.level));

13424

NDR_CHECK(ndr_pull_srvsvc_NetCharDevInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.info));

13425

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, LIBNDR_FLAG_REF_ALLOC);

13426

NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));

13427

}

13428

return NDR_ERR_SUCCESS;

13429

}

13430

13431

_PUBLIC_ void ndr_print_srvsvc_NetCharDevGetInfo(struct ndr_print *ndr, const char *name, int flags, const struct srvsvc_NetCharDevGetInfo *r)

13432

{

13433

ndr_print_struct(ndr, name, "srvsvc_NetCharDevGetInfo");

13434

ndr->depth++;

13435

if (flags & NDR_SET_VALUES) {

13436

ndr->flags |= LIBNDR_PRINT_SET_VALUES;

13437

}

13438

if (flags & NDR_IN) {

13439

ndr_print_struct(ndr, "in", "srvsvc_NetCharDevGetInfo");

13440

ndr->depth++;

13441

ndr_print_ptr(ndr, "server_unc", r->in.server_unc);

13442

ndr->depth++;

13443

if (r->in.server_unc) {

13444

ndr_print_string(ndr, "server_unc", r->in.server_unc);

13445

}

13446

ndr->depth--;

13447

ndr_print_string(ndr, "device_name", r->in.device_name);

13448

ndr_print_uint32(ndr, "level", r->in.level);

13449

ndr->depth--;

13450

}

13451

if (flags & NDR_OUT) {

13452

ndr_print_struct(ndr, "out", "srvsvc_NetCharDevGetInfo");

13453

ndr->depth++;

13454

ndr_print_ptr(ndr, "info", r->out.info);

13455

ndr->depth++;

13456

ndr_print_set_switch_value(ndr, r->out.info, r->in.level);

13457

ndr_print_srvsvc_NetCharDevInfo(ndr, "info", r->out.info);

13458

ndr->depth--;

13459

ndr_print_WERROR(ndr, "result", r->out.result);

13460

ndr->depth--;

13461

}

13462

ndr->depth--;

13463

}

13464

13465

static enum ndr_err_code ndr_push_srvsvc_NetCharDevControl(struct ndr_push *ndr, int flags, const struct srvsvc_NetCharDevControl *r)

13466

{

13467

if (flags & NDR_IN) {

13468

NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server_unc));

13469

if (r->in.server_unc) {

13470

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_unc, CH_UTF16)));

13471

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));

13472

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_unc, CH_UTF16)));

13473

NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server_unc, ndr_charset_length(r->in.server_unc, CH_UTF16), sizeof(uint16_t), CH_UTF16));

13474

}

13475

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.device_name, CH_UTF16)));

13476

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));

13477

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.device_name, CH_UTF16)));

13478

NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.device_name, ndr_charset_length(r->in.device_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));

13479

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.opcode));

13480

}

13481

if (flags & NDR_OUT) {

13482

NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));

13483

}

13484

return NDR_ERR_SUCCESS;

13485

}

13486

13487

static enum ndr_err_code ndr_pull_srvsvc_NetCharDevControl(struct ndr_pull *ndr, int flags, struct srvsvc_NetCharDevControl *r)

13488

{

13489

uint32_t _ptr_server_unc;

13490

TALLOC_CTX *_mem_save_server_unc_0;

13491

if (flags & NDR_IN) {

13492

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_unc));

13493

if (_ptr_server_unc) {

13494

NDR_PULL_ALLOC(ndr, r->in.server_unc);

13495

} else {

13496

r->in.server_unc = NULL;

13497

}

13498

if (r->in.server_unc) {

13499

_mem_save_server_unc_0 = NDR_PULL_GET_MEM_CTX(ndr);

13500

NDR_PULL_SET_MEM_CTX(ndr, r->in.server_unc, 0);

13501

NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_unc));

13502

NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_unc));

13503

if (ndr_get_array_length(ndr, &r->in.server_unc) > ndr_get_array_size(ndr, &r->in.server_unc)) {

13504

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.server_unc), ndr_get_array_length(ndr, &r->in.server_unc));

13505

}

13506

NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server_unc), sizeof(uint16_t)));

13507

NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server_unc, ndr_get_array_length(ndr, &r->in.server_unc), sizeof(uint16_t), CH_UTF16));

13508

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_unc_0, 0);

13509

}

13510

NDR_CHECK(ndr_pull_array_size(ndr, &r->in.device_name));

13511

NDR_CHECK(ndr_pull_array_length(ndr, &r->in.device_name));

13512

if (ndr_get_array_length(ndr, &r->in.device_name) > ndr_get_array_size(ndr, &r->in.device_name)) {

13513

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.device_name), ndr_get_array_length(ndr, &r->in.device_name));

13514

}

13515

NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.device_name), sizeof(uint16_t)));

13516

NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.device_name, ndr_get_array_length(ndr, &r->in.device_name), sizeof(uint16_t), CH_UTF16));

13517

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.opcode));

13518

}

13519

if (flags & NDR_OUT) {

13520

NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));

13521

}

13522

return NDR_ERR_SUCCESS;

13523

}

13524

13525

_PUBLIC_ void ndr_print_srvsvc_NetCharDevControl(struct ndr_print *ndr, const char *name, int flags, const struct srvsvc_NetCharDevControl *r)

13526

{

13527

ndr_print_struct(ndr, name, "srvsvc_NetCharDevControl");

13528

ndr->depth++;

13529

if (flags & NDR_SET_VALUES) {

13530

ndr->flags |= LIBNDR_PRINT_SET_VALUES;

13531

}

13532

if (flags & NDR_IN) {

13533

ndr_print_struct(ndr, "in", "srvsvc_NetCharDevControl");

13534

ndr->depth++;

13535

ndr_print_ptr(ndr, "server_unc", r->in.server_unc);

13536

ndr->depth++;

13537

if (r->in.server_unc) {

13538

ndr_print_string(ndr, "server_unc", r->in.server_unc);

13539

}

13540

ndr->depth--;

13541

ndr_print_string(ndr, "device_name", r->in.device_name);

13542

ndr_print_uint32(ndr, "opcode", r->in.opcode);

13543

ndr->depth--;

13544

}

13545

if (flags & NDR_OUT) {

13546

ndr_print_struct(ndr, "out", "srvsvc_NetCharDevControl");

13547

ndr->depth++;

13548

ndr_print_WERROR(ndr, "result", r->out.result);

13549

ndr->depth--;

13550

}

13551

ndr->depth--;

13552

}

13553

13554

static enum ndr_err_code ndr_push_srvsvc_NetCharDevQEnum(struct ndr_push *ndr, int flags, const struct srvsvc_NetCharDevQEnum *r)

13555

{

13556

if (flags & NDR_IN) {

13557

NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server_unc));

13558

if (r->in.server_unc) {

13559

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_unc, CH_UTF16)));

13560

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));

13561

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_unc, CH_UTF16)));

13562

NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server_unc, ndr_charset_length(r->in.server_unc, CH_UTF16), sizeof(uint16_t), CH_UTF16));

13563

}

13564

NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.user));

13565

if (r->in.user) {

13566

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.user, CH_UTF16)));

13567

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));

13568

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.user, CH_UTF16)));

13569

NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.user, ndr_charset_length(r->in.user, CH_UTF16), sizeof(uint16_t), CH_UTF16));

13570

}

13571

if (r->in.info_ctr == NULL) {

13572

return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");

13573

}

13574

NDR_CHECK(ndr_push_srvsvc_NetCharDevQInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info_ctr));

13575

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.max_buffer));

13576

NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.resume_handle));

13577

if (r->in.resume_handle) {

13578

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->in.resume_handle));

13579

}

13580

}

13581

if (flags & NDR_OUT) {

13582

if (r->out.info_ctr == NULL) {

13583

return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");

13584

}

13585

NDR_CHECK(ndr_push_srvsvc_NetCharDevQInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.info_ctr));

13586

if (r->out.totalentries == NULL) {

13587

return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");

13588

}

13589

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.totalentries));

13590

NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.resume_handle));

13591

if (r->out.resume_handle) {

13592

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.resume_handle));

13593

}

13594

NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));

13595

}

13596

return NDR_ERR_SUCCESS;

13597

}

13598

13599

static enum ndr_err_code ndr_pull_srvsvc_NetCharDevQEnum(struct ndr_pull *ndr, int flags, struct srvsvc_NetCharDevQEnum *r)

13600

{

13601

uint32_t _ptr_server_unc;

13602

uint32_t _ptr_user;

13603

uint32_t _ptr_resume_handle;

13604

TALLOC_CTX *_mem_save_server_unc_0;

13605

TALLOC_CTX *_mem_save_user_0;

13606

TALLOC_CTX *_mem_save_info_ctr_0;

13607

TALLOC_CTX *_mem_save_totalentries_0;

13608

TALLOC_CTX *_mem_save_resume_handle_0;

13609

if (flags & NDR_IN) {

13610

ZERO_STRUCT(r->out);

13611

13612

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_unc));

13613

if (_ptr_server_unc) {

13614

NDR_PULL_ALLOC(ndr, r->in.server_unc);

13615

} else {

13616

r->in.server_unc = NULL;

13617

}

13618

if (r->in.server_unc) {

13619

_mem_save_server_unc_0 = NDR_PULL_GET_MEM_CTX(ndr);

13620

NDR_PULL_SET_MEM_CTX(ndr, r->in.server_unc, 0);

13621

NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_unc));

13622

NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_unc));

13623

if (ndr_get_array_length(ndr, &r->in.server_unc) > ndr_get_array_size(ndr, &r->in.server_unc)) {

13624

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.server_unc), ndr_get_array_length(ndr, &r->in.server_unc));

13625

}

13626

NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server_unc), sizeof(uint16_t)));

13627

NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server_unc, ndr_get_array_length(ndr, &r->in.server_unc), sizeof(uint16_t), CH_UTF16));

13628

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_unc_0, 0);

13629

}

13630

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_user));

13631

if (_ptr_user) {

13632

NDR_PULL_ALLOC(ndr, r->in.user);

13633

} else {

13634

r->in.user = NULL;

13635

}

13636

if (r->in.user) {

13637

_mem_save_user_0 = NDR_PULL_GET_MEM_CTX(ndr);

13638

NDR_PULL_SET_MEM_CTX(ndr, r->in.user, 0);

13639

NDR_CHECK(ndr_pull_array_size(ndr, &r->in.user));

13640

NDR_CHECK(ndr_pull_array_length(ndr, &r->in.user));

13641

if (ndr_get_array_length(ndr, &r->in.user) > ndr_get_array_size(ndr, &r->in.user)) {

13642

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.user), ndr_get_array_length(ndr, &r->in.user));

13643

}

13644

NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.user), sizeof(uint16_t)));

13645

NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.user, ndr_get_array_length(ndr, &r->in.user), sizeof(uint16_t), CH_UTF16));

13646

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_0, 0);

13647

}

13648

if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {

13649

NDR_PULL_ALLOC(ndr, r->in.info_ctr);

13650

}

13651

_mem_save_info_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);

13652

NDR_PULL_SET_MEM_CTX(ndr, r->in.info_ctr, LIBNDR_FLAG_REF_ALLOC);

13653

NDR_CHECK(ndr_pull_srvsvc_NetCharDevQInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info_ctr));

13654

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_ctr_0, LIBNDR_FLAG_REF_ALLOC);

13655

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.max_buffer));

13656

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_resume_handle));

13657

if (_ptr_resume_handle) {

13658

NDR_PULL_ALLOC(ndr, r->in.resume_handle);

13659

} else {

13660

r->in.resume_handle = NULL;

13661

}

13662

if (r->in.resume_handle) {

13663

_mem_save_resume_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);

13664

NDR_PULL_SET_MEM_CTX(ndr, r->in.resume_handle, 0);

13665

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->in.resume_handle));

13666

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_resume_handle_0, 0);

13667

}

13668

NDR_PULL_ALLOC(ndr, r->out.info_ctr);

13669

*r->out.info_ctr = *r->in.info_ctr;

13670

NDR_PULL_ALLOC(ndr, r->out.totalentries);

13671

ZERO_STRUCTP(r->out.totalentries);

13672

}

13673

if (flags & NDR_OUT) {

13674

if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {

13675

NDR_PULL_ALLOC(ndr, r->out.info_ctr);

13676

}

13677

_mem_save_info_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);

13678

NDR_PULL_SET_MEM_CTX(ndr, r->out.info_ctr, LIBNDR_FLAG_REF_ALLOC);

13679

NDR_CHECK(ndr_pull_srvsvc_NetCharDevQInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.info_ctr));

13680

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_ctr_0, LIBNDR_FLAG_REF_ALLOC);

13681

if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {

13682

NDR_PULL_ALLOC(ndr, r->out.totalentries);

13683

}

13684

_mem_save_totalentries_0 = NDR_PULL_GET_MEM_CTX(ndr);

13685

NDR_PULL_SET_MEM_CTX(ndr, r->out.totalentries, LIBNDR_FLAG_REF_ALLOC);

13686

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.totalentries));

13687

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_totalentries_0, LIBNDR_FLAG_REF_ALLOC);

13688

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_resume_handle));

13689

if (_ptr_resume_handle) {

13690

NDR_PULL_ALLOC(ndr, r->out.resume_handle);

13691

} else {

13692

r->out.resume_handle = NULL;

13693

}

13694

if (r->out.resume_handle) {

13695

_mem_save_resume_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);

13696

NDR_PULL_SET_MEM_CTX(ndr, r->out.resume_handle, 0);

13697

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.resume_handle));

13698

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_resume_handle_0, 0);

13699

}

13700

NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));

13701

}

13702

return NDR_ERR_SUCCESS;

13703

}

13704

13705

_PUBLIC_ void ndr_print_srvsvc_NetCharDevQEnum(struct ndr_print *ndr, const char *name, int flags, const struct srvsvc_NetCharDevQEnum *r)

13706

{

13707

ndr_print_struct(ndr, name, "srvsvc_NetCharDevQEnum");

13708

ndr->depth++;

13709

if (flags & NDR_SET_VALUES) {

13710

ndr->flags |= LIBNDR_PRINT_SET_VALUES;

13711

}

13712

if (flags & NDR_IN) {

13713

ndr_print_struct(ndr, "in", "srvsvc_NetCharDevQEnum");

13714

ndr->depth++;

13715

ndr_print_ptr(ndr, "server_unc", r->in.server_unc);

13716

ndr->depth++;

13717

if (r->in.server_unc) {

13718

ndr_print_string(ndr, "server_unc", r->in.server_unc);

13719

}

13720

ndr->depth--;

13721

ndr_print_ptr(ndr, "user", r->in.user);

13722

ndr->depth++;

13723

if (r->in.user) {

13724

ndr_print_string(ndr, "user", r->in.user);

13725

}

13726

ndr->depth--;

13727

ndr_print_ptr(ndr, "info_ctr", r->in.info_ctr);

13728

ndr->depth++;

13729

ndr_print_srvsvc_NetCharDevQInfoCtr(ndr, "info_ctr", r->in.info_ctr);

13730

ndr->depth--;

13731

ndr_print_uint32(ndr, "max_buffer", r->in.max_buffer);

13732

ndr_print_ptr(ndr, "resume_handle", r->in.resume_handle);

13733

ndr->depth++;

13734

if (r->in.resume_handle) {

13735

ndr_print_uint32(ndr, "resume_handle", *r->in.resume_handle);

13736

}

13737

ndr->depth--;

13738

ndr->depth--;

13739

}

13740

if (flags & NDR_OUT) {

13741

ndr_print_struct(ndr, "out", "srvsvc_NetCharDevQEnum");

13742

ndr->depth++;

13743

ndr_print_ptr(ndr, "info_ctr", r->out.info_ctr);

13744

ndr->depth++;

13745

ndr_print_srvsvc_NetCharDevQInfoCtr(ndr, "info_ctr", r->out.info_ctr);

13746

ndr->depth--;

13747

ndr_print_ptr(ndr, "totalentries", r->out.totalentries);

13748

ndr->depth++;

13749

ndr_print_uint32(ndr, "totalentries", *r->out.totalentries);

13750

ndr->depth--;

13751

ndr_print_ptr(ndr, "resume_handle", r->out.resume_handle);

13752

ndr->depth++;

13753

if (r->out.resume_handle) {

13754

ndr_print_uint32(ndr, "resume_handle", *r->out.resume_handle);

13755

}

13756

ndr->depth--;

13757

ndr_print_WERROR(ndr, "result", r->out.result);

13758

ndr->depth--;

13759

}

13760

ndr->depth--;

13761

}

13762

13763

static enum ndr_err_code ndr_push_srvsvc_NetCharDevQGetInfo(struct ndr_push *ndr, int flags, const struct srvsvc_NetCharDevQGetInfo *r)

13764

{

13765

if (flags & NDR_IN) {

13766

NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server_unc));

13767

if (r->in.server_unc) {

13768

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_unc, CH_UTF16)));

13769

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));

13770

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_unc, CH_UTF16)));

13771

NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server_unc, ndr_charset_length(r->in.server_unc, CH_UTF16), sizeof(uint16_t), CH_UTF16));

13772

}

13773

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.queue_name, CH_UTF16)));

13774

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));

13775

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.queue_name, CH_UTF16)));

13776

NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.queue_name, ndr_charset_length(r->in.queue_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));

13777

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.user, CH_UTF16)));

13778

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));

13779

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.user, CH_UTF16)));

13780

NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.user, ndr_charset_length(r->in.user, CH_UTF16), sizeof(uint16_t), CH_UTF16));

13781

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));

13782

}

13783

if (flags & NDR_OUT) {

13784

if (r->out.info == NULL) {

13785

return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");

13786

}

13787

NDR_CHECK(ndr_push_set_switch_value(ndr, r->out.info, r->in.level));

13788

NDR_CHECK(ndr_push_srvsvc_NetCharDevQInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.info));

13789

NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));

13790

}

13791

return NDR_ERR_SUCCESS;

13792

}

13793

13794

static enum ndr_err_code ndr_pull_srvsvc_NetCharDevQGetInfo(struct ndr_pull *ndr, int flags, struct srvsvc_NetCharDevQGetInfo *r)

13795

{

13796

uint32_t _ptr_server_unc;

13797

TALLOC_CTX *_mem_save_server_unc_0;

13798

TALLOC_CTX *_mem_save_info_0;

13799

if (flags & NDR_IN) {

13800

ZERO_STRUCT(r->out);

13801

13802

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_unc));

13803

if (_ptr_server_unc) {

13804

NDR_PULL_ALLOC(ndr, r->in.server_unc);

13805

} else {

13806

r->in.server_unc = NULL;

13807

}

13808

if (r->in.server_unc) {

13809

_mem_save_server_unc_0 = NDR_PULL_GET_MEM_CTX(ndr);

13810

NDR_PULL_SET_MEM_CTX(ndr, r->in.server_unc, 0);

13811

NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_unc));

13812

NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_unc));

13813

if (ndr_get_array_length(ndr, &r->in.server_unc) > ndr_get_array_size(ndr, &r->in.server_unc)) {

13814

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.server_unc), ndr_get_array_length(ndr, &r->in.server_unc));

13815

}

13816

NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server_unc), sizeof(uint16_t)));

13817

NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server_unc, ndr_get_array_length(ndr, &r->in.server_unc), sizeof(uint16_t), CH_UTF16));

13818

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_unc_0, 0);

13819

}

13820

NDR_CHECK(ndr_pull_array_size(ndr, &r->in.queue_name));

13821

NDR_CHECK(ndr_pull_array_length(ndr, &r->in.queue_name));

13822

if (ndr_get_array_length(ndr, &r->in.queue_name) > ndr_get_array_size(ndr, &r->in.queue_name)) {

13823

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.queue_name), ndr_get_array_length(ndr, &r->in.queue_name));

13824

}

13825

NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.queue_name), sizeof(uint16_t)));

13826

NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.queue_name, ndr_get_array_length(ndr, &r->in.queue_name), sizeof(uint16_t), CH_UTF16));

13827

NDR_CHECK(ndr_pull_array_size(ndr, &r->in.user));

13828

NDR_CHECK(ndr_pull_array_length(ndr, &r->in.user));

13829

if (ndr_get_array_length(ndr, &r->in.user) > ndr_get_array_size(ndr, &r->in.user)) {

13830

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.user), ndr_get_array_length(ndr, &r->in.user));

13831

}

13832

NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.user), sizeof(uint16_t)));

13833

NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.user, ndr_get_array_length(ndr, &r->in.user), sizeof(uint16_t), CH_UTF16));

13834

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));

13835

NDR_PULL_ALLOC(ndr, r->out.info);

13836

ZERO_STRUCTP(r->out.info);

13837

}

13838

if (flags & NDR_OUT) {

13839

if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {

13840

NDR_PULL_ALLOC(ndr, r->out.info);

13841

}

13842

_mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);

13843

NDR_PULL_SET_MEM_CTX(ndr, r->out.info, LIBNDR_FLAG_REF_ALLOC);

13844

NDR_CHECK(ndr_pull_set_switch_value(ndr, r->out.info, r->in.level));

13845

NDR_CHECK(ndr_pull_srvsvc_NetCharDevQInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.info));

13846

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, LIBNDR_FLAG_REF_ALLOC);

13847

NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));

13848

}

13849

return NDR_ERR_SUCCESS;

13850

}

13851

13852

_PUBLIC_ void ndr_print_srvsvc_NetCharDevQGetInfo(struct ndr_print *ndr, const char *name, int flags, const struct srvsvc_NetCharDevQGetInfo *r)

13853

{

13854

ndr_print_struct(ndr, name, "srvsvc_NetCharDevQGetInfo");

13855

ndr->depth++;

13856

if (flags & NDR_SET_VALUES) {

13857

ndr->flags |= LIBNDR_PRINT_SET_VALUES;

13858

}

13859

if (flags & NDR_IN) {

13860

ndr_print_struct(ndr, "in", "srvsvc_NetCharDevQGetInfo");

13861

ndr->depth++;

13862

ndr_print_ptr(ndr, "server_unc", r->in.server_unc);

13863

ndr->depth++;

13864

if (r->in.server_unc) {

13865

ndr_print_string(ndr, "server_unc", r->in.server_unc);

13866

}

13867

ndr->depth--;

13868

ndr_print_string(ndr, "queue_name", r->in.queue_name);

13869

ndr_print_string(ndr, "user", r->in.user);

13870

ndr_print_uint32(ndr, "level", r->in.level);

13871

ndr->depth--;

13872

}

13873

if (flags & NDR_OUT) {

13874

ndr_print_struct(ndr, "out", "srvsvc_NetCharDevQGetInfo");

13875

ndr->depth++;

13876

ndr_print_ptr(ndr, "info", r->out.info);

13877

ndr->depth++;

13878

ndr_print_set_switch_value(ndr, r->out.info, r->in.level);

13879

ndr_print_srvsvc_NetCharDevQInfo(ndr, "info", r->out.info);

13880

ndr->depth--;

13881

ndr_print_WERROR(ndr, "result", r->out.result);

13882

ndr->depth--;

13883

}

13884

ndr->depth--;

13885

}

13886

13887

static enum ndr_err_code ndr_push_srvsvc_NetCharDevQSetInfo(struct ndr_push *ndr, int flags, const struct srvsvc_NetCharDevQSetInfo *r)

13888

{

13889

if (flags & NDR_IN) {

13890

NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server_unc));

13891

if (r->in.server_unc) {

13892

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_unc, CH_UTF16)));

13893

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));

13894

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_unc, CH_UTF16)));

13895

NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server_unc, ndr_charset_length(r->in.server_unc, CH_UTF16), sizeof(uint16_t), CH_UTF16));

13896

}

13897

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.queue_name, CH_UTF16)));

13898

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));

13899

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.queue_name, CH_UTF16)));

13900

NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.queue_name, ndr_charset_length(r->in.queue_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));

13901

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));

13902

NDR_CHECK(ndr_push_set_switch_value(ndr, &r->in.info, r->in.level));

13903

NDR_CHECK(ndr_push_srvsvc_NetCharDevQInfo(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.info));

13904

NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.parm_error));

13905

if (r->in.parm_error) {

13906

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->in.parm_error));

13907

}

13908

}

13909

if (flags & NDR_OUT) {

13910

NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.parm_error));

13911

if (r->out.parm_error) {

13912

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.parm_error));

13913

}

13914

NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));

13915

}

13916

return NDR_ERR_SUCCESS;

13917

}

13918

13919

static enum ndr_err_code ndr_pull_srvsvc_NetCharDevQSetInfo(struct ndr_pull *ndr, int flags, struct srvsvc_NetCharDevQSetInfo *r)

13920

{

13921

uint32_t _ptr_server_unc;

13922

uint32_t _ptr_parm_error;

13923

TALLOC_CTX *_mem_save_server_unc_0;

13924

TALLOC_CTX *_mem_save_parm_error_0;

13925

if (flags & NDR_IN) {

13926

ZERO_STRUCT(r->out);

13927

13928

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_unc));

13929

if (_ptr_server_unc) {

13930

NDR_PULL_ALLOC(ndr, r->in.server_unc);

13931

} else {

13932

r->in.server_unc = NULL;

13933

}

13934

if (r->in.server_unc) {

13935

_mem_save_server_unc_0 = NDR_PULL_GET_MEM_CTX(ndr);

13936

NDR_PULL_SET_MEM_CTX(ndr, r->in.server_unc, 0);

13937

NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_unc));

13938

NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_unc));

13939

if (ndr_get_array_length(ndr, &r->in.server_unc) > ndr_get_array_size(ndr, &r->in.server_unc)) {

13940

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.server_unc), ndr_get_array_length(ndr, &r->in.server_unc));

13941

}

13942

NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server_unc), sizeof(uint16_t)));

13943

NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server_unc, ndr_get_array_length(ndr, &r->in.server_unc), sizeof(uint16_t), CH_UTF16));

13944

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_unc_0, 0);

13945

}

13946

NDR_CHECK(ndr_pull_array_size(ndr, &r->in.queue_name));

13947

NDR_CHECK(ndr_pull_array_length(ndr, &r->in.queue_name));

13948

if (ndr_get_array_length(ndr, &r->in.queue_name) > ndr_get_array_size(ndr, &r->in.queue_name)) {

13949

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.queue_name), ndr_get_array_length(ndr, &r->in.queue_name));

13950

}

13951

NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.queue_name), sizeof(uint16_t)));

13952

NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.queue_name, ndr_get_array_length(ndr, &r->in.queue_name), sizeof(uint16_t), CH_UTF16));

13953

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));

13954

NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->in.info, r->in.level));

13955

NDR_CHECK(ndr_pull_srvsvc_NetCharDevQInfo(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.info));

13956

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_parm_error));

13957

if (_ptr_parm_error) {

13958

NDR_PULL_ALLOC(ndr, r->in.parm_error);

13959

} else {

13960

r->in.parm_error = NULL;

13961

}

13962

if (r->in.parm_error) {

13963

_mem_save_parm_error_0 = NDR_PULL_GET_MEM_CTX(ndr);

13964

NDR_PULL_SET_MEM_CTX(ndr, r->in.parm_error, 0);

13965

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->in.parm_error));

13966

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_parm_error_0, 0);

13967

}

13968

}

13969

if (flags & NDR_OUT) {

13970

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_parm_error));

13971

if (_ptr_parm_error) {

13972

NDR_PULL_ALLOC(ndr, r->out.parm_error);

13973

} else {

13974

r->out.parm_error = NULL;

13975

}

13976

if (r->out.parm_error) {

13977

_mem_save_parm_error_0 = NDR_PULL_GET_MEM_CTX(ndr);

13978

NDR_PULL_SET_MEM_CTX(ndr, r->out.parm_error, 0);

13979

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.parm_error));

13980

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_parm_error_0, 0);

13981

}

13982

NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));

13983

}

13984

return NDR_ERR_SUCCESS;

13985

}

13986

13987

_PUBLIC_ void ndr_print_srvsvc_NetCharDevQSetInfo(struct ndr_print *ndr, const char *name, int flags, const struct srvsvc_NetCharDevQSetInfo *r)

13988

{

13989

ndr_print_struct(ndr, name, "srvsvc_NetCharDevQSetInfo");

13990

ndr->depth++;

13991

if (flags & NDR_SET_VALUES) {

13992

ndr->flags |= LIBNDR_PRINT_SET_VALUES;

13993

}

13994

if (flags & NDR_IN) {

13995

ndr_print_struct(ndr, "in", "srvsvc_NetCharDevQSetInfo");

13996

ndr->depth++;

13997

ndr_print_ptr(ndr, "server_unc", r->in.server_unc);

13998

ndr->depth++;

13999

if (r->in.server_unc) {

14000

ndr_print_string(ndr, "server_unc", r->in.server_unc);

14001

}

14002

ndr->depth--;

14003

ndr_print_string(ndr, "queue_name", r->in.queue_name);

14004

ndr_print_uint32(ndr, "level", r->in.level);

14005

ndr_print_set_switch_value(ndr, &r->in.info, r->in.level);

14006

ndr_print_srvsvc_NetCharDevQInfo(ndr, "info", &r->in.info);

14007

ndr_print_ptr(ndr, "parm_error", r->in.parm_error);

14008

ndr->depth++;

14009

if (r->in.parm_error) {

14010

ndr_print_uint32(ndr, "parm_error", *r->in.parm_error);

14011

}

14012

ndr->depth--;

14013

ndr->depth--;

14014

}

14015

if (flags & NDR_OUT) {

14016

ndr_print_struct(ndr, "out", "srvsvc_NetCharDevQSetInfo");

14017

ndr->depth++;

14018

ndr_print_ptr(ndr, "parm_error", r->out.parm_error);

14019

ndr->depth++;

14020

if (r->out.parm_error) {

14021

ndr_print_uint32(ndr, "parm_error", *r->out.parm_error);

14022

}

14023

ndr->depth--;

14024

ndr_print_WERROR(ndr, "result", r->out.result);

14025

ndr->depth--;

14026

}

14027

ndr->depth--;

14028

}

14029

14030

static enum ndr_err_code ndr_push_srvsvc_NetCharDevQPurge(struct ndr_push *ndr, int flags, const struct srvsvc_NetCharDevQPurge *r)

14031

{

14032

if (flags & NDR_IN) {

14033

NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server_unc));

14034

if (r->in.server_unc) {

14035

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_unc, CH_UTF16)));

14036

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));

14037

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_unc, CH_UTF16)));

14038

NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server_unc, ndr_charset_length(r->in.server_unc, CH_UTF16), sizeof(uint16_t), CH_UTF16));

14039

}

14040

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.queue_name, CH_UTF16)));

14041

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));

14042

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.queue_name, CH_UTF16)));

14043

NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.queue_name, ndr_charset_length(r->in.queue_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));

14044

}

14045

if (flags & NDR_OUT) {

14046

NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));

14047

}

14048

return NDR_ERR_SUCCESS;

14049

}

14050

14051

static enum ndr_err_code ndr_pull_srvsvc_NetCharDevQPurge(struct ndr_pull *ndr, int flags, struct srvsvc_NetCharDevQPurge *r)

14052

{

14053

uint32_t _ptr_server_unc;

14054

TALLOC_CTX *_mem_save_server_unc_0;

14055

if (flags & NDR_IN) {

14056

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_unc));

14057

if (_ptr_server_unc) {

14058

NDR_PULL_ALLOC(ndr, r->in.server_unc);

14059

} else {

14060

r->in.server_unc = NULL;

14061

}

14062

if (r->in.server_unc) {

14063

_mem_save_server_unc_0 = NDR_PULL_GET_MEM_CTX(ndr);

14064

NDR_PULL_SET_MEM_CTX(ndr, r->in.server_unc, 0);

14065

NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_unc));

14066

NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_unc));

14067

if (ndr_get_array_length(ndr, &r->in.server_unc) > ndr_get_array_size(ndr, &r->in.server_unc)) {

14068

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.server_unc), ndr_get_array_length(ndr, &r->in.server_unc));

14069

}

14070

NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server_unc), sizeof(uint16_t)));

14071

NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server_unc, ndr_get_array_length(ndr, &r->in.server_unc), sizeof(uint16_t), CH_UTF16));

14072

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_unc_0, 0);

14073

}

14074

NDR_CHECK(ndr_pull_array_size(ndr, &r->in.queue_name));

14075

NDR_CHECK(ndr_pull_array_length(ndr, &r->in.queue_name));

14076

if (ndr_get_array_length(ndr, &r->in.queue_name) > ndr_get_array_size(ndr, &r->in.queue_name)) {

14077

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.queue_name), ndr_get_array_length(ndr, &r->in.queue_name));

14078

}

14079

NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.queue_name), sizeof(uint16_t)));

14080

NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.queue_name, ndr_get_array_length(ndr, &r->in.queue_name), sizeof(uint16_t), CH_UTF16));

14081

}

14082

if (flags & NDR_OUT) {

14083

NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));

14084

}

14085

return NDR_ERR_SUCCESS;

14086

}

14087

14088

_PUBLIC_ void ndr_print_srvsvc_NetCharDevQPurge(struct ndr_print *ndr, const char *name, int flags, const struct srvsvc_NetCharDevQPurge *r)

14089

{

14090

ndr_print_struct(ndr, name, "srvsvc_NetCharDevQPurge");

14091

ndr->depth++;

14092

if (flags & NDR_SET_VALUES) {

14093

ndr->flags |= LIBNDR_PRINT_SET_VALUES;

14094

}

14095

if (flags & NDR_IN) {

14096

ndr_print_struct(ndr, "in", "srvsvc_NetCharDevQPurge");

14097

ndr->depth++;

14098

ndr_print_ptr(ndr, "server_unc", r->in.server_unc);

14099

ndr->depth++;

14100

if (r->in.server_unc) {

14101

ndr_print_string(ndr, "server_unc", r->in.server_unc);

14102

}

14103

ndr->depth--;

14104

ndr_print_string(ndr, "queue_name", r->in.queue_name);

14105

ndr->depth--;

14106

}

14107

if (flags & NDR_OUT) {

14108

ndr_print_struct(ndr, "out", "srvsvc_NetCharDevQPurge");

14109

ndr->depth++;

14110

ndr_print_WERROR(ndr, "result", r->out.result);

14111

ndr->depth--;

14112

}

14113

ndr->depth--;

14114

}

14115

14116

static enum ndr_err_code ndr_push_srvsvc_NetCharDevQPurgeSelf(struct ndr_push *ndr, int flags, const struct srvsvc_NetCharDevQPurgeSelf *r)

14117

{

14118

if (flags & NDR_IN) {

14119

NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server_unc));

14120

if (r->in.server_unc) {

14121

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_unc, CH_UTF16)));

14122

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));

14123

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_unc, CH_UTF16)));

14124

NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server_unc, ndr_charset_length(r->in.server_unc, CH_UTF16), sizeof(uint16_t), CH_UTF16));

14125

}

14126

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.queue_name, CH_UTF16)));

14127

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));

14128

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.queue_name, CH_UTF16)));

14129

NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.queue_name, ndr_charset_length(r->in.queue_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));

14130

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.computer_name, CH_UTF16)));

14131

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));

14132

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.computer_name, CH_UTF16)));

14133

NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.computer_name, ndr_charset_length(r->in.computer_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));

14134

}

14135

if (flags & NDR_OUT) {

14136

NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));

14137

}

14138

return NDR_ERR_SUCCESS;

14139

}

14140

14141

static enum ndr_err_code ndr_pull_srvsvc_NetCharDevQPurgeSelf(struct ndr_pull *ndr, int flags, struct srvsvc_NetCharDevQPurgeSelf *r)

14142

{

14143

uint32_t _ptr_server_unc;

14144

TALLOC_CTX *_mem_save_server_unc_0;

14145

if (flags & NDR_IN) {

14146

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_unc));

14147

if (_ptr_server_unc) {

14148

NDR_PULL_ALLOC(ndr, r->in.server_unc);

14149

} else {

14150

r->in.server_unc = NULL;

14151

}

14152

if (r->in.server_unc) {

14153

_mem_save_server_unc_0 = NDR_PULL_GET_MEM_CTX(ndr);

14154

NDR_PULL_SET_MEM_CTX(ndr, r->in.server_unc, 0);

14155

NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_unc));

14156

NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_unc));

14157

if (ndr_get_array_length(ndr, &r->in.server_unc) > ndr_get_array_size(ndr, &r->in.server_unc)) {

14158

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.server_unc), ndr_get_array_length(ndr, &r->in.server_unc));

14159

}

14160

NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server_unc), sizeof(uint16_t)));

14161

NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server_unc, ndr_get_array_length(ndr, &r->in.server_unc), sizeof(uint16_t), CH_UTF16));

14162

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_unc_0, 0);

14163

}

14164

NDR_CHECK(ndr_pull_array_size(ndr, &r->in.queue_name));

14165

NDR_CHECK(ndr_pull_array_length(ndr, &r->in.queue_name));

14166

if (ndr_get_array_length(ndr, &r->in.queue_name) > ndr_get_array_size(ndr, &r->in.queue_name)) {

14167

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.queue_name), ndr_get_array_length(ndr, &r->in.queue_name));

14168

}

14169

NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.queue_name), sizeof(uint16_t)));

14170

NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.queue_name, ndr_get_array_length(ndr, &r->in.queue_name), sizeof(uint16_t), CH_UTF16));

14171

NDR_CHECK(ndr_pull_array_size(ndr, &r->in.computer_name));

14172

NDR_CHECK(ndr_pull_array_length(ndr, &r->in.computer_name));

14173

if (ndr_get_array_length(ndr, &r->in.computer_name) > ndr_get_array_size(ndr, &r->in.computer_name)) {

14174

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.computer_name), ndr_get_array_length(ndr, &r->in.computer_name));

14175

}

14176

NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.computer_name), sizeof(uint16_t)));

14177

NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.computer_name, ndr_get_array_length(ndr, &r->in.computer_name), sizeof(uint16_t), CH_UTF16));

14178

}

14179

if (flags & NDR_OUT) {

14180

NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));

14181

}

14182

return NDR_ERR_SUCCESS;

14183

}

14184

14185

_PUBLIC_ void ndr_print_srvsvc_NetCharDevQPurgeSelf(struct ndr_print *ndr, const char *name, int flags, const struct srvsvc_NetCharDevQPurgeSelf *r)

14186

{

14187

ndr_print_struct(ndr, name, "srvsvc_NetCharDevQPurgeSelf");

14188

ndr->depth++;

14189

if (flags & NDR_SET_VALUES) {

14190

ndr->flags |= LIBNDR_PRINT_SET_VALUES;

14191

}

14192

if (flags & NDR_IN) {

14193

ndr_print_struct(ndr, "in", "srvsvc_NetCharDevQPurgeSelf");

14194

ndr->depth++;

14195

ndr_print_ptr(ndr, "server_unc", r->in.server_unc);

14196

ndr->depth++;

14197

if (r->in.server_unc) {

14198

ndr_print_string(ndr, "server_unc", r->in.server_unc);

14199

}

14200

ndr->depth--;

14201

ndr_print_string(ndr, "queue_name", r->in.queue_name);

14202

ndr_print_string(ndr, "computer_name", r->in.computer_name);

14203

ndr->depth--;

14204

}

14205

if (flags & NDR_OUT) {

14206

ndr_print_struct(ndr, "out", "srvsvc_NetCharDevQPurgeSelf");

14207

ndr->depth++;

14208

ndr_print_WERROR(ndr, "result", r->out.result);

14209

ndr->depth--;

14210

}

14211

ndr->depth--;

14212

}

14213

14214

static enum ndr_err_code ndr_push_srvsvc_NetConnEnum(struct ndr_push *ndr, int flags, const struct srvsvc_NetConnEnum *r)

14215

{

14216

if (flags & NDR_IN) {

14217

NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server_unc));

14218

if (r->in.server_unc) {

14219

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_unc, CH_UTF16)));

14220

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));

14221

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_unc, CH_UTF16)));

14222

NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server_unc, ndr_charset_length(r->in.server_unc, CH_UTF16), sizeof(uint16_t), CH_UTF16));

14223

}

14224

NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.path));

14225

if (r->in.path) {

14226

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.path, CH_UTF16)));

14227

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));

14228

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.path, CH_UTF16)));

14229

NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.path, ndr_charset_length(r->in.path, CH_UTF16), sizeof(uint16_t), CH_UTF16));

14230

}

14231

if (r->in.info_ctr == NULL) {

14232

return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");

14233

}

14234

NDR_CHECK(ndr_push_srvsvc_NetConnInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info_ctr));

14235

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.max_buffer));

14236

NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.resume_handle));

14237

if (r->in.resume_handle) {

14238

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->in.resume_handle));

14239

}

14240

}

14241

if (flags & NDR_OUT) {

14242

if (r->out.info_ctr == NULL) {

14243

return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");

14244

}

14245

NDR_CHECK(ndr_push_srvsvc_NetConnInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.info_ctr));

14246

if (r->out.totalentries == NULL) {

14247

return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");

14248

}

14249

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.totalentries));

14250

NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.resume_handle));

14251

if (r->out.resume_handle) {

14252

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.resume_handle));

14253

}

14254

NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));

14255

}

14256

return NDR_ERR_SUCCESS;

14257

}

14258

14259

static enum ndr_err_code ndr_pull_srvsvc_NetConnEnum(struct ndr_pull *ndr, int flags, struct srvsvc_NetConnEnum *r)

14260

{

14261

uint32_t _ptr_server_unc;

14262

uint32_t _ptr_path;

14263

uint32_t _ptr_resume_handle;

14264

TALLOC_CTX *_mem_save_server_unc_0;

14265

TALLOC_CTX *_mem_save_path_0;

14266

TALLOC_CTX *_mem_save_info_ctr_0;

14267

TALLOC_CTX *_mem_save_totalentries_0;

14268

TALLOC_CTX *_mem_save_resume_handle_0;

14269

if (flags & NDR_IN) {

14270

ZERO_STRUCT(r->out);

14271

14272

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_unc));

14273

if (_ptr_server_unc) {

14274

NDR_PULL_ALLOC(ndr, r->in.server_unc);

14275

} else {

14276

r->in.server_unc = NULL;

14277

}

14278

if (r->in.server_unc) {

14279

_mem_save_server_unc_0 = NDR_PULL_GET_MEM_CTX(ndr);

14280

NDR_PULL_SET_MEM_CTX(ndr, r->in.server_unc, 0);

14281

NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_unc));

14282

NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_unc));

14283

if (ndr_get_array_length(ndr, &r->in.server_unc) > ndr_get_array_size(ndr, &r->in.server_unc)) {

14284

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.server_unc), ndr_get_array_length(ndr, &r->in.server_unc));

14285

}

14286

NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server_unc), sizeof(uint16_t)));

14287

NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server_unc, ndr_get_array_length(ndr, &r->in.server_unc), sizeof(uint16_t), CH_UTF16));

14288

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_unc_0, 0);

14289

}

14290

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_path));

14291

if (_ptr_path) {

14292

NDR_PULL_ALLOC(ndr, r->in.path);

14293

} else {

14294

r->in.path = NULL;

14295

}

14296

if (r->in.path) {

14297

_mem_save_path_0 = NDR_PULL_GET_MEM_CTX(ndr);

14298

NDR_PULL_SET_MEM_CTX(ndr, r->in.path, 0);

14299

NDR_CHECK(ndr_pull_array_size(ndr, &r->in.path));

14300

NDR_CHECK(ndr_pull_array_length(ndr, &r->in.path));

14301

if (ndr_get_array_length(ndr, &r->in.path) > ndr_get_array_size(ndr, &r->in.path)) {

14302

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.path), ndr_get_array_length(ndr, &r->in.path));

14303

}

14304

NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.path), sizeof(uint16_t)));

14305

NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.path, ndr_get_array_length(ndr, &r->in.path), sizeof(uint16_t), CH_UTF16));

14306

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_path_0, 0);

14307

}

14308

if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {

14309

NDR_PULL_ALLOC(ndr, r->in.info_ctr);

14310

}

14311

_mem_save_info_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);

14312

NDR_PULL_SET_MEM_CTX(ndr, r->in.info_ctr, LIBNDR_FLAG_REF_ALLOC);

14313

NDR_CHECK(ndr_pull_srvsvc_NetConnInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info_ctr));

14314

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_ctr_0, LIBNDR_FLAG_REF_ALLOC);

14315

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.max_buffer));

14316

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_resume_handle));

14317

if (_ptr_resume_handle) {

14318

NDR_PULL_ALLOC(ndr, r->in.resume_handle);

14319

} else {

14320

r->in.resume_handle = NULL;

14321

}

14322

if (r->in.resume_handle) {

14323

_mem_save_resume_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);

14324

NDR_PULL_SET_MEM_CTX(ndr, r->in.resume_handle, 0);

14325

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->in.resume_handle));

14326

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_resume_handle_0, 0);

14327

}

14328

NDR_PULL_ALLOC(ndr, r->out.info_ctr);

14329

*r->out.info_ctr = *r->in.info_ctr;

14330

NDR_PULL_ALLOC(ndr, r->out.totalentries);

14331

ZERO_STRUCTP(r->out.totalentries);

14332

}

14333

if (flags & NDR_OUT) {

14334

if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {

14335

NDR_PULL_ALLOC(ndr, r->out.info_ctr);

14336

}

14337

_mem_save_info_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);

14338

NDR_PULL_SET_MEM_CTX(ndr, r->out.info_ctr, LIBNDR_FLAG_REF_ALLOC);

14339

NDR_CHECK(ndr_pull_srvsvc_NetConnInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.info_ctr));

14340

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_ctr_0, LIBNDR_FLAG_REF_ALLOC);

14341

if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {

14342

NDR_PULL_ALLOC(ndr, r->out.totalentries);

14343

}

14344

_mem_save_totalentries_0 = NDR_PULL_GET_MEM_CTX(ndr);

14345

NDR_PULL_SET_MEM_CTX(ndr, r->out.totalentries, LIBNDR_FLAG_REF_ALLOC);

14346

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.totalentries));

14347

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_totalentries_0, LIBNDR_FLAG_REF_ALLOC);

14348

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_resume_handle));

14349

if (_ptr_resume_handle) {

14350

NDR_PULL_ALLOC(ndr, r->out.resume_handle);

14351

} else {

14352

r->out.resume_handle = NULL;

14353

}

14354

if (r->out.resume_handle) {

14355

_mem_save_resume_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);

14356

NDR_PULL_SET_MEM_CTX(ndr, r->out.resume_handle, 0);

14357

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.resume_handle));

14358

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_resume_handle_0, 0);

14359

}

14360

NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));

14361

}

14362

return NDR_ERR_SUCCESS;

14363

}

14364

14365

_PUBLIC_ void ndr_print_srvsvc_NetConnEnum(struct ndr_print *ndr, const char *name, int flags, const struct srvsvc_NetConnEnum *r)

14366

{

14367

ndr_print_struct(ndr, name, "srvsvc_NetConnEnum");

14368

ndr->depth++;

14369

if (flags & NDR_SET_VALUES) {

14370

ndr->flags |= LIBNDR_PRINT_SET_VALUES;

14371

}

14372

if (flags & NDR_IN) {

14373

ndr_print_struct(ndr, "in", "srvsvc_NetConnEnum");

14374

ndr->depth++;

14375

ndr_print_ptr(ndr, "server_unc", r->in.server_unc);

14376

ndr->depth++;

14377

if (r->in.server_unc) {

14378

ndr_print_string(ndr, "server_unc", r->in.server_unc);

14379

}

14380

ndr->depth--;

14381

ndr_print_ptr(ndr, "path", r->in.path);

14382

ndr->depth++;

14383

if (r->in.path) {

14384

ndr_print_string(ndr, "path", r->in.path);

14385

}

14386

ndr->depth--;

14387

ndr_print_ptr(ndr, "info_ctr", r->in.info_ctr);

14388

ndr->depth++;

14389

ndr_print_srvsvc_NetConnInfoCtr(ndr, "info_ctr", r->in.info_ctr);

14390

ndr->depth--;

14391

ndr_print_uint32(ndr, "max_buffer", r->in.max_buffer);

14392

ndr_print_ptr(ndr, "resume_handle", r->in.resume_handle);

14393

ndr->depth++;

14394

if (r->in.resume_handle) {

14395

ndr_print_uint32(ndr, "resume_handle", *r->in.resume_handle);

14396

}

14397

ndr->depth--;

14398

ndr->depth--;

14399

}

14400

if (flags & NDR_OUT) {

14401

ndr_print_struct(ndr, "out", "srvsvc_NetConnEnum");

14402

ndr->depth++;

14403

ndr_print_ptr(ndr, "info_ctr", r->out.info_ctr);

14404

ndr->depth++;

14405

ndr_print_srvsvc_NetConnInfoCtr(ndr, "info_ctr", r->out.info_ctr);

14406

ndr->depth--;

14407

ndr_print_ptr(ndr, "totalentries", r->out.totalentries);

14408

ndr->depth++;

14409

ndr_print_uint32(ndr, "totalentries", *r->out.totalentries);

14410

ndr->depth--;

14411

ndr_print_ptr(ndr, "resume_handle", r->out.resume_handle);

14412

ndr->depth++;

14413

if (r->out.resume_handle) {

14414

ndr_print_uint32(ndr, "resume_handle", *r->out.resume_handle);

14415

}

14416

ndr->depth--;

14417

ndr_print_WERROR(ndr, "result", r->out.result);

14418

ndr->depth--;

14419

}

14420

ndr->depth--;

14421

}

14422

14423

static enum ndr_err_code ndr_push_srvsvc_NetFileEnum(struct ndr_push *ndr, int flags, const struct srvsvc_NetFileEnum *r)

14424

{

14425

if (flags & NDR_IN) {

14426

NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server_unc));

14427

if (r->in.server_unc) {

14428

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_unc, CH_UTF16)));

14429

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));

14430

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_unc, CH_UTF16)));

14431

NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server_unc, ndr_charset_length(r->in.server_unc, CH_UTF16), sizeof(uint16_t), CH_UTF16));

14432

}

14433

NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.path));

14434

if (r->in.path) {

14435

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.path, CH_UTF16)));

14436

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));

14437

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.path, CH_UTF16)));

14438

NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.path, ndr_charset_length(r->in.path, CH_UTF16), sizeof(uint16_t), CH_UTF16));

14439

}

14440

NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.user));

14441

if (r->in.user) {

14442

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.user, CH_UTF16)));

14443

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));

14444

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.user, CH_UTF16)));

14445

NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.user, ndr_charset_length(r->in.user, CH_UTF16), sizeof(uint16_t), CH_UTF16));

14446

}

14447

if (r->in.info_ctr == NULL) {

14448

return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");

14449

}

14450

NDR_CHECK(ndr_push_srvsvc_NetFileInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info_ctr));

14451

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.max_buffer));

14452

NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.resume_handle));

14453

if (r->in.resume_handle) {

14454

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->in.resume_handle));

14455

}

14456

}

14457

if (flags & NDR_OUT) {

14458

if (r->out.info_ctr == NULL) {

14459

return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");

14460

}

14461

NDR_CHECK(ndr_push_srvsvc_NetFileInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.info_ctr));

14462

if (r->out.totalentries == NULL) {

14463

return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");

14464

}

14465

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.totalentries));

14466

NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.resume_handle));

14467

if (r->out.resume_handle) {

14468

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.resume_handle));

14469

}

14470

NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));

14471

}

14472

return NDR_ERR_SUCCESS;

14473

}

14474

14475

static enum ndr_err_code ndr_pull_srvsvc_NetFileEnum(struct ndr_pull *ndr, int flags, struct srvsvc_NetFileEnum *r)

14476

{

14477

uint32_t _ptr_server_unc;

14478

uint32_t _ptr_path;

14479

uint32_t _ptr_user;

14480

uint32_t _ptr_resume_handle;

14481

TALLOC_CTX *_mem_save_server_unc_0;

14482

TALLOC_CTX *_mem_save_path_0;

14483

TALLOC_CTX *_mem_save_user_0;

14484

TALLOC_CTX *_mem_save_info_ctr_0;

14485

TALLOC_CTX *_mem_save_totalentries_0;

14486

TALLOC_CTX *_mem_save_resume_handle_0;

14487

if (flags & NDR_IN) {

14488

ZERO_STRUCT(r->out);

14489

14490

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_unc));

14491

if (_ptr_server_unc) {

14492

NDR_PULL_ALLOC(ndr, r->in.server_unc);

14493

} else {

14494

r->in.server_unc = NULL;

14495

}

14496

if (r->in.server_unc) {

14497

_mem_save_server_unc_0 = NDR_PULL_GET_MEM_CTX(ndr);

14498

NDR_PULL_SET_MEM_CTX(ndr, r->in.server_unc, 0);

14499

NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_unc));

14500

NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_unc));

14501

if (ndr_get_array_length(ndr, &r->in.server_unc) > ndr_get_array_size(ndr, &r->in.server_unc)) {

14502

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.server_unc), ndr_get_array_length(ndr, &r->in.server_unc));

14503

}

14504

NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server_unc), sizeof(uint16_t)));

14505

NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server_unc, ndr_get_array_length(ndr, &r->in.server_unc), sizeof(uint16_t), CH_UTF16));

14506

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_unc_0, 0);

14507

}

14508

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_path));

14509

if (_ptr_path) {

14510

NDR_PULL_ALLOC(ndr, r->in.path);

14511

} else {

14512

r->in.path = NULL;

14513

}

14514

if (r->in.path) {

14515

_mem_save_path_0 = NDR_PULL_GET_MEM_CTX(ndr);

14516

NDR_PULL_SET_MEM_CTX(ndr, r->in.path, 0);

14517

NDR_CHECK(ndr_pull_array_size(ndr, &r->in.path));

14518

NDR_CHECK(ndr_pull_array_length(ndr, &r->in.path));

14519

if (ndr_get_array_length(ndr, &r->in.path) > ndr_get_array_size(ndr, &r->in.path)) {

14520

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.path), ndr_get_array_length(ndr, &r->in.path));

14521

}

14522

NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.path), sizeof(uint16_t)));

14523

NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.path, ndr_get_array_length(ndr, &r->in.path), sizeof(uint16_t), CH_UTF16));

14524

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_path_0, 0);

14525

}

14526

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_user));

14527

if (_ptr_user) {

14528

NDR_PULL_ALLOC(ndr, r->in.user);

14529

} else {

14530

r->in.user = NULL;

14531

}

14532

if (r->in.user) {

14533

_mem_save_user_0 = NDR_PULL_GET_MEM_CTX(ndr);

14534

NDR_PULL_SET_MEM_CTX(ndr, r->in.user, 0);

14535

NDR_CHECK(ndr_pull_array_size(ndr, &r->in.user));

14536

NDR_CHECK(ndr_pull_array_length(ndr, &r->in.user));

14537

if (ndr_get_array_length(ndr, &r->in.user) > ndr_get_array_size(ndr, &r->in.user)) {

14538

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.user), ndr_get_array_length(ndr, &r->in.user));

14539

}

14540

NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.user), sizeof(uint16_t)));

14541

NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.user, ndr_get_array_length(ndr, &r->in.user), sizeof(uint16_t), CH_UTF16));

14542

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_0, 0);

14543

}

14544

if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {

14545

NDR_PULL_ALLOC(ndr, r->in.info_ctr);

14546

}

14547

_mem_save_info_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);

14548

NDR_PULL_SET_MEM_CTX(ndr, r->in.info_ctr, LIBNDR_FLAG_REF_ALLOC);

14549

NDR_CHECK(ndr_pull_srvsvc_NetFileInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info_ctr));

14550

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_ctr_0, LIBNDR_FLAG_REF_ALLOC);

14551

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.max_buffer));

14552

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_resume_handle));

14553

if (_ptr_resume_handle) {

14554

NDR_PULL_ALLOC(ndr, r->in.resume_handle);

14555

} else {

14556

r->in.resume_handle = NULL;

14557

}

14558

if (r->in.resume_handle) {

14559

_mem_save_resume_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);

14560

NDR_PULL_SET_MEM_CTX(ndr, r->in.resume_handle, 0);

14561

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->in.resume_handle));

14562

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_resume_handle_0, 0);

14563

}

14564

NDR_PULL_ALLOC(ndr, r->out.info_ctr);

14565

*r->out.info_ctr = *r->in.info_ctr;

14566

NDR_PULL_ALLOC(ndr, r->out.totalentries);

14567

ZERO_STRUCTP(r->out.totalentries);

14568

}

14569

if (flags & NDR_OUT) {

14570

if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {

14571

NDR_PULL_ALLOC(ndr, r->out.info_ctr);

14572

}

14573

_mem_save_info_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);

14574

NDR_PULL_SET_MEM_CTX(ndr, r->out.info_ctr, LIBNDR_FLAG_REF_ALLOC);

14575

NDR_CHECK(ndr_pull_srvsvc_NetFileInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.info_ctr));

14576

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_ctr_0, LIBNDR_FLAG_REF_ALLOC);

14577

if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {

14578

NDR_PULL_ALLOC(ndr, r->out.totalentries);

14579

}

14580

_mem_save_totalentries_0 = NDR_PULL_GET_MEM_CTX(ndr);

14581

NDR_PULL_SET_MEM_CTX(ndr, r->out.totalentries, LIBNDR_FLAG_REF_ALLOC);

14582

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.totalentries));

14583

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_totalentries_0, LIBNDR_FLAG_REF_ALLOC);

14584

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_resume_handle));

14585

if (_ptr_resume_handle) {

14586

NDR_PULL_ALLOC(ndr, r->out.resume_handle);

14587

} else {

14588

r->out.resume_handle = NULL;

14589

}

14590

if (r->out.resume_handle) {

14591

_mem_save_resume_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);

14592

NDR_PULL_SET_MEM_CTX(ndr, r->out.resume_handle, 0);

14593

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.resume_handle));

14594

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_resume_handle_0, 0);

14595

}

14596

NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));

14597

}

14598

return NDR_ERR_SUCCESS;

14599

}

14600

14601

_PUBLIC_ void ndr_print_srvsvc_NetFileEnum(struct ndr_print *ndr, const char *name, int flags, const struct srvsvc_NetFileEnum *r)

14602

{

14603

ndr_print_struct(ndr, name, "srvsvc_NetFileEnum");

14604

ndr->depth++;

14605

if (flags & NDR_SET_VALUES) {

14606

ndr->flags |= LIBNDR_PRINT_SET_VALUES;

14607

}

14608

if (flags & NDR_IN) {

14609

ndr_print_struct(ndr, "in", "srvsvc_NetFileEnum");

14610

ndr->depth++;

14611

ndr_print_ptr(ndr, "server_unc", r->in.server_unc);

14612

ndr->depth++;

14613

if (r->in.server_unc) {

14614

ndr_print_string(ndr, "server_unc", r->in.server_unc);

14615

}

14616

ndr->depth--;

14617

ndr_print_ptr(ndr, "path", r->in.path);

14618

ndr->depth++;

14619

if (r->in.path) {

14620

ndr_print_string(ndr, "path", r->in.path);

14621

}

14622

ndr->depth--;

14623

ndr_print_ptr(ndr, "user", r->in.user);

14624

ndr->depth++;

14625

if (r->in.user) {

14626

ndr_print_string(ndr, "user", r->in.user);

14627

}

14628

ndr->depth--;

14629

ndr_print_ptr(ndr, "info_ctr", r->in.info_ctr);

14630

ndr->depth++;

14631

ndr_print_srvsvc_NetFileInfoCtr(ndr, "info_ctr", r->in.info_ctr);

14632

ndr->depth--;

14633

ndr_print_uint32(ndr, "max_buffer", r->in.max_buffer);

14634

ndr_print_ptr(ndr, "resume_handle", r->in.resume_handle);

14635

ndr->depth++;

14636

if (r->in.resume_handle) {

14637

ndr_print_uint32(ndr, "resume_handle", *r->in.resume_handle);

14638

}

14639

ndr->depth--;

14640

ndr->depth--;

14641

}

14642

if (flags & NDR_OUT) {

14643

ndr_print_struct(ndr, "out", "srvsvc_NetFileEnum");

14644

ndr->depth++;

14645

ndr_print_ptr(ndr, "info_ctr", r->out.info_ctr);

14646

ndr->depth++;

14647

ndr_print_srvsvc_NetFileInfoCtr(ndr, "info_ctr", r->out.info_ctr);

14648

ndr->depth--;

14649

ndr_print_ptr(ndr, "totalentries", r->out.totalentries);

14650

ndr->depth++;

14651

ndr_print_uint32(ndr, "totalentries", *r->out.totalentries);

14652

ndr->depth--;

14653

ndr_print_ptr(ndr, "resume_handle", r->out.resume_handle);

14654

ndr->depth++;

14655

if (r->out.resume_handle) {

14656

ndr_print_uint32(ndr, "resume_handle", *r->out.resume_handle);

14657

}

14658

ndr->depth--;

14659

ndr_print_WERROR(ndr, "result", r->out.result);

14660

ndr->depth--;

14661

}

14662

ndr->depth--;

14663

}

14664

14665

static enum ndr_err_code ndr_push_srvsvc_NetFileGetInfo(struct ndr_push *ndr, int flags, const struct srvsvc_NetFileGetInfo *r)

14666

{

14667

if (flags & NDR_IN) {

14668

NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server_unc));

14669

if (r->in.server_unc) {

14670

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_unc, CH_UTF16)));

14671

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));

14672

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_unc, CH_UTF16)));

14673

NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server_unc, ndr_charset_length(r->in.server_unc, CH_UTF16), sizeof(uint16_t), CH_UTF16));

14674

}

14675

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.fid));

14676

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));

14677

}

14678

if (flags & NDR_OUT) {

14679

if (r->out.info == NULL) {

14680

return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");

14681

}

14682

NDR_CHECK(ndr_push_set_switch_value(ndr, r->out.info, r->in.level));

14683

NDR_CHECK(ndr_push_srvsvc_NetFileInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.info));

14684

NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));

14685

}

14686

return NDR_ERR_SUCCESS;

14687

}

14688

14689

static enum ndr_err_code ndr_pull_srvsvc_NetFileGetInfo(struct ndr_pull *ndr, int flags, struct srvsvc_NetFileGetInfo *r)

14690

{

14691

uint32_t _ptr_server_unc;

14692

TALLOC_CTX *_mem_save_server_unc_0;

14693

TALLOC_CTX *_mem_save_info_0;

14694

if (flags & NDR_IN) {

14695

ZERO_STRUCT(r->out);

14696

14697

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_unc));

14698

if (_ptr_server_unc) {

14699

NDR_PULL_ALLOC(ndr, r->in.server_unc);

14700

} else {

14701

r->in.server_unc = NULL;

14702

}

14703

if (r->in.server_unc) {

14704

_mem_save_server_unc_0 = NDR_PULL_GET_MEM_CTX(ndr);

14705

NDR_PULL_SET_MEM_CTX(ndr, r->in.server_unc, 0);

14706

NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_unc));

14707

NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_unc));

14708

if (ndr_get_array_length(ndr, &r->in.server_unc) > ndr_get_array_size(ndr, &r->in.server_unc)) {

14709

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.server_unc), ndr_get_array_length(ndr, &r->in.server_unc));

14710

}

14711

NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server_unc), sizeof(uint16_t)));

14712

NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server_unc, ndr_get_array_length(ndr, &r->in.server_unc), sizeof(uint16_t), CH_UTF16));

14713

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_unc_0, 0);

14714

}

14715

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.fid));

14716

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));

14717

NDR_PULL_ALLOC(ndr, r->out.info);

14718

ZERO_STRUCTP(r->out.info);

14719

}

14720

if (flags & NDR_OUT) {

14721

if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {

14722

NDR_PULL_ALLOC(ndr, r->out.info);

14723

}

14724

_mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);

14725

NDR_PULL_SET_MEM_CTX(ndr, r->out.info, LIBNDR_FLAG_REF_ALLOC);

14726

NDR_CHECK(ndr_pull_set_switch_value(ndr, r->out.info, r->in.level));

14727

NDR_CHECK(ndr_pull_srvsvc_NetFileInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.info));

14728

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, LIBNDR_FLAG_REF_ALLOC);

14729

NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));

14730

}

14731

return NDR_ERR_SUCCESS;

14732

}

14733

14734

_PUBLIC_ void ndr_print_srvsvc_NetFileGetInfo(struct ndr_print *ndr, const char *name, int flags, const struct srvsvc_NetFileGetInfo *r)

14735

{

14736

ndr_print_struct(ndr, name, "srvsvc_NetFileGetInfo");

14737

ndr->depth++;

14738

if (flags & NDR_SET_VALUES) {

14739

ndr->flags |= LIBNDR_PRINT_SET_VALUES;

14740

}

14741

if (flags & NDR_IN) {

14742

ndr_print_struct(ndr, "in", "srvsvc_NetFileGetInfo");

14743

ndr->depth++;

14744

ndr_print_ptr(ndr, "server_unc", r->in.server_unc);

14745

ndr->depth++;

14746

if (r->in.server_unc) {

14747

ndr_print_string(ndr, "server_unc", r->in.server_unc);

14748

}

14749

ndr->depth--;

14750

ndr_print_uint32(ndr, "fid", r->in.fid);

14751

ndr_print_uint32(ndr, "level", r->in.level);

14752

ndr->depth--;

14753

}

14754

if (flags & NDR_OUT) {

14755

ndr_print_struct(ndr, "out", "srvsvc_NetFileGetInfo");

14756

ndr->depth++;

14757

ndr_print_ptr(ndr, "info", r->out.info);

14758

ndr->depth++;

14759

ndr_print_set_switch_value(ndr, r->out.info, r->in.level);

14760

ndr_print_srvsvc_NetFileInfo(ndr, "info", r->out.info);

14761

ndr->depth--;

14762

ndr_print_WERROR(ndr, "result", r->out.result);

14763

ndr->depth--;

14764

}

14765

ndr->depth--;

14766

}

14767

14768

static enum ndr_err_code ndr_push_srvsvc_NetFileClose(struct ndr_push *ndr, int flags, const struct srvsvc_NetFileClose *r)

14769

{

14770

if (flags & NDR_IN) {

14771

NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server_unc));

14772

if (r->in.server_unc) {

14773

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_unc, CH_UTF16)));

14774

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));

14775

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_unc, CH_UTF16)));

14776

NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server_unc, ndr_charset_length(r->in.server_unc, CH_UTF16), sizeof(uint16_t), CH_UTF16));

14777

}

14778

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.fid));

14779

}

14780

if (flags & NDR_OUT) {

14781

NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));

14782

}

14783

return NDR_ERR_SUCCESS;

14784

}

14785

14786

static enum ndr_err_code ndr_pull_srvsvc_NetFileClose(struct ndr_pull *ndr, int flags, struct srvsvc_NetFileClose *r)

14787

{

14788

uint32_t _ptr_server_unc;

14789

TALLOC_CTX *_mem_save_server_unc_0;

14790

if (flags & NDR_IN) {

14791

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_unc));

14792

if (_ptr_server_unc) {

14793

NDR_PULL_ALLOC(ndr, r->in.server_unc);

14794

} else {

14795

r->in.server_unc = NULL;

14796

}

14797

if (r->in.server_unc) {

14798

_mem_save_server_unc_0 = NDR_PULL_GET_MEM_CTX(ndr);

14799

NDR_PULL_SET_MEM_CTX(ndr, r->in.server_unc, 0);

14800

NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_unc));

14801

NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_unc));

14802

if (ndr_get_array_length(ndr, &r->in.server_unc) > ndr_get_array_size(ndr, &r->in.server_unc)) {

14803

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.server_unc), ndr_get_array_length(ndr, &r->in.server_unc));

14804

}

14805

NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server_unc), sizeof(uint16_t)));

14806

NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server_unc, ndr_get_array_length(ndr, &r->in.server_unc), sizeof(uint16_t), CH_UTF16));

14807

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_unc_0, 0);

14808

}

14809

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.fid));

14810

}

14811

if (flags & NDR_OUT) {

14812

NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));

14813

}

14814

return NDR_ERR_SUCCESS;

14815

}

14816

14817

_PUBLIC_ void ndr_print_srvsvc_NetFileClose(struct ndr_print *ndr, const char *name, int flags, const struct srvsvc_NetFileClose *r)

14818

{

14819

ndr_print_struct(ndr, name, "srvsvc_NetFileClose");

14820

ndr->depth++;

14821

if (flags & NDR_SET_VALUES) {

14822

ndr->flags |= LIBNDR_PRINT_SET_VALUES;

14823

}

14824

if (flags & NDR_IN) {

14825

ndr_print_struct(ndr, "in", "srvsvc_NetFileClose");

14826

ndr->depth++;

14827

ndr_print_ptr(ndr, "server_unc", r->in.server_unc);

14828

ndr->depth++;

14829

if (r->in.server_unc) {

14830

ndr_print_string(ndr, "server_unc", r->in.server_unc);

14831

}

14832

ndr->depth--;

14833

ndr_print_uint32(ndr, "fid", r->in.fid);

14834

ndr->depth--;

14835

}

14836

if (flags & NDR_OUT) {

14837

ndr_print_struct(ndr, "out", "srvsvc_NetFileClose");

14838

ndr->depth++;

14839

ndr_print_WERROR(ndr, "result", r->out.result);

14840

ndr->depth--;

14841

}

14842

ndr->depth--;

14843

}

14844

14845

static enum ndr_err_code ndr_push_srvsvc_NetSessEnum(struct ndr_push *ndr, int flags, const struct srvsvc_NetSessEnum *r)

14846

{

14847

if (flags & NDR_IN) {

14848

NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server_unc));

14849

if (r->in.server_unc) {

14850

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_unc, CH_UTF16)));

14851

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));

14852

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_unc, CH_UTF16)));

14853

NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server_unc, ndr_charset_length(r->in.server_unc, CH_UTF16), sizeof(uint16_t), CH_UTF16));

14854

}

14855

NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.client));

14856

if (r->in.client) {

14857

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.client, CH_UTF16)));

14858

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));

14859

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.client, CH_UTF16)));

14860

NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.client, ndr_charset_length(r->in.client, CH_UTF16), sizeof(uint16_t), CH_UTF16));

14861

}

14862

NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.user));

14863

if (r->in.user) {

14864

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.user, CH_UTF16)));

14865

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));

14866

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.user, CH_UTF16)));

14867

NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.user, ndr_charset_length(r->in.user, CH_UTF16), sizeof(uint16_t), CH_UTF16));

14868

}

14869

if (r->in.info_ctr == NULL) {

14870

return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");

14871

}

14872

NDR_CHECK(ndr_push_srvsvc_NetSessInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info_ctr));

14873

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.max_buffer));

14874

NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.resume_handle));

14875

if (r->in.resume_handle) {

14876

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->in.resume_handle));

14877

}

14878

}

14879

if (flags & NDR_OUT) {

14880

if (r->out.info_ctr == NULL) {

14881

return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");

14882

}

14883

NDR_CHECK(ndr_push_srvsvc_NetSessInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.info_ctr));

14884

if (r->out.totalentries == NULL) {

14885

return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");

14886

}

14887

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.totalentries));

14888

NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.resume_handle));

14889

if (r->out.resume_handle) {

14890

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.resume_handle));

14891

}

14892

NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));

14893

}

14894

return NDR_ERR_SUCCESS;

14895

}

14896

14897

static enum ndr_err_code ndr_pull_srvsvc_NetSessEnum(struct ndr_pull *ndr, int flags, struct srvsvc_NetSessEnum *r)

14898

{

14899

uint32_t _ptr_server_unc;

14900

uint32_t _ptr_client;

14901

uint32_t _ptr_user;

14902

uint32_t _ptr_resume_handle;

14903

TALLOC_CTX *_mem_save_server_unc_0;

14904

TALLOC_CTX *_mem_save_client_0;

14905

TALLOC_CTX *_mem_save_user_0;

14906

TALLOC_CTX *_mem_save_info_ctr_0;

14907

TALLOC_CTX *_mem_save_totalentries_0;

14908

TALLOC_CTX *_mem_save_resume_handle_0;

14909

if (flags & NDR_IN) {

14910

ZERO_STRUCT(r->out);

14911

14912

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_unc));

14913

if (_ptr_server_unc) {

14914

NDR_PULL_ALLOC(ndr, r->in.server_unc);

14915

} else {

14916

r->in.server_unc = NULL;

14917

}

14918

if (r->in.server_unc) {

14919

_mem_save_server_unc_0 = NDR_PULL_GET_MEM_CTX(ndr);

14920

NDR_PULL_SET_MEM_CTX(ndr, r->in.server_unc, 0);

14921

NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_unc));

14922

NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_unc));

14923

if (ndr_get_array_length(ndr, &r->in.server_unc) > ndr_get_array_size(ndr, &r->in.server_unc)) {

14924

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.server_unc), ndr_get_array_length(ndr, &r->in.server_unc));

14925

}

14926

NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server_unc), sizeof(uint16_t)));

14927

NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server_unc, ndr_get_array_length(ndr, &r->in.server_unc), sizeof(uint16_t), CH_UTF16));

14928

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_unc_0, 0);

14929

}

14930

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_client));

14931

if (_ptr_client) {

14932

NDR_PULL_ALLOC(ndr, r->in.client);

14933

} else {

14934

r->in.client = NULL;

14935

}

14936

if (r->in.client) {

14937

_mem_save_client_0 = NDR_PULL_GET_MEM_CTX(ndr);

14938

NDR_PULL_SET_MEM_CTX(ndr, r->in.client, 0);

14939

NDR_CHECK(ndr_pull_array_size(ndr, &r->in.client));

14940

NDR_CHECK(ndr_pull_array_length(ndr, &r->in.client));

14941

if (ndr_get_array_length(ndr, &r->in.client) > ndr_get_array_size(ndr, &r->in.client)) {

14942

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.client), ndr_get_array_length(ndr, &r->in.client));

14943

}

14944

NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.client), sizeof(uint16_t)));

14945

NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.client, ndr_get_array_length(ndr, &r->in.client), sizeof(uint16_t), CH_UTF16));

14946

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_client_0, 0);

14947

}

14948

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_user));

14949

if (_ptr_user) {

14950

NDR_PULL_ALLOC(ndr, r->in.user);

14951

} else {

14952

r->in.user = NULL;

14953

}

14954

if (r->in.user) {

14955

_mem_save_user_0 = NDR_PULL_GET_MEM_CTX(ndr);

14956

NDR_PULL_SET_MEM_CTX(ndr, r->in.user, 0);

14957

NDR_CHECK(ndr_pull_array_size(ndr, &r->in.user));

14958

NDR_CHECK(ndr_pull_array_length(ndr, &r->in.user));

14959

if (ndr_get_array_length(ndr, &r->in.user) > ndr_get_array_size(ndr, &r->in.user)) {

14960

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.user), ndr_get_array_length(ndr, &r->in.user));

14961

}

14962

NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.user), sizeof(uint16_t)));

14963

NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.user, ndr_get_array_length(ndr, &r->in.user), sizeof(uint16_t), CH_UTF16));

14964

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_0, 0);

14965

}

14966

if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {

14967

NDR_PULL_ALLOC(ndr, r->in.info_ctr);

14968

}

14969

_mem_save_info_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);

14970

NDR_PULL_SET_MEM_CTX(ndr, r->in.info_ctr, LIBNDR_FLAG_REF_ALLOC);

14971

NDR_CHECK(ndr_pull_srvsvc_NetSessInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info_ctr));

14972

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_ctr_0, LIBNDR_FLAG_REF_ALLOC);

14973

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.max_buffer));

14974

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_resume_handle));

14975

if (_ptr_resume_handle) {

14976

NDR_PULL_ALLOC(ndr, r->in.resume_handle);

14977

} else {

14978

r->in.resume_handle = NULL;

14979

}

14980

if (r->in.resume_handle) {

14981

_mem_save_resume_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);

14982

NDR_PULL_SET_MEM_CTX(ndr, r->in.resume_handle, 0);

14983

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->in.resume_handle));

14984

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_resume_handle_0, 0);

14985

}

14986

NDR_PULL_ALLOC(ndr, r->out.info_ctr);

14987

*r->out.info_ctr = *r->in.info_ctr;

14988

NDR_PULL_ALLOC(ndr, r->out.totalentries);

14989

ZERO_STRUCTP(r->out.totalentries);

14990

}

14991

if (flags & NDR_OUT) {

14992

if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {

14993

NDR_PULL_ALLOC(ndr, r->out.info_ctr);

14994

}

14995

_mem_save_info_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);

14996

NDR_PULL_SET_MEM_CTX(ndr, r->out.info_ctr, LIBNDR_FLAG_REF_ALLOC);

14997

NDR_CHECK(ndr_pull_srvsvc_NetSessInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.info_ctr));

14998

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_ctr_0, LIBNDR_FLAG_REF_ALLOC);

14999

if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {

15000

NDR_PULL_ALLOC(ndr, r->out.totalentries);

15001

}

15002

_mem_save_totalentries_0 = NDR_PULL_GET_MEM_CTX(ndr);

15003

NDR_PULL_SET_MEM_CTX(ndr, r->out.totalentries, LIBNDR_FLAG_REF_ALLOC);

15004

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.totalentries));

15005

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_totalentries_0, LIBNDR_FLAG_REF_ALLOC);

15006

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_resume_handle));

15007

if (_ptr_resume_handle) {

15008

NDR_PULL_ALLOC(ndr, r->out.resume_handle);

15009

} else {

15010

r->out.resume_handle = NULL;

15011

}

15012

if (r->out.resume_handle) {

15013

_mem_save_resume_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);

15014

NDR_PULL_SET_MEM_CTX(ndr, r->out.resume_handle, 0);

15015

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.resume_handle));

15016

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_resume_handle_0, 0);

15017

}

15018

NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));

15019

}

15020

return NDR_ERR_SUCCESS;

15021

}

15022

15023

_PUBLIC_ void ndr_print_srvsvc_NetSessEnum(struct ndr_print *ndr, const char *name, int flags, const struct srvsvc_NetSessEnum *r)

15024

{

15025

ndr_print_struct(ndr, name, "srvsvc_NetSessEnum");

15026

ndr->depth++;

15027

if (flags & NDR_SET_VALUES) {

15028

ndr->flags |= LIBNDR_PRINT_SET_VALUES;

15029

}

15030

if (flags & NDR_IN) {

15031

ndr_print_struct(ndr, "in", "srvsvc_NetSessEnum");

15032

ndr->depth++;

15033

ndr_print_ptr(ndr, "server_unc", r->in.server_unc);

15034

ndr->depth++;

15035

if (r->in.server_unc) {

15036

ndr_print_string(ndr, "server_unc", r->in.server_unc);

15037

}

15038

ndr->depth--;

15039

ndr_print_ptr(ndr, "client", r->in.client);

15040

ndr->depth++;

15041

if (r->in.client) {

15042

ndr_print_string(ndr, "client", r->in.client);

15043

}

15044

ndr->depth--;

15045

ndr_print_ptr(ndr, "user", r->in.user);

15046

ndr->depth++;

15047

if (r->in.user) {

15048

ndr_print_string(ndr, "user", r->in.user);

15049

}

15050

ndr->depth--;

15051

ndr_print_ptr(ndr, "info_ctr", r->in.info_ctr);

15052

ndr->depth++;

15053

ndr_print_srvsvc_NetSessInfoCtr(ndr, "info_ctr", r->in.info_ctr);

15054

ndr->depth--;

15055

ndr_print_uint32(ndr, "max_buffer", r->in.max_buffer);

15056

ndr_print_ptr(ndr, "resume_handle", r->in.resume_handle);

15057

ndr->depth++;

15058

if (r->in.resume_handle) {

15059

ndr_print_uint32(ndr, "resume_handle", *r->in.resume_handle);

15060

}

15061

ndr->depth--;

15062

ndr->depth--;

15063

}

15064

if (flags & NDR_OUT) {

15065

ndr_print_struct(ndr, "out", "srvsvc_NetSessEnum");

15066

ndr->depth++;

15067

ndr_print_ptr(ndr, "info_ctr", r->out.info_ctr);

15068

ndr->depth++;

15069

ndr_print_srvsvc_NetSessInfoCtr(ndr, "info_ctr", r->out.info_ctr);

15070

ndr->depth--;

15071

ndr_print_ptr(ndr, "totalentries", r->out.totalentries);

15072

ndr->depth++;

15073

ndr_print_uint32(ndr, "totalentries", *r->out.totalentries);

15074

ndr->depth--;

15075

ndr_print_ptr(ndr, "resume_handle", r->out.resume_handle);

15076

ndr->depth++;

15077

if (r->out.resume_handle) {

15078

ndr_print_uint32(ndr, "resume_handle", *r->out.resume_handle);

15079

}

15080

ndr->depth--;

15081

ndr_print_WERROR(ndr, "result", r->out.result);

15082

ndr->depth--;

15083

}

15084

ndr->depth--;

15085

}

15086

15087

static enum ndr_err_code ndr_push_srvsvc_NetSessDel(struct ndr_push *ndr, int flags, const struct srvsvc_NetSessDel *r)

15088

{

15089

if (flags & NDR_IN) {

15090

NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server_unc));

15091

if (r->in.server_unc) {

15092

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_unc, CH_UTF16)));

15093

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));

15094

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_unc, CH_UTF16)));

15095

NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server_unc, ndr_charset_length(r->in.server_unc, CH_UTF16), sizeof(uint16_t), CH_UTF16));

15096

}

15097

NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.client));

15098

if (r->in.client) {

15099

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.client, CH_UTF16)));

15100

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));

15101

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.client, CH_UTF16)));

15102

NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.client, ndr_charset_length(r->in.client, CH_UTF16), sizeof(uint16_t), CH_UTF16));

15103

}

15104

NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.user));

15105

if (r->in.user) {

15106

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.user, CH_UTF16)));

15107

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));

15108

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.user, CH_UTF16)));

15109

NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.user, ndr_charset_length(r->in.user, CH_UTF16), sizeof(uint16_t), CH_UTF16));

15110

}

15111

}

15112

if (flags & NDR_OUT) {

15113

NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));

15114

}

15115

return NDR_ERR_SUCCESS;

15116

}

15117

15118

static enum ndr_err_code ndr_pull_srvsvc_NetSessDel(struct ndr_pull *ndr, int flags, struct srvsvc_NetSessDel *r)

15119

{

15120

uint32_t _ptr_server_unc;

15121

uint32_t _ptr_client;

15122

uint32_t _ptr_user;

15123

TALLOC_CTX *_mem_save_server_unc_0;

15124

TALLOC_CTX *_mem_save_client_0;

15125

TALLOC_CTX *_mem_save_user_0;

15126

if (flags & NDR_IN) {

15127

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_unc));

15128

if (_ptr_server_unc) {

15129

NDR_PULL_ALLOC(ndr, r->in.server_unc);

15130

} else {

15131

r->in.server_unc = NULL;

15132

}

15133

if (r->in.server_unc) {

15134

_mem_save_server_unc_0 = NDR_PULL_GET_MEM_CTX(ndr);

15135

NDR_PULL_SET_MEM_CTX(ndr, r->in.server_unc, 0);

15136

NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_unc));

15137

NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_unc));

15138

if (ndr_get_array_length(ndr, &r->in.server_unc) > ndr_get_array_size(ndr, &r->in.server_unc)) {

15139

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.server_unc), ndr_get_array_length(ndr, &r->in.server_unc));

15140

}

15141

NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server_unc), sizeof(uint16_t)));

15142

NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server_unc, ndr_get_array_length(ndr, &r->in.server_unc), sizeof(uint16_t), CH_UTF16));

15143

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_unc_0, 0);

15144

}

15145

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_client));

15146

if (_ptr_client) {

15147

NDR_PULL_ALLOC(ndr, r->in.client);

15148

} else {

15149

r->in.client = NULL;

15150

}

15151

if (r->in.client) {

15152

_mem_save_client_0 = NDR_PULL_GET_MEM_CTX(ndr);

15153

NDR_PULL_SET_MEM_CTX(ndr, r->in.client, 0);

15154

NDR_CHECK(ndr_pull_array_size(ndr, &r->in.client));

15155

NDR_CHECK(ndr_pull_array_length(ndr, &r->in.client));

15156

if (ndr_get_array_length(ndr, &r->in.client) > ndr_get_array_size(ndr, &r->in.client)) {

15157

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.client), ndr_get_array_length(ndr, &r->in.client));

15158

}

15159

NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.client), sizeof(uint16_t)));

15160

NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.client, ndr_get_array_length(ndr, &r->in.client), sizeof(uint16_t), CH_UTF16));

15161

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_client_0, 0);

15162

}

15163

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_user));

15164

if (_ptr_user) {

15165

NDR_PULL_ALLOC(ndr, r->in.user);

15166

} else {

15167

r->in.user = NULL;

15168

}

15169

if (r->in.user) {

15170

_mem_save_user_0 = NDR_PULL_GET_MEM_CTX(ndr);

15171

NDR_PULL_SET_MEM_CTX(ndr, r->in.user, 0);

15172

NDR_CHECK(ndr_pull_array_size(ndr, &r->in.user));

15173

NDR_CHECK(ndr_pull_array_length(ndr, &r->in.user));

15174

if (ndr_get_array_length(ndr, &r->in.user) > ndr_get_array_size(ndr, &r->in.user)) {

15175

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.user), ndr_get_array_length(ndr, &r->in.user));

15176

}

15177

NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.user), sizeof(uint16_t)));

15178

NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.user, ndr_get_array_length(ndr, &r->in.user), sizeof(uint16_t), CH_UTF16));

15179

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_0, 0);

15180

}

15181

}

15182

if (flags & NDR_OUT) {

15183

NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));

15184

}

15185

return NDR_ERR_SUCCESS;

15186

}

15187

15188

_PUBLIC_ void ndr_print_srvsvc_NetSessDel(struct ndr_print *ndr, const char *name, int flags, const struct srvsvc_NetSessDel *r)

15189

{

15190

ndr_print_struct(ndr, name, "srvsvc_NetSessDel");

15191

ndr->depth++;

15192

if (flags & NDR_SET_VALUES) {

15193

ndr->flags |= LIBNDR_PRINT_SET_VALUES;

15194

}

15195

if (flags & NDR_IN) {

15196

ndr_print_struct(ndr, "in", "srvsvc_NetSessDel");

15197

ndr->depth++;

15198

ndr_print_ptr(ndr, "server_unc", r->in.server_unc);

15199

ndr->depth++;

15200

if (r->in.server_unc) {

15201

ndr_print_string(ndr, "server_unc", r->in.server_unc);

15202

}

15203

ndr->depth--;

15204

ndr_print_ptr(ndr, "client", r->in.client);

15205

ndr->depth++;

15206

if (r->in.client) {

15207

ndr_print_string(ndr, "client", r->in.client);

15208

}

15209

ndr->depth--;

15210

ndr_print_ptr(ndr, "user", r->in.user);

15211

ndr->depth++;

15212

if (r->in.user) {

15213

ndr_print_string(ndr, "user", r->in.user);

15214

}

15215

ndr->depth--;

15216

ndr->depth--;

15217

}

15218

if (flags & NDR_OUT) {

15219

ndr_print_struct(ndr, "out", "srvsvc_NetSessDel");

15220

ndr->depth++;

15221

ndr_print_WERROR(ndr, "result", r->out.result);

15222

ndr->depth--;

15223

}

15224

ndr->depth--;

15225

}

15226

15227

static enum ndr_err_code ndr_push_srvsvc_NetShareAdd(struct ndr_push *ndr, int flags, const struct srvsvc_NetShareAdd *r)

15228

{

15229

if (flags & NDR_IN) {

15230

NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server_unc));

15231

if (r->in.server_unc) {

15232

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_unc, CH_UTF16)));

15233

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));

15234

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_unc, CH_UTF16)));

15235

NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server_unc, ndr_charset_length(r->in.server_unc, CH_UTF16), sizeof(uint16_t), CH_UTF16));

15236

}

15237

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));

15238

if (r->in.info == NULL) {

15239

return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");

15240

}

15241

NDR_CHECK(ndr_push_set_switch_value(ndr, r->in.info, r->in.level));

15242

NDR_CHECK(ndr_push_srvsvc_NetShareInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info));

15243

NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.parm_error));

15244

if (r->in.parm_error) {

15245

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->in.parm_error));

15246

}

15247

}

15248

if (flags & NDR_OUT) {

15249

NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.parm_error));

15250

if (r->out.parm_error) {

15251

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.parm_error));

15252

}

15253

NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));

15254

}

15255

return NDR_ERR_SUCCESS;

15256

}

15257

15258

static enum ndr_err_code ndr_pull_srvsvc_NetShareAdd(struct ndr_pull *ndr, int flags, struct srvsvc_NetShareAdd *r)

15259

{

15260

uint32_t _ptr_server_unc;

15261

uint32_t _ptr_parm_error;

15262

TALLOC_CTX *_mem_save_server_unc_0;

15263

TALLOC_CTX *_mem_save_info_0;

15264

TALLOC_CTX *_mem_save_parm_error_0;

15265

if (flags & NDR_IN) {

15266

ZERO_STRUCT(r->out);

15267

15268

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_unc));

15269

if (_ptr_server_unc) {

15270

NDR_PULL_ALLOC(ndr, r->in.server_unc);

15271

} else {

15272

r->in.server_unc = NULL;

15273

}

15274

if (r->in.server_unc) {

15275

_mem_save_server_unc_0 = NDR_PULL_GET_MEM_CTX(ndr);

15276

NDR_PULL_SET_MEM_CTX(ndr, r->in.server_unc, 0);

15277

NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_unc));

15278

NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_unc));

15279

if (ndr_get_array_length(ndr, &r->in.server_unc) > ndr_get_array_size(ndr, &r->in.server_unc)) {

15280

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.server_unc), ndr_get_array_length(ndr, &r->in.server_unc));

15281

}

15282

NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server_unc), sizeof(uint16_t)));

15283

NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server_unc, ndr_get_array_length(ndr, &r->in.server_unc), sizeof(uint16_t), CH_UTF16));

15284

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_unc_0, 0);

15285

}

15286

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));

15287

if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {

15288

NDR_PULL_ALLOC(ndr, r->in.info);

15289

}

15290

_mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);

15291

NDR_PULL_SET_MEM_CTX(ndr, r->in.info, LIBNDR_FLAG_REF_ALLOC);

15292

NDR_CHECK(ndr_pull_set_switch_value(ndr, r->in.info, r->in.level));

15293

NDR_CHECK(ndr_pull_srvsvc_NetShareInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info));

15294

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, LIBNDR_FLAG_REF_ALLOC);

15295

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_parm_error));

15296

if (_ptr_parm_error) {

15297

NDR_PULL_ALLOC(ndr, r->in.parm_error);

15298

} else {

15299

r->in.parm_error = NULL;

15300

}

15301

if (r->in.parm_error) {

15302

_mem_save_parm_error_0 = NDR_PULL_GET_MEM_CTX(ndr);

15303

NDR_PULL_SET_MEM_CTX(ndr, r->in.parm_error, 0);

15304

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->in.parm_error));

15305

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_parm_error_0, 0);

15306

}

15307

}

15308

if (flags & NDR_OUT) {

15309

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_parm_error));

15310

if (_ptr_parm_error) {

15311

NDR_PULL_ALLOC(ndr, r->out.parm_error);

15312

} else {

15313

r->out.parm_error = NULL;

15314

}

15315

if (r->out.parm_error) {

15316

_mem_save_parm_error_0 = NDR_PULL_GET_MEM_CTX(ndr);

15317

NDR_PULL_SET_MEM_CTX(ndr, r->out.parm_error, 0);

15318

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.parm_error));

15319

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_parm_error_0, 0);

15320

}

15321

NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));

15322

}

15323

return NDR_ERR_SUCCESS;

15324

}

15325

15326

_PUBLIC_ void ndr_print_srvsvc_NetShareAdd(struct ndr_print *ndr, const char *name, int flags, const struct srvsvc_NetShareAdd *r)

15327

{

15328

ndr_print_struct(ndr, name, "srvsvc_NetShareAdd");

15329

ndr->depth++;

15330

if (flags & NDR_SET_VALUES) {

15331

ndr->flags |= LIBNDR_PRINT_SET_VALUES;

15332

}

15333

if (flags & NDR_IN) {

15334

ndr_print_struct(ndr, "in", "srvsvc_NetShareAdd");

15335

ndr->depth++;

15336

ndr_print_ptr(ndr, "server_unc", r->in.server_unc);

15337

ndr->depth++;

15338

if (r->in.server_unc) {

15339

ndr_print_string(ndr, "server_unc", r->in.server_unc);

15340

}

15341

ndr->depth--;

15342

ndr_print_uint32(ndr, "level", r->in.level);

15343

ndr_print_ptr(ndr, "info", r->in.info);

15344

ndr->depth++;

15345

ndr_print_set_switch_value(ndr, r->in.info, r->in.level);

15346

ndr_print_srvsvc_NetShareInfo(ndr, "info", r->in.info);

15347

ndr->depth--;

15348

ndr_print_ptr(ndr, "parm_error", r->in.parm_error);

15349

ndr->depth++;

15350

if (r->in.parm_error) {

15351

ndr_print_uint32(ndr, "parm_error", *r->in.parm_error);

15352

}

15353

ndr->depth--;

15354

ndr->depth--;

15355

}

15356

if (flags & NDR_OUT) {

15357

ndr_print_struct(ndr, "out", "srvsvc_NetShareAdd");

15358

ndr->depth++;

15359

ndr_print_ptr(ndr, "parm_error", r->out.parm_error);

15360

ndr->depth++;

15361

if (r->out.parm_error) {

15362

ndr_print_uint32(ndr, "parm_error", *r->out.parm_error);

15363

}

15364

ndr->depth--;

15365

ndr_print_WERROR(ndr, "result", r->out.result);

15366

ndr->depth--;

15367

}

15368

ndr->depth--;

15369

}

15370

15371

static enum ndr_err_code ndr_push_srvsvc_NetShareEnumAll(struct ndr_push *ndr, int flags, const struct srvsvc_NetShareEnumAll *r)

15372

{

15373

if (flags & NDR_IN) {

15374

NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server_unc));

15375

if (r->in.server_unc) {

15376

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_unc, CH_UTF16)));

15377

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));

15378

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_unc, CH_UTF16)));

15379

NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server_unc, ndr_charset_length(r->in.server_unc, CH_UTF16), sizeof(uint16_t), CH_UTF16));

15380

}

15381

if (r->in.info_ctr == NULL) {

15382

return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");

15383

}

15384

NDR_CHECK(ndr_push_srvsvc_NetShareInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info_ctr));

15385

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.max_buffer));

15386

NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.resume_handle));

15387

if (r->in.resume_handle) {

15388

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->in.resume_handle));

15389

}

15390

}

15391

if (flags & NDR_OUT) {

15392

if (r->out.info_ctr == NULL) {

15393

return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");

15394

}

15395

NDR_CHECK(ndr_push_srvsvc_NetShareInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.info_ctr));

15396

if (r->out.totalentries == NULL) {

15397

return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");

15398

}

15399

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.totalentries));

15400

NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.resume_handle));

15401

if (r->out.resume_handle) {

15402

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.resume_handle));

15403

}

15404

NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));

15405

}

15406

return NDR_ERR_SUCCESS;

15407

}

15408

15409

static enum ndr_err_code ndr_pull_srvsvc_NetShareEnumAll(struct ndr_pull *ndr, int flags, struct srvsvc_NetShareEnumAll *r)

15410

{

15411

uint32_t _ptr_server_unc;

15412

uint32_t _ptr_resume_handle;

15413

TALLOC_CTX *_mem_save_server_unc_0;

15414

TALLOC_CTX *_mem_save_info_ctr_0;

15415

TALLOC_CTX *_mem_save_totalentries_0;

15416

TALLOC_CTX *_mem_save_resume_handle_0;

15417

if (flags & NDR_IN) {

15418

ZERO_STRUCT(r->out);

15419

15420

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_unc));

15421

if (_ptr_server_unc) {

15422

NDR_PULL_ALLOC(ndr, r->in.server_unc);

15423

} else {

15424

r->in.server_unc = NULL;

15425

}

15426

if (r->in.server_unc) {

15427

_mem_save_server_unc_0 = NDR_PULL_GET_MEM_CTX(ndr);

15428

NDR_PULL_SET_MEM_CTX(ndr, r->in.server_unc, 0);

15429

NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_unc));

15430

NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_unc));

15431

if (ndr_get_array_length(ndr, &r->in.server_unc) > ndr_get_array_size(ndr, &r->in.server_unc)) {

15432

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.server_unc), ndr_get_array_length(ndr, &r->in.server_unc));

15433

}

15434

NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server_unc), sizeof(uint16_t)));

15435

NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server_unc, ndr_get_array_length(ndr, &r->in.server_unc), sizeof(uint16_t), CH_UTF16));

15436

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_unc_0, 0);

15437

}

15438

if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {

15439

NDR_PULL_ALLOC(ndr, r->in.info_ctr);

15440

}

15441

_mem_save_info_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);

15442

NDR_PULL_SET_MEM_CTX(ndr, r->in.info_ctr, LIBNDR_FLAG_REF_ALLOC);

15443

NDR_CHECK(ndr_pull_srvsvc_NetShareInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info_ctr));

15444

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_ctr_0, LIBNDR_FLAG_REF_ALLOC);

15445

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.max_buffer));

15446

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_resume_handle));

15447

if (_ptr_resume_handle) {

15448

NDR_PULL_ALLOC(ndr, r->in.resume_handle);

15449

} else {

15450

r->in.resume_handle = NULL;

15451

}

15452

if (r->in.resume_handle) {

15453

_mem_save_resume_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);

15454

NDR_PULL_SET_MEM_CTX(ndr, r->in.resume_handle, 0);

15455

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->in.resume_handle));

15456

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_resume_handle_0, 0);

15457

}

15458

NDR_PULL_ALLOC(ndr, r->out.info_ctr);

15459

*r->out.info_ctr = *r->in.info_ctr;

15460

NDR_PULL_ALLOC(ndr, r->out.totalentries);

15461

ZERO_STRUCTP(r->out.totalentries);

15462

}

15463

if (flags & NDR_OUT) {

15464

if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {

15465

NDR_PULL_ALLOC(ndr, r->out.info_ctr);

15466

}

15467

_mem_save_info_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);

15468

NDR_PULL_SET_MEM_CTX(ndr, r->out.info_ctr, LIBNDR_FLAG_REF_ALLOC);

15469

NDR_CHECK(ndr_pull_srvsvc_NetShareInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.info_ctr));

15470

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_ctr_0, LIBNDR_FLAG_REF_ALLOC);

15471

if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {

15472

NDR_PULL_ALLOC(ndr, r->out.totalentries);

15473

}

15474

_mem_save_totalentries_0 = NDR_PULL_GET_MEM_CTX(ndr);

15475

NDR_PULL_SET_MEM_CTX(ndr, r->out.totalentries, LIBNDR_FLAG_REF_ALLOC);

15476

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.totalentries));

15477

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_totalentries_0, LIBNDR_FLAG_REF_ALLOC);

15478

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_resume_handle));

15479

if (_ptr_resume_handle) {

15480

NDR_PULL_ALLOC(ndr, r->out.resume_handle);

15481

} else {

15482

r->out.resume_handle = NULL;

15483

}

15484

if (r->out.resume_handle) {

15485

_mem_save_resume_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);

15486

NDR_PULL_SET_MEM_CTX(ndr, r->out.resume_handle, 0);

15487

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.resume_handle));

15488

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_resume_handle_0, 0);

15489

}

15490

NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));

15491

}

15492

return NDR_ERR_SUCCESS;

15493

}

15494

15495

_PUBLIC_ void ndr_print_srvsvc_NetShareEnumAll(struct ndr_print *ndr, const char *name, int flags, const struct srvsvc_NetShareEnumAll *r)

15496

{

15497

ndr_print_struct(ndr, name, "srvsvc_NetShareEnumAll");

15498

ndr->depth++;

15499

if (flags & NDR_SET_VALUES) {

15500

ndr->flags |= LIBNDR_PRINT_SET_VALUES;

15501

}

15502

if (flags & NDR_IN) {

15503

ndr_print_struct(ndr, "in", "srvsvc_NetShareEnumAll");

15504

ndr->depth++;

15505

ndr_print_ptr(ndr, "server_unc", r->in.server_unc);

15506

ndr->depth++;

15507

if (r->in.server_unc) {

15508

ndr_print_string(ndr, "server_unc", r->in.server_unc);

15509

}

15510

ndr->depth--;

15511

ndr_print_ptr(ndr, "info_ctr", r->in.info_ctr);

15512

ndr->depth++;

15513

ndr_print_srvsvc_NetShareInfoCtr(ndr, "info_ctr", r->in.info_ctr);

15514

ndr->depth--;

15515

ndr_print_uint32(ndr, "max_buffer", r->in.max_buffer);

15516

ndr_print_ptr(ndr, "resume_handle", r->in.resume_handle);

15517

ndr->depth++;

15518

if (r->in.resume_handle) {

15519

ndr_print_uint32(ndr, "resume_handle", *r->in.resume_handle);

15520

}

15521

ndr->depth--;

15522

ndr->depth--;

15523

}

15524

if (flags & NDR_OUT) {

15525

ndr_print_struct(ndr, "out", "srvsvc_NetShareEnumAll");

15526

ndr->depth++;

15527

ndr_print_ptr(ndr, "info_ctr", r->out.info_ctr);

15528

ndr->depth++;

15529

ndr_print_srvsvc_NetShareInfoCtr(ndr, "info_ctr", r->out.info_ctr);

15530

ndr->depth--;

15531

ndr_print_ptr(ndr, "totalentries", r->out.totalentries);

15532

ndr->depth++;

15533

ndr_print_uint32(ndr, "totalentries", *r->out.totalentries);

15534

ndr->depth--;

15535

ndr_print_ptr(ndr, "resume_handle", r->out.resume_handle);

15536

ndr->depth++;

15537

if (r->out.resume_handle) {

15538

ndr_print_uint32(ndr, "resume_handle", *r->out.resume_handle);

15539

}

15540

ndr->depth--;

15541

ndr_print_WERROR(ndr, "result", r->out.result);

15542

ndr->depth--;

15543

}

15544

ndr->depth--;

15545

}

15546

15547

static enum ndr_err_code ndr_push_srvsvc_NetShareGetInfo(struct ndr_push *ndr, int flags, const struct srvsvc_NetShareGetInfo *r)

15548

{

15549

if (flags & NDR_IN) {

15550

NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server_unc));

15551

if (r->in.server_unc) {

15552

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_unc, CH_UTF16)));

15553

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));

15554

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_unc, CH_UTF16)));

15555

NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server_unc, ndr_charset_length(r->in.server_unc, CH_UTF16), sizeof(uint16_t), CH_UTF16));

15556

}

15557

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.share_name, CH_UTF16)));

15558

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));

15559

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.share_name, CH_UTF16)));

15560

NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.share_name, ndr_charset_length(r->in.share_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));

15561

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));

15562

}

15563

if (flags & NDR_OUT) {

15564

if (r->out.info == NULL) {

15565

return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");

15566

}

15567

NDR_CHECK(ndr_push_set_switch_value(ndr, r->out.info, r->in.level));

15568

NDR_CHECK(ndr_push_srvsvc_NetShareInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.info));

15569

NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));

15570

}

15571

return NDR_ERR_SUCCESS;

15572

}

15573

15574

static enum ndr_err_code ndr_pull_srvsvc_NetShareGetInfo(struct ndr_pull *ndr, int flags, struct srvsvc_NetShareGetInfo *r)

15575

{

15576

uint32_t _ptr_server_unc;

15577

TALLOC_CTX *_mem_save_server_unc_0;

15578

TALLOC_CTX *_mem_save_info_0;

15579

if (flags & NDR_IN) {

15580

ZERO_STRUCT(r->out);

15581

15582

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_unc));

15583

if (_ptr_server_unc) {

15584

NDR_PULL_ALLOC(ndr, r->in.server_unc);

15585

} else {

15586

r->in.server_unc = NULL;

15587

}

15588

if (r->in.server_unc) {

15589

_mem_save_server_unc_0 = NDR_PULL_GET_MEM_CTX(ndr);

15590

NDR_PULL_SET_MEM_CTX(ndr, r->in.server_unc, 0);

15591

NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_unc));

15592

NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_unc));

15593

if (ndr_get_array_length(ndr, &r->in.server_unc) > ndr_get_array_size(ndr, &r->in.server_unc)) {

15594

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.server_unc), ndr_get_array_length(ndr, &r->in.server_unc));

15595

}

15596

NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server_unc), sizeof(uint16_t)));

15597

NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server_unc, ndr_get_array_length(ndr, &r->in.server_unc), sizeof(uint16_t), CH_UTF16));

15598

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_unc_0, 0);

15599

}

15600

NDR_CHECK(ndr_pull_array_size(ndr, &r->in.share_name));

15601

NDR_CHECK(ndr_pull_array_length(ndr, &r->in.share_name));

15602

if (ndr_get_array_length(ndr, &r->in.share_name) > ndr_get_array_size(ndr, &r->in.share_name)) {

15603

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.share_name), ndr_get_array_length(ndr, &r->in.share_name));

15604

}

15605

NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.share_name), sizeof(uint16_t)));

15606

NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.share_name, ndr_get_array_length(ndr, &r->in.share_name), sizeof(uint16_t), CH_UTF16));

15607

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));

15608

NDR_PULL_ALLOC(ndr, r->out.info);

15609

ZERO_STRUCTP(r->out.info);

15610

}

15611

if (flags & NDR_OUT) {

15612

if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {

15613

NDR_PULL_ALLOC(ndr, r->out.info);

15614

}

15615

_mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);

15616

NDR_PULL_SET_MEM_CTX(ndr, r->out.info, LIBNDR_FLAG_REF_ALLOC);

15617

NDR_CHECK(ndr_pull_set_switch_value(ndr, r->out.info, r->in.level));

15618

NDR_CHECK(ndr_pull_srvsvc_NetShareInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.info));

15619

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, LIBNDR_FLAG_REF_ALLOC);

15620

NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));

15621

}

15622

return NDR_ERR_SUCCESS;

15623

}

15624

15625

_PUBLIC_ void ndr_print_srvsvc_NetShareGetInfo(struct ndr_print *ndr, const char *name, int flags, const struct srvsvc_NetShareGetInfo *r)

15626

{

15627

ndr_print_struct(ndr, name, "srvsvc_NetShareGetInfo");

15628

ndr->depth++;

15629

if (flags & NDR_SET_VALUES) {

15630

ndr->flags |= LIBNDR_PRINT_SET_VALUES;

15631

}

15632

if (flags & NDR_IN) {

15633

ndr_print_struct(ndr, "in", "srvsvc_NetShareGetInfo");

15634

ndr->depth++;

15635

ndr_print_ptr(ndr, "server_unc", r->in.server_unc);

15636

ndr->depth++;

15637

if (r->in.server_unc) {

15638

ndr_print_string(ndr, "server_unc", r->in.server_unc);

15639

}

15640

ndr->depth--;

15641

ndr_print_string(ndr, "share_name", r->in.share_name);

15642

ndr_print_uint32(ndr, "level", r->in.level);

15643

ndr->depth--;

15644

}

15645

if (flags & NDR_OUT) {

15646

ndr_print_struct(ndr, "out", "srvsvc_NetShareGetInfo");

15647

ndr->depth++;

15648

ndr_print_ptr(ndr, "info", r->out.info);

15649

ndr->depth++;

15650

ndr_print_set_switch_value(ndr, r->out.info, r->in.level);

15651

ndr_print_srvsvc_NetShareInfo(ndr, "info", r->out.info);

15652

ndr->depth--;

15653

ndr_print_WERROR(ndr, "result", r->out.result);

15654

ndr->depth--;

15655

}

15656

ndr->depth--;

15657

}

15658

15659

static enum ndr_err_code ndr_push_srvsvc_NetShareSetInfo(struct ndr_push *ndr, int flags, const struct srvsvc_NetShareSetInfo *r)

15660

{

15661

if (flags & NDR_IN) {

15662

NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server_unc));

15663

if (r->in.server_unc) {

15664

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_unc, CH_UTF16)));

15665

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));

15666

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_unc, CH_UTF16)));

15667

NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server_unc, ndr_charset_length(r->in.server_unc, CH_UTF16), sizeof(uint16_t), CH_UTF16));

15668

}

15669

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.share_name, CH_UTF16)));

15670

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));

15671

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.share_name, CH_UTF16)));

15672

NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.share_name, ndr_charset_length(r->in.share_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));

15673

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));

15674

if (r->in.info == NULL) {

15675

return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");

15676

}

15677

NDR_CHECK(ndr_push_set_switch_value(ndr, r->in.info, r->in.level));

15678

NDR_CHECK(ndr_push_srvsvc_NetShareInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info));

15679

NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.parm_error));

15680

if (r->in.parm_error) {

15681

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->in.parm_error));

15682

}

15683

}

15684

if (flags & NDR_OUT) {

15685

NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.parm_error));

15686

if (r->out.parm_error) {

15687

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.parm_error));

15688

}

15689

NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));

15690

}

15691

return NDR_ERR_SUCCESS;

15692

}

15693

15694

static enum ndr_err_code ndr_pull_srvsvc_NetShareSetInfo(struct ndr_pull *ndr, int flags, struct srvsvc_NetShareSetInfo *r)

15695

{

15696

uint32_t _ptr_server_unc;

15697

uint32_t _ptr_parm_error;

15698

TALLOC_CTX *_mem_save_server_unc_0;

15699

TALLOC_CTX *_mem_save_info_0;

15700

TALLOC_CTX *_mem_save_parm_error_0;

15701

if (flags & NDR_IN) {

15702

ZERO_STRUCT(r->out);

15703

15704

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_unc));

15705

if (_ptr_server_unc) {

15706

NDR_PULL_ALLOC(ndr, r->in.server_unc);

15707

} else {

15708

r->in.server_unc = NULL;

15709

}

15710

if (r->in.server_unc) {

15711

_mem_save_server_unc_0 = NDR_PULL_GET_MEM_CTX(ndr);

15712

NDR_PULL_SET_MEM_CTX(ndr, r->in.server_unc, 0);

15713

NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_unc));

15714

NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_unc));

15715

if (ndr_get_array_length(ndr, &r->in.server_unc) > ndr_get_array_size(ndr, &r->in.server_unc)) {

15716

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.server_unc), ndr_get_array_length(ndr, &r->in.server_unc));

15717

}

15718

NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server_unc), sizeof(uint16_t)));

15719

NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server_unc, ndr_get_array_length(ndr, &r->in.server_unc), sizeof(uint16_t), CH_UTF16));

15720

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_unc_0, 0);

15721

}

15722

NDR_CHECK(ndr_pull_array_size(ndr, &r->in.share_name));

15723

NDR_CHECK(ndr_pull_array_length(ndr, &r->in.share_name));

15724

if (ndr_get_array_length(ndr, &r->in.share_name) > ndr_get_array_size(ndr, &r->in.share_name)) {

15725

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.share_name), ndr_get_array_length(ndr, &r->in.share_name));

15726

}

15727

NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.share_name), sizeof(uint16_t)));

15728

NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.share_name, ndr_get_array_length(ndr, &r->in.share_name), sizeof(uint16_t), CH_UTF16));

15729

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));

15730

if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {

15731

NDR_PULL_ALLOC(ndr, r->in.info);

15732

}

15733

_mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);

15734

NDR_PULL_SET_MEM_CTX(ndr, r->in.info, LIBNDR_FLAG_REF_ALLOC);

15735

NDR_CHECK(ndr_pull_set_switch_value(ndr, r->in.info, r->in.level));

15736

NDR_CHECK(ndr_pull_srvsvc_NetShareInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info));

15737

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, LIBNDR_FLAG_REF_ALLOC);

15738

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_parm_error));

15739

if (_ptr_parm_error) {

15740

NDR_PULL_ALLOC(ndr, r->in.parm_error);

15741

} else {

15742

r->in.parm_error = NULL;

15743

}

15744

if (r->in.parm_error) {

15745

_mem_save_parm_error_0 = NDR_PULL_GET_MEM_CTX(ndr);

15746

NDR_PULL_SET_MEM_CTX(ndr, r->in.parm_error, 0);

15747

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->in.parm_error));

15748

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_parm_error_0, 0);

15749

}

15750

}

15751

if (flags & NDR_OUT) {

15752

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_parm_error));

15753

if (_ptr_parm_error) {

15754

NDR_PULL_ALLOC(ndr, r->out.parm_error);

15755

} else {

15756

r->out.parm_error = NULL;

15757

}

15758

if (r->out.parm_error) {

15759

_mem_save_parm_error_0 = NDR_PULL_GET_MEM_CTX(ndr);

15760

NDR_PULL_SET_MEM_CTX(ndr, r->out.parm_error, 0);

15761

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.parm_error));

15762

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_parm_error_0, 0);

15763

}

15764

NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));

15765

}

15766

return NDR_ERR_SUCCESS;

15767

}

15768

15769

_PUBLIC_ void ndr_print_srvsvc_NetShareSetInfo(struct ndr_print *ndr, const char *name, int flags, const struct srvsvc_NetShareSetInfo *r)

15770

{

15771

ndr_print_struct(ndr, name, "srvsvc_NetShareSetInfo");

15772

ndr->depth++;

15773

if (flags & NDR_SET_VALUES) {

15774

ndr->flags |= LIBNDR_PRINT_SET_VALUES;

15775

}

15776

if (flags & NDR_IN) {

15777

ndr_print_struct(ndr, "in", "srvsvc_NetShareSetInfo");

15778

ndr->depth++;

15779

ndr_print_ptr(ndr, "server_unc", r->in.server_unc);

15780

ndr->depth++;

15781

if (r->in.server_unc) {

15782

ndr_print_string(ndr, "server_unc", r->in.server_unc);

15783

}

15784

ndr->depth--;

15785

ndr_print_string(ndr, "share_name", r->in.share_name);

15786

ndr_print_uint32(ndr, "level", r->in.level);

15787

ndr_print_ptr(ndr, "info", r->in.info);

15788

ndr->depth++;

15789

ndr_print_set_switch_value(ndr, r->in.info, r->in.level);

15790

ndr_print_srvsvc_NetShareInfo(ndr, "info", r->in.info);

15791

ndr->depth--;

15792

ndr_print_ptr(ndr, "parm_error", r->in.parm_error);

15793

ndr->depth++;

15794

if (r->in.parm_error) {

15795

ndr_print_uint32(ndr, "parm_error", *r->in.parm_error);

15796

}

15797

ndr->depth--;

15798

ndr->depth--;

15799

}

15800

if (flags & NDR_OUT) {

15801

ndr_print_struct(ndr, "out", "srvsvc_NetShareSetInfo");

15802

ndr->depth++;

15803

ndr_print_ptr(ndr, "parm_error", r->out.parm_error);

15804

ndr->depth++;

15805

if (r->out.parm_error) {

15806

ndr_print_uint32(ndr, "parm_error", *r->out.parm_error);

15807

}

15808

ndr->depth--;

15809

ndr_print_WERROR(ndr, "result", r->out.result);

15810

ndr->depth--;

15811

}

15812

ndr->depth--;

15813

}

15814

15815

static enum ndr_err_code ndr_push_srvsvc_NetShareDel(struct ndr_push *ndr, int flags, const struct srvsvc_NetShareDel *r)

15816

{

15817

if (flags & NDR_IN) {

15818

NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server_unc));

15819

if (r->in.server_unc) {

15820

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_unc, CH_UTF16)));

15821

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));

15822

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_unc, CH_UTF16)));

15823

NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server_unc, ndr_charset_length(r->in.server_unc, CH_UTF16), sizeof(uint16_t), CH_UTF16));

15824

}

15825

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.share_name, CH_UTF16)));

15826

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));

15827

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.share_name, CH_UTF16)));

15828

NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.share_name, ndr_charset_length(r->in.share_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));

15829

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.reserved));

15830

}

15831

if (flags & NDR_OUT) {

15832

NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));

15833

}

15834

return NDR_ERR_SUCCESS;

15835

}

15836

15837

static enum ndr_err_code ndr_pull_srvsvc_NetShareDel(struct ndr_pull *ndr, int flags, struct srvsvc_NetShareDel *r)

15838

{

15839

uint32_t _ptr_server_unc;

15840

TALLOC_CTX *_mem_save_server_unc_0;

15841

if (flags & NDR_IN) {

15842

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_unc));

15843

if (_ptr_server_unc) {

15844

NDR_PULL_ALLOC(ndr, r->in.server_unc);

15845

} else {

15846

r->in.server_unc = NULL;

15847

}

15848

if (r->in.server_unc) {

15849

_mem_save_server_unc_0 = NDR_PULL_GET_MEM_CTX(ndr);

15850

NDR_PULL_SET_MEM_CTX(ndr, r->in.server_unc, 0);

15851

NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_unc));

15852

NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_unc));

15853

if (ndr_get_array_length(ndr, &r->in.server_unc) > ndr_get_array_size(ndr, &r->in.server_unc)) {

15854

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.server_unc), ndr_get_array_length(ndr, &r->in.server_unc));

15855

}

15856

NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server_unc), sizeof(uint16_t)));

15857

NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server_unc, ndr_get_array_length(ndr, &r->in.server_unc), sizeof(uint16_t), CH_UTF16));

15858

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_unc_0, 0);

15859

}

15860

NDR_CHECK(ndr_pull_array_size(ndr, &r->in.share_name));

15861

NDR_CHECK(ndr_pull_array_length(ndr, &r->in.share_name));

15862

if (ndr_get_array_length(ndr, &r->in.share_name) > ndr_get_array_size(ndr, &r->in.share_name)) {

15863

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.share_name), ndr_get_array_length(ndr, &r->in.share_name));

15864

}

15865

NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.share_name), sizeof(uint16_t)));

15866

NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.share_name, ndr_get_array_length(ndr, &r->in.share_name), sizeof(uint16_t), CH_UTF16));

15867

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.reserved));

15868

}

15869

if (flags & NDR_OUT) {

15870

NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));

15871

}

15872

return NDR_ERR_SUCCESS;

15873

}

15874

15875

_PUBLIC_ void ndr_print_srvsvc_NetShareDel(struct ndr_print *ndr, const char *name, int flags, const struct srvsvc_NetShareDel *r)

15876

{

15877

ndr_print_struct(ndr, name, "srvsvc_NetShareDel");

15878

ndr->depth++;

15879

if (flags & NDR_SET_VALUES) {

15880

ndr->flags |= LIBNDR_PRINT_SET_VALUES;

15881

}

15882

if (flags & NDR_IN) {

15883

ndr_print_struct(ndr, "in", "srvsvc_NetShareDel");

15884

ndr->depth++;

15885

ndr_print_ptr(ndr, "server_unc", r->in.server_unc);

15886

ndr->depth++;

15887

if (r->in.server_unc) {

15888

ndr_print_string(ndr, "server_unc", r->in.server_unc);

15889

}

15890

ndr->depth--;

15891

ndr_print_string(ndr, "share_name", r->in.share_name);

15892

ndr_print_uint32(ndr, "reserved", r->in.reserved);

15893

ndr->depth--;

15894

}

15895

if (flags & NDR_OUT) {

15896

ndr_print_struct(ndr, "out", "srvsvc_NetShareDel");

15897

ndr->depth++;

15898

ndr_print_WERROR(ndr, "result", r->out.result);

15899

ndr->depth--;

15900

}

15901

ndr->depth--;

15902

}

15903

15904

static enum ndr_err_code ndr_push_srvsvc_NetShareDelSticky(struct ndr_push *ndr, int flags, const struct srvsvc_NetShareDelSticky *r)

15905

{

15906

if (flags & NDR_IN) {

15907

NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server_unc));

15908

if (r->in.server_unc) {

15909

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_unc, CH_UTF16)));

15910

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));

15911

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_unc, CH_UTF16)));

15912

NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server_unc, ndr_charset_length(r->in.server_unc, CH_UTF16), sizeof(uint16_t), CH_UTF16));

15913

}

15914

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.share_name, CH_UTF16)));

15915

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));

15916

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.share_name, CH_UTF16)));

15917

NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.share_name, ndr_charset_length(r->in.share_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));

15918

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.reserved));

15919

}

15920

if (flags & NDR_OUT) {

15921

NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));

15922

}

15923

return NDR_ERR_SUCCESS;

15924

}

15925

15926

static enum ndr_err_code ndr_pull_srvsvc_NetShareDelSticky(struct ndr_pull *ndr, int flags, struct srvsvc_NetShareDelSticky *r)

15927

{

15928

uint32_t _ptr_server_unc;

15929

TALLOC_CTX *_mem_save_server_unc_0;

15930

if (flags & NDR_IN) {

15931

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_unc));

15932

if (_ptr_server_unc) {

15933

NDR_PULL_ALLOC(ndr, r->in.server_unc);

15934

} else {

15935

r->in.server_unc = NULL;

15936

}

15937

if (r->in.server_unc) {

15938

_mem_save_server_unc_0 = NDR_PULL_GET_MEM_CTX(ndr);

15939

NDR_PULL_SET_MEM_CTX(ndr, r->in.server_unc, 0);

15940

NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_unc));

15941

NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_unc));

15942

if (ndr_get_array_length(ndr, &r->in.server_unc) > ndr_get_array_size(ndr, &r->in.server_unc)) {

15943

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.server_unc), ndr_get_array_length(ndr, &r->in.server_unc));

15944

}

15945

NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server_unc), sizeof(uint16_t)));

15946

NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server_unc, ndr_get_array_length(ndr, &r->in.server_unc), sizeof(uint16_t), CH_UTF16));

15947

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_unc_0, 0);

15948

}

15949

NDR_CHECK(ndr_pull_array_size(ndr, &r->in.share_name));

15950

NDR_CHECK(ndr_pull_array_length(ndr, &r->in.share_name));

15951

if (ndr_get_array_length(ndr, &r->in.share_name) > ndr_get_array_size(ndr, &r->in.share_name)) {

15952

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.share_name), ndr_get_array_length(ndr, &r->in.share_name));

15953

}

15954

NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.share_name), sizeof(uint16_t)));

15955

NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.share_name, ndr_get_array_length(ndr, &r->in.share_name), sizeof(uint16_t), CH_UTF16));

15956

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.reserved));

15957

}

15958

if (flags & NDR_OUT) {

15959

NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));

15960

}

15961

return NDR_ERR_SUCCESS;

15962

}

15963

15964

_PUBLIC_ void ndr_print_srvsvc_NetShareDelSticky(struct ndr_print *ndr, const char *name, int flags, const struct srvsvc_NetShareDelSticky *r)

15965

{

15966

ndr_print_struct(ndr, name, "srvsvc_NetShareDelSticky");

15967

ndr->depth++;

15968

if (flags & NDR_SET_VALUES) {

15969

ndr->flags |= LIBNDR_PRINT_SET_VALUES;

15970

}

15971

if (flags & NDR_IN) {

15972

ndr_print_struct(ndr, "in", "srvsvc_NetShareDelSticky");

15973

ndr->depth++;

15974

ndr_print_ptr(ndr, "server_unc", r->in.server_unc);

15975

ndr->depth++;

15976

if (r->in.server_unc) {

15977

ndr_print_string(ndr, "server_unc", r->in.server_unc);

15978

}

15979

ndr->depth--;

15980

ndr_print_string(ndr, "share_name", r->in.share_name);

15981

ndr_print_uint32(ndr, "reserved", r->in.reserved);

15982

ndr->depth--;

15983

}

15984

if (flags & NDR_OUT) {

15985

ndr_print_struct(ndr, "out", "srvsvc_NetShareDelSticky");

15986

ndr->depth++;

15987

ndr_print_WERROR(ndr, "result", r->out.result);

15988

ndr->depth--;

15989

}

15990

ndr->depth--;

15991

}

15992

15993

static enum ndr_err_code ndr_push_srvsvc_NetShareCheck(struct ndr_push *ndr, int flags, const struct srvsvc_NetShareCheck *r)

15994

{

15995

if (flags & NDR_IN) {

15996

NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server_unc));

15997

if (r->in.server_unc) {

15998

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_unc, CH_UTF16)));

15999

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));

16000

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_unc, CH_UTF16)));

16001

NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server_unc, ndr_charset_length(r->in.server_unc, CH_UTF16), sizeof(uint16_t), CH_UTF16));

16002

}

16003

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.device_name, CH_UTF16)));

16004

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));

16005

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.device_name, CH_UTF16)));

16006

NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.device_name, ndr_charset_length(r->in.device_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));

16007

}

16008

if (flags & NDR_OUT) {

16009

if (r->out.type == NULL) {

16010

return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");

16011

}

16012

NDR_CHECK(ndr_push_srvsvc_ShareType(ndr, NDR_SCALARS, *r->out.type));

16013

NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));

16014

}

16015

return NDR_ERR_SUCCESS;

16016

}

16017

16018

static enum ndr_err_code ndr_pull_srvsvc_NetShareCheck(struct ndr_pull *ndr, int flags, struct srvsvc_NetShareCheck *r)

16019

{

16020

uint32_t _ptr_server_unc;

16021

TALLOC_CTX *_mem_save_server_unc_0;

16022

TALLOC_CTX *_mem_save_type_0;

16023

if (flags & NDR_IN) {

16024

ZERO_STRUCT(r->out);

16025

16026

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_unc));

16027

if (_ptr_server_unc) {

16028

NDR_PULL_ALLOC(ndr, r->in.server_unc);

16029

} else {

16030

r->in.server_unc = NULL;

16031

}

16032

if (r->in.server_unc) {

16033

_mem_save_server_unc_0 = NDR_PULL_GET_MEM_CTX(ndr);

16034

NDR_PULL_SET_MEM_CTX(ndr, r->in.server_unc, 0);

16035

NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_unc));

16036

NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_unc));

16037

if (ndr_get_array_length(ndr, &r->in.server_unc) > ndr_get_array_size(ndr, &r->in.server_unc)) {

16038

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.server_unc), ndr_get_array_length(ndr, &r->in.server_unc));

16039

}

16040

NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server_unc), sizeof(uint16_t)));

16041

NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server_unc, ndr_get_array_length(ndr, &r->in.server_unc), sizeof(uint16_t), CH_UTF16));

16042

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_unc_0, 0);

16043

}

16044

NDR_CHECK(ndr_pull_array_size(ndr, &r->in.device_name));

16045

NDR_CHECK(ndr_pull_array_length(ndr, &r->in.device_name));

16046

if (ndr_get_array_length(ndr, &r->in.device_name) > ndr_get_array_size(ndr, &r->in.device_name)) {

16047

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.device_name), ndr_get_array_length(ndr, &r->in.device_name));

16048

}

16049

NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.device_name), sizeof(uint16_t)));

16050

NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.device_name, ndr_get_array_length(ndr, &r->in.device_name), sizeof(uint16_t), CH_UTF16));

16051

NDR_PULL_ALLOC(ndr, r->out.type);

16052

ZERO_STRUCTP(r->out.type);

16053

}

16054

if (flags & NDR_OUT) {

16055

if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {

16056

NDR_PULL_ALLOC(ndr, r->out.type);

16057

}

16058

_mem_save_type_0 = NDR_PULL_GET_MEM_CTX(ndr);

16059

NDR_PULL_SET_MEM_CTX(ndr, r->out.type, LIBNDR_FLAG_REF_ALLOC);

16060

NDR_CHECK(ndr_pull_srvsvc_ShareType(ndr, NDR_SCALARS, r->out.type));

16061

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_type_0, LIBNDR_FLAG_REF_ALLOC);

16062

NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));

16063

}

16064

return NDR_ERR_SUCCESS;

16065

}

16066

16067

_PUBLIC_ void ndr_print_srvsvc_NetShareCheck(struct ndr_print *ndr, const char *name, int flags, const struct srvsvc_NetShareCheck *r)

16068

{

16069

ndr_print_struct(ndr, name, "srvsvc_NetShareCheck");

16070

ndr->depth++;

16071

if (flags & NDR_SET_VALUES) {

16072

ndr->flags |= LIBNDR_PRINT_SET_VALUES;

16073

}

16074

if (flags & NDR_IN) {

16075

ndr_print_struct(ndr, "in", "srvsvc_NetShareCheck");

16076

ndr->depth++;

16077

ndr_print_ptr(ndr, "server_unc", r->in.server_unc);

16078

ndr->depth++;

16079

if (r->in.server_unc) {

16080

ndr_print_string(ndr, "server_unc", r->in.server_unc);

16081

}

16082

ndr->depth--;

16083

ndr_print_string(ndr, "device_name", r->in.device_name);

16084

ndr->depth--;

16085

}

16086

if (flags & NDR_OUT) {

16087

ndr_print_struct(ndr, "out", "srvsvc_NetShareCheck");

16088

ndr->depth++;

16089

ndr_print_ptr(ndr, "type", r->out.type);

16090

ndr->depth++;

16091

ndr_print_srvsvc_ShareType(ndr, "type", *r->out.type);

16092

ndr->depth--;

16093

ndr_print_WERROR(ndr, "result", r->out.result);

16094

ndr->depth--;

16095

}

16096

ndr->depth--;

16097

}

16098

16099

static enum ndr_err_code ndr_push_srvsvc_NetSrvGetInfo(struct ndr_push *ndr, int flags, const struct srvsvc_NetSrvGetInfo *r)

16100

{

16101

if (flags & NDR_IN) {

16102

NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server_unc));

16103

if (r->in.server_unc) {

16104

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_unc, CH_UTF16)));

16105

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));

16106

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_unc, CH_UTF16)));

16107

NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server_unc, ndr_charset_length(r->in.server_unc, CH_UTF16), sizeof(uint16_t), CH_UTF16));

16108

}

16109

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));

16110

}

16111

if (flags & NDR_OUT) {

16112

if (r->out.info == NULL) {

16113

return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");

16114

}

16115

NDR_CHECK(ndr_push_set_switch_value(ndr, r->out.info, r->in.level));

16116

NDR_CHECK(ndr_push_srvsvc_NetSrvInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.info));

16117

NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));

16118

}

16119

return NDR_ERR_SUCCESS;

16120

}

16121

16122

static enum ndr_err_code ndr_pull_srvsvc_NetSrvGetInfo(struct ndr_pull *ndr, int flags, struct srvsvc_NetSrvGetInfo *r)

16123

{

16124

uint32_t _ptr_server_unc;

16125

TALLOC_CTX *_mem_save_server_unc_0;

16126

TALLOC_CTX *_mem_save_info_0;

16127

if (flags & NDR_IN) {

16128

ZERO_STRUCT(r->out);

16129

16130

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_unc));

16131

if (_ptr_server_unc) {

16132

NDR_PULL_ALLOC(ndr, r->in.server_unc);

16133

} else {

16134

r->in.server_unc = NULL;

16135

}

16136

if (r->in.server_unc) {

16137

_mem_save_server_unc_0 = NDR_PULL_GET_MEM_CTX(ndr);

16138

NDR_PULL_SET_MEM_CTX(ndr, r->in.server_unc, 0);

16139

NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_unc));

16140

NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_unc));

16141

if (ndr_get_array_length(ndr, &r->in.server_unc) > ndr_get_array_size(ndr, &r->in.server_unc)) {

16142

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.server_unc), ndr_get_array_length(ndr, &r->in.server_unc));

16143

}

16144

NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server_unc), sizeof(uint16_t)));

16145

NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server_unc, ndr_get_array_length(ndr, &r->in.server_unc), sizeof(uint16_t), CH_UTF16));

16146

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_unc_0, 0);

16147

}

16148

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));

16149

NDR_PULL_ALLOC(ndr, r->out.info);

16150

ZERO_STRUCTP(r->out.info);

16151

}

16152

if (flags & NDR_OUT) {

16153

if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {

16154

NDR_PULL_ALLOC(ndr, r->out.info);

16155

}

16156

_mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);

16157

NDR_PULL_SET_MEM_CTX(ndr, r->out.info, LIBNDR_FLAG_REF_ALLOC);

16158

NDR_CHECK(ndr_pull_set_switch_value(ndr, r->out.info, r->in.level));

16159

NDR_CHECK(ndr_pull_srvsvc_NetSrvInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.info));

16160

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, LIBNDR_FLAG_REF_ALLOC);

16161

NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));

16162

}

16163

return NDR_ERR_SUCCESS;

16164

}

16165

16166

_PUBLIC_ void ndr_print_srvsvc_NetSrvGetInfo(struct ndr_print *ndr, const char *name, int flags, const struct srvsvc_NetSrvGetInfo *r)

16167

{

16168

ndr_print_struct(ndr, name, "srvsvc_NetSrvGetInfo");

16169

ndr->depth++;

16170

if (flags & NDR_SET_VALUES) {

16171

ndr->flags |= LIBNDR_PRINT_SET_VALUES;

16172

}

16173

if (flags & NDR_IN) {

16174

ndr_print_struct(ndr, "in", "srvsvc_NetSrvGetInfo");

16175

ndr->depth++;

16176

ndr_print_ptr(ndr, "server_unc", r->in.server_unc);

16177

ndr->depth++;

16178

if (r->in.server_unc) {

16179

ndr_print_string(ndr, "server_unc", r->in.server_unc);

16180

}

16181

ndr->depth--;

16182

ndr_print_uint32(ndr, "level", r->in.level);

16183

ndr->depth--;

16184

}

16185

if (flags & NDR_OUT) {

16186

ndr_print_struct(ndr, "out", "srvsvc_NetSrvGetInfo");

16187

ndr->depth++;

16188

ndr_print_ptr(ndr, "info", r->out.info);

16189

ndr->depth++;

16190

ndr_print_set_switch_value(ndr, r->out.info, r->in.level);

16191

ndr_print_srvsvc_NetSrvInfo(ndr, "info", r->out.info);

16192

ndr->depth--;

16193

ndr_print_WERROR(ndr, "result", r->out.result);

16194

ndr->depth--;

16195

}

16196

ndr->depth--;

16197

}

16198

16199

static enum ndr_err_code ndr_push_srvsvc_NetSrvSetInfo(struct ndr_push *ndr, int flags, const struct srvsvc_NetSrvSetInfo *r)

16200

{

16201

if (flags & NDR_IN) {

16202

NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server_unc));

16203

if (r->in.server_unc) {

16204

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_unc, CH_UTF16)));

16205

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));

16206

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_unc, CH_UTF16)));

16207

NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server_unc, ndr_charset_length(r->in.server_unc, CH_UTF16), sizeof(uint16_t), CH_UTF16));

16208

}

16209

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));

16210

if (r->in.info == NULL) {

16211

return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");

16212

}

16213

NDR_CHECK(ndr_push_set_switch_value(ndr, r->in.info, r->in.level));

16214

NDR_CHECK(ndr_push_srvsvc_NetSrvInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info));

16215

NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.parm_error));

16216

if (r->in.parm_error) {

16217

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->in.parm_error));

16218

}

16219

}

16220

if (flags & NDR_OUT) {

16221

NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.parm_error));

16222

if (r->out.parm_error) {

16223

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.parm_error));

16224

}

16225

NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));

16226

}

16227

return NDR_ERR_SUCCESS;

16228

}

16229

16230

static enum ndr_err_code ndr_pull_srvsvc_NetSrvSetInfo(struct ndr_pull *ndr, int flags, struct srvsvc_NetSrvSetInfo *r)

16231

{

16232

uint32_t _ptr_server_unc;

16233

uint32_t _ptr_parm_error;

16234

TALLOC_CTX *_mem_save_server_unc_0;

16235

TALLOC_CTX *_mem_save_info_0;

16236

TALLOC_CTX *_mem_save_parm_error_0;

16237

if (flags & NDR_IN) {

16238

ZERO_STRUCT(r->out);

16239

16240

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_unc));

16241

if (_ptr_server_unc) {

16242

NDR_PULL_ALLOC(ndr, r->in.server_unc);

16243

} else {

16244

r->in.server_unc = NULL;

16245

}

16246

if (r->in.server_unc) {

16247

_mem_save_server_unc_0 = NDR_PULL_GET_MEM_CTX(ndr);

16248

NDR_PULL_SET_MEM_CTX(ndr, r->in.server_unc, 0);

16249

NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_unc));

16250

NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_unc));

16251

if (ndr_get_array_length(ndr, &r->in.server_unc) > ndr_get_array_size(ndr, &r->in.server_unc)) {

16252

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.server_unc), ndr_get_array_length(ndr, &r->in.server_unc));

16253

}

16254

NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server_unc), sizeof(uint16_t)));

16255

NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server_unc, ndr_get_array_length(ndr, &r->in.server_unc), sizeof(uint16_t), CH_UTF16));

16256

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_unc_0, 0);

16257

}

16258

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));

16259

if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {

16260

NDR_PULL_ALLOC(ndr, r->in.info);

16261

}

16262

_mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);

16263

NDR_PULL_SET_MEM_CTX(ndr, r->in.info, LIBNDR_FLAG_REF_ALLOC);

16264

NDR_CHECK(ndr_pull_set_switch_value(ndr, r->in.info, r->in.level));

16265

NDR_CHECK(ndr_pull_srvsvc_NetSrvInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info));

16266

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, LIBNDR_FLAG_REF_ALLOC);

16267

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_parm_error));

16268

if (_ptr_parm_error) {

16269

NDR_PULL_ALLOC(ndr, r->in.parm_error);

16270

} else {

16271

r->in.parm_error = NULL;

16272

}

16273

if (r->in.parm_error) {

16274

_mem_save_parm_error_0 = NDR_PULL_GET_MEM_CTX(ndr);

16275

NDR_PULL_SET_MEM_CTX(ndr, r->in.parm_error, 0);

16276

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->in.parm_error));

16277

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_parm_error_0, 0);

16278

}

16279

}

16280

if (flags & NDR_OUT) {

16281

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_parm_error));

16282

if (_ptr_parm_error) {

16283

NDR_PULL_ALLOC(ndr, r->out.parm_error);

16284

} else {

16285

r->out.parm_error = NULL;

16286

}

16287

if (r->out.parm_error) {

16288

_mem_save_parm_error_0 = NDR_PULL_GET_MEM_CTX(ndr);

16289

NDR_PULL_SET_MEM_CTX(ndr, r->out.parm_error, 0);

16290

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.parm_error));

16291

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_parm_error_0, 0);

16292

}

16293

NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));

16294

}

16295

return NDR_ERR_SUCCESS;

16296

}

16297

16298

_PUBLIC_ void ndr_print_srvsvc_NetSrvSetInfo(struct ndr_print *ndr, const char *name, int flags, const struct srvsvc_NetSrvSetInfo *r)

16299

{

16300

ndr_print_struct(ndr, name, "srvsvc_NetSrvSetInfo");

16301

ndr->depth++;

16302

if (flags & NDR_SET_VALUES) {

16303

ndr->flags |= LIBNDR_PRINT_SET_VALUES;

16304

}

16305

if (flags & NDR_IN) {

16306

ndr_print_struct(ndr, "in", "srvsvc_NetSrvSetInfo");

16307

ndr->depth++;

16308

ndr_print_ptr(ndr, "server_unc", r->in.server_unc);

16309

ndr->depth++;

16310

if (r->in.server_unc) {

16311

ndr_print_string(ndr, "server_unc", r->in.server_unc);

16312

}

16313

ndr->depth--;

16314

ndr_print_uint32(ndr, "level", r->in.level);

16315

ndr_print_ptr(ndr, "info", r->in.info);

16316

ndr->depth++;

16317

ndr_print_set_switch_value(ndr, r->in.info, r->in.level);

16318

ndr_print_srvsvc_NetSrvInfo(ndr, "info", r->in.info);

16319

ndr->depth--;

16320

ndr_print_ptr(ndr, "parm_error", r->in.parm_error);

16321

ndr->depth++;

16322

if (r->in.parm_error) {

16323

ndr_print_uint32(ndr, "parm_error", *r->in.parm_error);

16324

}

16325

ndr->depth--;

16326

ndr->depth--;

16327

}

16328

if (flags & NDR_OUT) {

16329

ndr_print_struct(ndr, "out", "srvsvc_NetSrvSetInfo");

16330

ndr->depth++;

16331

ndr_print_ptr(ndr, "parm_error", r->out.parm_error);

16332

ndr->depth++;

16333

if (r->out.parm_error) {

16334

ndr_print_uint32(ndr, "parm_error", *r->out.parm_error);

16335

}

16336

ndr->depth--;

16337

ndr_print_WERROR(ndr, "result", r->out.result);

16338

ndr->depth--;

16339

}

16340

ndr->depth--;

16341

}

16342

16343

static enum ndr_err_code ndr_push_srvsvc_NetDiskEnum(struct ndr_push *ndr, int flags, const struct srvsvc_NetDiskEnum *r)

16344

{

16345

if (flags & NDR_IN) {

16346

NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server_unc));

16347

if (r->in.server_unc) {

16348

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_unc, CH_UTF16)));

16349

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));

16350

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_unc, CH_UTF16)));

16351

NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server_unc, ndr_charset_length(r->in.server_unc, CH_UTF16), sizeof(uint16_t), CH_UTF16));

16352

}

16353

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));

16354

if (r->in.info == NULL) {

16355

return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");

16356

}

16357

NDR_CHECK(ndr_push_srvsvc_NetDiskInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info));

16358

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.maxlen));

16359

NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.resume_handle));

16360

if (r->in.resume_handle) {

16361

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->in.resume_handle));

16362

}

16363

}

16364

if (flags & NDR_OUT) {

16365

if (r->out.info == NULL) {

16366

return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");

16367

}

16368

NDR_CHECK(ndr_push_srvsvc_NetDiskInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.info));

16369

if (r->out.totalentries == NULL) {

16370

return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");

16371

}

16372

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.totalentries));

16373

NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.resume_handle));

16374

if (r->out.resume_handle) {

16375

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.resume_handle));

16376

}

16377

NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));

16378

}

16379

return NDR_ERR_SUCCESS;

16380

}

16381

16382

static enum ndr_err_code ndr_pull_srvsvc_NetDiskEnum(struct ndr_pull *ndr, int flags, struct srvsvc_NetDiskEnum *r)

16383

{

16384

uint32_t _ptr_server_unc;

16385

uint32_t _ptr_resume_handle;

16386

TALLOC_CTX *_mem_save_server_unc_0;

16387

TALLOC_CTX *_mem_save_info_0;

16388

TALLOC_CTX *_mem_save_totalentries_0;

16389

TALLOC_CTX *_mem_save_resume_handle_0;

16390

if (flags & NDR_IN) {

16391

ZERO_STRUCT(r->out);

16392

16393

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_unc));

16394

if (_ptr_server_unc) {

16395

NDR_PULL_ALLOC(ndr, r->in.server_unc);

16396

} else {

16397

r->in.server_unc = NULL;

16398

}

16399

if (r->in.server_unc) {

16400

_mem_save_server_unc_0 = NDR_PULL_GET_MEM_CTX(ndr);

16401

NDR_PULL_SET_MEM_CTX(ndr, r->in.server_unc, 0);

16402

NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_unc));

16403

NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_unc));

16404

if (ndr_get_array_length(ndr, &r->in.server_unc) > ndr_get_array_size(ndr, &r->in.server_unc)) {

16405

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.server_unc), ndr_get_array_length(ndr, &r->in.server_unc));

16406

}

16407

NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server_unc), sizeof(uint16_t)));

16408

NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server_unc, ndr_get_array_length(ndr, &r->in.server_unc), sizeof(uint16_t), CH_UTF16));

16409

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_unc_0, 0);

16410

}

16411

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));

16412

if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {

16413

NDR_PULL_ALLOC(ndr, r->in.info);

16414

}

16415

_mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);

16416

NDR_PULL_SET_MEM_CTX(ndr, r->in.info, LIBNDR_FLAG_REF_ALLOC);

16417

NDR_CHECK(ndr_pull_srvsvc_NetDiskInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info));

16418

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, LIBNDR_FLAG_REF_ALLOC);

16419

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.maxlen));

16420

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_resume_handle));

16421

if (_ptr_resume_handle) {

16422

NDR_PULL_ALLOC(ndr, r->in.resume_handle);

16423

} else {

16424

r->in.resume_handle = NULL;

16425

}

16426

if (r->in.resume_handle) {

16427

_mem_save_resume_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);

16428

NDR_PULL_SET_MEM_CTX(ndr, r->in.resume_handle, 0);

16429

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->in.resume_handle));

16430

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_resume_handle_0, 0);

16431

}

16432

NDR_PULL_ALLOC(ndr, r->out.info);

16433

*r->out.info = *r->in.info;

16434

NDR_PULL_ALLOC(ndr, r->out.totalentries);

16435

ZERO_STRUCTP(r->out.totalentries);

16436

}

16437

if (flags & NDR_OUT) {

16438

if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {

16439

NDR_PULL_ALLOC(ndr, r->out.info);

16440

}

16441

_mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);

16442

NDR_PULL_SET_MEM_CTX(ndr, r->out.info, LIBNDR_FLAG_REF_ALLOC);

16443

NDR_CHECK(ndr_pull_srvsvc_NetDiskInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.info));

16444

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, LIBNDR_FLAG_REF_ALLOC);

16445

if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {

16446

NDR_PULL_ALLOC(ndr, r->out.totalentries);

16447

}

16448

_mem_save_totalentries_0 = NDR_PULL_GET_MEM_CTX(ndr);

16449

NDR_PULL_SET_MEM_CTX(ndr, r->out.totalentries, LIBNDR_FLAG_REF_ALLOC);

16450

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.totalentries));

16451

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_totalentries_0, LIBNDR_FLAG_REF_ALLOC);

16452

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_resume_handle));

16453

if (_ptr_resume_handle) {

16454

NDR_PULL_ALLOC(ndr, r->out.resume_handle);

16455

} else {

16456

r->out.resume_handle = NULL;

16457

}

16458

if (r->out.resume_handle) {

16459

_mem_save_resume_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);

16460

NDR_PULL_SET_MEM_CTX(ndr, r->out.resume_handle, 0);

16461

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.resume_handle));

16462

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_resume_handle_0, 0);

16463

}

16464

NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));

16465

}

16466

return NDR_ERR_SUCCESS;

16467

}

16468

16469

_PUBLIC_ void ndr_print_srvsvc_NetDiskEnum(struct ndr_print *ndr, const char *name, int flags, const struct srvsvc_NetDiskEnum *r)

16470

{

16471

ndr_print_struct(ndr, name, "srvsvc_NetDiskEnum");

16472

ndr->depth++;

16473

if (flags & NDR_SET_VALUES) {

16474

ndr->flags |= LIBNDR_PRINT_SET_VALUES;

16475

}

16476

if (flags & NDR_IN) {

16477

ndr_print_struct(ndr, "in", "srvsvc_NetDiskEnum");

16478

ndr->depth++;

16479

ndr_print_ptr(ndr, "server_unc", r->in.server_unc);

16480

ndr->depth++;

16481

if (r->in.server_unc) {

16482

ndr_print_string(ndr, "server_unc", r->in.server_unc);

16483

}

16484

ndr->depth--;

16485

ndr_print_uint32(ndr, "level", r->in.level);

16486

ndr_print_ptr(ndr, "info", r->in.info);

16487

ndr->depth++;

16488

ndr_print_srvsvc_NetDiskInfo(ndr, "info", r->in.info);

16489

ndr->depth--;

16490

ndr_print_uint32(ndr, "maxlen", r->in.maxlen);

16491

ndr_print_ptr(ndr, "resume_handle", r->in.resume_handle);

16492

ndr->depth++;

16493

if (r->in.resume_handle) {

16494

ndr_print_uint32(ndr, "resume_handle", *r->in.resume_handle);

16495

}

16496

ndr->depth--;

16497

ndr->depth--;

16498

}

16499

if (flags & NDR_OUT) {

16500

ndr_print_struct(ndr, "out", "srvsvc_NetDiskEnum");

16501

ndr->depth++;

16502

ndr_print_ptr(ndr, "info", r->out.info);

16503

ndr->depth++;

16504

ndr_print_srvsvc_NetDiskInfo(ndr, "info", r->out.info);

16505

ndr->depth--;

16506

ndr_print_ptr(ndr, "totalentries", r->out.totalentries);

16507

ndr->depth++;

16508

ndr_print_uint32(ndr, "totalentries", *r->out.totalentries);

16509

ndr->depth--;

16510

ndr_print_ptr(ndr, "resume_handle", r->out.resume_handle);

16511

ndr->depth++;

16512

if (r->out.resume_handle) {

16513

ndr_print_uint32(ndr, "resume_handle", *r->out.resume_handle);

16514

}

16515

ndr->depth--;

16516

ndr_print_WERROR(ndr, "result", r->out.result);

16517

ndr->depth--;

16518

}

16519

ndr->depth--;

16520

}

16521

16522

static enum ndr_err_code ndr_push_srvsvc_NetServerStatisticsGet(struct ndr_push *ndr, int flags, const struct srvsvc_NetServerStatisticsGet *r)

16523

{

16524

if (flags & NDR_IN) {

16525

NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server_unc));

16526

if (r->in.server_unc) {

16527

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_unc, CH_UTF16)));

16528

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));

16529

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_unc, CH_UTF16)));

16530

NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server_unc, ndr_charset_length(r->in.server_unc, CH_UTF16), sizeof(uint16_t), CH_UTF16));

16531

}

16532

NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.service));

16533

if (r->in.service) {

16534

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.service, CH_UTF16)));

16535

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));

16536

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.service, CH_UTF16)));

16537

NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.service, ndr_charset_length(r->in.service, CH_UTF16), sizeof(uint16_t), CH_UTF16));

16538

}

16539

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));

16540

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.options));

16541

}

16542

if (flags & NDR_OUT) {

16543

if (r->out.stats == NULL) {

16544

return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");

16545

}

16546

NDR_CHECK(ndr_push_unique_ptr(ndr, *r->out.stats));

16547

if (*r->out.stats) {

16548

NDR_CHECK(ndr_push_srvsvc_Statistics(ndr, NDR_SCALARS, *r->out.stats));

16549

}

16550

NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));

16551

}

16552

return NDR_ERR_SUCCESS;

16553

}

16554

16555

static enum ndr_err_code ndr_pull_srvsvc_NetServerStatisticsGet(struct ndr_pull *ndr, int flags, struct srvsvc_NetServerStatisticsGet *r)

16556

{

16557

uint32_t _ptr_server_unc;

16558

uint32_t _ptr_service;

16559

uint32_t _ptr_stats;

16560

TALLOC_CTX *_mem_save_server_unc_0;

16561

TALLOC_CTX *_mem_save_service_0;

16562

TALLOC_CTX *_mem_save_stats_0;

16563

TALLOC_CTX *_mem_save_stats_1;

16564

if (flags & NDR_IN) {

16565

ZERO_STRUCT(r->out);

16566

16567

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_unc));

16568

if (_ptr_server_unc) {

16569

NDR_PULL_ALLOC(ndr, r->in.server_unc);

16570

} else {

16571

r->in.server_unc = NULL;

16572

}

16573

if (r->in.server_unc) {

16574

_mem_save_server_unc_0 = NDR_PULL_GET_MEM_CTX(ndr);

16575

NDR_PULL_SET_MEM_CTX(ndr, r->in.server_unc, 0);

16576

NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_unc));

16577

NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_unc));

16578

if (ndr_get_array_length(ndr, &r->in.server_unc) > ndr_get_array_size(ndr, &r->in.server_unc)) {

16579

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.server_unc), ndr_get_array_length(ndr, &r->in.server_unc));

16580

}

16581

NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server_unc), sizeof(uint16_t)));

16582

NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server_unc, ndr_get_array_length(ndr, &r->in.server_unc), sizeof(uint16_t), CH_UTF16));

16583

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_unc_0, 0);

16584

}

16585

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_service));

16586

if (_ptr_service) {

16587

NDR_PULL_ALLOC(ndr, r->in.service);

16588

} else {

16589

r->in.service = NULL;

16590

}

16591

if (r->in.service) {

16592

_mem_save_service_0 = NDR_PULL_GET_MEM_CTX(ndr);

16593

NDR_PULL_SET_MEM_CTX(ndr, r->in.service, 0);

16594

NDR_CHECK(ndr_pull_array_size(ndr, &r->in.service));

16595

NDR_CHECK(ndr_pull_array_length(ndr, &r->in.service));

16596

if (ndr_get_array_length(ndr, &r->in.service) > ndr_get_array_size(ndr, &r->in.service)) {

16597

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), ndr_get_array_length(ndr, &r->in.service));

16598

}

16599

NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.service), sizeof(uint16_t)));

16600

NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.service, ndr_get_array_length(ndr, &r->in.service), sizeof(uint16_t), CH_UTF16));

16601

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_service_0, 0);

16602

}

16603

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));

16604

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.options));

16605

NDR_PULL_ALLOC(ndr, r->out.stats);

16606

ZERO_STRUCTP(r->out.stats);

16607

}

16608

if (flags & NDR_OUT) {

16609

if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {

16610

NDR_PULL_ALLOC(ndr, r->out.stats);

16611

}

16612

_mem_save_stats_0 = NDR_PULL_GET_MEM_CTX(ndr);

16613

NDR_PULL_SET_MEM_CTX(ndr, r->out.stats, LIBNDR_FLAG_REF_ALLOC);

16614

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_stats));

16615

if (_ptr_stats) {

16616

NDR_PULL_ALLOC(ndr, *r->out.stats);

16617

} else {

16618

*r->out.stats = NULL;

16619

}

16620

if (*r->out.stats) {

16621

_mem_save_stats_1 = NDR_PULL_GET_MEM_CTX(ndr);

16622

NDR_PULL_SET_MEM_CTX(ndr, *r->out.stats, 0);

16623

NDR_CHECK(ndr_pull_srvsvc_Statistics(ndr, NDR_SCALARS, *r->out.stats));

16624

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_stats_1, 0);

16625

}

16626

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_stats_0, LIBNDR_FLAG_REF_ALLOC);

16627

NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));

16628

}

16629

return NDR_ERR_SUCCESS;

16630

}

16631

16632

_PUBLIC_ void ndr_print_srvsvc_NetServerStatisticsGet(struct ndr_print *ndr, const char *name, int flags, const struct srvsvc_NetServerStatisticsGet *r)

16633

{

16634

ndr_print_struct(ndr, name, "srvsvc_NetServerStatisticsGet");

16635

ndr->depth++;

16636

if (flags & NDR_SET_VALUES) {

16637

ndr->flags |= LIBNDR_PRINT_SET_VALUES;

16638

}

16639

if (flags & NDR_IN) {

16640

ndr_print_struct(ndr, "in", "srvsvc_NetServerStatisticsGet");

16641

ndr->depth++;

16642

ndr_print_ptr(ndr, "server_unc", r->in.server_unc);

16643

ndr->depth++;

16644

if (r->in.server_unc) {

16645

ndr_print_string(ndr, "server_unc", r->in.server_unc);

16646

}

16647

ndr->depth--;

16648

ndr_print_ptr(ndr, "service", r->in.service);

16649

ndr->depth++;

16650

if (r->in.service) {

16651

ndr_print_string(ndr, "service", r->in.service);

16652

}

16653

ndr->depth--;

16654

ndr_print_uint32(ndr, "level", r->in.level);

16655

ndr_print_uint32(ndr, "options", r->in.options);

16656

ndr->depth--;

16657

}

16658

if (flags & NDR_OUT) {

16659

ndr_print_struct(ndr, "out", "srvsvc_NetServerStatisticsGet");

16660

ndr->depth++;

16661

ndr_print_ptr(ndr, "stats", r->out.stats);

16662

ndr->depth++;

16663

ndr_print_ptr(ndr, "stats", *r->out.stats);

16664

ndr->depth++;

16665

if (*r->out.stats) {

16666

ndr_print_srvsvc_Statistics(ndr, "stats", *r->out.stats);

16667

}

16668

ndr->depth--;

16669

ndr->depth--;

16670

ndr_print_WERROR(ndr, "result", r->out.result);

16671

ndr->depth--;

16672

}

16673

ndr->depth--;

16674

}

16675

16676

static enum ndr_err_code ndr_push_srvsvc_NetTransportAdd(struct ndr_push *ndr, int flags, const struct srvsvc_NetTransportAdd *r)

16677

{

16678

if (flags & NDR_IN) {

16679

NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server_unc));

16680

if (r->in.server_unc) {

16681

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_unc, CH_UTF16)));

16682

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));

16683

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_unc, CH_UTF16)));

16684

NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server_unc, ndr_charset_length(r->in.server_unc, CH_UTF16), sizeof(uint16_t), CH_UTF16));

16685

}

16686

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));

16687

NDR_CHECK(ndr_push_set_switch_value(ndr, &r->in.info, r->in.level));

16688

NDR_CHECK(ndr_push_srvsvc_NetTransportInfo(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.info));

16689

}

16690

if (flags & NDR_OUT) {

16691

NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));

16692

}

16693

return NDR_ERR_SUCCESS;

16694

}

16695

16696

static enum ndr_err_code ndr_pull_srvsvc_NetTransportAdd(struct ndr_pull *ndr, int flags, struct srvsvc_NetTransportAdd *r)

16697

{

16698

uint32_t _ptr_server_unc;

16699

TALLOC_CTX *_mem_save_server_unc_0;

16700

if (flags & NDR_IN) {

16701

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_unc));

16702

if (_ptr_server_unc) {

16703

NDR_PULL_ALLOC(ndr, r->in.server_unc);

16704

} else {

16705

r->in.server_unc = NULL;

16706

}

16707

if (r->in.server_unc) {

16708

_mem_save_server_unc_0 = NDR_PULL_GET_MEM_CTX(ndr);

16709

NDR_PULL_SET_MEM_CTX(ndr, r->in.server_unc, 0);

16710

NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_unc));

16711

NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_unc));

16712

if (ndr_get_array_length(ndr, &r->in.server_unc) > ndr_get_array_size(ndr, &r->in.server_unc)) {

16713

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.server_unc), ndr_get_array_length(ndr, &r->in.server_unc));

16714

}

16715

NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server_unc), sizeof(uint16_t)));

16716

NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server_unc, ndr_get_array_length(ndr, &r->in.server_unc), sizeof(uint16_t), CH_UTF16));

16717

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_unc_0, 0);

16718

}

16719

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));

16720

NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->in.info, r->in.level));

16721

NDR_CHECK(ndr_pull_srvsvc_NetTransportInfo(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.info));

16722

}

16723

if (flags & NDR_OUT) {

16724

NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));

16725

}

16726

return NDR_ERR_SUCCESS;

16727

}

16728

16729

_PUBLIC_ void ndr_print_srvsvc_NetTransportAdd(struct ndr_print *ndr, const char *name, int flags, const struct srvsvc_NetTransportAdd *r)

16730

{

16731

ndr_print_struct(ndr, name, "srvsvc_NetTransportAdd");

16732

ndr->depth++;

16733

if (flags & NDR_SET_VALUES) {

16734

ndr->flags |= LIBNDR_PRINT_SET_VALUES;

16735

}

16736

if (flags & NDR_IN) {

16737

ndr_print_struct(ndr, "in", "srvsvc_NetTransportAdd");

16738

ndr->depth++;

16739

ndr_print_ptr(ndr, "server_unc", r->in.server_unc);

16740

ndr->depth++;

16741

if (r->in.server_unc) {

16742

ndr_print_string(ndr, "server_unc", r->in.server_unc);

16743

}

16744

ndr->depth--;

16745

ndr_print_uint32(ndr, "level", r->in.level);

16746

ndr_print_set_switch_value(ndr, &r->in.info, r->in.level);

16747

ndr_print_srvsvc_NetTransportInfo(ndr, "info", &r->in.info);

16748

ndr->depth--;

16749

}

16750

if (flags & NDR_OUT) {

16751

ndr_print_struct(ndr, "out", "srvsvc_NetTransportAdd");

16752

ndr->depth++;

16753

ndr_print_WERROR(ndr, "result", r->out.result);

16754

ndr->depth--;

16755

}

16756

ndr->depth--;

16757

}

16758

16759

static enum ndr_err_code ndr_push_srvsvc_NetTransportEnum(struct ndr_push *ndr, int flags, const struct srvsvc_NetTransportEnum *r)

16760

{

16761

if (flags & NDR_IN) {

16762

NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server_unc));

16763

if (r->in.server_unc) {

16764

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_unc, CH_UTF16)));

16765

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));

16766

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_unc, CH_UTF16)));

16767

NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server_unc, ndr_charset_length(r->in.server_unc, CH_UTF16), sizeof(uint16_t), CH_UTF16));

16768

}

16769

if (r->in.transports == NULL) {

16770

return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");

16771

}

16772

NDR_CHECK(ndr_push_srvsvc_NetTransportInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.transports));

16773

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.max_buffer));

16774

NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.resume_handle));

16775

if (r->in.resume_handle) {

16776

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->in.resume_handle));

16777

}

16778

}

16779

if (flags & NDR_OUT) {

16780

if (r->out.transports == NULL) {

16781

return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");

16782

}

16783

NDR_CHECK(ndr_push_srvsvc_NetTransportInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.transports));

16784

if (r->out.totalentries == NULL) {

16785

return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");

16786

}

16787

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.totalentries));

16788

NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.resume_handle));

16789

if (r->out.resume_handle) {

16790

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.resume_handle));

16791

}

16792

NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));

16793

}

16794

return NDR_ERR_SUCCESS;

16795

}

16796

16797

static enum ndr_err_code ndr_pull_srvsvc_NetTransportEnum(struct ndr_pull *ndr, int flags, struct srvsvc_NetTransportEnum *r)

16798

{

16799

uint32_t _ptr_server_unc;

16800

uint32_t _ptr_resume_handle;

16801

TALLOC_CTX *_mem_save_server_unc_0;

16802

TALLOC_CTX *_mem_save_transports_0;

16803

TALLOC_CTX *_mem_save_totalentries_0;

16804

TALLOC_CTX *_mem_save_resume_handle_0;

16805

if (flags & NDR_IN) {

16806

ZERO_STRUCT(r->out);

16807

16808

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_unc));

16809

if (_ptr_server_unc) {

16810

NDR_PULL_ALLOC(ndr, r->in.server_unc);

16811

} else {

16812

r->in.server_unc = NULL;

16813

}

16814

if (r->in.server_unc) {

16815

_mem_save_server_unc_0 = NDR_PULL_GET_MEM_CTX(ndr);

16816

NDR_PULL_SET_MEM_CTX(ndr, r->in.server_unc, 0);

16817

NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_unc));

16818

NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_unc));

16819

if (ndr_get_array_length(ndr, &r->in.server_unc) > ndr_get_array_size(ndr, &r->in.server_unc)) {

16820

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.server_unc), ndr_get_array_length(ndr, &r->in.server_unc));

16821

}

16822

NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server_unc), sizeof(uint16_t)));

16823

NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server_unc, ndr_get_array_length(ndr, &r->in.server_unc), sizeof(uint16_t), CH_UTF16));

16824

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_unc_0, 0);

16825

}

16826

if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {

16827

NDR_PULL_ALLOC(ndr, r->in.transports);

16828

}

16829

_mem_save_transports_0 = NDR_PULL_GET_MEM_CTX(ndr);

16830

NDR_PULL_SET_MEM_CTX(ndr, r->in.transports, LIBNDR_FLAG_REF_ALLOC);

16831

NDR_CHECK(ndr_pull_srvsvc_NetTransportInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.transports));

16832

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_transports_0, LIBNDR_FLAG_REF_ALLOC);

16833

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.max_buffer));

16834

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_resume_handle));

16835

if (_ptr_resume_handle) {

16836

NDR_PULL_ALLOC(ndr, r->in.resume_handle);

16837

} else {

16838

r->in.resume_handle = NULL;

16839

}

16840

if (r->in.resume_handle) {

16841

_mem_save_resume_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);

16842

NDR_PULL_SET_MEM_CTX(ndr, r->in.resume_handle, 0);

16843

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->in.resume_handle));

16844

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_resume_handle_0, 0);

16845

}

16846

NDR_PULL_ALLOC(ndr, r->out.transports);

16847

*r->out.transports = *r->in.transports;

16848

NDR_PULL_ALLOC(ndr, r->out.totalentries);

16849

ZERO_STRUCTP(r->out.totalentries);

16850

}

16851

if (flags & NDR_OUT) {

16852

if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {

16853

NDR_PULL_ALLOC(ndr, r->out.transports);

16854

}

16855

_mem_save_transports_0 = NDR_PULL_GET_MEM_CTX(ndr);

16856

NDR_PULL_SET_MEM_CTX(ndr, r->out.transports, LIBNDR_FLAG_REF_ALLOC);

16857

NDR_CHECK(ndr_pull_srvsvc_NetTransportInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.transports));

16858

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_transports_0, LIBNDR_FLAG_REF_ALLOC);

16859

if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {

16860

NDR_PULL_ALLOC(ndr, r->out.totalentries);

16861

}

16862

_mem_save_totalentries_0 = NDR_PULL_GET_MEM_CTX(ndr);

16863

NDR_PULL_SET_MEM_CTX(ndr, r->out.totalentries, LIBNDR_FLAG_REF_ALLOC);

16864

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.totalentries));

16865

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_totalentries_0, LIBNDR_FLAG_REF_ALLOC);

16866

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_resume_handle));

16867

if (_ptr_resume_handle) {

16868

NDR_PULL_ALLOC(ndr, r->out.resume_handle);

16869

} else {

16870

r->out.resume_handle = NULL;

16871

}

16872

if (r->out.resume_handle) {

16873

_mem_save_resume_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);

16874

NDR_PULL_SET_MEM_CTX(ndr, r->out.resume_handle, 0);

16875

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.resume_handle));

16876

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_resume_handle_0, 0);

16877

}

16878

NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));

16879

}

16880

return NDR_ERR_SUCCESS;

16881

}

16882

16883

_PUBLIC_ void ndr_print_srvsvc_NetTransportEnum(struct ndr_print *ndr, const char *name, int flags, const struct srvsvc_NetTransportEnum *r)

16884

{

16885

ndr_print_struct(ndr, name, "srvsvc_NetTransportEnum");

16886

ndr->depth++;

16887

if (flags & NDR_SET_VALUES) {

16888

ndr->flags |= LIBNDR_PRINT_SET_VALUES;

16889

}

16890

if (flags & NDR_IN) {

16891

ndr_print_struct(ndr, "in", "srvsvc_NetTransportEnum");

16892

ndr->depth++;

16893

ndr_print_ptr(ndr, "server_unc", r->in.server_unc);

16894

ndr->depth++;

16895

if (r->in.server_unc) {

16896

ndr_print_string(ndr, "server_unc", r->in.server_unc);

16897

}

16898

ndr->depth--;

16899

ndr_print_ptr(ndr, "transports", r->in.transports);

16900

ndr->depth++;

16901

ndr_print_srvsvc_NetTransportInfoCtr(ndr, "transports", r->in.transports);

16902

ndr->depth--;

16903

ndr_print_uint32(ndr, "max_buffer", r->in.max_buffer);

16904

ndr_print_ptr(ndr, "resume_handle", r->in.resume_handle);

16905

ndr->depth++;

16906

if (r->in.resume_handle) {

16907

ndr_print_uint32(ndr, "resume_handle", *r->in.resume_handle);

16908

}

16909

ndr->depth--;

16910

ndr->depth--;

16911

}

16912

if (flags & NDR_OUT) {

16913

ndr_print_struct(ndr, "out", "srvsvc_NetTransportEnum");

16914

ndr->depth++;

16915

ndr_print_ptr(ndr, "transports", r->out.transports);

16916

ndr->depth++;

16917

ndr_print_srvsvc_NetTransportInfoCtr(ndr, "transports", r->out.transports);

16918

ndr->depth--;

16919

ndr_print_ptr(ndr, "totalentries", r->out.totalentries);

16920

ndr->depth++;

16921

ndr_print_uint32(ndr, "totalentries", *r->out.totalentries);

16922

ndr->depth--;

16923

ndr_print_ptr(ndr, "resume_handle", r->out.resume_handle);

16924

ndr->depth++;

16925

if (r->out.resume_handle) {

16926

ndr_print_uint32(ndr, "resume_handle", *r->out.resume_handle);

16927

}

16928

ndr->depth--;

16929

ndr_print_WERROR(ndr, "result", r->out.result);

16930

ndr->depth--;

16931

}

16932

ndr->depth--;

16933

}

16934

16935

static enum ndr_err_code ndr_push_srvsvc_NetTransportDel(struct ndr_push *ndr, int flags, const struct srvsvc_NetTransportDel *r)

16936

{

16937

if (flags & NDR_IN) {

16938

NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server_unc));

16939

if (r->in.server_unc) {

16940

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_unc, CH_UTF16)));

16941

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));

16942

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_unc, CH_UTF16)));

16943

NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server_unc, ndr_charset_length(r->in.server_unc, CH_UTF16), sizeof(uint16_t), CH_UTF16));

16944

}

16945

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));

16946

if (r->in.info0 == NULL) {

16947

return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");

16948

}

16949

NDR_CHECK(ndr_push_srvsvc_NetTransportInfo0(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info0));

16950

}

16951

if (flags & NDR_OUT) {

16952

NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));

16953

}

16954

return NDR_ERR_SUCCESS;

16955

}

16956

16957

static enum ndr_err_code ndr_pull_srvsvc_NetTransportDel(struct ndr_pull *ndr, int flags, struct srvsvc_NetTransportDel *r)

16958

{

16959

uint32_t _ptr_server_unc;

16960

TALLOC_CTX *_mem_save_server_unc_0;

16961

TALLOC_CTX *_mem_save_info0_0;

16962

if (flags & NDR_IN) {

16963

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_unc));

16964

if (_ptr_server_unc) {

16965

NDR_PULL_ALLOC(ndr, r->in.server_unc);

16966

} else {

16967

r->in.server_unc = NULL;

16968

}

16969

if (r->in.server_unc) {

16970

_mem_save_server_unc_0 = NDR_PULL_GET_MEM_CTX(ndr);

16971

NDR_PULL_SET_MEM_CTX(ndr, r->in.server_unc, 0);

16972

NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_unc));

16973

NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_unc));

16974

if (ndr_get_array_length(ndr, &r->in.server_unc) > ndr_get_array_size(ndr, &r->in.server_unc)) {

16975

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.server_unc), ndr_get_array_length(ndr, &r->in.server_unc));

16976

}

16977

NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server_unc), sizeof(uint16_t)));

16978

NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server_unc, ndr_get_array_length(ndr, &r->in.server_unc), sizeof(uint16_t), CH_UTF16));

16979

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_unc_0, 0);

16980

}

16981

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));

16982

if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {

16983

NDR_PULL_ALLOC(ndr, r->in.info0);

16984

}

16985

_mem_save_info0_0 = NDR_PULL_GET_MEM_CTX(ndr);

16986

NDR_PULL_SET_MEM_CTX(ndr, r->in.info0, LIBNDR_FLAG_REF_ALLOC);

16987

NDR_CHECK(ndr_pull_srvsvc_NetTransportInfo0(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info0));

16988

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info0_0, LIBNDR_FLAG_REF_ALLOC);

16989

}

16990

if (flags & NDR_OUT) {

16991

NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));

16992

}

16993

return NDR_ERR_SUCCESS;

16994

}

16995

16996

_PUBLIC_ void ndr_print_srvsvc_NetTransportDel(struct ndr_print *ndr, const char *name, int flags, const struct srvsvc_NetTransportDel *r)

16997

{

16998

ndr_print_struct(ndr, name, "srvsvc_NetTransportDel");

16999

ndr->depth++;

17000

if (flags & NDR_SET_VALUES) {

17001

ndr->flags |= LIBNDR_PRINT_SET_VALUES;

17002

}

17003

if (flags & NDR_IN) {

17004

ndr_print_struct(ndr, "in", "srvsvc_NetTransportDel");

17005

ndr->depth++;

17006

ndr_print_ptr(ndr, "server_unc", r->in.server_unc);

17007

ndr->depth++;

17008

if (r->in.server_unc) {

17009

ndr_print_string(ndr, "server_unc", r->in.server_unc);

17010

}

17011

ndr->depth--;

17012

ndr_print_uint32(ndr, "level", r->in.level);

17013

ndr_print_ptr(ndr, "info0", r->in.info0);

17014

ndr->depth++;

17015

ndr_print_srvsvc_NetTransportInfo0(ndr, "info0", r->in.info0);

17016

ndr->depth--;

17017

ndr->depth--;

17018

}

17019

if (flags & NDR_OUT) {

17020

ndr_print_struct(ndr, "out", "srvsvc_NetTransportDel");

17021

ndr->depth++;

17022

ndr_print_WERROR(ndr, "result", r->out.result);

17023

ndr->depth--;

17024

}

17025

ndr->depth--;

17026

}

17027

17028

static enum ndr_err_code ndr_push_srvsvc_NetRemoteTOD(struct ndr_push *ndr, int flags, const struct srvsvc_NetRemoteTOD *r)

17029

{

17030

if (flags & NDR_IN) {

17031

NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server_unc));

17032

if (r->in.server_unc) {

17033

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_unc, CH_UTF16)));

17034

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));

17035

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_unc, CH_UTF16)));

17036

NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server_unc, ndr_charset_length(r->in.server_unc, CH_UTF16), sizeof(uint16_t), CH_UTF16));

17037

}

17038

}

17039

if (flags & NDR_OUT) {

17040

if (r->out.info == NULL) {

17041

return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");

17042

}

17043

NDR_CHECK(ndr_push_unique_ptr(ndr, *r->out.info));

17044

if (*r->out.info) {

17045

NDR_CHECK(ndr_push_srvsvc_NetRemoteTODInfo(ndr, NDR_SCALARS, *r->out.info));

17046

}

17047

NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));

17048

}

17049

return NDR_ERR_SUCCESS;

17050

}

17051

17052

static enum ndr_err_code ndr_pull_srvsvc_NetRemoteTOD(struct ndr_pull *ndr, int flags, struct srvsvc_NetRemoteTOD *r)

17053

{

17054

uint32_t _ptr_server_unc;

17055

uint32_t _ptr_info;

17056

TALLOC_CTX *_mem_save_server_unc_0;

17057

TALLOC_CTX *_mem_save_info_0;

17058

TALLOC_CTX *_mem_save_info_1;

17059

if (flags & NDR_IN) {

17060

ZERO_STRUCT(r->out);

17061

17062

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_unc));

17063

if (_ptr_server_unc) {

17064

NDR_PULL_ALLOC(ndr, r->in.server_unc);

17065

} else {

17066

r->in.server_unc = NULL;

17067

}

17068

if (r->in.server_unc) {

17069

_mem_save_server_unc_0 = NDR_PULL_GET_MEM_CTX(ndr);

17070

NDR_PULL_SET_MEM_CTX(ndr, r->in.server_unc, 0);

17071

NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_unc));

17072

NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_unc));

17073

if (ndr_get_array_length(ndr, &r->in.server_unc) > ndr_get_array_size(ndr, &r->in.server_unc)) {

17074

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.server_unc), ndr_get_array_length(ndr, &r->in.server_unc));

17075

}

17076

NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server_unc), sizeof(uint16_t)));

17077

NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server_unc, ndr_get_array_length(ndr, &r->in.server_unc), sizeof(uint16_t), CH_UTF16));

17078

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_unc_0, 0);

17079

}

17080

NDR_PULL_ALLOC(ndr, r->out.info);

17081

ZERO_STRUCTP(r->out.info);

17082

}

17083

if (flags & NDR_OUT) {

17084

if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {

17085

NDR_PULL_ALLOC(ndr, r->out.info);

17086

}

17087

_mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);

17088

NDR_PULL_SET_MEM_CTX(ndr, r->out.info, LIBNDR_FLAG_REF_ALLOC);

17089

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));

17090

if (_ptr_info) {

17091

NDR_PULL_ALLOC(ndr, *r->out.info);

17092

} else {

17093

*r->out.info = NULL;

17094

}

17095

if (*r->out.info) {

17096

_mem_save_info_1 = NDR_PULL_GET_MEM_CTX(ndr);

17097

NDR_PULL_SET_MEM_CTX(ndr, *r->out.info, 0);

17098

NDR_CHECK(ndr_pull_srvsvc_NetRemoteTODInfo(ndr, NDR_SCALARS, *r->out.info));

17099

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_1, 0);

17100

}

17101

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, LIBNDR_FLAG_REF_ALLOC);

17102

NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));

17103

}

17104

return NDR_ERR_SUCCESS;

17105

}

17106

17107

_PUBLIC_ void ndr_print_srvsvc_NetRemoteTOD(struct ndr_print *ndr, const char *name, int flags, const struct srvsvc_NetRemoteTOD *r)

17108

{

17109

ndr_print_struct(ndr, name, "srvsvc_NetRemoteTOD");

17110

ndr->depth++;

17111

if (flags & NDR_SET_VALUES) {

17112

ndr->flags |= LIBNDR_PRINT_SET_VALUES;

17113

}

17114

if (flags & NDR_IN) {

17115

ndr_print_struct(ndr, "in", "srvsvc_NetRemoteTOD");

17116

ndr->depth++;

17117

ndr_print_ptr(ndr, "server_unc", r->in.server_unc);

17118

ndr->depth++;

17119

if (r->in.server_unc) {

17120

ndr_print_string(ndr, "server_unc", r->in.server_unc);

17121

}

17122

ndr->depth--;

17123

ndr->depth--;

17124

}

17125

if (flags & NDR_OUT) {

17126

ndr_print_struct(ndr, "out", "srvsvc_NetRemoteTOD");

17127

ndr->depth++;

17128

ndr_print_ptr(ndr, "info", r->out.info);

17129

ndr->depth++;

17130

ndr_print_ptr(ndr, "info", *r->out.info);

17131

ndr->depth++;

17132

if (*r->out.info) {

17133

ndr_print_srvsvc_NetRemoteTODInfo(ndr, "info", *r->out.info);

17134

}

17135

ndr->depth--;

17136

ndr->depth--;

17137

ndr_print_WERROR(ndr, "result", r->out.result);

17138

ndr->depth--;

17139

}

17140

ndr->depth--;

17141

}

17142

17143

static enum ndr_err_code ndr_push_srvsvc_NetSetServiceBits(struct ndr_push *ndr, int flags, const struct srvsvc_NetSetServiceBits *r)

17144

{

17145

if (flags & NDR_IN) {

17146

NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server_unc));

17147

if (r->in.server_unc) {

17148

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_unc, CH_UTF16)));

17149

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));

17150

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_unc, CH_UTF16)));

17151

NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server_unc, ndr_charset_length(r->in.server_unc, CH_UTF16), sizeof(uint16_t), CH_UTF16));

17152

}

17153

NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.transport));

17154

if (r->in.transport) {

17155

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.transport, CH_UTF16)));

17156

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));

17157

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.transport, CH_UTF16)));

17158

NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.transport, ndr_charset_length(r->in.transport, CH_UTF16), sizeof(uint16_t), CH_UTF16));

17159

}

17160

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.servicebits));

17161

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.updateimmediately));

17162

}

17163

if (flags & NDR_OUT) {

17164

NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));

17165

}

17166

return NDR_ERR_SUCCESS;

17167

}

17168

17169

static enum ndr_err_code ndr_pull_srvsvc_NetSetServiceBits(struct ndr_pull *ndr, int flags, struct srvsvc_NetSetServiceBits *r)

17170

{

17171

uint32_t _ptr_server_unc;

17172

uint32_t _ptr_transport;

17173

TALLOC_CTX *_mem_save_server_unc_0;

17174

TALLOC_CTX *_mem_save_transport_0;

17175

if (flags & NDR_IN) {

17176

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_unc));

17177

if (_ptr_server_unc) {

17178

NDR_PULL_ALLOC(ndr, r->in.server_unc);

17179

} else {

17180

r->in.server_unc = NULL;

17181

}

17182

if (r->in.server_unc) {

17183

_mem_save_server_unc_0 = NDR_PULL_GET_MEM_CTX(ndr);

17184

NDR_PULL_SET_MEM_CTX(ndr, r->in.server_unc, 0);

17185

NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_unc));

17186

NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_unc));

17187

if (ndr_get_array_length(ndr, &r->in.server_unc) > ndr_get_array_size(ndr, &r->in.server_unc)) {

17188

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.server_unc), ndr_get_array_length(ndr, &r->in.server_unc));

17189

}

17190

NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server_unc), sizeof(uint16_t)));

17191

NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server_unc, ndr_get_array_length(ndr, &r->in.server_unc), sizeof(uint16_t), CH_UTF16));

17192

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_unc_0, 0);

17193

}

17194

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_transport));

17195

if (_ptr_transport) {

17196

NDR_PULL_ALLOC(ndr, r->in.transport);

17197

} else {

17198

r->in.transport = NULL;

17199

}

17200

if (r->in.transport) {

17201

_mem_save_transport_0 = NDR_PULL_GET_MEM_CTX(ndr);

17202

NDR_PULL_SET_MEM_CTX(ndr, r->in.transport, 0);

17203

NDR_CHECK(ndr_pull_array_size(ndr, &r->in.transport));

17204

NDR_CHECK(ndr_pull_array_length(ndr, &r->in.transport));

17205

if (ndr_get_array_length(ndr, &r->in.transport) > ndr_get_array_size(ndr, &r->in.transport)) {

17206

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.transport), ndr_get_array_length(ndr, &r->in.transport));

17207

}

17208

NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.transport), sizeof(uint16_t)));

17209

NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.transport, ndr_get_array_length(ndr, &r->in.transport), sizeof(uint16_t), CH_UTF16));

17210

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_transport_0, 0);

17211

}

17212

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.servicebits));

17213

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.updateimmediately));

17214

}

17215

if (flags & NDR_OUT) {

17216

NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));

17217

}

17218

return NDR_ERR_SUCCESS;

17219

}

17220

17221

_PUBLIC_ void ndr_print_srvsvc_NetSetServiceBits(struct ndr_print *ndr, const char *name, int flags, const struct srvsvc_NetSetServiceBits *r)

17222

{

17223

ndr_print_struct(ndr, name, "srvsvc_NetSetServiceBits");

17224

ndr->depth++;

17225

if (flags & NDR_SET_VALUES) {

17226

ndr->flags |= LIBNDR_PRINT_SET_VALUES;

17227

}

17228

if (flags & NDR_IN) {

17229

ndr_print_struct(ndr, "in", "srvsvc_NetSetServiceBits");

17230

ndr->depth++;

17231

ndr_print_ptr(ndr, "server_unc", r->in.server_unc);

17232

ndr->depth++;

17233

if (r->in.server_unc) {

17234

ndr_print_string(ndr, "server_unc", r->in.server_unc);

17235

}

17236

ndr->depth--;

17237

ndr_print_ptr(ndr, "transport", r->in.transport);

17238

ndr->depth++;

17239

if (r->in.transport) {

17240

ndr_print_string(ndr, "transport", r->in.transport);

17241

}

17242

ndr->depth--;

17243

ndr_print_uint32(ndr, "servicebits", r->in.servicebits);

17244

ndr_print_uint32(ndr, "updateimmediately", r->in.updateimmediately);

17245

ndr->depth--;

17246

}

17247

if (flags & NDR_OUT) {

17248

ndr_print_struct(ndr, "out", "srvsvc_NetSetServiceBits");

17249

ndr->depth++;

17250

ndr_print_WERROR(ndr, "result", r->out.result);

17251

ndr->depth--;

17252

}

17253

ndr->depth--;

17254

}

17255

17256

static enum ndr_err_code ndr_push_srvsvc_NetPathType(struct ndr_push *ndr, int flags, const struct srvsvc_NetPathType *r)

17257

{

17258

if (flags & NDR_IN) {

17259

NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server_unc));

17260

if (r->in.server_unc) {

17261

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_unc, CH_UTF16)));

17262

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));

17263

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_unc, CH_UTF16)));

17264

NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server_unc, ndr_charset_length(r->in.server_unc, CH_UTF16), sizeof(uint16_t), CH_UTF16));

17265

}

17266

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.path, CH_UTF16)));

17267

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));

17268

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.path, CH_UTF16)));

17269

NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.path, ndr_charset_length(r->in.path, CH_UTF16), sizeof(uint16_t), CH_UTF16));

17270

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.pathflags));

17271

}

17272

if (flags & NDR_OUT) {

17273

if (r->out.pathtype == NULL) {

17274

return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");

17275

}

17276

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.pathtype));

17277

NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));

17278

}

17279

return NDR_ERR_SUCCESS;

17280

}

17281

17282

static enum ndr_err_code ndr_pull_srvsvc_NetPathType(struct ndr_pull *ndr, int flags, struct srvsvc_NetPathType *r)

17283

{

17284

uint32_t _ptr_server_unc;

17285

TALLOC_CTX *_mem_save_server_unc_0;

17286

TALLOC_CTX *_mem_save_pathtype_0;

17287

if (flags & NDR_IN) {

17288

ZERO_STRUCT(r->out);

17289

17290

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_unc));

17291

if (_ptr_server_unc) {

17292

NDR_PULL_ALLOC(ndr, r->in.server_unc);

17293

} else {

17294

r->in.server_unc = NULL;

17295

}

17296

if (r->in.server_unc) {

17297

_mem_save_server_unc_0 = NDR_PULL_GET_MEM_CTX(ndr);

17298

NDR_PULL_SET_MEM_CTX(ndr, r->in.server_unc, 0);

17299

NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_unc));

17300

NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_unc));

17301

if (ndr_get_array_length(ndr, &r->in.server_unc) > ndr_get_array_size(ndr, &r->in.server_unc)) {

17302

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.server_unc), ndr_get_array_length(ndr, &r->in.server_unc));

17303

}

17304

NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server_unc), sizeof(uint16_t)));

17305

NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server_unc, ndr_get_array_length(ndr, &r->in.server_unc), sizeof(uint16_t), CH_UTF16));

17306

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_unc_0, 0);

17307

}

17308

NDR_CHECK(ndr_pull_array_size(ndr, &r->in.path));

17309

NDR_CHECK(ndr_pull_array_length(ndr, &r->in.path));

17310

if (ndr_get_array_length(ndr, &r->in.path) > ndr_get_array_size(ndr, &r->in.path)) {

17311

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.path), ndr_get_array_length(ndr, &r->in.path));

17312

}

17313

NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.path), sizeof(uint16_t)));

17314

NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.path, ndr_get_array_length(ndr, &r->in.path), sizeof(uint16_t), CH_UTF16));

17315

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.pathflags));

17316

NDR_PULL_ALLOC(ndr, r->out.pathtype);

17317

ZERO_STRUCTP(r->out.pathtype);

17318

}

17319

if (flags & NDR_OUT) {

17320

if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {

17321

NDR_PULL_ALLOC(ndr, r->out.pathtype);

17322

}

17323

_mem_save_pathtype_0 = NDR_PULL_GET_MEM_CTX(ndr);

17324

NDR_PULL_SET_MEM_CTX(ndr, r->out.pathtype, LIBNDR_FLAG_REF_ALLOC);

17325

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.pathtype));

17326

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_pathtype_0, LIBNDR_FLAG_REF_ALLOC);

17327

NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));

17328

}

17329

return NDR_ERR_SUCCESS;

17330

}

17331

17332

_PUBLIC_ void ndr_print_srvsvc_NetPathType(struct ndr_print *ndr, const char *name, int flags, const struct srvsvc_NetPathType *r)

17333

{

17334

ndr_print_struct(ndr, name, "srvsvc_NetPathType");

17335

ndr->depth++;

17336

if (flags & NDR_SET_VALUES) {

17337

ndr->flags |= LIBNDR_PRINT_SET_VALUES;

17338

}

17339

if (flags & NDR_IN) {

17340

ndr_print_struct(ndr, "in", "srvsvc_NetPathType");

17341

ndr->depth++;

17342

ndr_print_ptr(ndr, "server_unc", r->in.server_unc);

17343

ndr->depth++;

17344

if (r->in.server_unc) {

17345

ndr_print_string(ndr, "server_unc", r->in.server_unc);

17346

}

17347

ndr->depth--;

17348

ndr_print_string(ndr, "path", r->in.path);

17349

ndr_print_uint32(ndr, "pathflags", r->in.pathflags);

17350

ndr->depth--;

17351

}

17352

if (flags & NDR_OUT) {

17353

ndr_print_struct(ndr, "out", "srvsvc_NetPathType");

17354

ndr->depth++;

17355

ndr_print_ptr(ndr, "pathtype", r->out.pathtype);

17356

ndr->depth++;

17357

ndr_print_uint32(ndr, "pathtype", *r->out.pathtype);

17358

ndr->depth--;

17359

ndr_print_WERROR(ndr, "result", r->out.result);

17360

ndr->depth--;

17361

}

17362

ndr->depth--;

17363

}

17364

17365

static enum ndr_err_code ndr_push_srvsvc_NetPathCanonicalize(struct ndr_push *ndr, int flags, const struct srvsvc_NetPathCanonicalize *r)

17366

{

17367

if (flags & NDR_IN) {

17368

NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server_unc));

17369

if (r->in.server_unc) {

17370

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_unc, CH_UTF16)));

17371

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));

17372

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_unc, CH_UTF16)));

17373

NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server_unc, ndr_charset_length(r->in.server_unc, CH_UTF16), sizeof(uint16_t), CH_UTF16));

17374

}

17375

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.path, CH_UTF16)));

17376

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));

17377

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.path, CH_UTF16)));

17378

NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.path, ndr_charset_length(r->in.path, CH_UTF16), sizeof(uint16_t), CH_UTF16));

17379

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.maxbuf));

17380

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.prefix, CH_UTF16)));

17381

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));

17382

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.prefix, CH_UTF16)));

17383

NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.prefix, ndr_charset_length(r->in.prefix, CH_UTF16), sizeof(uint16_t), CH_UTF16));

17384

if (r->in.pathtype == NULL) {

17385

return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");

17386

}

17387

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->in.pathtype));

17388

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.pathflags));

17389

}

17390

if (flags & NDR_OUT) {

17391

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.maxbuf));

17392

NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->out.can_path, r->in.maxbuf));

17393

if (r->out.pathtype == NULL) {

17394

return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");

17395

}

17396

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.pathtype));

17397

NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));

17398

}

17399

return NDR_ERR_SUCCESS;

17400

}

17401

17402

static enum ndr_err_code ndr_pull_srvsvc_NetPathCanonicalize(struct ndr_pull *ndr, int flags, struct srvsvc_NetPathCanonicalize *r)

17403

{

17404

uint32_t _ptr_server_unc;

17405

TALLOC_CTX *_mem_save_server_unc_0;

17406

TALLOC_CTX *_mem_save_pathtype_0;

17407

if (flags & NDR_IN) {

17408

ZERO_STRUCT(r->out);

17409

17410

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_unc));

17411

if (_ptr_server_unc) {

17412

NDR_PULL_ALLOC(ndr, r->in.server_unc);

17413

} else {

17414

r->in.server_unc = NULL;

17415

}

17416

if (r->in.server_unc) {

17417

_mem_save_server_unc_0 = NDR_PULL_GET_MEM_CTX(ndr);

17418

NDR_PULL_SET_MEM_CTX(ndr, r->in.server_unc, 0);

17419

NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_unc));

17420

NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_unc));

17421

if (ndr_get_array_length(ndr, &r->in.server_unc) > ndr_get_array_size(ndr, &r->in.server_unc)) {

17422

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.server_unc), ndr_get_array_length(ndr, &r->in.server_unc));

17423

}

17424

NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server_unc), sizeof(uint16_t)));

17425

NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server_unc, ndr_get_array_length(ndr, &r->in.server_unc), sizeof(uint16_t), CH_UTF16));

17426

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_unc_0, 0);

17427

}

17428

NDR_CHECK(ndr_pull_array_size(ndr, &r->in.path));

17429

NDR_CHECK(ndr_pull_array_length(ndr, &r->in.path));

17430

if (ndr_get_array_length(ndr, &r->in.path) > ndr_get_array_size(ndr, &r->in.path)) {

17431

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.path), ndr_get_array_length(ndr, &r->in.path));

17432

}

17433

NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.path), sizeof(uint16_t)));

17434

NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.path, ndr_get_array_length(ndr, &r->in.path), sizeof(uint16_t), CH_UTF16));

17435

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.maxbuf));

17436

NDR_CHECK(ndr_pull_array_size(ndr, &r->in.prefix));

17437

NDR_CHECK(ndr_pull_array_length(ndr, &r->in.prefix));

17438

if (ndr_get_array_length(ndr, &r->in.prefix) > ndr_get_array_size(ndr, &r->in.prefix)) {

17439

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.prefix), ndr_get_array_length(ndr, &r->in.prefix));

17440

}

17441

NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.prefix), sizeof(uint16_t)));

17442

NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.prefix, ndr_get_array_length(ndr, &r->in.prefix), sizeof(uint16_t), CH_UTF16));

17443

if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {

17444

NDR_PULL_ALLOC(ndr, r->in.pathtype);

17445

}

17446

_mem_save_pathtype_0 = NDR_PULL_GET_MEM_CTX(ndr);

17447

NDR_PULL_SET_MEM_CTX(ndr, r->in.pathtype, LIBNDR_FLAG_REF_ALLOC);

17448

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->in.pathtype));

17449

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_pathtype_0, LIBNDR_FLAG_REF_ALLOC);

17450

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.pathflags));

17451

NDR_PULL_ALLOC(ndr, r->out.pathtype);

17452

*r->out.pathtype = *r->in.pathtype;

17453

}

17454

if (flags & NDR_OUT) {

17455

NDR_CHECK(ndr_pull_array_size(ndr, &r->out.can_path));

17456

NDR_PULL_ALLOC_N(ndr, r->out.can_path, ndr_get_array_size(ndr, &r->out.can_path));

17457

NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->out.can_path, ndr_get_array_size(ndr, &r->out.can_path)));

17458

if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {

17459

NDR_PULL_ALLOC(ndr, r->out.pathtype);

17460

}

17461

_mem_save_pathtype_0 = NDR_PULL_GET_MEM_CTX(ndr);

17462

NDR_PULL_SET_MEM_CTX(ndr, r->out.pathtype, LIBNDR_FLAG_REF_ALLOC);

17463

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.pathtype));

17464

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_pathtype_0, LIBNDR_FLAG_REF_ALLOC);

17465

NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));

17466

if (r->out.can_path) {

17467

NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->out.can_path, r->in.maxbuf));

17468

}

17469

}

17470

return NDR_ERR_SUCCESS;

17471

}

17472

17473

_PUBLIC_ void ndr_print_srvsvc_NetPathCanonicalize(struct ndr_print *ndr, const char *name, int flags, const struct srvsvc_NetPathCanonicalize *r)

17474

{

17475

ndr_print_struct(ndr, name, "srvsvc_NetPathCanonicalize");

17476

ndr->depth++;

17477

if (flags & NDR_SET_VALUES) {

17478

ndr->flags |= LIBNDR_PRINT_SET_VALUES;

17479

}

17480

if (flags & NDR_IN) {

17481

ndr_print_struct(ndr, "in", "srvsvc_NetPathCanonicalize");

17482

ndr->depth++;

17483

ndr_print_ptr(ndr, "server_unc", r->in.server_unc);

17484

ndr->depth++;

17485

if (r->in.server_unc) {

17486

ndr_print_string(ndr, "server_unc", r->in.server_unc);

17487

}

17488

ndr->depth--;

17489

ndr_print_string(ndr, "path", r->in.path);

17490

ndr_print_uint32(ndr, "maxbuf", r->in.maxbuf);

17491

ndr_print_string(ndr, "prefix", r->in.prefix);

17492

ndr_print_ptr(ndr, "pathtype", r->in.pathtype);

17493

ndr->depth++;

17494

ndr_print_uint32(ndr, "pathtype", *r->in.pathtype);

17495

ndr->depth--;

17496

ndr_print_uint32(ndr, "pathflags", r->in.pathflags);

17497

ndr->depth--;

17498

}

17499

if (flags & NDR_OUT) {

17500

ndr_print_struct(ndr, "out", "srvsvc_NetPathCanonicalize");

17501

ndr->depth++;

17502

ndr_print_array_uint8(ndr, "can_path", r->out.can_path, r->in.maxbuf);

17503

ndr_print_ptr(ndr, "pathtype", r->out.pathtype);

17504

ndr->depth++;

17505

ndr_print_uint32(ndr, "pathtype", *r->out.pathtype);

17506

ndr->depth--;

17507

ndr_print_WERROR(ndr, "result", r->out.result);

17508

ndr->depth--;

17509

}

17510

ndr->depth--;

17511

}

17512

17513

static enum ndr_err_code ndr_push_srvsvc_NetPathCompare(struct ndr_push *ndr, int flags, const struct srvsvc_NetPathCompare *r)

17514

{

17515

if (flags & NDR_IN) {

17516

NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server_unc));

17517

if (r->in.server_unc) {

17518

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_unc, CH_UTF16)));

17519

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));

17520

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_unc, CH_UTF16)));

17521

NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server_unc, ndr_charset_length(r->in.server_unc, CH_UTF16), sizeof(uint16_t), CH_UTF16));

17522

}

17523

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.path1, CH_UTF16)));

17524

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));

17525

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.path1, CH_UTF16)));

17526

NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.path1, ndr_charset_length(r->in.path1, CH_UTF16), sizeof(uint16_t), CH_UTF16));

17527

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.path2, CH_UTF16)));

17528

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));

17529

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.path2, CH_UTF16)));

17530

NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.path2, ndr_charset_length(r->in.path2, CH_UTF16), sizeof(uint16_t), CH_UTF16));

17531

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.pathtype));

17532

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.pathflags));

17533

}

17534

if (flags & NDR_OUT) {

17535

NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));

17536

}

17537

return NDR_ERR_SUCCESS;

17538

}

17539

17540

static enum ndr_err_code ndr_pull_srvsvc_NetPathCompare(struct ndr_pull *ndr, int flags, struct srvsvc_NetPathCompare *r)

17541

{

17542

uint32_t _ptr_server_unc;

17543

TALLOC_CTX *_mem_save_server_unc_0;

17544

if (flags & NDR_IN) {

17545

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_unc));

17546

if (_ptr_server_unc) {

17547

NDR_PULL_ALLOC(ndr, r->in.server_unc);

17548

} else {

17549

r->in.server_unc = NULL;

17550

}

17551

if (r->in.server_unc) {

17552

_mem_save_server_unc_0 = NDR_PULL_GET_MEM_CTX(ndr);

17553

NDR_PULL_SET_MEM_CTX(ndr, r->in.server_unc, 0);

17554

NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_unc));

17555

NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_unc));

17556

if (ndr_get_array_length(ndr, &r->in.server_unc) > ndr_get_array_size(ndr, &r->in.server_unc)) {

17557

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.server_unc), ndr_get_array_length(ndr, &r->in.server_unc));

17558

}

17559

NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server_unc), sizeof(uint16_t)));

17560

NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server_unc, ndr_get_array_length(ndr, &r->in.server_unc), sizeof(uint16_t), CH_UTF16));

17561

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_unc_0, 0);

17562

}

17563

NDR_CHECK(ndr_pull_array_size(ndr, &r->in.path1));

17564

NDR_CHECK(ndr_pull_array_length(ndr, &r->in.path1));

17565

if (ndr_get_array_length(ndr, &r->in.path1) > ndr_get_array_size(ndr, &r->in.path1)) {

17566

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.path1), ndr_get_array_length(ndr, &r->in.path1));

17567

}

17568

NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.path1), sizeof(uint16_t)));

17569

NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.path1, ndr_get_array_length(ndr, &r->in.path1), sizeof(uint16_t), CH_UTF16));

17570

NDR_CHECK(ndr_pull_array_size(ndr, &r->in.path2));

17571

NDR_CHECK(ndr_pull_array_length(ndr, &r->in.path2));

17572

if (ndr_get_array_length(ndr, &r->in.path2) > ndr_get_array_size(ndr, &r->in.path2)) {

17573

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.path2), ndr_get_array_length(ndr, &r->in.path2));

17574

}

17575

NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.path2), sizeof(uint16_t)));

17576

NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.path2, ndr_get_array_length(ndr, &r->in.path2), sizeof(uint16_t), CH_UTF16));

17577

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.pathtype));

17578

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.pathflags));

17579

}

17580

if (flags & NDR_OUT) {

17581

NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));

17582

}

17583

return NDR_ERR_SUCCESS;

17584

}

17585

17586

_PUBLIC_ void ndr_print_srvsvc_NetPathCompare(struct ndr_print *ndr, const char *name, int flags, const struct srvsvc_NetPathCompare *r)

17587

{

17588

ndr_print_struct(ndr, name, "srvsvc_NetPathCompare");

17589

ndr->depth++;

17590

if (flags & NDR_SET_VALUES) {

17591

ndr->flags |= LIBNDR_PRINT_SET_VALUES;

17592

}

17593

if (flags & NDR_IN) {

17594

ndr_print_struct(ndr, "in", "srvsvc_NetPathCompare");

17595

ndr->depth++;

17596

ndr_print_ptr(ndr, "server_unc", r->in.server_unc);

17597

ndr->depth++;

17598

if (r->in.server_unc) {

17599

ndr_print_string(ndr, "server_unc", r->in.server_unc);

17600

}

17601

ndr->depth--;

17602

ndr_print_string(ndr, "path1", r->in.path1);

17603

ndr_print_string(ndr, "path2", r->in.path2);

17604

ndr_print_uint32(ndr, "pathtype", r->in.pathtype);

17605

ndr_print_uint32(ndr, "pathflags", r->in.pathflags);

17606

ndr->depth--;

17607

}

17608

if (flags & NDR_OUT) {

17609

ndr_print_struct(ndr, "out", "srvsvc_NetPathCompare");

17610

ndr->depth++;

17611

ndr_print_WERROR(ndr, "result", r->out.result);

17612

ndr->depth--;

17613

}

17614

ndr->depth--;

17615

}

17616

17617

static enum ndr_err_code ndr_push_srvsvc_NetNameValidate(struct ndr_push *ndr, int flags, const struct srvsvc_NetNameValidate *r)

17618

{

17619

if (flags & NDR_IN) {

17620

NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server_unc));

17621

if (r->in.server_unc) {

17622

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_unc, CH_UTF16)));

17623

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));

17624

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_unc, CH_UTF16)));

17625

NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server_unc, ndr_charset_length(r->in.server_unc, CH_UTF16), sizeof(uint16_t), CH_UTF16));

17626

}

17627

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.name, CH_UTF16)));

17628

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));

17629

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.name, CH_UTF16)));

17630

NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.name, ndr_charset_length(r->in.name, CH_UTF16), sizeof(uint16_t), CH_UTF16));

17631

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.name_type));

17632

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.flags));

17633

}

17634

if (flags & NDR_OUT) {

17635

NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));

17636

}

17637

return NDR_ERR_SUCCESS;

17638

}

17639

17640

static enum ndr_err_code ndr_pull_srvsvc_NetNameValidate(struct ndr_pull *ndr, int flags, struct srvsvc_NetNameValidate *r)

17641

{

17642

uint32_t _ptr_server_unc;

17643

TALLOC_CTX *_mem_save_server_unc_0;

17644

if (flags & NDR_IN) {

17645

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_unc));

17646

if (_ptr_server_unc) {

17647

NDR_PULL_ALLOC(ndr, r->in.server_unc);

17648

} else {

17649

r->in.server_unc = NULL;

17650

}

17651

if (r->in.server_unc) {

17652

_mem_save_server_unc_0 = NDR_PULL_GET_MEM_CTX(ndr);

17653

NDR_PULL_SET_MEM_CTX(ndr, r->in.server_unc, 0);

17654

NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_unc));

17655

NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_unc));

17656

if (ndr_get_array_length(ndr, &r->in.server_unc) > ndr_get_array_size(ndr, &r->in.server_unc)) {

17657

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.server_unc), ndr_get_array_length(ndr, &r->in.server_unc));

17658

}

17659

NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server_unc), sizeof(uint16_t)));

17660

NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server_unc, ndr_get_array_length(ndr, &r->in.server_unc), sizeof(uint16_t), CH_UTF16));

17661

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_unc_0, 0);

17662

}

17663

NDR_CHECK(ndr_pull_array_size(ndr, &r->in.name));

17664

NDR_CHECK(ndr_pull_array_length(ndr, &r->in.name));

17665

if (ndr_get_array_length(ndr, &r->in.name) > ndr_get_array_size(ndr, &r->in.name)) {

17666

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.name), ndr_get_array_length(ndr, &r->in.name));

17667

}

17668

NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.name), sizeof(uint16_t)));

17669

NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.name, ndr_get_array_length(ndr, &r->in.name), sizeof(uint16_t), CH_UTF16));

17670

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.name_type));

17671

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.flags));

17672

}

17673

if (flags & NDR_OUT) {

17674

NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));

17675

}

17676

return NDR_ERR_SUCCESS;

17677

}

17678

17679

_PUBLIC_ void ndr_print_srvsvc_NetNameValidate(struct ndr_print *ndr, const char *name, int flags, const struct srvsvc_NetNameValidate *r)

17680

{

17681

ndr_print_struct(ndr, name, "srvsvc_NetNameValidate");

17682

ndr->depth++;

17683

if (flags & NDR_SET_VALUES) {

17684

ndr->flags |= LIBNDR_PRINT_SET_VALUES;

17685

}

17686

if (flags & NDR_IN) {

17687

ndr_print_struct(ndr, "in", "srvsvc_NetNameValidate");

17688

ndr->depth++;

17689

ndr_print_ptr(ndr, "server_unc", r->in.server_unc);

17690

ndr->depth++;

17691

if (r->in.server_unc) {

17692

ndr_print_string(ndr, "server_unc", r->in.server_unc);

17693

}

17694

ndr->depth--;

17695

ndr_print_string(ndr, "name", r->in.name);

17696

ndr_print_uint32(ndr, "name_type", r->in.name_type);

17697

ndr_print_uint32(ndr, "flags", r->in.flags);

17698

ndr->depth--;

17699

}

17700

if (flags & NDR_OUT) {

17701

ndr_print_struct(ndr, "out", "srvsvc_NetNameValidate");

17702

ndr->depth++;

17703

ndr_print_WERROR(ndr, "result", r->out.result);

17704

ndr->depth--;

17705

}

17706

ndr->depth--;

17707

}

17708

17709

static enum ndr_err_code ndr_push_srvsvc_NETRPRNAMECANONICALIZE(struct ndr_push *ndr, int flags, const struct srvsvc_NETRPRNAMECANONICALIZE *r)

17710

{

17711

if (flags & NDR_IN) {

17712

}

17713

if (flags & NDR_OUT) {

17714

NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));

17715

}

17716

return NDR_ERR_SUCCESS;

17717

}

17718

17719

static enum ndr_err_code ndr_pull_srvsvc_NETRPRNAMECANONICALIZE(struct ndr_pull *ndr, int flags, struct srvsvc_NETRPRNAMECANONICALIZE *r)

17720

{

17721

if (flags & NDR_IN) {

17722

}

17723

if (flags & NDR_OUT) {

17724

NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));

17725

}

17726

return NDR_ERR_SUCCESS;

17727

}

17728

17729

_PUBLIC_ void ndr_print_srvsvc_NETRPRNAMECANONICALIZE(struct ndr_print *ndr, const char *name, int flags, const struct srvsvc_NETRPRNAMECANONICALIZE *r)

17730

{

17731

ndr_print_struct(ndr, name, "srvsvc_NETRPRNAMECANONICALIZE");

17732

ndr->depth++;

17733

if (flags & NDR_SET_VALUES) {

17734

ndr->flags |= LIBNDR_PRINT_SET_VALUES;

17735

}

17736

if (flags & NDR_IN) {

17737

ndr_print_struct(ndr, "in", "srvsvc_NETRPRNAMECANONICALIZE");

17738

ndr->depth++;

17739

ndr->depth--;

17740

}

17741

if (flags & NDR_OUT) {

17742

ndr_print_struct(ndr, "out", "srvsvc_NETRPRNAMECANONICALIZE");

17743

ndr->depth++;

17744

ndr_print_WERROR(ndr, "result", r->out.result);

17745

ndr->depth--;

17746

}

17747

ndr->depth--;

17748

}

17749

17750

static enum ndr_err_code ndr_push_srvsvc_NetPRNameCompare(struct ndr_push *ndr, int flags, const struct srvsvc_NetPRNameCompare *r)

17751

{

17752

if (flags & NDR_IN) {

17753

NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server_unc));

17754

if (r->in.server_unc) {

17755

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_unc, CH_UTF16)));

17756

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));

17757

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_unc, CH_UTF16)));

17758

NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server_unc, ndr_charset_length(r->in.server_unc, CH_UTF16), sizeof(uint16_t), CH_UTF16));

17759

}

17760

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.name1, CH_UTF16)));

17761

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));

17762

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.name1, CH_UTF16)));

17763

NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.name1, ndr_charset_length(r->in.name1, CH_UTF16), sizeof(uint16_t), CH_UTF16));

17764

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.name2, CH_UTF16)));

17765

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));

17766

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.name2, CH_UTF16)));

17767

NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.name2, ndr_charset_length(r->in.name2, CH_UTF16), sizeof(uint16_t), CH_UTF16));

17768

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.name_type));

17769

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.flags));

17770

}

17771

if (flags & NDR_OUT) {

17772

NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));

17773

}

17774

return NDR_ERR_SUCCESS;

17775

}

17776

17777

static enum ndr_err_code ndr_pull_srvsvc_NetPRNameCompare(struct ndr_pull *ndr, int flags, struct srvsvc_NetPRNameCompare *r)

17778

{

17779

uint32_t _ptr_server_unc;

17780

TALLOC_CTX *_mem_save_server_unc_0;

17781

if (flags & NDR_IN) {

17782

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_unc));

17783

if (_ptr_server_unc) {

17784

NDR_PULL_ALLOC(ndr, r->in.server_unc);

17785

} else {

17786

r->in.server_unc = NULL;

17787

}

17788

if (r->in.server_unc) {

17789

_mem_save_server_unc_0 = NDR_PULL_GET_MEM_CTX(ndr);

17790

NDR_PULL_SET_MEM_CTX(ndr, r->in.server_unc, 0);

17791

NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_unc));

17792

NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_unc));

17793

if (ndr_get_array_length(ndr, &r->in.server_unc) > ndr_get_array_size(ndr, &r->in.server_unc)) {

17794

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.server_unc), ndr_get_array_length(ndr, &r->in.server_unc));

17795

}

17796

NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server_unc), sizeof(uint16_t)));

17797

NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server_unc, ndr_get_array_length(ndr, &r->in.server_unc), sizeof(uint16_t), CH_UTF16));

17798

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_unc_0, 0);

17799

}

17800

NDR_CHECK(ndr_pull_array_size(ndr, &r->in.name1));

17801

NDR_CHECK(ndr_pull_array_length(ndr, &r->in.name1));

17802

if (ndr_get_array_length(ndr, &r->in.name1) > ndr_get_array_size(ndr, &r->in.name1)) {

17803

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.name1), ndr_get_array_length(ndr, &r->in.name1));

17804

}

17805

NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.name1), sizeof(uint16_t)));

17806

NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.name1, ndr_get_array_length(ndr, &r->in.name1), sizeof(uint16_t), CH_UTF16));

17807

NDR_CHECK(ndr_pull_array_size(ndr, &r->in.name2));

17808

NDR_CHECK(ndr_pull_array_length(ndr, &r->in.name2));

17809

if (ndr_get_array_length(ndr, &r->in.name2) > ndr_get_array_size(ndr, &r->in.name2)) {

17810

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.name2), ndr_get_array_length(ndr, &r->in.name2));

17811

}

17812

NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.name2), sizeof(uint16_t)));

17813

NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.name2, ndr_get_array_length(ndr, &r->in.name2), sizeof(uint16_t), CH_UTF16));

17814

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.name_type));

17815

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.flags));

17816

}

17817

if (flags & NDR_OUT) {

17818

NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));

17819

}

17820

return NDR_ERR_SUCCESS;

17821

}

17822

17823

_PUBLIC_ void ndr_print_srvsvc_NetPRNameCompare(struct ndr_print *ndr, const char *name, int flags, const struct srvsvc_NetPRNameCompare *r)

17824

{

17825

ndr_print_struct(ndr, name, "srvsvc_NetPRNameCompare");

17826

ndr->depth++;

17827

if (flags & NDR_SET_VALUES) {

17828

ndr->flags |= LIBNDR_PRINT_SET_VALUES;

17829

}

17830

if (flags & NDR_IN) {

17831

ndr_print_struct(ndr, "in", "srvsvc_NetPRNameCompare");

17832

ndr->depth++;

17833

ndr_print_ptr(ndr, "server_unc", r->in.server_unc);

17834

ndr->depth++;

17835

if (r->in.server_unc) {

17836

ndr_print_string(ndr, "server_unc", r->in.server_unc);

17837

}

17838

ndr->depth--;

17839

ndr_print_string(ndr, "name1", r->in.name1);

17840

ndr_print_string(ndr, "name2", r->in.name2);

17841

ndr_print_uint32(ndr, "name_type", r->in.name_type);

17842

ndr_print_uint32(ndr, "flags", r->in.flags);

17843

ndr->depth--;

17844

}

17845

if (flags & NDR_OUT) {

17846

ndr_print_struct(ndr, "out", "srvsvc_NetPRNameCompare");

17847

ndr->depth++;

17848

ndr_print_WERROR(ndr, "result", r->out.result);

17849

ndr->depth--;

17850

}

17851

ndr->depth--;

17852

}

17853

17854

static enum ndr_err_code ndr_push_srvsvc_NetShareEnum(struct ndr_push *ndr, int flags, const struct srvsvc_NetShareEnum *r)

17855

{

17856

if (flags & NDR_IN) {

17857

NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server_unc));

17858

if (r->in.server_unc) {

17859

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_unc, CH_UTF16)));

17860

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));

17861

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_unc, CH_UTF16)));

17862

NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server_unc, ndr_charset_length(r->in.server_unc, CH_UTF16), sizeof(uint16_t), CH_UTF16));

17863

}

17864

if (r->in.info_ctr == NULL) {

17865

return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");

17866

}

17867

NDR_CHECK(ndr_push_srvsvc_NetShareInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info_ctr));

17868

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.max_buffer));

17869

NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.resume_handle));

17870

if (r->in.resume_handle) {

17871

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->in.resume_handle));

17872

}

17873

}

17874

if (flags & NDR_OUT) {

17875

if (r->out.info_ctr == NULL) {

17876

return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");

17877

}

17878

NDR_CHECK(ndr_push_srvsvc_NetShareInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.info_ctr));

17879

if (r->out.totalentries == NULL) {

17880

return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");

17881

}

17882

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.totalentries));

17883

NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.resume_handle));

17884

if (r->out.resume_handle) {

17885

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.resume_handle));

17886

}

17887

NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));

17888

}

17889

return NDR_ERR_SUCCESS;

17890

}

17891

17892

static enum ndr_err_code ndr_pull_srvsvc_NetShareEnum(struct ndr_pull *ndr, int flags, struct srvsvc_NetShareEnum *r)

17893

{

17894

uint32_t _ptr_server_unc;

17895

uint32_t _ptr_resume_handle;

17896

TALLOC_CTX *_mem_save_server_unc_0;

17897

TALLOC_CTX *_mem_save_info_ctr_0;

17898

TALLOC_CTX *_mem_save_totalentries_0;

17899

TALLOC_CTX *_mem_save_resume_handle_0;

17900

if (flags & NDR_IN) {

17901

ZERO_STRUCT(r->out);

17902

17903

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_unc));

17904

if (_ptr_server_unc) {

17905

NDR_PULL_ALLOC(ndr, r->in.server_unc);

17906

} else {

17907

r->in.server_unc = NULL;

17908

}

17909

if (r->in.server_unc) {

17910

_mem_save_server_unc_0 = NDR_PULL_GET_MEM_CTX(ndr);

17911

NDR_PULL_SET_MEM_CTX(ndr, r->in.server_unc, 0);

17912

NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_unc));

17913

NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_unc));

17914

if (ndr_get_array_length(ndr, &r->in.server_unc) > ndr_get_array_size(ndr, &r->in.server_unc)) {

17915

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.server_unc), ndr_get_array_length(ndr, &r->in.server_unc));

17916

}

17917

NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server_unc), sizeof(uint16_t)));

17918

NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server_unc, ndr_get_array_length(ndr, &r->in.server_unc), sizeof(uint16_t), CH_UTF16));

17919

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_unc_0, 0);

17920

}

17921

if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {

17922

NDR_PULL_ALLOC(ndr, r->in.info_ctr);

17923

}

17924

_mem_save_info_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);

17925

NDR_PULL_SET_MEM_CTX(ndr, r->in.info_ctr, LIBNDR_FLAG_REF_ALLOC);

17926

NDR_CHECK(ndr_pull_srvsvc_NetShareInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info_ctr));

17927

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_ctr_0, LIBNDR_FLAG_REF_ALLOC);

17928

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.max_buffer));

17929

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_resume_handle));

17930

if (_ptr_resume_handle) {

17931

NDR_PULL_ALLOC(ndr, r->in.resume_handle);

17932

} else {

17933

r->in.resume_handle = NULL;

17934

}

17935

if (r->in.resume_handle) {

17936

_mem_save_resume_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);

17937

NDR_PULL_SET_MEM_CTX(ndr, r->in.resume_handle, 0);

17938

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->in.resume_handle));

17939

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_resume_handle_0, 0);

17940

}

17941

NDR_PULL_ALLOC(ndr, r->out.info_ctr);

17942

*r->out.info_ctr = *r->in.info_ctr;

17943

NDR_PULL_ALLOC(ndr, r->out.totalentries);

17944

ZERO_STRUCTP(r->out.totalentries);

17945

}

17946

if (flags & NDR_OUT) {

17947

if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {

17948

NDR_PULL_ALLOC(ndr, r->out.info_ctr);

17949

}

17950

_mem_save_info_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);

17951

NDR_PULL_SET_MEM_CTX(ndr, r->out.info_ctr, LIBNDR_FLAG_REF_ALLOC);

17952

NDR_CHECK(ndr_pull_srvsvc_NetShareInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.info_ctr));

17953

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_ctr_0, LIBNDR_FLAG_REF_ALLOC);

17954

if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {

17955

NDR_PULL_ALLOC(ndr, r->out.totalentries);

17956

}

17957

_mem_save_totalentries_0 = NDR_PULL_GET_MEM_CTX(ndr);

17958

NDR_PULL_SET_MEM_CTX(ndr, r->out.totalentries, LIBNDR_FLAG_REF_ALLOC);

17959

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.totalentries));

17960

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_totalentries_0, LIBNDR_FLAG_REF_ALLOC);

17961

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_resume_handle));

17962

if (_ptr_resume_handle) {

17963

NDR_PULL_ALLOC(ndr, r->out.resume_handle);

17964

} else {

17965

r->out.resume_handle = NULL;

17966

}

17967

if (r->out.resume_handle) {

17968

_mem_save_resume_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);

17969

NDR_PULL_SET_MEM_CTX(ndr, r->out.resume_handle, 0);

17970

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.resume_handle));

17971

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_resume_handle_0, 0);

17972

}

17973

NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));

17974

}

17975

return NDR_ERR_SUCCESS;

17976

}

17977

17978

_PUBLIC_ void ndr_print_srvsvc_NetShareEnum(struct ndr_print *ndr, const char *name, int flags, const struct srvsvc_NetShareEnum *r)

17979

{

17980

ndr_print_struct(ndr, name, "srvsvc_NetShareEnum");

17981

ndr->depth++;

17982

if (flags & NDR_SET_VALUES) {

17983

ndr->flags |= LIBNDR_PRINT_SET_VALUES;

17984

}

17985

if (flags & NDR_IN) {

17986

ndr_print_struct(ndr, "in", "srvsvc_NetShareEnum");

17987

ndr->depth++;

17988

ndr_print_ptr(ndr, "server_unc", r->in.server_unc);

17989

ndr->depth++;

17990

if (r->in.server_unc) {

17991

ndr_print_string(ndr, "server_unc", r->in.server_unc);

17992

}

17993

ndr->depth--;

17994

ndr_print_ptr(ndr, "info_ctr", r->in.info_ctr);

17995

ndr->depth++;

17996

ndr_print_srvsvc_NetShareInfoCtr(ndr, "info_ctr", r->in.info_ctr);

17997

ndr->depth--;

17998

ndr_print_uint32(ndr, "max_buffer", r->in.max_buffer);

17999

ndr_print_ptr(ndr, "resume_handle", r->in.resume_handle);

18000

ndr->depth++;

18001

if (r->in.resume_handle) {

18002

ndr_print_uint32(ndr, "resume_handle", *r->in.resume_handle);

18003

}

18004

ndr->depth--;

18005

ndr->depth--;

18006

}

18007

if (flags & NDR_OUT) {

18008

ndr_print_struct(ndr, "out", "srvsvc_NetShareEnum");

18009

ndr->depth++;

18010

ndr_print_ptr(ndr, "info_ctr", r->out.info_ctr);

18011

ndr->depth++;

18012

ndr_print_srvsvc_NetShareInfoCtr(ndr, "info_ctr", r->out.info_ctr);

18013

ndr->depth--;

18014

ndr_print_ptr(ndr, "totalentries", r->out.totalentries);

18015

ndr->depth++;

18016

ndr_print_uint32(ndr, "totalentries", *r->out.totalentries);

18017

ndr->depth--;

18018

ndr_print_ptr(ndr, "resume_handle", r->out.resume_handle);

18019

ndr->depth++;

18020

if (r->out.resume_handle) {

18021

ndr_print_uint32(ndr, "resume_handle", *r->out.resume_handle);

18022

}

18023

ndr->depth--;

18024

ndr_print_WERROR(ndr, "result", r->out.result);

18025

ndr->depth--;

18026

}

18027

ndr->depth--;

18028

}

18029

18030

static enum ndr_err_code ndr_push_srvsvc_NetShareDelStart(struct ndr_push *ndr, int flags, const struct srvsvc_NetShareDelStart *r)

18031

{

18032

if (flags & NDR_IN) {

18033

NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server_unc));

18034

if (r->in.server_unc) {

18035

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_unc, CH_UTF16)));

18036

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));

18037

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_unc, CH_UTF16)));

18038

NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server_unc, ndr_charset_length(r->in.server_unc, CH_UTF16), sizeof(uint16_t), CH_UTF16));

18039

}

18040

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.share, CH_UTF16)));

18041

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));

18042

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.share, CH_UTF16)));

18043

NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.share, ndr_charset_length(r->in.share, CH_UTF16), sizeof(uint16_t), CH_UTF16));

18044

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.reserved));

18045

}

18046

if (flags & NDR_OUT) {

18047

NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.hnd));

18048

if (r->out.hnd) {

18049

NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.hnd));

18050

}

18051

NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));

18052

}

18053

return NDR_ERR_SUCCESS;

18054

}

18055

18056

static enum ndr_err_code ndr_pull_srvsvc_NetShareDelStart(struct ndr_pull *ndr, int flags, struct srvsvc_NetShareDelStart *r)

18057

{

18058

uint32_t _ptr_server_unc;

18059

uint32_t _ptr_hnd;

18060

TALLOC_CTX *_mem_save_server_unc_0;

18061

TALLOC_CTX *_mem_save_hnd_0;

18062

if (flags & NDR_IN) {

18063

ZERO_STRUCT(r->out);

18064

18065

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_unc));

18066

if (_ptr_server_unc) {

18067

NDR_PULL_ALLOC(ndr, r->in.server_unc);

18068

} else {

18069

r->in.server_unc = NULL;

18070

}

18071

if (r->in.server_unc) {

18072

_mem_save_server_unc_0 = NDR_PULL_GET_MEM_CTX(ndr);

18073

NDR_PULL_SET_MEM_CTX(ndr, r->in.server_unc, 0);

18074

NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_unc));

18075

NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_unc));

18076

if (ndr_get_array_length(ndr, &r->in.server_unc) > ndr_get_array_size(ndr, &r->in.server_unc)) {

18077

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.server_unc), ndr_get_array_length(ndr, &r->in.server_unc));

18078

}

18079

NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server_unc), sizeof(uint16_t)));

18080

NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server_unc, ndr_get_array_length(ndr, &r->in.server_unc), sizeof(uint16_t), CH_UTF16));

18081

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_unc_0, 0);

18082

}

18083

NDR_CHECK(ndr_pull_array_size(ndr, &r->in.share));

18084

NDR_CHECK(ndr_pull_array_length(ndr, &r->in.share));

18085

if (ndr_get_array_length(ndr, &r->in.share) > ndr_get_array_size(ndr, &r->in.share)) {

18086

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.share), ndr_get_array_length(ndr, &r->in.share));

18087

}

18088

NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.share), sizeof(uint16_t)));

18089

NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.share, ndr_get_array_length(ndr, &r->in.share), sizeof(uint16_t), CH_UTF16));

18090

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.reserved));

18091

}

18092

if (flags & NDR_OUT) {

18093

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_hnd));

18094

if (_ptr_hnd) {

18095

NDR_PULL_ALLOC(ndr, r->out.hnd);

18096

} else {

18097

r->out.hnd = NULL;

18098

}

18099

if (r->out.hnd) {

18100

_mem_save_hnd_0 = NDR_PULL_GET_MEM_CTX(ndr);

18101

NDR_PULL_SET_MEM_CTX(ndr, r->out.hnd, 0);

18102

NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.hnd));

18103

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_hnd_0, 0);

18104

}

18105

NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));

18106

}

18107

return NDR_ERR_SUCCESS;

18108

}

18109

18110

_PUBLIC_ void ndr_print_srvsvc_NetShareDelStart(struct ndr_print *ndr, const char *name, int flags, const struct srvsvc_NetShareDelStart *r)

18111

{

18112

ndr_print_struct(ndr, name, "srvsvc_NetShareDelStart");

18113

ndr->depth++;

18114

if (flags & NDR_SET_VALUES) {

18115

ndr->flags |= LIBNDR_PRINT_SET_VALUES;

18116

}

18117

if (flags & NDR_IN) {

18118

ndr_print_struct(ndr, "in", "srvsvc_NetShareDelStart");

18119

ndr->depth++;

18120

ndr_print_ptr(ndr, "server_unc", r->in.server_unc);

18121

ndr->depth++;

18122

if (r->in.server_unc) {

18123

ndr_print_string(ndr, "server_unc", r->in.server_unc);

18124

}

18125

ndr->depth--;

18126

ndr_print_string(ndr, "share", r->in.share);

18127

ndr_print_uint32(ndr, "reserved", r->in.reserved);

18128

ndr->depth--;

18129

}

18130

if (flags & NDR_OUT) {

18131

ndr_print_struct(ndr, "out", "srvsvc_NetShareDelStart");

18132

ndr->depth++;

18133

ndr_print_ptr(ndr, "hnd", r->out.hnd);

18134

ndr->depth++;

18135

if (r->out.hnd) {

18136

ndr_print_policy_handle(ndr, "hnd", r->out.hnd);

18137

}

18138

ndr->depth--;

18139

ndr_print_WERROR(ndr, "result", r->out.result);

18140

ndr->depth--;

18141

}

18142

ndr->depth--;

18143

}

18144

18145

static enum ndr_err_code ndr_push_srvsvc_NetShareDelCommit(struct ndr_push *ndr, int flags, const struct srvsvc_NetShareDelCommit *r)

18146

{

18147

if (flags & NDR_IN) {

18148

NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.hnd));

18149

if (r->in.hnd) {

18150

NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.hnd));

18151

}

18152

}

18153

if (flags & NDR_OUT) {

18154

NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.hnd));

18155

if (r->out.hnd) {

18156

NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.hnd));

18157

}

18158

NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));

18159

}

18160

return NDR_ERR_SUCCESS;

18161

}

18162

18163

static enum ndr_err_code ndr_pull_srvsvc_NetShareDelCommit(struct ndr_pull *ndr, int flags, struct srvsvc_NetShareDelCommit *r)

18164

{

18165

uint32_t _ptr_hnd;

18166

TALLOC_CTX *_mem_save_hnd_0;

18167

if (flags & NDR_IN) {

18168

ZERO_STRUCT(r->out);

18169

18170

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_hnd));

18171

if (_ptr_hnd) {

18172

NDR_PULL_ALLOC(ndr, r->in.hnd);

18173

} else {

18174

r->in.hnd = NULL;

18175

}

18176

if (r->in.hnd) {

18177

_mem_save_hnd_0 = NDR_PULL_GET_MEM_CTX(ndr);

18178

NDR_PULL_SET_MEM_CTX(ndr, r->in.hnd, 0);

18179

NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.hnd));

18180

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_hnd_0, 0);

18181

}

18182

}

18183

if (flags & NDR_OUT) {

18184

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_hnd));

18185

if (_ptr_hnd) {

18186

NDR_PULL_ALLOC(ndr, r->out.hnd);

18187

} else {

18188

r->out.hnd = NULL;

18189

}

18190

if (r->out.hnd) {

18191

_mem_save_hnd_0 = NDR_PULL_GET_MEM_CTX(ndr);

18192

NDR_PULL_SET_MEM_CTX(ndr, r->out.hnd, 0);

18193

NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.hnd));

18194

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_hnd_0, 0);

18195

}

18196

NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));

18197

}

18198

return NDR_ERR_SUCCESS;

18199

}

18200

18201

_PUBLIC_ void ndr_print_srvsvc_NetShareDelCommit(struct ndr_print *ndr, const char *name, int flags, const struct srvsvc_NetShareDelCommit *r)

18202

{

18203

ndr_print_struct(ndr, name, "srvsvc_NetShareDelCommit");

18204

ndr->depth++;

18205

if (flags & NDR_SET_VALUES) {

18206

ndr->flags |= LIBNDR_PRINT_SET_VALUES;

18207

}

18208

if (flags & NDR_IN) {

18209

ndr_print_struct(ndr, "in", "srvsvc_NetShareDelCommit");

18210

ndr->depth++;

18211

ndr_print_ptr(ndr, "hnd", r->in.hnd);

18212

ndr->depth++;

18213

if (r->in.hnd) {

18214

ndr_print_policy_handle(ndr, "hnd", r->in.hnd);

18215

}

18216

ndr->depth--;

18217

ndr->depth--;

18218

}

18219

if (flags & NDR_OUT) {

18220

ndr_print_struct(ndr, "out", "srvsvc_NetShareDelCommit");

18221

ndr->depth++;

18222

ndr_print_ptr(ndr, "hnd", r->out.hnd);

18223

ndr->depth++;

18224

if (r->out.hnd) {

18225

ndr_print_policy_handle(ndr, "hnd", r->out.hnd);

18226

}

18227

ndr->depth--;

18228

ndr_print_WERROR(ndr, "result", r->out.result);

18229

ndr->depth--;

18230

}

18231

ndr->depth--;

18232

}

18233

18234

static enum ndr_err_code ndr_push_srvsvc_NetGetFileSecurity(struct ndr_push *ndr, int flags, const struct srvsvc_NetGetFileSecurity *r)

18235

{

18236

if (flags & NDR_IN) {

18237

NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server_unc));

18238

if (r->in.server_unc) {

18239

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_unc, CH_UTF16)));

18240

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));

18241

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_unc, CH_UTF16)));

18242

NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server_unc, ndr_charset_length(r->in.server_unc, CH_UTF16), sizeof(uint16_t), CH_UTF16));

18243

}

18244

NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.share));

18245

if (r->in.share) {

18246

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.share, CH_UTF16)));

18247

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));

18248

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.share, CH_UTF16)));

18249

NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.share, ndr_charset_length(r->in.share, CH_UTF16), sizeof(uint16_t), CH_UTF16));

18250

}

18251

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.file, CH_UTF16)));

18252

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));

18253

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.file, CH_UTF16)));

18254

NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.file, ndr_charset_length(r->in.file, CH_UTF16), sizeof(uint16_t), CH_UTF16));

18255

NDR_CHECK(ndr_push_security_secinfo(ndr, NDR_SCALARS, r->in.securityinformation));

18256

}

18257

if (flags & NDR_OUT) {

18258

if (r->out.sd_buf == NULL) {

18259

return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");

18260

}

18261

NDR_CHECK(ndr_push_unique_ptr(ndr, *r->out.sd_buf));

18262

if (*r->out.sd_buf) {

18263

NDR_CHECK(ndr_push_sec_desc_buf(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.sd_buf));

18264

}

18265

NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));

18266

}

18267

return NDR_ERR_SUCCESS;

18268

}

18269

18270

static enum ndr_err_code ndr_pull_srvsvc_NetGetFileSecurity(struct ndr_pull *ndr, int flags, struct srvsvc_NetGetFileSecurity *r)

18271

{

18272

uint32_t _ptr_server_unc;

18273

uint32_t _ptr_share;

18274

uint32_t _ptr_sd_buf;

18275

TALLOC_CTX *_mem_save_server_unc_0;

18276

TALLOC_CTX *_mem_save_share_0;

18277

TALLOC_CTX *_mem_save_sd_buf_0;

18278

TALLOC_CTX *_mem_save_sd_buf_1;

18279

if (flags & NDR_IN) {

18280

ZERO_STRUCT(r->out);

18281

18282

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_unc));

18283

if (_ptr_server_unc) {

18284

NDR_PULL_ALLOC(ndr, r->in.server_unc);

18285

} else {

18286

r->in.server_unc = NULL;

18287

}

18288

if (r->in.server_unc) {

18289

_mem_save_server_unc_0 = NDR_PULL_GET_MEM_CTX(ndr);

18290

NDR_PULL_SET_MEM_CTX(ndr, r->in.server_unc, 0);

18291

NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_unc));

18292

NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_unc));

18293

if (ndr_get_array_length(ndr, &r->in.server_unc) > ndr_get_array_size(ndr, &r->in.server_unc)) {

18294

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.server_unc), ndr_get_array_length(ndr, &r->in.server_unc));

18295

}

18296

NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server_unc), sizeof(uint16_t)));

18297

NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server_unc, ndr_get_array_length(ndr, &r->in.server_unc), sizeof(uint16_t), CH_UTF16));

18298

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_unc_0, 0);

18299

}

18300

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_share));

18301

if (_ptr_share) {

18302

NDR_PULL_ALLOC(ndr, r->in.share);

18303

} else {

18304

r->in.share = NULL;

18305

}

18306

if (r->in.share) {

18307

_mem_save_share_0 = NDR_PULL_GET_MEM_CTX(ndr);

18308

NDR_PULL_SET_MEM_CTX(ndr, r->in.share, 0);

18309

NDR_CHECK(ndr_pull_array_size(ndr, &r->in.share));

18310

NDR_CHECK(ndr_pull_array_length(ndr, &r->in.share));

18311

if (ndr_get_array_length(ndr, &r->in.share) > ndr_get_array_size(ndr, &r->in.share)) {

18312

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.share), ndr_get_array_length(ndr, &r->in.share));

18313

}

18314

NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.share), sizeof(uint16_t)));

18315

NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.share, ndr_get_array_length(ndr, &r->in.share), sizeof(uint16_t), CH_UTF16));

18316

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_share_0, 0);

18317

}

18318

NDR_CHECK(ndr_pull_array_size(ndr, &r->in.file));

18319

NDR_CHECK(ndr_pull_array_length(ndr, &r->in.file));

18320

if (ndr_get_array_length(ndr, &r->in.file) > ndr_get_array_size(ndr, &r->in.file)) {

18321

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.file), ndr_get_array_length(ndr, &r->in.file));

18322

}

18323

NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.file), sizeof(uint16_t)));

18324

NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.file, ndr_get_array_length(ndr, &r->in.file), sizeof(uint16_t), CH_UTF16));

18325

NDR_CHECK(ndr_pull_security_secinfo(ndr, NDR_SCALARS, &r->in.securityinformation));

18326

NDR_PULL_ALLOC(ndr, r->out.sd_buf);

18327

ZERO_STRUCTP(r->out.sd_buf);

18328

}

18329

if (flags & NDR_OUT) {

18330

if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {

18331

NDR_PULL_ALLOC(ndr, r->out.sd_buf);

18332

}

18333

_mem_save_sd_buf_0 = NDR_PULL_GET_MEM_CTX(ndr);

18334

NDR_PULL_SET_MEM_CTX(ndr, r->out.sd_buf, LIBNDR_FLAG_REF_ALLOC);

18335

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_sd_buf));

18336

if (_ptr_sd_buf) {

18337

NDR_PULL_ALLOC(ndr, *r->out.sd_buf);

18338

} else {

18339

*r->out.sd_buf = NULL;

18340

}

18341

if (*r->out.sd_buf) {

18342

_mem_save_sd_buf_1 = NDR_PULL_GET_MEM_CTX(ndr);

18343

NDR_PULL_SET_MEM_CTX(ndr, *r->out.sd_buf, 0);

18344

NDR_CHECK(ndr_pull_sec_desc_buf(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.sd_buf));

18345

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sd_buf_1, 0);

18346

}

18347

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sd_buf_0, LIBNDR_FLAG_REF_ALLOC);

18348

NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));

18349

}

18350

return NDR_ERR_SUCCESS;

18351

}

18352

18353

_PUBLIC_ void ndr_print_srvsvc_NetGetFileSecurity(struct ndr_print *ndr, const char *name, int flags, const struct srvsvc_NetGetFileSecurity *r)

18354

{

18355

ndr_print_struct(ndr, name, "srvsvc_NetGetFileSecurity");

18356

ndr->depth++;

18357

if (flags & NDR_SET_VALUES) {

18358

ndr->flags |= LIBNDR_PRINT_SET_VALUES;

18359

}

18360

if (flags & NDR_IN) {

18361

ndr_print_struct(ndr, "in", "srvsvc_NetGetFileSecurity");

18362

ndr->depth++;

18363

ndr_print_ptr(ndr, "server_unc", r->in.server_unc);

18364

ndr->depth++;

18365

if (r->in.server_unc) {

18366

ndr_print_string(ndr, "server_unc", r->in.server_unc);

18367

}

18368

ndr->depth--;

18369

ndr_print_ptr(ndr, "share", r->in.share);

18370

ndr->depth++;

18371

if (r->in.share) {

18372

ndr_print_string(ndr, "share", r->in.share);

18373

}

18374

ndr->depth--;

18375

ndr_print_string(ndr, "file", r->in.file);

18376

ndr_print_security_secinfo(ndr, "securityinformation", r->in.securityinformation);

18377

ndr->depth--;

18378

}

18379

if (flags & NDR_OUT) {

18380

ndr_print_struct(ndr, "out", "srvsvc_NetGetFileSecurity");

18381

ndr->depth++;

18382

ndr_print_ptr(ndr, "sd_buf", r->out.sd_buf);

18383

ndr->depth++;

18384

ndr_print_ptr(ndr, "sd_buf", *r->out.sd_buf);

18385

ndr->depth++;

18386

if (*r->out.sd_buf) {

18387

ndr_print_sec_desc_buf(ndr, "sd_buf", *r->out.sd_buf);

18388

}

18389

ndr->depth--;

18390

ndr->depth--;

18391

ndr_print_WERROR(ndr, "result", r->out.result);

18392

ndr->depth--;

18393

}

18394

ndr->depth--;

18395

}

18396

18397

static enum ndr_err_code ndr_push_srvsvc_NetSetFileSecurity(struct ndr_push *ndr, int flags, const struct srvsvc_NetSetFileSecurity *r)

18398

{

18399

if (flags & NDR_IN) {

18400

NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server_unc));

18401

if (r->in.server_unc) {

18402

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_unc, CH_UTF16)));

18403

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));

18404

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_unc, CH_UTF16)));

18405

NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server_unc, ndr_charset_length(r->in.server_unc, CH_UTF16), sizeof(uint16_t), CH_UTF16));

18406

}

18407

NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.share));

18408

if (r->in.share) {

18409

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.share, CH_UTF16)));

18410

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));

18411

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.share, CH_UTF16)));

18412

NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.share, ndr_charset_length(r->in.share, CH_UTF16), sizeof(uint16_t), CH_UTF16));

18413

}

18414

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.file, CH_UTF16)));

18415

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));

18416

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.file, CH_UTF16)));

18417

NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.file, ndr_charset_length(r->in.file, CH_UTF16), sizeof(uint16_t), CH_UTF16));

18418

NDR_CHECK(ndr_push_security_secinfo(ndr, NDR_SCALARS, r->in.securityinformation));

18419

if (r->in.sd_buf == NULL) {

18420

return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");

18421

}

18422

NDR_CHECK(ndr_push_sec_desc_buf(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.sd_buf));

18423

}

18424

if (flags & NDR_OUT) {

18425

NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));

18426

}

18427

return NDR_ERR_SUCCESS;

18428

}

18429

18430

static enum ndr_err_code ndr_pull_srvsvc_NetSetFileSecurity(struct ndr_pull *ndr, int flags, struct srvsvc_NetSetFileSecurity *r)

18431

{

18432

uint32_t _ptr_server_unc;

18433

uint32_t _ptr_share;

18434

TALLOC_CTX *_mem_save_server_unc_0;

18435

TALLOC_CTX *_mem_save_share_0;

18436

TALLOC_CTX *_mem_save_sd_buf_0;

18437

if (flags & NDR_IN) {

18438

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_unc));

18439

if (_ptr_server_unc) {

18440

NDR_PULL_ALLOC(ndr, r->in.server_unc);

18441

} else {

18442

r->in.server_unc = NULL;

18443

}

18444

if (r->in.server_unc) {

18445

_mem_save_server_unc_0 = NDR_PULL_GET_MEM_CTX(ndr);

18446

NDR_PULL_SET_MEM_CTX(ndr, r->in.server_unc, 0);

18447

NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_unc));

18448

NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_unc));

18449

if (ndr_get_array_length(ndr, &r->in.server_unc) > ndr_get_array_size(ndr, &r->in.server_unc)) {

18450

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.server_unc), ndr_get_array_length(ndr, &r->in.server_unc));

18451

}

18452

NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server_unc), sizeof(uint16_t)));

18453

NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server_unc, ndr_get_array_length(ndr, &r->in.server_unc), sizeof(uint16_t), CH_UTF16));

18454

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_unc_0, 0);

18455

}

18456

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_share));

18457

if (_ptr_share) {

18458

NDR_PULL_ALLOC(ndr, r->in.share);

18459

} else {

18460

r->in.share = NULL;

18461

}

18462

if (r->in.share) {

18463

_mem_save_share_0 = NDR_PULL_GET_MEM_CTX(ndr);

18464

NDR_PULL_SET_MEM_CTX(ndr, r->in.share, 0);

18465

NDR_CHECK(ndr_pull_array_size(ndr, &r->in.share));

18466

NDR_CHECK(ndr_pull_array_length(ndr, &r->in.share));

18467

if (ndr_get_array_length(ndr, &r->in.share) > ndr_get_array_size(ndr, &r->in.share)) {

18468

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.share), ndr_get_array_length(ndr, &r->in.share));

18469

}

18470

NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.share), sizeof(uint16_t)));

18471

NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.share, ndr_get_array_length(ndr, &r->in.share), sizeof(uint16_t), CH_UTF16));

18472

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_share_0, 0);

18473

}

18474

NDR_CHECK(ndr_pull_array_size(ndr, &r->in.file));

18475

NDR_CHECK(ndr_pull_array_length(ndr, &r->in.file));

18476

if (ndr_get_array_length(ndr, &r->in.file) > ndr_get_array_size(ndr, &r->in.file)) {

18477

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.file), ndr_get_array_length(ndr, &r->in.file));

18478

}

18479

NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.file), sizeof(uint16_t)));

18480

NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.file, ndr_get_array_length(ndr, &r->in.file), sizeof(uint16_t), CH_UTF16));

18481

NDR_CHECK(ndr_pull_security_secinfo(ndr, NDR_SCALARS, &r->in.securityinformation));

18482

if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {

18483

NDR_PULL_ALLOC(ndr, r->in.sd_buf);

18484

}

18485

_mem_save_sd_buf_0 = NDR_PULL_GET_MEM_CTX(ndr);

18486

NDR_PULL_SET_MEM_CTX(ndr, r->in.sd_buf, LIBNDR_FLAG_REF_ALLOC);

18487

NDR_CHECK(ndr_pull_sec_desc_buf(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.sd_buf));

18488

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sd_buf_0, LIBNDR_FLAG_REF_ALLOC);

18489

}

18490

if (flags & NDR_OUT) {

18491

NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));

18492

}

18493

return NDR_ERR_SUCCESS;

18494

}

18495

18496

_PUBLIC_ void ndr_print_srvsvc_NetSetFileSecurity(struct ndr_print *ndr, const char *name, int flags, const struct srvsvc_NetSetFileSecurity *r)

18497

{

18498

ndr_print_struct(ndr, name, "srvsvc_NetSetFileSecurity");

18499

ndr->depth++;

18500

if (flags & NDR_SET_VALUES) {

18501

ndr->flags |= LIBNDR_PRINT_SET_VALUES;

18502

}

18503

if (flags & NDR_IN) {

18504

ndr_print_struct(ndr, "in", "srvsvc_NetSetFileSecurity");

18505

ndr->depth++;

18506

ndr_print_ptr(ndr, "server_unc", r->in.server_unc);

18507

ndr->depth++;

18508

if (r->in.server_unc) {

18509

ndr_print_string(ndr, "server_unc", r->in.server_unc);

18510

}

18511

ndr->depth--;

18512

ndr_print_ptr(ndr, "share", r->in.share);

18513

ndr->depth++;

18514

if (r->in.share) {

18515

ndr_print_string(ndr, "share", r->in.share);

18516

}

18517

ndr->depth--;

18518

ndr_print_string(ndr, "file", r->in.file);

18519

ndr_print_security_secinfo(ndr, "securityinformation", r->in.securityinformation);

18520

ndr_print_ptr(ndr, "sd_buf", r->in.sd_buf);

18521

ndr->depth++;

18522

ndr_print_sec_desc_buf(ndr, "sd_buf", r->in.sd_buf);

18523

ndr->depth--;

18524

ndr->depth--;

18525

}

18526

if (flags & NDR_OUT) {

18527

ndr_print_struct(ndr, "out", "srvsvc_NetSetFileSecurity");

18528

ndr->depth++;

18529

ndr_print_WERROR(ndr, "result", r->out.result);

18530

ndr->depth--;

18531

}

18532

ndr->depth--;

18533

}

18534

18535

static enum ndr_err_code ndr_push_srvsvc_NetServerTransportAddEx(struct ndr_push *ndr, int flags, const struct srvsvc_NetServerTransportAddEx *r)

18536

{

18537

if (flags & NDR_IN) {

18538

NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server_unc));

18539

if (r->in.server_unc) {

18540

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_unc, CH_UTF16)));

18541

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));

18542

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_unc, CH_UTF16)));

18543

NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server_unc, ndr_charset_length(r->in.server_unc, CH_UTF16), sizeof(uint16_t), CH_UTF16));

18544

}

18545

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));

18546

NDR_CHECK(ndr_push_set_switch_value(ndr, &r->in.info, r->in.level));

18547

NDR_CHECK(ndr_push_srvsvc_NetTransportInfo(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.info));

18548

}

18549

if (flags & NDR_OUT) {

18550

NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));

18551

}

18552

return NDR_ERR_SUCCESS;

18553

}

18554

18555

static enum ndr_err_code ndr_pull_srvsvc_NetServerTransportAddEx(struct ndr_pull *ndr, int flags, struct srvsvc_NetServerTransportAddEx *r)

18556

{

18557

uint32_t _ptr_server_unc;

18558

TALLOC_CTX *_mem_save_server_unc_0;

18559

if (flags & NDR_IN) {

18560

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_unc));

18561

if (_ptr_server_unc) {

18562

NDR_PULL_ALLOC(ndr, r->in.server_unc);

18563

} else {

18564

r->in.server_unc = NULL;

18565

}

18566

if (r->in.server_unc) {

18567

_mem_save_server_unc_0 = NDR_PULL_GET_MEM_CTX(ndr);

18568

NDR_PULL_SET_MEM_CTX(ndr, r->in.server_unc, 0);

18569

NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_unc));

18570

NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_unc));

18571

if (ndr_get_array_length(ndr, &r->in.server_unc) > ndr_get_array_size(ndr, &r->in.server_unc)) {

18572

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.server_unc), ndr_get_array_length(ndr, &r->in.server_unc));

18573

}

18574

NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server_unc), sizeof(uint16_t)));

18575

NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server_unc, ndr_get_array_length(ndr, &r->in.server_unc), sizeof(uint16_t), CH_UTF16));

18576

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_unc_0, 0);

18577

}

18578

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));

18579

NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->in.info, r->in.level));

18580

NDR_CHECK(ndr_pull_srvsvc_NetTransportInfo(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.info));

18581

}

18582

if (flags & NDR_OUT) {

18583

NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));

18584

}

18585

return NDR_ERR_SUCCESS;

18586

}

18587

18588

_PUBLIC_ void ndr_print_srvsvc_NetServerTransportAddEx(struct ndr_print *ndr, const char *name, int flags, const struct srvsvc_NetServerTransportAddEx *r)

18589

{

18590

ndr_print_struct(ndr, name, "srvsvc_NetServerTransportAddEx");

18591

ndr->depth++;

18592

if (flags & NDR_SET_VALUES) {

18593

ndr->flags |= LIBNDR_PRINT_SET_VALUES;

18594

}

18595

if (flags & NDR_IN) {

18596

ndr_print_struct(ndr, "in", "srvsvc_NetServerTransportAddEx");

18597

ndr->depth++;

18598

ndr_print_ptr(ndr, "server_unc", r->in.server_unc);

18599

ndr->depth++;

18600

if (r->in.server_unc) {

18601

ndr_print_string(ndr, "server_unc", r->in.server_unc);

18602

}

18603

ndr->depth--;

18604

ndr_print_uint32(ndr, "level", r->in.level);

18605

ndr_print_set_switch_value(ndr, &r->in.info, r->in.level);

18606

ndr_print_srvsvc_NetTransportInfo(ndr, "info", &r->in.info);

18607

ndr->depth--;

18608

}

18609

if (flags & NDR_OUT) {

18610

ndr_print_struct(ndr, "out", "srvsvc_NetServerTransportAddEx");

18611

ndr->depth++;

18612

ndr_print_WERROR(ndr, "result", r->out.result);

18613

ndr->depth--;

18614

}

18615

ndr->depth--;

18616

}

18617

18618

static enum ndr_err_code ndr_push_srvsvc_NetServerSetServiceBitsEx(struct ndr_push *ndr, int flags, const struct srvsvc_NetServerSetServiceBitsEx *r)

18619

{

18620

if (flags & NDR_IN) {

18621

NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server_unc));

18622

if (r->in.server_unc) {

18623

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_unc, CH_UTF16)));

18624

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));

18625

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_unc, CH_UTF16)));

18626

NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server_unc, ndr_charset_length(r->in.server_unc, CH_UTF16), sizeof(uint16_t), CH_UTF16));

18627

}

18628

NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.emulated_server_unc));

18629

if (r->in.emulated_server_unc) {

18630

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.emulated_server_unc, CH_UTF16)));

18631

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));

18632

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.emulated_server_unc, CH_UTF16)));

18633

NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.emulated_server_unc, ndr_charset_length(r->in.emulated_server_unc, CH_UTF16), sizeof(uint16_t), CH_UTF16));

18634

}

18635

NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.transport));

18636

if (r->in.transport) {

18637

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.transport, CH_UTF16)));

18638

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));

18639

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.transport, CH_UTF16)));

18640

NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.transport, ndr_charset_length(r->in.transport, CH_UTF16), sizeof(uint16_t), CH_UTF16));

18641

}

18642

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.servicebitsofinterest));

18643

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.servicebits));

18644

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.updateimmediately));

18645

}

18646

if (flags & NDR_OUT) {

18647

NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));

18648

}

18649

return NDR_ERR_SUCCESS;

18650

}

18651

18652

static enum ndr_err_code ndr_pull_srvsvc_NetServerSetServiceBitsEx(struct ndr_pull *ndr, int flags, struct srvsvc_NetServerSetServiceBitsEx *r)

18653

{

18654

uint32_t _ptr_server_unc;

18655

uint32_t _ptr_emulated_server_unc;

18656

uint32_t _ptr_transport;

18657

TALLOC_CTX *_mem_save_server_unc_0;

18658

TALLOC_CTX *_mem_save_emulated_server_unc_0;

18659

TALLOC_CTX *_mem_save_transport_0;

18660

if (flags & NDR_IN) {

18661

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_unc));

18662

if (_ptr_server_unc) {

18663

NDR_PULL_ALLOC(ndr, r->in.server_unc);

18664

} else {

18665

r->in.server_unc = NULL;

18666

}

18667

if (r->in.server_unc) {

18668

_mem_save_server_unc_0 = NDR_PULL_GET_MEM_CTX(ndr);

18669

NDR_PULL_SET_MEM_CTX(ndr, r->in.server_unc, 0);

18670

NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_unc));

18671

NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_unc));

18672

if (ndr_get_array_length(ndr, &r->in.server_unc) > ndr_get_array_size(ndr, &r->in.server_unc)) {

18673

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.server_unc), ndr_get_array_length(ndr, &r->in.server_unc));

18674

}

18675

NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server_unc), sizeof(uint16_t)));

18676

NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server_unc, ndr_get_array_length(ndr, &r->in.server_unc), sizeof(uint16_t), CH_UTF16));

18677

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_unc_0, 0);

18678

}

18679

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_emulated_server_unc));

18680

if (_ptr_emulated_server_unc) {

18681

NDR_PULL_ALLOC(ndr, r->in.emulated_server_unc);

18682

} else {

18683

r->in.emulated_server_unc = NULL;

18684

}

18685

if (r->in.emulated_server_unc) {

18686

_mem_save_emulated_server_unc_0 = NDR_PULL_GET_MEM_CTX(ndr);

18687

NDR_PULL_SET_MEM_CTX(ndr, r->in.emulated_server_unc, 0);

18688

NDR_CHECK(ndr_pull_array_size(ndr, &r->in.emulated_server_unc));

18689

NDR_CHECK(ndr_pull_array_length(ndr, &r->in.emulated_server_unc));

18690

if (ndr_get_array_length(ndr, &r->in.emulated_server_unc) > ndr_get_array_size(ndr, &r->in.emulated_server_unc)) {

18691

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.emulated_server_unc), ndr_get_array_length(ndr, &r->in.emulated_server_unc));

18692

}

18693

NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.emulated_server_unc), sizeof(uint16_t)));

18694

NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.emulated_server_unc, ndr_get_array_length(ndr, &r->in.emulated_server_unc), sizeof(uint16_t), CH_UTF16));

18695

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_emulated_server_unc_0, 0);

18696

}

18697

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_transport));

18698

if (_ptr_transport) {

18699

NDR_PULL_ALLOC(ndr, r->in.transport);

18700

} else {

18701

r->in.transport = NULL;

18702

}

18703

if (r->in.transport) {

18704

_mem_save_transport_0 = NDR_PULL_GET_MEM_CTX(ndr);

18705

NDR_PULL_SET_MEM_CTX(ndr, r->in.transport, 0);

18706

NDR_CHECK(ndr_pull_array_size(ndr, &r->in.transport));

18707

NDR_CHECK(ndr_pull_array_length(ndr, &r->in.transport));

18708

if (ndr_get_array_length(ndr, &r->in.transport) > ndr_get_array_size(ndr, &r->in.transport)) {

18709

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.transport), ndr_get_array_length(ndr, &r->in.transport));

18710

}

18711

NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.transport), sizeof(uint16_t)));

18712

NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.transport, ndr_get_array_length(ndr, &r->in.transport), sizeof(uint16_t), CH_UTF16));

18713

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_transport_0, 0);

18714

}

18715

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.servicebitsofinterest));

18716

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.servicebits));

18717

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.updateimmediately));

18718

}

18719

if (flags & NDR_OUT) {

18720

NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));

18721

}

18722

return NDR_ERR_SUCCESS;

18723

}

18724

18725

_PUBLIC_ void ndr_print_srvsvc_NetServerSetServiceBitsEx(struct ndr_print *ndr, const char *name, int flags, const struct srvsvc_NetServerSetServiceBitsEx *r)

18726

{

18727

ndr_print_struct(ndr, name, "srvsvc_NetServerSetServiceBitsEx");

18728

ndr->depth++;

18729

if (flags & NDR_SET_VALUES) {

18730

ndr->flags |= LIBNDR_PRINT_SET_VALUES;

18731

}

18732

if (flags & NDR_IN) {

18733

ndr_print_struct(ndr, "in", "srvsvc_NetServerSetServiceBitsEx");

18734

ndr->depth++;

18735

ndr_print_ptr(ndr, "server_unc", r->in.server_unc);

18736

ndr->depth++;

18737

if (r->in.server_unc) {

18738

ndr_print_string(ndr, "server_unc", r->in.server_unc);

18739

}

18740

ndr->depth--;

18741

ndr_print_ptr(ndr, "emulated_server_unc", r->in.emulated_server_unc);

18742

ndr->depth++;

18743

if (r->in.emulated_server_unc) {

18744

ndr_print_string(ndr, "emulated_server_unc", r->in.emulated_server_unc);

18745

}

18746

ndr->depth--;

18747

ndr_print_ptr(ndr, "transport", r->in.transport);

18748

ndr->depth++;

18749

if (r->in.transport) {

18750

ndr_print_string(ndr, "transport", r->in.transport);

18751

}

18752

ndr->depth--;

18753

ndr_print_uint32(ndr, "servicebitsofinterest", r->in.servicebitsofinterest);

18754

ndr_print_uint32(ndr, "servicebits", r->in.servicebits);

18755

ndr_print_uint32(ndr, "updateimmediately", r->in.updateimmediately);

18756

ndr->depth--;

18757

}

18758

if (flags & NDR_OUT) {

18759

ndr_print_struct(ndr, "out", "srvsvc_NetServerSetServiceBitsEx");

18760

ndr->depth++;

18761

ndr_print_WERROR(ndr, "result", r->out.result);

18762

ndr->depth--;

18763

}

18764

ndr->depth--;

18765

}

18766

18767

static enum ndr_err_code ndr_push_srvsvc_NETRDFSGETVERSION(struct ndr_push *ndr, int flags, const struct srvsvc_NETRDFSGETVERSION *r)

18768

{

18769

if (flags & NDR_IN) {

18770

}

18771

if (flags & NDR_OUT) {

18772

NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));

18773

}

18774

return NDR_ERR_SUCCESS;

18775

}

18776

18777

static enum ndr_err_code ndr_pull_srvsvc_NETRDFSGETVERSION(struct ndr_pull *ndr, int flags, struct srvsvc_NETRDFSGETVERSION *r)

18778

{

18779

if (flags & NDR_IN) {

18780

}

18781

if (flags & NDR_OUT) {

18782

NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));

18783

}

18784

return NDR_ERR_SUCCESS;

18785

}

18786

18787

_PUBLIC_ void ndr_print_srvsvc_NETRDFSGETVERSION(struct ndr_print *ndr, const char *name, int flags, const struct srvsvc_NETRDFSGETVERSION *r)

18788

{

18789

ndr_print_struct(ndr, name, "srvsvc_NETRDFSGETVERSION");

18790

ndr->depth++;

18791

if (flags & NDR_SET_VALUES) {

18792

ndr->flags |= LIBNDR_PRINT_SET_VALUES;

18793

}

18794

if (flags & NDR_IN) {

18795

ndr_print_struct(ndr, "in", "srvsvc_NETRDFSGETVERSION");

18796

ndr->depth++;

18797

ndr->depth--;

18798

}

18799

if (flags & NDR_OUT) {

18800

ndr_print_struct(ndr, "out", "srvsvc_NETRDFSGETVERSION");

18801

ndr->depth++;

18802

ndr_print_WERROR(ndr, "result", r->out.result);

18803

ndr->depth--;

18804

}

18805

ndr->depth--;

18806

}

18807

18808

static enum ndr_err_code ndr_push_srvsvc_NETRDFSCREATELOCALPARTITION(struct ndr_push *ndr, int flags, const struct srvsvc_NETRDFSCREATELOCALPARTITION *r)

18809

{

18810

if (flags & NDR_IN) {

18811

}

18812

if (flags & NDR_OUT) {

18813

NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));

18814

}

18815

return NDR_ERR_SUCCESS;

18816

}

18817

18818

static enum ndr_err_code ndr_pull_srvsvc_NETRDFSCREATELOCALPARTITION(struct ndr_pull *ndr, int flags, struct srvsvc_NETRDFSCREATELOCALPARTITION *r)

18819

{

18820

if (flags & NDR_IN) {

18821

}

18822

if (flags & NDR_OUT) {

18823

NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));

18824

}

18825

return NDR_ERR_SUCCESS;

18826

}

18827

18828

_PUBLIC_ void ndr_print_srvsvc_NETRDFSCREATELOCALPARTITION(struct ndr_print *ndr, const char *name, int flags, const struct srvsvc_NETRDFSCREATELOCALPARTITION *r)

18829

{

18830

ndr_print_struct(ndr, name, "srvsvc_NETRDFSCREATELOCALPARTITION");

18831

ndr->depth++;

18832

if (flags & NDR_SET_VALUES) {

18833

ndr->flags |= LIBNDR_PRINT_SET_VALUES;

18834

}

18835

if (flags & NDR_IN) {

18836

ndr_print_struct(ndr, "in", "srvsvc_NETRDFSCREATELOCALPARTITION");

18837

ndr->depth++;

18838

ndr->depth--;

18839

}

18840

if (flags & NDR_OUT) {

18841

ndr_print_struct(ndr, "out", "srvsvc_NETRDFSCREATELOCALPARTITION");

18842

ndr->depth++;

18843

ndr_print_WERROR(ndr, "result", r->out.result);

18844

ndr->depth--;

18845

}

18846

ndr->depth--;

18847

}

18848

18849

static enum ndr_err_code ndr_push_srvsvc_NETRDFSDELETELOCALPARTITION(struct ndr_push *ndr, int flags, const struct srvsvc_NETRDFSDELETELOCALPARTITION *r)

18850

{

18851

if (flags & NDR_IN) {

18852

}

18853

if (flags & NDR_OUT) {

18854

NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));

18855

}

18856

return NDR_ERR_SUCCESS;

18857

}

18858

18859

static enum ndr_err_code ndr_pull_srvsvc_NETRDFSDELETELOCALPARTITION(struct ndr_pull *ndr, int flags, struct srvsvc_NETRDFSDELETELOCALPARTITION *r)

18860

{

18861

if (flags & NDR_IN) {

18862

}

18863

if (flags & NDR_OUT) {

18864

NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));

18865

}

18866

return NDR_ERR_SUCCESS;

18867

}

18868

18869

_PUBLIC_ void ndr_print_srvsvc_NETRDFSDELETELOCALPARTITION(struct ndr_print *ndr, const char *name, int flags, const struct srvsvc_NETRDFSDELETELOCALPARTITION *r)

18870

{

18871

ndr_print_struct(ndr, name, "srvsvc_NETRDFSDELETELOCALPARTITION");

18872

ndr->depth++;

18873

if (flags & NDR_SET_VALUES) {

18874

ndr->flags |= LIBNDR_PRINT_SET_VALUES;

18875

}

18876

if (flags & NDR_IN) {

18877

ndr_print_struct(ndr, "in", "srvsvc_NETRDFSDELETELOCALPARTITION");

18878

ndr->depth++;

18879

ndr->depth--;

18880

}

18881

if (flags & NDR_OUT) {

18882

ndr_print_struct(ndr, "out", "srvsvc_NETRDFSDELETELOCALPARTITION");

18883

ndr->depth++;

18884

ndr_print_WERROR(ndr, "result", r->out.result);

18885

ndr->depth--;

18886

}

18887

ndr->depth--;

18888

}

18889

18890

static enum ndr_err_code ndr_push_srvsvc_NETRDFSSETLOCALVOLUMESTATE(struct ndr_push *ndr, int flags, const struct srvsvc_NETRDFSSETLOCALVOLUMESTATE *r)

18891

{

18892

if (flags & NDR_IN) {

18893

}

18894

if (flags & NDR_OUT) {

18895

NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));

18896

}

18897

return NDR_ERR_SUCCESS;

18898

}

18899

18900

static enum ndr_err_code ndr_pull_srvsvc_NETRDFSSETLOCALVOLUMESTATE(struct ndr_pull *ndr, int flags, struct srvsvc_NETRDFSSETLOCALVOLUMESTATE *r)

18901

{

18902

if (flags & NDR_IN) {

18903

}

18904

if (flags & NDR_OUT) {

18905

NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));

18906

}

18907

return NDR_ERR_SUCCESS;

18908

}

18909

18910

_PUBLIC_ void ndr_print_srvsvc_NETRDFSSETLOCALVOLUMESTATE(struct ndr_print *ndr, const char *name, int flags, const struct srvsvc_NETRDFSSETLOCALVOLUMESTATE *r)

18911

{

18912

ndr_print_struct(ndr, name, "srvsvc_NETRDFSSETLOCALVOLUMESTATE");

18913

ndr->depth++;

18914

if (flags & NDR_SET_VALUES) {

18915

ndr->flags |= LIBNDR_PRINT_SET_VALUES;

18916

}

18917

if (flags & NDR_IN) {

18918

ndr_print_struct(ndr, "in", "srvsvc_NETRDFSSETLOCALVOLUMESTATE");

18919

ndr->depth++;

18920

ndr->depth--;

18921

}

18922

if (flags & NDR_OUT) {

18923

ndr_print_struct(ndr, "out", "srvsvc_NETRDFSSETLOCALVOLUMESTATE");

18924

ndr->depth++;

18925

ndr_print_WERROR(ndr, "result", r->out.result);

18926

ndr->depth--;

18927

}

18928

ndr->depth--;

18929

}

18930

18931

static enum ndr_err_code ndr_push_srvsvc_NETRDFSSETSERVERINFO(struct ndr_push *ndr, int flags, const struct srvsvc_NETRDFSSETSERVERINFO *r)

18932

{

18933

if (flags & NDR_IN) {

18934

}

18935

if (flags & NDR_OUT) {

18936

NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));

18937

}

18938

return NDR_ERR_SUCCESS;

18939

}

18940

18941

static enum ndr_err_code ndr_pull_srvsvc_NETRDFSSETSERVERINFO(struct ndr_pull *ndr, int flags, struct srvsvc_NETRDFSSETSERVERINFO *r)

18942

{

18943

if (flags & NDR_IN) {

18944

}

18945

if (flags & NDR_OUT) {

18946

NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));

18947

}

18948

return NDR_ERR_SUCCESS;

18949

}

18950

18951

_PUBLIC_ void ndr_print_srvsvc_NETRDFSSETSERVERINFO(struct ndr_print *ndr, const char *name, int flags, const struct srvsvc_NETRDFSSETSERVERINFO *r)

18952

{

18953

ndr_print_struct(ndr, name, "srvsvc_NETRDFSSETSERVERINFO");

18954

ndr->depth++;

18955

if (flags & NDR_SET_VALUES) {

18956

ndr->flags |= LIBNDR_PRINT_SET_VALUES;

18957

}

18958

if (flags & NDR_IN) {

18959

ndr_print_struct(ndr, "in", "srvsvc_NETRDFSSETSERVERINFO");

18960

ndr->depth++;

18961

ndr->depth--;

18962

}

18963

if (flags & NDR_OUT) {

18964

ndr_print_struct(ndr, "out", "srvsvc_NETRDFSSETSERVERINFO");

18965

ndr->depth++;

18966

ndr_print_WERROR(ndr, "result", r->out.result);

18967

ndr->depth--;

18968

}

18969

ndr->depth--;

18970

}

18971

18972

static enum ndr_err_code ndr_push_srvsvc_NETRDFSCREATEEXITPOINT(struct ndr_push *ndr, int flags, const struct srvsvc_NETRDFSCREATEEXITPOINT *r)

18973

{

18974

if (flags & NDR_IN) {

18975

}

18976

if (flags & NDR_OUT) {

18977

NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));

18978

}

18979

return NDR_ERR_SUCCESS;

18980

}

18981

18982

static enum ndr_err_code ndr_pull_srvsvc_NETRDFSCREATEEXITPOINT(struct ndr_pull *ndr, int flags, struct srvsvc_NETRDFSCREATEEXITPOINT *r)

18983

{

18984

if (flags & NDR_IN) {

18985

}

18986

if (flags & NDR_OUT) {

18987

NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));

18988

}

18989

return NDR_ERR_SUCCESS;

18990

}

18991

18992

_PUBLIC_ void ndr_print_srvsvc_NETRDFSCREATEEXITPOINT(struct ndr_print *ndr, const char *name, int flags, const struct srvsvc_NETRDFSCREATEEXITPOINT *r)

18993

{

18994

ndr_print_struct(ndr, name, "srvsvc_NETRDFSCREATEEXITPOINT");

18995

ndr->depth++;

18996

if (flags & NDR_SET_VALUES) {

18997

ndr->flags |= LIBNDR_PRINT_SET_VALUES;

18998

}

18999

if (flags & NDR_IN) {

19000

ndr_print_struct(ndr, "in", "srvsvc_NETRDFSCREATEEXITPOINT");

19001

ndr->depth++;

19002

ndr->depth--;

19003

}

19004

if (flags & NDR_OUT) {

19005

ndr_print_struct(ndr, "out", "srvsvc_NETRDFSCREATEEXITPOINT");

19006

ndr->depth++;

19007

ndr_print_WERROR(ndr, "result", r->out.result);

19008

ndr->depth--;

19009

}

19010

ndr->depth--;

19011

}

19012

19013

static enum ndr_err_code ndr_push_srvsvc_NETRDFSDELETEEXITPOINT(struct ndr_push *ndr, int flags, const struct srvsvc_NETRDFSDELETEEXITPOINT *r)

19014

{

19015

if (flags & NDR_IN) {

19016

}

19017

if (flags & NDR_OUT) {

19018

NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));

19019

}

19020

return NDR_ERR_SUCCESS;

19021

}

19022

19023

static enum ndr_err_code ndr_pull_srvsvc_NETRDFSDELETEEXITPOINT(struct ndr_pull *ndr, int flags, struct srvsvc_NETRDFSDELETEEXITPOINT *r)

19024

{

19025

if (flags & NDR_IN) {

19026

}

19027

if (flags & NDR_OUT) {

19028

NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));

19029

}

19030

return NDR_ERR_SUCCESS;

19031

}

19032

19033

_PUBLIC_ void ndr_print_srvsvc_NETRDFSDELETEEXITPOINT(struct ndr_print *ndr, const char *name, int flags, const struct srvsvc_NETRDFSDELETEEXITPOINT *r)

19034

{

19035

ndr_print_struct(ndr, name, "srvsvc_NETRDFSDELETEEXITPOINT");

19036

ndr->depth++;

19037

if (flags & NDR_SET_VALUES) {

19038

ndr->flags |= LIBNDR_PRINT_SET_VALUES;

19039

}

19040

if (flags & NDR_IN) {

19041

ndr_print_struct(ndr, "in", "srvsvc_NETRDFSDELETEEXITPOINT");

19042

ndr->depth++;

19043

ndr->depth--;

19044

}

19045

if (flags & NDR_OUT) {

19046

ndr_print_struct(ndr, "out", "srvsvc_NETRDFSDELETEEXITPOINT");

19047

ndr->depth++;

19048

ndr_print_WERROR(ndr, "result", r->out.result);

19049

ndr->depth--;

19050

}

19051

ndr->depth--;

19052

}

19053

19054

static enum ndr_err_code ndr_push_srvsvc_NETRDFSMODIFYPREFIX(struct ndr_push *ndr, int flags, const struct srvsvc_NETRDFSMODIFYPREFIX *r)

19055

{

19056

if (flags & NDR_IN) {

19057

}

19058

if (flags & NDR_OUT) {

19059

NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));

19060

}

19061

return NDR_ERR_SUCCESS;

19062

}

19063

19064

static enum ndr_err_code ndr_pull_srvsvc_NETRDFSMODIFYPREFIX(struct ndr_pull *ndr, int flags, struct srvsvc_NETRDFSMODIFYPREFIX *r)

19065

{

19066

if (flags & NDR_IN) {

19067

}

19068

if (flags & NDR_OUT) {

19069

NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));

19070

}

19071

return NDR_ERR_SUCCESS;

19072

}

19073

19074

_PUBLIC_ void ndr_print_srvsvc_NETRDFSMODIFYPREFIX(struct ndr_print *ndr, const char *name, int flags, const struct srvsvc_NETRDFSMODIFYPREFIX *r)

19075

{

19076

ndr_print_struct(ndr, name, "srvsvc_NETRDFSMODIFYPREFIX");

19077

ndr->depth++;

19078

if (flags & NDR_SET_VALUES) {

19079

ndr->flags |= LIBNDR_PRINT_SET_VALUES;

19080

}

19081

if (flags & NDR_IN) {

19082

ndr_print_struct(ndr, "in", "srvsvc_NETRDFSMODIFYPREFIX");

19083

ndr->depth++;

19084

ndr->depth--;

19085

}

19086

if (flags & NDR_OUT) {

19087

ndr_print_struct(ndr, "out", "srvsvc_NETRDFSMODIFYPREFIX");

19088

ndr->depth++;

19089

ndr_print_WERROR(ndr, "result", r->out.result);

19090

ndr->depth--;

19091

}

19092

ndr->depth--;

19093

}

19094

19095

static enum ndr_err_code ndr_push_srvsvc_NETRDFSFIXLOCALVOLUME(struct ndr_push *ndr, int flags, const struct srvsvc_NETRDFSFIXLOCALVOLUME *r)

19096

{

19097

if (flags & NDR_IN) {

19098

}

19099

if (flags & NDR_OUT) {

19100

NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));

19101

}

19102

return NDR_ERR_SUCCESS;

19103

}

19104

19105

static enum ndr_err_code ndr_pull_srvsvc_NETRDFSFIXLOCALVOLUME(struct ndr_pull *ndr, int flags, struct srvsvc_NETRDFSFIXLOCALVOLUME *r)

19106

{

19107

if (flags & NDR_IN) {

19108

}

19109

if (flags & NDR_OUT) {

19110

NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));

19111

}

19112

return NDR_ERR_SUCCESS;

19113

}

19114

19115

_PUBLIC_ void ndr_print_srvsvc_NETRDFSFIXLOCALVOLUME(struct ndr_print *ndr, const char *name, int flags, const struct srvsvc_NETRDFSFIXLOCALVOLUME *r)

19116

{

19117

ndr_print_struct(ndr, name, "srvsvc_NETRDFSFIXLOCALVOLUME");

19118

ndr->depth++;

19119

if (flags & NDR_SET_VALUES) {

19120

ndr->flags |= LIBNDR_PRINT_SET_VALUES;

19121

}

19122

if (flags & NDR_IN) {

19123

ndr_print_struct(ndr, "in", "srvsvc_NETRDFSFIXLOCALVOLUME");

19124

ndr->depth++;

19125

ndr->depth--;

19126

}

19127

if (flags & NDR_OUT) {

19128

ndr_print_struct(ndr, "out", "srvsvc_NETRDFSFIXLOCALVOLUME");

19129

ndr->depth++;

19130

ndr_print_WERROR(ndr, "result", r->out.result);

19131

ndr->depth--;

19132

}

19133

ndr->depth--;

19134

}

19135

19136

static enum ndr_err_code ndr_push_srvsvc_NETRDFSMANAGERREPORTSITEINFO(struct ndr_push *ndr, int flags, const struct srvsvc_NETRDFSMANAGERREPORTSITEINFO *r)

19137

{

19138

if (flags & NDR_IN) {

19139

}

19140

if (flags & NDR_OUT) {

19141

NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));

19142

}

19143

return NDR_ERR_SUCCESS;

19144

}

19145

19146

static enum ndr_err_code ndr_pull_srvsvc_NETRDFSMANAGERREPORTSITEINFO(struct ndr_pull *ndr, int flags, struct srvsvc_NETRDFSMANAGERREPORTSITEINFO *r)

19147

{

19148

if (flags & NDR_IN) {

19149

}

19150

if (flags & NDR_OUT) {

19151

NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));

19152

}

19153

return NDR_ERR_SUCCESS;

19154

}

19155

19156

_PUBLIC_ void ndr_print_srvsvc_NETRDFSMANAGERREPORTSITEINFO(struct ndr_print *ndr, const char *name, int flags, const struct srvsvc_NETRDFSMANAGERREPORTSITEINFO *r)

19157

{

19158

ndr_print_struct(ndr, name, "srvsvc_NETRDFSMANAGERREPORTSITEINFO");

19159

ndr->depth++;

19160

if (flags & NDR_SET_VALUES) {

19161

ndr->flags |= LIBNDR_PRINT_SET_VALUES;

19162

}

19163

if (flags & NDR_IN) {

19164

ndr_print_struct(ndr, "in", "srvsvc_NETRDFSMANAGERREPORTSITEINFO");

19165

ndr->depth++;

19166

ndr->depth--;

19167

}

19168

if (flags & NDR_OUT) {

19169

ndr_print_struct(ndr, "out", "srvsvc_NETRDFSMANAGERREPORTSITEINFO");

19170

ndr->depth++;

19171

ndr_print_WERROR(ndr, "result", r->out.result);

19172

ndr->depth--;

19173

}

19174

ndr->depth--;

19175

}

19176

19177

static enum ndr_err_code ndr_push_srvsvc_NETRSERVERTRANSPORTDELEX(struct ndr_push *ndr, int flags, const struct srvsvc_NETRSERVERTRANSPORTDELEX *r)

19178

{

19179

if (flags & NDR_IN) {

19180

}

19181

if (flags & NDR_OUT) {

19182

NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));

19183

}

19184

return NDR_ERR_SUCCESS;

19185

}

19186

19187

static enum ndr_err_code ndr_pull_srvsvc_NETRSERVERTRANSPORTDELEX(struct ndr_pull *ndr, int flags, struct srvsvc_NETRSERVERTRANSPORTDELEX *r)

19188

{

19189

if (flags & NDR_IN) {

19190

}

19191

if (flags & NDR_OUT) {

19192

NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));

19193

}

19194

return NDR_ERR_SUCCESS;

19195

}

19196

19197

_PUBLIC_ void ndr_print_srvsvc_NETRSERVERTRANSPORTDELEX(struct ndr_print *ndr, const char *name, int flags, const struct srvsvc_NETRSERVERTRANSPORTDELEX *r)

19198

{

19199

ndr_print_struct(ndr, name, "srvsvc_NETRSERVERTRANSPORTDELEX");

19200

ndr->depth++;

19201

if (flags & NDR_SET_VALUES) {

19202

ndr->flags |= LIBNDR_PRINT_SET_VALUES;

19203

}

19204

if (flags & NDR_IN) {

19205

ndr_print_struct(ndr, "in", "srvsvc_NETRSERVERTRANSPORTDELEX");

19206

ndr->depth++;

19207

ndr->depth--;

19208

}

19209

if (flags & NDR_OUT) {

19210

ndr_print_struct(ndr, "out", "srvsvc_NETRSERVERTRANSPORTDELEX");

19211

ndr->depth++;

19212

ndr_print_WERROR(ndr, "result", r->out.result);

19213

ndr->depth--;

19214

}

19215

ndr->depth--;

19216

}

19217

19218

static const struct ndr_interface_call srvsvc_calls[] = {

19219

{

19220

"srvsvc_NetCharDevEnum",

19221

sizeof(struct srvsvc_NetCharDevEnum),

19222

(ndr_push_flags_fn_t) ndr_push_srvsvc_NetCharDevEnum,

19223

(ndr_pull_flags_fn_t) ndr_pull_srvsvc_NetCharDevEnum,

19224

(ndr_print_function_t) ndr_print_srvsvc_NetCharDevEnum,

19225

false,

19226

19227

{

19228

"srvsvc_NetCharDevGetInfo",

19229

sizeof(struct srvsvc_NetCharDevGetInfo),

19230

(ndr_push_flags_fn_t) ndr_push_srvsvc_NetCharDevGetInfo,

19231

(ndr_pull_flags_fn_t) ndr_pull_srvsvc_NetCharDevGetInfo,

19232

(ndr_print_function_t) ndr_print_srvsvc_NetCharDevGetInfo,

19233

false,

19234

19235

{

19236

"srvsvc_NetCharDevControl",

19237

sizeof(struct srvsvc_NetCharDevControl),

19238

(ndr_push_flags_fn_t) ndr_push_srvsvc_NetCharDevControl,

19239

(ndr_pull_flags_fn_t) ndr_pull_srvsvc_NetCharDevControl,

19240

(ndr_print_function_t) ndr_print_srvsvc_NetCharDevControl,

19241

false,

19242

19243

{

19244

"srvsvc_NetCharDevQEnum",

19245

sizeof(struct srvsvc_NetCharDevQEnum),

19246

(ndr_push_flags_fn_t) ndr_push_srvsvc_NetCharDevQEnum,

19247

(ndr_pull_flags_fn_t) ndr_pull_srvsvc_NetCharDevQEnum,

19248

(ndr_print_function_t) ndr_print_srvsvc_NetCharDevQEnum,

19249

false,

19250

19251

{

19252

"srvsvc_NetCharDevQGetInfo",

19253

sizeof(struct srvsvc_NetCharDevQGetInfo),

19254

(ndr_push_flags_fn_t) ndr_push_srvsvc_NetCharDevQGetInfo,

19255

(ndr_pull_flags_fn_t) ndr_pull_srvsvc_NetCharDevQGetInfo,

19256

(ndr_print_function_t) ndr_print_srvsvc_NetCharDevQGetInfo,

19257

false,

19258

19259

{

19260

"srvsvc_NetCharDevQSetInfo",

19261

sizeof(struct srvsvc_NetCharDevQSetInfo),

19262

(ndr_push_flags_fn_t) ndr_push_srvsvc_NetCharDevQSetInfo,

19263

(ndr_pull_flags_fn_t) ndr_pull_srvsvc_NetCharDevQSetInfo,

19264

(ndr_print_function_t) ndr_print_srvsvc_NetCharDevQSetInfo,

19265

false,

19266

19267

{

19268

"srvsvc_NetCharDevQPurge",

19269

sizeof(struct srvsvc_NetCharDevQPurge),

19270

(ndr_push_flags_fn_t) ndr_push_srvsvc_NetCharDevQPurge,

19271

(ndr_pull_flags_fn_t) ndr_pull_srvsvc_NetCharDevQPurge,

19272

(ndr_print_function_t) ndr_print_srvsvc_NetCharDevQPurge,

19273

false,

19274

19275

{

19276

"srvsvc_NetCharDevQPurgeSelf",

19277

sizeof(struct srvsvc_NetCharDevQPurgeSelf),

19278

(ndr_push_flags_fn_t) ndr_push_srvsvc_NetCharDevQPurgeSelf,

19279

(ndr_pull_flags_fn_t) ndr_pull_srvsvc_NetCharDevQPurgeSelf,

19280

(ndr_print_function_t) ndr_print_srvsvc_NetCharDevQPurgeSelf,

19281

false,

19282

19283

{

19284

"srvsvc_NetConnEnum",

19285

sizeof(struct srvsvc_NetConnEnum),

19286

(ndr_push_flags_fn_t) ndr_push_srvsvc_NetConnEnum,

19287

(ndr_pull_flags_fn_t) ndr_pull_srvsvc_NetConnEnum,

19288

(ndr_print_function_t) ndr_print_srvsvc_NetConnEnum,

19289

false,

19290

19291

{

19292

"srvsvc_NetFileEnum",

19293

sizeof(struct srvsvc_NetFileEnum),

19294

(ndr_push_flags_fn_t) ndr_push_srvsvc_NetFileEnum,

19295

(ndr_pull_flags_fn_t) ndr_pull_srvsvc_NetFileEnum,

19296

(ndr_print_function_t) ndr_print_srvsvc_NetFileEnum,

19297

false,

19298

19299

{

19300

"srvsvc_NetFileGetInfo",

19301

sizeof(struct srvsvc_NetFileGetInfo),

19302

(ndr_push_flags_fn_t) ndr_push_srvsvc_NetFileGetInfo,

19303

(ndr_pull_flags_fn_t) ndr_pull_srvsvc_NetFileGetInfo,

19304

(ndr_print_function_t) ndr_print_srvsvc_NetFileGetInfo,

19305

false,

19306

19307

{

19308

"srvsvc_NetFileClose",

19309

sizeof(struct srvsvc_NetFileClose),

19310

(ndr_push_flags_fn_t) ndr_push_srvsvc_NetFileClose,

19311

(ndr_pull_flags_fn_t) ndr_pull_srvsvc_NetFileClose,

19312

(ndr_print_function_t) ndr_print_srvsvc_NetFileClose,

19313

false,

19314

19315

{

19316

"srvsvc_NetSessEnum",

19317

sizeof(struct srvsvc_NetSessEnum),

19318

(ndr_push_flags_fn_t) ndr_push_srvsvc_NetSessEnum,

19319

(ndr_pull_flags_fn_t) ndr_pull_srvsvc_NetSessEnum,

19320

(ndr_print_function_t) ndr_print_srvsvc_NetSessEnum,

19321

false,

19322

19323

{

19324

"srvsvc_NetSessDel",

19325

sizeof(struct srvsvc_NetSessDel),

19326

(ndr_push_flags_fn_t) ndr_push_srvsvc_NetSessDel,

19327

(ndr_pull_flags_fn_t) ndr_pull_srvsvc_NetSessDel,

19328

(ndr_print_function_t) ndr_print_srvsvc_NetSessDel,

19329

false,

19330

19331

{

19332

"srvsvc_NetShareAdd",

19333

sizeof(struct srvsvc_NetShareAdd),

19334

(ndr_push_flags_fn_t) ndr_push_srvsvc_NetShareAdd,

19335

(ndr_pull_flags_fn_t) ndr_pull_srvsvc_NetShareAdd,

19336

(ndr_print_function_t) ndr_print_srvsvc_NetShareAdd,

19337

false,

19338

19339

{

19340

"srvsvc_NetShareEnumAll",

19341

sizeof(struct srvsvc_NetShareEnumAll),

19342

(ndr_push_flags_fn_t) ndr_push_srvsvc_NetShareEnumAll,

19343

(ndr_pull_flags_fn_t) ndr_pull_srvsvc_NetShareEnumAll,

19344

(ndr_print_function_t) ndr_print_srvsvc_NetShareEnumAll,

19345

false,

19346

19347

{

19348

"srvsvc_NetShareGetInfo",

19349

sizeof(struct srvsvc_NetShareGetInfo),

19350

(ndr_push_flags_fn_t) ndr_push_srvsvc_NetShareGetInfo,

19351

(ndr_pull_flags_fn_t) ndr_pull_srvsvc_NetShareGetInfo,

19352

(ndr_print_function_t) ndr_print_srvsvc_NetShareGetInfo,

19353

false,

19354

19355

{

19356

"srvsvc_NetShareSetInfo",

19357

sizeof(struct srvsvc_NetShareSetInfo),

19358

(ndr_push_flags_fn_t) ndr_push_srvsvc_NetShareSetInfo,

19359

(ndr_pull_flags_fn_t) ndr_pull_srvsvc_NetShareSetInfo,

19360

(ndr_print_function_t) ndr_print_srvsvc_NetShareSetInfo,

19361

false,

19362

19363

{

19364

"srvsvc_NetShareDel",

19365

sizeof(struct srvsvc_NetShareDel),

19366

(ndr_push_flags_fn_t) ndr_push_srvsvc_NetShareDel,

19367

(ndr_pull_flags_fn_t) ndr_pull_srvsvc_NetShareDel,

19368

(ndr_print_function_t) ndr_print_srvsvc_NetShareDel,

19369

false,

19370

19371

{

19372

"srvsvc_NetShareDelSticky",

19373

sizeof(struct srvsvc_NetShareDelSticky),

19374

(ndr_push_flags_fn_t) ndr_push_srvsvc_NetShareDelSticky,

19375

(ndr_pull_flags_fn_t) ndr_pull_srvsvc_NetShareDelSticky,

19376

(ndr_print_function_t) ndr_print_srvsvc_NetShareDelSticky,

19377

false,

19378

19379

{

19380

"srvsvc_NetShareCheck",

19381

sizeof(struct srvsvc_NetShareCheck),

19382

(ndr_push_flags_fn_t) ndr_push_srvsvc_NetShareCheck,

19383

(ndr_pull_flags_fn_t) ndr_pull_srvsvc_NetShareCheck,

19384

(ndr_print_function_t) ndr_print_srvsvc_NetShareCheck,

19385

false,

19386

19387

{

19388

"srvsvc_NetSrvGetInfo",

19389

sizeof(struct srvsvc_NetSrvGetInfo),

19390

(ndr_push_flags_fn_t) ndr_push_srvsvc_NetSrvGetInfo,

19391

(ndr_pull_flags_fn_t) ndr_pull_srvsvc_NetSrvGetInfo,

19392

(ndr_print_function_t) ndr_print_srvsvc_NetSrvGetInfo,

19393

false,

19394

19395

{

19396

"srvsvc_NetSrvSetInfo",

19397

sizeof(struct srvsvc_NetSrvSetInfo),

19398

(ndr_push_flags_fn_t) ndr_push_srvsvc_NetSrvSetInfo,

19399

(ndr_pull_flags_fn_t) ndr_pull_srvsvc_NetSrvSetInfo,

19400

(ndr_print_function_t) ndr_print_srvsvc_NetSrvSetInfo,

19401

false,

19402

19403

{

19404

"srvsvc_NetDiskEnum",

19405

sizeof(struct srvsvc_NetDiskEnum),

19406

(ndr_push_flags_fn_t) ndr_push_srvsvc_NetDiskEnum,

19407

(ndr_pull_flags_fn_t) ndr_pull_srvsvc_NetDiskEnum,

19408

(ndr_print_function_t) ndr_print_srvsvc_NetDiskEnum,

19409

false,

19410

19411

{

19412

"srvsvc_NetServerStatisticsGet",

19413

sizeof(struct srvsvc_NetServerStatisticsGet),

19414

(ndr_push_flags_fn_t) ndr_push_srvsvc_NetServerStatisticsGet,

19415

(ndr_pull_flags_fn_t) ndr_pull_srvsvc_NetServerStatisticsGet,

19416

(ndr_print_function_t) ndr_print_srvsvc_NetServerStatisticsGet,

19417

false,

19418

19419

{

19420

"srvsvc_NetTransportAdd",

19421

sizeof(struct srvsvc_NetTransportAdd),

19422

(ndr_push_flags_fn_t) ndr_push_srvsvc_NetTransportAdd,

19423

(ndr_pull_flags_fn_t) ndr_pull_srvsvc_NetTransportAdd,

19424

(ndr_print_function_t) ndr_print_srvsvc_NetTransportAdd,

19425

false,

19426

19427

{

19428

"srvsvc_NetTransportEnum",

19429

sizeof(struct srvsvc_NetTransportEnum),

19430

(ndr_push_flags_fn_t) ndr_push_srvsvc_NetTransportEnum,

19431

(ndr_pull_flags_fn_t) ndr_pull_srvsvc_NetTransportEnum,

19432

(ndr_print_function_t) ndr_print_srvsvc_NetTransportEnum,

19433

false,

19434

19435

{

19436

"srvsvc_NetTransportDel",

19437

sizeof(struct srvsvc_NetTransportDel),

19438

(ndr_push_flags_fn_t) ndr_push_srvsvc_NetTransportDel,

19439

(ndr_pull_flags_fn_t) ndr_pull_srvsvc_NetTransportDel,

19440

(ndr_print_function_t) ndr_print_srvsvc_NetTransportDel,

19441

false,

19442

19443

{

19444

"srvsvc_NetRemoteTOD",

19445

sizeof(struct srvsvc_NetRemoteTOD),

19446

(ndr_push_flags_fn_t) ndr_push_srvsvc_NetRemoteTOD,

19447

(ndr_pull_flags_fn_t) ndr_pull_srvsvc_NetRemoteTOD,

19448

(ndr_print_function_t) ndr_print_srvsvc_NetRemoteTOD,

19449

false,

19450

19451

{

19452

"srvsvc_NetSetServiceBits",

19453

sizeof(struct srvsvc_NetSetServiceBits),

19454

(ndr_push_flags_fn_t) ndr_push_srvsvc_NetSetServiceBits,

19455

(ndr_pull_flags_fn_t) ndr_pull_srvsvc_NetSetServiceBits,

19456

(ndr_print_function_t) ndr_print_srvsvc_NetSetServiceBits,

19457

false,

19458

19459

{

19460

"srvsvc_NetPathType",

19461

sizeof(struct srvsvc_NetPathType),

19462

(ndr_push_flags_fn_t) ndr_push_srvsvc_NetPathType,

19463

(ndr_pull_flags_fn_t) ndr_pull_srvsvc_NetPathType,

19464

(ndr_print_function_t) ndr_print_srvsvc_NetPathType,

19465

false,

19466

19467

{

19468

"srvsvc_NetPathCanonicalize",

19469

sizeof(struct srvsvc_NetPathCanonicalize),

19470

(ndr_push_flags_fn_t) ndr_push_srvsvc_NetPathCanonicalize,

19471

(ndr_pull_flags_fn_t) ndr_pull_srvsvc_NetPathCanonicalize,

19472

(ndr_print_function_t) ndr_print_srvsvc_NetPathCanonicalize,

19473

false,

19474

19475

{

19476

"srvsvc_NetPathCompare",

19477

sizeof(struct srvsvc_NetPathCompare),

19478

(ndr_push_flags_fn_t) ndr_push_srvsvc_NetPathCompare,

19479

(ndr_pull_flags_fn_t) ndr_pull_srvsvc_NetPathCompare,

19480

(ndr_print_function_t) ndr_print_srvsvc_NetPathCompare,

19481

false,

19482

19483

{

19484

"srvsvc_NetNameValidate",

19485

sizeof(struct srvsvc_NetNameValidate),

19486

(ndr_push_flags_fn_t) ndr_push_srvsvc_NetNameValidate,

19487

(ndr_pull_flags_fn_t) ndr_pull_srvsvc_NetNameValidate,

19488

(ndr_print_function_t) ndr_print_srvsvc_NetNameValidate,

19489

false,

19490

19491

{

19492

"srvsvc_NETRPRNAMECANONICALIZE",

19493

sizeof(struct srvsvc_NETRPRNAMECANONICALIZE),

19494

(ndr_push_flags_fn_t) ndr_push_srvsvc_NETRPRNAMECANONICALIZE,

19495

(ndr_pull_flags_fn_t) ndr_pull_srvsvc_NETRPRNAMECANONICALIZE,

19496

(ndr_print_function_t) ndr_print_srvsvc_NETRPRNAMECANONICALIZE,

19497

false,

19498

19499

{

19500

"srvsvc_NetPRNameCompare",

19501

sizeof(struct srvsvc_NetPRNameCompare),

19502

(ndr_push_flags_fn_t) ndr_push_srvsvc_NetPRNameCompare,

19503

(ndr_pull_flags_fn_t) ndr_pull_srvsvc_NetPRNameCompare,

19504

(ndr_print_function_t) ndr_print_srvsvc_NetPRNameCompare,

19505

false,

19506

19507

{

19508

"srvsvc_NetShareEnum",

19509

sizeof(struct srvsvc_NetShareEnum),

19510

(ndr_push_flags_fn_t) ndr_push_srvsvc_NetShareEnum,

19511

(ndr_pull_flags_fn_t) ndr_pull_srvsvc_NetShareEnum,

19512

(ndr_print_function_t) ndr_print_srvsvc_NetShareEnum,

19513

false,

19514

19515

{

19516

"srvsvc_NetShareDelStart",

19517

sizeof(struct srvsvc_NetShareDelStart),

19518

(ndr_push_flags_fn_t) ndr_push_srvsvc_NetShareDelStart,

19519

(ndr_pull_flags_fn_t) ndr_pull_srvsvc_NetShareDelStart,

19520

(ndr_print_function_t) ndr_print_srvsvc_NetShareDelStart,

19521

false,

19522

19523

{

19524

"srvsvc_NetShareDelCommit",

19525

sizeof(struct srvsvc_NetShareDelCommit),

19526

(ndr_push_flags_fn_t) ndr_push_srvsvc_NetShareDelCommit,

19527

(ndr_pull_flags_fn_t) ndr_pull_srvsvc_NetShareDelCommit,

19528

(ndr_print_function_t) ndr_print_srvsvc_NetShareDelCommit,

19529

false,

19530

19531

{

19532

"srvsvc_NetGetFileSecurity",

19533

sizeof(struct srvsvc_NetGetFileSecurity),

19534

(ndr_push_flags_fn_t) ndr_push_srvsvc_NetGetFileSecurity,

19535

(ndr_pull_flags_fn_t) ndr_pull_srvsvc_NetGetFileSecurity,

19536

(ndr_print_function_t) ndr_print_srvsvc_NetGetFileSecurity,

19537

false,

19538

19539

{

19540

"srvsvc_NetSetFileSecurity",

19541

sizeof(struct srvsvc_NetSetFileSecurity),

19542

(ndr_push_flags_fn_t) ndr_push_srvsvc_NetSetFileSecurity,

19543

(ndr_pull_flags_fn_t) ndr_pull_srvsvc_NetSetFileSecurity,

19544

(ndr_print_function_t) ndr_print_srvsvc_NetSetFileSecurity,

19545

false,

19546

19547

{

19548

"srvsvc_NetServerTransportAddEx",

19549

sizeof(struct srvsvc_NetServerTransportAddEx),

19550

(ndr_push_flags_fn_t) ndr_push_srvsvc_NetServerTransportAddEx,

19551

(ndr_pull_flags_fn_t) ndr_pull_srvsvc_NetServerTransportAddEx,

19552

(ndr_print_function_t) ndr_print_srvsvc_NetServerTransportAddEx,

19553

false,

19554

19555

{

19556

"srvsvc_NetServerSetServiceBitsEx",

19557

sizeof(struct srvsvc_NetServerSetServiceBitsEx),

19558

(ndr_push_flags_fn_t) ndr_push_srvsvc_NetServerSetServiceBitsEx,

19559

(ndr_pull_flags_fn_t) ndr_pull_srvsvc_NetServerSetServiceBitsEx,

19560

(ndr_print_function_t) ndr_print_srvsvc_NetServerSetServiceBitsEx,

19561

false,

19562

19563

{

19564

"srvsvc_NETRDFSGETVERSION",

19565

sizeof(struct srvsvc_NETRDFSGETVERSION),

19566

(ndr_push_flags_fn_t) ndr_push_srvsvc_NETRDFSGETVERSION,

19567

(ndr_pull_flags_fn_t) ndr_pull_srvsvc_NETRDFSGETVERSION,

19568

(ndr_print_function_t) ndr_print_srvsvc_NETRDFSGETVERSION,

19569

false,

19570

19571

{

19572

"srvsvc_NETRDFSCREATELOCALPARTITION",

19573

sizeof(struct srvsvc_NETRDFSCREATELOCALPARTITION),

19574

(ndr_push_flags_fn_t) ndr_push_srvsvc_NETRDFSCREATELOCALPARTITION,

19575

(ndr_pull_flags_fn_t) ndr_pull_srvsvc_NETRDFSCREATELOCALPARTITION,

19576

(ndr_print_function_t) ndr_print_srvsvc_NETRDFSCREATELOCALPARTITION,

19577

false,

19578

19579

{

19580

"srvsvc_NETRDFSDELETELOCALPARTITION",

19581

sizeof(struct srvsvc_NETRDFSDELETELOCALPARTITION),

19582

(ndr_push_flags_fn_t) ndr_push_srvsvc_NETRDFSDELETELOCALPARTITION,

19583

(ndr_pull_flags_fn_t) ndr_pull_srvsvc_NETRDFSDELETELOCALPARTITION,

19584

(ndr_print_function_t) ndr_print_srvsvc_NETRDFSDELETELOCALPARTITION,

19585

false,

19586

19587

{

19588

"srvsvc_NETRDFSSETLOCALVOLUMESTATE",

19589

sizeof(struct srvsvc_NETRDFSSETLOCALVOLUMESTATE),

19590

(ndr_push_flags_fn_t) ndr_push_srvsvc_NETRDFSSETLOCALVOLUMESTATE,

19591

(ndr_pull_flags_fn_t) ndr_pull_srvsvc_NETRDFSSETLOCALVOLUMESTATE,

19592

(ndr_print_function_t) ndr_print_srvsvc_NETRDFSSETLOCALVOLUMESTATE,

19593

false,

19594

19595

{

19596

"srvsvc_NETRDFSSETSERVERINFO",

19597

sizeof(struct srvsvc_NETRDFSSETSERVERINFO),

19598

(ndr_push_flags_fn_t) ndr_push_srvsvc_NETRDFSSETSERVERINFO,

19599

(ndr_pull_flags_fn_t) ndr_pull_srvsvc_NETRDFSSETSERVERINFO,

19600

(ndr_print_function_t) ndr_print_srvsvc_NETRDFSSETSERVERINFO,

19601

false,

19602

19603

{

19604

"srvsvc_NETRDFSCREATEEXITPOINT",

19605

sizeof(struct srvsvc_NETRDFSCREATEEXITPOINT),

19606

(ndr_push_flags_fn_t) ndr_push_srvsvc_NETRDFSCREATEEXITPOINT,

19607

(ndr_pull_flags_fn_t) ndr_pull_srvsvc_NETRDFSCREATEEXITPOINT,

19608

(ndr_print_function_t) ndr_print_srvsvc_NETRDFSCREATEEXITPOINT,

19609

false,

19610

19611

{

19612

"srvsvc_NETRDFSDELETEEXITPOINT",

19613

sizeof(struct srvsvc_NETRDFSDELETEEXITPOINT),

19614

(ndr_push_flags_fn_t) ndr_push_srvsvc_NETRDFSDELETEEXITPOINT,

19615

(ndr_pull_flags_fn_t) ndr_pull_srvsvc_NETRDFSDELETEEXITPOINT,

19616

(ndr_print_function_t) ndr_print_srvsvc_NETRDFSDELETEEXITPOINT,

19617

false,

19618

19619

{

19620

"srvsvc_NETRDFSMODIFYPREFIX",

19621

sizeof(struct srvsvc_NETRDFSMODIFYPREFIX),

19622

(ndr_push_flags_fn_t) ndr_push_srvsvc_NETRDFSMODIFYPREFIX,

19623

(ndr_pull_flags_fn_t) ndr_pull_srvsvc_NETRDFSMODIFYPREFIX,

19624

(ndr_print_function_t) ndr_print_srvsvc_NETRDFSMODIFYPREFIX,

19625

false,

19626

19627

{

19628

"srvsvc_NETRDFSFIXLOCALVOLUME",

19629

sizeof(struct srvsvc_NETRDFSFIXLOCALVOLUME),

19630

(ndr_push_flags_fn_t) ndr_push_srvsvc_NETRDFSFIXLOCALVOLUME,

19631

(ndr_pull_flags_fn_t) ndr_pull_srvsvc_NETRDFSFIXLOCALVOLUME,

19632

(ndr_print_function_t) ndr_print_srvsvc_NETRDFSFIXLOCALVOLUME,

19633

false,

19634

19635

{

19636

"srvsvc_NETRDFSMANAGERREPORTSITEINFO",

19637

sizeof(struct srvsvc_NETRDFSMANAGERREPORTSITEINFO),

19638

(ndr_push_flags_fn_t) ndr_push_srvsvc_NETRDFSMANAGERREPORTSITEINFO,

19639

(ndr_pull_flags_fn_t) ndr_pull_srvsvc_NETRDFSMANAGERREPORTSITEINFO,

19640

(ndr_print_function_t) ndr_print_srvsvc_NETRDFSMANAGERREPORTSITEINFO,

19641

false,

19642

19643

{

19644

"srvsvc_NETRSERVERTRANSPORTDELEX",

19645

sizeof(struct srvsvc_NETRSERVERTRANSPORTDELEX),

19646

(ndr_push_flags_fn_t) ndr_push_srvsvc_NETRSERVERTRANSPORTDELEX,

19647

(ndr_pull_flags_fn_t) ndr_pull_srvsvc_NETRSERVERTRANSPORTDELEX,

19648

(ndr_print_function_t) ndr_print_srvsvc_NETRSERVERTRANSPORTDELEX,

19649

false,

19650

19651

{ NULL, 0, NULL, NULL, NULL, false }

19652

};

19653

19654

static const char * const srvsvc_endpoint_strings[] = {

19655

"ncacn_np:[\\pipe\\srvsvc]",

19656

"ncacn_ip_tcp:",

19657

"ncalrpc:",

19658

};

19659

19660

static const struct ndr_interface_string_array srvsvc_endpoints = {

19661

.count = 3,

19662

.names = srvsvc_endpoint_strings

19663

};

19664

19665

static const char * const srvsvc_authservice_strings[] = {

19666

"host",

19667

};

19668

19669

static const struct ndr_interface_string_array srvsvc_authservices = {

19670

.count = 1,

19671

.names = srvsvc_authservice_strings

19672

};

19673

19674

19675

const struct ndr_interface_table ndr_table_srvsvc = {

19676

.name = "srvsvc",

19677

.syntax_id = {

19678

{0x4b324fc8,0x1670,0x01d3,{0x12,0x78},{0x5a,0x47,0xbf,0x6e,0xe1,0x88}},

19679

NDR_SRVSVC_VERSION

19680

19681

.helpstring = NDR_SRVSVC_HELPSTRING,

19682

.num_calls = 54,

19683

.calls = srvsvc_calls,

19684

.endpoints = &srvsvc_endpoints,

19685

.authservices = &srvsvc_authservices

19686

};

19687