~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->server_name), ndr_get_array_length(ndr, &r->server_name));

}

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

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

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_name_0, 0);

}

if (r->domain_name) {

_mem_save_domain_name_0 = NDR_PULL_GET_MEM_CTX(ndr);

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

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

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

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

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_name), ndr_get_array_length(ndr, &r->domain_name));

}

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

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

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domain_name_0, 0);

}

return NDR_ERR_SUCCESS;

}

_PUBLIC_ void ndr_print_wkssvc_NetWkstaInfo100(struct ndr_print *ndr, const char *name, const struct wkssvc_NetWkstaInfo100 *r)

{

ndr_print_struct(ndr, name, "wkssvc_NetWkstaInfo100");

ndr->depth++;

ndr_print_srvsvc_PlatformId(ndr, "platform_id", r->platform_id);

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

ndr->depth++;

if (r->server_name) {

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

}

ndr->depth--;

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

100

ndr->depth++;

101

if (r->domain_name) {

102

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

103

}

104

ndr->depth--;

105

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

106

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

107

ndr->depth--;

108

}

109

110

static enum ndr_err_code ndr_push_wkssvc_NetWkstaInfo101(struct ndr_push *ndr, int ndr_flags, const struct wkssvc_NetWkstaInfo101 *r)

111

{

112

if (ndr_flags & NDR_SCALARS) {

113

NDR_CHECK(ndr_push_align(ndr, 4));

114

NDR_CHECK(ndr_push_srvsvc_PlatformId(ndr, NDR_SCALARS, r->platform_id));

115

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

116

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

117

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

118

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

119

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

120

}

121

if (ndr_flags & NDR_BUFFERS) {

122

if (r->server_name) {

123

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

124

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

125

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

126

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

127

}

128

if (r->domain_name) {

129

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

130

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

131

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

132

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

133

}

134

if (r->lan_root) {

135

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

136

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

137

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

138

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

139

}

140

}

141

return NDR_ERR_SUCCESS;

142

}

143

144

static enum ndr_err_code ndr_pull_wkssvc_NetWkstaInfo101(struct ndr_pull *ndr, int ndr_flags, struct wkssvc_NetWkstaInfo101 *r)

145

{

146

uint32_t _ptr_server_name;

147

TALLOC_CTX *_mem_save_server_name_0;

148

uint32_t _ptr_domain_name;

149

TALLOC_CTX *_mem_save_domain_name_0;

150

uint32_t _ptr_lan_root;

151

TALLOC_CTX *_mem_save_lan_root_0;

152

if (ndr_flags & NDR_SCALARS) {

153

NDR_CHECK(ndr_pull_align(ndr, 4));

154

NDR_CHECK(ndr_pull_srvsvc_PlatformId(ndr, NDR_SCALARS, &r->platform_id));

155

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_name));

156

if (_ptr_server_name) {

157

NDR_PULL_ALLOC(ndr, r->server_name);

158

} else {

159

r->server_name = NULL;

160

}

161

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_domain_name));

162

if (_ptr_domain_name) {

163

NDR_PULL_ALLOC(ndr, r->domain_name);

164

} else {

165

r->domain_name = NULL;

166

}

167

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

168

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

169

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_lan_root));

170

if (_ptr_lan_root) {

171

NDR_PULL_ALLOC(ndr, r->lan_root);

172

} else {

173

r->lan_root = NULL;

174

}

175

}

176

if (ndr_flags & NDR_BUFFERS) {

177

if (r->server_name) {

178

_mem_save_server_name_0 = NDR_PULL_GET_MEM_CTX(ndr);

179

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

180

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

181

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

182

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

183

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));

184

}

185

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

186

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

187

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_name_0, 0);

188

}

189

if (r->domain_name) {

190

_mem_save_domain_name_0 = NDR_PULL_GET_MEM_CTX(ndr);

191

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

192

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

193

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

194

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

195

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_name), ndr_get_array_length(ndr, &r->domain_name));

196

}

197

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

198

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

199

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domain_name_0, 0);

200

}

201

if (r->lan_root) {

202

_mem_save_lan_root_0 = NDR_PULL_GET_MEM_CTX(ndr);

203

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

204

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

205

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

206

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

207

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

208

}

209

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

210

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

211

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_lan_root_0, 0);

212

}

213

}

214

return NDR_ERR_SUCCESS;

215

}

216

217

_PUBLIC_ void ndr_print_wkssvc_NetWkstaInfo101(struct ndr_print *ndr, const char *name, const struct wkssvc_NetWkstaInfo101 *r)

218

{

219

ndr_print_struct(ndr, name, "wkssvc_NetWkstaInfo101");

220

ndr->depth++;

221

ndr_print_srvsvc_PlatformId(ndr, "platform_id", r->platform_id);

222

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

223

ndr->depth++;

224

if (r->server_name) {

225

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

226

}

227

ndr->depth--;

228

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

229

ndr->depth++;

230

if (r->domain_name) {

231

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

232

}

233

ndr->depth--;

234

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

235

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

236

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

237

ndr->depth++;

238

if (r->lan_root) {

239

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

240

}

241

ndr->depth--;

242

ndr->depth--;

243

}

244

245

static enum ndr_err_code ndr_push_wkssvc_NetWkstaInfo102(struct ndr_push *ndr, int ndr_flags, const struct wkssvc_NetWkstaInfo102 *r)

246

{

247

if (ndr_flags & NDR_SCALARS) {

248

NDR_CHECK(ndr_push_align(ndr, 4));

249

NDR_CHECK(ndr_push_srvsvc_PlatformId(ndr, NDR_SCALARS, r->platform_id));

250

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

251

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

252

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

253

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

254

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

255

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

256

}

257

if (ndr_flags & NDR_BUFFERS) {

258

if (r->server_name) {

259

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

260

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

261

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

262

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

263

}

264

if (r->domain_name) {

265

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

266

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

267

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

268

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

269

}

270

if (r->lan_root) {

271

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

272

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

273

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

274

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

275

}

276

}

277

return NDR_ERR_SUCCESS;

278

}

279

280

static enum ndr_err_code ndr_pull_wkssvc_NetWkstaInfo102(struct ndr_pull *ndr, int ndr_flags, struct wkssvc_NetWkstaInfo102 *r)

281

{

282

uint32_t _ptr_server_name;

283

TALLOC_CTX *_mem_save_server_name_0;

284

uint32_t _ptr_domain_name;

285

TALLOC_CTX *_mem_save_domain_name_0;

286

uint32_t _ptr_lan_root;

287

TALLOC_CTX *_mem_save_lan_root_0;

288

if (ndr_flags & NDR_SCALARS) {

289

NDR_CHECK(ndr_pull_align(ndr, 4));

290

NDR_CHECK(ndr_pull_srvsvc_PlatformId(ndr, NDR_SCALARS, &r->platform_id));

291

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_name));

292

if (_ptr_server_name) {

293

NDR_PULL_ALLOC(ndr, r->server_name);

294

} else {

295

r->server_name = NULL;

296

}

297

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_domain_name));

298

if (_ptr_domain_name) {

299

NDR_PULL_ALLOC(ndr, r->domain_name);

300

} else {

301

r->domain_name = NULL;

302

}

303

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

304

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

305

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_lan_root));

306

if (_ptr_lan_root) {

307

NDR_PULL_ALLOC(ndr, r->lan_root);

308

} else {

309

r->lan_root = NULL;

310

}

311

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

312

}

313

if (ndr_flags & NDR_BUFFERS) {

314

if (r->server_name) {

315

_mem_save_server_name_0 = NDR_PULL_GET_MEM_CTX(ndr);

316

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

317

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

318

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

319

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

320

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));

321

}

322

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

323

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

324

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_name_0, 0);

325

}

326

if (r->domain_name) {

327

_mem_save_domain_name_0 = NDR_PULL_GET_MEM_CTX(ndr);

328

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

329

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

330

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

331

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

332

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_name), ndr_get_array_length(ndr, &r->domain_name));

333

}

334

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

335

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

336

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domain_name_0, 0);

337

}

338

if (r->lan_root) {

339

_mem_save_lan_root_0 = NDR_PULL_GET_MEM_CTX(ndr);

340

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

341

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

342

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

343

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

344

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

345

}

346

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

347

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

348

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_lan_root_0, 0);

349

}

350

}

351

return NDR_ERR_SUCCESS;

352

}

353

354

_PUBLIC_ void ndr_print_wkssvc_NetWkstaInfo102(struct ndr_print *ndr, const char *name, const struct wkssvc_NetWkstaInfo102 *r)

355

{

356

ndr_print_struct(ndr, name, "wkssvc_NetWkstaInfo102");

357

ndr->depth++;

358

ndr_print_srvsvc_PlatformId(ndr, "platform_id", r->platform_id);

359

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

360

ndr->depth++;

361

if (r->server_name) {

362

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

363

}

364

ndr->depth--;

365

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

366

ndr->depth++;

367

if (r->domain_name) {

368

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

369

}

370

ndr->depth--;

371

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

372

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

373

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

374

ndr->depth++;

375

if (r->lan_root) {

376

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

377

}

378

ndr->depth--;

379

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

380

ndr->depth--;

381

}

382

383

static enum ndr_err_code ndr_push_wkssvc_NetWkstaInfo502(struct ndr_push *ndr, int ndr_flags, const struct wkssvc_NetWkstaInfo502 *r)

384

{

385

if (ndr_flags & NDR_SCALARS) {

386

NDR_CHECK(ndr_push_align(ndr, 4));

387

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

388

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

389

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

390

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

391

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

392

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

393

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

394

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

395

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

396

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

397

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

398

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

399

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

400

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

401

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

402

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

403

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

404

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

405

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

406

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

407

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

408

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

409

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

410

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

411

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

412

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

413

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

414

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

415

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

416

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

417

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

418

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

419

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

420

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

421

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

422

}

423

if (ndr_flags & NDR_BUFFERS) {

424

}

425

return NDR_ERR_SUCCESS;

426

}

427

428

static enum ndr_err_code ndr_pull_wkssvc_NetWkstaInfo502(struct ndr_pull *ndr, int ndr_flags, struct wkssvc_NetWkstaInfo502 *r)

429

{

430

if (ndr_flags & NDR_SCALARS) {

431

NDR_CHECK(ndr_pull_align(ndr, 4));

432

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

433

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

434

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

435

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

436

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

437

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

438

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

439

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

440

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

441

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

442

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

443

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

444

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

445

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

446

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

447

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

448

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

449

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

450

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

451

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

452

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

453

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

454

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

455

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

456

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

457

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

458

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

459

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

460

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

461

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

462

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

463

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

464

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

465

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

466

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

467

}

468

if (ndr_flags & NDR_BUFFERS) {

469

}

470

return NDR_ERR_SUCCESS;

471

}

472

473

_PUBLIC_ void ndr_print_wkssvc_NetWkstaInfo502(struct ndr_print *ndr, const char *name, const struct wkssvc_NetWkstaInfo502 *r)

474

{

475

ndr_print_struct(ndr, name, "wkssvc_NetWkstaInfo502");

476

ndr->depth++;

477

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

478

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

479

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

480

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

481

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

482

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

483

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

484

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

485

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

486

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

487

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

488

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

489

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

490

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

491

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

492

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

493

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

494

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

495

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

496

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

497

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

498

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

499

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

500

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

501

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

502

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

503

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

504

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

505

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

506

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

507

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

508

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

509

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

510

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

511

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

512

ndr->depth--;

513

}

514

515

static enum ndr_err_code ndr_push_wkssvc_NetWkstaInfo1010(struct ndr_push *ndr, int ndr_flags, const struct wkssvc_NetWkstaInfo1010 *r)

516

{

517

if (ndr_flags & NDR_SCALARS) {

518

NDR_CHECK(ndr_push_align(ndr, 4));

519

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

520

}

521

if (ndr_flags & NDR_BUFFERS) {

522

}

523

return NDR_ERR_SUCCESS;

524

}

525

526

static enum ndr_err_code ndr_pull_wkssvc_NetWkstaInfo1010(struct ndr_pull *ndr, int ndr_flags, struct wkssvc_NetWkstaInfo1010 *r)

527

{

528

if (ndr_flags & NDR_SCALARS) {

529

NDR_CHECK(ndr_pull_align(ndr, 4));

530

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

531

}

532

if (ndr_flags & NDR_BUFFERS) {

533

}

534

return NDR_ERR_SUCCESS;

535

}

536

537

_PUBLIC_ void ndr_print_wkssvc_NetWkstaInfo1010(struct ndr_print *ndr, const char *name, const struct wkssvc_NetWkstaInfo1010 *r)

538

{

539

ndr_print_struct(ndr, name, "wkssvc_NetWkstaInfo1010");

540

ndr->depth++;

541

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

542

ndr->depth--;

543

}

544

545

static enum ndr_err_code ndr_push_wkssvc_NetWkstaInfo1011(struct ndr_push *ndr, int ndr_flags, const struct wkssvc_NetWkstaInfo1011 *r)

546

{

547

if (ndr_flags & NDR_SCALARS) {

548

NDR_CHECK(ndr_push_align(ndr, 4));

549

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

550

}

551

if (ndr_flags & NDR_BUFFERS) {

552

}

553

return NDR_ERR_SUCCESS;

554

}

555

556

static enum ndr_err_code ndr_pull_wkssvc_NetWkstaInfo1011(struct ndr_pull *ndr, int ndr_flags, struct wkssvc_NetWkstaInfo1011 *r)

557

{

558

if (ndr_flags & NDR_SCALARS) {

559

NDR_CHECK(ndr_pull_align(ndr, 4));

560

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

561

}

562

if (ndr_flags & NDR_BUFFERS) {

563

}

564

return NDR_ERR_SUCCESS;

565

}

566

567

_PUBLIC_ void ndr_print_wkssvc_NetWkstaInfo1011(struct ndr_print *ndr, const char *name, const struct wkssvc_NetWkstaInfo1011 *r)

568

{

569

ndr_print_struct(ndr, name, "wkssvc_NetWkstaInfo1011");

570

ndr->depth++;

571

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

572

ndr->depth--;

573

}

574

575

static enum ndr_err_code ndr_push_wkssvc_NetWkstaInfo1012(struct ndr_push *ndr, int ndr_flags, const struct wkssvc_NetWkstaInfo1012 *r)

576

{

577

if (ndr_flags & NDR_SCALARS) {

578

NDR_CHECK(ndr_push_align(ndr, 4));

579

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

580

}

581

if (ndr_flags & NDR_BUFFERS) {

582

}

583

return NDR_ERR_SUCCESS;

584

}

585

586

static enum ndr_err_code ndr_pull_wkssvc_NetWkstaInfo1012(struct ndr_pull *ndr, int ndr_flags, struct wkssvc_NetWkstaInfo1012 *r)

587

{

588

if (ndr_flags & NDR_SCALARS) {

589

NDR_CHECK(ndr_pull_align(ndr, 4));

590

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

591

}

592

if (ndr_flags & NDR_BUFFERS) {

593

}

594

return NDR_ERR_SUCCESS;

595

}

596

597

_PUBLIC_ void ndr_print_wkssvc_NetWkstaInfo1012(struct ndr_print *ndr, const char *name, const struct wkssvc_NetWkstaInfo1012 *r)

598

{

599

ndr_print_struct(ndr, name, "wkssvc_NetWkstaInfo1012");

600

ndr->depth++;

601

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

602

ndr->depth--;

603

}

604

605

static enum ndr_err_code ndr_push_wkssvc_NetWkstaInfo1013(struct ndr_push *ndr, int ndr_flags, const struct wkssvc_NetWkstaInfo1013 *r)

606

{

607

if (ndr_flags & NDR_SCALARS) {

608

NDR_CHECK(ndr_push_align(ndr, 4));

609

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

610

}

611

if (ndr_flags & NDR_BUFFERS) {

612

}

613

return NDR_ERR_SUCCESS;

614

}

615

616

static enum ndr_err_code ndr_pull_wkssvc_NetWkstaInfo1013(struct ndr_pull *ndr, int ndr_flags, struct wkssvc_NetWkstaInfo1013 *r)

617

{

618

if (ndr_flags & NDR_SCALARS) {

619

NDR_CHECK(ndr_pull_align(ndr, 4));

620

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

621

}

622

if (ndr_flags & NDR_BUFFERS) {

623

}

624

return NDR_ERR_SUCCESS;

625

}

626

627

_PUBLIC_ void ndr_print_wkssvc_NetWkstaInfo1013(struct ndr_print *ndr, const char *name, const struct wkssvc_NetWkstaInfo1013 *r)

628

{

629

ndr_print_struct(ndr, name, "wkssvc_NetWkstaInfo1013");

630

ndr->depth++;

631

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

632

ndr->depth--;

633

}

634

635

static enum ndr_err_code ndr_push_wkssvc_NetWkstaInfo1018(struct ndr_push *ndr, int ndr_flags, const struct wkssvc_NetWkstaInfo1018 *r)

636

{

637

if (ndr_flags & NDR_SCALARS) {

638

NDR_CHECK(ndr_push_align(ndr, 4));

639

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

640

}

641

if (ndr_flags & NDR_BUFFERS) {

642

}

643

return NDR_ERR_SUCCESS;

644

}

645

646

static enum ndr_err_code ndr_pull_wkssvc_NetWkstaInfo1018(struct ndr_pull *ndr, int ndr_flags, struct wkssvc_NetWkstaInfo1018 *r)

647

{

648

if (ndr_flags & NDR_SCALARS) {

649

NDR_CHECK(ndr_pull_align(ndr, 4));

650

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

651

}

652

if (ndr_flags & NDR_BUFFERS) {

653

}

654

return NDR_ERR_SUCCESS;

655

}

656

657

_PUBLIC_ void ndr_print_wkssvc_NetWkstaInfo1018(struct ndr_print *ndr, const char *name, const struct wkssvc_NetWkstaInfo1018 *r)

658

{

659

ndr_print_struct(ndr, name, "wkssvc_NetWkstaInfo1018");

660

ndr->depth++;

661

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

662

ndr->depth--;

663

}

664

665

static enum ndr_err_code ndr_push_wkssvc_NetWkstaInfo1023(struct ndr_push *ndr, int ndr_flags, const struct wkssvc_NetWkstaInfo1023 *r)

666

{

667

if (ndr_flags & NDR_SCALARS) {

668

NDR_CHECK(ndr_push_align(ndr, 4));

669

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

670

}

671

if (ndr_flags & NDR_BUFFERS) {

672

}

673

return NDR_ERR_SUCCESS;

674

}

675

676

static enum ndr_err_code ndr_pull_wkssvc_NetWkstaInfo1023(struct ndr_pull *ndr, int ndr_flags, struct wkssvc_NetWkstaInfo1023 *r)

677

{

678

if (ndr_flags & NDR_SCALARS) {

679

NDR_CHECK(ndr_pull_align(ndr, 4));

680

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

681

}

682

if (ndr_flags & NDR_BUFFERS) {

683

}

684

return NDR_ERR_SUCCESS;

685

}

686

687

_PUBLIC_ void ndr_print_wkssvc_NetWkstaInfo1023(struct ndr_print *ndr, const char *name, const struct wkssvc_NetWkstaInfo1023 *r)

688

{

689

ndr_print_struct(ndr, name, "wkssvc_NetWkstaInfo1023");

690

ndr->depth++;

691

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

692

ndr->depth--;

693

}

694

695

static enum ndr_err_code ndr_push_wkssvc_NetWkstaInfo1027(struct ndr_push *ndr, int ndr_flags, const struct wkssvc_NetWkstaInfo1027 *r)

696

{

697

if (ndr_flags & NDR_SCALARS) {

698

NDR_CHECK(ndr_push_align(ndr, 4));

699

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

700

}

701

if (ndr_flags & NDR_BUFFERS) {

702

}

703

return NDR_ERR_SUCCESS;

704

}

705

706

static enum ndr_err_code ndr_pull_wkssvc_NetWkstaInfo1027(struct ndr_pull *ndr, int ndr_flags, struct wkssvc_NetWkstaInfo1027 *r)

707

{

708

if (ndr_flags & NDR_SCALARS) {

709

NDR_CHECK(ndr_pull_align(ndr, 4));

710

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

711

}

712

if (ndr_flags & NDR_BUFFERS) {

713

}

714

return NDR_ERR_SUCCESS;

715

}

716

717

_PUBLIC_ void ndr_print_wkssvc_NetWkstaInfo1027(struct ndr_print *ndr, const char *name, const struct wkssvc_NetWkstaInfo1027 *r)

718

{

719

ndr_print_struct(ndr, name, "wkssvc_NetWkstaInfo1027");

720

ndr->depth++;

721

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

722

ndr->depth--;

723

}

724

725

static enum ndr_err_code ndr_push_wkssvc_NetWkstaInfo1028(struct ndr_push *ndr, int ndr_flags, const struct wkssvc_NetWkstaInfo1028 *r)

726

{

727

if (ndr_flags & NDR_SCALARS) {

728

NDR_CHECK(ndr_push_align(ndr, 4));

729

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

730

}

731

if (ndr_flags & NDR_BUFFERS) {

732

}

733

return NDR_ERR_SUCCESS;

734

}

735

736

static enum ndr_err_code ndr_pull_wkssvc_NetWkstaInfo1028(struct ndr_pull *ndr, int ndr_flags, struct wkssvc_NetWkstaInfo1028 *r)

737

{

738

if (ndr_flags & NDR_SCALARS) {

739

NDR_CHECK(ndr_pull_align(ndr, 4));

740

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

741

}

742

if (ndr_flags & NDR_BUFFERS) {

743

}

744

return NDR_ERR_SUCCESS;

745

}

746

747

_PUBLIC_ void ndr_print_wkssvc_NetWkstaInfo1028(struct ndr_print *ndr, const char *name, const struct wkssvc_NetWkstaInfo1028 *r)

748

{

749

ndr_print_struct(ndr, name, "wkssvc_NetWkstaInfo1028");

750

ndr->depth++;

751

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

752

ndr->depth--;

753

}

754

755

static enum ndr_err_code ndr_push_wkssvc_NetWkstaInfo1032(struct ndr_push *ndr, int ndr_flags, const struct wkssvc_NetWkstaInfo1032 *r)

756

{

757

if (ndr_flags & NDR_SCALARS) {

758

NDR_CHECK(ndr_push_align(ndr, 4));

759

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

760

}

761

if (ndr_flags & NDR_BUFFERS) {

762

}

763

return NDR_ERR_SUCCESS;

764

}

765

766

static enum ndr_err_code ndr_pull_wkssvc_NetWkstaInfo1032(struct ndr_pull *ndr, int ndr_flags, struct wkssvc_NetWkstaInfo1032 *r)

767

{

768

if (ndr_flags & NDR_SCALARS) {

769

NDR_CHECK(ndr_pull_align(ndr, 4));

770

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

771

}

772

if (ndr_flags & NDR_BUFFERS) {

773

}

774

return NDR_ERR_SUCCESS;

775

}

776

777

_PUBLIC_ void ndr_print_wkssvc_NetWkstaInfo1032(struct ndr_print *ndr, const char *name, const struct wkssvc_NetWkstaInfo1032 *r)

778

{

779

ndr_print_struct(ndr, name, "wkssvc_NetWkstaInfo1032");

780

ndr->depth++;

781

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

782

ndr->depth--;

783

}

784

785

static enum ndr_err_code ndr_push_wkssvc_NetWkstaInfo1033(struct ndr_push *ndr, int ndr_flags, const struct wkssvc_NetWkstaInfo1033 *r)

786

{

787

if (ndr_flags & NDR_SCALARS) {

788

NDR_CHECK(ndr_push_align(ndr, 4));

789

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

790

}

791

if (ndr_flags & NDR_BUFFERS) {

792

}

793

return NDR_ERR_SUCCESS;

794

}

795

796

static enum ndr_err_code ndr_pull_wkssvc_NetWkstaInfo1033(struct ndr_pull *ndr, int ndr_flags, struct wkssvc_NetWkstaInfo1033 *r)

797

{

798

if (ndr_flags & NDR_SCALARS) {

799

NDR_CHECK(ndr_pull_align(ndr, 4));

800

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

801

}

802

if (ndr_flags & NDR_BUFFERS) {

803

}

804

return NDR_ERR_SUCCESS;

805

}

806

807

_PUBLIC_ void ndr_print_wkssvc_NetWkstaInfo1033(struct ndr_print *ndr, const char *name, const struct wkssvc_NetWkstaInfo1033 *r)

808

{

809

ndr_print_struct(ndr, name, "wkssvc_NetWkstaInfo1033");

810

ndr->depth++;

811

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

812

ndr->depth--;

813

}

814

815

static enum ndr_err_code ndr_push_wkssvc_NetWkstaInfo1041(struct ndr_push *ndr, int ndr_flags, const struct wkssvc_NetWkstaInfo1041 *r)

816

{

817

if (ndr_flags & NDR_SCALARS) {

818

NDR_CHECK(ndr_push_align(ndr, 4));

819

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

820

}

821

if (ndr_flags & NDR_BUFFERS) {

822

}

823

return NDR_ERR_SUCCESS;

824

}

825

826

static enum ndr_err_code ndr_pull_wkssvc_NetWkstaInfo1041(struct ndr_pull *ndr, int ndr_flags, struct wkssvc_NetWkstaInfo1041 *r)

827

{

828

if (ndr_flags & NDR_SCALARS) {

829

NDR_CHECK(ndr_pull_align(ndr, 4));

830

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

831

}

832

if (ndr_flags & NDR_BUFFERS) {

833

}

834

return NDR_ERR_SUCCESS;

835

}

836

837

_PUBLIC_ void ndr_print_wkssvc_NetWkstaInfo1041(struct ndr_print *ndr, const char *name, const struct wkssvc_NetWkstaInfo1041 *r)

838

{

839

ndr_print_struct(ndr, name, "wkssvc_NetWkstaInfo1041");

840

ndr->depth++;

841

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

842

ndr->depth--;

843

}

844

845

static enum ndr_err_code ndr_push_wkssvc_NetWkstaInfo1042(struct ndr_push *ndr, int ndr_flags, const struct wkssvc_NetWkstaInfo1042 *r)

846

{

847

if (ndr_flags & NDR_SCALARS) {

848

NDR_CHECK(ndr_push_align(ndr, 4));

849

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

850

}

851

if (ndr_flags & NDR_BUFFERS) {

852

}

853

return NDR_ERR_SUCCESS;

854

}

855

856

static enum ndr_err_code ndr_pull_wkssvc_NetWkstaInfo1042(struct ndr_pull *ndr, int ndr_flags, struct wkssvc_NetWkstaInfo1042 *r)

857

{

858

if (ndr_flags & NDR_SCALARS) {

859

NDR_CHECK(ndr_pull_align(ndr, 4));

860

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

861

}

862

if (ndr_flags & NDR_BUFFERS) {

863

}

864

return NDR_ERR_SUCCESS;

865

}

866

867

_PUBLIC_ void ndr_print_wkssvc_NetWkstaInfo1042(struct ndr_print *ndr, const char *name, const struct wkssvc_NetWkstaInfo1042 *r)

868

{

869

ndr_print_struct(ndr, name, "wkssvc_NetWkstaInfo1042");

870

ndr->depth++;

871

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

872

ndr->depth--;

873

}

874

875

static enum ndr_err_code ndr_push_wkssvc_NetWkstaInfo1043(struct ndr_push *ndr, int ndr_flags, const struct wkssvc_NetWkstaInfo1043 *r)

876

{

877

if (ndr_flags & NDR_SCALARS) {

878

NDR_CHECK(ndr_push_align(ndr, 4));

879

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

880

}

881

if (ndr_flags & NDR_BUFFERS) {

882

}

883

return NDR_ERR_SUCCESS;

884

}

885

886

static enum ndr_err_code ndr_pull_wkssvc_NetWkstaInfo1043(struct ndr_pull *ndr, int ndr_flags, struct wkssvc_NetWkstaInfo1043 *r)

887

{

888

if (ndr_flags & NDR_SCALARS) {

889

NDR_CHECK(ndr_pull_align(ndr, 4));

890

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

891

}

892

if (ndr_flags & NDR_BUFFERS) {

893

}

894

return NDR_ERR_SUCCESS;

895

}

896

897

_PUBLIC_ void ndr_print_wkssvc_NetWkstaInfo1043(struct ndr_print *ndr, const char *name, const struct wkssvc_NetWkstaInfo1043 *r)

898

{

899

ndr_print_struct(ndr, name, "wkssvc_NetWkstaInfo1043");

900

ndr->depth++;

901

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

902

ndr->depth--;

903

}

904

905

static enum ndr_err_code ndr_push_wkssvc_NetWkstaInfo1044(struct ndr_push *ndr, int ndr_flags, const struct wkssvc_NetWkstaInfo1044 *r)

906

{

907

if (ndr_flags & NDR_SCALARS) {

908

NDR_CHECK(ndr_push_align(ndr, 4));

909

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

910

}

911

if (ndr_flags & NDR_BUFFERS) {

912

}

913

return NDR_ERR_SUCCESS;

914

}

915

916

static enum ndr_err_code ndr_pull_wkssvc_NetWkstaInfo1044(struct ndr_pull *ndr, int ndr_flags, struct wkssvc_NetWkstaInfo1044 *r)

917

{

918

if (ndr_flags & NDR_SCALARS) {

919

NDR_CHECK(ndr_pull_align(ndr, 4));

920

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

921

}

922

if (ndr_flags & NDR_BUFFERS) {

923

}

924

return NDR_ERR_SUCCESS;

925

}

926

927

_PUBLIC_ void ndr_print_wkssvc_NetWkstaInfo1044(struct ndr_print *ndr, const char *name, const struct wkssvc_NetWkstaInfo1044 *r)

928

{

929

ndr_print_struct(ndr, name, "wkssvc_NetWkstaInfo1044");

930

ndr->depth++;

931

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

932

ndr->depth--;

933

}

934

935

static enum ndr_err_code ndr_push_wkssvc_NetWkstaInfo1045(struct ndr_push *ndr, int ndr_flags, const struct wkssvc_NetWkstaInfo1045 *r)

936

{

937

if (ndr_flags & NDR_SCALARS) {

938

NDR_CHECK(ndr_push_align(ndr, 4));

939

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

940

}

941

if (ndr_flags & NDR_BUFFERS) {

942

}

943

return NDR_ERR_SUCCESS;

944

}

945

946

static enum ndr_err_code ndr_pull_wkssvc_NetWkstaInfo1045(struct ndr_pull *ndr, int ndr_flags, struct wkssvc_NetWkstaInfo1045 *r)

947

{

948

if (ndr_flags & NDR_SCALARS) {

949

NDR_CHECK(ndr_pull_align(ndr, 4));

950

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

951

}

952

if (ndr_flags & NDR_BUFFERS) {

953

}

954

return NDR_ERR_SUCCESS;

955

}

956

957

_PUBLIC_ void ndr_print_wkssvc_NetWkstaInfo1045(struct ndr_print *ndr, const char *name, const struct wkssvc_NetWkstaInfo1045 *r)

958

{

959

ndr_print_struct(ndr, name, "wkssvc_NetWkstaInfo1045");

960

ndr->depth++;

961

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

962

ndr->depth--;

963

}

964

965

static enum ndr_err_code ndr_push_wkssvc_NetWkstaInfo1046(struct ndr_push *ndr, int ndr_flags, const struct wkssvc_NetWkstaInfo1046 *r)

966

{

967

if (ndr_flags & NDR_SCALARS) {

968

NDR_CHECK(ndr_push_align(ndr, 4));

969

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

970

}

971

if (ndr_flags & NDR_BUFFERS) {

972

}

973

return NDR_ERR_SUCCESS;

974

}

975

976

static enum ndr_err_code ndr_pull_wkssvc_NetWkstaInfo1046(struct ndr_pull *ndr, int ndr_flags, struct wkssvc_NetWkstaInfo1046 *r)

977

{

978

if (ndr_flags & NDR_SCALARS) {

979

NDR_CHECK(ndr_pull_align(ndr, 4));

980

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

981

}

982

if (ndr_flags & NDR_BUFFERS) {

983

}

984

return NDR_ERR_SUCCESS;

985

}

986

987

_PUBLIC_ void ndr_print_wkssvc_NetWkstaInfo1046(struct ndr_print *ndr, const char *name, const struct wkssvc_NetWkstaInfo1046 *r)

988

{

989

ndr_print_struct(ndr, name, "wkssvc_NetWkstaInfo1046");

990

ndr->depth++;

991

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

992

ndr->depth--;

993

}

994

995

static enum ndr_err_code ndr_push_wkssvc_NetWkstaInfo1047(struct ndr_push *ndr, int ndr_flags, const struct wkssvc_NetWkstaInfo1047 *r)

996

{

997

if (ndr_flags & NDR_SCALARS) {

998

NDR_CHECK(ndr_push_align(ndr, 4));

999

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

1000

}

1001

if (ndr_flags & NDR_BUFFERS) {

1002

}

1003

return NDR_ERR_SUCCESS;

1004

}

1005

1006

static enum ndr_err_code ndr_pull_wkssvc_NetWkstaInfo1047(struct ndr_pull *ndr, int ndr_flags, struct wkssvc_NetWkstaInfo1047 *r)

1007

{

1008

if (ndr_flags & NDR_SCALARS) {

1009

NDR_CHECK(ndr_pull_align(ndr, 4));

1010

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

1011

}

1012

if (ndr_flags & NDR_BUFFERS) {

1013

}

1014

return NDR_ERR_SUCCESS;

1015

}

1016

1017

_PUBLIC_ void ndr_print_wkssvc_NetWkstaInfo1047(struct ndr_print *ndr, const char *name, const struct wkssvc_NetWkstaInfo1047 *r)

1018

{

1019

ndr_print_struct(ndr, name, "wkssvc_NetWkstaInfo1047");

1020

ndr->depth++;

1021

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

1022

ndr->depth--;

1023

}

1024

1025

static enum ndr_err_code ndr_push_wkssvc_NetWkstaInfo1048(struct ndr_push *ndr, int ndr_flags, const struct wkssvc_NetWkstaInfo1048 *r)

1026

{

1027

if (ndr_flags & NDR_SCALARS) {

1028

NDR_CHECK(ndr_push_align(ndr, 4));

1029

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

1030

}

1031

if (ndr_flags & NDR_BUFFERS) {

1032

}

1033

return NDR_ERR_SUCCESS;

1034

}

1035

1036

static enum ndr_err_code ndr_pull_wkssvc_NetWkstaInfo1048(struct ndr_pull *ndr, int ndr_flags, struct wkssvc_NetWkstaInfo1048 *r)

1037

{

1038

if (ndr_flags & NDR_SCALARS) {

1039

NDR_CHECK(ndr_pull_align(ndr, 4));

1040

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

1041

}

1042

if (ndr_flags & NDR_BUFFERS) {

1043

}

1044

return NDR_ERR_SUCCESS;

1045

}

1046

1047

_PUBLIC_ void ndr_print_wkssvc_NetWkstaInfo1048(struct ndr_print *ndr, const char *name, const struct wkssvc_NetWkstaInfo1048 *r)

1048

{

1049

ndr_print_struct(ndr, name, "wkssvc_NetWkstaInfo1048");

1050

ndr->depth++;

1051

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

1052

ndr->depth--;

1053

}

1054

1055

static enum ndr_err_code ndr_push_wkssvc_NetWkstaInfo1049(struct ndr_push *ndr, int ndr_flags, const struct wkssvc_NetWkstaInfo1049 *r)

1056

{

1057

if (ndr_flags & NDR_SCALARS) {

1058

NDR_CHECK(ndr_push_align(ndr, 4));

1059

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

1060

}

1061

if (ndr_flags & NDR_BUFFERS) {

1062

}

1063

return NDR_ERR_SUCCESS;

1064

}

1065

1066

static enum ndr_err_code ndr_pull_wkssvc_NetWkstaInfo1049(struct ndr_pull *ndr, int ndr_flags, struct wkssvc_NetWkstaInfo1049 *r)

1067

{

1068

if (ndr_flags & NDR_SCALARS) {

1069

NDR_CHECK(ndr_pull_align(ndr, 4));

1070

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

1071

}

1072

if (ndr_flags & NDR_BUFFERS) {

1073

}

1074

return NDR_ERR_SUCCESS;

1075

}

1076

1077

_PUBLIC_ void ndr_print_wkssvc_NetWkstaInfo1049(struct ndr_print *ndr, const char *name, const struct wkssvc_NetWkstaInfo1049 *r)

1078

{

1079

ndr_print_struct(ndr, name, "wkssvc_NetWkstaInfo1049");

1080

ndr->depth++;

1081

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

1082

ndr->depth--;

1083

}

1084

1085

static enum ndr_err_code ndr_push_wkssvc_NetWkstaInfo1050(struct ndr_push *ndr, int ndr_flags, const struct wkssvc_NetWkstaInfo1050 *r)

1086

{

1087

if (ndr_flags & NDR_SCALARS) {

1088

NDR_CHECK(ndr_push_align(ndr, 4));

1089

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

1090

}

1091

if (ndr_flags & NDR_BUFFERS) {

1092

}

1093

return NDR_ERR_SUCCESS;

1094

}

1095

1096

static enum ndr_err_code ndr_pull_wkssvc_NetWkstaInfo1050(struct ndr_pull *ndr, int ndr_flags, struct wkssvc_NetWkstaInfo1050 *r)

1097

{

1098

if (ndr_flags & NDR_SCALARS) {

1099

NDR_CHECK(ndr_pull_align(ndr, 4));

1100

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

1101

}

1102

if (ndr_flags & NDR_BUFFERS) {

1103

}

1104

return NDR_ERR_SUCCESS;

1105

}

1106

1107

_PUBLIC_ void ndr_print_wkssvc_NetWkstaInfo1050(struct ndr_print *ndr, const char *name, const struct wkssvc_NetWkstaInfo1050 *r)

1108

{

1109

ndr_print_struct(ndr, name, "wkssvc_NetWkstaInfo1050");

1110

ndr->depth++;

1111

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

1112

ndr->depth--;

1113

}

1114

1115

static enum ndr_err_code ndr_push_wkssvc_NetWkstaInfo1051(struct ndr_push *ndr, int ndr_flags, const struct wkssvc_NetWkstaInfo1051 *r)

1116

{

1117

if (ndr_flags & NDR_SCALARS) {

1118

NDR_CHECK(ndr_push_align(ndr, 4));

1119

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

1120

}

1121

if (ndr_flags & NDR_BUFFERS) {

1122

}

1123

return NDR_ERR_SUCCESS;

1124

}

1125

1126

static enum ndr_err_code ndr_pull_wkssvc_NetWkstaInfo1051(struct ndr_pull *ndr, int ndr_flags, struct wkssvc_NetWkstaInfo1051 *r)

1127

{

1128

if (ndr_flags & NDR_SCALARS) {

1129

NDR_CHECK(ndr_pull_align(ndr, 4));

1130

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

1131

}

1132

if (ndr_flags & NDR_BUFFERS) {

1133

}

1134

return NDR_ERR_SUCCESS;

1135

}

1136

1137

_PUBLIC_ void ndr_print_wkssvc_NetWkstaInfo1051(struct ndr_print *ndr, const char *name, const struct wkssvc_NetWkstaInfo1051 *r)

1138

{

1139

ndr_print_struct(ndr, name, "wkssvc_NetWkstaInfo1051");

1140

ndr->depth++;

1141

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

1142

ndr->depth--;

1143

}

1144

1145

static enum ndr_err_code ndr_push_wkssvc_NetWkstaInfo1052(struct ndr_push *ndr, int ndr_flags, const struct wkssvc_NetWkstaInfo1052 *r)

1146

{

1147

if (ndr_flags & NDR_SCALARS) {

1148

NDR_CHECK(ndr_push_align(ndr, 4));

1149

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

1150

}

1151

if (ndr_flags & NDR_BUFFERS) {

1152

}

1153

return NDR_ERR_SUCCESS;

1154

}

1155

1156

static enum ndr_err_code ndr_pull_wkssvc_NetWkstaInfo1052(struct ndr_pull *ndr, int ndr_flags, struct wkssvc_NetWkstaInfo1052 *r)

1157

{

1158

if (ndr_flags & NDR_SCALARS) {

1159

NDR_CHECK(ndr_pull_align(ndr, 4));

1160

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

1161

}

1162

if (ndr_flags & NDR_BUFFERS) {

1163

}

1164

return NDR_ERR_SUCCESS;

1165

}

1166

1167

_PUBLIC_ void ndr_print_wkssvc_NetWkstaInfo1052(struct ndr_print *ndr, const char *name, const struct wkssvc_NetWkstaInfo1052 *r)

1168

{

1169

ndr_print_struct(ndr, name, "wkssvc_NetWkstaInfo1052");

1170

ndr->depth++;

1171

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

1172

ndr->depth--;

1173

}

1174

1175

static enum ndr_err_code ndr_push_wkssvc_NetWkstaInfo1053(struct ndr_push *ndr, int ndr_flags, const struct wkssvc_NetWkstaInfo1053 *r)

1176

{

1177

if (ndr_flags & NDR_SCALARS) {

1178

NDR_CHECK(ndr_push_align(ndr, 4));

1179

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

1180

}

1181

if (ndr_flags & NDR_BUFFERS) {

1182

}

1183

return NDR_ERR_SUCCESS;

1184

}

1185

1186

static enum ndr_err_code ndr_pull_wkssvc_NetWkstaInfo1053(struct ndr_pull *ndr, int ndr_flags, struct wkssvc_NetWkstaInfo1053 *r)

1187

{

1188

if (ndr_flags & NDR_SCALARS) {

1189

NDR_CHECK(ndr_pull_align(ndr, 4));

1190

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

1191

}

1192

if (ndr_flags & NDR_BUFFERS) {

1193

}

1194

return NDR_ERR_SUCCESS;

1195

}

1196

1197

_PUBLIC_ void ndr_print_wkssvc_NetWkstaInfo1053(struct ndr_print *ndr, const char *name, const struct wkssvc_NetWkstaInfo1053 *r)

1198

{

1199

ndr_print_struct(ndr, name, "wkssvc_NetWkstaInfo1053");

1200

ndr->depth++;

1201

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

1202

ndr->depth--;

1203

}

1204

1205

static enum ndr_err_code ndr_push_wkssvc_NetWkstaInfo1054(struct ndr_push *ndr, int ndr_flags, const struct wkssvc_NetWkstaInfo1054 *r)

1206

{

1207

if (ndr_flags & NDR_SCALARS) {

1208

NDR_CHECK(ndr_push_align(ndr, 4));

1209

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

1210

}

1211

if (ndr_flags & NDR_BUFFERS) {

1212

}

1213

return NDR_ERR_SUCCESS;

1214

}

1215

1216

static enum ndr_err_code ndr_pull_wkssvc_NetWkstaInfo1054(struct ndr_pull *ndr, int ndr_flags, struct wkssvc_NetWkstaInfo1054 *r)

1217

{

1218

if (ndr_flags & NDR_SCALARS) {

1219

NDR_CHECK(ndr_pull_align(ndr, 4));

1220

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

1221

}

1222

if (ndr_flags & NDR_BUFFERS) {

1223

}

1224

return NDR_ERR_SUCCESS;

1225

}

1226

1227

_PUBLIC_ void ndr_print_wkssvc_NetWkstaInfo1054(struct ndr_print *ndr, const char *name, const struct wkssvc_NetWkstaInfo1054 *r)

1228

{

1229

ndr_print_struct(ndr, name, "wkssvc_NetWkstaInfo1054");

1230

ndr->depth++;

1231

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

1232

ndr->depth--;

1233

}

1234

1235

static enum ndr_err_code ndr_push_wkssvc_NetWkstaInfo1055(struct ndr_push *ndr, int ndr_flags, const struct wkssvc_NetWkstaInfo1055 *r)

1236

{

1237

if (ndr_flags & NDR_SCALARS) {

1238

NDR_CHECK(ndr_push_align(ndr, 4));

1239

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

1240

}

1241

if (ndr_flags & NDR_BUFFERS) {

1242

}

1243

return NDR_ERR_SUCCESS;

1244

}

1245

1246

static enum ndr_err_code ndr_pull_wkssvc_NetWkstaInfo1055(struct ndr_pull *ndr, int ndr_flags, struct wkssvc_NetWkstaInfo1055 *r)

1247

{

1248

if (ndr_flags & NDR_SCALARS) {

1249

NDR_CHECK(ndr_pull_align(ndr, 4));

1250

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

1251

}

1252

if (ndr_flags & NDR_BUFFERS) {

1253

}

1254

return NDR_ERR_SUCCESS;

1255

}

1256

1257

_PUBLIC_ void ndr_print_wkssvc_NetWkstaInfo1055(struct ndr_print *ndr, const char *name, const struct wkssvc_NetWkstaInfo1055 *r)

1258

{

1259

ndr_print_struct(ndr, name, "wkssvc_NetWkstaInfo1055");

1260

ndr->depth++;

1261

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

1262

ndr->depth--;

1263

}

1264

1265

static enum ndr_err_code ndr_push_wkssvc_NetWkstaInfo1056(struct ndr_push *ndr, int ndr_flags, const struct wkssvc_NetWkstaInfo1056 *r)

1266

{

1267

if (ndr_flags & NDR_SCALARS) {

1268

NDR_CHECK(ndr_push_align(ndr, 4));

1269

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

1270

}

1271

if (ndr_flags & NDR_BUFFERS) {

1272

}

1273

return NDR_ERR_SUCCESS;

1274

}

1275

1276

static enum ndr_err_code ndr_pull_wkssvc_NetWkstaInfo1056(struct ndr_pull *ndr, int ndr_flags, struct wkssvc_NetWkstaInfo1056 *r)

1277

{

1278

if (ndr_flags & NDR_SCALARS) {

1279

NDR_CHECK(ndr_pull_align(ndr, 4));

1280

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

1281

}

1282

if (ndr_flags & NDR_BUFFERS) {

1283

}

1284

return NDR_ERR_SUCCESS;

1285

}

1286

1287

_PUBLIC_ void ndr_print_wkssvc_NetWkstaInfo1056(struct ndr_print *ndr, const char *name, const struct wkssvc_NetWkstaInfo1056 *r)

1288

{

1289

ndr_print_struct(ndr, name, "wkssvc_NetWkstaInfo1056");

1290

ndr->depth++;

1291

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

1292

ndr->depth--;

1293

}

1294

1295

static enum ndr_err_code ndr_push_wkssvc_NetWkstaInfo1057(struct ndr_push *ndr, int ndr_flags, const struct wkssvc_NetWkstaInfo1057 *r)

1296

{

1297

if (ndr_flags & NDR_SCALARS) {

1298

NDR_CHECK(ndr_push_align(ndr, 4));

1299

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

1300

}

1301

if (ndr_flags & NDR_BUFFERS) {

1302

}

1303

return NDR_ERR_SUCCESS;

1304

}

1305

1306

static enum ndr_err_code ndr_pull_wkssvc_NetWkstaInfo1057(struct ndr_pull *ndr, int ndr_flags, struct wkssvc_NetWkstaInfo1057 *r)

1307

{

1308

if (ndr_flags & NDR_SCALARS) {

1309

NDR_CHECK(ndr_pull_align(ndr, 4));

1310

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

1311

}

1312

if (ndr_flags & NDR_BUFFERS) {

1313

}

1314

return NDR_ERR_SUCCESS;

1315

}

1316

1317

_PUBLIC_ void ndr_print_wkssvc_NetWkstaInfo1057(struct ndr_print *ndr, const char *name, const struct wkssvc_NetWkstaInfo1057 *r)

1318

{

1319

ndr_print_struct(ndr, name, "wkssvc_NetWkstaInfo1057");

1320

ndr->depth++;

1321

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

1322

ndr->depth--;

1323

}

1324

1325

static enum ndr_err_code ndr_push_wkssvc_NetWkstaInfo1058(struct ndr_push *ndr, int ndr_flags, const struct wkssvc_NetWkstaInfo1058 *r)

1326

{

1327

if (ndr_flags & NDR_SCALARS) {

1328

NDR_CHECK(ndr_push_align(ndr, 4));

1329

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

1330

}

1331

if (ndr_flags & NDR_BUFFERS) {

1332

}

1333

return NDR_ERR_SUCCESS;

1334

}

1335

1336

static enum ndr_err_code ndr_pull_wkssvc_NetWkstaInfo1058(struct ndr_pull *ndr, int ndr_flags, struct wkssvc_NetWkstaInfo1058 *r)

1337

{

1338

if (ndr_flags & NDR_SCALARS) {

1339

NDR_CHECK(ndr_pull_align(ndr, 4));

1340

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

1341

}

1342

if (ndr_flags & NDR_BUFFERS) {

1343

}

1344

return NDR_ERR_SUCCESS;

1345

}

1346

1347

_PUBLIC_ void ndr_print_wkssvc_NetWkstaInfo1058(struct ndr_print *ndr, const char *name, const struct wkssvc_NetWkstaInfo1058 *r)

1348

{

1349

ndr_print_struct(ndr, name, "wkssvc_NetWkstaInfo1058");

1350

ndr->depth++;

1351

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

1352

ndr->depth--;

1353

}

1354

1355

static enum ndr_err_code ndr_push_wkssvc_NetWkstaInfo1059(struct ndr_push *ndr, int ndr_flags, const struct wkssvc_NetWkstaInfo1059 *r)

1356

{

1357

if (ndr_flags & NDR_SCALARS) {

1358

NDR_CHECK(ndr_push_align(ndr, 4));

1359

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

1360

}

1361

if (ndr_flags & NDR_BUFFERS) {

1362

}

1363

return NDR_ERR_SUCCESS;

1364

}

1365

1366

static enum ndr_err_code ndr_pull_wkssvc_NetWkstaInfo1059(struct ndr_pull *ndr, int ndr_flags, struct wkssvc_NetWkstaInfo1059 *r)

1367

{

1368

if (ndr_flags & NDR_SCALARS) {

1369

NDR_CHECK(ndr_pull_align(ndr, 4));

1370

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

1371

}

1372

if (ndr_flags & NDR_BUFFERS) {

1373

}

1374

return NDR_ERR_SUCCESS;

1375

}

1376

1377

_PUBLIC_ void ndr_print_wkssvc_NetWkstaInfo1059(struct ndr_print *ndr, const char *name, const struct wkssvc_NetWkstaInfo1059 *r)

1378

{

1379

ndr_print_struct(ndr, name, "wkssvc_NetWkstaInfo1059");

1380

ndr->depth++;

1381

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

1382

ndr->depth--;

1383

}

1384

1385

static enum ndr_err_code ndr_push_wkssvc_NetWkstaInfo1060(struct ndr_push *ndr, int ndr_flags, const struct wkssvc_NetWkstaInfo1060 *r)

1386

{

1387

if (ndr_flags & NDR_SCALARS) {

1388

NDR_CHECK(ndr_push_align(ndr, 4));

1389

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

1390

}

1391

if (ndr_flags & NDR_BUFFERS) {

1392

}

1393

return NDR_ERR_SUCCESS;

1394

}

1395

1396

static enum ndr_err_code ndr_pull_wkssvc_NetWkstaInfo1060(struct ndr_pull *ndr, int ndr_flags, struct wkssvc_NetWkstaInfo1060 *r)

1397

{

1398

if (ndr_flags & NDR_SCALARS) {

1399

NDR_CHECK(ndr_pull_align(ndr, 4));

1400

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

1401

}

1402

if (ndr_flags & NDR_BUFFERS) {

1403

}

1404

return NDR_ERR_SUCCESS;

1405

}

1406

1407

_PUBLIC_ void ndr_print_wkssvc_NetWkstaInfo1060(struct ndr_print *ndr, const char *name, const struct wkssvc_NetWkstaInfo1060 *r)

1408

{

1409

ndr_print_struct(ndr, name, "wkssvc_NetWkstaInfo1060");

1410

ndr->depth++;

1411

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

1412

ndr->depth--;

1413

}

1414

1415

static enum ndr_err_code ndr_push_wkssvc_NetWkstaInfo1061(struct ndr_push *ndr, int ndr_flags, const struct wkssvc_NetWkstaInfo1061 *r)

1416

{

1417

if (ndr_flags & NDR_SCALARS) {

1418

NDR_CHECK(ndr_push_align(ndr, 4));

1419

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

1420

}

1421

if (ndr_flags & NDR_BUFFERS) {

1422

}

1423

return NDR_ERR_SUCCESS;

1424

}

1425

1426

static enum ndr_err_code ndr_pull_wkssvc_NetWkstaInfo1061(struct ndr_pull *ndr, int ndr_flags, struct wkssvc_NetWkstaInfo1061 *r)

1427

{

1428

if (ndr_flags & NDR_SCALARS) {

1429

NDR_CHECK(ndr_pull_align(ndr, 4));

1430

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

1431

}

1432

if (ndr_flags & NDR_BUFFERS) {

1433

}

1434

return NDR_ERR_SUCCESS;

1435

}

1436

1437

_PUBLIC_ void ndr_print_wkssvc_NetWkstaInfo1061(struct ndr_print *ndr, const char *name, const struct wkssvc_NetWkstaInfo1061 *r)

1438

{

1439

ndr_print_struct(ndr, name, "wkssvc_NetWkstaInfo1061");

1440

ndr->depth++;

1441

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

1442

ndr->depth--;

1443

}

1444

1445

static enum ndr_err_code ndr_push_wkssvc_NetWkstaInfo1062(struct ndr_push *ndr, int ndr_flags, const struct wkssvc_NetWkstaInfo1062 *r)

1446

{

1447

if (ndr_flags & NDR_SCALARS) {

1448

NDR_CHECK(ndr_push_align(ndr, 4));

1449

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

1450

}

1451

if (ndr_flags & NDR_BUFFERS) {

1452

}

1453

return NDR_ERR_SUCCESS;

1454

}

1455

1456

static enum ndr_err_code ndr_pull_wkssvc_NetWkstaInfo1062(struct ndr_pull *ndr, int ndr_flags, struct wkssvc_NetWkstaInfo1062 *r)

1457

{

1458

if (ndr_flags & NDR_SCALARS) {

1459

NDR_CHECK(ndr_pull_align(ndr, 4));

1460

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

1461

}

1462

if (ndr_flags & NDR_BUFFERS) {

1463

}

1464

return NDR_ERR_SUCCESS;

1465

}

1466

1467

_PUBLIC_ void ndr_print_wkssvc_NetWkstaInfo1062(struct ndr_print *ndr, const char *name, const struct wkssvc_NetWkstaInfo1062 *r)

1468

{

1469

ndr_print_struct(ndr, name, "wkssvc_NetWkstaInfo1062");

1470

ndr->depth++;

1471

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

1472

ndr->depth--;

1473

}

1474

1475

static enum ndr_err_code ndr_push_wkssvc_NetWkstaInfo(struct ndr_push *ndr, int ndr_flags, const union wkssvc_NetWkstaInfo *r)

1476

{

1477

if (ndr_flags & NDR_SCALARS) {

1478

int level = ndr_push_get_switch_value(ndr, r);

1479

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

1480

switch (level) {

1481

case 100: {

1482

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

1483

break; }

1484

1485

case 101: {

1486

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

1487

break; }

1488

1489

case 102: {

1490

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

1491

break; }

1492

1493

case 502: {

1494

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

1495

break; }

1496

1497

case 1010: {

1498

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

1499

break; }

1500

1501

case 1011: {

1502

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

1503

break; }

1504

1505

case 1012: {

1506

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

1507

break; }

1508

1509

case 1013: {

1510

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

1511

break; }

1512

1513

case 1018: {

1514

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

1515

break; }

1516

1517

case 1023: {

1518

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

1519

break; }

1520

1521

case 1027: {

1522

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

1523

break; }

1524

1525

case 1028: {

1526

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

1527

break; }

1528

1529

case 1032: {

1530

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

1531

break; }

1532

1533

case 1033: {

1534

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

1535

break; }

1536

1537

case 1041: {

1538

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

1539

break; }

1540

1541

case 1042: {

1542

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

1543

break; }

1544

1545

case 1043: {

1546

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

1547

break; }

1548

1549

case 1044: {

1550

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

1551

break; }

1552

1553

case 1045: {

1554

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

1555

break; }

1556

1557

case 1046: {

1558

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

1559

break; }

1560

1561

case 1047: {

1562

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

1563

break; }

1564

1565

case 1048: {

1566

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

1567

break; }

1568

1569

case 1049: {

1570

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

1571

break; }

1572

1573

case 1050: {

1574

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

1575

break; }

1576

1577

case 1051: {

1578

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

1579

break; }

1580

1581

case 1052: {

1582

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

1583

break; }

1584

1585

case 1053: {

1586

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

1587

break; }

1588

1589

case 1054: {

1590

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

1591

break; }

1592

1593

case 1055: {

1594

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

1595

break; }

1596

1597

case 1056: {

1598

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

1599

break; }

1600

1601

case 1057: {

1602

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

1603

break; }

1604

1605

case 1058: {

1606

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

1607

break; }

1608

1609

case 1059: {

1610

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

1611

break; }

1612

1613

case 1060: {

1614

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

1615

break; }

1616

1617

case 1061: {

1618

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

1619

break; }

1620

1621

case 1062: {

1622

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

1623

break; }

1624

1625

default: {

1626

break; }

1627

1628

}

1629

}

1630

if (ndr_flags & NDR_BUFFERS) {

1631

int level = ndr_push_get_switch_value(ndr, r);

1632

switch (level) {

1633

case 100:

1634

if (r->info100) {

1635

NDR_CHECK(ndr_push_wkssvc_NetWkstaInfo100(ndr, NDR_SCALARS|NDR_BUFFERS, r->info100));

1636

}

1637

break;

1638

1639

case 101:

1640

if (r->info101) {

1641

NDR_CHECK(ndr_push_wkssvc_NetWkstaInfo101(ndr, NDR_SCALARS|NDR_BUFFERS, r->info101));

1642

}

1643

break;

1644

1645

case 102:

1646

if (r->info102) {

1647

NDR_CHECK(ndr_push_wkssvc_NetWkstaInfo102(ndr, NDR_SCALARS|NDR_BUFFERS, r->info102));

1648

}

1649

break;

1650

1651

case 502:

1652

if (r->info502) {

1653

NDR_CHECK(ndr_push_wkssvc_NetWkstaInfo502(ndr, NDR_SCALARS, r->info502));

1654

}

1655

break;

1656

1657

case 1010:

1658

if (r->info1010) {

1659

NDR_CHECK(ndr_push_wkssvc_NetWkstaInfo1010(ndr, NDR_SCALARS, r->info1010));

1660

}

1661

break;

1662

1663

case 1011:

1664

if (r->info1011) {

1665

NDR_CHECK(ndr_push_wkssvc_NetWkstaInfo1011(ndr, NDR_SCALARS, r->info1011));

1666

}

1667

break;

1668

1669

case 1012:

1670

if (r->info1012) {

1671

NDR_CHECK(ndr_push_wkssvc_NetWkstaInfo1012(ndr, NDR_SCALARS, r->info1012));

1672

}

1673

break;

1674

1675

case 1013:

1676

if (r->info1013) {

1677

NDR_CHECK(ndr_push_wkssvc_NetWkstaInfo1013(ndr, NDR_SCALARS, r->info1013));

1678

}

1679

break;

1680

1681

case 1018:

1682

if (r->info1018) {

1683

NDR_CHECK(ndr_push_wkssvc_NetWkstaInfo1018(ndr, NDR_SCALARS, r->info1018));

1684

}

1685

break;

1686

1687

case 1023:

1688

if (r->info1023) {

1689

NDR_CHECK(ndr_push_wkssvc_NetWkstaInfo1023(ndr, NDR_SCALARS, r->info1023));

1690

}

1691

break;

1692

1693

case 1027:

1694

if (r->info1027) {

1695

NDR_CHECK(ndr_push_wkssvc_NetWkstaInfo1027(ndr, NDR_SCALARS, r->info1027));

1696

}

1697

break;

1698

1699

case 1028:

1700

if (r->info1028) {

1701

NDR_CHECK(ndr_push_wkssvc_NetWkstaInfo1028(ndr, NDR_SCALARS, r->info1028));

1702

}

1703

break;

1704

1705

case 1032:

1706

if (r->info1032) {

1707

NDR_CHECK(ndr_push_wkssvc_NetWkstaInfo1032(ndr, NDR_SCALARS, r->info1032));

1708

}

1709

break;

1710

1711

case 1033:

1712

if (r->info1033) {

1713

NDR_CHECK(ndr_push_wkssvc_NetWkstaInfo1033(ndr, NDR_SCALARS, r->info1033));

1714

}

1715

break;

1716

1717

case 1041:

1718

if (r->info1041) {

1719

NDR_CHECK(ndr_push_wkssvc_NetWkstaInfo1041(ndr, NDR_SCALARS, r->info1041));

1720

}

1721

break;

1722

1723

case 1042:

1724

if (r->info1042) {

1725

NDR_CHECK(ndr_push_wkssvc_NetWkstaInfo1042(ndr, NDR_SCALARS, r->info1042));

1726

}

1727

break;

1728

1729

case 1043:

1730

if (r->info1043) {

1731

NDR_CHECK(ndr_push_wkssvc_NetWkstaInfo1043(ndr, NDR_SCALARS, r->info1043));

1732

}

1733

break;

1734

1735

case 1044:

1736

if (r->info1044) {

1737

NDR_CHECK(ndr_push_wkssvc_NetWkstaInfo1044(ndr, NDR_SCALARS, r->info1044));

1738

}

1739

break;

1740

1741

case 1045:

1742

if (r->info1045) {

1743

NDR_CHECK(ndr_push_wkssvc_NetWkstaInfo1045(ndr, NDR_SCALARS, r->info1045));

1744

}

1745

break;

1746

1747

case 1046:

1748

if (r->info1046) {

1749

NDR_CHECK(ndr_push_wkssvc_NetWkstaInfo1046(ndr, NDR_SCALARS, r->info1046));

1750

}

1751

break;

1752

1753

case 1047:

1754

if (r->info1047) {

1755

NDR_CHECK(ndr_push_wkssvc_NetWkstaInfo1047(ndr, NDR_SCALARS, r->info1047));

1756

}

1757

break;

1758

1759

case 1048:

1760

if (r->info1048) {

1761

NDR_CHECK(ndr_push_wkssvc_NetWkstaInfo1048(ndr, NDR_SCALARS, r->info1048));

1762

}

1763

break;

1764

1765

case 1049:

1766

if (r->info1049) {

1767

NDR_CHECK(ndr_push_wkssvc_NetWkstaInfo1049(ndr, NDR_SCALARS, r->info1049));

1768

}

1769

break;

1770

1771

case 1050:

1772

if (r->info1050) {

1773

NDR_CHECK(ndr_push_wkssvc_NetWkstaInfo1050(ndr, NDR_SCALARS, r->info1050));

1774

}

1775

break;

1776

1777

case 1051:

1778

if (r->info1051) {

1779

NDR_CHECK(ndr_push_wkssvc_NetWkstaInfo1051(ndr, NDR_SCALARS, r->info1051));

1780

}

1781

break;

1782

1783

case 1052:

1784

if (r->info1052) {

1785

NDR_CHECK(ndr_push_wkssvc_NetWkstaInfo1052(ndr, NDR_SCALARS, r->info1052));

1786

}

1787

break;

1788

1789

case 1053:

1790

if (r->info1053) {

1791

NDR_CHECK(ndr_push_wkssvc_NetWkstaInfo1053(ndr, NDR_SCALARS, r->info1053));

1792

}

1793

break;

1794

1795

case 1054:

1796

if (r->info1054) {

1797

NDR_CHECK(ndr_push_wkssvc_NetWkstaInfo1054(ndr, NDR_SCALARS, r->info1054));

1798

}

1799

break;

1800

1801

case 1055:

1802

if (r->info1055) {

1803

NDR_CHECK(ndr_push_wkssvc_NetWkstaInfo1055(ndr, NDR_SCALARS, r->info1055));

1804

}

1805

break;

1806

1807

case 1056:

1808

if (r->info1056) {

1809

NDR_CHECK(ndr_push_wkssvc_NetWkstaInfo1056(ndr, NDR_SCALARS, r->info1056));

1810

}

1811

break;

1812

1813

case 1057:

1814

if (r->info1057) {

1815

NDR_CHECK(ndr_push_wkssvc_NetWkstaInfo1057(ndr, NDR_SCALARS, r->info1057));

1816

}

1817

break;

1818

1819

case 1058:

1820

if (r->info1058) {

1821

NDR_CHECK(ndr_push_wkssvc_NetWkstaInfo1058(ndr, NDR_SCALARS, r->info1058));

1822

}

1823

break;

1824

1825

case 1059:

1826

if (r->info1059) {

1827

NDR_CHECK(ndr_push_wkssvc_NetWkstaInfo1059(ndr, NDR_SCALARS, r->info1059));

1828

}

1829

break;

1830

1831

case 1060:

1832

if (r->info1060) {

1833

NDR_CHECK(ndr_push_wkssvc_NetWkstaInfo1060(ndr, NDR_SCALARS, r->info1060));

1834

}

1835

break;

1836

1837

case 1061:

1838

if (r->info1061) {

1839

NDR_CHECK(ndr_push_wkssvc_NetWkstaInfo1061(ndr, NDR_SCALARS, r->info1061));

1840

}

1841

break;

1842

1843

case 1062:

1844

if (r->info1062) {

1845

NDR_CHECK(ndr_push_wkssvc_NetWkstaInfo1062(ndr, NDR_SCALARS, r->info1062));

1846

}

1847

break;

1848

1849

default:

1850

break;

1851

1852

}

1853

}

1854

return NDR_ERR_SUCCESS;

1855

}

1856

1857

static enum ndr_err_code ndr_pull_wkssvc_NetWkstaInfo(struct ndr_pull *ndr, int ndr_flags, union wkssvc_NetWkstaInfo *r)

1858

{

1859

int level;

1860

uint32_t _level;

1861

TALLOC_CTX *_mem_save_info100_0;

1862

TALLOC_CTX *_mem_save_info101_0;

1863

TALLOC_CTX *_mem_save_info102_0;

1864

TALLOC_CTX *_mem_save_info502_0;

1865

TALLOC_CTX *_mem_save_info1010_0;

1866

TALLOC_CTX *_mem_save_info1011_0;

1867

TALLOC_CTX *_mem_save_info1012_0;

1868

TALLOC_CTX *_mem_save_info1013_0;

1869

TALLOC_CTX *_mem_save_info1018_0;

1870

TALLOC_CTX *_mem_save_info1023_0;

1871

TALLOC_CTX *_mem_save_info1027_0;

1872

TALLOC_CTX *_mem_save_info1028_0;

1873

TALLOC_CTX *_mem_save_info1032_0;

1874

TALLOC_CTX *_mem_save_info1033_0;

1875

TALLOC_CTX *_mem_save_info1041_0;

1876

TALLOC_CTX *_mem_save_info1042_0;

1877

TALLOC_CTX *_mem_save_info1043_0;

1878

TALLOC_CTX *_mem_save_info1044_0;

1879

TALLOC_CTX *_mem_save_info1045_0;

1880

TALLOC_CTX *_mem_save_info1046_0;

1881

TALLOC_CTX *_mem_save_info1047_0;

1882

TALLOC_CTX *_mem_save_info1048_0;

1883

TALLOC_CTX *_mem_save_info1049_0;

1884

TALLOC_CTX *_mem_save_info1050_0;

1885

TALLOC_CTX *_mem_save_info1051_0;

1886

TALLOC_CTX *_mem_save_info1052_0;

1887

TALLOC_CTX *_mem_save_info1053_0;

1888

TALLOC_CTX *_mem_save_info1054_0;

1889

TALLOC_CTX *_mem_save_info1055_0;

1890

TALLOC_CTX *_mem_save_info1056_0;

1891

TALLOC_CTX *_mem_save_info1057_0;

1892

TALLOC_CTX *_mem_save_info1058_0;

1893

TALLOC_CTX *_mem_save_info1059_0;

1894

TALLOC_CTX *_mem_save_info1060_0;

1895

TALLOC_CTX *_mem_save_info1061_0;

1896

TALLOC_CTX *_mem_save_info1062_0;

1897

level = ndr_pull_get_switch_value(ndr, r);

1898

if (ndr_flags & NDR_SCALARS) {

1899

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

1900

if (_level != level) {

1901

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

1902

}

1903

switch (level) {

1904

case 100: {

1905

uint32_t _ptr_info100;

1906

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info100));

1907

if (_ptr_info100) {

1908

NDR_PULL_ALLOC(ndr, r->info100);

1909

} else {

1910

r->info100 = NULL;

1911

}

1912

break; }

1913

1914

case 101: {

1915

uint32_t _ptr_info101;

1916

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info101));

1917

if (_ptr_info101) {

1918

NDR_PULL_ALLOC(ndr, r->info101);

1919

} else {

1920

r->info101 = NULL;

1921

}

1922

break; }

1923

1924

case 102: {

1925

uint32_t _ptr_info102;

1926

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info102));

1927

if (_ptr_info102) {

1928

NDR_PULL_ALLOC(ndr, r->info102);

1929

} else {

1930

r->info102 = NULL;

1931

}

1932

break; }

1933

1934

case 502: {

1935

uint32_t _ptr_info502;

1936

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info502));

1937

if (_ptr_info502) {

1938

NDR_PULL_ALLOC(ndr, r->info502);

1939

} else {

1940

r->info502 = NULL;

1941

}

1942

break; }

1943

1944

case 1010: {

1945

uint32_t _ptr_info1010;

1946

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1010));

1947

if (_ptr_info1010) {

1948

NDR_PULL_ALLOC(ndr, r->info1010);

1949

} else {

1950

r->info1010 = NULL;

1951

}

1952

break; }

1953

1954

case 1011: {

1955

uint32_t _ptr_info1011;

1956

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1011));

1957

if (_ptr_info1011) {

1958

NDR_PULL_ALLOC(ndr, r->info1011);

1959

} else {

1960

r->info1011 = NULL;

1961

}

1962

break; }

1963

1964

case 1012: {

1965

uint32_t _ptr_info1012;

1966

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1012));

1967

if (_ptr_info1012) {

1968

NDR_PULL_ALLOC(ndr, r->info1012);

1969

} else {

1970

r->info1012 = NULL;

1971

}

1972

break; }

1973

1974

case 1013: {

1975

uint32_t _ptr_info1013;

1976

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1013));

1977

if (_ptr_info1013) {

1978

NDR_PULL_ALLOC(ndr, r->info1013);

1979

} else {

1980

r->info1013 = NULL;

1981

}

1982

break; }

1983

1984

case 1018: {

1985

uint32_t _ptr_info1018;

1986

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1018));

1987

if (_ptr_info1018) {

1988

NDR_PULL_ALLOC(ndr, r->info1018);

1989

} else {

1990

r->info1018 = NULL;

1991

}

1992

break; }

1993

1994

case 1023: {

1995

uint32_t _ptr_info1023;

1996

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1023));

1997

if (_ptr_info1023) {

1998

NDR_PULL_ALLOC(ndr, r->info1023);

1999

} else {

2000

r->info1023 = NULL;

2001

}

2002

break; }

2003

2004

case 1027: {

2005

uint32_t _ptr_info1027;

2006

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1027));

2007

if (_ptr_info1027) {

2008

NDR_PULL_ALLOC(ndr, r->info1027);

2009

} else {

2010

r->info1027 = NULL;

2011

}

2012

break; }

2013

2014

case 1028: {

2015

uint32_t _ptr_info1028;

2016

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1028));

2017

if (_ptr_info1028) {

2018

NDR_PULL_ALLOC(ndr, r->info1028);

2019

} else {

2020

r->info1028 = NULL;

2021

}

2022

break; }

2023

2024

case 1032: {

2025

uint32_t _ptr_info1032;

2026

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1032));

2027

if (_ptr_info1032) {

2028

NDR_PULL_ALLOC(ndr, r->info1032);

2029

} else {

2030

r->info1032 = NULL;

2031

}

2032

break; }

2033

2034

case 1033: {

2035

uint32_t _ptr_info1033;

2036

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1033));

2037

if (_ptr_info1033) {

2038

NDR_PULL_ALLOC(ndr, r->info1033);

2039

} else {

2040

r->info1033 = NULL;

2041

}

2042

break; }

2043

2044

case 1041: {

2045

uint32_t _ptr_info1041;

2046

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1041));

2047

if (_ptr_info1041) {

2048

NDR_PULL_ALLOC(ndr, r->info1041);

2049

} else {

2050

r->info1041 = NULL;

2051

}

2052

break; }

2053

2054

case 1042: {

2055

uint32_t _ptr_info1042;

2056

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1042));

2057

if (_ptr_info1042) {

2058

NDR_PULL_ALLOC(ndr, r->info1042);

2059

} else {

2060

r->info1042 = NULL;

2061

}

2062

break; }

2063

2064

case 1043: {

2065

uint32_t _ptr_info1043;

2066

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1043));

2067

if (_ptr_info1043) {

2068

NDR_PULL_ALLOC(ndr, r->info1043);

2069

} else {

2070

r->info1043 = NULL;

2071

}

2072

break; }

2073

2074

case 1044: {

2075

uint32_t _ptr_info1044;

2076

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1044));

2077

if (_ptr_info1044) {

2078

NDR_PULL_ALLOC(ndr, r->info1044);

2079

} else {

2080

r->info1044 = NULL;

2081

}

2082

break; }

2083

2084

case 1045: {

2085

uint32_t _ptr_info1045;

2086

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1045));

2087

if (_ptr_info1045) {

2088

NDR_PULL_ALLOC(ndr, r->info1045);

2089

} else {

2090

r->info1045 = NULL;

2091

}

2092

break; }

2093

2094

case 1046: {

2095

uint32_t _ptr_info1046;

2096

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1046));

2097

if (_ptr_info1046) {

2098

NDR_PULL_ALLOC(ndr, r->info1046);

2099

} else {

2100

r->info1046 = NULL;

2101

}

2102

break; }

2103

2104

case 1047: {

2105

uint32_t _ptr_info1047;

2106

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1047));

2107

if (_ptr_info1047) {

2108

NDR_PULL_ALLOC(ndr, r->info1047);

2109

} else {

2110

r->info1047 = NULL;

2111

}

2112

break; }

2113

2114

case 1048: {

2115

uint32_t _ptr_info1048;

2116

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1048));

2117

if (_ptr_info1048) {

2118

NDR_PULL_ALLOC(ndr, r->info1048);

2119

} else {

2120

r->info1048 = NULL;

2121

}

2122

break; }

2123

2124

case 1049: {

2125

uint32_t _ptr_info1049;

2126

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1049));

2127

if (_ptr_info1049) {

2128

NDR_PULL_ALLOC(ndr, r->info1049);

2129

} else {

2130

r->info1049 = NULL;

2131

}

2132

break; }

2133

2134

case 1050: {

2135

uint32_t _ptr_info1050;

2136

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1050));

2137

if (_ptr_info1050) {

2138

NDR_PULL_ALLOC(ndr, r->info1050);

2139

} else {

2140

r->info1050 = NULL;

2141

}

2142

break; }

2143

2144

case 1051: {

2145

uint32_t _ptr_info1051;

2146

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1051));

2147

if (_ptr_info1051) {

2148

NDR_PULL_ALLOC(ndr, r->info1051);

2149

} else {

2150

r->info1051 = NULL;

2151

}

2152

break; }

2153

2154

case 1052: {

2155

uint32_t _ptr_info1052;

2156

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1052));

2157

if (_ptr_info1052) {

2158

NDR_PULL_ALLOC(ndr, r->info1052);

2159

} else {

2160

r->info1052 = NULL;

2161

}

2162

break; }

2163

2164

case 1053: {

2165

uint32_t _ptr_info1053;

2166

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1053));

2167

if (_ptr_info1053) {

2168

NDR_PULL_ALLOC(ndr, r->info1053);

2169

} else {

2170

r->info1053 = NULL;

2171

}

2172

break; }

2173

2174

case 1054: {

2175

uint32_t _ptr_info1054;

2176

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1054));

2177

if (_ptr_info1054) {

2178

NDR_PULL_ALLOC(ndr, r->info1054);

2179

} else {

2180

r->info1054 = NULL;

2181

}

2182

break; }

2183

2184

case 1055: {

2185

uint32_t _ptr_info1055;

2186

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1055));

2187

if (_ptr_info1055) {

2188

NDR_PULL_ALLOC(ndr, r->info1055);

2189

} else {

2190

r->info1055 = NULL;

2191

}

2192

break; }

2193

2194

case 1056: {

2195

uint32_t _ptr_info1056;

2196

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1056));

2197

if (_ptr_info1056) {

2198

NDR_PULL_ALLOC(ndr, r->info1056);

2199

} else {

2200

r->info1056 = NULL;

2201

}

2202

break; }

2203

2204

case 1057: {

2205

uint32_t _ptr_info1057;

2206

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1057));

2207

if (_ptr_info1057) {

2208

NDR_PULL_ALLOC(ndr, r->info1057);

2209

} else {

2210

r->info1057 = NULL;

2211

}

2212

break; }

2213

2214

case 1058: {

2215

uint32_t _ptr_info1058;

2216

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1058));

2217

if (_ptr_info1058) {

2218

NDR_PULL_ALLOC(ndr, r->info1058);

2219

} else {

2220

r->info1058 = NULL;

2221

}

2222

break; }

2223

2224

case 1059: {

2225

uint32_t _ptr_info1059;

2226

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1059));

2227

if (_ptr_info1059) {

2228

NDR_PULL_ALLOC(ndr, r->info1059);

2229

} else {

2230

r->info1059 = NULL;

2231

}

2232

break; }

2233

2234

case 1060: {

2235

uint32_t _ptr_info1060;

2236

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1060));

2237

if (_ptr_info1060) {

2238

NDR_PULL_ALLOC(ndr, r->info1060);

2239

} else {

2240

r->info1060 = NULL;

2241

}

2242

break; }

2243

2244

case 1061: {

2245

uint32_t _ptr_info1061;

2246

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1061));

2247

if (_ptr_info1061) {

2248

NDR_PULL_ALLOC(ndr, r->info1061);

2249

} else {

2250

r->info1061 = NULL;

2251

}

2252

break; }

2253

2254

case 1062: {

2255

uint32_t _ptr_info1062;

2256

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1062));

2257

if (_ptr_info1062) {

2258

NDR_PULL_ALLOC(ndr, r->info1062);

2259

} else {

2260

r->info1062 = NULL;

2261

}

2262

break; }

2263

2264

default: {

2265

break; }

2266

2267

}

2268

}

2269

if (ndr_flags & NDR_BUFFERS) {

2270

switch (level) {

2271

case 100:

2272

if (r->info100) {

2273

_mem_save_info100_0 = NDR_PULL_GET_MEM_CTX(ndr);

2274

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

2275

NDR_CHECK(ndr_pull_wkssvc_NetWkstaInfo100(ndr, NDR_SCALARS|NDR_BUFFERS, r->info100));

2276

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info100_0, 0);

2277

}

2278

break;

2279

2280

case 101:

2281

if (r->info101) {

2282

_mem_save_info101_0 = NDR_PULL_GET_MEM_CTX(ndr);

2283

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

2284

NDR_CHECK(ndr_pull_wkssvc_NetWkstaInfo101(ndr, NDR_SCALARS|NDR_BUFFERS, r->info101));

2285

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info101_0, 0);

2286

}

2287

break;

2288

2289

case 102:

2290

if (r->info102) {

2291

_mem_save_info102_0 = NDR_PULL_GET_MEM_CTX(ndr);

2292

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

2293

NDR_CHECK(ndr_pull_wkssvc_NetWkstaInfo102(ndr, NDR_SCALARS|NDR_BUFFERS, r->info102));

2294

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info102_0, 0);

2295

}

2296

break;

2297

2298

case 502:

2299

if (r->info502) {

2300

_mem_save_info502_0 = NDR_PULL_GET_MEM_CTX(ndr);

2301

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

2302

NDR_CHECK(ndr_pull_wkssvc_NetWkstaInfo502(ndr, NDR_SCALARS, r->info502));

2303

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info502_0, 0);

2304

}

2305

break;

2306

2307

case 1010:

2308

if (r->info1010) {

2309

_mem_save_info1010_0 = NDR_PULL_GET_MEM_CTX(ndr);

2310

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

2311

NDR_CHECK(ndr_pull_wkssvc_NetWkstaInfo1010(ndr, NDR_SCALARS, r->info1010));

2312

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1010_0, 0);

2313

}

2314

break;

2315

2316

case 1011:

2317

if (r->info1011) {

2318

_mem_save_info1011_0 = NDR_PULL_GET_MEM_CTX(ndr);

2319

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

2320

NDR_CHECK(ndr_pull_wkssvc_NetWkstaInfo1011(ndr, NDR_SCALARS, r->info1011));

2321

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1011_0, 0);

2322

}

2323

break;

2324

2325

case 1012:

2326

if (r->info1012) {

2327

_mem_save_info1012_0 = NDR_PULL_GET_MEM_CTX(ndr);

2328

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

2329

NDR_CHECK(ndr_pull_wkssvc_NetWkstaInfo1012(ndr, NDR_SCALARS, r->info1012));

2330

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1012_0, 0);

2331

}

2332

break;

2333

2334

case 1013:

2335

if (r->info1013) {

2336

_mem_save_info1013_0 = NDR_PULL_GET_MEM_CTX(ndr);

2337

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

2338

NDR_CHECK(ndr_pull_wkssvc_NetWkstaInfo1013(ndr, NDR_SCALARS, r->info1013));

2339

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1013_0, 0);

2340

}

2341

break;

2342

2343

case 1018:

2344

if (r->info1018) {

2345

_mem_save_info1018_0 = NDR_PULL_GET_MEM_CTX(ndr);

2346

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

2347

NDR_CHECK(ndr_pull_wkssvc_NetWkstaInfo1018(ndr, NDR_SCALARS, r->info1018));

2348

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1018_0, 0);

2349

}

2350

break;

2351

2352

case 1023:

2353

if (r->info1023) {

2354

_mem_save_info1023_0 = NDR_PULL_GET_MEM_CTX(ndr);

2355

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

2356

NDR_CHECK(ndr_pull_wkssvc_NetWkstaInfo1023(ndr, NDR_SCALARS, r->info1023));

2357

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1023_0, 0);

2358

}

2359

break;

2360

2361

case 1027:

2362

if (r->info1027) {

2363

_mem_save_info1027_0 = NDR_PULL_GET_MEM_CTX(ndr);

2364

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

2365

NDR_CHECK(ndr_pull_wkssvc_NetWkstaInfo1027(ndr, NDR_SCALARS, r->info1027));

2366

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1027_0, 0);

2367

}

2368

break;

2369

2370

case 1028:

2371

if (r->info1028) {

2372

_mem_save_info1028_0 = NDR_PULL_GET_MEM_CTX(ndr);

2373

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

2374

NDR_CHECK(ndr_pull_wkssvc_NetWkstaInfo1028(ndr, NDR_SCALARS, r->info1028));

2375

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1028_0, 0);

2376

}

2377

break;

2378

2379

case 1032:

2380

if (r->info1032) {

2381

_mem_save_info1032_0 = NDR_PULL_GET_MEM_CTX(ndr);

2382

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

2383

NDR_CHECK(ndr_pull_wkssvc_NetWkstaInfo1032(ndr, NDR_SCALARS, r->info1032));

2384

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1032_0, 0);

2385

}

2386

break;

2387

2388

case 1033:

2389

if (r->info1033) {

2390

_mem_save_info1033_0 = NDR_PULL_GET_MEM_CTX(ndr);

2391

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

2392

NDR_CHECK(ndr_pull_wkssvc_NetWkstaInfo1033(ndr, NDR_SCALARS, r->info1033));

2393

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1033_0, 0);

2394

}

2395

break;

2396

2397

case 1041:

2398

if (r->info1041) {

2399

_mem_save_info1041_0 = NDR_PULL_GET_MEM_CTX(ndr);

2400

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

2401

NDR_CHECK(ndr_pull_wkssvc_NetWkstaInfo1041(ndr, NDR_SCALARS, r->info1041));

2402

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1041_0, 0);

2403

}

2404

break;

2405

2406

case 1042:

2407

if (r->info1042) {

2408

_mem_save_info1042_0 = NDR_PULL_GET_MEM_CTX(ndr);

2409

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

2410

NDR_CHECK(ndr_pull_wkssvc_NetWkstaInfo1042(ndr, NDR_SCALARS, r->info1042));

2411

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1042_0, 0);

2412

}

2413

break;

2414

2415

case 1043:

2416

if (r->info1043) {

2417

_mem_save_info1043_0 = NDR_PULL_GET_MEM_CTX(ndr);

2418

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

2419

NDR_CHECK(ndr_pull_wkssvc_NetWkstaInfo1043(ndr, NDR_SCALARS, r->info1043));

2420

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1043_0, 0);

2421

}

2422

break;

2423

2424

case 1044:

2425

if (r->info1044) {

2426

_mem_save_info1044_0 = NDR_PULL_GET_MEM_CTX(ndr);

2427

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

2428

NDR_CHECK(ndr_pull_wkssvc_NetWkstaInfo1044(ndr, NDR_SCALARS, r->info1044));

2429

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1044_0, 0);

2430

}

2431

break;

2432

2433

case 1045:

2434

if (r->info1045) {

2435

_mem_save_info1045_0 = NDR_PULL_GET_MEM_CTX(ndr);

2436

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

2437

NDR_CHECK(ndr_pull_wkssvc_NetWkstaInfo1045(ndr, NDR_SCALARS, r->info1045));

2438

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1045_0, 0);

2439

}

2440

break;

2441

2442

case 1046:

2443

if (r->info1046) {

2444

_mem_save_info1046_0 = NDR_PULL_GET_MEM_CTX(ndr);

2445

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

2446

NDR_CHECK(ndr_pull_wkssvc_NetWkstaInfo1046(ndr, NDR_SCALARS, r->info1046));

2447

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1046_0, 0);

2448

}

2449

break;

2450

2451

case 1047:

2452

if (r->info1047) {

2453

_mem_save_info1047_0 = NDR_PULL_GET_MEM_CTX(ndr);

2454

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

2455

NDR_CHECK(ndr_pull_wkssvc_NetWkstaInfo1047(ndr, NDR_SCALARS, r->info1047));

2456

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1047_0, 0);

2457

}

2458

break;

2459

2460

case 1048:

2461

if (r->info1048) {

2462

_mem_save_info1048_0 = NDR_PULL_GET_MEM_CTX(ndr);

2463

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

2464

NDR_CHECK(ndr_pull_wkssvc_NetWkstaInfo1048(ndr, NDR_SCALARS, r->info1048));

2465

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1048_0, 0);

2466

}

2467

break;

2468

2469

case 1049:

2470

if (r->info1049) {

2471

_mem_save_info1049_0 = NDR_PULL_GET_MEM_CTX(ndr);

2472

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

2473

NDR_CHECK(ndr_pull_wkssvc_NetWkstaInfo1049(ndr, NDR_SCALARS, r->info1049));

2474

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1049_0, 0);

2475

}

2476

break;

2477

2478

case 1050:

2479

if (r->info1050) {

2480

_mem_save_info1050_0 = NDR_PULL_GET_MEM_CTX(ndr);

2481

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

2482

NDR_CHECK(ndr_pull_wkssvc_NetWkstaInfo1050(ndr, NDR_SCALARS, r->info1050));

2483

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1050_0, 0);

2484

}

2485

break;

2486

2487

case 1051:

2488

if (r->info1051) {

2489

_mem_save_info1051_0 = NDR_PULL_GET_MEM_CTX(ndr);

2490

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

2491

NDR_CHECK(ndr_pull_wkssvc_NetWkstaInfo1051(ndr, NDR_SCALARS, r->info1051));

2492

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1051_0, 0);

2493

}

2494

break;

2495

2496

case 1052:

2497

if (r->info1052) {

2498

_mem_save_info1052_0 = NDR_PULL_GET_MEM_CTX(ndr);

2499

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

2500

NDR_CHECK(ndr_pull_wkssvc_NetWkstaInfo1052(ndr, NDR_SCALARS, r->info1052));

2501

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1052_0, 0);

2502

}

2503

break;

2504

2505

case 1053:

2506

if (r->info1053) {

2507

_mem_save_info1053_0 = NDR_PULL_GET_MEM_CTX(ndr);

2508

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

2509

NDR_CHECK(ndr_pull_wkssvc_NetWkstaInfo1053(ndr, NDR_SCALARS, r->info1053));

2510

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1053_0, 0);

2511

}

2512

break;

2513

2514

case 1054:

2515

if (r->info1054) {

2516

_mem_save_info1054_0 = NDR_PULL_GET_MEM_CTX(ndr);

2517

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

2518

NDR_CHECK(ndr_pull_wkssvc_NetWkstaInfo1054(ndr, NDR_SCALARS, r->info1054));

2519

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1054_0, 0);

2520

}

2521

break;

2522

2523

case 1055:

2524

if (r->info1055) {

2525

_mem_save_info1055_0 = NDR_PULL_GET_MEM_CTX(ndr);

2526

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

2527

NDR_CHECK(ndr_pull_wkssvc_NetWkstaInfo1055(ndr, NDR_SCALARS, r->info1055));

2528

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1055_0, 0);

2529

}

2530

break;

2531

2532

case 1056:

2533

if (r->info1056) {

2534

_mem_save_info1056_0 = NDR_PULL_GET_MEM_CTX(ndr);

2535

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

2536

NDR_CHECK(ndr_pull_wkssvc_NetWkstaInfo1056(ndr, NDR_SCALARS, r->info1056));

2537

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1056_0, 0);

2538

}

2539

break;

2540

2541

case 1057:

2542

if (r->info1057) {

2543

_mem_save_info1057_0 = NDR_PULL_GET_MEM_CTX(ndr);

2544

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

2545

NDR_CHECK(ndr_pull_wkssvc_NetWkstaInfo1057(ndr, NDR_SCALARS, r->info1057));

2546

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1057_0, 0);

2547

}

2548

break;

2549

2550

case 1058:

2551

if (r->info1058) {

2552

_mem_save_info1058_0 = NDR_PULL_GET_MEM_CTX(ndr);

2553

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

2554

NDR_CHECK(ndr_pull_wkssvc_NetWkstaInfo1058(ndr, NDR_SCALARS, r->info1058));

2555

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1058_0, 0);

2556

}

2557

break;

2558

2559

case 1059:

2560

if (r->info1059) {

2561

_mem_save_info1059_0 = NDR_PULL_GET_MEM_CTX(ndr);

2562

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

2563

NDR_CHECK(ndr_pull_wkssvc_NetWkstaInfo1059(ndr, NDR_SCALARS, r->info1059));

2564

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1059_0, 0);

2565

}

2566

break;

2567

2568

case 1060:

2569

if (r->info1060) {

2570

_mem_save_info1060_0 = NDR_PULL_GET_MEM_CTX(ndr);

2571

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

2572

NDR_CHECK(ndr_pull_wkssvc_NetWkstaInfo1060(ndr, NDR_SCALARS, r->info1060));

2573

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1060_0, 0);

2574

}

2575

break;

2576

2577

case 1061:

2578

if (r->info1061) {

2579

_mem_save_info1061_0 = NDR_PULL_GET_MEM_CTX(ndr);

2580

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

2581

NDR_CHECK(ndr_pull_wkssvc_NetWkstaInfo1061(ndr, NDR_SCALARS, r->info1061));

2582

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1061_0, 0);

2583

}

2584

break;

2585

2586

case 1062:

2587

if (r->info1062) {

2588

_mem_save_info1062_0 = NDR_PULL_GET_MEM_CTX(ndr);

2589

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

2590

NDR_CHECK(ndr_pull_wkssvc_NetWkstaInfo1062(ndr, NDR_SCALARS, r->info1062));

2591

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1062_0, 0);

2592

}

2593

break;

2594

2595

default:

2596

break;

2597

2598

}

2599

}

2600

return NDR_ERR_SUCCESS;

2601

}

2602

2603

_PUBLIC_ void ndr_print_wkssvc_NetWkstaInfo(struct ndr_print *ndr, const char *name, const union wkssvc_NetWkstaInfo *r)

2604

{

2605

int level;

2606

level = ndr_print_get_switch_value(ndr, r);

2607

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

2608

switch (level) {

2609

case 100:

2610

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

2611

ndr->depth++;

2612

if (r->info100) {

2613

ndr_print_wkssvc_NetWkstaInfo100(ndr, "info100", r->info100);

2614

}

2615

ndr->depth--;

2616

break;

2617

2618

case 101:

2619

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

2620

ndr->depth++;

2621

if (r->info101) {

2622

ndr_print_wkssvc_NetWkstaInfo101(ndr, "info101", r->info101);

2623

}

2624

ndr->depth--;

2625

break;

2626

2627

case 102:

2628

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

2629

ndr->depth++;

2630

if (r->info102) {

2631

ndr_print_wkssvc_NetWkstaInfo102(ndr, "info102", r->info102);

2632

}

2633

ndr->depth--;

2634

break;

2635

2636

case 502:

2637

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

2638

ndr->depth++;

2639

if (r->info502) {

2640

ndr_print_wkssvc_NetWkstaInfo502(ndr, "info502", r->info502);

2641

}

2642

ndr->depth--;

2643

break;

2644

2645

case 1010:

2646

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

2647

ndr->depth++;

2648

if (r->info1010) {

2649

ndr_print_wkssvc_NetWkstaInfo1010(ndr, "info1010", r->info1010);

2650

}

2651

ndr->depth--;

2652

break;

2653

2654

case 1011:

2655

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

2656

ndr->depth++;

2657

if (r->info1011) {

2658

ndr_print_wkssvc_NetWkstaInfo1011(ndr, "info1011", r->info1011);

2659

}

2660

ndr->depth--;

2661

break;

2662

2663

case 1012:

2664

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

2665

ndr->depth++;

2666

if (r->info1012) {

2667

ndr_print_wkssvc_NetWkstaInfo1012(ndr, "info1012", r->info1012);

2668

}

2669

ndr->depth--;

2670

break;

2671

2672

case 1013:

2673

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

2674

ndr->depth++;

2675

if (r->info1013) {

2676

ndr_print_wkssvc_NetWkstaInfo1013(ndr, "info1013", r->info1013);

2677

}

2678

ndr->depth--;

2679

break;

2680

2681

case 1018:

2682

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

2683

ndr->depth++;

2684

if (r->info1018) {

2685

ndr_print_wkssvc_NetWkstaInfo1018(ndr, "info1018", r->info1018);

2686

}

2687

ndr->depth--;

2688

break;

2689

2690

case 1023:

2691

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

2692

ndr->depth++;

2693

if (r->info1023) {

2694

ndr_print_wkssvc_NetWkstaInfo1023(ndr, "info1023", r->info1023);

2695

}

2696

ndr->depth--;

2697

break;

2698

2699

case 1027:

2700

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

2701

ndr->depth++;

2702

if (r->info1027) {

2703

ndr_print_wkssvc_NetWkstaInfo1027(ndr, "info1027", r->info1027);

2704

}

2705

ndr->depth--;

2706

break;

2707

2708

case 1028:

2709

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

2710

ndr->depth++;

2711

if (r->info1028) {

2712

ndr_print_wkssvc_NetWkstaInfo1028(ndr, "info1028", r->info1028);

2713

}

2714

ndr->depth--;

2715

break;

2716

2717

case 1032:

2718

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

2719

ndr->depth++;

2720

if (r->info1032) {

2721

ndr_print_wkssvc_NetWkstaInfo1032(ndr, "info1032", r->info1032);

2722

}

2723

ndr->depth--;

2724

break;

2725

2726

case 1033:

2727

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

2728

ndr->depth++;

2729

if (r->info1033) {

2730

ndr_print_wkssvc_NetWkstaInfo1033(ndr, "info1033", r->info1033);

2731

}

2732

ndr->depth--;

2733

break;

2734

2735

case 1041:

2736

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

2737

ndr->depth++;

2738

if (r->info1041) {

2739

ndr_print_wkssvc_NetWkstaInfo1041(ndr, "info1041", r->info1041);

2740

}

2741

ndr->depth--;

2742

break;

2743

2744

case 1042:

2745

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

2746

ndr->depth++;

2747

if (r->info1042) {

2748

ndr_print_wkssvc_NetWkstaInfo1042(ndr, "info1042", r->info1042);

2749

}

2750

ndr->depth--;

2751

break;

2752

2753

case 1043:

2754

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

2755

ndr->depth++;

2756

if (r->info1043) {

2757

ndr_print_wkssvc_NetWkstaInfo1043(ndr, "info1043", r->info1043);

2758

}

2759

ndr->depth--;

2760

break;

2761

2762

case 1044:

2763

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

2764

ndr->depth++;

2765

if (r->info1044) {

2766

ndr_print_wkssvc_NetWkstaInfo1044(ndr, "info1044", r->info1044);

2767

}

2768

ndr->depth--;

2769

break;

2770

2771

case 1045:

2772

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

2773

ndr->depth++;

2774

if (r->info1045) {

2775

ndr_print_wkssvc_NetWkstaInfo1045(ndr, "info1045", r->info1045);

2776

}

2777

ndr->depth--;

2778

break;

2779

2780

case 1046:

2781

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

2782

ndr->depth++;

2783

if (r->info1046) {

2784

ndr_print_wkssvc_NetWkstaInfo1046(ndr, "info1046", r->info1046);

2785

}

2786

ndr->depth--;

2787

break;

2788

2789

case 1047:

2790

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

2791

ndr->depth++;

2792

if (r->info1047) {

2793

ndr_print_wkssvc_NetWkstaInfo1047(ndr, "info1047", r->info1047);

2794

}

2795

ndr->depth--;

2796

break;

2797

2798

case 1048:

2799

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

2800

ndr->depth++;

2801

if (r->info1048) {

2802

ndr_print_wkssvc_NetWkstaInfo1048(ndr, "info1048", r->info1048);

2803

}

2804

ndr->depth--;

2805

break;

2806

2807

case 1049:

2808

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

2809

ndr->depth++;

2810

if (r->info1049) {

2811

ndr_print_wkssvc_NetWkstaInfo1049(ndr, "info1049", r->info1049);

2812

}

2813

ndr->depth--;

2814

break;

2815

2816

case 1050:

2817

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

2818

ndr->depth++;

2819

if (r->info1050) {

2820

ndr_print_wkssvc_NetWkstaInfo1050(ndr, "info1050", r->info1050);

2821

}

2822

ndr->depth--;

2823

break;

2824

2825

case 1051:

2826

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

2827

ndr->depth++;

2828

if (r->info1051) {

2829

ndr_print_wkssvc_NetWkstaInfo1051(ndr, "info1051", r->info1051);

2830

}

2831

ndr->depth--;

2832

break;

2833

2834

case 1052:

2835

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

2836

ndr->depth++;

2837

if (r->info1052) {

2838

ndr_print_wkssvc_NetWkstaInfo1052(ndr, "info1052", r->info1052);

2839

}

2840

ndr->depth--;

2841

break;

2842

2843

case 1053:

2844

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

2845

ndr->depth++;

2846

if (r->info1053) {

2847

ndr_print_wkssvc_NetWkstaInfo1053(ndr, "info1053", r->info1053);

2848

}

2849

ndr->depth--;

2850

break;

2851

2852

case 1054:

2853

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

2854

ndr->depth++;

2855

if (r->info1054) {

2856

ndr_print_wkssvc_NetWkstaInfo1054(ndr, "info1054", r->info1054);

2857

}

2858

ndr->depth--;

2859

break;

2860

2861

case 1055:

2862

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

2863

ndr->depth++;

2864

if (r->info1055) {

2865

ndr_print_wkssvc_NetWkstaInfo1055(ndr, "info1055", r->info1055);

2866

}

2867

ndr->depth--;

2868

break;

2869

2870

case 1056:

2871

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

2872

ndr->depth++;

2873

if (r->info1056) {

2874

ndr_print_wkssvc_NetWkstaInfo1056(ndr, "info1056", r->info1056);

2875

}

2876

ndr->depth--;

2877

break;

2878

2879

case 1057:

2880

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

2881

ndr->depth++;

2882

if (r->info1057) {

2883

ndr_print_wkssvc_NetWkstaInfo1057(ndr, "info1057", r->info1057);

2884

}

2885

ndr->depth--;

2886

break;

2887

2888

case 1058:

2889

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

2890

ndr->depth++;

2891

if (r->info1058) {

2892

ndr_print_wkssvc_NetWkstaInfo1058(ndr, "info1058", r->info1058);

2893

}

2894

ndr->depth--;

2895

break;

2896

2897

case 1059:

2898

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

2899

ndr->depth++;

2900

if (r->info1059) {

2901

ndr_print_wkssvc_NetWkstaInfo1059(ndr, "info1059", r->info1059);

2902

}

2903

ndr->depth--;

2904

break;

2905

2906

case 1060:

2907

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

2908

ndr->depth++;

2909

if (r->info1060) {

2910

ndr_print_wkssvc_NetWkstaInfo1060(ndr, "info1060", r->info1060);

2911

}

2912

ndr->depth--;

2913

break;

2914

2915

case 1061:

2916

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

2917

ndr->depth++;

2918

if (r->info1061) {

2919

ndr_print_wkssvc_NetWkstaInfo1061(ndr, "info1061", r->info1061);

2920

}

2921

ndr->depth--;

2922

break;

2923

2924

case 1062:

2925

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

2926

ndr->depth++;

2927

if (r->info1062) {

2928

ndr_print_wkssvc_NetWkstaInfo1062(ndr, "info1062", r->info1062);

2929

}

2930

ndr->depth--;

2931

break;

2932

2933

default:

2934

break;

2935

2936

}

2937

}

2938

2939

static enum ndr_err_code ndr_push_wkssvc_NetrWkstaUserInfo0(struct ndr_push *ndr, int ndr_flags, const struct wkssvc_NetrWkstaUserInfo0 *r)

2940

{

2941

if (ndr_flags & NDR_SCALARS) {

2942

NDR_CHECK(ndr_push_align(ndr, 4));

2943

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

2944

}

2945

if (ndr_flags & NDR_BUFFERS) {

2946

if (r->user_name) {

2947

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

2948

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

2949

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

2950

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

2951

}

2952

}

2953

return NDR_ERR_SUCCESS;

2954

}

2955

2956

static enum ndr_err_code ndr_pull_wkssvc_NetrWkstaUserInfo0(struct ndr_pull *ndr, int ndr_flags, struct wkssvc_NetrWkstaUserInfo0 *r)

2957

{

2958

uint32_t _ptr_user_name;

2959

TALLOC_CTX *_mem_save_user_name_0;

2960

if (ndr_flags & NDR_SCALARS) {

2961

NDR_CHECK(ndr_pull_align(ndr, 4));

2962

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_user_name));

2963

if (_ptr_user_name) {

2964

NDR_PULL_ALLOC(ndr, r->user_name);

2965

} else {

2966

r->user_name = NULL;

2967

}

2968

}

2969

if (ndr_flags & NDR_BUFFERS) {

2970

if (r->user_name) {

2971

_mem_save_user_name_0 = NDR_PULL_GET_MEM_CTX(ndr);

2972

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

2973

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

2974

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

2975

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

2976

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_name), ndr_get_array_length(ndr, &r->user_name));

2977

}

2978

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

2979

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

2980

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_name_0, 0);

2981

}

2982

}

2983

return NDR_ERR_SUCCESS;

2984

}

2985

2986

_PUBLIC_ void ndr_print_wkssvc_NetrWkstaUserInfo0(struct ndr_print *ndr, const char *name, const struct wkssvc_NetrWkstaUserInfo0 *r)

2987

{

2988

ndr_print_struct(ndr, name, "wkssvc_NetrWkstaUserInfo0");

2989

ndr->depth++;

2990

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

2991

ndr->depth++;

2992

if (r->user_name) {

2993

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

2994

}

2995

ndr->depth--;

2996

ndr->depth--;

2997

}

2998

2999

static enum ndr_err_code ndr_push_wkssvc_NetWkstaEnumUsersCtr0(struct ndr_push *ndr, int ndr_flags, const struct wkssvc_NetWkstaEnumUsersCtr0 *r)

3000

{

3001

uint32_t cntr_user0_1;

3002

if (ndr_flags & NDR_SCALARS) {

3003

NDR_CHECK(ndr_push_align(ndr, 4));

3004

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

3005

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

3006

}

3007

if (ndr_flags & NDR_BUFFERS) {

3008

if (r->user0) {

3009

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

3010

for (cntr_user0_1 = 0; cntr_user0_1 < r->entries_read; cntr_user0_1++) {

3011

NDR_CHECK(ndr_push_wkssvc_NetrWkstaUserInfo0(ndr, NDR_SCALARS, &r->user0[cntr_user0_1]));

3012

}

3013

for (cntr_user0_1 = 0; cntr_user0_1 < r->entries_read; cntr_user0_1++) {

3014

NDR_CHECK(ndr_push_wkssvc_NetrWkstaUserInfo0(ndr, NDR_BUFFERS, &r->user0[cntr_user0_1]));

3015

}

3016

}

3017

}

3018

return NDR_ERR_SUCCESS;

3019

}

3020

3021

static enum ndr_err_code ndr_pull_wkssvc_NetWkstaEnumUsersCtr0(struct ndr_pull *ndr, int ndr_flags, struct wkssvc_NetWkstaEnumUsersCtr0 *r)

3022

{

3023

uint32_t _ptr_user0;

3024

uint32_t cntr_user0_1;

3025

TALLOC_CTX *_mem_save_user0_0;

3026

TALLOC_CTX *_mem_save_user0_1;

3027

if (ndr_flags & NDR_SCALARS) {

3028

NDR_CHECK(ndr_pull_align(ndr, 4));

3029

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

3030

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_user0));

3031

if (_ptr_user0) {

3032

NDR_PULL_ALLOC(ndr, r->user0);

3033

} else {

3034

r->user0 = NULL;

3035

}

3036

}

3037

if (ndr_flags & NDR_BUFFERS) {

3038

if (r->user0) {

3039

_mem_save_user0_0 = NDR_PULL_GET_MEM_CTX(ndr);

3040

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

3041

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

3042

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

3043

_mem_save_user0_1 = NDR_PULL_GET_MEM_CTX(ndr);

3044

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

3045

for (cntr_user0_1 = 0; cntr_user0_1 < r->entries_read; cntr_user0_1++) {

3046

NDR_CHECK(ndr_pull_wkssvc_NetrWkstaUserInfo0(ndr, NDR_SCALARS, &r->user0[cntr_user0_1]));

3047

}

3048

for (cntr_user0_1 = 0; cntr_user0_1 < r->entries_read; cntr_user0_1++) {

3049

NDR_CHECK(ndr_pull_wkssvc_NetrWkstaUserInfo0(ndr, NDR_BUFFERS, &r->user0[cntr_user0_1]));

3050

}

3051

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user0_1, 0);

3052

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user0_0, 0);

3053

}

3054

if (r->user0) {

3055

NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->user0, r->entries_read));

3056

}

3057

}

3058

return NDR_ERR_SUCCESS;

3059

}

3060

3061

_PUBLIC_ void ndr_print_wkssvc_NetWkstaEnumUsersCtr0(struct ndr_print *ndr, const char *name, const struct wkssvc_NetWkstaEnumUsersCtr0 *r)

3062

{

3063

uint32_t cntr_user0_1;

3064

ndr_print_struct(ndr, name, "wkssvc_NetWkstaEnumUsersCtr0");

3065

ndr->depth++;

3066

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

3067

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

3068

ndr->depth++;

3069

if (r->user0) {

3070

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

3071

ndr->depth++;

3072

for (cntr_user0_1=0;cntr_user0_1<r->entries_read;cntr_user0_1++) {

3073

char *idx_1=NULL;

3074

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

3075

ndr_print_wkssvc_NetrWkstaUserInfo0(ndr, "user0", &r->user0[cntr_user0_1]);

3076

free(idx_1);

3077

}

3078

}

3079

ndr->depth--;

3080

}

3081

ndr->depth--;

3082

ndr->depth--;

3083

}

3084

3085

static enum ndr_err_code ndr_push_wkssvc_NetrWkstaUserInfo1(struct ndr_push *ndr, int ndr_flags, const struct wkssvc_NetrWkstaUserInfo1 *r)

3086

{

3087

if (ndr_flags & NDR_SCALARS) {

3088

NDR_CHECK(ndr_push_align(ndr, 4));

3089

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

3090

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

3091

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

3092

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

3093

}

3094

if (ndr_flags & NDR_BUFFERS) {

3095

if (r->user_name) {

3096

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

3097

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

3098

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

3099

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

3100

}

3101

if (r->logon_domain) {

3102

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

3103

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

3104

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

3105

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

3106

}

3107

if (r->other_domains) {

3108

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

3109

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

3110

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

3111

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

3112

}

3113

if (r->logon_server) {

3114

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

3115

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

3116

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

3117

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

3118

}

3119

}

3120

return NDR_ERR_SUCCESS;

3121

}

3122

3123

static enum ndr_err_code ndr_pull_wkssvc_NetrWkstaUserInfo1(struct ndr_pull *ndr, int ndr_flags, struct wkssvc_NetrWkstaUserInfo1 *r)

3124

{

3125

uint32_t _ptr_user_name;

3126

TALLOC_CTX *_mem_save_user_name_0;

3127

uint32_t _ptr_logon_domain;

3128

TALLOC_CTX *_mem_save_logon_domain_0;

3129

uint32_t _ptr_other_domains;

3130

TALLOC_CTX *_mem_save_other_domains_0;

3131

uint32_t _ptr_logon_server;

3132

TALLOC_CTX *_mem_save_logon_server_0;

3133

if (ndr_flags & NDR_SCALARS) {

3134

NDR_CHECK(ndr_pull_align(ndr, 4));

3135

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_user_name));

3136

if (_ptr_user_name) {

3137

NDR_PULL_ALLOC(ndr, r->user_name);

3138

} else {

3139

r->user_name = NULL;

3140

}

3141

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_logon_domain));

3142

if (_ptr_logon_domain) {

3143

NDR_PULL_ALLOC(ndr, r->logon_domain);

3144

} else {

3145

r->logon_domain = NULL;

3146

}

3147

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_other_domains));

3148

if (_ptr_other_domains) {

3149

NDR_PULL_ALLOC(ndr, r->other_domains);

3150

} else {

3151

r->other_domains = NULL;

3152

}

3153

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_logon_server));

3154

if (_ptr_logon_server) {

3155

NDR_PULL_ALLOC(ndr, r->logon_server);

3156

} else {

3157

r->logon_server = NULL;

3158

}

3159

}

3160

if (ndr_flags & NDR_BUFFERS) {

3161

if (r->user_name) {

3162

_mem_save_user_name_0 = NDR_PULL_GET_MEM_CTX(ndr);

3163

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

3164

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

3165

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

3166

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

3167

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_name), ndr_get_array_length(ndr, &r->user_name));

3168

}

3169

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

3170

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

3171

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_name_0, 0);

3172

}

3173

if (r->logon_domain) {

3174

_mem_save_logon_domain_0 = NDR_PULL_GET_MEM_CTX(ndr);

3175

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

3176

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

3177

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

3178

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

3179

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

3180

}

3181

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

3182

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

3183

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_logon_domain_0, 0);

3184

}

3185

if (r->other_domains) {

3186

_mem_save_other_domains_0 = NDR_PULL_GET_MEM_CTX(ndr);

3187

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

3188

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

3189

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

3190

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

3191

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

3192

}

3193

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

3194

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

3195

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_other_domains_0, 0);

3196

}

3197

if (r->logon_server) {

3198

_mem_save_logon_server_0 = NDR_PULL_GET_MEM_CTX(ndr);

3199

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

3200

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

3201

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

3202

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

3203

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

3204

}

3205

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

3206

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

3207

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_logon_server_0, 0);

3208

}

3209

}

3210

return NDR_ERR_SUCCESS;

3211

}

3212

3213

_PUBLIC_ void ndr_print_wkssvc_NetrWkstaUserInfo1(struct ndr_print *ndr, const char *name, const struct wkssvc_NetrWkstaUserInfo1 *r)

3214

{

3215

ndr_print_struct(ndr, name, "wkssvc_NetrWkstaUserInfo1");

3216

ndr->depth++;

3217

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

3218

ndr->depth++;

3219

if (r->user_name) {

3220

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

3221

}

3222

ndr->depth--;

3223

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

3224

ndr->depth++;

3225

if (r->logon_domain) {

3226

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

3227

}

3228

ndr->depth--;

3229

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

3230

ndr->depth++;

3231

if (r->other_domains) {

3232

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

3233

}

3234

ndr->depth--;

3235

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

3236

ndr->depth++;

3237

if (r->logon_server) {

3238

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

3239

}

3240

ndr->depth--;

3241

ndr->depth--;

3242

}

3243

3244

static enum ndr_err_code ndr_push_wkssvc_NetWkstaEnumUsersCtr1(struct ndr_push *ndr, int ndr_flags, const struct wkssvc_NetWkstaEnumUsersCtr1 *r)

3245

{

3246

uint32_t cntr_user1_1;

3247

if (ndr_flags & NDR_SCALARS) {

3248

NDR_CHECK(ndr_push_align(ndr, 4));

3249

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

3250

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

3251

}

3252

if (ndr_flags & NDR_BUFFERS) {

3253

if (r->user1) {

3254

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

3255

for (cntr_user1_1 = 0; cntr_user1_1 < r->entries_read; cntr_user1_1++) {

3256

NDR_CHECK(ndr_push_wkssvc_NetrWkstaUserInfo1(ndr, NDR_SCALARS, &r->user1[cntr_user1_1]));

3257

}

3258

for (cntr_user1_1 = 0; cntr_user1_1 < r->entries_read; cntr_user1_1++) {

3259

NDR_CHECK(ndr_push_wkssvc_NetrWkstaUserInfo1(ndr, NDR_BUFFERS, &r->user1[cntr_user1_1]));

3260

}

3261

}

3262

}

3263

return NDR_ERR_SUCCESS;

3264

}

3265

3266

static enum ndr_err_code ndr_pull_wkssvc_NetWkstaEnumUsersCtr1(struct ndr_pull *ndr, int ndr_flags, struct wkssvc_NetWkstaEnumUsersCtr1 *r)

3267

{

3268

uint32_t _ptr_user1;

3269

uint32_t cntr_user1_1;

3270

TALLOC_CTX *_mem_save_user1_0;

3271

TALLOC_CTX *_mem_save_user1_1;

3272

if (ndr_flags & NDR_SCALARS) {

3273

NDR_CHECK(ndr_pull_align(ndr, 4));

3274

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

3275

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_user1));

3276

if (_ptr_user1) {

3277

NDR_PULL_ALLOC(ndr, r->user1);

3278

} else {

3279

r->user1 = NULL;

3280

}

3281

}

3282

if (ndr_flags & NDR_BUFFERS) {

3283

if (r->user1) {

3284

_mem_save_user1_0 = NDR_PULL_GET_MEM_CTX(ndr);

3285

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

3286

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

3287

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

3288

_mem_save_user1_1 = NDR_PULL_GET_MEM_CTX(ndr);

3289

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

3290

for (cntr_user1_1 = 0; cntr_user1_1 < r->entries_read; cntr_user1_1++) {

3291

NDR_CHECK(ndr_pull_wkssvc_NetrWkstaUserInfo1(ndr, NDR_SCALARS, &r->user1[cntr_user1_1]));

3292

}

3293

for (cntr_user1_1 = 0; cntr_user1_1 < r->entries_read; cntr_user1_1++) {

3294

NDR_CHECK(ndr_pull_wkssvc_NetrWkstaUserInfo1(ndr, NDR_BUFFERS, &r->user1[cntr_user1_1]));

3295

}

3296

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user1_1, 0);

3297

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user1_0, 0);

3298

}

3299

if (r->user1) {

3300

NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->user1, r->entries_read));

3301

}

3302

}

3303

return NDR_ERR_SUCCESS;

3304

}

3305

3306

_PUBLIC_ void ndr_print_wkssvc_NetWkstaEnumUsersCtr1(struct ndr_print *ndr, const char *name, const struct wkssvc_NetWkstaEnumUsersCtr1 *r)

3307

{

3308

uint32_t cntr_user1_1;

3309

ndr_print_struct(ndr, name, "wkssvc_NetWkstaEnumUsersCtr1");

3310

ndr->depth++;

3311

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

3312

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

3313

ndr->depth++;

3314

if (r->user1) {

3315

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

3316

ndr->depth++;

3317

for (cntr_user1_1=0;cntr_user1_1<r->entries_read;cntr_user1_1++) {

3318

char *idx_1=NULL;

3319

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

3320

ndr_print_wkssvc_NetrWkstaUserInfo1(ndr, "user1", &r->user1[cntr_user1_1]);

3321

free(idx_1);

3322

}

3323

}

3324

ndr->depth--;

3325

}

3326

ndr->depth--;

3327

ndr->depth--;

3328

}

3329

3330

static enum ndr_err_code ndr_push_wkssvc_NetWkstaEnumUsersCtr(struct ndr_push *ndr, int ndr_flags, const union wkssvc_NetWkstaEnumUsersCtr *r)

3331

{

3332

if (ndr_flags & NDR_SCALARS) {

3333

int level = ndr_push_get_switch_value(ndr, r);

3334

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

3335

switch (level) {

3336

case 0: {

3337

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

3338

break; }

3339

3340

case 1: {

3341

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

3342

break; }

3343

3344

default:

3345

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

3346

}

3347

}

3348

if (ndr_flags & NDR_BUFFERS) {

3349

int level = ndr_push_get_switch_value(ndr, r);

3350

switch (level) {

3351

case 0:

3352

if (r->user0) {

3353

NDR_CHECK(ndr_push_wkssvc_NetWkstaEnumUsersCtr0(ndr, NDR_SCALARS|NDR_BUFFERS, r->user0));

3354

}

3355

break;

3356

3357

case 1:

3358

if (r->user1) {

3359

NDR_CHECK(ndr_push_wkssvc_NetWkstaEnumUsersCtr1(ndr, NDR_SCALARS|NDR_BUFFERS, r->user1));

3360

}

3361

break;

3362

3363

default:

3364

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

3365

}

3366

}

3367

return NDR_ERR_SUCCESS;

3368

}

3369

3370

static enum ndr_err_code ndr_pull_wkssvc_NetWkstaEnumUsersCtr(struct ndr_pull *ndr, int ndr_flags, union wkssvc_NetWkstaEnumUsersCtr *r)

3371

{

3372

int level;

3373

uint32_t _level;

3374

TALLOC_CTX *_mem_save_user0_0;

3375

TALLOC_CTX *_mem_save_user1_0;

3376

level = ndr_pull_get_switch_value(ndr, r);

3377

if (ndr_flags & NDR_SCALARS) {

3378

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

3379

if (_level != level) {

3380

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

3381

}

3382

switch (level) {

3383

case 0: {

3384

uint32_t _ptr_user0;

3385

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_user0));

3386

if (_ptr_user0) {

3387

NDR_PULL_ALLOC(ndr, r->user0);

3388

} else {

3389

r->user0 = NULL;

3390

}

3391

break; }

3392

3393

case 1: {

3394

uint32_t _ptr_user1;

3395

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_user1));

3396

if (_ptr_user1) {

3397

NDR_PULL_ALLOC(ndr, r->user1);

3398

} else {

3399

r->user1 = NULL;

3400

}

3401

break; }

3402

3403

default:

3404

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

3405

}

3406

}

3407

if (ndr_flags & NDR_BUFFERS) {

3408

switch (level) {

3409

case 0:

3410

if (r->user0) {

3411

_mem_save_user0_0 = NDR_PULL_GET_MEM_CTX(ndr);

3412

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

3413

NDR_CHECK(ndr_pull_wkssvc_NetWkstaEnumUsersCtr0(ndr, NDR_SCALARS|NDR_BUFFERS, r->user0));

3414

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user0_0, 0);

3415

}

3416

break;

3417

3418

case 1:

3419

if (r->user1) {

3420

_mem_save_user1_0 = NDR_PULL_GET_MEM_CTX(ndr);

3421

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

3422

NDR_CHECK(ndr_pull_wkssvc_NetWkstaEnumUsersCtr1(ndr, NDR_SCALARS|NDR_BUFFERS, r->user1));

3423

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user1_0, 0);

3424

}

3425

break;

3426

3427

default:

3428

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

3429

}

3430

}

3431

return NDR_ERR_SUCCESS;

3432

}

3433

3434

_PUBLIC_ void ndr_print_wkssvc_NetWkstaEnumUsersCtr(struct ndr_print *ndr, const char *name, const union wkssvc_NetWkstaEnumUsersCtr *r)

3435

{

3436

int level;

3437

level = ndr_print_get_switch_value(ndr, r);

3438

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

3439

switch (level) {

3440

case 0:

3441

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

3442

ndr->depth++;

3443

if (r->user0) {

3444

ndr_print_wkssvc_NetWkstaEnumUsersCtr0(ndr, "user0", r->user0);

3445

}

3446

ndr->depth--;

3447

break;

3448

3449

case 1:

3450

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

3451

ndr->depth++;

3452

if (r->user1) {

3453

ndr_print_wkssvc_NetWkstaEnumUsersCtr1(ndr, "user1", r->user1);

3454

}

3455

ndr->depth--;

3456

break;

3457

3458

default:

3459

ndr_print_bad_level(ndr, name, level);

3460

}

3461

}

3462

3463

static enum ndr_err_code ndr_push_wkssvc_NetWkstaEnumUsersInfo(struct ndr_push *ndr, int ndr_flags, const struct wkssvc_NetWkstaEnumUsersInfo *r)

3464

{

3465

if (ndr_flags & NDR_SCALARS) {

3466

NDR_CHECK(ndr_push_align(ndr, 4));

3467

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

3468

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

3469

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

3470

}

3471

if (ndr_flags & NDR_BUFFERS) {

3472

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

3473

}

3474

return NDR_ERR_SUCCESS;

3475

}

3476

3477

static enum ndr_err_code ndr_pull_wkssvc_NetWkstaEnumUsersInfo(struct ndr_pull *ndr, int ndr_flags, struct wkssvc_NetWkstaEnumUsersInfo *r)

3478

{

3479

if (ndr_flags & NDR_SCALARS) {

3480

NDR_CHECK(ndr_pull_align(ndr, 4));

3481

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

3482

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

3483

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

3484

}

3485

if (ndr_flags & NDR_BUFFERS) {

3486

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

3487

}

3488

return NDR_ERR_SUCCESS;

3489

}

3490

3491

_PUBLIC_ void ndr_print_wkssvc_NetWkstaEnumUsersInfo(struct ndr_print *ndr, const char *name, const struct wkssvc_NetWkstaEnumUsersInfo *r)

3492

{

3493

ndr_print_struct(ndr, name, "wkssvc_NetWkstaEnumUsersInfo");

3494

ndr->depth++;

3495

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

3496

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

3497

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

3498

ndr->depth--;

3499

}

3500

3501

static enum ndr_err_code ndr_push_wkssvc_NetrWkstaUserInfo1101(struct ndr_push *ndr, int ndr_flags, const struct wkssvc_NetrWkstaUserInfo1101 *r)

3502

{

3503

if (ndr_flags & NDR_SCALARS) {

3504

NDR_CHECK(ndr_push_align(ndr, 4));

3505

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

3506

}

3507

if (ndr_flags & NDR_BUFFERS) {

3508

if (r->other_domains) {

3509

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

3510

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

3511

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

3512

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

3513

}

3514

}

3515

return NDR_ERR_SUCCESS;

3516

}

3517

3518

static enum ndr_err_code ndr_pull_wkssvc_NetrWkstaUserInfo1101(struct ndr_pull *ndr, int ndr_flags, struct wkssvc_NetrWkstaUserInfo1101 *r)

3519

{

3520

uint32_t _ptr_other_domains;

3521

TALLOC_CTX *_mem_save_other_domains_0;

3522

if (ndr_flags & NDR_SCALARS) {

3523

NDR_CHECK(ndr_pull_align(ndr, 4));

3524

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_other_domains));

3525

if (_ptr_other_domains) {

3526

NDR_PULL_ALLOC(ndr, r->other_domains);

3527

} else {

3528

r->other_domains = NULL;

3529

}

3530

}

3531

if (ndr_flags & NDR_BUFFERS) {

3532

if (r->other_domains) {

3533

_mem_save_other_domains_0 = NDR_PULL_GET_MEM_CTX(ndr);

3534

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

3535

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

3536

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

3537

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

3538

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

3539

}

3540

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

3541

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

3542

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_other_domains_0, 0);

3543

}

3544

}

3545

return NDR_ERR_SUCCESS;

3546

}

3547

3548

_PUBLIC_ void ndr_print_wkssvc_NetrWkstaUserInfo1101(struct ndr_print *ndr, const char *name, const struct wkssvc_NetrWkstaUserInfo1101 *r)

3549

{

3550

ndr_print_struct(ndr, name, "wkssvc_NetrWkstaUserInfo1101");

3551

ndr->depth++;

3552

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

3553

ndr->depth++;

3554

if (r->other_domains) {

3555

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

3556

}

3557

ndr->depth--;

3558

ndr->depth--;

3559

}

3560

3561

static enum ndr_err_code ndr_push_wkssvc_NetrWkstaUserInfo(struct ndr_push *ndr, int ndr_flags, const union wkssvc_NetrWkstaUserInfo *r)

3562

{

3563

if (ndr_flags & NDR_SCALARS) {

3564

int level = ndr_push_get_switch_value(ndr, r);

3565

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

3566

switch (level) {

3567

case 0: {

3568

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

3569

break; }

3570

3571

case 1: {

3572

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

3573

break; }

3574

3575

case 1101: {

3576

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

3577

break; }

3578

3579

default:

3580

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

3581

}

3582

}

3583

if (ndr_flags & NDR_BUFFERS) {

3584

int level = ndr_push_get_switch_value(ndr, r);

3585

switch (level) {

3586

case 0:

3587

if (r->info0) {

3588

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

3589

}

3590

break;

3591

3592

case 1:

3593

if (r->info1) {

3594

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

3595

}

3596

break;

3597

3598

case 1101:

3599

if (r->info1101) {

3600

NDR_CHECK(ndr_push_wkssvc_NetrWkstaUserInfo1101(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1101));

3601

}

3602

break;

3603

3604

default:

3605

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

3606

}

3607

}

3608

return NDR_ERR_SUCCESS;

3609

}

3610

3611

static enum ndr_err_code ndr_pull_wkssvc_NetrWkstaUserInfo(struct ndr_pull *ndr, int ndr_flags, union wkssvc_NetrWkstaUserInfo *r)

3612

{

3613

int level;

3614

uint32_t _level;

3615

TALLOC_CTX *_mem_save_info0_0;

3616

TALLOC_CTX *_mem_save_info1_0;

3617

TALLOC_CTX *_mem_save_info1101_0;

3618

level = ndr_pull_get_switch_value(ndr, r);

3619

if (ndr_flags & NDR_SCALARS) {

3620

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

3621

if (_level != level) {

3622

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

3623

}

3624

switch (level) {

3625

case 0: {

3626

uint32_t _ptr_info0;

3627

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info0));

3628

if (_ptr_info0) {

3629

NDR_PULL_ALLOC(ndr, r->info0);

3630

} else {

3631

r->info0 = NULL;

3632

}

3633

break; }

3634

3635

case 1: {

3636

uint32_t _ptr_info1;

3637

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1));

3638

if (_ptr_info1) {

3639

NDR_PULL_ALLOC(ndr, r->info1);

3640

} else {

3641

r->info1 = NULL;

3642

}

3643

break; }

3644

3645

case 1101: {

3646

uint32_t _ptr_info1101;

3647

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1101));

3648

if (_ptr_info1101) {

3649

NDR_PULL_ALLOC(ndr, r->info1101);

3650

} else {

3651

r->info1101 = NULL;

3652

}

3653

break; }

3654

3655

default:

3656

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

3657

}

3658

}

3659

if (ndr_flags & NDR_BUFFERS) {

3660

switch (level) {

3661

case 0:

3662

if (r->info0) {

3663

_mem_save_info0_0 = NDR_PULL_GET_MEM_CTX(ndr);

3664

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

3665

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

3666

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info0_0, 0);

3667

}

3668

break;

3669

3670

case 1:

3671

if (r->info1) {

3672

_mem_save_info1_0 = NDR_PULL_GET_MEM_CTX(ndr);

3673

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

3674

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

3675

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1_0, 0);

3676

}

3677

break;

3678

3679

case 1101:

3680

if (r->info1101) {

3681

_mem_save_info1101_0 = NDR_PULL_GET_MEM_CTX(ndr);

3682

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

3683

NDR_CHECK(ndr_pull_wkssvc_NetrWkstaUserInfo1101(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1101));

3684

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1101_0, 0);

3685

}

3686

break;

3687

3688

default:

3689

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

3690

}

3691

}

3692

return NDR_ERR_SUCCESS;

3693

}

3694

3695

_PUBLIC_ void ndr_print_wkssvc_NetrWkstaUserInfo(struct ndr_print *ndr, const char *name, const union wkssvc_NetrWkstaUserInfo *r)

3696

{

3697

int level;

3698

level = ndr_print_get_switch_value(ndr, r);

3699

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

3700

switch (level) {

3701

case 0:

3702

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

3703

ndr->depth++;

3704

if (r->info0) {

3705

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

3706

}

3707

ndr->depth--;

3708

break;

3709

3710

case 1:

3711

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

3712

ndr->depth++;

3713

if (r->info1) {

3714

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

3715

}

3716

ndr->depth--;

3717

break;

3718

3719

case 1101:

3720

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

3721

ndr->depth++;

3722

if (r->info1101) {

3723

ndr_print_wkssvc_NetrWkstaUserInfo1101(ndr, "info1101", r->info1101);

3724

}

3725

ndr->depth--;

3726

break;

3727

3728

default:

3729

ndr_print_bad_level(ndr, name, level);

3730

}

3731

}

3732

3733

static enum ndr_err_code ndr_push_wkssvc_NetWkstaTransportInfo0(struct ndr_push *ndr, int ndr_flags, const struct wkssvc_NetWkstaTransportInfo0 *r)

3734

{

3735

if (ndr_flags & NDR_SCALARS) {

3736

NDR_CHECK(ndr_push_align(ndr, 4));

3737

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

3738

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

3739

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

3740

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

3741

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

3742

}

3743

if (ndr_flags & NDR_BUFFERS) {

3744

if (r->name) {

3745

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

3746

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

3747

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

3748

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

3749

}

3750

if (r->address) {

3751

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

3752

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

3753

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

3754

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

3755

}

3756

}

3757

return NDR_ERR_SUCCESS;

3758

}

3759

3760

static enum ndr_err_code ndr_pull_wkssvc_NetWkstaTransportInfo0(struct ndr_pull *ndr, int ndr_flags, struct wkssvc_NetWkstaTransportInfo0 *r)

3761

{

3762

uint32_t _ptr_name;

3763

TALLOC_CTX *_mem_save_name_0;

3764

uint32_t _ptr_address;

3765

TALLOC_CTX *_mem_save_address_0;

3766

if (ndr_flags & NDR_SCALARS) {

3767

NDR_CHECK(ndr_pull_align(ndr, 4));

3768

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

3769

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

3770

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_name));

3771

if (_ptr_name) {

3772

NDR_PULL_ALLOC(ndr, r->name);

3773

} else {

3774

r->name = NULL;

3775

}

3776

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_address));

3777

if (_ptr_address) {

3778

NDR_PULL_ALLOC(ndr, r->address);

3779

} else {

3780

r->address = NULL;

3781

}

3782

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

3783

}

3784

if (ndr_flags & NDR_BUFFERS) {

3785

if (r->name) {

3786

_mem_save_name_0 = NDR_PULL_GET_MEM_CTX(ndr);

3787

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

3788

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

3789

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

3790

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

3791

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));

3792

}

3793

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

3794

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

3795

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_name_0, 0);

3796

}

3797

if (r->address) {

3798

_mem_save_address_0 = NDR_PULL_GET_MEM_CTX(ndr);

3799

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

3800

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

3801

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

3802

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

3803

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

3804

}

3805

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

3806

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

3807

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_address_0, 0);

3808

}

3809

}

3810

return NDR_ERR_SUCCESS;

3811

}

3812

3813

_PUBLIC_ void ndr_print_wkssvc_NetWkstaTransportInfo0(struct ndr_print *ndr, const char *name, const struct wkssvc_NetWkstaTransportInfo0 *r)

3814

{

3815

ndr_print_struct(ndr, name, "wkssvc_NetWkstaTransportInfo0");

3816

ndr->depth++;

3817

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

3818

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

3819

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

3820

ndr->depth++;

3821

if (r->name) {

3822

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

3823

}

3824

ndr->depth--;

3825

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

3826

ndr->depth++;

3827

if (r->address) {

3828

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

3829

}

3830

ndr->depth--;

3831

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

3832

ndr->depth--;

3833

}

3834

3835

static enum ndr_err_code ndr_push_wkssvc_NetWkstaTransportCtr0(struct ndr_push *ndr, int ndr_flags, const struct wkssvc_NetWkstaTransportCtr0 *r)

3836

{

3837

uint32_t cntr_array_1;

3838

if (ndr_flags & NDR_SCALARS) {

3839

NDR_CHECK(ndr_push_align(ndr, 4));

3840

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

3841

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

3842

}

3843

if (ndr_flags & NDR_BUFFERS) {

3844

if (r->array) {

3845

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

3846

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

3847

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

3848

}

3849

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

3850

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

3851

}

3852

}

3853

}

3854

return NDR_ERR_SUCCESS;

3855

}

3856

3857

static enum ndr_err_code ndr_pull_wkssvc_NetWkstaTransportCtr0(struct ndr_pull *ndr, int ndr_flags, struct wkssvc_NetWkstaTransportCtr0 *r)

3858

{

3859

uint32_t _ptr_array;

3860

uint32_t cntr_array_1;

3861

TALLOC_CTX *_mem_save_array_0;

3862

TALLOC_CTX *_mem_save_array_1;

3863

if (ndr_flags & NDR_SCALARS) {

3864

NDR_CHECK(ndr_pull_align(ndr, 4));

3865

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

3866

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_array));

3867

if (_ptr_array) {

3868

NDR_PULL_ALLOC(ndr, r->array);

3869

} else {

3870

r->array = NULL;

3871

}

3872

}

3873

if (ndr_flags & NDR_BUFFERS) {

3874

if (r->array) {

3875

_mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);

3876

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

3877

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

3878

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

3879

_mem_save_array_1 = NDR_PULL_GET_MEM_CTX(ndr);

3880

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

3881

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

3882

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

3883

}

3884

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

3885

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

3886

}

3887

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_1, 0);

3888

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);

3889

}

3890

if (r->array) {

3891

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

3892

}

3893

}

3894

return NDR_ERR_SUCCESS;

3895

}

3896

3897

_PUBLIC_ void ndr_print_wkssvc_NetWkstaTransportCtr0(struct ndr_print *ndr, const char *name, const struct wkssvc_NetWkstaTransportCtr0 *r)

3898

{

3899

uint32_t cntr_array_1;

3900

ndr_print_struct(ndr, name, "wkssvc_NetWkstaTransportCtr0");

3901

ndr->depth++;

3902

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

3903

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

3904

ndr->depth++;

3905

if (r->array) {

3906

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

3907

ndr->depth++;

3908

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

3909

char *idx_1=NULL;

3910

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

3911

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

3912

free(idx_1);

3913

}

3914

}

3915

ndr->depth--;

3916

}

3917

ndr->depth--;

3918

ndr->depth--;

3919

}

3920

3921

static enum ndr_err_code ndr_push_wkssvc_NetWkstaTransportCtr(struct ndr_push *ndr, int ndr_flags, const union wkssvc_NetWkstaTransportCtr *r)

3922

{

3923

if (ndr_flags & NDR_SCALARS) {

3924

int level = ndr_push_get_switch_value(ndr, r);

3925

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

3926

switch (level) {

3927

case 0: {

3928

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

3929

break; }

3930

3931

default:

3932

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

3933

}

3934

}

3935

if (ndr_flags & NDR_BUFFERS) {

3936

int level = ndr_push_get_switch_value(ndr, r);

3937

switch (level) {

3938

case 0:

3939

if (r->ctr0) {

3940

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

3941

}

3942

break;

3943

3944

default:

3945

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

3946

}

3947

}

3948

return NDR_ERR_SUCCESS;

3949

}

3950

3951

static enum ndr_err_code ndr_pull_wkssvc_NetWkstaTransportCtr(struct ndr_pull *ndr, int ndr_flags, union wkssvc_NetWkstaTransportCtr *r)

3952

{

3953

int level;

3954

uint32_t _level;

3955

TALLOC_CTX *_mem_save_ctr0_0;

3956

level = ndr_pull_get_switch_value(ndr, r);

3957

if (ndr_flags & NDR_SCALARS) {

3958

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

3959

if (_level != level) {

3960

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

3961

}

3962

switch (level) {

3963

case 0: {

3964

uint32_t _ptr_ctr0;

3965

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_ctr0));

3966

if (_ptr_ctr0) {

3967

NDR_PULL_ALLOC(ndr, r->ctr0);

3968

} else {

3969

r->ctr0 = NULL;

3970

}

3971

break; }

3972

3973

default:

3974

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

3975

}

3976

}

3977

if (ndr_flags & NDR_BUFFERS) {

3978

switch (level) {

3979

case 0:

3980

if (r->ctr0) {

3981

_mem_save_ctr0_0 = NDR_PULL_GET_MEM_CTX(ndr);

3982

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

3983

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

3984

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ctr0_0, 0);

3985

}

3986

break;

3987

3988

default:

3989

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

3990

}

3991

}

3992

return NDR_ERR_SUCCESS;

3993

}

3994

3995

_PUBLIC_ void ndr_print_wkssvc_NetWkstaTransportCtr(struct ndr_print *ndr, const char *name, const union wkssvc_NetWkstaTransportCtr *r)

3996

{

3997

int level;

3998

level = ndr_print_get_switch_value(ndr, r);

3999

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

4000

switch (level) {

4001

case 0:

4002

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

4003

ndr->depth++;

4004

if (r->ctr0) {

4005

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

4006

}

4007

ndr->depth--;

4008

break;

4009

4010

default:

4011

ndr_print_bad_level(ndr, name, level);

4012

}

4013

}

4014

4015

static enum ndr_err_code ndr_push_wkssvc_NetWkstaTransportInfo(struct ndr_push *ndr, int ndr_flags, const struct wkssvc_NetWkstaTransportInfo *r)

4016

{

4017

if (ndr_flags & NDR_SCALARS) {

4018

NDR_CHECK(ndr_push_align(ndr, 4));

4019

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

4020

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

4021

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

4022

}

4023

if (ndr_flags & NDR_BUFFERS) {

4024

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

4025

}

4026

return NDR_ERR_SUCCESS;

4027

}

4028

4029

static enum ndr_err_code ndr_pull_wkssvc_NetWkstaTransportInfo(struct ndr_pull *ndr, int ndr_flags, struct wkssvc_NetWkstaTransportInfo *r)

4030

{

4031

if (ndr_flags & NDR_SCALARS) {

4032

NDR_CHECK(ndr_pull_align(ndr, 4));

4033

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

4034

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

4035

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

4036

}

4037

if (ndr_flags & NDR_BUFFERS) {

4038

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

4039

}

4040

return NDR_ERR_SUCCESS;

4041

}

4042

4043

_PUBLIC_ void ndr_print_wkssvc_NetWkstaTransportInfo(struct ndr_print *ndr, const char *name, const struct wkssvc_NetWkstaTransportInfo *r)

4044

{

4045

ndr_print_struct(ndr, name, "wkssvc_NetWkstaTransportInfo");

4046

ndr->depth++;

4047

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

4048

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

4049

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

4050

ndr->depth--;

4051

}

4052

4053

static enum ndr_err_code ndr_push_wkssvc_NetrUseInfo3(struct ndr_push *ndr, int ndr_flags, const struct wkssvc_NetrUseInfo3 *r)

4054

{

4055

if (ndr_flags & NDR_SCALARS) {

4056

NDR_CHECK(ndr_push_align(ndr, 4));

4057

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

4058

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

4059

}

4060

if (ndr_flags & NDR_BUFFERS) {

4061

if (r->unknown1) {

4062

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

4063

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

4064

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

4065

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

4066

}

4067

if (r->unknown2) {

4068

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

4069

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

4070

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

4071

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

4072

}

4073

}

4074

return NDR_ERR_SUCCESS;

4075

}

4076

4077

static enum ndr_err_code ndr_pull_wkssvc_NetrUseInfo3(struct ndr_pull *ndr, int ndr_flags, struct wkssvc_NetrUseInfo3 *r)

4078

{

4079

uint32_t _ptr_unknown1;

4080

TALLOC_CTX *_mem_save_unknown1_0;

4081

uint32_t _ptr_unknown2;

4082

TALLOC_CTX *_mem_save_unknown2_0;

4083

if (ndr_flags & NDR_SCALARS) {

4084

NDR_CHECK(ndr_pull_align(ndr, 4));

4085

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_unknown1));

4086

if (_ptr_unknown1) {

4087

NDR_PULL_ALLOC(ndr, r->unknown1);

4088

} else {

4089

r->unknown1 = NULL;

4090

}

4091

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_unknown2));

4092

if (_ptr_unknown2) {

4093

NDR_PULL_ALLOC(ndr, r->unknown2);

4094

} else {

4095

r->unknown2 = NULL;

4096

}

4097

}

4098

if (ndr_flags & NDR_BUFFERS) {

4099

if (r->unknown1) {

4100

_mem_save_unknown1_0 = NDR_PULL_GET_MEM_CTX(ndr);

4101

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

4102

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

4103

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

4104

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

4105

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

4106

}

4107

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

4108

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

4109

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_unknown1_0, 0);

4110

}

4111

if (r->unknown2) {

4112

_mem_save_unknown2_0 = NDR_PULL_GET_MEM_CTX(ndr);

4113

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

4114

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

4115

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

4116

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

4117

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

4118

}

4119

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

4120

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

4121

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_unknown2_0, 0);

4122

}

4123

}

4124

return NDR_ERR_SUCCESS;

4125

}

4126

4127

_PUBLIC_ void ndr_print_wkssvc_NetrUseInfo3(struct ndr_print *ndr, const char *name, const struct wkssvc_NetrUseInfo3 *r)

4128

{

4129

ndr_print_struct(ndr, name, "wkssvc_NetrUseInfo3");

4130

ndr->depth++;

4131

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

4132

ndr->depth++;

4133

if (r->unknown1) {

4134

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

4135

}

4136

ndr->depth--;

4137

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

4138

ndr->depth++;

4139

if (r->unknown2) {

4140

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

4141

}

4142

ndr->depth--;

4143

ndr->depth--;

4144

}

4145

4146

static enum ndr_err_code ndr_push_wkssvc_NetrUseInfo2(struct ndr_push *ndr, int ndr_flags, const struct wkssvc_NetrUseInfo2 *r)

4147

{

4148

if (ndr_flags & NDR_SCALARS) {

4149

NDR_CHECK(ndr_push_align(ndr, 4));

4150

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

4151

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

4152

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

4153

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

4154

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

4155

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

4156

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

4157

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

4158

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

4159

}

4160

if (ndr_flags & NDR_BUFFERS) {

4161

if (r->local) {

4162

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

4163

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

4164

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

4165

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

4166

}

4167

if (r->remote) {

4168

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

4169

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

4170

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

4171

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

4172

}

4173

if (r->password) {

4174

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

4175

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

4176

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

4177

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

4178

}

4179

if (r->user_name) {

4180

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

4181

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

4182

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

4183

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

4184

}

4185

if (r->domain_name) {

4186

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

4187

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

4188

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

4189

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

4190

}

4191

}

4192

return NDR_ERR_SUCCESS;

4193

}

4194

4195

static enum ndr_err_code ndr_pull_wkssvc_NetrUseInfo2(struct ndr_pull *ndr, int ndr_flags, struct wkssvc_NetrUseInfo2 *r)

4196

{

4197

uint32_t _ptr_local;

4198

TALLOC_CTX *_mem_save_local_0;

4199

uint32_t _ptr_remote;

4200

TALLOC_CTX *_mem_save_remote_0;

4201

uint32_t _ptr_password;

4202

TALLOC_CTX *_mem_save_password_0;

4203

uint32_t _ptr_user_name;

4204

TALLOC_CTX *_mem_save_user_name_0;

4205

uint32_t _ptr_domain_name;

4206

TALLOC_CTX *_mem_save_domain_name_0;

4207

if (ndr_flags & NDR_SCALARS) {

4208

NDR_CHECK(ndr_pull_align(ndr, 4));

4209

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_local));

4210

if (_ptr_local) {

4211

NDR_PULL_ALLOC(ndr, r->local);

4212

} else {

4213

r->local = NULL;

4214

}

4215

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_remote));

4216

if (_ptr_remote) {

4217

NDR_PULL_ALLOC(ndr, r->remote);

4218

} else {

4219

r->remote = NULL;

4220

}

4221

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_password));

4222

if (_ptr_password) {

4223

NDR_PULL_ALLOC(ndr, r->password);

4224

} else {

4225

r->password = NULL;

4226

}

4227

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

4228

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

4229

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

4230

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

4231

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_user_name));

4232

if (_ptr_user_name) {

4233

NDR_PULL_ALLOC(ndr, r->user_name);

4234

} else {

4235

r->user_name = NULL;

4236

}

4237

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_domain_name));

4238

if (_ptr_domain_name) {

4239

NDR_PULL_ALLOC(ndr, r->domain_name);

4240

} else {

4241

r->domain_name = NULL;

4242

}

4243

}

4244

if (ndr_flags & NDR_BUFFERS) {

4245

if (r->local) {

4246

_mem_save_local_0 = NDR_PULL_GET_MEM_CTX(ndr);

4247

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

4248

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

4249

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

4250

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

4251

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

4252

}

4253

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

4254

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

4255

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_local_0, 0);

4256

}

4257

if (r->remote) {

4258

_mem_save_remote_0 = NDR_PULL_GET_MEM_CTX(ndr);

4259

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

4260

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

4261

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

4262

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

4263

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

4264

}

4265

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

4266

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

4267

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_remote_0, 0);

4268

}

4269

if (r->password) {

4270

_mem_save_password_0 = NDR_PULL_GET_MEM_CTX(ndr);

4271

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

4272

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

4273

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

4274

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

4275

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));

4276

}

4277

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

4278

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

4279

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_password_0, 0);

4280

}

4281

if (r->user_name) {

4282

_mem_save_user_name_0 = NDR_PULL_GET_MEM_CTX(ndr);

4283

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

4284

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

4285

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

4286

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

4287

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_name), ndr_get_array_length(ndr, &r->user_name));

4288

}

4289

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

4290

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

4291

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_name_0, 0);

4292

}

4293

if (r->domain_name) {

4294

_mem_save_domain_name_0 = NDR_PULL_GET_MEM_CTX(ndr);

4295

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

4296

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

4297

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

4298

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

4299

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_name), ndr_get_array_length(ndr, &r->domain_name));

4300

}

4301

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

4302

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

4303

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domain_name_0, 0);

4304

}

4305

}

4306

return NDR_ERR_SUCCESS;

4307

}

4308

4309

_PUBLIC_ void ndr_print_wkssvc_NetrUseInfo2(struct ndr_print *ndr, const char *name, const struct wkssvc_NetrUseInfo2 *r)

4310

{

4311

ndr_print_struct(ndr, name, "wkssvc_NetrUseInfo2");

4312

ndr->depth++;

4313

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

4314

ndr->depth++;

4315

if (r->local) {

4316

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

4317

}

4318

ndr->depth--;

4319

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

4320

ndr->depth++;

4321

if (r->remote) {

4322

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

4323

}

4324

ndr->depth--;

4325

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

4326

ndr->depth++;

4327

if (r->password) {

4328

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

4329

}

4330

ndr->depth--;

4331

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

4332

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

4333

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

4334

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

4335

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

4336

ndr->depth++;

4337

if (r->user_name) {

4338

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

4339

}

4340

ndr->depth--;

4341

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

4342

ndr->depth++;

4343

if (r->domain_name) {

4344

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

4345

}

4346

ndr->depth--;

4347

ndr->depth--;

4348

}

4349

4350

static enum ndr_err_code ndr_push_wkssvc_NetrUseInfo1(struct ndr_push *ndr, int ndr_flags, const struct wkssvc_NetrUseInfo1 *r)

4351

{

4352

if (ndr_flags & NDR_SCALARS) {

4353

NDR_CHECK(ndr_push_align(ndr, 4));

4354

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

4355

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

4356

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

4357

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

4358

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

4359

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

4360

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

4361

}

4362

if (ndr_flags & NDR_BUFFERS) {

4363

if (r->local) {

4364

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

4365

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

4366

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

4367

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

4368

}

4369

if (r->remote) {

4370

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

4371

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

4372

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

4373

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

4374

}

4375

if (r->password) {

4376

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

4377

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

4378

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

4379

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

4380

}

4381

}

4382

return NDR_ERR_SUCCESS;

4383

}

4384

4385

static enum ndr_err_code ndr_pull_wkssvc_NetrUseInfo1(struct ndr_pull *ndr, int ndr_flags, struct wkssvc_NetrUseInfo1 *r)

4386

{

4387

uint32_t _ptr_local;

4388

TALLOC_CTX *_mem_save_local_0;

4389

uint32_t _ptr_remote;

4390

TALLOC_CTX *_mem_save_remote_0;

4391

uint32_t _ptr_password;

4392

TALLOC_CTX *_mem_save_password_0;

4393

if (ndr_flags & NDR_SCALARS) {

4394

NDR_CHECK(ndr_pull_align(ndr, 4));

4395

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_local));

4396

if (_ptr_local) {

4397

NDR_PULL_ALLOC(ndr, r->local);

4398

} else {

4399

r->local = NULL;

4400

}

4401

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_remote));

4402

if (_ptr_remote) {

4403

NDR_PULL_ALLOC(ndr, r->remote);

4404

} else {

4405

r->remote = NULL;

4406

}

4407

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_password));

4408

if (_ptr_password) {

4409

NDR_PULL_ALLOC(ndr, r->password);

4410

} else {

4411

r->password = NULL;

4412

}

4413

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

4414

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

4415

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

4416

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

4417

}

4418

if (ndr_flags & NDR_BUFFERS) {

4419

if (r->local) {

4420

_mem_save_local_0 = NDR_PULL_GET_MEM_CTX(ndr);

4421

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

4422

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

4423

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

4424

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

4425

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

4426

}

4427

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

4428

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

4429

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_local_0, 0);

4430

}

4431

if (r->remote) {

4432

_mem_save_remote_0 = NDR_PULL_GET_MEM_CTX(ndr);

4433

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

4434

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

4435

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

4436

if (ndr_get_array_length(ndr, &r->remote) > ndr_get_array_size(ndr, &r->remote)) {

4437

return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->remote), ndr_get_array_length(ndr, &r->remote));

4438

}

4439

NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->remote), sizeof(uint16_t)));

4440

NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->remote, ndr_get_array_length(ndr, &r->remote), sizeof(uint16_t), CH_UTF16));

4441

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_remote_0, 0);

4442

}

4443

if (r->password) {

4444

_mem_save_password_0 = NDR_PULL_GET_MEM_CTX(ndr);

4445

NDR_PULL_SET_MEM_CTX(ndr, r->password, 0);

4446

NDR_CHECK(ndr_pull_array_size(ndr, &r->password));

4447

NDR_CHECK(ndr_pull_array_length(ndr, &r->password));

4448

if (ndr_get_array_length(ndr, &r->password) > ndr_get_array_size(ndr, &r->password)) {

4449

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));

4450

}

4451

NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->password), sizeof(uint16_t)));

4452

NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->password, ndr_get_array_length(ndr, &r->password), sizeof(uint16_t), CH_UTF16));

4453

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_password_0, 0);

4454

}

4455

}

4456

return NDR_ERR_SUCCESS;

4457

}

4458

4459

_PUBLIC_ void ndr_print_wkssvc_NetrUseInfo1(struct ndr_print *ndr, const char *name, const struct wkssvc_NetrUseInfo1 *r)

4460

{

4461

ndr_print_struct(ndr, name, "wkssvc_NetrUseInfo1");

4462

ndr->depth++;

4463

ndr_print_ptr(ndr, "local", r->local);

4464

ndr->depth++;

4465

if (r->local) {

4466

ndr_print_string(ndr, "local", r->local);

4467

}

4468

ndr->depth--;

4469

ndr_print_ptr(ndr, "remote", r->remote);

4470

ndr->depth++;

4471

if (r->remote) {

4472

ndr_print_string(ndr, "remote", r->remote);

4473

}

4474

ndr->depth--;

4475

ndr_print_ptr(ndr, "password", r->password);

4476

ndr->depth++;

4477

if (r->password) {

4478

ndr_print_string(ndr, "password", r->password);

4479

}

4480

ndr->depth--;

4481

ndr_print_uint32(ndr, "status", r->status);

4482

ndr_print_uint32(ndr, "asg_type", r->asg_type);

4483

ndr_print_uint32(ndr, "ref_count", r->ref_count);

4484

ndr_print_uint32(ndr, "use_count", r->use_count);

4485

ndr->depth--;

4486

}

4487

4488

static enum ndr_err_code ndr_push_wkssvc_NetrUseInfo0(struct ndr_push *ndr, int ndr_flags, const struct wkssvc_NetrUseInfo0 *r)

4489

{

4490

if (ndr_flags & NDR_SCALARS) {

4491

NDR_CHECK(ndr_push_align(ndr, 4));

4492

NDR_CHECK(ndr_push_unique_ptr(ndr, r->local));

4493

NDR_CHECK(ndr_push_unique_ptr(ndr, r->remote));

4494

}

4495

if (ndr_flags & NDR_BUFFERS) {

4496

if (r->local) {

4497

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->local, CH_UTF16)));

4498

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));

4499

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->local, CH_UTF16)));

4500

NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->local, ndr_charset_length(r->local, CH_UTF16), sizeof(uint16_t), CH_UTF16));

4501

}

4502

if (r->remote) {

4503

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->remote, CH_UTF16)));

4504

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));

4505

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->remote, CH_UTF16)));

4506

NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->remote, ndr_charset_length(r->remote, CH_UTF16), sizeof(uint16_t), CH_UTF16));

4507

}

4508

}

4509

return NDR_ERR_SUCCESS;

4510

}

4511

4512

static enum ndr_err_code ndr_pull_wkssvc_NetrUseInfo0(struct ndr_pull *ndr, int ndr_flags, struct wkssvc_NetrUseInfo0 *r)

4513

{

4514

uint32_t _ptr_local;

4515

TALLOC_CTX *_mem_save_local_0;

4516

uint32_t _ptr_remote;

4517

TALLOC_CTX *_mem_save_remote_0;

4518

if (ndr_flags & NDR_SCALARS) {

4519

NDR_CHECK(ndr_pull_align(ndr, 4));

4520

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_local));

4521

if (_ptr_local) {

4522

NDR_PULL_ALLOC(ndr, r->local);

4523

} else {

4524

r->local = NULL;

4525

}

4526

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_remote));

4527

if (_ptr_remote) {

4528

NDR_PULL_ALLOC(ndr, r->remote);

4529

} else {

4530

r->remote = NULL;

4531

}

4532

}

4533

if (ndr_flags & NDR_BUFFERS) {

4534

if (r->local) {

4535

_mem_save_local_0 = NDR_PULL_GET_MEM_CTX(ndr);

4536

NDR_PULL_SET_MEM_CTX(ndr, r->local, 0);

4537

NDR_CHECK(ndr_pull_array_size(ndr, &r->local));

4538

NDR_CHECK(ndr_pull_array_length(ndr, &r->local));

4539

if (ndr_get_array_length(ndr, &r->local) > ndr_get_array_size(ndr, &r->local)) {

4540

return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->local), ndr_get_array_length(ndr, &r->local));

4541

}

4542

NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->local), sizeof(uint16_t)));

4543

NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->local, ndr_get_array_length(ndr, &r->local), sizeof(uint16_t), CH_UTF16));

4544

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_local_0, 0);

4545

}

4546

if (r->remote) {

4547

_mem_save_remote_0 = NDR_PULL_GET_MEM_CTX(ndr);

4548

NDR_PULL_SET_MEM_CTX(ndr, r->remote, 0);

4549

NDR_CHECK(ndr_pull_array_size(ndr, &r->remote));

4550

NDR_CHECK(ndr_pull_array_length(ndr, &r->remote));

4551

if (ndr_get_array_length(ndr, &r->remote) > ndr_get_array_size(ndr, &r->remote)) {

4552

return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->remote), ndr_get_array_length(ndr, &r->remote));

4553

}

4554

NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->remote), sizeof(uint16_t)));

4555

NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->remote, ndr_get_array_length(ndr, &r->remote), sizeof(uint16_t), CH_UTF16));

4556

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_remote_0, 0);

4557

}

4558

}

4559

return NDR_ERR_SUCCESS;

4560

}

4561

4562

_PUBLIC_ void ndr_print_wkssvc_NetrUseInfo0(struct ndr_print *ndr, const char *name, const struct wkssvc_NetrUseInfo0 *r)

4563

{

4564

ndr_print_struct(ndr, name, "wkssvc_NetrUseInfo0");

4565

ndr->depth++;

4566

ndr_print_ptr(ndr, "local", r->local);

4567

ndr->depth++;

4568

if (r->local) {

4569

ndr_print_string(ndr, "local", r->local);

4570

}

4571

ndr->depth--;

4572

ndr_print_ptr(ndr, "remote", r->remote);

4573

ndr->depth++;

4574

if (r->remote) {

4575

ndr_print_string(ndr, "remote", r->remote);

4576

}

4577

ndr->depth--;

4578

ndr->depth--;

4579

}

4580

4581

static enum ndr_err_code ndr_push_wkssvc_NetrUseGetInfoCtr(struct ndr_push *ndr, int ndr_flags, const union wkssvc_NetrUseGetInfoCtr *r)

4582

{

4583

if (ndr_flags & NDR_SCALARS) {

4584

int level = ndr_push_get_switch_value(ndr, r);

4585

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));

4586

switch (level) {

4587

case 0: {

4588

NDR_CHECK(ndr_push_unique_ptr(ndr, r->info0));

4589

break; }

4590

4591

case 1: {

4592

NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1));

4593

break; }

4594

4595

case 2: {

4596

NDR_CHECK(ndr_push_unique_ptr(ndr, r->info2));

4597

break; }

4598

4599

case 3: {

4600

NDR_CHECK(ndr_push_unique_ptr(ndr, r->info3));

4601

break; }

4602

4603

default:

4604

return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);

4605

}

4606

}

4607

if (ndr_flags & NDR_BUFFERS) {

4608

int level = ndr_push_get_switch_value(ndr, r);

4609

switch (level) {

4610

case 0:

4611

if (r->info0) {

4612

NDR_CHECK(ndr_push_wkssvc_NetrUseInfo0(ndr, NDR_SCALARS|NDR_BUFFERS, r->info0));

4613

}

4614

break;

4615

4616

case 1:

4617

if (r->info1) {

4618

NDR_CHECK(ndr_push_wkssvc_NetrUseInfo1(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1));

4619

}

4620

break;

4621

4622

case 2:

4623

if (r->info2) {

4624

NDR_CHECK(ndr_push_wkssvc_NetrUseInfo2(ndr, NDR_SCALARS|NDR_BUFFERS, r->info2));

4625

}

4626

break;

4627

4628

case 3:

4629

if (r->info3) {

4630

NDR_CHECK(ndr_push_wkssvc_NetrUseInfo3(ndr, NDR_SCALARS|NDR_BUFFERS, r->info3));

4631

}

4632

break;

4633

4634

default:

4635

return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);

4636

}

4637

}

4638

return NDR_ERR_SUCCESS;

4639

}

4640

4641

static enum ndr_err_code ndr_pull_wkssvc_NetrUseGetInfoCtr(struct ndr_pull *ndr, int ndr_flags, union wkssvc_NetrUseGetInfoCtr *r)

4642

{

4643

int level;

4644

uint32_t _level;

4645

TALLOC_CTX *_mem_save_info0_0;

4646

TALLOC_CTX *_mem_save_info1_0;

4647

TALLOC_CTX *_mem_save_info2_0;

4648

TALLOC_CTX *_mem_save_info3_0;

4649

level = ndr_pull_get_switch_value(ndr, r);

4650

if (ndr_flags & NDR_SCALARS) {

4651

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));

4652

if (_level != level) {

4653

return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r", _level);

4654

}

4655

switch (level) {

4656

case 0: {

4657

uint32_t _ptr_info0;

4658

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info0));

4659

if (_ptr_info0) {

4660

NDR_PULL_ALLOC(ndr, r->info0);

4661

} else {

4662

r->info0 = NULL;

4663

}

4664

break; }

4665

4666

case 1: {

4667

uint32_t _ptr_info1;

4668

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1));

4669

if (_ptr_info1) {

4670

NDR_PULL_ALLOC(ndr, r->info1);

4671

} else {

4672

r->info1 = NULL;

4673

}

4674

break; }

4675

4676

case 2: {

4677

uint32_t _ptr_info2;

4678

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info2));

4679

if (_ptr_info2) {

4680

NDR_PULL_ALLOC(ndr, r->info2);

4681

} else {

4682

r->info2 = NULL;

4683

}

4684

break; }

4685

4686

case 3: {

4687

uint32_t _ptr_info3;

4688

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info3));

4689

if (_ptr_info3) {

4690

NDR_PULL_ALLOC(ndr, r->info3);

4691

} else {

4692

r->info3 = NULL;

4693

}

4694

break; }

4695

4696

default:

4697

return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);

4698

}

4699

}

4700

if (ndr_flags & NDR_BUFFERS) {

4701

switch (level) {

4702

case 0:

4703

if (r->info0) {

4704

_mem_save_info0_0 = NDR_PULL_GET_MEM_CTX(ndr);

4705

NDR_PULL_SET_MEM_CTX(ndr, r->info0, 0);

4706

NDR_CHECK(ndr_pull_wkssvc_NetrUseInfo0(ndr, NDR_SCALARS|NDR_BUFFERS, r->info0));

4707

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info0_0, 0);

4708

}

4709

break;

4710

4711

case 1:

4712

if (r->info1) {

4713

_mem_save_info1_0 = NDR_PULL_GET_MEM_CTX(ndr);

4714

NDR_PULL_SET_MEM_CTX(ndr, r->info1, 0);

4715

NDR_CHECK(ndr_pull_wkssvc_NetrUseInfo1(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1));

4716

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1_0, 0);

4717

}

4718

break;

4719

4720

case 2:

4721

if (r->info2) {

4722

_mem_save_info2_0 = NDR_PULL_GET_MEM_CTX(ndr);

4723

NDR_PULL_SET_MEM_CTX(ndr, r->info2, 0);

4724

NDR_CHECK(ndr_pull_wkssvc_NetrUseInfo2(ndr, NDR_SCALARS|NDR_BUFFERS, r->info2));

4725

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info2_0, 0);

4726

}

4727

break;

4728

4729

case 3:

4730

if (r->info3) {

4731

_mem_save_info3_0 = NDR_PULL_GET_MEM_CTX(ndr);

4732

NDR_PULL_SET_MEM_CTX(ndr, r->info3, 0);

4733

NDR_CHECK(ndr_pull_wkssvc_NetrUseInfo3(ndr, NDR_SCALARS|NDR_BUFFERS, r->info3));

4734

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info3_0, 0);

4735

}

4736

break;

4737

4738

default:

4739

return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);

4740

}

4741

}

4742

return NDR_ERR_SUCCESS;

4743

}

4744

4745

_PUBLIC_ void ndr_print_wkssvc_NetrUseGetInfoCtr(struct ndr_print *ndr, const char *name, const union wkssvc_NetrUseGetInfoCtr *r)

4746

{

4747

int level;

4748

level = ndr_print_get_switch_value(ndr, r);

4749

ndr_print_union(ndr, name, level, "wkssvc_NetrUseGetInfoCtr");

4750

switch (level) {

4751

case 0:

4752

ndr_print_ptr(ndr, "info0", r->info0);

4753

ndr->depth++;

4754

if (r->info0) {

4755

ndr_print_wkssvc_NetrUseInfo0(ndr, "info0", r->info0);

4756

}

4757

ndr->depth--;

4758

break;

4759

4760

case 1:

4761

ndr_print_ptr(ndr, "info1", r->info1);

4762

ndr->depth++;

4763

if (r->info1) {

4764

ndr_print_wkssvc_NetrUseInfo1(ndr, "info1", r->info1);

4765

}

4766

ndr->depth--;

4767

break;

4768

4769

case 2:

4770

ndr_print_ptr(ndr, "info2", r->info2);

4771

ndr->depth++;

4772

if (r->info2) {

4773

ndr_print_wkssvc_NetrUseInfo2(ndr, "info2", r->info2);

4774

}

4775

ndr->depth--;

4776

break;

4777

4778

case 3:

4779

ndr_print_ptr(ndr, "info3", r->info3);

4780

ndr->depth++;

4781

if (r->info3) {

4782

ndr_print_wkssvc_NetrUseInfo3(ndr, "info3", r->info3);

4783

}

4784

ndr->depth--;

4785

break;

4786

4787

default:

4788

ndr_print_bad_level(ndr, name, level);

4789

}

4790

}

4791

4792

static enum ndr_err_code ndr_push_wkssvc_NetrUseEnumCtr2(struct ndr_push *ndr, int ndr_flags, const struct wkssvc_NetrUseEnumCtr2 *r)

4793

{

4794

uint32_t cntr_array_1;

4795

if (ndr_flags & NDR_SCALARS) {

4796

NDR_CHECK(ndr_push_align(ndr, 4));

4797

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));

4798

NDR_CHECK(ndr_push_unique_ptr(ndr, r->array));

4799

}

4800

if (ndr_flags & NDR_BUFFERS) {

4801

if (r->array) {

4802

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));

4803

for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {

4804

NDR_CHECK(ndr_push_wkssvc_NetrUseInfo2(ndr, NDR_SCALARS, &r->array[cntr_array_1]));

4805

}

4806

for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {

4807

NDR_CHECK(ndr_push_wkssvc_NetrUseInfo2(ndr, NDR_BUFFERS, &r->array[cntr_array_1]));

4808

}

4809

}

4810

}

4811

return NDR_ERR_SUCCESS;

4812

}

4813

4814

static enum ndr_err_code ndr_pull_wkssvc_NetrUseEnumCtr2(struct ndr_pull *ndr, int ndr_flags, struct wkssvc_NetrUseEnumCtr2 *r)

4815

{

4816

uint32_t _ptr_array;

4817

uint32_t cntr_array_1;

4818

TALLOC_CTX *_mem_save_array_0;

4819

TALLOC_CTX *_mem_save_array_1;

4820

if (ndr_flags & NDR_SCALARS) {

4821

NDR_CHECK(ndr_pull_align(ndr, 4));

4822

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));

4823

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_array));

4824

if (_ptr_array) {

4825

NDR_PULL_ALLOC(ndr, r->array);

4826

} else {

4827

r->array = NULL;

4828

}

4829

}

4830

if (ndr_flags & NDR_BUFFERS) {

4831

if (r->array) {

4832

_mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);

4833

NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);

4834

NDR_CHECK(ndr_pull_array_size(ndr, &r->array));

4835

NDR_PULL_ALLOC_N(ndr, r->array, ndr_get_array_size(ndr, &r->array));

4836

_mem_save_array_1 = NDR_PULL_GET_MEM_CTX(ndr);

4837

NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);

4838

for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {

4839

NDR_CHECK(ndr_pull_wkssvc_NetrUseInfo2(ndr, NDR_SCALARS, &r->array[cntr_array_1]));

4840

}

4841

for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {

4842

NDR_CHECK(ndr_pull_wkssvc_NetrUseInfo2(ndr, NDR_BUFFERS, &r->array[cntr_array_1]));

4843

}

4844

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_1, 0);

4845

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);

4846

}

4847

if (r->array) {

4848

NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->array, r->count));

4849

}

4850

}

4851

return NDR_ERR_SUCCESS;

4852

}

4853

4854

_PUBLIC_ void ndr_print_wkssvc_NetrUseEnumCtr2(struct ndr_print *ndr, const char *name, const struct wkssvc_NetrUseEnumCtr2 *r)

4855

{

4856

uint32_t cntr_array_1;

4857

ndr_print_struct(ndr, name, "wkssvc_NetrUseEnumCtr2");

4858

ndr->depth++;

4859

ndr_print_uint32(ndr, "count", r->count);

4860

ndr_print_ptr(ndr, "array", r->array);

4861

ndr->depth++;

4862

if (r->array) {

4863

ndr->print(ndr, "%s: ARRAY(%d)", "array", (int)r->count);

4864

ndr->depth++;

4865

for (cntr_array_1=0;cntr_array_1<r->count;cntr_array_1++) {

4866

char *idx_1=NULL;

4867

if (asprintf(&idx_1, "[%d]", cntr_array_1) != -1) {

4868

ndr_print_wkssvc_NetrUseInfo2(ndr, "array", &r->array[cntr_array_1]);

4869

free(idx_1);

4870

}

4871

}

4872

ndr->depth--;

4873

}

4874

ndr->depth--;

4875

ndr->depth--;

4876

}

4877

4878

static enum ndr_err_code ndr_push_wkssvc_NetrUseEnumCtr1(struct ndr_push *ndr, int ndr_flags, const struct wkssvc_NetrUseEnumCtr1 *r)

4879

{

4880

uint32_t cntr_array_1;

4881

if (ndr_flags & NDR_SCALARS) {

4882

NDR_CHECK(ndr_push_align(ndr, 4));

4883

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));

4884

NDR_CHECK(ndr_push_unique_ptr(ndr, r->array));

4885

}

4886

if (ndr_flags & NDR_BUFFERS) {

4887

if (r->array) {

4888

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));

4889

for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {

4890

NDR_CHECK(ndr_push_wkssvc_NetrUseInfo1(ndr, NDR_SCALARS, &r->array[cntr_array_1]));

4891

}

4892

for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {

4893

NDR_CHECK(ndr_push_wkssvc_NetrUseInfo1(ndr, NDR_BUFFERS, &r->array[cntr_array_1]));

4894

}

4895

}

4896

}

4897

return NDR_ERR_SUCCESS;

4898

}

4899

4900

static enum ndr_err_code ndr_pull_wkssvc_NetrUseEnumCtr1(struct ndr_pull *ndr, int ndr_flags, struct wkssvc_NetrUseEnumCtr1 *r)

4901

{

4902

uint32_t _ptr_array;

4903

uint32_t cntr_array_1;

4904

TALLOC_CTX *_mem_save_array_0;

4905

TALLOC_CTX *_mem_save_array_1;

4906

if (ndr_flags & NDR_SCALARS) {

4907

NDR_CHECK(ndr_pull_align(ndr, 4));

4908

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));

4909

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_array));

4910

if (_ptr_array) {

4911

NDR_PULL_ALLOC(ndr, r->array);

4912

} else {

4913

r->array = NULL;

4914

}

4915

}

4916

if (ndr_flags & NDR_BUFFERS) {

4917

if (r->array) {

4918

_mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);

4919

NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);

4920

NDR_CHECK(ndr_pull_array_size(ndr, &r->array));

4921

NDR_PULL_ALLOC_N(ndr, r->array, ndr_get_array_size(ndr, &r->array));

4922

_mem_save_array_1 = NDR_PULL_GET_MEM_CTX(ndr);

4923

NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);

4924

for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {

4925

NDR_CHECK(ndr_pull_wkssvc_NetrUseInfo1(ndr, NDR_SCALARS, &r->array[cntr_array_1]));

4926

}

4927

for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {

4928

NDR_CHECK(ndr_pull_wkssvc_NetrUseInfo1(ndr, NDR_BUFFERS, &r->array[cntr_array_1]));

4929

}

4930

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_1, 0);

4931

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);

4932

}

4933

if (r->array) {

4934

NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->array, r->count));

4935

}

4936

}

4937

return NDR_ERR_SUCCESS;

4938

}

4939

4940

_PUBLIC_ void ndr_print_wkssvc_NetrUseEnumCtr1(struct ndr_print *ndr, const char *name, const struct wkssvc_NetrUseEnumCtr1 *r)

4941

{

4942

uint32_t cntr_array_1;

4943

ndr_print_struct(ndr, name, "wkssvc_NetrUseEnumCtr1");

4944

ndr->depth++;

4945

ndr_print_uint32(ndr, "count", r->count);

4946

ndr_print_ptr(ndr, "array", r->array);

4947

ndr->depth++;

4948

if (r->array) {

4949

ndr->print(ndr, "%s: ARRAY(%d)", "array", (int)r->count);

4950

ndr->depth++;

4951

for (cntr_array_1=0;cntr_array_1<r->count;cntr_array_1++) {

4952

char *idx_1=NULL;

4953

if (asprintf(&idx_1, "[%d]", cntr_array_1) != -1) {

4954

ndr_print_wkssvc_NetrUseInfo1(ndr, "array", &r->array[cntr_array_1]);

4955

free(idx_1);

4956

}

4957

}

4958

ndr->depth--;

4959

}

4960

ndr->depth--;

4961

ndr->depth--;

4962

}

4963

4964

static enum ndr_err_code ndr_push_wkssvc_NetrUseEnumCtr0(struct ndr_push *ndr, int ndr_flags, const struct wkssvc_NetrUseEnumCtr0 *r)

4965

{

4966

uint32_t cntr_array_1;

4967

if (ndr_flags & NDR_SCALARS) {

4968

NDR_CHECK(ndr_push_align(ndr, 4));

4969

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));

4970

NDR_CHECK(ndr_push_unique_ptr(ndr, r->array));

4971

}

4972

if (ndr_flags & NDR_BUFFERS) {

4973

if (r->array) {

4974

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));

4975

for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {

4976

NDR_CHECK(ndr_push_wkssvc_NetrUseInfo0(ndr, NDR_SCALARS, &r->array[cntr_array_1]));

4977

}

4978

for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {

4979

NDR_CHECK(ndr_push_wkssvc_NetrUseInfo0(ndr, NDR_BUFFERS, &r->array[cntr_array_1]));

4980

}

4981

}

4982

}

4983

return NDR_ERR_SUCCESS;

4984

}

4985

4986

static enum ndr_err_code ndr_pull_wkssvc_NetrUseEnumCtr0(struct ndr_pull *ndr, int ndr_flags, struct wkssvc_NetrUseEnumCtr0 *r)

4987

{

4988

uint32_t _ptr_array;

4989

uint32_t cntr_array_1;

4990

TALLOC_CTX *_mem_save_array_0;

4991

TALLOC_CTX *_mem_save_array_1;

4992

if (ndr_flags & NDR_SCALARS) {

4993

NDR_CHECK(ndr_pull_align(ndr, 4));

4994

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));

4995

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_array));

4996

if (_ptr_array) {

4997

NDR_PULL_ALLOC(ndr, r->array);

4998

} else {

4999

r->array = NULL;

5000

}

5001

}

5002

if (ndr_flags & NDR_BUFFERS) {

5003

if (r->array) {

5004

_mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);

5005

NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);

5006

NDR_CHECK(ndr_pull_array_size(ndr, &r->array));

5007

NDR_PULL_ALLOC_N(ndr, r->array, ndr_get_array_size(ndr, &r->array));

5008

_mem_save_array_1 = NDR_PULL_GET_MEM_CTX(ndr);

5009

NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);

5010

for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {

5011

NDR_CHECK(ndr_pull_wkssvc_NetrUseInfo0(ndr, NDR_SCALARS, &r->array[cntr_array_1]));

5012

}

5013

for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {

5014

NDR_CHECK(ndr_pull_wkssvc_NetrUseInfo0(ndr, NDR_BUFFERS, &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_wkssvc_NetrUseEnumCtr0(struct ndr_print *ndr, const char *name, const struct wkssvc_NetrUseEnumCtr0 *r)

5027

{

5028

uint32_t cntr_array_1;

5029

ndr_print_struct(ndr, name, "wkssvc_NetrUseEnumCtr0");

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_wkssvc_NetrUseInfo0(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_wkssvc_NetrUseEnumCtr(struct ndr_push *ndr, int ndr_flags, const union wkssvc_NetrUseEnumCtr *r)

5051

{

5052

if (ndr_flags & NDR_SCALARS) {

5053

int level = ndr_push_get_switch_value(ndr, r);

5054

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));

5055

switch (level) {

5056

case 0: {

5057

NDR_CHECK(ndr_push_unique_ptr(ndr, r->ctr0));

5058

break; }

5059

5060

case 1: {

5061

NDR_CHECK(ndr_push_unique_ptr(ndr, r->ctr1));

5062

break; }

5063

5064

case 2: {

5065

NDR_CHECK(ndr_push_unique_ptr(ndr, r->ctr2));

5066

break; }

5067

5068

default:

5069

return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);

5070

}

5071

}

5072

if (ndr_flags & NDR_BUFFERS) {

5073

int level = ndr_push_get_switch_value(ndr, r);

5074

switch (level) {

5075

case 0:

5076

if (r->ctr0) {

5077

NDR_CHECK(ndr_push_wkssvc_NetrUseEnumCtr0(ndr, NDR_SCALARS|NDR_BUFFERS, r->ctr0));

5078

}

5079

break;

5080

5081

case 1:

5082

if (r->ctr1) {

5083

NDR_CHECK(ndr_push_wkssvc_NetrUseEnumCtr1(ndr, NDR_SCALARS|NDR_BUFFERS, r->ctr1));

5084

}

5085

break;

5086

5087

case 2:

5088

if (r->ctr2) {

5089

NDR_CHECK(ndr_push_wkssvc_NetrUseEnumCtr2(ndr, NDR_SCALARS|NDR_BUFFERS, r->ctr2));

5090

}

5091

break;

5092

5093

default:

5094

return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);

5095

}

5096

}

5097

return NDR_ERR_SUCCESS;

5098

}

5099

5100

static enum ndr_err_code ndr_pull_wkssvc_NetrUseEnumCtr(struct ndr_pull *ndr, int ndr_flags, union wkssvc_NetrUseEnumCtr *r)

5101

{

5102

int level;

5103

uint32_t _level;

5104

TALLOC_CTX *_mem_save_ctr0_0;

5105

TALLOC_CTX *_mem_save_ctr1_0;

5106

TALLOC_CTX *_mem_save_ctr2_0;

5107

level = ndr_pull_get_switch_value(ndr, r);

5108

if (ndr_flags & NDR_SCALARS) {

5109

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));

5110

if (_level != level) {

5111

return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r", _level);

5112

}

5113

switch (level) {

5114

case 0: {

5115

uint32_t _ptr_ctr0;

5116

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_ctr0));

5117

if (_ptr_ctr0) {

5118

NDR_PULL_ALLOC(ndr, r->ctr0);

5119

} else {

5120

r->ctr0 = NULL;

5121

}

5122

break; }

5123

5124

case 1: {

5125

uint32_t _ptr_ctr1;

5126

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_ctr1));

5127

if (_ptr_ctr1) {

5128

NDR_PULL_ALLOC(ndr, r->ctr1);

5129

} else {

5130

r->ctr1 = NULL;

5131

}

5132

break; }

5133

5134

case 2: {

5135

uint32_t _ptr_ctr2;

5136

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_ctr2));

5137

if (_ptr_ctr2) {

5138

NDR_PULL_ALLOC(ndr, r->ctr2);

5139

} else {

5140

r->ctr2 = NULL;

5141

}

5142

break; }

5143

5144

default:

5145

return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);

5146

}

5147

}

5148

if (ndr_flags & NDR_BUFFERS) {

5149

switch (level) {

5150

case 0:

5151

if (r->ctr0) {

5152

_mem_save_ctr0_0 = NDR_PULL_GET_MEM_CTX(ndr);

5153

NDR_PULL_SET_MEM_CTX(ndr, r->ctr0, 0);

5154

NDR_CHECK(ndr_pull_wkssvc_NetrUseEnumCtr0(ndr, NDR_SCALARS|NDR_BUFFERS, r->ctr0));

5155

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ctr0_0, 0);

5156

}

5157

break;

5158

5159

case 1:

5160

if (r->ctr1) {

5161

_mem_save_ctr1_0 = NDR_PULL_GET_MEM_CTX(ndr);

5162

NDR_PULL_SET_MEM_CTX(ndr, r->ctr1, 0);

5163

NDR_CHECK(ndr_pull_wkssvc_NetrUseEnumCtr1(ndr, NDR_SCALARS|NDR_BUFFERS, r->ctr1));

5164

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ctr1_0, 0);

5165

}

5166

break;

5167

5168

case 2:

5169

if (r->ctr2) {

5170

_mem_save_ctr2_0 = NDR_PULL_GET_MEM_CTX(ndr);

5171

NDR_PULL_SET_MEM_CTX(ndr, r->ctr2, 0);

5172

NDR_CHECK(ndr_pull_wkssvc_NetrUseEnumCtr2(ndr, NDR_SCALARS|NDR_BUFFERS, r->ctr2));

5173

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ctr2_0, 0);

5174

}

5175

break;

5176

5177

default:

5178

return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);

5179

}

5180

}

5181

return NDR_ERR_SUCCESS;

5182

}

5183

5184

_PUBLIC_ void ndr_print_wkssvc_NetrUseEnumCtr(struct ndr_print *ndr, const char *name, const union wkssvc_NetrUseEnumCtr *r)

5185

{

5186

int level;

5187

level = ndr_print_get_switch_value(ndr, r);

5188

ndr_print_union(ndr, name, level, "wkssvc_NetrUseEnumCtr");

5189

switch (level) {

5190

case 0:

5191

ndr_print_ptr(ndr, "ctr0", r->ctr0);

5192

ndr->depth++;

5193

if (r->ctr0) {

5194

ndr_print_wkssvc_NetrUseEnumCtr0(ndr, "ctr0", r->ctr0);

5195

}

5196

ndr->depth--;

5197

break;

5198

5199

case 1:

5200

ndr_print_ptr(ndr, "ctr1", r->ctr1);

5201

ndr->depth++;

5202

if (r->ctr1) {

5203

ndr_print_wkssvc_NetrUseEnumCtr1(ndr, "ctr1", r->ctr1);

5204

}

5205

ndr->depth--;

5206

break;

5207

5208

case 2:

5209

ndr_print_ptr(ndr, "ctr2", r->ctr2);

5210

ndr->depth++;

5211

if (r->ctr2) {

5212

ndr_print_wkssvc_NetrUseEnumCtr2(ndr, "ctr2", r->ctr2);

5213

}

5214

ndr->depth--;

5215

break;

5216

5217

default:

5218

ndr_print_bad_level(ndr, name, level);

5219

}

5220

}

5221

5222

static enum ndr_err_code ndr_push_wkssvc_NetrUseEnumInfo(struct ndr_push *ndr, int ndr_flags, const struct wkssvc_NetrUseEnumInfo *r)

5223

{

5224

if (ndr_flags & NDR_SCALARS) {

5225

NDR_CHECK(ndr_push_align(ndr, 4));

5226

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->level));

5227

NDR_CHECK(ndr_push_set_switch_value(ndr, &r->ctr, r->level));

5228

NDR_CHECK(ndr_push_wkssvc_NetrUseEnumCtr(ndr, NDR_SCALARS, &r->ctr));

5229

}

5230

if (ndr_flags & NDR_BUFFERS) {

5231

NDR_CHECK(ndr_push_wkssvc_NetrUseEnumCtr(ndr, NDR_BUFFERS, &r->ctr));

5232

}

5233

return NDR_ERR_SUCCESS;

5234

}

5235

5236

static enum ndr_err_code ndr_pull_wkssvc_NetrUseEnumInfo(struct ndr_pull *ndr, int ndr_flags, struct wkssvc_NetrUseEnumInfo *r)

5237

{

5238

if (ndr_flags & NDR_SCALARS) {

5239

NDR_CHECK(ndr_pull_align(ndr, 4));

5240

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->level));

5241

NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->ctr, r->level));

5242

NDR_CHECK(ndr_pull_wkssvc_NetrUseEnumCtr(ndr, NDR_SCALARS, &r->ctr));

5243

}

5244

if (ndr_flags & NDR_BUFFERS) {

5245

NDR_CHECK(ndr_pull_wkssvc_NetrUseEnumCtr(ndr, NDR_BUFFERS, &r->ctr));

5246

}

5247

return NDR_ERR_SUCCESS;

5248

}

5249

5250

_PUBLIC_ void ndr_print_wkssvc_NetrUseEnumInfo(struct ndr_print *ndr, const char *name, const struct wkssvc_NetrUseEnumInfo *r)

5251

{

5252

ndr_print_struct(ndr, name, "wkssvc_NetrUseEnumInfo");

5253

ndr->depth++;

5254

ndr_print_uint32(ndr, "level", r->level);

5255

ndr_print_set_switch_value(ndr, &r->ctr, r->level);

5256

ndr_print_wkssvc_NetrUseEnumCtr(ndr, "ctr", &r->ctr);

5257

ndr->depth--;

5258

}

5259

5260

static enum ndr_err_code ndr_push_wkssvc_NetrWorkstationStatistics(struct ndr_push *ndr, int ndr_flags, const struct wkssvc_NetrWorkstationStatistics *r)

5261

{

5262

if (ndr_flags & NDR_SCALARS) {

5263

NDR_CHECK(ndr_push_align(ndr, 8));

5264

NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->unknown1));

5265

NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->unknown2));

5266

NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->unknown3));

5267

NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->unknown4));

5268

NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->unknown5));

5269

NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->unknown6));

5270

NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->unknown7));

5271

NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->unknown8));

5272

NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->unknown9));

5273

NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->unknown10));

5274

NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->unknown11));

5275

NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->unknown12));

5276

NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->unknown13));

5277

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown14));

5278

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown15));

5279

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown16));

5280

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown17));

5281

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown18));

5282

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown19));

5283

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown20));

5284

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown21));

5285

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown22));

5286

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown23));

5287

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown24));

5288

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown25));

5289

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown26));

5290

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown27));

5291

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown28));

5292

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown29));

5293

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown30));

5294

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown31));

5295

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown32));

5296

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown33));

5297

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown34));

5298

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown35));

5299

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown36));

5300

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown37));

5301

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown38));

5302

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown39));

5303

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown40));

5304

}

5305

if (ndr_flags & NDR_BUFFERS) {

5306

}

5307

return NDR_ERR_SUCCESS;

5308

}

5309

5310

static enum ndr_err_code ndr_pull_wkssvc_NetrWorkstationStatistics(struct ndr_pull *ndr, int ndr_flags, struct wkssvc_NetrWorkstationStatistics *r)

5311

{

5312

if (ndr_flags & NDR_SCALARS) {

5313

NDR_CHECK(ndr_pull_align(ndr, 8));

5314

NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->unknown1));

5315

NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->unknown2));

5316

NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->unknown3));

5317

NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->unknown4));

5318

NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->unknown5));

5319

NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->unknown6));

5320

NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->unknown7));

5321

NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->unknown8));

5322

NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->unknown9));

5323

NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->unknown10));

5324

NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->unknown11));

5325

NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->unknown12));

5326

NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->unknown13));

5327

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown14));

5328

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown15));

5329

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown16));

5330

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown17));

5331

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown18));

5332

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown19));

5333

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown20));

5334

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown21));

5335

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown22));

5336

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown23));

5337

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown24));

5338

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown25));

5339

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown26));

5340

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown27));

5341

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown28));

5342

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown29));

5343

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown30));

5344

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown31));

5345

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown32));

5346

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown33));

5347

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown34));

5348

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown35));

5349

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown36));

5350

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown37));

5351

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown38));

5352

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown39));

5353

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown40));

5354

}

5355

if (ndr_flags & NDR_BUFFERS) {

5356

}

5357

return NDR_ERR_SUCCESS;

5358

}

5359

5360

_PUBLIC_ void ndr_print_wkssvc_NetrWorkstationStatistics(struct ndr_print *ndr, const char *name, const struct wkssvc_NetrWorkstationStatistics *r)

5361

{

5362

ndr_print_struct(ndr, name, "wkssvc_NetrWorkstationStatistics");

5363

ndr->depth++;

5364

ndr_print_hyper(ndr, "unknown1", r->unknown1);

5365

ndr_print_hyper(ndr, "unknown2", r->unknown2);

5366

ndr_print_hyper(ndr, "unknown3", r->unknown3);

5367

ndr_print_hyper(ndr, "unknown4", r->unknown4);

5368

ndr_print_hyper(ndr, "unknown5", r->unknown5);

5369

ndr_print_hyper(ndr, "unknown6", r->unknown6);

5370

ndr_print_hyper(ndr, "unknown7", r->unknown7);

5371

ndr_print_hyper(ndr, "unknown8", r->unknown8);

5372

ndr_print_hyper(ndr, "unknown9", r->unknown9);

5373

ndr_print_hyper(ndr, "unknown10", r->unknown10);

5374

ndr_print_hyper(ndr, "unknown11", r->unknown11);

5375

ndr_print_hyper(ndr, "unknown12", r->unknown12);

5376

ndr_print_hyper(ndr, "unknown13", r->unknown13);

5377

ndr_print_uint32(ndr, "unknown14", r->unknown14);

5378

ndr_print_uint32(ndr, "unknown15", r->unknown15);

5379

ndr_print_uint32(ndr, "unknown16", r->unknown16);

5380

ndr_print_uint32(ndr, "unknown17", r->unknown17);

5381

ndr_print_uint32(ndr, "unknown18", r->unknown18);

5382

ndr_print_uint32(ndr, "unknown19", r->unknown19);

5383

ndr_print_uint32(ndr, "unknown20", r->unknown20);

5384

ndr_print_uint32(ndr, "unknown21", r->unknown21);

5385

ndr_print_uint32(ndr, "unknown22", r->unknown22);

5386

ndr_print_uint32(ndr, "unknown23", r->unknown23);

5387

ndr_print_uint32(ndr, "unknown24", r->unknown24);

5388

ndr_print_uint32(ndr, "unknown25", r->unknown25);

5389

ndr_print_uint32(ndr, "unknown26", r->unknown26);

5390

ndr_print_uint32(ndr, "unknown27", r->unknown27);

5391

ndr_print_uint32(ndr, "unknown28", r->unknown28);

5392

ndr_print_uint32(ndr, "unknown29", r->unknown29);

5393

ndr_print_uint32(ndr, "unknown30", r->unknown30);

5394

ndr_print_uint32(ndr, "unknown31", r->unknown31);

5395

ndr_print_uint32(ndr, "unknown32", r->unknown32);

5396

ndr_print_uint32(ndr, "unknown33", r->unknown33);

5397

ndr_print_uint32(ndr, "unknown34", r->unknown34);

5398

ndr_print_uint32(ndr, "unknown35", r->unknown35);

5399

ndr_print_uint32(ndr, "unknown36", r->unknown36);

5400

ndr_print_uint32(ndr, "unknown37", r->unknown37);

5401

ndr_print_uint32(ndr, "unknown38", r->unknown38);

5402

ndr_print_uint32(ndr, "unknown39", r->unknown39);

5403

ndr_print_uint32(ndr, "unknown40", r->unknown40);

5404

ndr->depth--;

5405

}

5406

5407

static enum ndr_err_code ndr_push_wkssvc_renameflags(struct ndr_push *ndr, int ndr_flags, uint32_t r)

5408

{

5409

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));

5410

return NDR_ERR_SUCCESS;

5411

}

5412

5413

static enum ndr_err_code ndr_pull_wkssvc_renameflags(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)

5414

{

5415

uint32_t v;

5416

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));

5417

*r = v;

5418

return NDR_ERR_SUCCESS;

5419

}

5420

5421

_PUBLIC_ void ndr_print_wkssvc_renameflags(struct ndr_print *ndr, const char *name, uint32_t r)

5422

{

5423

ndr_print_uint32(ndr, name, r);

5424

ndr->depth++;

5425

ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "WKSSVC_JOIN_FLAGS_ACCOUNT_CREATE", WKSSVC_JOIN_FLAGS_ACCOUNT_CREATE, r);

5426

ndr->depth--;

5427

}

5428

5429

static enum ndr_err_code ndr_push_wkssvc_NetValidateNameType(struct ndr_push *ndr, int ndr_flags, enum wkssvc_NetValidateNameType r)

5430

{

5431

NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r));

5432

return NDR_ERR_SUCCESS;

5433

}

5434

5435

static enum ndr_err_code ndr_pull_wkssvc_NetValidateNameType(struct ndr_pull *ndr, int ndr_flags, enum wkssvc_NetValidateNameType *r)

5436

{

5437

uint16_t v;

5438

NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &v));

5439

*r = v;

5440

return NDR_ERR_SUCCESS;

5441

}

5442

5443

_PUBLIC_ void ndr_print_wkssvc_NetValidateNameType(struct ndr_print *ndr, const char *name, enum wkssvc_NetValidateNameType r)

5444

{

5445

const char *val = NULL;

5446

5447

switch (r) {

5448

case NetSetupUnknown: val = "NetSetupUnknown"; break;

5449

case NetSetupMachine: val = "NetSetupMachine"; break;

5450

case NetSetupWorkgroup: val = "NetSetupWorkgroup"; break;

5451

case NetSetupDomain: val = "NetSetupDomain"; break;

5452

case NetSetupNonExistentDomain: val = "NetSetupNonExistentDomain"; break;

5453

case NetSetupDnsMachine: val = "NetSetupDnsMachine"; break;

5454

}

5455

ndr_print_enum(ndr, name, "ENUM", val, r);

5456

}

5457

5458

static enum ndr_err_code ndr_push_wkssvc_NetJoinStatus(struct ndr_push *ndr, int ndr_flags, enum wkssvc_NetJoinStatus r)

5459

{

5460

NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r));

5461

return NDR_ERR_SUCCESS;

5462

}

5463

5464

static enum ndr_err_code ndr_pull_wkssvc_NetJoinStatus(struct ndr_pull *ndr, int ndr_flags, enum wkssvc_NetJoinStatus *r)

5465

{

5466

uint16_t v;

5467

NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &v));

5468

*r = v;

5469

return NDR_ERR_SUCCESS;

5470

}

5471

5472

_PUBLIC_ void ndr_print_wkssvc_NetJoinStatus(struct ndr_print *ndr, const char *name, enum wkssvc_NetJoinStatus r)

5473

{

5474

const char *val = NULL;

5475

5476

switch (r) {

5477

case NET_SETUP_UNKNOWN_STATUS: val = "NET_SETUP_UNKNOWN_STATUS"; break;

5478

case NET_SETUP_UNJOINED: val = "NET_SETUP_UNJOINED"; break;

5479

case NET_SETUP_WORKGROUP_NAME: val = "NET_SETUP_WORKGROUP_NAME"; break;

5480

case NET_SETUP_DOMAIN_NAME: val = "NET_SETUP_DOMAIN_NAME"; break;

5481

}

5482

ndr_print_enum(ndr, name, "ENUM", val, r);

5483

}

5484

5485

static enum ndr_err_code ndr_push_wkssvc_PasswordBuffer(struct ndr_push *ndr, int ndr_flags, const struct wkssvc_PasswordBuffer *r)

5486

{

5487

{

5488

uint32_t _flags_save_STRUCT = ndr->flags;

5489

ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);

5490

if (ndr_flags & NDR_SCALARS) {

5491

NDR_CHECK(ndr_push_align(ndr, 1));

5492

NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->data, 524));

5493

}

5494

if (ndr_flags & NDR_BUFFERS) {

5495

}

5496

ndr->flags = _flags_save_STRUCT;

5497

}

5498

return NDR_ERR_SUCCESS;

5499

}

5500

5501

static enum ndr_err_code ndr_pull_wkssvc_PasswordBuffer(struct ndr_pull *ndr, int ndr_flags, struct wkssvc_PasswordBuffer *r)

5502

{

5503

{

5504

uint32_t _flags_save_STRUCT = ndr->flags;

5505

ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);

5506

if (ndr_flags & NDR_SCALARS) {

5507

NDR_CHECK(ndr_pull_align(ndr, 1));

5508

NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->data, 524));

5509

}

5510

if (ndr_flags & NDR_BUFFERS) {

5511

}

5512

ndr->flags = _flags_save_STRUCT;

5513

}

5514

return NDR_ERR_SUCCESS;

5515

}

5516

5517

_PUBLIC_ void ndr_print_wkssvc_PasswordBuffer(struct ndr_print *ndr, const char *name, const struct wkssvc_PasswordBuffer *r)

5518

{

5519

ndr_print_struct(ndr, name, "wkssvc_PasswordBuffer");

5520

{

5521

uint32_t _flags_save_STRUCT = ndr->flags;

5522

ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);

5523

ndr->depth++;

5524

ndr_print_array_uint8(ndr, "data", r->data, 524);

5525

ndr->depth--;

5526

ndr->flags = _flags_save_STRUCT;

5527

}

5528

}

5529

5530

static enum ndr_err_code ndr_push_wkssvc_joinflags(struct ndr_push *ndr, int ndr_flags, uint32_t r)

5531

{

5532

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));

5533

return NDR_ERR_SUCCESS;

5534

}

5535

5536

static enum ndr_err_code ndr_pull_wkssvc_joinflags(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)

5537

{

5538

uint32_t v;

5539

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));

5540

*r = v;

5541

return NDR_ERR_SUCCESS;

5542

}

5543

5544

_PUBLIC_ void ndr_print_wkssvc_joinflags(struct ndr_print *ndr, const char *name, uint32_t r)

5545

{

5546

ndr_print_uint32(ndr, name, r);

5547

ndr->depth++;

5548

ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "WKSSVC_JOIN_FLAGS_IGNORE_UNSUPPORTED_FLAGS", WKSSVC_JOIN_FLAGS_IGNORE_UNSUPPORTED_FLAGS, r);

5549

ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "WKSSVC_JOIN_FLAGS_JOIN_WITH_NEW_NAME", WKSSVC_JOIN_FLAGS_JOIN_WITH_NEW_NAME, r);

5550

ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "WKSSVC_JOIN_FLAGS_JOIN_DC_ACCOUNT", WKSSVC_JOIN_FLAGS_JOIN_DC_ACCOUNT, r);

5551

ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "WKSSVC_JOIN_FLAGS_DEFER_SPN", WKSSVC_JOIN_FLAGS_DEFER_SPN, r);

5552

ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "WKSSVC_JOIN_FLAGS_MACHINE_PWD_PASSED", WKSSVC_JOIN_FLAGS_MACHINE_PWD_PASSED, r);

5553

ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "WKSSVC_JOIN_FLAGS_JOIN_UNSECURE", WKSSVC_JOIN_FLAGS_JOIN_UNSECURE, r);

5554

ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "WKSSVC_JOIN_FLAGS_DOMAIN_JOIN_IF_JOINED", WKSSVC_JOIN_FLAGS_DOMAIN_JOIN_IF_JOINED, r);

5555

ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "WKSSVC_JOIN_FLAGS_WIN9X_UPGRADE", WKSSVC_JOIN_FLAGS_WIN9X_UPGRADE, r);

5556

ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "WKSSVC_JOIN_FLAGS_ACCOUNT_DELETE", WKSSVC_JOIN_FLAGS_ACCOUNT_DELETE, r);

5557

ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "WKSSVC_JOIN_FLAGS_ACCOUNT_CREATE", WKSSVC_JOIN_FLAGS_ACCOUNT_CREATE, r);

5558

ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "WKSSVC_JOIN_FLAGS_JOIN_TYPE", WKSSVC_JOIN_FLAGS_JOIN_TYPE, r);

5559

ndr->depth--;

5560

}

5561

5562

static enum ndr_err_code ndr_push_wkssvc_ComputerNameType(struct ndr_push *ndr, int ndr_flags, enum wkssvc_ComputerNameType r)

5563

{

5564

NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r));

5565

return NDR_ERR_SUCCESS;

5566

}

5567

5568

static enum ndr_err_code ndr_pull_wkssvc_ComputerNameType(struct ndr_pull *ndr, int ndr_flags, enum wkssvc_ComputerNameType *r)

5569

{

5570

uint16_t v;

5571

NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &v));

5572

*r = v;

5573

return NDR_ERR_SUCCESS;

5574

}

5575

5576

_PUBLIC_ void ndr_print_wkssvc_ComputerNameType(struct ndr_print *ndr, const char *name, enum wkssvc_ComputerNameType r)

5577

{

5578

const char *val = NULL;

5579

5580

switch (r) {

5581

case NetPrimaryComputerName: val = "NetPrimaryComputerName"; break;

5582

case NetAlternateComputerNames: val = "NetAlternateComputerNames"; break;

5583

case NetAllComputerNames: val = "NetAllComputerNames"; break;

5584

case NetComputerNameTypeMax: val = "NetComputerNameTypeMax"; break;

5585

}

5586

ndr_print_enum(ndr, name, "ENUM", val, r);

5587

}

5588

5589

static enum ndr_err_code ndr_push_wkssvc_ComputerNamesCtr(struct ndr_push *ndr, int ndr_flags, const struct wkssvc_ComputerNamesCtr *r)

5590

{

5591

uint32_t cntr_computer_name_1;

5592

if (ndr_flags & NDR_SCALARS) {

5593

NDR_CHECK(ndr_push_align(ndr, 4));

5594

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));

5595

NDR_CHECK(ndr_push_unique_ptr(ndr, r->computer_name));

5596

}

5597

if (ndr_flags & NDR_BUFFERS) {

5598

if (r->computer_name) {

5599

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));

5600

for (cntr_computer_name_1 = 0; cntr_computer_name_1 < r->count; cntr_computer_name_1++) {

5601

NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->computer_name[cntr_computer_name_1]));

5602

}

5603

for (cntr_computer_name_1 = 0; cntr_computer_name_1 < r->count; cntr_computer_name_1++) {

5604

NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->computer_name[cntr_computer_name_1]));

5605

}

5606

}

5607

}

5608

return NDR_ERR_SUCCESS;

5609

}

5610

5611

static enum ndr_err_code ndr_pull_wkssvc_ComputerNamesCtr(struct ndr_pull *ndr, int ndr_flags, struct wkssvc_ComputerNamesCtr *r)

5612

{

5613

uint32_t _ptr_computer_name;

5614

uint32_t cntr_computer_name_1;

5615

TALLOC_CTX *_mem_save_computer_name_0;

5616

TALLOC_CTX *_mem_save_computer_name_1;

5617

if (ndr_flags & NDR_SCALARS) {

5618

NDR_CHECK(ndr_pull_align(ndr, 4));

5619

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));

5620

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_computer_name));

5621

if (_ptr_computer_name) {

5622

NDR_PULL_ALLOC(ndr, r->computer_name);

5623

} else {

5624

r->computer_name = NULL;

5625

}

5626

}

5627

if (ndr_flags & NDR_BUFFERS) {

5628

if (r->computer_name) {

5629

_mem_save_computer_name_0 = NDR_PULL_GET_MEM_CTX(ndr);

5630

NDR_PULL_SET_MEM_CTX(ndr, r->computer_name, 0);

5631

NDR_CHECK(ndr_pull_array_size(ndr, &r->computer_name));

5632

NDR_PULL_ALLOC_N(ndr, r->computer_name, ndr_get_array_size(ndr, &r->computer_name));

5633

_mem_save_computer_name_1 = NDR_PULL_GET_MEM_CTX(ndr);

5634

NDR_PULL_SET_MEM_CTX(ndr, r->computer_name, 0);

5635

for (cntr_computer_name_1 = 0; cntr_computer_name_1 < r->count; cntr_computer_name_1++) {

5636

NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->computer_name[cntr_computer_name_1]));

5637

}

5638

for (cntr_computer_name_1 = 0; cntr_computer_name_1 < r->count; cntr_computer_name_1++) {

5639

NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->computer_name[cntr_computer_name_1]));

5640

}

5641

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_computer_name_1, 0);

5642

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_computer_name_0, 0);

5643

}

5644

if (r->computer_name) {

5645

NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->computer_name, r->count));

5646

}

5647

}

5648

return NDR_ERR_SUCCESS;

5649

}

5650

5651

_PUBLIC_ void ndr_print_wkssvc_ComputerNamesCtr(struct ndr_print *ndr, const char *name, const struct wkssvc_ComputerNamesCtr *r)

5652

{

5653

uint32_t cntr_computer_name_1;

5654

ndr_print_struct(ndr, name, "wkssvc_ComputerNamesCtr");

5655

ndr->depth++;

5656

ndr_print_uint32(ndr, "count", r->count);

5657

ndr_print_ptr(ndr, "computer_name", r->computer_name);

5658

ndr->depth++;

5659

if (r->computer_name) {

5660

ndr->print(ndr, "%s: ARRAY(%d)", "computer_name", (int)r->count);

5661

ndr->depth++;

5662

for (cntr_computer_name_1=0;cntr_computer_name_1<r->count;cntr_computer_name_1++) {

5663

char *idx_1=NULL;

5664

if (asprintf(&idx_1, "[%d]", cntr_computer_name_1) != -1) {

5665

ndr_print_lsa_String(ndr, "computer_name", &r->computer_name[cntr_computer_name_1]);

5666

free(idx_1);

5667

}

5668

}

5669

ndr->depth--;

5670

}

5671

ndr->depth--;

5672

ndr->depth--;

5673

}

5674

5675

static enum ndr_err_code ndr_push_wkssvc_NetWkstaGetInfo(struct ndr_push *ndr, int flags, const struct wkssvc_NetWkstaGetInfo *r)

5676

{

5677

if (flags & NDR_IN) {

5678

NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server_name));

5679

if (r->in.server_name) {

5680

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));

5681

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));

5682

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));

5683

NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server_name, ndr_charset_length(r->in.server_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));

5684

}

5685

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));

5686

}

5687

if (flags & NDR_OUT) {

5688

if (r->out.info == NULL) {

5689

return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");

5690

}

5691

NDR_CHECK(ndr_push_set_switch_value(ndr, r->out.info, r->in.level));

5692

NDR_CHECK(ndr_push_wkssvc_NetWkstaInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.info));

5693

NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));

5694

}

5695

return NDR_ERR_SUCCESS;

5696

}

5697

5698

static enum ndr_err_code ndr_pull_wkssvc_NetWkstaGetInfo(struct ndr_pull *ndr, int flags, struct wkssvc_NetWkstaGetInfo *r)

5699

{

5700

uint32_t _ptr_server_name;

5701

TALLOC_CTX *_mem_save_server_name_0;

5702

TALLOC_CTX *_mem_save_info_0;

5703

if (flags & NDR_IN) {

5704

ZERO_STRUCT(r->out);

5705

5706

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_name));

5707

if (_ptr_server_name) {

5708

NDR_PULL_ALLOC(ndr, r->in.server_name);

5709

} else {

5710

r->in.server_name = NULL;

5711

}

5712

if (r->in.server_name) {

5713

_mem_save_server_name_0 = NDR_PULL_GET_MEM_CTX(ndr);

5714

NDR_PULL_SET_MEM_CTX(ndr, r->in.server_name, 0);

5715

NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_name));

5716

NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_name));

5717

if (ndr_get_array_length(ndr, &r->in.server_name) > ndr_get_array_size(ndr, &r->in.server_name)) {

5718

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_name), ndr_get_array_length(ndr, &r->in.server_name));

5719

}

5720

NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server_name), sizeof(uint16_t)));

5721

NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server_name, ndr_get_array_length(ndr, &r->in.server_name), sizeof(uint16_t), CH_UTF16));

5722

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_name_0, 0);

5723

}

5724

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));

5725

NDR_PULL_ALLOC(ndr, r->out.info);

5726

ZERO_STRUCTP(r->out.info);

5727

}

5728

if (flags & NDR_OUT) {

5729

if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {

5730

NDR_PULL_ALLOC(ndr, r->out.info);

5731

}

5732

_mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);

5733

NDR_PULL_SET_MEM_CTX(ndr, r->out.info, LIBNDR_FLAG_REF_ALLOC);

5734

NDR_CHECK(ndr_pull_set_switch_value(ndr, r->out.info, r->in.level));

5735

NDR_CHECK(ndr_pull_wkssvc_NetWkstaInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.info));

5736

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, LIBNDR_FLAG_REF_ALLOC);

5737

NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));

5738

}

5739

return NDR_ERR_SUCCESS;

5740

}

5741

5742

_PUBLIC_ void ndr_print_wkssvc_NetWkstaGetInfo(struct ndr_print *ndr, const char *name, int flags, const struct wkssvc_NetWkstaGetInfo *r)

5743

{

5744

ndr_print_struct(ndr, name, "wkssvc_NetWkstaGetInfo");

5745

ndr->depth++;

5746

if (flags & NDR_SET_VALUES) {

5747

ndr->flags |= LIBNDR_PRINT_SET_VALUES;

5748

}

5749

if (flags & NDR_IN) {

5750

ndr_print_struct(ndr, "in", "wkssvc_NetWkstaGetInfo");

5751

ndr->depth++;

5752

ndr_print_ptr(ndr, "server_name", r->in.server_name);

5753

ndr->depth++;

5754

if (r->in.server_name) {

5755

ndr_print_string(ndr, "server_name", r->in.server_name);

5756

}

5757

ndr->depth--;

5758

ndr_print_uint32(ndr, "level", r->in.level);

5759

ndr->depth--;

5760

}

5761

if (flags & NDR_OUT) {

5762

ndr_print_struct(ndr, "out", "wkssvc_NetWkstaGetInfo");

5763

ndr->depth++;

5764

ndr_print_ptr(ndr, "info", r->out.info);

5765

ndr->depth++;

5766

ndr_print_set_switch_value(ndr, r->out.info, r->in.level);

5767

ndr_print_wkssvc_NetWkstaInfo(ndr, "info", r->out.info);

5768

ndr->depth--;

5769

ndr_print_WERROR(ndr, "result", r->out.result);

5770

ndr->depth--;

5771

}

5772

ndr->depth--;

5773

}

5774

5775

static enum ndr_err_code ndr_push_wkssvc_NetWkstaSetInfo(struct ndr_push *ndr, int flags, const struct wkssvc_NetWkstaSetInfo *r)

5776

{

5777

if (flags & NDR_IN) {

5778

NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server_name));

5779

if (r->in.server_name) {

5780

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));

5781

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));

5782

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));

5783

NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server_name, ndr_charset_length(r->in.server_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));

5784

}

5785

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));

5786

if (r->in.info == NULL) {

5787

return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");

5788

}

5789

NDR_CHECK(ndr_push_set_switch_value(ndr, r->in.info, r->in.level));

5790

NDR_CHECK(ndr_push_wkssvc_NetWkstaInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info));

5791

if (r->in.parm_error == NULL) {

5792

return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");

5793

}

5794

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->in.parm_error));

5795

}

5796

if (flags & NDR_OUT) {

5797

if (r->out.parm_error == NULL) {

5798

return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");

5799

}

5800

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.parm_error));

5801

NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));

5802

}

5803

return NDR_ERR_SUCCESS;

5804

}

5805

5806

static enum ndr_err_code ndr_pull_wkssvc_NetWkstaSetInfo(struct ndr_pull *ndr, int flags, struct wkssvc_NetWkstaSetInfo *r)

5807

{

5808

uint32_t _ptr_server_name;

5809

TALLOC_CTX *_mem_save_server_name_0;

5810

TALLOC_CTX *_mem_save_info_0;

5811

TALLOC_CTX *_mem_save_parm_error_0;

5812

if (flags & NDR_IN) {

5813

ZERO_STRUCT(r->out);

5814

5815

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_name));

5816

if (_ptr_server_name) {

5817

NDR_PULL_ALLOC(ndr, r->in.server_name);

5818

} else {

5819

r->in.server_name = NULL;

5820

}

5821

if (r->in.server_name) {

5822

_mem_save_server_name_0 = NDR_PULL_GET_MEM_CTX(ndr);

5823

NDR_PULL_SET_MEM_CTX(ndr, r->in.server_name, 0);

5824

NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_name));

5825

NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_name));

5826

if (ndr_get_array_length(ndr, &r->in.server_name) > ndr_get_array_size(ndr, &r->in.server_name)) {

5827

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_name), ndr_get_array_length(ndr, &r->in.server_name));

5828

}

5829

NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server_name), sizeof(uint16_t)));

5830

NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server_name, ndr_get_array_length(ndr, &r->in.server_name), sizeof(uint16_t), CH_UTF16));

5831

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_name_0, 0);

5832

}

5833

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));

5834

if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {

5835

NDR_PULL_ALLOC(ndr, r->in.info);

5836

}

5837

_mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);

5838

NDR_PULL_SET_MEM_CTX(ndr, r->in.info, LIBNDR_FLAG_REF_ALLOC);

5839

NDR_CHECK(ndr_pull_set_switch_value(ndr, r->in.info, r->in.level));

5840

NDR_CHECK(ndr_pull_wkssvc_NetWkstaInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info));

5841

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, LIBNDR_FLAG_REF_ALLOC);

5842

if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {

5843

NDR_PULL_ALLOC(ndr, r->in.parm_error);

5844

}

5845

_mem_save_parm_error_0 = NDR_PULL_GET_MEM_CTX(ndr);

5846

NDR_PULL_SET_MEM_CTX(ndr, r->in.parm_error, LIBNDR_FLAG_REF_ALLOC);

5847

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->in.parm_error));

5848

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_parm_error_0, LIBNDR_FLAG_REF_ALLOC);

5849

NDR_PULL_ALLOC(ndr, r->out.parm_error);

5850

*r->out.parm_error = *r->in.parm_error;

5851

}

5852

if (flags & NDR_OUT) {

5853

if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {

5854

NDR_PULL_ALLOC(ndr, r->out.parm_error);

5855

}

5856

_mem_save_parm_error_0 = NDR_PULL_GET_MEM_CTX(ndr);

5857

NDR_PULL_SET_MEM_CTX(ndr, r->out.parm_error, LIBNDR_FLAG_REF_ALLOC);

5858

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.parm_error));

5859

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_parm_error_0, LIBNDR_FLAG_REF_ALLOC);

5860

NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));

5861

}

5862

return NDR_ERR_SUCCESS;

5863

}

5864

5865

_PUBLIC_ void ndr_print_wkssvc_NetWkstaSetInfo(struct ndr_print *ndr, const char *name, int flags, const struct wkssvc_NetWkstaSetInfo *r)

5866

{

5867

ndr_print_struct(ndr, name, "wkssvc_NetWkstaSetInfo");

5868

ndr->depth++;

5869

if (flags & NDR_SET_VALUES) {

5870

ndr->flags |= LIBNDR_PRINT_SET_VALUES;

5871

}

5872

if (flags & NDR_IN) {

5873

ndr_print_struct(ndr, "in", "wkssvc_NetWkstaSetInfo");

5874

ndr->depth++;

5875

ndr_print_ptr(ndr, "server_name", r->in.server_name);

5876

ndr->depth++;

5877

if (r->in.server_name) {

5878

ndr_print_string(ndr, "server_name", r->in.server_name);

5879

}

5880

ndr->depth--;

5881

ndr_print_uint32(ndr, "level", r->in.level);

5882

ndr_print_ptr(ndr, "info", r->in.info);

5883

ndr->depth++;

5884

ndr_print_set_switch_value(ndr, r->in.info, r->in.level);

5885

ndr_print_wkssvc_NetWkstaInfo(ndr, "info", r->in.info);

5886

ndr->depth--;

5887

ndr_print_ptr(ndr, "parm_error", r->in.parm_error);

5888

ndr->depth++;

5889

ndr_print_uint32(ndr, "parm_error", *r->in.parm_error);

5890

ndr->depth--;

5891

ndr->depth--;

5892

}

5893

if (flags & NDR_OUT) {

5894

ndr_print_struct(ndr, "out", "wkssvc_NetWkstaSetInfo");

5895

ndr->depth++;

5896

ndr_print_ptr(ndr, "parm_error", r->out.parm_error);

5897

ndr->depth++;

5898

ndr_print_uint32(ndr, "parm_error", *r->out.parm_error);

5899

ndr->depth--;

5900

ndr_print_WERROR(ndr, "result", r->out.result);

5901

ndr->depth--;

5902

}

5903

ndr->depth--;

5904

}

5905

5906

static enum ndr_err_code ndr_push_wkssvc_NetWkstaEnumUsers(struct ndr_push *ndr, int flags, const struct wkssvc_NetWkstaEnumUsers *r)

5907

{

5908

if (flags & NDR_IN) {

5909

NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server_name));

5910

if (r->in.server_name) {

5911

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));

5912

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));

5913

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));

5914

NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server_name, ndr_charset_length(r->in.server_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));

5915

}

5916

if (r->in.info == NULL) {

5917

return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");

5918

}

5919

NDR_CHECK(ndr_push_wkssvc_NetWkstaEnumUsersInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info));

5920

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.prefmaxlen));

5921

NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.resume_handle));

5922

if (r->in.resume_handle) {

5923

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->in.resume_handle));

5924

}

5925

}

5926

if (flags & NDR_OUT) {

5927

if (r->out.info == NULL) {

5928

return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");

5929

}

5930

NDR_CHECK(ndr_push_wkssvc_NetWkstaEnumUsersInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.info));

5931

if (r->out.entries_read == NULL) {

5932

return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");

5933

}

5934

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.entries_read));

5935

NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.resume_handle));

5936

if (r->out.resume_handle) {

5937

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.resume_handle));

5938

}

5939

NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));

5940

}

5941

return NDR_ERR_SUCCESS;

5942

}

5943

5944

static enum ndr_err_code ndr_pull_wkssvc_NetWkstaEnumUsers(struct ndr_pull *ndr, int flags, struct wkssvc_NetWkstaEnumUsers *r)

5945

{

5946

uint32_t _ptr_server_name;

5947

uint32_t _ptr_resume_handle;

5948

TALLOC_CTX *_mem_save_server_name_0;

5949

TALLOC_CTX *_mem_save_info_0;

5950

TALLOC_CTX *_mem_save_entries_read_0;

5951

TALLOC_CTX *_mem_save_resume_handle_0;

5952

if (flags & NDR_IN) {

5953

ZERO_STRUCT(r->out);

5954

5955

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_name));

5956

if (_ptr_server_name) {

5957

NDR_PULL_ALLOC(ndr, r->in.server_name);

5958

} else {

5959

r->in.server_name = NULL;

5960

}

5961

if (r->in.server_name) {

5962

_mem_save_server_name_0 = NDR_PULL_GET_MEM_CTX(ndr);

5963

NDR_PULL_SET_MEM_CTX(ndr, r->in.server_name, 0);

5964

NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_name));

5965

NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_name));

5966

if (ndr_get_array_length(ndr, &r->in.server_name) > ndr_get_array_size(ndr, &r->in.server_name)) {

5967

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_name), ndr_get_array_length(ndr, &r->in.server_name));

5968

}

5969

NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server_name), sizeof(uint16_t)));

5970

NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server_name, ndr_get_array_length(ndr, &r->in.server_name), sizeof(uint16_t), CH_UTF16));

5971

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_name_0, 0);

5972

}

5973

if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {

5974

NDR_PULL_ALLOC(ndr, r->in.info);

5975

}

5976

_mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);

5977

NDR_PULL_SET_MEM_CTX(ndr, r->in.info, LIBNDR_FLAG_REF_ALLOC);

5978

NDR_CHECK(ndr_pull_wkssvc_NetWkstaEnumUsersInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info));

5979

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, LIBNDR_FLAG_REF_ALLOC);

5980

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.prefmaxlen));

5981

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_resume_handle));

5982

if (_ptr_resume_handle) {

5983

NDR_PULL_ALLOC(ndr, r->in.resume_handle);

5984

} else {

5985

r->in.resume_handle = NULL;

5986

}

5987

if (r->in.resume_handle) {

5988

_mem_save_resume_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);

5989

NDR_PULL_SET_MEM_CTX(ndr, r->in.resume_handle, 0);

5990

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->in.resume_handle));

5991

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_resume_handle_0, 0);

5992

}

5993

NDR_PULL_ALLOC(ndr, r->out.info);

5994

*r->out.info = *r->in.info;

5995

NDR_PULL_ALLOC(ndr, r->out.entries_read);

5996

ZERO_STRUCTP(r->out.entries_read);

5997

}

5998

if (flags & NDR_OUT) {

5999

if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {

6000

NDR_PULL_ALLOC(ndr, r->out.info);

6001

}

6002

_mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);

6003

NDR_PULL_SET_MEM_CTX(ndr, r->out.info, LIBNDR_FLAG_REF_ALLOC);

6004

NDR_CHECK(ndr_pull_wkssvc_NetWkstaEnumUsersInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.info));

6005

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, LIBNDR_FLAG_REF_ALLOC);

6006

if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {

6007

NDR_PULL_ALLOC(ndr, r->out.entries_read);

6008

}

6009

_mem_save_entries_read_0 = NDR_PULL_GET_MEM_CTX(ndr);

6010

NDR_PULL_SET_MEM_CTX(ndr, r->out.entries_read, LIBNDR_FLAG_REF_ALLOC);

6011

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.entries_read));

6012

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_entries_read_0, LIBNDR_FLAG_REF_ALLOC);

6013

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_resume_handle));

6014

if (_ptr_resume_handle) {

6015

NDR_PULL_ALLOC(ndr, r->out.resume_handle);

6016

} else {

6017

r->out.resume_handle = NULL;

6018

}

6019

if (r->out.resume_handle) {

6020

_mem_save_resume_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);

6021

NDR_PULL_SET_MEM_CTX(ndr, r->out.resume_handle, 0);

6022

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.resume_handle));

6023

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_resume_handle_0, 0);

6024

}

6025

NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));

6026

}

6027

return NDR_ERR_SUCCESS;

6028

}

6029

6030

_PUBLIC_ void ndr_print_wkssvc_NetWkstaEnumUsers(struct ndr_print *ndr, const char *name, int flags, const struct wkssvc_NetWkstaEnumUsers *r)

6031

{

6032

ndr_print_struct(ndr, name, "wkssvc_NetWkstaEnumUsers");

6033

ndr->depth++;

6034

if (flags & NDR_SET_VALUES) {

6035

ndr->flags |= LIBNDR_PRINT_SET_VALUES;

6036

}

6037

if (flags & NDR_IN) {

6038

ndr_print_struct(ndr, "in", "wkssvc_NetWkstaEnumUsers");

6039

ndr->depth++;

6040

ndr_print_ptr(ndr, "server_name", r->in.server_name);

6041

ndr->depth++;

6042

if (r->in.server_name) {

6043

ndr_print_string(ndr, "server_name", r->in.server_name);

6044

}

6045

ndr->depth--;

6046

ndr_print_ptr(ndr, "info", r->in.info);

6047

ndr->depth++;

6048

ndr_print_wkssvc_NetWkstaEnumUsersInfo(ndr, "info", r->in.info);

6049

ndr->depth--;

6050

ndr_print_uint32(ndr, "prefmaxlen", r->in.prefmaxlen);

6051

ndr_print_ptr(ndr, "resume_handle", r->in.resume_handle);

6052

ndr->depth++;

6053

if (r->in.resume_handle) {

6054

ndr_print_uint32(ndr, "resume_handle", *r->in.resume_handle);

6055

}

6056

ndr->depth--;

6057

ndr->depth--;

6058

}

6059

if (flags & NDR_OUT) {

6060

ndr_print_struct(ndr, "out", "wkssvc_NetWkstaEnumUsers");

6061

ndr->depth++;

6062

ndr_print_ptr(ndr, "info", r->out.info);

6063

ndr->depth++;

6064

ndr_print_wkssvc_NetWkstaEnumUsersInfo(ndr, "info", r->out.info);

6065

ndr->depth--;

6066

ndr_print_ptr(ndr, "entries_read", r->out.entries_read);

6067

ndr->depth++;

6068

ndr_print_uint32(ndr, "entries_read", *r->out.entries_read);

6069

ndr->depth--;

6070

ndr_print_ptr(ndr, "resume_handle", r->out.resume_handle);

6071

ndr->depth++;

6072

if (r->out.resume_handle) {

6073

ndr_print_uint32(ndr, "resume_handle", *r->out.resume_handle);

6074

}

6075

ndr->depth--;

6076

ndr_print_WERROR(ndr, "result", r->out.result);

6077

ndr->depth--;

6078

}

6079

ndr->depth--;

6080

}

6081

6082

static enum ndr_err_code ndr_push_wkssvc_NetrWkstaUserGetInfo(struct ndr_push *ndr, int flags, const struct wkssvc_NetrWkstaUserGetInfo *r)

6083

{

6084

if (flags & NDR_IN) {

6085

NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.unknown));

6086

if (r->in.unknown) {

6087

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.unknown, CH_UTF16)));

6088

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));

6089

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.unknown, CH_UTF16)));

6090

NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.unknown, ndr_charset_length(r->in.unknown, CH_UTF16), sizeof(uint16_t), CH_UTF16));

6091

}

6092

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));

6093

}

6094

if (flags & NDR_OUT) {

6095

if (r->out.info == NULL) {

6096

return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");

6097

}

6098

NDR_CHECK(ndr_push_set_switch_value(ndr, r->out.info, r->in.level));

6099

NDR_CHECK(ndr_push_wkssvc_NetrWkstaUserInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.info));

6100

NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));

6101

}

6102

return NDR_ERR_SUCCESS;

6103

}

6104

6105

static enum ndr_err_code ndr_pull_wkssvc_NetrWkstaUserGetInfo(struct ndr_pull *ndr, int flags, struct wkssvc_NetrWkstaUserGetInfo *r)

6106

{

6107

uint32_t _ptr_unknown;

6108

TALLOC_CTX *_mem_save_unknown_0;

6109

TALLOC_CTX *_mem_save_info_0;

6110

if (flags & NDR_IN) {

6111

ZERO_STRUCT(r->out);

6112

6113

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_unknown));

6114

if (_ptr_unknown) {

6115

NDR_PULL_ALLOC(ndr, r->in.unknown);

6116

} else {

6117

r->in.unknown = NULL;

6118

}

6119

if (r->in.unknown) {

6120

_mem_save_unknown_0 = NDR_PULL_GET_MEM_CTX(ndr);

6121

NDR_PULL_SET_MEM_CTX(ndr, r->in.unknown, 0);

6122

NDR_CHECK(ndr_pull_array_size(ndr, &r->in.unknown));

6123

NDR_CHECK(ndr_pull_array_length(ndr, &r->in.unknown));

6124

if (ndr_get_array_length(ndr, &r->in.unknown) > ndr_get_array_size(ndr, &r->in.unknown)) {

6125

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.unknown), ndr_get_array_length(ndr, &r->in.unknown));

6126

}

6127

NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.unknown), sizeof(uint16_t)));

6128

NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.unknown, ndr_get_array_length(ndr, &r->in.unknown), sizeof(uint16_t), CH_UTF16));

6129

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_unknown_0, 0);

6130

}

6131

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));

6132

NDR_PULL_ALLOC(ndr, r->out.info);

6133

ZERO_STRUCTP(r->out.info);

6134

}

6135

if (flags & NDR_OUT) {

6136

if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {

6137

NDR_PULL_ALLOC(ndr, r->out.info);

6138

}

6139

_mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);

6140

NDR_PULL_SET_MEM_CTX(ndr, r->out.info, LIBNDR_FLAG_REF_ALLOC);

6141

NDR_CHECK(ndr_pull_set_switch_value(ndr, r->out.info, r->in.level));

6142

NDR_CHECK(ndr_pull_wkssvc_NetrWkstaUserInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.info));

6143

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, LIBNDR_FLAG_REF_ALLOC);

6144

NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));

6145

}

6146

return NDR_ERR_SUCCESS;

6147

}

6148

6149

_PUBLIC_ void ndr_print_wkssvc_NetrWkstaUserGetInfo(struct ndr_print *ndr, const char *name, int flags, const struct wkssvc_NetrWkstaUserGetInfo *r)

6150

{

6151

ndr_print_struct(ndr, name, "wkssvc_NetrWkstaUserGetInfo");

6152

ndr->depth++;

6153

if (flags & NDR_SET_VALUES) {

6154

ndr->flags |= LIBNDR_PRINT_SET_VALUES;

6155

}

6156

if (flags & NDR_IN) {

6157

ndr_print_struct(ndr, "in", "wkssvc_NetrWkstaUserGetInfo");

6158

ndr->depth++;

6159

ndr_print_ptr(ndr, "unknown", r->in.unknown);

6160

ndr->depth++;

6161

if (r->in.unknown) {

6162

ndr_print_string(ndr, "unknown", r->in.unknown);

6163

}

6164

ndr->depth--;

6165

ndr_print_uint32(ndr, "level", r->in.level);

6166

ndr->depth--;

6167

}

6168

if (flags & NDR_OUT) {

6169

ndr_print_struct(ndr, "out", "wkssvc_NetrWkstaUserGetInfo");

6170

ndr->depth++;

6171

ndr_print_ptr(ndr, "info", r->out.info);

6172

ndr->depth++;

6173

ndr_print_set_switch_value(ndr, r->out.info, r->in.level);

6174

ndr_print_wkssvc_NetrWkstaUserInfo(ndr, "info", r->out.info);

6175

ndr->depth--;

6176

ndr_print_WERROR(ndr, "result", r->out.result);

6177

ndr->depth--;

6178

}

6179

ndr->depth--;

6180

}

6181

6182

static enum ndr_err_code ndr_push_wkssvc_NetrWkstaUserSetInfo(struct ndr_push *ndr, int flags, const struct wkssvc_NetrWkstaUserSetInfo *r)

6183

{

6184

if (flags & NDR_IN) {

6185

NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.unknown));

6186

if (r->in.unknown) {

6187

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.unknown, CH_UTF16)));

6188

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));

6189

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.unknown, CH_UTF16)));

6190

NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.unknown, ndr_charset_length(r->in.unknown, CH_UTF16), sizeof(uint16_t), CH_UTF16));

6191

}

6192

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));

6193

if (r->in.info == NULL) {

6194

return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");

6195

}

6196

NDR_CHECK(ndr_push_set_switch_value(ndr, r->in.info, r->in.level));

6197

NDR_CHECK(ndr_push_wkssvc_NetrWkstaUserInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info));

6198

NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.parm_err));

6199

if (r->in.parm_err) {

6200

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->in.parm_err));

6201

}

6202

}

6203

if (flags & NDR_OUT) {

6204

NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.parm_err));

6205

if (r->out.parm_err) {

6206

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.parm_err));

6207

}

6208

NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));

6209

}

6210

return NDR_ERR_SUCCESS;

6211

}

6212

6213

static enum ndr_err_code ndr_pull_wkssvc_NetrWkstaUserSetInfo(struct ndr_pull *ndr, int flags, struct wkssvc_NetrWkstaUserSetInfo *r)

6214

{

6215

uint32_t _ptr_unknown;

6216

uint32_t _ptr_parm_err;

6217

TALLOC_CTX *_mem_save_unknown_0;

6218

TALLOC_CTX *_mem_save_info_0;

6219

TALLOC_CTX *_mem_save_parm_err_0;

6220

if (flags & NDR_IN) {

6221

ZERO_STRUCT(r->out);

6222

6223

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_unknown));

6224

if (_ptr_unknown) {

6225

NDR_PULL_ALLOC(ndr, r->in.unknown);

6226

} else {

6227

r->in.unknown = NULL;

6228

}

6229

if (r->in.unknown) {

6230

_mem_save_unknown_0 = NDR_PULL_GET_MEM_CTX(ndr);

6231

NDR_PULL_SET_MEM_CTX(ndr, r->in.unknown, 0);

6232

NDR_CHECK(ndr_pull_array_size(ndr, &r->in.unknown));

6233

NDR_CHECK(ndr_pull_array_length(ndr, &r->in.unknown));

6234

if (ndr_get_array_length(ndr, &r->in.unknown) > ndr_get_array_size(ndr, &r->in.unknown)) {

6235

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.unknown), ndr_get_array_length(ndr, &r->in.unknown));

6236

}

6237

NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.unknown), sizeof(uint16_t)));

6238

NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.unknown, ndr_get_array_length(ndr, &r->in.unknown), sizeof(uint16_t), CH_UTF16));

6239

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_unknown_0, 0);

6240

}

6241

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));

6242

if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {

6243

NDR_PULL_ALLOC(ndr, r->in.info);

6244

}

6245

_mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);

6246

NDR_PULL_SET_MEM_CTX(ndr, r->in.info, LIBNDR_FLAG_REF_ALLOC);

6247

NDR_CHECK(ndr_pull_set_switch_value(ndr, r->in.info, r->in.level));

6248

NDR_CHECK(ndr_pull_wkssvc_NetrWkstaUserInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info));

6249

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, LIBNDR_FLAG_REF_ALLOC);

6250

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_parm_err));

6251

if (_ptr_parm_err) {

6252

NDR_PULL_ALLOC(ndr, r->in.parm_err);

6253

} else {

6254

r->in.parm_err = NULL;

6255

}

6256

if (r->in.parm_err) {

6257

_mem_save_parm_err_0 = NDR_PULL_GET_MEM_CTX(ndr);

6258

NDR_PULL_SET_MEM_CTX(ndr, r->in.parm_err, 0);

6259

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->in.parm_err));

6260

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_parm_err_0, 0);

6261

}

6262

}

6263

if (flags & NDR_OUT) {

6264

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_parm_err));

6265

if (_ptr_parm_err) {

6266

NDR_PULL_ALLOC(ndr, r->out.parm_err);

6267

} else {

6268

r->out.parm_err = NULL;

6269

}

6270

if (r->out.parm_err) {

6271

_mem_save_parm_err_0 = NDR_PULL_GET_MEM_CTX(ndr);

6272

NDR_PULL_SET_MEM_CTX(ndr, r->out.parm_err, 0);

6273

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.parm_err));

6274

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_parm_err_0, 0);

6275

}

6276

NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));

6277

}

6278

return NDR_ERR_SUCCESS;

6279

}

6280

6281

_PUBLIC_ void ndr_print_wkssvc_NetrWkstaUserSetInfo(struct ndr_print *ndr, const char *name, int flags, const struct wkssvc_NetrWkstaUserSetInfo *r)

6282

{

6283

ndr_print_struct(ndr, name, "wkssvc_NetrWkstaUserSetInfo");

6284

ndr->depth++;

6285

if (flags & NDR_SET_VALUES) {

6286

ndr->flags |= LIBNDR_PRINT_SET_VALUES;

6287

}

6288

if (flags & NDR_IN) {

6289

ndr_print_struct(ndr, "in", "wkssvc_NetrWkstaUserSetInfo");

6290

ndr->depth++;

6291

ndr_print_ptr(ndr, "unknown", r->in.unknown);

6292

ndr->depth++;

6293

if (r->in.unknown) {

6294

ndr_print_string(ndr, "unknown", r->in.unknown);

6295

}

6296

ndr->depth--;

6297

ndr_print_uint32(ndr, "level", r->in.level);

6298

ndr_print_ptr(ndr, "info", r->in.info);

6299

ndr->depth++;

6300

ndr_print_set_switch_value(ndr, r->in.info, r->in.level);

6301

ndr_print_wkssvc_NetrWkstaUserInfo(ndr, "info", r->in.info);

6302

ndr->depth--;

6303

ndr_print_ptr(ndr, "parm_err", r->in.parm_err);

6304

ndr->depth++;

6305

if (r->in.parm_err) {

6306

ndr_print_uint32(ndr, "parm_err", *r->in.parm_err);

6307

}

6308

ndr->depth--;

6309

ndr->depth--;

6310

}

6311

if (flags & NDR_OUT) {

6312

ndr_print_struct(ndr, "out", "wkssvc_NetrWkstaUserSetInfo");

6313

ndr->depth++;

6314

ndr_print_ptr(ndr, "parm_err", r->out.parm_err);

6315

ndr->depth++;

6316

if (r->out.parm_err) {

6317

ndr_print_uint32(ndr, "parm_err", *r->out.parm_err);

6318

}

6319

ndr->depth--;

6320

ndr_print_WERROR(ndr, "result", r->out.result);

6321

ndr->depth--;

6322

}

6323

ndr->depth--;

6324

}

6325

6326

static enum ndr_err_code ndr_push_wkssvc_NetWkstaTransportEnum(struct ndr_push *ndr, int flags, const struct wkssvc_NetWkstaTransportEnum *r)

6327

{

6328

if (flags & NDR_IN) {

6329

NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server_name));

6330

if (r->in.server_name) {

6331

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));

6332

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));

6333

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));

6334

NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server_name, ndr_charset_length(r->in.server_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));

6335

}

6336

if (r->in.info == NULL) {

6337

return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");

6338

}

6339

NDR_CHECK(ndr_push_wkssvc_NetWkstaTransportInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info));

6340

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.max_buffer));

6341

NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.resume_handle));

6342

if (r->in.resume_handle) {

6343

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->in.resume_handle));

6344

}

6345

}

6346

if (flags & NDR_OUT) {

6347

if (r->out.info == NULL) {

6348

return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");

6349

}

6350

NDR_CHECK(ndr_push_wkssvc_NetWkstaTransportInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.info));

6351

if (r->out.total_entries == NULL) {

6352

return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");

6353

}

6354

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.total_entries));

6355

NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.resume_handle));

6356

if (r->out.resume_handle) {

6357

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.resume_handle));

6358

}

6359

NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));

6360

}

6361

return NDR_ERR_SUCCESS;

6362

}

6363

6364

static enum ndr_err_code ndr_pull_wkssvc_NetWkstaTransportEnum(struct ndr_pull *ndr, int flags, struct wkssvc_NetWkstaTransportEnum *r)

6365

{

6366

uint32_t _ptr_server_name;

6367

uint32_t _ptr_resume_handle;

6368

TALLOC_CTX *_mem_save_server_name_0;

6369

TALLOC_CTX *_mem_save_info_0;

6370

TALLOC_CTX *_mem_save_total_entries_0;

6371

TALLOC_CTX *_mem_save_resume_handle_0;

6372

if (flags & NDR_IN) {

6373

ZERO_STRUCT(r->out);

6374

6375

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_name));

6376

if (_ptr_server_name) {

6377

NDR_PULL_ALLOC(ndr, r->in.server_name);

6378

} else {

6379

r->in.server_name = NULL;

6380

}

6381

if (r->in.server_name) {

6382

_mem_save_server_name_0 = NDR_PULL_GET_MEM_CTX(ndr);

6383

NDR_PULL_SET_MEM_CTX(ndr, r->in.server_name, 0);

6384

NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_name));

6385

NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_name));

6386

if (ndr_get_array_length(ndr, &r->in.server_name) > ndr_get_array_size(ndr, &r->in.server_name)) {

6387

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_name), ndr_get_array_length(ndr, &r->in.server_name));

6388

}

6389

NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server_name), sizeof(uint16_t)));

6390

NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server_name, ndr_get_array_length(ndr, &r->in.server_name), sizeof(uint16_t), CH_UTF16));

6391

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_name_0, 0);

6392

}

6393

if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {

6394

NDR_PULL_ALLOC(ndr, r->in.info);

6395

}

6396

_mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);

6397

NDR_PULL_SET_MEM_CTX(ndr, r->in.info, LIBNDR_FLAG_REF_ALLOC);

6398

NDR_CHECK(ndr_pull_wkssvc_NetWkstaTransportInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info));

6399

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, LIBNDR_FLAG_REF_ALLOC);

6400

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.max_buffer));

6401

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_resume_handle));

6402

if (_ptr_resume_handle) {

6403

NDR_PULL_ALLOC(ndr, r->in.resume_handle);

6404

} else {

6405

r->in.resume_handle = NULL;

6406

}

6407

if (r->in.resume_handle) {

6408

_mem_save_resume_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);

6409

NDR_PULL_SET_MEM_CTX(ndr, r->in.resume_handle, 0);

6410

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->in.resume_handle));

6411

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_resume_handle_0, 0);

6412

}

6413

NDR_PULL_ALLOC(ndr, r->out.info);

6414

*r->out.info = *r->in.info;

6415

NDR_PULL_ALLOC(ndr, r->out.total_entries);

6416

ZERO_STRUCTP(r->out.total_entries);

6417

}

6418

if (flags & NDR_OUT) {

6419

if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {

6420

NDR_PULL_ALLOC(ndr, r->out.info);

6421

}

6422

_mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);

6423

NDR_PULL_SET_MEM_CTX(ndr, r->out.info, LIBNDR_FLAG_REF_ALLOC);

6424

NDR_CHECK(ndr_pull_wkssvc_NetWkstaTransportInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.info));

6425

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, LIBNDR_FLAG_REF_ALLOC);

6426

if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {

6427

NDR_PULL_ALLOC(ndr, r->out.total_entries);

6428

}

6429

_mem_save_total_entries_0 = NDR_PULL_GET_MEM_CTX(ndr);

6430

NDR_PULL_SET_MEM_CTX(ndr, r->out.total_entries, LIBNDR_FLAG_REF_ALLOC);

6431

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.total_entries));

6432

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_total_entries_0, LIBNDR_FLAG_REF_ALLOC);

6433

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_resume_handle));

6434

if (_ptr_resume_handle) {

6435

NDR_PULL_ALLOC(ndr, r->out.resume_handle);

6436

} else {

6437

r->out.resume_handle = NULL;

6438

}

6439

if (r->out.resume_handle) {

6440

_mem_save_resume_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);

6441

NDR_PULL_SET_MEM_CTX(ndr, r->out.resume_handle, 0);

6442

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.resume_handle));

6443

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_resume_handle_0, 0);

6444

}

6445

NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));

6446

}

6447

return NDR_ERR_SUCCESS;

6448

}

6449

6450

_PUBLIC_ void ndr_print_wkssvc_NetWkstaTransportEnum(struct ndr_print *ndr, const char *name, int flags, const struct wkssvc_NetWkstaTransportEnum *r)

6451

{

6452

ndr_print_struct(ndr, name, "wkssvc_NetWkstaTransportEnum");

6453

ndr->depth++;

6454

if (flags & NDR_SET_VALUES) {

6455

ndr->flags |= LIBNDR_PRINT_SET_VALUES;

6456

}

6457

if (flags & NDR_IN) {

6458

ndr_print_struct(ndr, "in", "wkssvc_NetWkstaTransportEnum");

6459

ndr->depth++;

6460

ndr_print_ptr(ndr, "server_name", r->in.server_name);

6461

ndr->depth++;

6462

if (r->in.server_name) {

6463

ndr_print_string(ndr, "server_name", r->in.server_name);

6464

}

6465

ndr->depth--;

6466

ndr_print_ptr(ndr, "info", r->in.info);

6467

ndr->depth++;

6468

ndr_print_wkssvc_NetWkstaTransportInfo(ndr, "info", r->in.info);

6469

ndr->depth--;

6470

ndr_print_uint32(ndr, "max_buffer", r->in.max_buffer);

6471

ndr_print_ptr(ndr, "resume_handle", r->in.resume_handle);

6472

ndr->depth++;

6473

if (r->in.resume_handle) {

6474

ndr_print_uint32(ndr, "resume_handle", *r->in.resume_handle);

6475

}

6476

ndr->depth--;

6477

ndr->depth--;

6478

}

6479

if (flags & NDR_OUT) {

6480

ndr_print_struct(ndr, "out", "wkssvc_NetWkstaTransportEnum");

6481

ndr->depth++;

6482

ndr_print_ptr(ndr, "info", r->out.info);

6483

ndr->depth++;

6484

ndr_print_wkssvc_NetWkstaTransportInfo(ndr, "info", r->out.info);

6485

ndr->depth--;

6486

ndr_print_ptr(ndr, "total_entries", r->out.total_entries);

6487

ndr->depth++;

6488

ndr_print_uint32(ndr, "total_entries", *r->out.total_entries);

6489

ndr->depth--;

6490

ndr_print_ptr(ndr, "resume_handle", r->out.resume_handle);

6491

ndr->depth++;

6492

if (r->out.resume_handle) {

6493

ndr_print_uint32(ndr, "resume_handle", *r->out.resume_handle);

6494

}

6495

ndr->depth--;

6496

ndr_print_WERROR(ndr, "result", r->out.result);

6497

ndr->depth--;

6498

}

6499

ndr->depth--;

6500

}

6501

6502

static enum ndr_err_code ndr_push_wkssvc_NetrWkstaTransportAdd(struct ndr_push *ndr, int flags, const struct wkssvc_NetrWkstaTransportAdd *r)

6503

{

6504

if (flags & NDR_IN) {

6505

NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server_name));

6506

if (r->in.server_name) {

6507

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));

6508

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));

6509

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));

6510

NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server_name, ndr_charset_length(r->in.server_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));

6511

}

6512

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));

6513

if (r->in.info0 == NULL) {

6514

return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");

6515

}

6516

NDR_CHECK(ndr_push_wkssvc_NetWkstaTransportInfo0(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info0));

6517

NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.parm_err));

6518

if (r->in.parm_err) {

6519

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->in.parm_err));

6520

}

6521

}

6522

if (flags & NDR_OUT) {

6523

NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.parm_err));

6524

if (r->out.parm_err) {

6525

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.parm_err));

6526

}

6527

NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));

6528

}

6529

return NDR_ERR_SUCCESS;

6530

}

6531

6532

static enum ndr_err_code ndr_pull_wkssvc_NetrWkstaTransportAdd(struct ndr_pull *ndr, int flags, struct wkssvc_NetrWkstaTransportAdd *r)

6533

{

6534

uint32_t _ptr_server_name;

6535

uint32_t _ptr_parm_err;

6536

TALLOC_CTX *_mem_save_server_name_0;

6537

TALLOC_CTX *_mem_save_info0_0;

6538

TALLOC_CTX *_mem_save_parm_err_0;

6539

if (flags & NDR_IN) {

6540

ZERO_STRUCT(r->out);

6541

6542

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_name));

6543

if (_ptr_server_name) {

6544

NDR_PULL_ALLOC(ndr, r->in.server_name);

6545

} else {

6546

r->in.server_name = NULL;

6547

}

6548

if (r->in.server_name) {

6549

_mem_save_server_name_0 = NDR_PULL_GET_MEM_CTX(ndr);

6550

NDR_PULL_SET_MEM_CTX(ndr, r->in.server_name, 0);

6551

NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_name));

6552

NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_name));

6553

if (ndr_get_array_length(ndr, &r->in.server_name) > ndr_get_array_size(ndr, &r->in.server_name)) {

6554

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_name), ndr_get_array_length(ndr, &r->in.server_name));

6555

}

6556

NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server_name), sizeof(uint16_t)));

6557

NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server_name, ndr_get_array_length(ndr, &r->in.server_name), sizeof(uint16_t), CH_UTF16));

6558

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_name_0, 0);

6559

}

6560

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));

6561

if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {

6562

NDR_PULL_ALLOC(ndr, r->in.info0);

6563

}

6564

_mem_save_info0_0 = NDR_PULL_GET_MEM_CTX(ndr);

6565

NDR_PULL_SET_MEM_CTX(ndr, r->in.info0, LIBNDR_FLAG_REF_ALLOC);

6566

NDR_CHECK(ndr_pull_wkssvc_NetWkstaTransportInfo0(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info0));

6567

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info0_0, LIBNDR_FLAG_REF_ALLOC);

6568

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_parm_err));

6569

if (_ptr_parm_err) {

6570

NDR_PULL_ALLOC(ndr, r->in.parm_err);

6571

} else {

6572

r->in.parm_err = NULL;

6573

}

6574

if (r->in.parm_err) {

6575

_mem_save_parm_err_0 = NDR_PULL_GET_MEM_CTX(ndr);

6576

NDR_PULL_SET_MEM_CTX(ndr, r->in.parm_err, 0);

6577

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->in.parm_err));

6578

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_parm_err_0, 0);

6579

}

6580

}

6581

if (flags & NDR_OUT) {

6582

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_parm_err));

6583

if (_ptr_parm_err) {

6584

NDR_PULL_ALLOC(ndr, r->out.parm_err);

6585

} else {

6586

r->out.parm_err = NULL;

6587

}

6588

if (r->out.parm_err) {

6589

_mem_save_parm_err_0 = NDR_PULL_GET_MEM_CTX(ndr);

6590

NDR_PULL_SET_MEM_CTX(ndr, r->out.parm_err, 0);

6591

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.parm_err));

6592

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_parm_err_0, 0);

6593

}

6594

NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));

6595

}

6596

return NDR_ERR_SUCCESS;

6597

}

6598

6599

_PUBLIC_ void ndr_print_wkssvc_NetrWkstaTransportAdd(struct ndr_print *ndr, const char *name, int flags, const struct wkssvc_NetrWkstaTransportAdd *r)

6600

{

6601

ndr_print_struct(ndr, name, "wkssvc_NetrWkstaTransportAdd");

6602

ndr->depth++;

6603

if (flags & NDR_SET_VALUES) {

6604

ndr->flags |= LIBNDR_PRINT_SET_VALUES;

6605

}

6606

if (flags & NDR_IN) {

6607

ndr_print_struct(ndr, "in", "wkssvc_NetrWkstaTransportAdd");

6608

ndr->depth++;

6609

ndr_print_ptr(ndr, "server_name", r->in.server_name);

6610

ndr->depth++;

6611

if (r->in.server_name) {

6612

ndr_print_string(ndr, "server_name", r->in.server_name);

6613

}

6614

ndr->depth--;

6615

ndr_print_uint32(ndr, "level", r->in.level);

6616

ndr_print_ptr(ndr, "info0", r->in.info0);

6617

ndr->depth++;

6618

ndr_print_wkssvc_NetWkstaTransportInfo0(ndr, "info0", r->in.info0);

6619

ndr->depth--;

6620

ndr_print_ptr(ndr, "parm_err", r->in.parm_err);

6621

ndr->depth++;

6622

if (r->in.parm_err) {

6623

ndr_print_uint32(ndr, "parm_err", *r->in.parm_err);

6624

}

6625

ndr->depth--;

6626

ndr->depth--;

6627

}

6628

if (flags & NDR_OUT) {

6629

ndr_print_struct(ndr, "out", "wkssvc_NetrWkstaTransportAdd");

6630

ndr->depth++;

6631

ndr_print_ptr(ndr, "parm_err", r->out.parm_err);

6632

ndr->depth++;

6633

if (r->out.parm_err) {

6634

ndr_print_uint32(ndr, "parm_err", *r->out.parm_err);

6635

}

6636

ndr->depth--;

6637

ndr_print_WERROR(ndr, "result", r->out.result);

6638

ndr->depth--;

6639

}

6640

ndr->depth--;

6641

}

6642

6643

static enum ndr_err_code ndr_push_wkssvc_NetrWkstaTransportDel(struct ndr_push *ndr, int flags, const struct wkssvc_NetrWkstaTransportDel *r)

6644

{

6645

if (flags & NDR_IN) {

6646

NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server_name));

6647

if (r->in.server_name) {

6648

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));

6649

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));

6650

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));

6651

NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server_name, ndr_charset_length(r->in.server_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));

6652

}

6653

NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.transport_name));

6654

if (r->in.transport_name) {

6655

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.transport_name, CH_UTF16)));

6656

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));

6657

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.transport_name, CH_UTF16)));

6658

NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.transport_name, ndr_charset_length(r->in.transport_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));

6659

}

6660

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.unknown3));

6661

}

6662

if (flags & NDR_OUT) {

6663

NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));

6664

}

6665

return NDR_ERR_SUCCESS;

6666

}

6667

6668

static enum ndr_err_code ndr_pull_wkssvc_NetrWkstaTransportDel(struct ndr_pull *ndr, int flags, struct wkssvc_NetrWkstaTransportDel *r)

6669

{

6670

uint32_t _ptr_server_name;

6671

uint32_t _ptr_transport_name;

6672

TALLOC_CTX *_mem_save_server_name_0;

6673

TALLOC_CTX *_mem_save_transport_name_0;

6674

if (flags & NDR_IN) {

6675

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_name));

6676

if (_ptr_server_name) {

6677

NDR_PULL_ALLOC(ndr, r->in.server_name);

6678

} else {

6679

r->in.server_name = NULL;

6680

}

6681

if (r->in.server_name) {

6682

_mem_save_server_name_0 = NDR_PULL_GET_MEM_CTX(ndr);

6683

NDR_PULL_SET_MEM_CTX(ndr, r->in.server_name, 0);

6684

NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_name));

6685

NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_name));

6686

if (ndr_get_array_length(ndr, &r->in.server_name) > ndr_get_array_size(ndr, &r->in.server_name)) {

6687

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_name), ndr_get_array_length(ndr, &r->in.server_name));

6688

}

6689

NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server_name), sizeof(uint16_t)));

6690

NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server_name, ndr_get_array_length(ndr, &r->in.server_name), sizeof(uint16_t), CH_UTF16));

6691

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_name_0, 0);

6692

}

6693

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_transport_name));

6694

if (_ptr_transport_name) {

6695

NDR_PULL_ALLOC(ndr, r->in.transport_name);

6696

} else {

6697

r->in.transport_name = NULL;

6698

}

6699

if (r->in.transport_name) {

6700

_mem_save_transport_name_0 = NDR_PULL_GET_MEM_CTX(ndr);

6701

NDR_PULL_SET_MEM_CTX(ndr, r->in.transport_name, 0);

6702

NDR_CHECK(ndr_pull_array_size(ndr, &r->in.transport_name));

6703

NDR_CHECK(ndr_pull_array_length(ndr, &r->in.transport_name));

6704

if (ndr_get_array_length(ndr, &r->in.transport_name) > ndr_get_array_size(ndr, &r->in.transport_name)) {

6705

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_name), ndr_get_array_length(ndr, &r->in.transport_name));

6706

}

6707

NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.transport_name), sizeof(uint16_t)));

6708

NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.transport_name, ndr_get_array_length(ndr, &r->in.transport_name), sizeof(uint16_t), CH_UTF16));

6709

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_transport_name_0, 0);

6710

}

6711

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.unknown3));

6712

}

6713

if (flags & NDR_OUT) {

6714

NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));

6715

}

6716

return NDR_ERR_SUCCESS;

6717

}

6718

6719

_PUBLIC_ void ndr_print_wkssvc_NetrWkstaTransportDel(struct ndr_print *ndr, const char *name, int flags, const struct wkssvc_NetrWkstaTransportDel *r)

6720

{

6721

ndr_print_struct(ndr, name, "wkssvc_NetrWkstaTransportDel");

6722

ndr->depth++;

6723

if (flags & NDR_SET_VALUES) {

6724

ndr->flags |= LIBNDR_PRINT_SET_VALUES;

6725

}

6726

if (flags & NDR_IN) {

6727

ndr_print_struct(ndr, "in", "wkssvc_NetrWkstaTransportDel");

6728

ndr->depth++;

6729

ndr_print_ptr(ndr, "server_name", r->in.server_name);

6730

ndr->depth++;

6731

if (r->in.server_name) {

6732

ndr_print_string(ndr, "server_name", r->in.server_name);

6733

}

6734

ndr->depth--;

6735

ndr_print_ptr(ndr, "transport_name", r->in.transport_name);

6736

ndr->depth++;

6737

if (r->in.transport_name) {

6738

ndr_print_string(ndr, "transport_name", r->in.transport_name);

6739

}

6740

ndr->depth--;

6741

ndr_print_uint32(ndr, "unknown3", r->in.unknown3);

6742

ndr->depth--;

6743

}

6744

if (flags & NDR_OUT) {

6745

ndr_print_struct(ndr, "out", "wkssvc_NetrWkstaTransportDel");

6746

ndr->depth++;

6747

ndr_print_WERROR(ndr, "result", r->out.result);

6748

ndr->depth--;

6749

}

6750

ndr->depth--;

6751

}

6752

6753

static enum ndr_err_code ndr_push_wkssvc_NetrUseAdd(struct ndr_push *ndr, int flags, const struct wkssvc_NetrUseAdd *r)

6754

{

6755

if (flags & NDR_IN) {

6756

NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server_name));

6757

if (r->in.server_name) {

6758

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));

6759

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));

6760

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));

6761

NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server_name, ndr_charset_length(r->in.server_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));

6762

}

6763

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));

6764

if (r->in.ctr == NULL) {

6765

return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");

6766

}

6767

NDR_CHECK(ndr_push_set_switch_value(ndr, r->in.ctr, r->in.level));

6768

NDR_CHECK(ndr_push_wkssvc_NetrUseGetInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.ctr));

6769

NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.parm_err));

6770

if (r->in.parm_err) {

6771

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->in.parm_err));

6772

}

6773

}

6774

if (flags & NDR_OUT) {

6775

NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.parm_err));

6776

if (r->out.parm_err) {

6777

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.parm_err));

6778

}

6779

NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));

6780

}

6781

return NDR_ERR_SUCCESS;

6782

}

6783

6784

static enum ndr_err_code ndr_pull_wkssvc_NetrUseAdd(struct ndr_pull *ndr, int flags, struct wkssvc_NetrUseAdd *r)

6785

{

6786

uint32_t _ptr_server_name;

6787

uint32_t _ptr_parm_err;

6788

TALLOC_CTX *_mem_save_server_name_0;

6789

TALLOC_CTX *_mem_save_ctr_0;

6790

TALLOC_CTX *_mem_save_parm_err_0;

6791

if (flags & NDR_IN) {

6792

ZERO_STRUCT(r->out);

6793

6794

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_name));

6795

if (_ptr_server_name) {

6796

NDR_PULL_ALLOC(ndr, r->in.server_name);

6797

} else {

6798

r->in.server_name = NULL;

6799

}

6800

if (r->in.server_name) {

6801

_mem_save_server_name_0 = NDR_PULL_GET_MEM_CTX(ndr);

6802

NDR_PULL_SET_MEM_CTX(ndr, r->in.server_name, 0);

6803

NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_name));

6804

NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_name));

6805

if (ndr_get_array_length(ndr, &r->in.server_name) > ndr_get_array_size(ndr, &r->in.server_name)) {

6806

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_name), ndr_get_array_length(ndr, &r->in.server_name));

6807

}

6808

NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server_name), sizeof(uint16_t)));

6809

NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server_name, ndr_get_array_length(ndr, &r->in.server_name), sizeof(uint16_t), CH_UTF16));

6810

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_name_0, 0);

6811

}

6812

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));

6813

if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {

6814

NDR_PULL_ALLOC(ndr, r->in.ctr);

6815

}

6816

_mem_save_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);

6817

NDR_PULL_SET_MEM_CTX(ndr, r->in.ctr, LIBNDR_FLAG_REF_ALLOC);

6818

NDR_CHECK(ndr_pull_set_switch_value(ndr, r->in.ctr, r->in.level));

6819

NDR_CHECK(ndr_pull_wkssvc_NetrUseGetInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.ctr));

6820

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ctr_0, LIBNDR_FLAG_REF_ALLOC);

6821

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_parm_err));

6822

if (_ptr_parm_err) {

6823

NDR_PULL_ALLOC(ndr, r->in.parm_err);

6824

} else {

6825

r->in.parm_err = NULL;

6826

}

6827

if (r->in.parm_err) {

6828

_mem_save_parm_err_0 = NDR_PULL_GET_MEM_CTX(ndr);

6829

NDR_PULL_SET_MEM_CTX(ndr, r->in.parm_err, 0);

6830

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->in.parm_err));

6831

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_parm_err_0, 0);

6832

}

6833

}

6834

if (flags & NDR_OUT) {

6835

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_parm_err));

6836

if (_ptr_parm_err) {

6837

NDR_PULL_ALLOC(ndr, r->out.parm_err);

6838

} else {

6839

r->out.parm_err = NULL;

6840

}

6841

if (r->out.parm_err) {

6842

_mem_save_parm_err_0 = NDR_PULL_GET_MEM_CTX(ndr);

6843

NDR_PULL_SET_MEM_CTX(ndr, r->out.parm_err, 0);

6844

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.parm_err));

6845

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_parm_err_0, 0);

6846

}

6847

NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));

6848

}

6849

return NDR_ERR_SUCCESS;

6850

}

6851

6852

_PUBLIC_ void ndr_print_wkssvc_NetrUseAdd(struct ndr_print *ndr, const char *name, int flags, const struct wkssvc_NetrUseAdd *r)

6853

{

6854

ndr_print_struct(ndr, name, "wkssvc_NetrUseAdd");

6855

ndr->depth++;

6856

if (flags & NDR_SET_VALUES) {

6857

ndr->flags |= LIBNDR_PRINT_SET_VALUES;

6858

}

6859

if (flags & NDR_IN) {

6860

ndr_print_struct(ndr, "in", "wkssvc_NetrUseAdd");

6861

ndr->depth++;

6862

ndr_print_ptr(ndr, "server_name", r->in.server_name);

6863

ndr->depth++;

6864

if (r->in.server_name) {

6865

ndr_print_string(ndr, "server_name", r->in.server_name);

6866

}

6867

ndr->depth--;

6868

ndr_print_uint32(ndr, "level", r->in.level);

6869

ndr_print_ptr(ndr, "ctr", r->in.ctr);

6870

ndr->depth++;

6871

ndr_print_set_switch_value(ndr, r->in.ctr, r->in.level);

6872

ndr_print_wkssvc_NetrUseGetInfoCtr(ndr, "ctr", r->in.ctr);

6873

ndr->depth--;

6874

ndr_print_ptr(ndr, "parm_err", r->in.parm_err);

6875

ndr->depth++;

6876

if (r->in.parm_err) {

6877

ndr_print_uint32(ndr, "parm_err", *r->in.parm_err);

6878

}

6879

ndr->depth--;

6880

ndr->depth--;

6881

}

6882

if (flags & NDR_OUT) {

6883

ndr_print_struct(ndr, "out", "wkssvc_NetrUseAdd");

6884

ndr->depth++;

6885

ndr_print_ptr(ndr, "parm_err", r->out.parm_err);

6886

ndr->depth++;

6887

if (r->out.parm_err) {

6888

ndr_print_uint32(ndr, "parm_err", *r->out.parm_err);

6889

}

6890

ndr->depth--;

6891

ndr_print_WERROR(ndr, "result", r->out.result);

6892

ndr->depth--;

6893

}

6894

ndr->depth--;

6895

}

6896

6897

static enum ndr_err_code ndr_push_wkssvc_NetrUseGetInfo(struct ndr_push *ndr, int flags, const struct wkssvc_NetrUseGetInfo *r)

6898

{

6899

if (flags & NDR_IN) {

6900

NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server_name));

6901

if (r->in.server_name) {

6902

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));

6903

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));

6904

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));

6905

NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server_name, ndr_charset_length(r->in.server_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));

6906

}

6907

if (r->in.use_name == NULL) {

6908

return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");

6909

}

6910

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.use_name, CH_UTF16)));

6911

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));

6912

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.use_name, CH_UTF16)));

6913

NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.use_name, ndr_charset_length(r->in.use_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));

6914

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));

6915

}

6916

if (flags & NDR_OUT) {

6917

if (r->out.ctr == NULL) {

6918

return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");

6919

}

6920

NDR_CHECK(ndr_push_set_switch_value(ndr, r->out.ctr, r->in.level));

6921

NDR_CHECK(ndr_push_wkssvc_NetrUseGetInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.ctr));

6922

NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));

6923

}

6924

return NDR_ERR_SUCCESS;

6925

}

6926

6927

static enum ndr_err_code ndr_pull_wkssvc_NetrUseGetInfo(struct ndr_pull *ndr, int flags, struct wkssvc_NetrUseGetInfo *r)

6928

{

6929

uint32_t _ptr_server_name;

6930

TALLOC_CTX *_mem_save_server_name_0;

6931

TALLOC_CTX *_mem_save_ctr_0;

6932

if (flags & NDR_IN) {

6933

ZERO_STRUCT(r->out);

6934

6935

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_name));

6936

if (_ptr_server_name) {

6937

NDR_PULL_ALLOC(ndr, r->in.server_name);

6938

} else {

6939

r->in.server_name = NULL;

6940

}

6941

if (r->in.server_name) {

6942

_mem_save_server_name_0 = NDR_PULL_GET_MEM_CTX(ndr);

6943

NDR_PULL_SET_MEM_CTX(ndr, r->in.server_name, 0);

6944

NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_name));

6945

NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_name));

6946

if (ndr_get_array_length(ndr, &r->in.server_name) > ndr_get_array_size(ndr, &r->in.server_name)) {

6947

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_name), ndr_get_array_length(ndr, &r->in.server_name));

6948

}

6949

NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server_name), sizeof(uint16_t)));

6950

NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server_name, ndr_get_array_length(ndr, &r->in.server_name), sizeof(uint16_t), CH_UTF16));

6951

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_name_0, 0);

6952

}

6953

NDR_CHECK(ndr_pull_array_size(ndr, &r->in.use_name));

6954

NDR_CHECK(ndr_pull_array_length(ndr, &r->in.use_name));

6955

if (ndr_get_array_length(ndr, &r->in.use_name) > ndr_get_array_size(ndr, &r->in.use_name)) {

6956

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.use_name), ndr_get_array_length(ndr, &r->in.use_name));

6957

}

6958

NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.use_name), sizeof(uint16_t)));

6959

NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.use_name, ndr_get_array_length(ndr, &r->in.use_name), sizeof(uint16_t), CH_UTF16));

6960

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));

6961

NDR_PULL_ALLOC(ndr, r->out.ctr);

6962

ZERO_STRUCTP(r->out.ctr);

6963

}

6964

if (flags & NDR_OUT) {

6965

if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {

6966

NDR_PULL_ALLOC(ndr, r->out.ctr);

6967

}

6968

_mem_save_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);

6969

NDR_PULL_SET_MEM_CTX(ndr, r->out.ctr, LIBNDR_FLAG_REF_ALLOC);

6970

NDR_CHECK(ndr_pull_set_switch_value(ndr, r->out.ctr, r->in.level));

6971

NDR_CHECK(ndr_pull_wkssvc_NetrUseGetInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.ctr));

6972

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ctr_0, LIBNDR_FLAG_REF_ALLOC);

6973

NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));

6974

}

6975

return NDR_ERR_SUCCESS;

6976

}

6977

6978

_PUBLIC_ void ndr_print_wkssvc_NetrUseGetInfo(struct ndr_print *ndr, const char *name, int flags, const struct wkssvc_NetrUseGetInfo *r)

6979

{

6980

ndr_print_struct(ndr, name, "wkssvc_NetrUseGetInfo");

6981

ndr->depth++;

6982

if (flags & NDR_SET_VALUES) {

6983

ndr->flags |= LIBNDR_PRINT_SET_VALUES;

6984

}

6985

if (flags & NDR_IN) {

6986

ndr_print_struct(ndr, "in", "wkssvc_NetrUseGetInfo");

6987

ndr->depth++;

6988

ndr_print_ptr(ndr, "server_name", r->in.server_name);

6989

ndr->depth++;

6990

if (r->in.server_name) {

6991

ndr_print_string(ndr, "server_name", r->in.server_name);

6992

}

6993

ndr->depth--;

6994

ndr_print_ptr(ndr, "use_name", r->in.use_name);

6995

ndr->depth++;

6996

ndr_print_string(ndr, "use_name", r->in.use_name);

6997

ndr->depth--;

6998

ndr_print_uint32(ndr, "level", r->in.level);

6999

ndr->depth--;

7000

}

7001

if (flags & NDR_OUT) {

7002

ndr_print_struct(ndr, "out", "wkssvc_NetrUseGetInfo");

7003

ndr->depth++;

7004

ndr_print_ptr(ndr, "ctr", r->out.ctr);

7005

ndr->depth++;

7006

ndr_print_set_switch_value(ndr, r->out.ctr, r->in.level);

7007

ndr_print_wkssvc_NetrUseGetInfoCtr(ndr, "ctr", r->out.ctr);

7008

ndr->depth--;

7009

ndr_print_WERROR(ndr, "result", r->out.result);

7010

ndr->depth--;

7011

}

7012

ndr->depth--;

7013

}

7014

7015

static enum ndr_err_code ndr_push_wkssvc_NetrUseDel(struct ndr_push *ndr, int flags, const struct wkssvc_NetrUseDel *r)

7016

{

7017

if (flags & NDR_IN) {

7018

NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server_name));

7019

if (r->in.server_name) {

7020

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));

7021

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));

7022

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));

7023

NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server_name, ndr_charset_length(r->in.server_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));

7024

}

7025

if (r->in.use_name == NULL) {

7026

return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");

7027

}

7028

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.use_name, CH_UTF16)));

7029

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));

7030

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.use_name, CH_UTF16)));

7031

NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.use_name, ndr_charset_length(r->in.use_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));

7032

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.force_cond));

7033

}

7034

if (flags & NDR_OUT) {

7035

NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));

7036

}

7037

return NDR_ERR_SUCCESS;

7038

}

7039

7040

static enum ndr_err_code ndr_pull_wkssvc_NetrUseDel(struct ndr_pull *ndr, int flags, struct wkssvc_NetrUseDel *r)

7041

{

7042

uint32_t _ptr_server_name;

7043

TALLOC_CTX *_mem_save_server_name_0;

7044

if (flags & NDR_IN) {

7045

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_name));

7046

if (_ptr_server_name) {

7047

NDR_PULL_ALLOC(ndr, r->in.server_name);

7048

} else {

7049

r->in.server_name = NULL;

7050

}

7051

if (r->in.server_name) {

7052

_mem_save_server_name_0 = NDR_PULL_GET_MEM_CTX(ndr);

7053

NDR_PULL_SET_MEM_CTX(ndr, r->in.server_name, 0);

7054

NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_name));

7055

NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_name));

7056

if (ndr_get_array_length(ndr, &r->in.server_name) > ndr_get_array_size(ndr, &r->in.server_name)) {

7057

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_name), ndr_get_array_length(ndr, &r->in.server_name));

7058

}

7059

NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server_name), sizeof(uint16_t)));

7060

NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server_name, ndr_get_array_length(ndr, &r->in.server_name), sizeof(uint16_t), CH_UTF16));

7061

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_name_0, 0);

7062

}

7063

NDR_CHECK(ndr_pull_array_size(ndr, &r->in.use_name));

7064

NDR_CHECK(ndr_pull_array_length(ndr, &r->in.use_name));

7065

if (ndr_get_array_length(ndr, &r->in.use_name) > ndr_get_array_size(ndr, &r->in.use_name)) {

7066

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.use_name), ndr_get_array_length(ndr, &r->in.use_name));

7067

}

7068

NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.use_name), sizeof(uint16_t)));

7069

NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.use_name, ndr_get_array_length(ndr, &r->in.use_name), sizeof(uint16_t), CH_UTF16));

7070

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.force_cond));

7071

}

7072

if (flags & NDR_OUT) {

7073

NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));

7074

}

7075

return NDR_ERR_SUCCESS;

7076

}

7077

7078

_PUBLIC_ void ndr_print_wkssvc_NetrUseDel(struct ndr_print *ndr, const char *name, int flags, const struct wkssvc_NetrUseDel *r)

7079

{

7080

ndr_print_struct(ndr, name, "wkssvc_NetrUseDel");

7081

ndr->depth++;

7082

if (flags & NDR_SET_VALUES) {

7083

ndr->flags |= LIBNDR_PRINT_SET_VALUES;

7084

}

7085

if (flags & NDR_IN) {

7086

ndr_print_struct(ndr, "in", "wkssvc_NetrUseDel");

7087

ndr->depth++;

7088

ndr_print_ptr(ndr, "server_name", r->in.server_name);

7089

ndr->depth++;

7090

if (r->in.server_name) {

7091

ndr_print_string(ndr, "server_name", r->in.server_name);

7092

}

7093

ndr->depth--;

7094

ndr_print_ptr(ndr, "use_name", r->in.use_name);

7095

ndr->depth++;

7096

ndr_print_string(ndr, "use_name", r->in.use_name);

7097

ndr->depth--;

7098

ndr_print_uint32(ndr, "force_cond", r->in.force_cond);

7099

ndr->depth--;

7100

}

7101

if (flags & NDR_OUT) {

7102

ndr_print_struct(ndr, "out", "wkssvc_NetrUseDel");

7103

ndr->depth++;

7104

ndr_print_WERROR(ndr, "result", r->out.result);

7105

ndr->depth--;

7106

}

7107

ndr->depth--;

7108

}

7109

7110

static enum ndr_err_code ndr_push_wkssvc_NetrUseEnum(struct ndr_push *ndr, int flags, const struct wkssvc_NetrUseEnum *r)

7111

{

7112

if (flags & NDR_IN) {

7113

NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server_name));

7114

if (r->in.server_name) {

7115

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));

7116

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));

7117

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));

7118

NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server_name, ndr_charset_length(r->in.server_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));

7119

}

7120

if (r->in.info == NULL) {

7121

return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");

7122

}

7123

NDR_CHECK(ndr_push_wkssvc_NetrUseEnumInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info));

7124

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.prefmaxlen));

7125

NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.resume_handle));

7126

if (r->in.resume_handle) {

7127

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->in.resume_handle));

7128

}

7129

}

7130

if (flags & NDR_OUT) {

7131

if (r->out.info == NULL) {

7132

return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");

7133

}

7134

NDR_CHECK(ndr_push_wkssvc_NetrUseEnumInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.info));

7135

if (r->out.entries_read == NULL) {

7136

return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");

7137

}

7138

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.entries_read));

7139

NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.resume_handle));

7140

if (r->out.resume_handle) {

7141

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.resume_handle));

7142

}

7143

NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));

7144

}

7145

return NDR_ERR_SUCCESS;

7146

}

7147

7148

static enum ndr_err_code ndr_pull_wkssvc_NetrUseEnum(struct ndr_pull *ndr, int flags, struct wkssvc_NetrUseEnum *r)

7149

{

7150

uint32_t _ptr_server_name;

7151

uint32_t _ptr_resume_handle;

7152

TALLOC_CTX *_mem_save_server_name_0;

7153

TALLOC_CTX *_mem_save_info_0;

7154

TALLOC_CTX *_mem_save_entries_read_0;

7155

TALLOC_CTX *_mem_save_resume_handle_0;

7156

if (flags & NDR_IN) {

7157

ZERO_STRUCT(r->out);

7158

7159

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_name));

7160

if (_ptr_server_name) {

7161

NDR_PULL_ALLOC(ndr, r->in.server_name);

7162

} else {

7163

r->in.server_name = NULL;

7164

}

7165

if (r->in.server_name) {

7166

_mem_save_server_name_0 = NDR_PULL_GET_MEM_CTX(ndr);

7167

NDR_PULL_SET_MEM_CTX(ndr, r->in.server_name, 0);

7168

NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_name));

7169

NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_name));

7170

if (ndr_get_array_length(ndr, &r->in.server_name) > ndr_get_array_size(ndr, &r->in.server_name)) {

7171

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_name), ndr_get_array_length(ndr, &r->in.server_name));

7172

}

7173

NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server_name), sizeof(uint16_t)));

7174

NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server_name, ndr_get_array_length(ndr, &r->in.server_name), sizeof(uint16_t), CH_UTF16));

7175

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_name_0, 0);

7176

}

7177

if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {

7178

NDR_PULL_ALLOC(ndr, r->in.info);

7179

}

7180

_mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);

7181

NDR_PULL_SET_MEM_CTX(ndr, r->in.info, LIBNDR_FLAG_REF_ALLOC);

7182

NDR_CHECK(ndr_pull_wkssvc_NetrUseEnumInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info));

7183

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, LIBNDR_FLAG_REF_ALLOC);

7184

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.prefmaxlen));

7185

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_resume_handle));

7186

if (_ptr_resume_handle) {

7187

NDR_PULL_ALLOC(ndr, r->in.resume_handle);

7188

} else {

7189

r->in.resume_handle = NULL;

7190

}

7191

if (r->in.resume_handle) {

7192

_mem_save_resume_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);

7193

NDR_PULL_SET_MEM_CTX(ndr, r->in.resume_handle, 0);

7194

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->in.resume_handle));

7195

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_resume_handle_0, 0);

7196

}

7197

NDR_PULL_ALLOC(ndr, r->out.info);

7198

*r->out.info = *r->in.info;

7199

NDR_PULL_ALLOC(ndr, r->out.entries_read);

7200

ZERO_STRUCTP(r->out.entries_read);

7201

}

7202

if (flags & NDR_OUT) {

7203

if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {

7204

NDR_PULL_ALLOC(ndr, r->out.info);

7205

}

7206

_mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);

7207

NDR_PULL_SET_MEM_CTX(ndr, r->out.info, LIBNDR_FLAG_REF_ALLOC);

7208

NDR_CHECK(ndr_pull_wkssvc_NetrUseEnumInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.info));

7209

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, LIBNDR_FLAG_REF_ALLOC);

7210

if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {

7211

NDR_PULL_ALLOC(ndr, r->out.entries_read);

7212

}

7213

_mem_save_entries_read_0 = NDR_PULL_GET_MEM_CTX(ndr);

7214

NDR_PULL_SET_MEM_CTX(ndr, r->out.entries_read, LIBNDR_FLAG_REF_ALLOC);

7215

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.entries_read));

7216

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_entries_read_0, LIBNDR_FLAG_REF_ALLOC);

7217

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_resume_handle));

7218

if (_ptr_resume_handle) {

7219

NDR_PULL_ALLOC(ndr, r->out.resume_handle);

7220

} else {

7221

r->out.resume_handle = NULL;

7222

}

7223

if (r->out.resume_handle) {

7224

_mem_save_resume_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);

7225

NDR_PULL_SET_MEM_CTX(ndr, r->out.resume_handle, 0);

7226

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.resume_handle));

7227

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_resume_handle_0, 0);

7228

}

7229

NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));

7230

}

7231

return NDR_ERR_SUCCESS;

7232

}

7233

7234

_PUBLIC_ void ndr_print_wkssvc_NetrUseEnum(struct ndr_print *ndr, const char *name, int flags, const struct wkssvc_NetrUseEnum *r)

7235

{

7236

ndr_print_struct(ndr, name, "wkssvc_NetrUseEnum");

7237

ndr->depth++;

7238

if (flags & NDR_SET_VALUES) {

7239

ndr->flags |= LIBNDR_PRINT_SET_VALUES;

7240

}

7241

if (flags & NDR_IN) {

7242

ndr_print_struct(ndr, "in", "wkssvc_NetrUseEnum");

7243

ndr->depth++;

7244

ndr_print_ptr(ndr, "server_name", r->in.server_name);

7245

ndr->depth++;

7246

if (r->in.server_name) {

7247

ndr_print_string(ndr, "server_name", r->in.server_name);

7248

}

7249

ndr->depth--;

7250

ndr_print_ptr(ndr, "info", r->in.info);

7251

ndr->depth++;

7252

ndr_print_wkssvc_NetrUseEnumInfo(ndr, "info", r->in.info);

7253

ndr->depth--;

7254

ndr_print_uint32(ndr, "prefmaxlen", r->in.prefmaxlen);

7255

ndr_print_ptr(ndr, "resume_handle", r->in.resume_handle);

7256

ndr->depth++;

7257

if (r->in.resume_handle) {

7258

ndr_print_uint32(ndr, "resume_handle", *r->in.resume_handle);

7259

}

7260

ndr->depth--;

7261

ndr->depth--;

7262

}

7263

if (flags & NDR_OUT) {

7264

ndr_print_struct(ndr, "out", "wkssvc_NetrUseEnum");

7265

ndr->depth++;

7266

ndr_print_ptr(ndr, "info", r->out.info);

7267

ndr->depth++;

7268

ndr_print_wkssvc_NetrUseEnumInfo(ndr, "info", r->out.info);

7269

ndr->depth--;

7270

ndr_print_ptr(ndr, "entries_read", r->out.entries_read);

7271

ndr->depth++;

7272

ndr_print_uint32(ndr, "entries_read", *r->out.entries_read);

7273

ndr->depth--;

7274

ndr_print_ptr(ndr, "resume_handle", r->out.resume_handle);

7275

ndr->depth++;

7276

if (r->out.resume_handle) {

7277

ndr_print_uint32(ndr, "resume_handle", *r->out.resume_handle);

7278

}

7279

ndr->depth--;

7280

ndr_print_WERROR(ndr, "result", r->out.result);

7281

ndr->depth--;

7282

}

7283

ndr->depth--;

7284

}

7285

7286

static enum ndr_err_code ndr_push_wkssvc_NetrMessageBufferSend(struct ndr_push *ndr, int flags, const struct wkssvc_NetrMessageBufferSend *r)

7287

{

7288

if (flags & NDR_IN) {

7289

NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server_name));

7290

if (r->in.server_name) {

7291

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));

7292

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));

7293

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));

7294

NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server_name, ndr_charset_length(r->in.server_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));

7295

}

7296

if (r->in.message_name == NULL) {

7297

return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");

7298

}

7299

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.message_name, CH_UTF16)));

7300

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));

7301

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.message_name, CH_UTF16)));

7302

NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.message_name, ndr_charset_length(r->in.message_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));

7303

NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.message_sender_name));

7304

if (r->in.message_sender_name) {

7305

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.message_sender_name, CH_UTF16)));

7306

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));

7307

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.message_sender_name, CH_UTF16)));

7308

NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.message_sender_name, ndr_charset_length(r->in.message_sender_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));

7309

}

7310

if (r->in.message_buffer == NULL) {

7311

return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");

7312

}

7313

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.message_size));

7314

NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->in.message_buffer, r->in.message_size));

7315

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.message_size));

7316

}

7317

if (flags & NDR_OUT) {

7318

NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));

7319

}

7320

return NDR_ERR_SUCCESS;

7321

}

7322

7323

static enum ndr_err_code ndr_pull_wkssvc_NetrMessageBufferSend(struct ndr_pull *ndr, int flags, struct wkssvc_NetrMessageBufferSend *r)

7324

{

7325

uint32_t _ptr_server_name;

7326

uint32_t _ptr_message_sender_name;

7327

TALLOC_CTX *_mem_save_server_name_0;

7328

TALLOC_CTX *_mem_save_message_sender_name_0;

7329

if (flags & NDR_IN) {

7330

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_name));

7331

if (_ptr_server_name) {

7332

NDR_PULL_ALLOC(ndr, r->in.server_name);

7333

} else {

7334

r->in.server_name = NULL;

7335

}

7336

if (r->in.server_name) {

7337

_mem_save_server_name_0 = NDR_PULL_GET_MEM_CTX(ndr);

7338

NDR_PULL_SET_MEM_CTX(ndr, r->in.server_name, 0);

7339

NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_name));

7340

NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_name));

7341

if (ndr_get_array_length(ndr, &r->in.server_name) > ndr_get_array_size(ndr, &r->in.server_name)) {

7342

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_name), ndr_get_array_length(ndr, &r->in.server_name));

7343

}

7344

NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server_name), sizeof(uint16_t)));

7345

NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server_name, ndr_get_array_length(ndr, &r->in.server_name), sizeof(uint16_t), CH_UTF16));

7346

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_name_0, 0);

7347

}

7348

NDR_CHECK(ndr_pull_array_size(ndr, &r->in.message_name));

7349

NDR_CHECK(ndr_pull_array_length(ndr, &r->in.message_name));

7350

if (ndr_get_array_length(ndr, &r->in.message_name) > ndr_get_array_size(ndr, &r->in.message_name)) {

7351

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.message_name), ndr_get_array_length(ndr, &r->in.message_name));

7352

}

7353

NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.message_name), sizeof(uint16_t)));

7354

NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.message_name, ndr_get_array_length(ndr, &r->in.message_name), sizeof(uint16_t), CH_UTF16));

7355

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_message_sender_name));

7356

if (_ptr_message_sender_name) {

7357

NDR_PULL_ALLOC(ndr, r->in.message_sender_name);

7358

} else {

7359

r->in.message_sender_name = NULL;

7360

}

7361

if (r->in.message_sender_name) {

7362

_mem_save_message_sender_name_0 = NDR_PULL_GET_MEM_CTX(ndr);

7363

NDR_PULL_SET_MEM_CTX(ndr, r->in.message_sender_name, 0);

7364

NDR_CHECK(ndr_pull_array_size(ndr, &r->in.message_sender_name));

7365

NDR_CHECK(ndr_pull_array_length(ndr, &r->in.message_sender_name));

7366

if (ndr_get_array_length(ndr, &r->in.message_sender_name) > ndr_get_array_size(ndr, &r->in.message_sender_name)) {

7367

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.message_sender_name), ndr_get_array_length(ndr, &r->in.message_sender_name));

7368

}

7369

NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.message_sender_name), sizeof(uint16_t)));

7370

NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.message_sender_name, ndr_get_array_length(ndr, &r->in.message_sender_name), sizeof(uint16_t), CH_UTF16));

7371

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_message_sender_name_0, 0);

7372

}

7373

NDR_CHECK(ndr_pull_array_size(ndr, &r->in.message_buffer));

7374

if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {

7375

NDR_PULL_ALLOC_N(ndr, r->in.message_buffer, ndr_get_array_size(ndr, &r->in.message_buffer));

7376

}

7377

NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->in.message_buffer, ndr_get_array_size(ndr, &r->in.message_buffer)));

7378

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.message_size));

7379

if (r->in.message_buffer) {

7380

NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->in.message_buffer, r->in.message_size));

7381

}

7382

}

7383

if (flags & NDR_OUT) {

7384

NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));

7385

}

7386

return NDR_ERR_SUCCESS;

7387

}

7388

7389

_PUBLIC_ void ndr_print_wkssvc_NetrMessageBufferSend(struct ndr_print *ndr, const char *name, int flags, const struct wkssvc_NetrMessageBufferSend *r)

7390

{

7391

ndr_print_struct(ndr, name, "wkssvc_NetrMessageBufferSend");

7392

ndr->depth++;

7393

if (flags & NDR_SET_VALUES) {

7394

ndr->flags |= LIBNDR_PRINT_SET_VALUES;

7395

}

7396

if (flags & NDR_IN) {

7397

ndr_print_struct(ndr, "in", "wkssvc_NetrMessageBufferSend");

7398

ndr->depth++;

7399

ndr_print_ptr(ndr, "server_name", r->in.server_name);

7400

ndr->depth++;

7401

if (r->in.server_name) {

7402

ndr_print_string(ndr, "server_name", r->in.server_name);

7403

}

7404

ndr->depth--;

7405

ndr_print_ptr(ndr, "message_name", r->in.message_name);

7406

ndr->depth++;

7407

ndr_print_string(ndr, "message_name", r->in.message_name);

7408

ndr->depth--;

7409

ndr_print_ptr(ndr, "message_sender_name", r->in.message_sender_name);

7410

ndr->depth++;

7411

if (r->in.message_sender_name) {

7412

ndr_print_string(ndr, "message_sender_name", r->in.message_sender_name);

7413

}

7414

ndr->depth--;

7415

ndr_print_ptr(ndr, "message_buffer", r->in.message_buffer);

7416

ndr->depth++;

7417

ndr_print_array_uint8(ndr, "message_buffer", r->in.message_buffer, r->in.message_size);

7418

ndr->depth--;

7419

ndr_print_uint32(ndr, "message_size", r->in.message_size);

7420

ndr->depth--;

7421

}

7422

if (flags & NDR_OUT) {

7423

ndr_print_struct(ndr, "out", "wkssvc_NetrMessageBufferSend");

7424

ndr->depth++;

7425

ndr_print_WERROR(ndr, "result", r->out.result);

7426

ndr->depth--;

7427

}

7428

ndr->depth--;

7429

}

7430

7431

static enum ndr_err_code ndr_push_wkssvc_NetrWorkstationStatisticsGet(struct ndr_push *ndr, int flags, const struct wkssvc_NetrWorkstationStatisticsGet *r)

7432

{

7433

if (flags & NDR_IN) {

7434

NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server_name));

7435

if (r->in.server_name) {

7436

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));

7437

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));

7438

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));

7439

NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server_name, ndr_charset_length(r->in.server_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));

7440

}

7441

NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.unknown2));

7442

if (r->in.unknown2) {

7443

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.unknown2, CH_UTF16)));

7444

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));

7445

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.unknown2, CH_UTF16)));

7446

NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.unknown2, ndr_charset_length(r->in.unknown2, CH_UTF16), sizeof(uint16_t), CH_UTF16));

7447

}

7448

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.unknown3));

7449

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.unknown4));

7450

}

7451

if (flags & NDR_OUT) {

7452

if (r->out.info == NULL) {

7453

return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");

7454

}

7455

NDR_CHECK(ndr_push_unique_ptr(ndr, *r->out.info));

7456

if (*r->out.info) {

7457

NDR_CHECK(ndr_push_wkssvc_NetrWorkstationStatistics(ndr, NDR_SCALARS, *r->out.info));

7458

}

7459

NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));

7460

}

7461

return NDR_ERR_SUCCESS;

7462

}

7463

7464

static enum ndr_err_code ndr_pull_wkssvc_NetrWorkstationStatisticsGet(struct ndr_pull *ndr, int flags, struct wkssvc_NetrWorkstationStatisticsGet *r)

7465

{

7466

uint32_t _ptr_server_name;

7467

uint32_t _ptr_unknown2;

7468

uint32_t _ptr_info;

7469

TALLOC_CTX *_mem_save_server_name_0;

7470

TALLOC_CTX *_mem_save_unknown2_0;

7471

TALLOC_CTX *_mem_save_info_0;

7472

TALLOC_CTX *_mem_save_info_1;

7473

if (flags & NDR_IN) {

7474

ZERO_STRUCT(r->out);

7475

7476

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_name));

7477

if (_ptr_server_name) {

7478

NDR_PULL_ALLOC(ndr, r->in.server_name);

7479

} else {

7480

r->in.server_name = NULL;

7481

}

7482

if (r->in.server_name) {

7483

_mem_save_server_name_0 = NDR_PULL_GET_MEM_CTX(ndr);

7484

NDR_PULL_SET_MEM_CTX(ndr, r->in.server_name, 0);

7485

NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_name));

7486

NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_name));

7487

if (ndr_get_array_length(ndr, &r->in.server_name) > ndr_get_array_size(ndr, &r->in.server_name)) {

7488

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_name), ndr_get_array_length(ndr, &r->in.server_name));

7489

}

7490

NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server_name), sizeof(uint16_t)));

7491

NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server_name, ndr_get_array_length(ndr, &r->in.server_name), sizeof(uint16_t), CH_UTF16));

7492

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_name_0, 0);

7493

}

7494

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_unknown2));

7495

if (_ptr_unknown2) {

7496

NDR_PULL_ALLOC(ndr, r->in.unknown2);

7497

} else {

7498

r->in.unknown2 = NULL;

7499

}

7500

if (r->in.unknown2) {

7501

_mem_save_unknown2_0 = NDR_PULL_GET_MEM_CTX(ndr);

7502

NDR_PULL_SET_MEM_CTX(ndr, r->in.unknown2, 0);

7503

NDR_CHECK(ndr_pull_array_size(ndr, &r->in.unknown2));

7504

NDR_CHECK(ndr_pull_array_length(ndr, &r->in.unknown2));

7505

if (ndr_get_array_length(ndr, &r->in.unknown2) > ndr_get_array_size(ndr, &r->in.unknown2)) {

7506

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.unknown2), ndr_get_array_length(ndr, &r->in.unknown2));

7507

}

7508

NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.unknown2), sizeof(uint16_t)));

7509

NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.unknown2, ndr_get_array_length(ndr, &r->in.unknown2), sizeof(uint16_t), CH_UTF16));

7510

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_unknown2_0, 0);

7511

}

7512

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.unknown3));

7513

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.unknown4));

7514

NDR_PULL_ALLOC(ndr, r->out.info);

7515

ZERO_STRUCTP(r->out.info);

7516

}

7517

if (flags & NDR_OUT) {

7518

if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {

7519

NDR_PULL_ALLOC(ndr, r->out.info);

7520

}

7521

_mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);

7522

NDR_PULL_SET_MEM_CTX(ndr, r->out.info, LIBNDR_FLAG_REF_ALLOC);

7523

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));

7524

if (_ptr_info) {

7525

NDR_PULL_ALLOC(ndr, *r->out.info);

7526

} else {

7527

*r->out.info = NULL;

7528

}

7529

if (*r->out.info) {

7530

_mem_save_info_1 = NDR_PULL_GET_MEM_CTX(ndr);

7531

NDR_PULL_SET_MEM_CTX(ndr, *r->out.info, 0);

7532

NDR_CHECK(ndr_pull_wkssvc_NetrWorkstationStatistics(ndr, NDR_SCALARS, *r->out.info));

7533

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_1, 0);

7534

}

7535

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, LIBNDR_FLAG_REF_ALLOC);

7536

NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));

7537

}

7538

return NDR_ERR_SUCCESS;

7539

}

7540

7541

_PUBLIC_ void ndr_print_wkssvc_NetrWorkstationStatisticsGet(struct ndr_print *ndr, const char *name, int flags, const struct wkssvc_NetrWorkstationStatisticsGet *r)

7542

{

7543

ndr_print_struct(ndr, name, "wkssvc_NetrWorkstationStatisticsGet");

7544

ndr->depth++;

7545

if (flags & NDR_SET_VALUES) {

7546

ndr->flags |= LIBNDR_PRINT_SET_VALUES;

7547

}

7548

if (flags & NDR_IN) {

7549

ndr_print_struct(ndr, "in", "wkssvc_NetrWorkstationStatisticsGet");

7550

ndr->depth++;

7551

ndr_print_ptr(ndr, "server_name", r->in.server_name);

7552

ndr->depth++;

7553

if (r->in.server_name) {

7554

ndr_print_string(ndr, "server_name", r->in.server_name);

7555

}

7556

ndr->depth--;

7557

ndr_print_ptr(ndr, "unknown2", r->in.unknown2);

7558

ndr->depth++;

7559

if (r->in.unknown2) {

7560

ndr_print_string(ndr, "unknown2", r->in.unknown2);

7561

}

7562

ndr->depth--;

7563

ndr_print_uint32(ndr, "unknown3", r->in.unknown3);

7564

ndr_print_uint32(ndr, "unknown4", r->in.unknown4);

7565

ndr->depth--;

7566

}

7567

if (flags & NDR_OUT) {

7568

ndr_print_struct(ndr, "out", "wkssvc_NetrWorkstationStatisticsGet");

7569

ndr->depth++;

7570

ndr_print_ptr(ndr, "info", r->out.info);

7571

ndr->depth++;

7572

ndr_print_ptr(ndr, "info", *r->out.info);

7573

ndr->depth++;

7574

if (*r->out.info) {

7575

ndr_print_wkssvc_NetrWorkstationStatistics(ndr, "info", *r->out.info);

7576

}

7577

ndr->depth--;

7578

ndr->depth--;

7579

ndr_print_WERROR(ndr, "result", r->out.result);

7580

ndr->depth--;

7581

}

7582

ndr->depth--;

7583

}

7584

7585

static enum ndr_err_code ndr_push_wkssvc_NetrLogonDomainNameAdd(struct ndr_push *ndr, int flags, const struct wkssvc_NetrLogonDomainNameAdd *r)

7586

{

7587

if (flags & NDR_IN) {

7588

if (r->in.domain_name == NULL) {

7589

return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");

7590

}

7591

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.domain_name, CH_UTF16)));

7592

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));

7593

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.domain_name, CH_UTF16)));

7594

NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.domain_name, ndr_charset_length(r->in.domain_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));

7595

}

7596

if (flags & NDR_OUT) {

7597

NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));

7598

}

7599

return NDR_ERR_SUCCESS;

7600

}

7601

7602

static enum ndr_err_code ndr_pull_wkssvc_NetrLogonDomainNameAdd(struct ndr_pull *ndr, int flags, struct wkssvc_NetrLogonDomainNameAdd *r)

7603

{

7604

if (flags & NDR_IN) {

7605

NDR_CHECK(ndr_pull_array_size(ndr, &r->in.domain_name));

7606

NDR_CHECK(ndr_pull_array_length(ndr, &r->in.domain_name));

7607

if (ndr_get_array_length(ndr, &r->in.domain_name) > ndr_get_array_size(ndr, &r->in.domain_name)) {

7608

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.domain_name), ndr_get_array_length(ndr, &r->in.domain_name));

7609

}

7610

NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.domain_name), sizeof(uint16_t)));

7611

NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.domain_name, ndr_get_array_length(ndr, &r->in.domain_name), sizeof(uint16_t), CH_UTF16));

7612

}

7613

if (flags & NDR_OUT) {

7614

NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));

7615

}

7616

return NDR_ERR_SUCCESS;

7617

}

7618

7619

_PUBLIC_ void ndr_print_wkssvc_NetrLogonDomainNameAdd(struct ndr_print *ndr, const char *name, int flags, const struct wkssvc_NetrLogonDomainNameAdd *r)

7620

{

7621

ndr_print_struct(ndr, name, "wkssvc_NetrLogonDomainNameAdd");

7622

ndr->depth++;

7623

if (flags & NDR_SET_VALUES) {

7624

ndr->flags |= LIBNDR_PRINT_SET_VALUES;

7625

}

7626

if (flags & NDR_IN) {

7627

ndr_print_struct(ndr, "in", "wkssvc_NetrLogonDomainNameAdd");

7628

ndr->depth++;

7629

ndr_print_ptr(ndr, "domain_name", r->in.domain_name);

7630

ndr->depth++;

7631

ndr_print_string(ndr, "domain_name", r->in.domain_name);

7632

ndr->depth--;

7633

ndr->depth--;

7634

}

7635

if (flags & NDR_OUT) {

7636

ndr_print_struct(ndr, "out", "wkssvc_NetrLogonDomainNameAdd");

7637

ndr->depth++;

7638

ndr_print_WERROR(ndr, "result", r->out.result);

7639

ndr->depth--;

7640

}

7641

ndr->depth--;

7642

}

7643

7644

static enum ndr_err_code ndr_push_wkssvc_NetrLogonDomainNameDel(struct ndr_push *ndr, int flags, const struct wkssvc_NetrLogonDomainNameDel *r)

7645

{

7646

if (flags & NDR_IN) {

7647

if (r->in.domain_name == NULL) {

7648

return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");

7649

}

7650

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.domain_name, CH_UTF16)));

7651

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));

7652

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.domain_name, CH_UTF16)));

7653

NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.domain_name, ndr_charset_length(r->in.domain_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));

7654

}

7655

if (flags & NDR_OUT) {

7656

NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));

7657

}

7658

return NDR_ERR_SUCCESS;

7659

}

7660

7661

static enum ndr_err_code ndr_pull_wkssvc_NetrLogonDomainNameDel(struct ndr_pull *ndr, int flags, struct wkssvc_NetrLogonDomainNameDel *r)

7662

{

7663

if (flags & NDR_IN) {

7664

NDR_CHECK(ndr_pull_array_size(ndr, &r->in.domain_name));

7665

NDR_CHECK(ndr_pull_array_length(ndr, &r->in.domain_name));

7666

if (ndr_get_array_length(ndr, &r->in.domain_name) > ndr_get_array_size(ndr, &r->in.domain_name)) {

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->in.domain_name), ndr_get_array_length(ndr, &r->in.domain_name));

7668

}

7669

NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.domain_name), sizeof(uint16_t)));

7670

NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.domain_name, ndr_get_array_length(ndr, &r->in.domain_name), sizeof(uint16_t), CH_UTF16));

7671

}

7672

if (flags & NDR_OUT) {

7673

NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));

7674

}

7675

return NDR_ERR_SUCCESS;

7676

}

7677

7678

_PUBLIC_ void ndr_print_wkssvc_NetrLogonDomainNameDel(struct ndr_print *ndr, const char *name, int flags, const struct wkssvc_NetrLogonDomainNameDel *r)

7679

{

7680

ndr_print_struct(ndr, name, "wkssvc_NetrLogonDomainNameDel");

7681

ndr->depth++;

7682

if (flags & NDR_SET_VALUES) {

7683

ndr->flags |= LIBNDR_PRINT_SET_VALUES;

7684

}

7685

if (flags & NDR_IN) {

7686

ndr_print_struct(ndr, "in", "wkssvc_NetrLogonDomainNameDel");

7687

ndr->depth++;

7688

ndr_print_ptr(ndr, "domain_name", r->in.domain_name);

7689

ndr->depth++;

7690

ndr_print_string(ndr, "domain_name", r->in.domain_name);

7691

ndr->depth--;

7692

ndr->depth--;

7693

}

7694

if (flags & NDR_OUT) {

7695

ndr_print_struct(ndr, "out", "wkssvc_NetrLogonDomainNameDel");

7696

ndr->depth++;

7697

ndr_print_WERROR(ndr, "result", r->out.result);

7698

ndr->depth--;

7699

}

7700

ndr->depth--;

7701

}

7702

7703

static enum ndr_err_code ndr_push_wkssvc_NetrJoinDomain(struct ndr_push *ndr, int flags, const struct wkssvc_NetrJoinDomain *r)

7704

{

7705

if (flags & NDR_IN) {

7706

NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server_name));

7707

if (r->in.server_name) {

7708

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));

7709

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));

7710

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));

7711

NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server_name, ndr_charset_length(r->in.server_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));

7712

}

7713

if (r->in.domain_name == NULL) {

7714

return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");

7715

}

7716

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.domain_name, CH_UTF16)));

7717

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));

7718

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.domain_name, CH_UTF16)));

7719

NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.domain_name, ndr_charset_length(r->in.domain_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));

7720

NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.account_ou));

7721

if (r->in.account_ou) {

7722

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.account_ou, CH_UTF16)));

7723

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));

7724

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.account_ou, CH_UTF16)));

7725

NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.account_ou, ndr_charset_length(r->in.account_ou, CH_UTF16), sizeof(uint16_t), CH_UTF16));

7726

}

7727

NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.Account));

7728

if (r->in.Account) {

7729

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.Account, CH_UTF16)));

7730

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));

7731

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.Account, CH_UTF16)));

7732

NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.Account, ndr_charset_length(r->in.Account, CH_UTF16), sizeof(uint16_t), CH_UTF16));

7733

}

7734

NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.password));

7735

if (r->in.password) {

7736

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.password, CH_UTF16)));

7737

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));

7738

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.password, CH_UTF16)));

7739

NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.password, ndr_charset_length(r->in.password, CH_UTF16), sizeof(uint16_t), CH_UTF16));

7740

}

7741

NDR_CHECK(ndr_push_wkssvc_joinflags(ndr, NDR_SCALARS, r->in.join_flags));

7742

}

7743

if (flags & NDR_OUT) {

7744

NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));

7745

}

7746

return NDR_ERR_SUCCESS;

7747

}

7748

7749

static enum ndr_err_code ndr_pull_wkssvc_NetrJoinDomain(struct ndr_pull *ndr, int flags, struct wkssvc_NetrJoinDomain *r)

7750

{

7751

uint32_t _ptr_server_name;

7752

uint32_t _ptr_account_ou;

7753

uint32_t _ptr_Account;

7754

uint32_t _ptr_password;

7755

TALLOC_CTX *_mem_save_server_name_0;

7756

TALLOC_CTX *_mem_save_account_ou_0;

7757

TALLOC_CTX *_mem_save_Account_0;

7758

TALLOC_CTX *_mem_save_password_0;

7759

if (flags & NDR_IN) {

7760

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_name));

7761

if (_ptr_server_name) {

7762

NDR_PULL_ALLOC(ndr, r->in.server_name);

7763

} else {

7764

r->in.server_name = NULL;

7765

}

7766

if (r->in.server_name) {

7767

_mem_save_server_name_0 = NDR_PULL_GET_MEM_CTX(ndr);

7768

NDR_PULL_SET_MEM_CTX(ndr, r->in.server_name, 0);

7769

NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_name));

7770

NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_name));

7771

if (ndr_get_array_length(ndr, &r->in.server_name) > ndr_get_array_size(ndr, &r->in.server_name)) {

7772

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_name), ndr_get_array_length(ndr, &r->in.server_name));

7773

}

7774

NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server_name), sizeof(uint16_t)));

7775

NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server_name, ndr_get_array_length(ndr, &r->in.server_name), sizeof(uint16_t), CH_UTF16));

7776

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_name_0, 0);

7777

}

7778

NDR_CHECK(ndr_pull_array_size(ndr, &r->in.domain_name));

7779

NDR_CHECK(ndr_pull_array_length(ndr, &r->in.domain_name));

7780

if (ndr_get_array_length(ndr, &r->in.domain_name) > ndr_get_array_size(ndr, &r->in.domain_name)) {

7781

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.domain_name), ndr_get_array_length(ndr, &r->in.domain_name));

7782

}

7783

NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.domain_name), sizeof(uint16_t)));

7784

NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.domain_name, ndr_get_array_length(ndr, &r->in.domain_name), sizeof(uint16_t), CH_UTF16));

7785

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_account_ou));

7786

if (_ptr_account_ou) {

7787

NDR_PULL_ALLOC(ndr, r->in.account_ou);

7788

} else {

7789

r->in.account_ou = NULL;

7790

}

7791

if (r->in.account_ou) {

7792

_mem_save_account_ou_0 = NDR_PULL_GET_MEM_CTX(ndr);

7793

NDR_PULL_SET_MEM_CTX(ndr, r->in.account_ou, 0);

7794

NDR_CHECK(ndr_pull_array_size(ndr, &r->in.account_ou));

7795

NDR_CHECK(ndr_pull_array_length(ndr, &r->in.account_ou));

7796

if (ndr_get_array_length(ndr, &r->in.account_ou) > ndr_get_array_size(ndr, &r->in.account_ou)) {

7797

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.account_ou), ndr_get_array_length(ndr, &r->in.account_ou));

7798

}

7799

NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.account_ou), sizeof(uint16_t)));

7800

NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.account_ou, ndr_get_array_length(ndr, &r->in.account_ou), sizeof(uint16_t), CH_UTF16));

7801

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_account_ou_0, 0);

7802

}

7803

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_Account));

7804

if (_ptr_Account) {

7805

NDR_PULL_ALLOC(ndr, r->in.Account);

7806

} else {

7807

r->in.Account = NULL;

7808

}

7809

if (r->in.Account) {

7810

_mem_save_Account_0 = NDR_PULL_GET_MEM_CTX(ndr);

7811

NDR_PULL_SET_MEM_CTX(ndr, r->in.Account, 0);

7812

NDR_CHECK(ndr_pull_array_size(ndr, &r->in.Account));

7813

NDR_CHECK(ndr_pull_array_length(ndr, &r->in.Account));

7814

if (ndr_get_array_length(ndr, &r->in.Account) > ndr_get_array_size(ndr, &r->in.Account)) {

7815

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.Account), ndr_get_array_length(ndr, &r->in.Account));

7816

}

7817

NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.Account), sizeof(uint16_t)));

7818

NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.Account, ndr_get_array_length(ndr, &r->in.Account), sizeof(uint16_t), CH_UTF16));

7819

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_Account_0, 0);

7820

}

7821

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_password));

7822

if (_ptr_password) {

7823

NDR_PULL_ALLOC(ndr, r->in.password);

7824

} else {

7825

r->in.password = NULL;

7826

}

7827

if (r->in.password) {

7828

_mem_save_password_0 = NDR_PULL_GET_MEM_CTX(ndr);

7829

NDR_PULL_SET_MEM_CTX(ndr, r->in.password, 0);

7830

NDR_CHECK(ndr_pull_array_size(ndr, &r->in.password));

7831

NDR_CHECK(ndr_pull_array_length(ndr, &r->in.password));

7832

if (ndr_get_array_length(ndr, &r->in.password) > ndr_get_array_size(ndr, &r->in.password)) {

7833

return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->in.password), ndr_get_array_length(ndr, &r->in.password));

7834

}

7835

NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.password), sizeof(uint16_t)));

7836

NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.password, ndr_get_array_length(ndr, &r->in.password), sizeof(uint16_t), CH_UTF16));

7837

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_password_0, 0);

7838

}

7839

NDR_CHECK(ndr_pull_wkssvc_joinflags(ndr, NDR_SCALARS, &r->in.join_flags));

7840

}

7841

if (flags & NDR_OUT) {

7842

NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));

7843

}

7844

return NDR_ERR_SUCCESS;

7845

}

7846

7847

_PUBLIC_ void ndr_print_wkssvc_NetrJoinDomain(struct ndr_print *ndr, const char *name, int flags, const struct wkssvc_NetrJoinDomain *r)

7848

{

7849

ndr_print_struct(ndr, name, "wkssvc_NetrJoinDomain");

7850

ndr->depth++;

7851

if (flags & NDR_SET_VALUES) {

7852

ndr->flags |= LIBNDR_PRINT_SET_VALUES;

7853

}

7854

if (flags & NDR_IN) {

7855

ndr_print_struct(ndr, "in", "wkssvc_NetrJoinDomain");

7856

ndr->depth++;

7857

ndr_print_ptr(ndr, "server_name", r->in.server_name);

7858

ndr->depth++;

7859

if (r->in.server_name) {

7860

ndr_print_string(ndr, "server_name", r->in.server_name);

7861

}

7862

ndr->depth--;

7863

ndr_print_ptr(ndr, "domain_name", r->in.domain_name);

7864

ndr->depth++;

7865

ndr_print_string(ndr, "domain_name", r->in.domain_name);

7866

ndr->depth--;

7867

ndr_print_ptr(ndr, "account_ou", r->in.account_ou);

7868

ndr->depth++;

7869

if (r->in.account_ou) {

7870

ndr_print_string(ndr, "account_ou", r->in.account_ou);

7871

}

7872

ndr->depth--;

7873

ndr_print_ptr(ndr, "Account", r->in.Account);

7874

ndr->depth++;

7875

if (r->in.Account) {

7876

ndr_print_string(ndr, "Account", r->in.Account);

7877

}

7878

ndr->depth--;

7879

ndr_print_ptr(ndr, "password", r->in.password);

7880

ndr->depth++;

7881

if (r->in.password) {

7882

ndr_print_string(ndr, "password", r->in.password);

7883

}

7884

ndr->depth--;

7885

ndr_print_wkssvc_joinflags(ndr, "join_flags", r->in.join_flags);

7886

ndr->depth--;

7887

}

7888

if (flags & NDR_OUT) {

7889

ndr_print_struct(ndr, "out", "wkssvc_NetrJoinDomain");

7890

ndr->depth++;

7891

ndr_print_WERROR(ndr, "result", r->out.result);

7892

ndr->depth--;

7893

}

7894

ndr->depth--;

7895

}

7896

7897

static enum ndr_err_code ndr_push_wkssvc_NetrUnjoinDomain(struct ndr_push *ndr, int flags, const struct wkssvc_NetrUnjoinDomain *r)

7898

{

7899

if (flags & NDR_IN) {

7900

NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server_name));

7901

if (r->in.server_name) {

7902

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));

7903

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));

7904

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));

7905

NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server_name, ndr_charset_length(r->in.server_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));

7906

}

7907

NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.Account));

7908

if (r->in.Account) {

7909

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.Account, CH_UTF16)));

7910

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));

7911

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.Account, CH_UTF16)));

7912

NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.Account, ndr_charset_length(r->in.Account, CH_UTF16), sizeof(uint16_t), CH_UTF16));

7913

}

7914

NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.password));

7915

if (r->in.password) {

7916

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.password, CH_UTF16)));

7917

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));

7918

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.password, CH_UTF16)));

7919

NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.password, ndr_charset_length(r->in.password, CH_UTF16), sizeof(uint16_t), CH_UTF16));

7920

}

7921

NDR_CHECK(ndr_push_wkssvc_joinflags(ndr, NDR_SCALARS, r->in.unjoin_flags));

7922

}

7923

if (flags & NDR_OUT) {

7924

NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));

7925

}

7926

return NDR_ERR_SUCCESS;

7927

}

7928

7929

static enum ndr_err_code ndr_pull_wkssvc_NetrUnjoinDomain(struct ndr_pull *ndr, int flags, struct wkssvc_NetrUnjoinDomain *r)

7930

{

7931

uint32_t _ptr_server_name;

7932

uint32_t _ptr_Account;

7933

uint32_t _ptr_password;

7934

TALLOC_CTX *_mem_save_server_name_0;

7935

TALLOC_CTX *_mem_save_Account_0;

7936

TALLOC_CTX *_mem_save_password_0;

7937

if (flags & NDR_IN) {

7938

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_name));

7939

if (_ptr_server_name) {

7940

NDR_PULL_ALLOC(ndr, r->in.server_name);

7941

} else {

7942

r->in.server_name = NULL;

7943

}

7944

if (r->in.server_name) {

7945

_mem_save_server_name_0 = NDR_PULL_GET_MEM_CTX(ndr);

7946

NDR_PULL_SET_MEM_CTX(ndr, r->in.server_name, 0);

7947

NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_name));

7948

NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_name));

7949

if (ndr_get_array_length(ndr, &r->in.server_name) > ndr_get_array_size(ndr, &r->in.server_name)) {

7950

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_name), ndr_get_array_length(ndr, &r->in.server_name));

7951

}

7952

NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server_name), sizeof(uint16_t)));

7953

NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server_name, ndr_get_array_length(ndr, &r->in.server_name), sizeof(uint16_t), CH_UTF16));

7954

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_name_0, 0);

7955

}

7956

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_Account));

7957

if (_ptr_Account) {

7958

NDR_PULL_ALLOC(ndr, r->in.Account);

7959

} else {

7960

r->in.Account = NULL;

7961

}

7962

if (r->in.Account) {

7963

_mem_save_Account_0 = NDR_PULL_GET_MEM_CTX(ndr);

7964

NDR_PULL_SET_MEM_CTX(ndr, r->in.Account, 0);

7965

NDR_CHECK(ndr_pull_array_size(ndr, &r->in.Account));

7966

NDR_CHECK(ndr_pull_array_length(ndr, &r->in.Account));

7967

if (ndr_get_array_length(ndr, &r->in.Account) > ndr_get_array_size(ndr, &r->in.Account)) {

7968

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.Account), ndr_get_array_length(ndr, &r->in.Account));

7969

}

7970

NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.Account), sizeof(uint16_t)));

7971

NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.Account, ndr_get_array_length(ndr, &r->in.Account), sizeof(uint16_t), CH_UTF16));

7972

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_Account_0, 0);

7973

}

7974

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_password));

7975

if (_ptr_password) {

7976

NDR_PULL_ALLOC(ndr, r->in.password);

7977

} else {

7978

r->in.password = NULL;

7979

}

7980

if (r->in.password) {

7981

_mem_save_password_0 = NDR_PULL_GET_MEM_CTX(ndr);

7982

NDR_PULL_SET_MEM_CTX(ndr, r->in.password, 0);

7983

NDR_CHECK(ndr_pull_array_size(ndr, &r->in.password));

7984

NDR_CHECK(ndr_pull_array_length(ndr, &r->in.password));

7985

if (ndr_get_array_length(ndr, &r->in.password) > ndr_get_array_size(ndr, &r->in.password)) {

7986

return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->in.password), ndr_get_array_length(ndr, &r->in.password));

7987

}

7988

NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.password), sizeof(uint16_t)));

7989

NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.password, ndr_get_array_length(ndr, &r->in.password), sizeof(uint16_t), CH_UTF16));

7990

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_password_0, 0);

7991

}

7992

NDR_CHECK(ndr_pull_wkssvc_joinflags(ndr, NDR_SCALARS, &r->in.unjoin_flags));

7993

}

7994

if (flags & NDR_OUT) {

7995

NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));

7996

}

7997

return NDR_ERR_SUCCESS;

7998

}

7999

8000

_PUBLIC_ void ndr_print_wkssvc_NetrUnjoinDomain(struct ndr_print *ndr, const char *name, int flags, const struct wkssvc_NetrUnjoinDomain *r)

8001

{

8002

ndr_print_struct(ndr, name, "wkssvc_NetrUnjoinDomain");

8003

ndr->depth++;

8004

if (flags & NDR_SET_VALUES) {

8005

ndr->flags |= LIBNDR_PRINT_SET_VALUES;

8006

}

8007

if (flags & NDR_IN) {

8008

ndr_print_struct(ndr, "in", "wkssvc_NetrUnjoinDomain");

8009

ndr->depth++;

8010

ndr_print_ptr(ndr, "server_name", r->in.server_name);

8011

ndr->depth++;

8012

if (r->in.server_name) {

8013

ndr_print_string(ndr, "server_name", r->in.server_name);

8014

}

8015

ndr->depth--;

8016

ndr_print_ptr(ndr, "Account", r->in.Account);

8017

ndr->depth++;

8018

if (r->in.Account) {

8019

ndr_print_string(ndr, "Account", r->in.Account);

8020

}

8021

ndr->depth--;

8022

ndr_print_ptr(ndr, "password", r->in.password);

8023

ndr->depth++;

8024

if (r->in.password) {

8025

ndr_print_string(ndr, "password", r->in.password);

8026

}

8027

ndr->depth--;

8028

ndr_print_wkssvc_joinflags(ndr, "unjoin_flags", r->in.unjoin_flags);

8029

ndr->depth--;

8030

}

8031

if (flags & NDR_OUT) {

8032

ndr_print_struct(ndr, "out", "wkssvc_NetrUnjoinDomain");

8033

ndr->depth++;

8034

ndr_print_WERROR(ndr, "result", r->out.result);

8035

ndr->depth--;

8036

}

8037

ndr->depth--;

8038

}

8039

8040

static enum ndr_err_code ndr_push_wkssvc_NetrRenameMachineInDomain(struct ndr_push *ndr, int flags, const struct wkssvc_NetrRenameMachineInDomain *r)

8041

{

8042

if (flags & NDR_IN) {

8043

NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server_name));

8044

if (r->in.server_name) {

8045

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));

8046

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));

8047

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));

8048

NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server_name, ndr_charset_length(r->in.server_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));

8049

}

8050

NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.NewMachineName));

8051

if (r->in.NewMachineName) {

8052

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.NewMachineName, CH_UTF16)));

8053

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));

8054

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.NewMachineName, CH_UTF16)));

8055

NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.NewMachineName, ndr_charset_length(r->in.NewMachineName, CH_UTF16), sizeof(uint16_t), CH_UTF16));

8056

}

8057

NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.Account));

8058

if (r->in.Account) {

8059

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.Account, CH_UTF16)));

8060

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));

8061

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.Account, CH_UTF16)));

8062

NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.Account, ndr_charset_length(r->in.Account, CH_UTF16), sizeof(uint16_t), CH_UTF16));

8063

}

8064

NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.password));

8065

if (r->in.password) {

8066

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.password, CH_UTF16)));

8067

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));

8068

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.password, CH_UTF16)));

8069

NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.password, ndr_charset_length(r->in.password, CH_UTF16), sizeof(uint16_t), CH_UTF16));

8070

}

8071

NDR_CHECK(ndr_push_wkssvc_renameflags(ndr, NDR_SCALARS, r->in.RenameOptions));

8072

}

8073

if (flags & NDR_OUT) {

8074

NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));

8075

}

8076

return NDR_ERR_SUCCESS;

8077

}

8078

8079

static enum ndr_err_code ndr_pull_wkssvc_NetrRenameMachineInDomain(struct ndr_pull *ndr, int flags, struct wkssvc_NetrRenameMachineInDomain *r)

8080

{

8081

uint32_t _ptr_server_name;

8082

uint32_t _ptr_NewMachineName;

8083

uint32_t _ptr_Account;

8084

uint32_t _ptr_password;

8085

TALLOC_CTX *_mem_save_server_name_0;

8086

TALLOC_CTX *_mem_save_NewMachineName_0;

8087

TALLOC_CTX *_mem_save_Account_0;

8088

TALLOC_CTX *_mem_save_password_0;

8089

if (flags & NDR_IN) {

8090

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_name));

8091

if (_ptr_server_name) {

8092

NDR_PULL_ALLOC(ndr, r->in.server_name);

8093

} else {

8094

r->in.server_name = NULL;

8095

}

8096

if (r->in.server_name) {

8097

_mem_save_server_name_0 = NDR_PULL_GET_MEM_CTX(ndr);

8098

NDR_PULL_SET_MEM_CTX(ndr, r->in.server_name, 0);

8099

NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_name));

8100

NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_name));

8101

if (ndr_get_array_length(ndr, &r->in.server_name) > ndr_get_array_size(ndr, &r->in.server_name)) {

8102

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_name), ndr_get_array_length(ndr, &r->in.server_name));

8103

}

8104

NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server_name), sizeof(uint16_t)));

8105

NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server_name, ndr_get_array_length(ndr, &r->in.server_name), sizeof(uint16_t), CH_UTF16));

8106

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_name_0, 0);

8107

}

8108

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_NewMachineName));

8109

if (_ptr_NewMachineName) {

8110

NDR_PULL_ALLOC(ndr, r->in.NewMachineName);

8111

} else {

8112

r->in.NewMachineName = NULL;

8113

}

8114

if (r->in.NewMachineName) {

8115

_mem_save_NewMachineName_0 = NDR_PULL_GET_MEM_CTX(ndr);

8116

NDR_PULL_SET_MEM_CTX(ndr, r->in.NewMachineName, 0);

8117

NDR_CHECK(ndr_pull_array_size(ndr, &r->in.NewMachineName));

8118

NDR_CHECK(ndr_pull_array_length(ndr, &r->in.NewMachineName));

8119

if (ndr_get_array_length(ndr, &r->in.NewMachineName) > ndr_get_array_size(ndr, &r->in.NewMachineName)) {

8120

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.NewMachineName), ndr_get_array_length(ndr, &r->in.NewMachineName));

8121

}

8122

NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.NewMachineName), sizeof(uint16_t)));

8123

NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.NewMachineName, ndr_get_array_length(ndr, &r->in.NewMachineName), sizeof(uint16_t), CH_UTF16));

8124

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_NewMachineName_0, 0);

8125

}

8126

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_Account));

8127

if (_ptr_Account) {

8128

NDR_PULL_ALLOC(ndr, r->in.Account);

8129

} else {

8130

r->in.Account = NULL;

8131

}

8132

if (r->in.Account) {

8133

_mem_save_Account_0 = NDR_PULL_GET_MEM_CTX(ndr);

8134

NDR_PULL_SET_MEM_CTX(ndr, r->in.Account, 0);

8135

NDR_CHECK(ndr_pull_array_size(ndr, &r->in.Account));

8136

NDR_CHECK(ndr_pull_array_length(ndr, &r->in.Account));

8137

if (ndr_get_array_length(ndr, &r->in.Account) > ndr_get_array_size(ndr, &r->in.Account)) {

8138

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.Account), ndr_get_array_length(ndr, &r->in.Account));

8139

}

8140

NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.Account), sizeof(uint16_t)));

8141

NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.Account, ndr_get_array_length(ndr, &r->in.Account), sizeof(uint16_t), CH_UTF16));

8142

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_Account_0, 0);

8143

}

8144

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_password));

8145

if (_ptr_password) {

8146

NDR_PULL_ALLOC(ndr, r->in.password);

8147

} else {

8148

r->in.password = NULL;

8149

}

8150

if (r->in.password) {

8151

_mem_save_password_0 = NDR_PULL_GET_MEM_CTX(ndr);

8152

NDR_PULL_SET_MEM_CTX(ndr, r->in.password, 0);

8153

NDR_CHECK(ndr_pull_array_size(ndr, &r->in.password));

8154

NDR_CHECK(ndr_pull_array_length(ndr, &r->in.password));

8155

if (ndr_get_array_length(ndr, &r->in.password) > ndr_get_array_size(ndr, &r->in.password)) {

8156

return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->in.password), ndr_get_array_length(ndr, &r->in.password));

8157

}

8158

NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.password), sizeof(uint16_t)));

8159

NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.password, ndr_get_array_length(ndr, &r->in.password), sizeof(uint16_t), CH_UTF16));

8160

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_password_0, 0);

8161

}

8162

NDR_CHECK(ndr_pull_wkssvc_renameflags(ndr, NDR_SCALARS, &r->in.RenameOptions));

8163

}

8164

if (flags & NDR_OUT) {

8165

NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));

8166

}

8167

return NDR_ERR_SUCCESS;

8168

}

8169

8170

_PUBLIC_ void ndr_print_wkssvc_NetrRenameMachineInDomain(struct ndr_print *ndr, const char *name, int flags, const struct wkssvc_NetrRenameMachineInDomain *r)

8171

{

8172

ndr_print_struct(ndr, name, "wkssvc_NetrRenameMachineInDomain");

8173

ndr->depth++;

8174

if (flags & NDR_SET_VALUES) {

8175

ndr->flags |= LIBNDR_PRINT_SET_VALUES;

8176

}

8177

if (flags & NDR_IN) {

8178

ndr_print_struct(ndr, "in", "wkssvc_NetrRenameMachineInDomain");

8179

ndr->depth++;

8180

ndr_print_ptr(ndr, "server_name", r->in.server_name);

8181

ndr->depth++;

8182

if (r->in.server_name) {

8183

ndr_print_string(ndr, "server_name", r->in.server_name);

8184

}

8185

ndr->depth--;

8186

ndr_print_ptr(ndr, "NewMachineName", r->in.NewMachineName);

8187

ndr->depth++;

8188

if (r->in.NewMachineName) {

8189

ndr_print_string(ndr, "NewMachineName", r->in.NewMachineName);

8190

}

8191

ndr->depth--;

8192

ndr_print_ptr(ndr, "Account", r->in.Account);

8193

ndr->depth++;

8194

if (r->in.Account) {

8195

ndr_print_string(ndr, "Account", r->in.Account);

8196

}

8197

ndr->depth--;

8198

ndr_print_ptr(ndr, "password", r->in.password);

8199

ndr->depth++;

8200

if (r->in.password) {

8201

ndr_print_string(ndr, "password", r->in.password);

8202

}

8203

ndr->depth--;

8204

ndr_print_wkssvc_renameflags(ndr, "RenameOptions", r->in.RenameOptions);

8205

ndr->depth--;

8206

}

8207

if (flags & NDR_OUT) {

8208

ndr_print_struct(ndr, "out", "wkssvc_NetrRenameMachineInDomain");

8209

ndr->depth++;

8210

ndr_print_WERROR(ndr, "result", r->out.result);

8211

ndr->depth--;

8212

}

8213

ndr->depth--;

8214

}

8215

8216

static enum ndr_err_code ndr_push_wkssvc_NetrValidateName(struct ndr_push *ndr, int flags, const struct wkssvc_NetrValidateName *r)

8217

{

8218

if (flags & NDR_IN) {

8219

NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server_name));

8220

if (r->in.server_name) {

8221

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));

8222

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));

8223

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));

8224

NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server_name, ndr_charset_length(r->in.server_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));

8225

}

8226

if (r->in.name == NULL) {

8227

return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");

8228

}

8229

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.name, CH_UTF16)));

8230

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));

8231

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.name, CH_UTF16)));

8232

NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.name, ndr_charset_length(r->in.name, CH_UTF16), sizeof(uint16_t), CH_UTF16));

8233

NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.Account));

8234

if (r->in.Account) {

8235

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.Account, CH_UTF16)));

8236

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));

8237

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.Account, CH_UTF16)));

8238

NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.Account, ndr_charset_length(r->in.Account, CH_UTF16), sizeof(uint16_t), CH_UTF16));

8239

}

8240

NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.Password));

8241

if (r->in.Password) {

8242

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.Password, CH_UTF16)));

8243

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));

8244

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.Password, CH_UTF16)));

8245

NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.Password, ndr_charset_length(r->in.Password, CH_UTF16), sizeof(uint16_t), CH_UTF16));

8246

}

8247

NDR_CHECK(ndr_push_wkssvc_NetValidateNameType(ndr, NDR_SCALARS, r->in.name_type));

8248

}

8249

if (flags & NDR_OUT) {

8250

NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));

8251

}

8252

return NDR_ERR_SUCCESS;

8253

}

8254

8255

static enum ndr_err_code ndr_pull_wkssvc_NetrValidateName(struct ndr_pull *ndr, int flags, struct wkssvc_NetrValidateName *r)

8256

{

8257

uint32_t _ptr_server_name;

8258

uint32_t _ptr_Account;

8259

uint32_t _ptr_Password;

8260

TALLOC_CTX *_mem_save_server_name_0;

8261

TALLOC_CTX *_mem_save_Account_0;

8262

TALLOC_CTX *_mem_save_Password_0;

8263

if (flags & NDR_IN) {

8264

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_name));

8265

if (_ptr_server_name) {

8266

NDR_PULL_ALLOC(ndr, r->in.server_name);

8267

} else {

8268

r->in.server_name = NULL;

8269

}

8270

if (r->in.server_name) {

8271

_mem_save_server_name_0 = NDR_PULL_GET_MEM_CTX(ndr);

8272

NDR_PULL_SET_MEM_CTX(ndr, r->in.server_name, 0);

8273

NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_name));

8274

NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_name));

8275

if (ndr_get_array_length(ndr, &r->in.server_name) > ndr_get_array_size(ndr, &r->in.server_name)) {

8276

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_name), ndr_get_array_length(ndr, &r->in.server_name));

8277

}

8278

NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server_name), sizeof(uint16_t)));

8279

NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server_name, ndr_get_array_length(ndr, &r->in.server_name), sizeof(uint16_t), CH_UTF16));

8280

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_name_0, 0);

8281

}

8282

NDR_CHECK(ndr_pull_array_size(ndr, &r->in.name));

8283

NDR_CHECK(ndr_pull_array_length(ndr, &r->in.name));

8284

if (ndr_get_array_length(ndr, &r->in.name) > ndr_get_array_size(ndr, &r->in.name)) {

8285

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));

8286

}

8287

NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.name), sizeof(uint16_t)));

8288

NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.name, ndr_get_array_length(ndr, &r->in.name), sizeof(uint16_t), CH_UTF16));

8289

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_Account));

8290

if (_ptr_Account) {

8291

NDR_PULL_ALLOC(ndr, r->in.Account);

8292

} else {

8293

r->in.Account = NULL;

8294

}

8295

if (r->in.Account) {

8296

_mem_save_Account_0 = NDR_PULL_GET_MEM_CTX(ndr);

8297

NDR_PULL_SET_MEM_CTX(ndr, r->in.Account, 0);

8298

NDR_CHECK(ndr_pull_array_size(ndr, &r->in.Account));

8299

NDR_CHECK(ndr_pull_array_length(ndr, &r->in.Account));

8300

if (ndr_get_array_length(ndr, &r->in.Account) > ndr_get_array_size(ndr, &r->in.Account)) {

8301

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.Account), ndr_get_array_length(ndr, &r->in.Account));

8302

}

8303

NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.Account), sizeof(uint16_t)));

8304

NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.Account, ndr_get_array_length(ndr, &r->in.Account), sizeof(uint16_t), CH_UTF16));

8305

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_Account_0, 0);

8306

}

8307

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_Password));

8308

if (_ptr_Password) {

8309

NDR_PULL_ALLOC(ndr, r->in.Password);

8310

} else {

8311

r->in.Password = NULL;

8312

}

8313

if (r->in.Password) {

8314

_mem_save_Password_0 = NDR_PULL_GET_MEM_CTX(ndr);

8315

NDR_PULL_SET_MEM_CTX(ndr, r->in.Password, 0);

8316

NDR_CHECK(ndr_pull_array_size(ndr, &r->in.Password));

8317

NDR_CHECK(ndr_pull_array_length(ndr, &r->in.Password));

8318

if (ndr_get_array_length(ndr, &r->in.Password) > ndr_get_array_size(ndr, &r->in.Password)) {

8319

return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->in.Password), ndr_get_array_length(ndr, &r->in.Password));

8320

}

8321

NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.Password), sizeof(uint16_t)));

8322

NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.Password, ndr_get_array_length(ndr, &r->in.Password), sizeof(uint16_t), CH_UTF16));

8323

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_Password_0, 0);

8324

}

8325

NDR_CHECK(ndr_pull_wkssvc_NetValidateNameType(ndr, NDR_SCALARS, &r->in.name_type));

8326

}

8327

if (flags & NDR_OUT) {

8328

NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));

8329

}

8330

return NDR_ERR_SUCCESS;

8331

}

8332

8333

_PUBLIC_ void ndr_print_wkssvc_NetrValidateName(struct ndr_print *ndr, const char *name, int flags, const struct wkssvc_NetrValidateName *r)

8334

{

8335

ndr_print_struct(ndr, name, "wkssvc_NetrValidateName");

8336

ndr->depth++;

8337

if (flags & NDR_SET_VALUES) {

8338

ndr->flags |= LIBNDR_PRINT_SET_VALUES;

8339

}

8340

if (flags & NDR_IN) {

8341

ndr_print_struct(ndr, "in", "wkssvc_NetrValidateName");

8342

ndr->depth++;

8343

ndr_print_ptr(ndr, "server_name", r->in.server_name);

8344

ndr->depth++;

8345

if (r->in.server_name) {

8346

ndr_print_string(ndr, "server_name", r->in.server_name);

8347

}

8348

ndr->depth--;

8349

ndr_print_ptr(ndr, "name", r->in.name);

8350

ndr->depth++;

8351

ndr_print_string(ndr, "name", r->in.name);

8352

ndr->depth--;

8353

ndr_print_ptr(ndr, "Account", r->in.Account);

8354

ndr->depth++;

8355

if (r->in.Account) {

8356

ndr_print_string(ndr, "Account", r->in.Account);

8357

}

8358

ndr->depth--;

8359

ndr_print_ptr(ndr, "Password", r->in.Password);

8360

ndr->depth++;

8361

if (r->in.Password) {

8362

ndr_print_string(ndr, "Password", r->in.Password);

8363

}

8364

ndr->depth--;

8365

ndr_print_wkssvc_NetValidateNameType(ndr, "name_type", r->in.name_type);

8366

ndr->depth--;

8367

}

8368

if (flags & NDR_OUT) {

8369

ndr_print_struct(ndr, "out", "wkssvc_NetrValidateName");

8370

ndr->depth++;

8371

ndr_print_WERROR(ndr, "result", r->out.result);

8372

ndr->depth--;

8373

}

8374

ndr->depth--;

8375

}

8376

8377

static enum ndr_err_code ndr_push_wkssvc_NetrGetJoinInformation(struct ndr_push *ndr, int flags, const struct wkssvc_NetrGetJoinInformation *r)

8378

{

8379

if (flags & NDR_IN) {

8380

NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server_name));

8381

if (r->in.server_name) {

8382

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));

8383

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));

8384

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));

8385

NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server_name, ndr_charset_length(r->in.server_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));

8386

}

8387

if (r->in.name_buffer == NULL) {

8388

return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");

8389

}

8390

NDR_CHECK(ndr_push_unique_ptr(ndr, *r->in.name_buffer));

8391

if (*r->in.name_buffer) {

8392

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(*r->in.name_buffer, CH_UTF16)));

8393

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));

8394

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(*r->in.name_buffer, CH_UTF16)));

8395

NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, *r->in.name_buffer, ndr_charset_length(*r->in.name_buffer, CH_UTF16), sizeof(uint16_t), CH_UTF16));

8396

}

8397

}

8398

if (flags & NDR_OUT) {

8399

if (r->out.name_buffer == NULL) {

8400

return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");

8401

}

8402

NDR_CHECK(ndr_push_unique_ptr(ndr, *r->out.name_buffer));

8403

if (*r->out.name_buffer) {

8404

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(*r->out.name_buffer, CH_UTF16)));

8405

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));

8406

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(*r->out.name_buffer, CH_UTF16)));

8407

NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, *r->out.name_buffer, ndr_charset_length(*r->out.name_buffer, CH_UTF16), sizeof(uint16_t), CH_UTF16));

8408

}

8409

if (r->out.name_type == NULL) {

8410

return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");

8411

}

8412

NDR_CHECK(ndr_push_wkssvc_NetJoinStatus(ndr, NDR_SCALARS, *r->out.name_type));

8413

NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));

8414

}

8415

return NDR_ERR_SUCCESS;

8416

}

8417

8418

static enum ndr_err_code ndr_pull_wkssvc_NetrGetJoinInformation(struct ndr_pull *ndr, int flags, struct wkssvc_NetrGetJoinInformation *r)

8419

{

8420

uint32_t _ptr_server_name;

8421

uint32_t _ptr_name_buffer;

8422

TALLOC_CTX *_mem_save_server_name_0;

8423

TALLOC_CTX *_mem_save_name_buffer_0;

8424

TALLOC_CTX *_mem_save_name_buffer_1;

8425

TALLOC_CTX *_mem_save_name_type_0;

8426

if (flags & NDR_IN) {

8427

ZERO_STRUCT(r->out);

8428

8429

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_name));

8430

if (_ptr_server_name) {

8431

NDR_PULL_ALLOC(ndr, r->in.server_name);

8432

} else {

8433

r->in.server_name = NULL;

8434

}

8435

if (r->in.server_name) {

8436

_mem_save_server_name_0 = NDR_PULL_GET_MEM_CTX(ndr);

8437

NDR_PULL_SET_MEM_CTX(ndr, r->in.server_name, 0);

8438

NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_name));

8439

NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_name));

8440

if (ndr_get_array_length(ndr, &r->in.server_name) > ndr_get_array_size(ndr, &r->in.server_name)) {

8441

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_name), ndr_get_array_length(ndr, &r->in.server_name));

8442

}

8443

NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server_name), sizeof(uint16_t)));

8444

NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server_name, ndr_get_array_length(ndr, &r->in.server_name), sizeof(uint16_t), CH_UTF16));

8445

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_name_0, 0);

8446

}

8447

if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {

8448

NDR_PULL_ALLOC(ndr, r->in.name_buffer);

8449

}

8450

_mem_save_name_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);

8451

NDR_PULL_SET_MEM_CTX(ndr, r->in.name_buffer, LIBNDR_FLAG_REF_ALLOC);

8452

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_name_buffer));

8453

if (_ptr_name_buffer) {

8454

NDR_PULL_ALLOC(ndr, *r->in.name_buffer);

8455

} else {

8456

*r->in.name_buffer = NULL;

8457

}

8458

if (*r->in.name_buffer) {

8459

_mem_save_name_buffer_1 = NDR_PULL_GET_MEM_CTX(ndr);

8460

NDR_PULL_SET_MEM_CTX(ndr, *r->in.name_buffer, 0);

8461

NDR_CHECK(ndr_pull_array_size(ndr, r->in.name_buffer));

8462

NDR_CHECK(ndr_pull_array_length(ndr, r->in.name_buffer));

8463

if (ndr_get_array_length(ndr, r->in.name_buffer) > ndr_get_array_size(ndr, r->in.name_buffer)) {

8464

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_buffer), ndr_get_array_length(ndr, r->in.name_buffer));

8465

}

8466

NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, r->in.name_buffer), sizeof(uint16_t)));

8467

NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, r->in.name_buffer, ndr_get_array_length(ndr, r->in.name_buffer), sizeof(uint16_t), CH_UTF16));

8468

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_name_buffer_1, 0);

8469

}

8470

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_name_buffer_0, LIBNDR_FLAG_REF_ALLOC);

8471

NDR_PULL_ALLOC(ndr, r->out.name_buffer);

8472

*r->out.name_buffer = *r->in.name_buffer;

8473

NDR_PULL_ALLOC(ndr, r->out.name_type);

8474

ZERO_STRUCTP(r->out.name_type);

8475

}

8476

if (flags & NDR_OUT) {

8477

if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {

8478

NDR_PULL_ALLOC(ndr, r->out.name_buffer);

8479

}

8480

_mem_save_name_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);

8481

NDR_PULL_SET_MEM_CTX(ndr, r->out.name_buffer, LIBNDR_FLAG_REF_ALLOC);

8482

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_name_buffer));

8483

if (_ptr_name_buffer) {

8484

NDR_PULL_ALLOC(ndr, *r->out.name_buffer);

8485

} else {

8486

*r->out.name_buffer = NULL;

8487

}

8488

if (*r->out.name_buffer) {

8489

_mem_save_name_buffer_1 = NDR_PULL_GET_MEM_CTX(ndr);

8490

NDR_PULL_SET_MEM_CTX(ndr, *r->out.name_buffer, 0);

8491

NDR_CHECK(ndr_pull_array_size(ndr, r->out.name_buffer));

8492

NDR_CHECK(ndr_pull_array_length(ndr, r->out.name_buffer));

8493

if (ndr_get_array_length(ndr, r->out.name_buffer) > ndr_get_array_size(ndr, r->out.name_buffer)) {

8494

return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, r->out.name_buffer), ndr_get_array_length(ndr, r->out.name_buffer));

8495

}

8496

NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, r->out.name_buffer), sizeof(uint16_t)));

8497

NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, r->out.name_buffer, ndr_get_array_length(ndr, r->out.name_buffer), sizeof(uint16_t), CH_UTF16));

8498

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_name_buffer_1, 0);

8499

}

8500

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_name_buffer_0, LIBNDR_FLAG_REF_ALLOC);

8501

if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {

8502

NDR_PULL_ALLOC(ndr, r->out.name_type);

8503

}

8504

_mem_save_name_type_0 = NDR_PULL_GET_MEM_CTX(ndr);

8505

NDR_PULL_SET_MEM_CTX(ndr, r->out.name_type, LIBNDR_FLAG_REF_ALLOC);

8506

NDR_CHECK(ndr_pull_wkssvc_NetJoinStatus(ndr, NDR_SCALARS, r->out.name_type));

8507

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_name_type_0, LIBNDR_FLAG_REF_ALLOC);

8508

NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));

8509

}

8510

return NDR_ERR_SUCCESS;

8511

}

8512

8513

_PUBLIC_ void ndr_print_wkssvc_NetrGetJoinInformation(struct ndr_print *ndr, const char *name, int flags, const struct wkssvc_NetrGetJoinInformation *r)

8514

{

8515

ndr_print_struct(ndr, name, "wkssvc_NetrGetJoinInformation");

8516

ndr->depth++;

8517

if (flags & NDR_SET_VALUES) {

8518

ndr->flags |= LIBNDR_PRINT_SET_VALUES;

8519

}

8520

if (flags & NDR_IN) {

8521

ndr_print_struct(ndr, "in", "wkssvc_NetrGetJoinInformation");

8522

ndr->depth++;

8523

ndr_print_ptr(ndr, "server_name", r->in.server_name);

8524

ndr->depth++;

8525

if (r->in.server_name) {

8526

ndr_print_string(ndr, "server_name", r->in.server_name);

8527

}

8528

ndr->depth--;

8529

ndr_print_ptr(ndr, "name_buffer", r->in.name_buffer);

8530

ndr->depth++;

8531

ndr_print_ptr(ndr, "name_buffer", *r->in.name_buffer);

8532

ndr->depth++;

8533

if (*r->in.name_buffer) {

8534

ndr_print_string(ndr, "name_buffer", *r->in.name_buffer);

8535

}

8536

ndr->depth--;

8537

ndr->depth--;

8538

ndr->depth--;

8539

}

8540

if (flags & NDR_OUT) {

8541

ndr_print_struct(ndr, "out", "wkssvc_NetrGetJoinInformation");

8542

ndr->depth++;

8543

ndr_print_ptr(ndr, "name_buffer", r->out.name_buffer);

8544

ndr->depth++;

8545

ndr_print_ptr(ndr, "name_buffer", *r->out.name_buffer);

8546

ndr->depth++;

8547

if (*r->out.name_buffer) {

8548

ndr_print_string(ndr, "name_buffer", *r->out.name_buffer);

8549

}

8550

ndr->depth--;

8551

ndr->depth--;

8552

ndr_print_ptr(ndr, "name_type", r->out.name_type);

8553

ndr->depth++;

8554

ndr_print_wkssvc_NetJoinStatus(ndr, "name_type", *r->out.name_type);

8555

ndr->depth--;

8556

ndr_print_WERROR(ndr, "result", r->out.result);

8557

ndr->depth--;

8558

}

8559

ndr->depth--;

8560

}

8561

8562

static enum ndr_err_code ndr_push_wkssvc_NetrGetJoinableOus(struct ndr_push *ndr, int flags, const struct wkssvc_NetrGetJoinableOus *r)

8563

{

8564

uint32_t cntr_ous_2;

8565

if (flags & NDR_IN) {

8566

NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server_name));

8567

if (r->in.server_name) {

8568

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));

8569

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));

8570

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));

8571

NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server_name, ndr_charset_length(r->in.server_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));

8572

}

8573

if (r->in.domain_name == NULL) {

8574

return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");

8575

}

8576

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.domain_name, CH_UTF16)));

8577

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));

8578

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.domain_name, CH_UTF16)));

8579

NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.domain_name, ndr_charset_length(r->in.domain_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));

8580

NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.Account));

8581

if (r->in.Account) {

8582

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.Account, CH_UTF16)));

8583

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));

8584

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.Account, CH_UTF16)));

8585

NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.Account, ndr_charset_length(r->in.Account, CH_UTF16), sizeof(uint16_t), CH_UTF16));

8586

}

8587

NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.unknown));

8588

if (r->in.unknown) {

8589

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.unknown, CH_UTF16)));

8590

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));

8591

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.unknown, CH_UTF16)));

8592

NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.unknown, ndr_charset_length(r->in.unknown, CH_UTF16), sizeof(uint16_t), CH_UTF16));

8593

}

8594

if (r->in.num_ous == NULL) {

8595

return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");

8596

}

8597

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->in.num_ous));

8598

}

8599

if (flags & NDR_OUT) {

8600

if (r->out.num_ous == NULL) {

8601

return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");

8602

}

8603

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.num_ous));

8604

if (r->out.ous == NULL) {

8605

return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");

8606

}

8607

NDR_CHECK(ndr_push_unique_ptr(ndr, *r->out.ous));

8608

if (*r->out.ous) {

8609

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.num_ous));

8610

for (cntr_ous_2 = 0; cntr_ous_2 < *r->out.num_ous; cntr_ous_2++) {

8611

NDR_CHECK(ndr_push_unique_ptr(ndr, (*r->out.ous)[cntr_ous_2]));

8612

}

8613

for (cntr_ous_2 = 0; cntr_ous_2 < *r->out.num_ous; cntr_ous_2++) {

8614

if ((*r->out.ous)[cntr_ous_2]) {

8615

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length((*r->out.ous)[cntr_ous_2], CH_UTF16)));

8616

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));

8617

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length((*r->out.ous)[cntr_ous_2], CH_UTF16)));

8618

NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, (*r->out.ous)[cntr_ous_2], ndr_charset_length((*r->out.ous)[cntr_ous_2], CH_UTF16), sizeof(uint16_t), CH_UTF16));

8619

}

8620

}

8621

}

8622

NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));

8623

}

8624

return NDR_ERR_SUCCESS;

8625

}

8626

8627

static enum ndr_err_code ndr_pull_wkssvc_NetrGetJoinableOus(struct ndr_pull *ndr, int flags, struct wkssvc_NetrGetJoinableOus *r)

8628

{

8629

uint32_t _ptr_server_name;

8630

uint32_t _ptr_Account;

8631

uint32_t _ptr_unknown;

8632

uint32_t _ptr_ous;

8633

uint32_t cntr_ous_2;

8634

TALLOC_CTX *_mem_save_server_name_0;

8635

TALLOC_CTX *_mem_save_Account_0;

8636

TALLOC_CTX *_mem_save_unknown_0;

8637

TALLOC_CTX *_mem_save_num_ous_0;

8638

TALLOC_CTX *_mem_save_ous_0;

8639

TALLOC_CTX *_mem_save_ous_1;

8640

TALLOC_CTX *_mem_save_ous_2;

8641

TALLOC_CTX *_mem_save_ous_3;

8642

if (flags & NDR_IN) {

8643

ZERO_STRUCT(r->out);

8644

8645

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_name));

8646

if (_ptr_server_name) {

8647

NDR_PULL_ALLOC(ndr, r->in.server_name);

8648

} else {

8649

r->in.server_name = NULL;

8650

}

8651

if (r->in.server_name) {

8652

_mem_save_server_name_0 = NDR_PULL_GET_MEM_CTX(ndr);

8653

NDR_PULL_SET_MEM_CTX(ndr, r->in.server_name, 0);

8654

NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_name));

8655

NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_name));

8656

if (ndr_get_array_length(ndr, &r->in.server_name) > ndr_get_array_size(ndr, &r->in.server_name)) {

8657

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_name), ndr_get_array_length(ndr, &r->in.server_name));

8658

}

8659

NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server_name), sizeof(uint16_t)));

8660

NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server_name, ndr_get_array_length(ndr, &r->in.server_name), sizeof(uint16_t), CH_UTF16));

8661

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_name_0, 0);

8662

}

8663

NDR_CHECK(ndr_pull_array_size(ndr, &r->in.domain_name));

8664

NDR_CHECK(ndr_pull_array_length(ndr, &r->in.domain_name));

8665

if (ndr_get_array_length(ndr, &r->in.domain_name) > ndr_get_array_size(ndr, &r->in.domain_name)) {

8666

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.domain_name), ndr_get_array_length(ndr, &r->in.domain_name));

8667

}

8668

NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.domain_name), sizeof(uint16_t)));

8669

NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.domain_name, ndr_get_array_length(ndr, &r->in.domain_name), sizeof(uint16_t), CH_UTF16));

8670

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_Account));

8671

if (_ptr_Account) {

8672

NDR_PULL_ALLOC(ndr, r->in.Account);

8673

} else {

8674

r->in.Account = NULL;

8675

}

8676

if (r->in.Account) {

8677

_mem_save_Account_0 = NDR_PULL_GET_MEM_CTX(ndr);

8678

NDR_PULL_SET_MEM_CTX(ndr, r->in.Account, 0);

8679

NDR_CHECK(ndr_pull_array_size(ndr, &r->in.Account));

8680

NDR_CHECK(ndr_pull_array_length(ndr, &r->in.Account));

8681

if (ndr_get_array_length(ndr, &r->in.Account) > ndr_get_array_size(ndr, &r->in.Account)) {

8682

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.Account), ndr_get_array_length(ndr, &r->in.Account));

8683

}

8684

NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.Account), sizeof(uint16_t)));

8685

NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.Account, ndr_get_array_length(ndr, &r->in.Account), sizeof(uint16_t), CH_UTF16));

8686

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_Account_0, 0);

8687

}

8688

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_unknown));

8689

if (_ptr_unknown) {

8690

NDR_PULL_ALLOC(ndr, r->in.unknown);

8691

} else {

8692

r->in.unknown = NULL;

8693

}

8694

if (r->in.unknown) {

8695

_mem_save_unknown_0 = NDR_PULL_GET_MEM_CTX(ndr);

8696

NDR_PULL_SET_MEM_CTX(ndr, r->in.unknown, 0);

8697

NDR_CHECK(ndr_pull_array_size(ndr, &r->in.unknown));

8698

NDR_CHECK(ndr_pull_array_length(ndr, &r->in.unknown));

8699

if (ndr_get_array_length(ndr, &r->in.unknown) > ndr_get_array_size(ndr, &r->in.unknown)) {

8700

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.unknown), ndr_get_array_length(ndr, &r->in.unknown));

8701

}

8702

NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.unknown), sizeof(uint16_t)));

8703

NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.unknown, ndr_get_array_length(ndr, &r->in.unknown), sizeof(uint16_t), CH_UTF16));

8704

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_unknown_0, 0);

8705

}

8706

if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {

8707

NDR_PULL_ALLOC(ndr, r->in.num_ous);

8708

}

8709

_mem_save_num_ous_0 = NDR_PULL_GET_MEM_CTX(ndr);

8710

NDR_PULL_SET_MEM_CTX(ndr, r->in.num_ous, LIBNDR_FLAG_REF_ALLOC);

8711

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->in.num_ous));

8712

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_num_ous_0, LIBNDR_FLAG_REF_ALLOC);

8713

NDR_PULL_ALLOC(ndr, r->out.num_ous);

8714

*r->out.num_ous = *r->in.num_ous;

8715

NDR_PULL_ALLOC(ndr, r->out.ous);

8716

ZERO_STRUCTP(r->out.ous);

8717

}

8718

if (flags & NDR_OUT) {

8719

if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {

8720

NDR_PULL_ALLOC(ndr, r->out.num_ous);

8721

}

8722

_mem_save_num_ous_0 = NDR_PULL_GET_MEM_CTX(ndr);

8723

NDR_PULL_SET_MEM_CTX(ndr, r->out.num_ous, LIBNDR_FLAG_REF_ALLOC);

8724

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.num_ous));

8725

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_num_ous_0, LIBNDR_FLAG_REF_ALLOC);

8726

if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {

8727

NDR_PULL_ALLOC(ndr, r->out.ous);

8728

}

8729

_mem_save_ous_0 = NDR_PULL_GET_MEM_CTX(ndr);

8730

NDR_PULL_SET_MEM_CTX(ndr, r->out.ous, LIBNDR_FLAG_REF_ALLOC);

8731

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_ous));

8732

if (_ptr_ous) {

8733

NDR_PULL_ALLOC(ndr, *r->out.ous);

8734

} else {

8735

*r->out.ous = NULL;

8736

}

8737

if (*r->out.ous) {

8738

_mem_save_ous_1 = NDR_PULL_GET_MEM_CTX(ndr);

8739

NDR_PULL_SET_MEM_CTX(ndr, *r->out.ous, 0);

8740

NDR_CHECK(ndr_pull_array_size(ndr, r->out.ous));

8741

NDR_PULL_ALLOC_N(ndr, *r->out.ous, ndr_get_array_size(ndr, r->out.ous));

8742

_mem_save_ous_2 = NDR_PULL_GET_MEM_CTX(ndr);

8743

NDR_PULL_SET_MEM_CTX(ndr, *r->out.ous, 0);

8744

for (cntr_ous_2 = 0; cntr_ous_2 < *r->out.num_ous; cntr_ous_2++) {

8745

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_ous));

8746

if (_ptr_ous) {

8747

NDR_PULL_ALLOC(ndr, (*r->out.ous)[cntr_ous_2]);

8748

} else {

8749

(*r->out.ous)[cntr_ous_2] = NULL;

8750

}

8751

}

8752

for (cntr_ous_2 = 0; cntr_ous_2 < *r->out.num_ous; cntr_ous_2++) {

8753

if ((*r->out.ous)[cntr_ous_2]) {

8754

_mem_save_ous_3 = NDR_PULL_GET_MEM_CTX(ndr);

8755

NDR_PULL_SET_MEM_CTX(ndr, (*r->out.ous)[cntr_ous_2], 0);

8756

NDR_CHECK(ndr_pull_array_size(ndr, &(*r->out.ous)[cntr_ous_2]));

8757

NDR_CHECK(ndr_pull_array_length(ndr, &(*r->out.ous)[cntr_ous_2]));

8758

if (ndr_get_array_length(ndr, &(*r->out.ous)[cntr_ous_2]) > ndr_get_array_size(ndr, &(*r->out.ous)[cntr_ous_2])) {

8759

return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &(*r->out.ous)[cntr_ous_2]), ndr_get_array_length(ndr, &(*r->out.ous)[cntr_ous_2]));

8760

}

8761

NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &(*r->out.ous)[cntr_ous_2]), sizeof(uint16_t)));

8762

NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &(*r->out.ous)[cntr_ous_2], ndr_get_array_length(ndr, &(*r->out.ous)[cntr_ous_2]), sizeof(uint16_t), CH_UTF16));

8763

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ous_3, 0);

8764

}

8765

}

8766

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ous_2, 0);

8767

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ous_1, 0);

8768

}

8769

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ous_0, LIBNDR_FLAG_REF_ALLOC);

8770

NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));

8771

if (*r->out.ous) {

8772

NDR_CHECK(ndr_check_array_size(ndr, (void*)r->out.ous, *r->out.num_ous));

8773

}

8774

}

8775

return NDR_ERR_SUCCESS;

8776

}

8777

8778

_PUBLIC_ void ndr_print_wkssvc_NetrGetJoinableOus(struct ndr_print *ndr, const char *name, int flags, const struct wkssvc_NetrGetJoinableOus *r)

8779

{

8780

uint32_t cntr_ous_2;

8781

ndr_print_struct(ndr, name, "wkssvc_NetrGetJoinableOus");

8782

ndr->depth++;

8783

if (flags & NDR_SET_VALUES) {

8784

ndr->flags |= LIBNDR_PRINT_SET_VALUES;

8785

}

8786

if (flags & NDR_IN) {

8787

ndr_print_struct(ndr, "in", "wkssvc_NetrGetJoinableOus");

8788

ndr->depth++;

8789

ndr_print_ptr(ndr, "server_name", r->in.server_name);

8790

ndr->depth++;

8791

if (r->in.server_name) {

8792

ndr_print_string(ndr, "server_name", r->in.server_name);

8793

}

8794

ndr->depth--;

8795

ndr_print_ptr(ndr, "domain_name", r->in.domain_name);

8796

ndr->depth++;

8797

ndr_print_string(ndr, "domain_name", r->in.domain_name);

8798

ndr->depth--;

8799

ndr_print_ptr(ndr, "Account", r->in.Account);

8800

ndr->depth++;

8801

if (r->in.Account) {

8802

ndr_print_string(ndr, "Account", r->in.Account);

8803

}

8804

ndr->depth--;

8805

ndr_print_ptr(ndr, "unknown", r->in.unknown);

8806

ndr->depth++;

8807

if (r->in.unknown) {

8808

ndr_print_string(ndr, "unknown", r->in.unknown);

8809

}

8810

ndr->depth--;

8811

ndr_print_ptr(ndr, "num_ous", r->in.num_ous);

8812

ndr->depth++;

8813

ndr_print_uint32(ndr, "num_ous", *r->in.num_ous);

8814

ndr->depth--;

8815

ndr->depth--;

8816

}

8817

if (flags & NDR_OUT) {

8818

ndr_print_struct(ndr, "out", "wkssvc_NetrGetJoinableOus");

8819

ndr->depth++;

8820

ndr_print_ptr(ndr, "num_ous", r->out.num_ous);

8821

ndr->depth++;

8822

ndr_print_uint32(ndr, "num_ous", *r->out.num_ous);

8823

ndr->depth--;

8824

ndr_print_ptr(ndr, "ous", r->out.ous);

8825

ndr->depth++;

8826

ndr_print_ptr(ndr, "ous", *r->out.ous);

8827

ndr->depth++;

8828

if (*r->out.ous) {

8829

ndr->print(ndr, "%s: ARRAY(%d)", "ous", (int)*r->out.num_ous);

8830

ndr->depth++;

8831

for (cntr_ous_2=0;cntr_ous_2<*r->out.num_ous;cntr_ous_2++) {

8832

char *idx_2=NULL;

8833

if (asprintf(&idx_2, "[%d]", cntr_ous_2) != -1) {

8834

ndr_print_ptr(ndr, "ous", (*r->out.ous)[cntr_ous_2]);

8835

ndr->depth++;

8836

if ((*r->out.ous)[cntr_ous_2]) {

8837

ndr_print_string(ndr, "ous", (*r->out.ous)[cntr_ous_2]);

8838

}

8839

ndr->depth--;

8840

free(idx_2);

8841

}

8842

}

8843

ndr->depth--;

8844

}

8845

ndr->depth--;

8846

ndr->depth--;

8847

ndr_print_WERROR(ndr, "result", r->out.result);

8848

ndr->depth--;

8849

}

8850

ndr->depth--;

8851

}

8852

8853

static enum ndr_err_code ndr_push_wkssvc_NetrJoinDomain2(struct ndr_push *ndr, int flags, const struct wkssvc_NetrJoinDomain2 *r)

8854

{

8855

if (flags & NDR_IN) {

8856

NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server_name));

8857

if (r->in.server_name) {

8858

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));

8859

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));

8860

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));

8861

NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server_name, ndr_charset_length(r->in.server_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));

8862

}

8863

if (r->in.domain_name == NULL) {

8864

return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");

8865

}

8866

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.domain_name, CH_UTF16)));

8867

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));

8868

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.domain_name, CH_UTF16)));

8869

NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.domain_name, ndr_charset_length(r->in.domain_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));

8870

NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.account_ou));

8871

if (r->in.account_ou) {

8872

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.account_ou, CH_UTF16)));

8873

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));

8874

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.account_ou, CH_UTF16)));

8875

NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.account_ou, ndr_charset_length(r->in.account_ou, CH_UTF16), sizeof(uint16_t), CH_UTF16));

8876

}

8877

NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.admin_account));

8878

if (r->in.admin_account) {

8879

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.admin_account, CH_UTF16)));

8880

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));

8881

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.admin_account, CH_UTF16)));

8882

NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.admin_account, ndr_charset_length(r->in.admin_account, CH_UTF16), sizeof(uint16_t), CH_UTF16));

8883

}

8884

NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.encrypted_password));

8885

if (r->in.encrypted_password) {

8886

NDR_CHECK(ndr_push_wkssvc_PasswordBuffer(ndr, NDR_SCALARS, r->in.encrypted_password));

8887

}

8888

NDR_CHECK(ndr_push_wkssvc_joinflags(ndr, NDR_SCALARS, r->in.join_flags));

8889

}

8890

if (flags & NDR_OUT) {

8891

NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));

8892

}

8893

return NDR_ERR_SUCCESS;

8894

}

8895

8896

static enum ndr_err_code ndr_pull_wkssvc_NetrJoinDomain2(struct ndr_pull *ndr, int flags, struct wkssvc_NetrJoinDomain2 *r)

8897

{

8898

uint32_t _ptr_server_name;

8899

uint32_t _ptr_account_ou;

8900

uint32_t _ptr_admin_account;

8901

uint32_t _ptr_encrypted_password;

8902

TALLOC_CTX *_mem_save_server_name_0;

8903

TALLOC_CTX *_mem_save_account_ou_0;

8904

TALLOC_CTX *_mem_save_admin_account_0;

8905

TALLOC_CTX *_mem_save_encrypted_password_0;

8906

if (flags & NDR_IN) {

8907

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_name));

8908

if (_ptr_server_name) {

8909

NDR_PULL_ALLOC(ndr, r->in.server_name);

8910

} else {

8911

r->in.server_name = NULL;

8912

}

8913

if (r->in.server_name) {

8914

_mem_save_server_name_0 = NDR_PULL_GET_MEM_CTX(ndr);

8915

NDR_PULL_SET_MEM_CTX(ndr, r->in.server_name, 0);

8916

NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_name));

8917

NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_name));

8918

if (ndr_get_array_length(ndr, &r->in.server_name) > ndr_get_array_size(ndr, &r->in.server_name)) {

8919

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_name), ndr_get_array_length(ndr, &r->in.server_name));

8920

}

8921

NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server_name), sizeof(uint16_t)));

8922

NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server_name, ndr_get_array_length(ndr, &r->in.server_name), sizeof(uint16_t), CH_UTF16));

8923

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_name_0, 0);

8924

}

8925

NDR_CHECK(ndr_pull_array_size(ndr, &r->in.domain_name));

8926

NDR_CHECK(ndr_pull_array_length(ndr, &r->in.domain_name));

8927

if (ndr_get_array_length(ndr, &r->in.domain_name) > ndr_get_array_size(ndr, &r->in.domain_name)) {

8928

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.domain_name), ndr_get_array_length(ndr, &r->in.domain_name));

8929

}

8930

NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.domain_name), sizeof(uint16_t)));

8931

NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.domain_name, ndr_get_array_length(ndr, &r->in.domain_name), sizeof(uint16_t), CH_UTF16));

8932

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_account_ou));

8933

if (_ptr_account_ou) {

8934

NDR_PULL_ALLOC(ndr, r->in.account_ou);

8935

} else {

8936

r->in.account_ou = NULL;

8937

}

8938

if (r->in.account_ou) {

8939

_mem_save_account_ou_0 = NDR_PULL_GET_MEM_CTX(ndr);

8940

NDR_PULL_SET_MEM_CTX(ndr, r->in.account_ou, 0);

8941

NDR_CHECK(ndr_pull_array_size(ndr, &r->in.account_ou));

8942

NDR_CHECK(ndr_pull_array_length(ndr, &r->in.account_ou));

8943

if (ndr_get_array_length(ndr, &r->in.account_ou) > ndr_get_array_size(ndr, &r->in.account_ou)) {

8944

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.account_ou), ndr_get_array_length(ndr, &r->in.account_ou));

8945

}

8946

NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.account_ou), sizeof(uint16_t)));

8947

NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.account_ou, ndr_get_array_length(ndr, &r->in.account_ou), sizeof(uint16_t), CH_UTF16));

8948

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_account_ou_0, 0);

8949

}

8950

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_admin_account));

8951

if (_ptr_admin_account) {

8952

NDR_PULL_ALLOC(ndr, r->in.admin_account);

8953

} else {

8954

r->in.admin_account = NULL;

8955

}

8956

if (r->in.admin_account) {

8957

_mem_save_admin_account_0 = NDR_PULL_GET_MEM_CTX(ndr);

8958

NDR_PULL_SET_MEM_CTX(ndr, r->in.admin_account, 0);

8959

NDR_CHECK(ndr_pull_array_size(ndr, &r->in.admin_account));

8960

NDR_CHECK(ndr_pull_array_length(ndr, &r->in.admin_account));

8961

if (ndr_get_array_length(ndr, &r->in.admin_account) > ndr_get_array_size(ndr, &r->in.admin_account)) {

8962

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.admin_account), ndr_get_array_length(ndr, &r->in.admin_account));

8963

}

8964

NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.admin_account), sizeof(uint16_t)));

8965

NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.admin_account, ndr_get_array_length(ndr, &r->in.admin_account), sizeof(uint16_t), CH_UTF16));

8966

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_admin_account_0, 0);

8967

}

8968

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_encrypted_password));

8969

if (_ptr_encrypted_password) {

8970

NDR_PULL_ALLOC(ndr, r->in.encrypted_password);

8971

} else {

8972

r->in.encrypted_password = NULL;

8973

}

8974

if (r->in.encrypted_password) {

8975

_mem_save_encrypted_password_0 = NDR_PULL_GET_MEM_CTX(ndr);

8976

NDR_PULL_SET_MEM_CTX(ndr, r->in.encrypted_password, 0);

8977

NDR_CHECK(ndr_pull_wkssvc_PasswordBuffer(ndr, NDR_SCALARS, r->in.encrypted_password));

8978

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_encrypted_password_0, 0);

8979

}

8980

NDR_CHECK(ndr_pull_wkssvc_joinflags(ndr, NDR_SCALARS, &r->in.join_flags));

8981

}

8982

if (flags & NDR_OUT) {

8983

NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));

8984

}

8985

return NDR_ERR_SUCCESS;

8986

}

8987

8988

_PUBLIC_ void ndr_print_wkssvc_NetrJoinDomain2(struct ndr_print *ndr, const char *name, int flags, const struct wkssvc_NetrJoinDomain2 *r)

8989

{

8990

ndr_print_struct(ndr, name, "wkssvc_NetrJoinDomain2");

8991

ndr->depth++;

8992

if (flags & NDR_SET_VALUES) {

8993

ndr->flags |= LIBNDR_PRINT_SET_VALUES;

8994

}

8995

if (flags & NDR_IN) {

8996

ndr_print_struct(ndr, "in", "wkssvc_NetrJoinDomain2");

8997

ndr->depth++;

8998

ndr_print_ptr(ndr, "server_name", r->in.server_name);

8999

ndr->depth++;

9000

if (r->in.server_name) {

9001

ndr_print_string(ndr, "server_name", r->in.server_name);

9002

}

9003

ndr->depth--;

9004

ndr_print_ptr(ndr, "domain_name", r->in.domain_name);

9005

ndr->depth++;

9006

ndr_print_string(ndr, "domain_name", r->in.domain_name);

9007

ndr->depth--;

9008

ndr_print_ptr(ndr, "account_ou", r->in.account_ou);

9009

ndr->depth++;

9010

if (r->in.account_ou) {

9011

ndr_print_string(ndr, "account_ou", r->in.account_ou);

9012

}

9013

ndr->depth--;

9014

ndr_print_ptr(ndr, "admin_account", r->in.admin_account);

9015

ndr->depth++;

9016

if (r->in.admin_account) {

9017

ndr_print_string(ndr, "admin_account", r->in.admin_account);

9018

}

9019

ndr->depth--;

9020

ndr_print_ptr(ndr, "encrypted_password", r->in.encrypted_password);

9021

ndr->depth++;

9022

if (r->in.encrypted_password) {

9023

ndr_print_wkssvc_PasswordBuffer(ndr, "encrypted_password", r->in.encrypted_password);

9024

}

9025

ndr->depth--;

9026

ndr_print_wkssvc_joinflags(ndr, "join_flags", r->in.join_flags);

9027

ndr->depth--;

9028

}

9029

if (flags & NDR_OUT) {

9030

ndr_print_struct(ndr, "out", "wkssvc_NetrJoinDomain2");

9031

ndr->depth++;

9032

ndr_print_WERROR(ndr, "result", r->out.result);

9033

ndr->depth--;

9034

}

9035

ndr->depth--;

9036

}

9037

9038

static enum ndr_err_code ndr_push_wkssvc_NetrUnjoinDomain2(struct ndr_push *ndr, int flags, const struct wkssvc_NetrUnjoinDomain2 *r)

9039

{

9040

if (flags & NDR_IN) {

9041

NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server_name));

9042

if (r->in.server_name) {

9043

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));

9044

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));

9045

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));

9046

NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server_name, ndr_charset_length(r->in.server_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));

9047

}

9048

NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.account));

9049

if (r->in.account) {

9050

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.account, CH_UTF16)));

9051

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));

9052

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.account, CH_UTF16)));

9053

NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.account, ndr_charset_length(r->in.account, CH_UTF16), sizeof(uint16_t), CH_UTF16));

9054

}

9055

NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.encrypted_password));

9056

if (r->in.encrypted_password) {

9057

NDR_CHECK(ndr_push_wkssvc_PasswordBuffer(ndr, NDR_SCALARS, r->in.encrypted_password));

9058

}

9059

NDR_CHECK(ndr_push_wkssvc_joinflags(ndr, NDR_SCALARS, r->in.unjoin_flags));

9060

}

9061

if (flags & NDR_OUT) {

9062

NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));

9063

}

9064

return NDR_ERR_SUCCESS;

9065

}

9066

9067

static enum ndr_err_code ndr_pull_wkssvc_NetrUnjoinDomain2(struct ndr_pull *ndr, int flags, struct wkssvc_NetrUnjoinDomain2 *r)

9068

{

9069

uint32_t _ptr_server_name;

9070

uint32_t _ptr_account;

9071

uint32_t _ptr_encrypted_password;

9072

TALLOC_CTX *_mem_save_server_name_0;

9073

TALLOC_CTX *_mem_save_account_0;

9074

TALLOC_CTX *_mem_save_encrypted_password_0;

9075

if (flags & NDR_IN) {

9076

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_name));

9077

if (_ptr_server_name) {

9078

NDR_PULL_ALLOC(ndr, r->in.server_name);

9079

} else {

9080

r->in.server_name = NULL;

9081

}

9082

if (r->in.server_name) {

9083

_mem_save_server_name_0 = NDR_PULL_GET_MEM_CTX(ndr);

9084

NDR_PULL_SET_MEM_CTX(ndr, r->in.server_name, 0);

9085

NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_name));

9086

NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_name));

9087

if (ndr_get_array_length(ndr, &r->in.server_name) > ndr_get_array_size(ndr, &r->in.server_name)) {

9088

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_name), ndr_get_array_length(ndr, &r->in.server_name));

9089

}

9090

NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server_name), sizeof(uint16_t)));

9091

NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server_name, ndr_get_array_length(ndr, &r->in.server_name), sizeof(uint16_t), CH_UTF16));

9092

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_name_0, 0);

9093

}

9094

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_account));

9095

if (_ptr_account) {

9096

NDR_PULL_ALLOC(ndr, r->in.account);

9097

} else {

9098

r->in.account = NULL;

9099

}

9100

if (r->in.account) {

9101

_mem_save_account_0 = NDR_PULL_GET_MEM_CTX(ndr);

9102

NDR_PULL_SET_MEM_CTX(ndr, r->in.account, 0);

9103

NDR_CHECK(ndr_pull_array_size(ndr, &r->in.account));

9104

NDR_CHECK(ndr_pull_array_length(ndr, &r->in.account));

9105

if (ndr_get_array_length(ndr, &r->in.account) > ndr_get_array_size(ndr, &r->in.account)) {

9106

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.account), ndr_get_array_length(ndr, &r->in.account));

9107

}

9108

NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.account), sizeof(uint16_t)));

9109

NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.account, ndr_get_array_length(ndr, &r->in.account), sizeof(uint16_t), CH_UTF16));

9110

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_account_0, 0);

9111

}

9112

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_encrypted_password));

9113

if (_ptr_encrypted_password) {

9114

NDR_PULL_ALLOC(ndr, r->in.encrypted_password);

9115

} else {

9116

r->in.encrypted_password = NULL;

9117

}

9118

if (r->in.encrypted_password) {

9119

_mem_save_encrypted_password_0 = NDR_PULL_GET_MEM_CTX(ndr);

9120

NDR_PULL_SET_MEM_CTX(ndr, r->in.encrypted_password, 0);

9121

NDR_CHECK(ndr_pull_wkssvc_PasswordBuffer(ndr, NDR_SCALARS, r->in.encrypted_password));

9122

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_encrypted_password_0, 0);

9123

}

9124

NDR_CHECK(ndr_pull_wkssvc_joinflags(ndr, NDR_SCALARS, &r->in.unjoin_flags));

9125

}

9126

if (flags & NDR_OUT) {

9127

NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));

9128

}

9129

return NDR_ERR_SUCCESS;

9130

}

9131

9132

_PUBLIC_ void ndr_print_wkssvc_NetrUnjoinDomain2(struct ndr_print *ndr, const char *name, int flags, const struct wkssvc_NetrUnjoinDomain2 *r)

9133

{

9134

ndr_print_struct(ndr, name, "wkssvc_NetrUnjoinDomain2");

9135

ndr->depth++;

9136

if (flags & NDR_SET_VALUES) {

9137

ndr->flags |= LIBNDR_PRINT_SET_VALUES;

9138

}

9139

if (flags & NDR_IN) {

9140

ndr_print_struct(ndr, "in", "wkssvc_NetrUnjoinDomain2");

9141

ndr->depth++;

9142

ndr_print_ptr(ndr, "server_name", r->in.server_name);

9143

ndr->depth++;

9144

if (r->in.server_name) {

9145

ndr_print_string(ndr, "server_name", r->in.server_name);

9146

}

9147

ndr->depth--;

9148

ndr_print_ptr(ndr, "account", r->in.account);

9149

ndr->depth++;

9150

if (r->in.account) {

9151

ndr_print_string(ndr, "account", r->in.account);

9152

}

9153

ndr->depth--;

9154

ndr_print_ptr(ndr, "encrypted_password", r->in.encrypted_password);

9155

ndr->depth++;

9156

if (r->in.encrypted_password) {

9157

ndr_print_wkssvc_PasswordBuffer(ndr, "encrypted_password", r->in.encrypted_password);

9158

}

9159

ndr->depth--;

9160

ndr_print_wkssvc_joinflags(ndr, "unjoin_flags", r->in.unjoin_flags);

9161

ndr->depth--;

9162

}

9163

if (flags & NDR_OUT) {

9164

ndr_print_struct(ndr, "out", "wkssvc_NetrUnjoinDomain2");

9165

ndr->depth++;

9166

ndr_print_WERROR(ndr, "result", r->out.result);

9167

ndr->depth--;

9168

}

9169

ndr->depth--;

9170

}

9171

9172

static enum ndr_err_code ndr_push_wkssvc_NetrRenameMachineInDomain2(struct ndr_push *ndr, int flags, const struct wkssvc_NetrRenameMachineInDomain2 *r)

9173

{

9174

if (flags & NDR_IN) {

9175

NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server_name));

9176

if (r->in.server_name) {

9177

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));

9178

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));

9179

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));

9180

NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server_name, ndr_charset_length(r->in.server_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));

9181

}

9182

NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.NewMachineName));

9183

if (r->in.NewMachineName) {

9184

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.NewMachineName, CH_UTF16)));

9185

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));

9186

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.NewMachineName, CH_UTF16)));

9187

NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.NewMachineName, ndr_charset_length(r->in.NewMachineName, CH_UTF16), sizeof(uint16_t), CH_UTF16));

9188

}

9189

NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.Account));

9190

if (r->in.Account) {

9191

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.Account, CH_UTF16)));

9192

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));

9193

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.Account, CH_UTF16)));

9194

NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.Account, ndr_charset_length(r->in.Account, CH_UTF16), sizeof(uint16_t), CH_UTF16));

9195

}

9196

NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.EncryptedPassword));

9197

if (r->in.EncryptedPassword) {

9198

NDR_CHECK(ndr_push_wkssvc_PasswordBuffer(ndr, NDR_SCALARS, r->in.EncryptedPassword));

9199

}

9200

NDR_CHECK(ndr_push_wkssvc_renameflags(ndr, NDR_SCALARS, r->in.RenameOptions));

9201

}

9202

if (flags & NDR_OUT) {

9203

NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));

9204

}

9205

return NDR_ERR_SUCCESS;

9206

}

9207

9208

static enum ndr_err_code ndr_pull_wkssvc_NetrRenameMachineInDomain2(struct ndr_pull *ndr, int flags, struct wkssvc_NetrRenameMachineInDomain2 *r)

9209

{

9210

uint32_t _ptr_server_name;

9211

uint32_t _ptr_NewMachineName;

9212

uint32_t _ptr_Account;

9213

uint32_t _ptr_EncryptedPassword;

9214

TALLOC_CTX *_mem_save_server_name_0;

9215

TALLOC_CTX *_mem_save_NewMachineName_0;

9216

TALLOC_CTX *_mem_save_Account_0;

9217

TALLOC_CTX *_mem_save_EncryptedPassword_0;

9218

if (flags & NDR_IN) {

9219

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_name));

9220

if (_ptr_server_name) {

9221

NDR_PULL_ALLOC(ndr, r->in.server_name);

9222

} else {

9223

r->in.server_name = NULL;

9224

}

9225

if (r->in.server_name) {

9226

_mem_save_server_name_0 = NDR_PULL_GET_MEM_CTX(ndr);

9227

NDR_PULL_SET_MEM_CTX(ndr, r->in.server_name, 0);

9228

NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_name));

9229

NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_name));

9230

if (ndr_get_array_length(ndr, &r->in.server_name) > ndr_get_array_size(ndr, &r->in.server_name)) {

9231

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_name), ndr_get_array_length(ndr, &r->in.server_name));

9232

}

9233

NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server_name), sizeof(uint16_t)));

9234

NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server_name, ndr_get_array_length(ndr, &r->in.server_name), sizeof(uint16_t), CH_UTF16));

9235

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_name_0, 0);

9236

}

9237

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_NewMachineName));

9238

if (_ptr_NewMachineName) {

9239

NDR_PULL_ALLOC(ndr, r->in.NewMachineName);

9240

} else {

9241

r->in.NewMachineName = NULL;

9242

}

9243

if (r->in.NewMachineName) {

9244

_mem_save_NewMachineName_0 = NDR_PULL_GET_MEM_CTX(ndr);

9245

NDR_PULL_SET_MEM_CTX(ndr, r->in.NewMachineName, 0);

9246

NDR_CHECK(ndr_pull_array_size(ndr, &r->in.NewMachineName));

9247

NDR_CHECK(ndr_pull_array_length(ndr, &r->in.NewMachineName));

9248

if (ndr_get_array_length(ndr, &r->in.NewMachineName) > ndr_get_array_size(ndr, &r->in.NewMachineName)) {

9249

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.NewMachineName), ndr_get_array_length(ndr, &r->in.NewMachineName));

9250

}

9251

NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.NewMachineName), sizeof(uint16_t)));

9252

NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.NewMachineName, ndr_get_array_length(ndr, &r->in.NewMachineName), sizeof(uint16_t), CH_UTF16));

9253

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_NewMachineName_0, 0);

9254

}

9255

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_Account));

9256

if (_ptr_Account) {

9257

NDR_PULL_ALLOC(ndr, r->in.Account);

9258

} else {

9259

r->in.Account = NULL;

9260

}

9261

if (r->in.Account) {

9262

_mem_save_Account_0 = NDR_PULL_GET_MEM_CTX(ndr);

9263

NDR_PULL_SET_MEM_CTX(ndr, r->in.Account, 0);

9264

NDR_CHECK(ndr_pull_array_size(ndr, &r->in.Account));

9265

NDR_CHECK(ndr_pull_array_length(ndr, &r->in.Account));

9266

if (ndr_get_array_length(ndr, &r->in.Account) > ndr_get_array_size(ndr, &r->in.Account)) {

9267

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.Account), ndr_get_array_length(ndr, &r->in.Account));

9268

}

9269

NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.Account), sizeof(uint16_t)));

9270

NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.Account, ndr_get_array_length(ndr, &r->in.Account), sizeof(uint16_t), CH_UTF16));

9271

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_Account_0, 0);

9272

}

9273

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_EncryptedPassword));

9274

if (_ptr_EncryptedPassword) {

9275

NDR_PULL_ALLOC(ndr, r->in.EncryptedPassword);

9276

} else {

9277

r->in.EncryptedPassword = NULL;

9278

}

9279

if (r->in.EncryptedPassword) {

9280

_mem_save_EncryptedPassword_0 = NDR_PULL_GET_MEM_CTX(ndr);

9281

NDR_PULL_SET_MEM_CTX(ndr, r->in.EncryptedPassword, 0);

9282

NDR_CHECK(ndr_pull_wkssvc_PasswordBuffer(ndr, NDR_SCALARS, r->in.EncryptedPassword));

9283

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_EncryptedPassword_0, 0);

9284

}

9285

NDR_CHECK(ndr_pull_wkssvc_renameflags(ndr, NDR_SCALARS, &r->in.RenameOptions));

9286

}

9287

if (flags & NDR_OUT) {

9288

NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));

9289

}

9290

return NDR_ERR_SUCCESS;

9291

}

9292

9293

_PUBLIC_ void ndr_print_wkssvc_NetrRenameMachineInDomain2(struct ndr_print *ndr, const char *name, int flags, const struct wkssvc_NetrRenameMachineInDomain2 *r)

9294

{

9295

ndr_print_struct(ndr, name, "wkssvc_NetrRenameMachineInDomain2");

9296

ndr->depth++;

9297

if (flags & NDR_SET_VALUES) {

9298

ndr->flags |= LIBNDR_PRINT_SET_VALUES;

9299

}

9300

if (flags & NDR_IN) {

9301

ndr_print_struct(ndr, "in", "wkssvc_NetrRenameMachineInDomain2");

9302

ndr->depth++;

9303

ndr_print_ptr(ndr, "server_name", r->in.server_name);

9304

ndr->depth++;

9305

if (r->in.server_name) {

9306

ndr_print_string(ndr, "server_name", r->in.server_name);

9307

}

9308

ndr->depth--;

9309

ndr_print_ptr(ndr, "NewMachineName", r->in.NewMachineName);

9310

ndr->depth++;

9311

if (r->in.NewMachineName) {

9312

ndr_print_string(ndr, "NewMachineName", r->in.NewMachineName);

9313

}

9314

ndr->depth--;

9315

ndr_print_ptr(ndr, "Account", r->in.Account);

9316

ndr->depth++;

9317

if (r->in.Account) {

9318

ndr_print_string(ndr, "Account", r->in.Account);

9319

}

9320

ndr->depth--;

9321

ndr_print_ptr(ndr, "EncryptedPassword", r->in.EncryptedPassword);

9322

ndr->depth++;

9323

if (r->in.EncryptedPassword) {

9324

ndr_print_wkssvc_PasswordBuffer(ndr, "EncryptedPassword", r->in.EncryptedPassword);

9325

}

9326

ndr->depth--;

9327

ndr_print_wkssvc_renameflags(ndr, "RenameOptions", r->in.RenameOptions);

9328

ndr->depth--;

9329

}

9330

if (flags & NDR_OUT) {

9331

ndr_print_struct(ndr, "out", "wkssvc_NetrRenameMachineInDomain2");

9332

ndr->depth++;

9333

ndr_print_WERROR(ndr, "result", r->out.result);

9334

ndr->depth--;

9335

}

9336

ndr->depth--;

9337

}

9338

9339

static enum ndr_err_code ndr_push_wkssvc_NetrValidateName2(struct ndr_push *ndr, int flags, const struct wkssvc_NetrValidateName2 *r)

9340

{

9341

if (flags & NDR_IN) {

9342

NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server_name));

9343

if (r->in.server_name) {

9344

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));

9345

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));

9346

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));

9347

NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server_name, ndr_charset_length(r->in.server_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));

9348

}

9349

if (r->in.name == NULL) {

9350

return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");

9351

}

9352

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.name, CH_UTF16)));

9353

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));

9354

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.name, CH_UTF16)));

9355

NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.name, ndr_charset_length(r->in.name, CH_UTF16), sizeof(uint16_t), CH_UTF16));

9356

NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.Account));

9357

if (r->in.Account) {

9358

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.Account, CH_UTF16)));

9359

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));

9360

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.Account, CH_UTF16)));

9361

NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.Account, ndr_charset_length(r->in.Account, CH_UTF16), sizeof(uint16_t), CH_UTF16));

9362

}

9363

NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.EncryptedPassword));

9364

if (r->in.EncryptedPassword) {

9365

NDR_CHECK(ndr_push_wkssvc_PasswordBuffer(ndr, NDR_SCALARS, r->in.EncryptedPassword));

9366

}

9367

NDR_CHECK(ndr_push_wkssvc_NetValidateNameType(ndr, NDR_SCALARS, r->in.name_type));

9368

}

9369

if (flags & NDR_OUT) {

9370

NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));

9371

}

9372

return NDR_ERR_SUCCESS;

9373

}

9374

9375

static enum ndr_err_code ndr_pull_wkssvc_NetrValidateName2(struct ndr_pull *ndr, int flags, struct wkssvc_NetrValidateName2 *r)

9376

{

9377

uint32_t _ptr_server_name;

9378

uint32_t _ptr_Account;

9379

uint32_t _ptr_EncryptedPassword;

9380

TALLOC_CTX *_mem_save_server_name_0;

9381

TALLOC_CTX *_mem_save_Account_0;

9382

TALLOC_CTX *_mem_save_EncryptedPassword_0;

9383

if (flags & NDR_IN) {

9384

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_name));

9385

if (_ptr_server_name) {

9386

NDR_PULL_ALLOC(ndr, r->in.server_name);

9387

} else {

9388

r->in.server_name = NULL;

9389

}

9390

if (r->in.server_name) {

9391

_mem_save_server_name_0 = NDR_PULL_GET_MEM_CTX(ndr);

9392

NDR_PULL_SET_MEM_CTX(ndr, r->in.server_name, 0);

9393

NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_name));

9394

NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_name));

9395

if (ndr_get_array_length(ndr, &r->in.server_name) > ndr_get_array_size(ndr, &r->in.server_name)) {

9396

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_name), ndr_get_array_length(ndr, &r->in.server_name));

9397

}

9398

NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server_name), sizeof(uint16_t)));

9399

NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server_name, ndr_get_array_length(ndr, &r->in.server_name), sizeof(uint16_t), CH_UTF16));

9400

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_name_0, 0);

9401

}

9402

NDR_CHECK(ndr_pull_array_size(ndr, &r->in.name));

9403

NDR_CHECK(ndr_pull_array_length(ndr, &r->in.name));

9404

if (ndr_get_array_length(ndr, &r->in.name) > ndr_get_array_size(ndr, &r->in.name)) {

9405

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));

9406

}

9407

NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.name), sizeof(uint16_t)));

9408

NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.name, ndr_get_array_length(ndr, &r->in.name), sizeof(uint16_t), CH_UTF16));

9409

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_Account));

9410

if (_ptr_Account) {

9411

NDR_PULL_ALLOC(ndr, r->in.Account);

9412

} else {

9413

r->in.Account = NULL;

9414

}

9415

if (r->in.Account) {

9416

_mem_save_Account_0 = NDR_PULL_GET_MEM_CTX(ndr);

9417

NDR_PULL_SET_MEM_CTX(ndr, r->in.Account, 0);

9418

NDR_CHECK(ndr_pull_array_size(ndr, &r->in.Account));

9419

NDR_CHECK(ndr_pull_array_length(ndr, &r->in.Account));

9420

if (ndr_get_array_length(ndr, &r->in.Account) > ndr_get_array_size(ndr, &r->in.Account)) {

9421

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.Account), ndr_get_array_length(ndr, &r->in.Account));

9422

}

9423

NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.Account), sizeof(uint16_t)));

9424

NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.Account, ndr_get_array_length(ndr, &r->in.Account), sizeof(uint16_t), CH_UTF16));

9425

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_Account_0, 0);

9426

}

9427

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_EncryptedPassword));

9428

if (_ptr_EncryptedPassword) {

9429

NDR_PULL_ALLOC(ndr, r->in.EncryptedPassword);

9430

} else {

9431

r->in.EncryptedPassword = NULL;

9432

}

9433

if (r->in.EncryptedPassword) {

9434

_mem_save_EncryptedPassword_0 = NDR_PULL_GET_MEM_CTX(ndr);

9435

NDR_PULL_SET_MEM_CTX(ndr, r->in.EncryptedPassword, 0);

9436

NDR_CHECK(ndr_pull_wkssvc_PasswordBuffer(ndr, NDR_SCALARS, r->in.EncryptedPassword));

9437

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_EncryptedPassword_0, 0);

9438

}

9439

NDR_CHECK(ndr_pull_wkssvc_NetValidateNameType(ndr, NDR_SCALARS, &r->in.name_type));

9440

}

9441

if (flags & NDR_OUT) {

9442

NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));

9443

}

9444

return NDR_ERR_SUCCESS;

9445

}

9446

9447

_PUBLIC_ void ndr_print_wkssvc_NetrValidateName2(struct ndr_print *ndr, const char *name, int flags, const struct wkssvc_NetrValidateName2 *r)

9448

{

9449

ndr_print_struct(ndr, name, "wkssvc_NetrValidateName2");

9450

ndr->depth++;

9451

if (flags & NDR_SET_VALUES) {

9452

ndr->flags |= LIBNDR_PRINT_SET_VALUES;

9453

}

9454

if (flags & NDR_IN) {

9455

ndr_print_struct(ndr, "in", "wkssvc_NetrValidateName2");

9456

ndr->depth++;

9457

ndr_print_ptr(ndr, "server_name", r->in.server_name);

9458

ndr->depth++;

9459

if (r->in.server_name) {

9460

ndr_print_string(ndr, "server_name", r->in.server_name);

9461

}

9462

ndr->depth--;

9463

ndr_print_ptr(ndr, "name", r->in.name);

9464

ndr->depth++;

9465

ndr_print_string(ndr, "name", r->in.name);

9466

ndr->depth--;

9467

ndr_print_ptr(ndr, "Account", r->in.Account);

9468

ndr->depth++;

9469

if (r->in.Account) {

9470

ndr_print_string(ndr, "Account", r->in.Account);

9471

}

9472

ndr->depth--;

9473

ndr_print_ptr(ndr, "EncryptedPassword", r->in.EncryptedPassword);

9474

ndr->depth++;

9475

if (r->in.EncryptedPassword) {

9476

ndr_print_wkssvc_PasswordBuffer(ndr, "EncryptedPassword", r->in.EncryptedPassword);

9477

}

9478

ndr->depth--;

9479

ndr_print_wkssvc_NetValidateNameType(ndr, "name_type", r->in.name_type);

9480

ndr->depth--;

9481

}

9482

if (flags & NDR_OUT) {

9483

ndr_print_struct(ndr, "out", "wkssvc_NetrValidateName2");

9484

ndr->depth++;

9485

ndr_print_WERROR(ndr, "result", r->out.result);

9486

ndr->depth--;

9487

}

9488

ndr->depth--;

9489

}

9490

9491

static enum ndr_err_code ndr_push_wkssvc_NetrGetJoinableOus2(struct ndr_push *ndr, int flags, const struct wkssvc_NetrGetJoinableOus2 *r)

9492

{

9493

uint32_t cntr_ous_2;

9494

if (flags & NDR_IN) {

9495

NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server_name));

9496

if (r->in.server_name) {

9497

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));

9498

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));

9499

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));

9500

NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server_name, ndr_charset_length(r->in.server_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));

9501

}

9502

if (r->in.domain_name == NULL) {

9503

return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");

9504

}

9505

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.domain_name, CH_UTF16)));

9506

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));

9507

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.domain_name, CH_UTF16)));

9508

NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.domain_name, ndr_charset_length(r->in.domain_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));

9509

NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.Account));

9510

if (r->in.Account) {

9511

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.Account, CH_UTF16)));

9512

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));

9513

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.Account, CH_UTF16)));

9514

NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.Account, ndr_charset_length(r->in.Account, CH_UTF16), sizeof(uint16_t), CH_UTF16));

9515

}

9516

NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.EncryptedPassword));

9517

if (r->in.EncryptedPassword) {

9518

NDR_CHECK(ndr_push_wkssvc_PasswordBuffer(ndr, NDR_SCALARS, r->in.EncryptedPassword));

9519

}

9520

if (r->in.num_ous == NULL) {

9521

return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");

9522

}

9523

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->in.num_ous));

9524

}

9525

if (flags & NDR_OUT) {

9526

if (r->out.num_ous == NULL) {

9527

return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");

9528

}

9529

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.num_ous));

9530

if (r->out.ous == NULL) {

9531

return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");

9532

}

9533

NDR_CHECK(ndr_push_unique_ptr(ndr, *r->out.ous));

9534

if (*r->out.ous) {

9535

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.num_ous));

9536

for (cntr_ous_2 = 0; cntr_ous_2 < *r->out.num_ous; cntr_ous_2++) {

9537

NDR_CHECK(ndr_push_unique_ptr(ndr, (*r->out.ous)[cntr_ous_2]));

9538

}

9539

for (cntr_ous_2 = 0; cntr_ous_2 < *r->out.num_ous; cntr_ous_2++) {

9540

if ((*r->out.ous)[cntr_ous_2]) {

9541

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length((*r->out.ous)[cntr_ous_2], CH_UTF16)));

9542

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));

9543

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length((*r->out.ous)[cntr_ous_2], CH_UTF16)));

9544

NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, (*r->out.ous)[cntr_ous_2], ndr_charset_length((*r->out.ous)[cntr_ous_2], CH_UTF16), sizeof(uint16_t), CH_UTF16));

9545

}

9546

}

9547

}

9548

NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));

9549

}

9550

return NDR_ERR_SUCCESS;

9551

}

9552

9553

static enum ndr_err_code ndr_pull_wkssvc_NetrGetJoinableOus2(struct ndr_pull *ndr, int flags, struct wkssvc_NetrGetJoinableOus2 *r)

9554

{

9555

uint32_t _ptr_server_name;

9556

uint32_t _ptr_Account;

9557

uint32_t _ptr_EncryptedPassword;

9558

uint32_t _ptr_ous;

9559

uint32_t cntr_ous_2;

9560

TALLOC_CTX *_mem_save_server_name_0;

9561

TALLOC_CTX *_mem_save_Account_0;

9562

TALLOC_CTX *_mem_save_EncryptedPassword_0;

9563

TALLOC_CTX *_mem_save_num_ous_0;

9564

TALLOC_CTX *_mem_save_ous_0;

9565

TALLOC_CTX *_mem_save_ous_1;

9566

TALLOC_CTX *_mem_save_ous_2;

9567

TALLOC_CTX *_mem_save_ous_3;

9568

if (flags & NDR_IN) {

9569

ZERO_STRUCT(r->out);

9570

9571

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_name));

9572

if (_ptr_server_name) {

9573

NDR_PULL_ALLOC(ndr, r->in.server_name);

9574

} else {

9575

r->in.server_name = NULL;

9576

}

9577

if (r->in.server_name) {

9578

_mem_save_server_name_0 = NDR_PULL_GET_MEM_CTX(ndr);

9579

NDR_PULL_SET_MEM_CTX(ndr, r->in.server_name, 0);

9580

NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_name));

9581

NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_name));

9582

if (ndr_get_array_length(ndr, &r->in.server_name) > ndr_get_array_size(ndr, &r->in.server_name)) {

9583

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_name), ndr_get_array_length(ndr, &r->in.server_name));

9584

}

9585

NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server_name), sizeof(uint16_t)));

9586

NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server_name, ndr_get_array_length(ndr, &r->in.server_name), sizeof(uint16_t), CH_UTF16));

9587

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_name_0, 0);

9588

}

9589

NDR_CHECK(ndr_pull_array_size(ndr, &r->in.domain_name));

9590

NDR_CHECK(ndr_pull_array_length(ndr, &r->in.domain_name));

9591

if (ndr_get_array_length(ndr, &r->in.domain_name) > ndr_get_array_size(ndr, &r->in.domain_name)) {

9592

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.domain_name), ndr_get_array_length(ndr, &r->in.domain_name));

9593

}

9594

NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.domain_name), sizeof(uint16_t)));

9595

NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.domain_name, ndr_get_array_length(ndr, &r->in.domain_name), sizeof(uint16_t), CH_UTF16));

9596

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_Account));

9597

if (_ptr_Account) {

9598

NDR_PULL_ALLOC(ndr, r->in.Account);

9599

} else {

9600

r->in.Account = NULL;

9601

}

9602

if (r->in.Account) {

9603

_mem_save_Account_0 = NDR_PULL_GET_MEM_CTX(ndr);

9604

NDR_PULL_SET_MEM_CTX(ndr, r->in.Account, 0);

9605

NDR_CHECK(ndr_pull_array_size(ndr, &r->in.Account));

9606

NDR_CHECK(ndr_pull_array_length(ndr, &r->in.Account));

9607

if (ndr_get_array_length(ndr, &r->in.Account) > ndr_get_array_size(ndr, &r->in.Account)) {

9608

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.Account), ndr_get_array_length(ndr, &r->in.Account));

9609

}

9610

NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.Account), sizeof(uint16_t)));

9611

NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.Account, ndr_get_array_length(ndr, &r->in.Account), sizeof(uint16_t), CH_UTF16));

9612

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_Account_0, 0);

9613

}

9614

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_EncryptedPassword));

9615

if (_ptr_EncryptedPassword) {

9616

NDR_PULL_ALLOC(ndr, r->in.EncryptedPassword);

9617

} else {

9618

r->in.EncryptedPassword = NULL;

9619

}

9620

if (r->in.EncryptedPassword) {

9621

_mem_save_EncryptedPassword_0 = NDR_PULL_GET_MEM_CTX(ndr);

9622

NDR_PULL_SET_MEM_CTX(ndr, r->in.EncryptedPassword, 0);

9623

NDR_CHECK(ndr_pull_wkssvc_PasswordBuffer(ndr, NDR_SCALARS, r->in.EncryptedPassword));

9624

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_EncryptedPassword_0, 0);

9625

}

9626

if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {

9627

NDR_PULL_ALLOC(ndr, r->in.num_ous);

9628

}

9629

_mem_save_num_ous_0 = NDR_PULL_GET_MEM_CTX(ndr);

9630

NDR_PULL_SET_MEM_CTX(ndr, r->in.num_ous, LIBNDR_FLAG_REF_ALLOC);

9631

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->in.num_ous));

9632

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_num_ous_0, LIBNDR_FLAG_REF_ALLOC);

9633

NDR_PULL_ALLOC(ndr, r->out.num_ous);

9634

*r->out.num_ous = *r->in.num_ous;

9635

NDR_PULL_ALLOC(ndr, r->out.ous);

9636

ZERO_STRUCTP(r->out.ous);

9637

}

9638

if (flags & NDR_OUT) {

9639

if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {

9640

NDR_PULL_ALLOC(ndr, r->out.num_ous);

9641

}

9642

_mem_save_num_ous_0 = NDR_PULL_GET_MEM_CTX(ndr);

9643

NDR_PULL_SET_MEM_CTX(ndr, r->out.num_ous, LIBNDR_FLAG_REF_ALLOC);

9644

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.num_ous));

9645

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_num_ous_0, LIBNDR_FLAG_REF_ALLOC);

9646

if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {

9647

NDR_PULL_ALLOC(ndr, r->out.ous);

9648

}

9649

_mem_save_ous_0 = NDR_PULL_GET_MEM_CTX(ndr);

9650

NDR_PULL_SET_MEM_CTX(ndr, r->out.ous, LIBNDR_FLAG_REF_ALLOC);

9651

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_ous));

9652

if (_ptr_ous) {

9653

NDR_PULL_ALLOC(ndr, *r->out.ous);

9654

} else {

9655

*r->out.ous = NULL;

9656

}

9657

if (*r->out.ous) {

9658

_mem_save_ous_1 = NDR_PULL_GET_MEM_CTX(ndr);

9659

NDR_PULL_SET_MEM_CTX(ndr, *r->out.ous, 0);

9660

NDR_CHECK(ndr_pull_array_size(ndr, r->out.ous));

9661

NDR_PULL_ALLOC_N(ndr, *r->out.ous, ndr_get_array_size(ndr, r->out.ous));

9662

_mem_save_ous_2 = NDR_PULL_GET_MEM_CTX(ndr);

9663

NDR_PULL_SET_MEM_CTX(ndr, *r->out.ous, 0);

9664

for (cntr_ous_2 = 0; cntr_ous_2 < *r->out.num_ous; cntr_ous_2++) {

9665

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_ous));

9666

if (_ptr_ous) {

9667

NDR_PULL_ALLOC(ndr, (*r->out.ous)[cntr_ous_2]);

9668

} else {

9669

(*r->out.ous)[cntr_ous_2] = NULL;

9670

}

9671

}

9672

for (cntr_ous_2 = 0; cntr_ous_2 < *r->out.num_ous; cntr_ous_2++) {

9673

if ((*r->out.ous)[cntr_ous_2]) {

9674

_mem_save_ous_3 = NDR_PULL_GET_MEM_CTX(ndr);

9675

NDR_PULL_SET_MEM_CTX(ndr, (*r->out.ous)[cntr_ous_2], 0);

9676

NDR_CHECK(ndr_pull_array_size(ndr, &(*r->out.ous)[cntr_ous_2]));

9677

NDR_CHECK(ndr_pull_array_length(ndr, &(*r->out.ous)[cntr_ous_2]));

9678

if (ndr_get_array_length(ndr, &(*r->out.ous)[cntr_ous_2]) > ndr_get_array_size(ndr, &(*r->out.ous)[cntr_ous_2])) {

9679

9680

}

9681

NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &(*r->out.ous)[cntr_ous_2]), sizeof(uint16_t)));

9682

NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &(*r->out.ous)[cntr_ous_2], ndr_get_array_length(ndr, &(*r->out.ous)[cntr_ous_2]), sizeof(uint16_t), CH_UTF16));

9683

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ous_3, 0);

9684

}

9685

}

9686

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ous_2, 0);

9687

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ous_1, 0);

9688

}

9689

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ous_0, LIBNDR_FLAG_REF_ALLOC);

9690

NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));

9691

if (*r->out.ous) {

9692

NDR_CHECK(ndr_check_array_size(ndr, (void*)r->out.ous, *r->out.num_ous));

9693

}

9694

}

9695

return NDR_ERR_SUCCESS;

9696

}

9697

9698

_PUBLIC_ void ndr_print_wkssvc_NetrGetJoinableOus2(struct ndr_print *ndr, const char *name, int flags, const struct wkssvc_NetrGetJoinableOus2 *r)

9699

{

9700

uint32_t cntr_ous_2;

9701

ndr_print_struct(ndr, name, "wkssvc_NetrGetJoinableOus2");

9702

ndr->depth++;

9703

if (flags & NDR_SET_VALUES) {

9704

ndr->flags |= LIBNDR_PRINT_SET_VALUES;

9705

}

9706

if (flags & NDR_IN) {

9707

ndr_print_struct(ndr, "in", "wkssvc_NetrGetJoinableOus2");

9708

ndr->depth++;

9709

ndr_print_ptr(ndr, "server_name", r->in.server_name);

9710

ndr->depth++;

9711

if (r->in.server_name) {

9712

ndr_print_string(ndr, "server_name", r->in.server_name);

9713

}

9714

ndr->depth--;

9715

ndr_print_ptr(ndr, "domain_name", r->in.domain_name);

9716

ndr->depth++;

9717

ndr_print_string(ndr, "domain_name", r->in.domain_name);

9718

ndr->depth--;

9719

ndr_print_ptr(ndr, "Account", r->in.Account);

9720

ndr->depth++;

9721

if (r->in.Account) {

9722

ndr_print_string(ndr, "Account", r->in.Account);

9723

}

9724

ndr->depth--;

9725

ndr_print_ptr(ndr, "EncryptedPassword", r->in.EncryptedPassword);

9726

ndr->depth++;

9727

if (r->in.EncryptedPassword) {

9728

ndr_print_wkssvc_PasswordBuffer(ndr, "EncryptedPassword", r->in.EncryptedPassword);

9729

}

9730

ndr->depth--;

9731

ndr_print_ptr(ndr, "num_ous", r->in.num_ous);

9732

ndr->depth++;

9733

ndr_print_uint32(ndr, "num_ous", *r->in.num_ous);

9734

ndr->depth--;

9735

ndr->depth--;

9736

}

9737

if (flags & NDR_OUT) {

9738

ndr_print_struct(ndr, "out", "wkssvc_NetrGetJoinableOus2");

9739

ndr->depth++;

9740

ndr_print_ptr(ndr, "num_ous", r->out.num_ous);

9741

ndr->depth++;

9742

ndr_print_uint32(ndr, "num_ous", *r->out.num_ous);

9743

ndr->depth--;

9744

ndr_print_ptr(ndr, "ous", r->out.ous);

9745

ndr->depth++;

9746

ndr_print_ptr(ndr, "ous", *r->out.ous);

9747

ndr->depth++;

9748

if (*r->out.ous) {

9749

ndr->print(ndr, "%s: ARRAY(%d)", "ous", (int)*r->out.num_ous);

9750

ndr->depth++;

9751

for (cntr_ous_2=0;cntr_ous_2<*r->out.num_ous;cntr_ous_2++) {

9752

char *idx_2=NULL;

9753

if (asprintf(&idx_2, "[%d]", cntr_ous_2) != -1) {

9754

ndr_print_ptr(ndr, "ous", (*r->out.ous)[cntr_ous_2]);

9755

ndr->depth++;

9756

if ((*r->out.ous)[cntr_ous_2]) {

9757

ndr_print_string(ndr, "ous", (*r->out.ous)[cntr_ous_2]);

9758

}

9759

ndr->depth--;

9760

free(idx_2);

9761

}

9762

}

9763

ndr->depth--;

9764

}

9765

ndr->depth--;

9766

ndr->depth--;

9767

ndr_print_WERROR(ndr, "result", r->out.result);

9768

ndr->depth--;

9769

}

9770

ndr->depth--;

9771

}

9772

9773

static enum ndr_err_code ndr_push_wkssvc_NetrAddAlternateComputerName(struct ndr_push *ndr, int flags, const struct wkssvc_NetrAddAlternateComputerName *r)

9774

{

9775

if (flags & NDR_IN) {

9776

NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server_name));

9777

if (r->in.server_name) {

9778

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));

9779

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));

9780

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));

9781

NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server_name, ndr_charset_length(r->in.server_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));

9782

}

9783

NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.NewAlternateMachineName));

9784

if (r->in.NewAlternateMachineName) {

9785

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.NewAlternateMachineName, CH_UTF16)));

9786

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));

9787

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.NewAlternateMachineName, CH_UTF16)));

9788

NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.NewAlternateMachineName, ndr_charset_length(r->in.NewAlternateMachineName, CH_UTF16), sizeof(uint16_t), CH_UTF16));

9789

}

9790

NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.Account));

9791

if (r->in.Account) {

9792

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.Account, CH_UTF16)));

9793

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));

9794

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.Account, CH_UTF16)));

9795

NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.Account, ndr_charset_length(r->in.Account, CH_UTF16), sizeof(uint16_t), CH_UTF16));

9796

}

9797

NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.EncryptedPassword));

9798

if (r->in.EncryptedPassword) {

9799

NDR_CHECK(ndr_push_wkssvc_PasswordBuffer(ndr, NDR_SCALARS, r->in.EncryptedPassword));

9800

}

9801

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.Reserved));

9802

}

9803

if (flags & NDR_OUT) {

9804

NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));

9805

}

9806

return NDR_ERR_SUCCESS;

9807

}

9808

9809

static enum ndr_err_code ndr_pull_wkssvc_NetrAddAlternateComputerName(struct ndr_pull *ndr, int flags, struct wkssvc_NetrAddAlternateComputerName *r)

9810

{

9811

uint32_t _ptr_server_name;

9812

uint32_t _ptr_NewAlternateMachineName;

9813

uint32_t _ptr_Account;

9814

uint32_t _ptr_EncryptedPassword;

9815

TALLOC_CTX *_mem_save_server_name_0;

9816

TALLOC_CTX *_mem_save_NewAlternateMachineName_0;

9817

TALLOC_CTX *_mem_save_Account_0;

9818

TALLOC_CTX *_mem_save_EncryptedPassword_0;

9819

if (flags & NDR_IN) {

9820

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_name));

9821

if (_ptr_server_name) {

9822

NDR_PULL_ALLOC(ndr, r->in.server_name);

9823

} else {

9824

r->in.server_name = NULL;

9825

}

9826

if (r->in.server_name) {

9827

_mem_save_server_name_0 = NDR_PULL_GET_MEM_CTX(ndr);

9828

NDR_PULL_SET_MEM_CTX(ndr, r->in.server_name, 0);

9829

NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_name));

9830

NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_name));

9831

if (ndr_get_array_length(ndr, &r->in.server_name) > ndr_get_array_size(ndr, &r->in.server_name)) {

9832

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_name), ndr_get_array_length(ndr, &r->in.server_name));

9833

}

9834

NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server_name), sizeof(uint16_t)));

9835

NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server_name, ndr_get_array_length(ndr, &r->in.server_name), sizeof(uint16_t), CH_UTF16));

9836

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_name_0, 0);

9837

}

9838

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_NewAlternateMachineName));

9839

if (_ptr_NewAlternateMachineName) {

9840

NDR_PULL_ALLOC(ndr, r->in.NewAlternateMachineName);

9841

} else {

9842

r->in.NewAlternateMachineName = NULL;

9843

}

9844

if (r->in.NewAlternateMachineName) {

9845

_mem_save_NewAlternateMachineName_0 = NDR_PULL_GET_MEM_CTX(ndr);

9846

NDR_PULL_SET_MEM_CTX(ndr, r->in.NewAlternateMachineName, 0);

9847

NDR_CHECK(ndr_pull_array_size(ndr, &r->in.NewAlternateMachineName));

9848

NDR_CHECK(ndr_pull_array_length(ndr, &r->in.NewAlternateMachineName));

9849

if (ndr_get_array_length(ndr, &r->in.NewAlternateMachineName) > ndr_get_array_size(ndr, &r->in.NewAlternateMachineName)) {

9850

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.NewAlternateMachineName), ndr_get_array_length(ndr, &r->in.NewAlternateMachineName));

9851

}

9852

NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.NewAlternateMachineName), sizeof(uint16_t)));

9853

NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.NewAlternateMachineName, ndr_get_array_length(ndr, &r->in.NewAlternateMachineName), sizeof(uint16_t), CH_UTF16));

9854

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_NewAlternateMachineName_0, 0);

9855

}

9856

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_Account));

9857

if (_ptr_Account) {

9858

NDR_PULL_ALLOC(ndr, r->in.Account);

9859

} else {

9860

r->in.Account = NULL;

9861

}

9862

if (r->in.Account) {

9863

_mem_save_Account_0 = NDR_PULL_GET_MEM_CTX(ndr);

9864

NDR_PULL_SET_MEM_CTX(ndr, r->in.Account, 0);

9865

NDR_CHECK(ndr_pull_array_size(ndr, &r->in.Account));

9866

NDR_CHECK(ndr_pull_array_length(ndr, &r->in.Account));

9867

if (ndr_get_array_length(ndr, &r->in.Account) > ndr_get_array_size(ndr, &r->in.Account)) {

9868

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.Account), ndr_get_array_length(ndr, &r->in.Account));

9869

}

9870

NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.Account), sizeof(uint16_t)));

9871

NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.Account, ndr_get_array_length(ndr, &r->in.Account), sizeof(uint16_t), CH_UTF16));

9872

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_Account_0, 0);

9873

}

9874

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_EncryptedPassword));

9875

if (_ptr_EncryptedPassword) {

9876

NDR_PULL_ALLOC(ndr, r->in.EncryptedPassword);

9877

} else {

9878

r->in.EncryptedPassword = NULL;

9879

}

9880

if (r->in.EncryptedPassword) {

9881

_mem_save_EncryptedPassword_0 = NDR_PULL_GET_MEM_CTX(ndr);

9882

NDR_PULL_SET_MEM_CTX(ndr, r->in.EncryptedPassword, 0);

9883

NDR_CHECK(ndr_pull_wkssvc_PasswordBuffer(ndr, NDR_SCALARS, r->in.EncryptedPassword));

9884

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_EncryptedPassword_0, 0);

9885

}

9886

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.Reserved));

9887

}

9888

if (flags & NDR_OUT) {

9889

NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));

9890

}

9891

return NDR_ERR_SUCCESS;

9892

}

9893

9894

_PUBLIC_ void ndr_print_wkssvc_NetrAddAlternateComputerName(struct ndr_print *ndr, const char *name, int flags, const struct wkssvc_NetrAddAlternateComputerName *r)

9895

{

9896

ndr_print_struct(ndr, name, "wkssvc_NetrAddAlternateComputerName");

9897

ndr->depth++;

9898

if (flags & NDR_SET_VALUES) {

9899

ndr->flags |= LIBNDR_PRINT_SET_VALUES;

9900

}

9901

if (flags & NDR_IN) {

9902

ndr_print_struct(ndr, "in", "wkssvc_NetrAddAlternateComputerName");

9903

ndr->depth++;

9904

ndr_print_ptr(ndr, "server_name", r->in.server_name);

9905

ndr->depth++;

9906

if (r->in.server_name) {

9907

ndr_print_string(ndr, "server_name", r->in.server_name);

9908

}

9909

ndr->depth--;

9910

ndr_print_ptr(ndr, "NewAlternateMachineName", r->in.NewAlternateMachineName);

9911

ndr->depth++;

9912

if (r->in.NewAlternateMachineName) {

9913

ndr_print_string(ndr, "NewAlternateMachineName", r->in.NewAlternateMachineName);

9914

}

9915

ndr->depth--;

9916

ndr_print_ptr(ndr, "Account", r->in.Account);

9917

ndr->depth++;

9918

if (r->in.Account) {

9919

ndr_print_string(ndr, "Account", r->in.Account);

9920

}

9921

ndr->depth--;

9922

ndr_print_ptr(ndr, "EncryptedPassword", r->in.EncryptedPassword);

9923

ndr->depth++;

9924

if (r->in.EncryptedPassword) {

9925

ndr_print_wkssvc_PasswordBuffer(ndr, "EncryptedPassword", r->in.EncryptedPassword);

9926

}

9927

ndr->depth--;

9928

ndr_print_uint32(ndr, "Reserved", r->in.Reserved);

9929

ndr->depth--;

9930

}

9931

if (flags & NDR_OUT) {

9932

ndr_print_struct(ndr, "out", "wkssvc_NetrAddAlternateComputerName");

9933

ndr->depth++;

9934

ndr_print_WERROR(ndr, "result", r->out.result);

9935

ndr->depth--;

9936

}

9937

ndr->depth--;

9938

}

9939

9940

static enum ndr_err_code ndr_push_wkssvc_NetrRemoveAlternateComputerName(struct ndr_push *ndr, int flags, const struct wkssvc_NetrRemoveAlternateComputerName *r)

9941

{

9942

if (flags & NDR_IN) {

9943

NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server_name));

9944

if (r->in.server_name) {

9945

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));

9946

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));

9947

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));

9948

NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server_name, ndr_charset_length(r->in.server_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));

9949

}

9950

NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.AlternateMachineNameToRemove));

9951

if (r->in.AlternateMachineNameToRemove) {

9952

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.AlternateMachineNameToRemove, CH_UTF16)));

9953

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));

9954

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.AlternateMachineNameToRemove, CH_UTF16)));

9955

NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.AlternateMachineNameToRemove, ndr_charset_length(r->in.AlternateMachineNameToRemove, CH_UTF16), sizeof(uint16_t), CH_UTF16));

9956

}

9957

NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.Account));

9958

if (r->in.Account) {

9959

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.Account, CH_UTF16)));

9960

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));

9961

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.Account, CH_UTF16)));

9962

NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.Account, ndr_charset_length(r->in.Account, CH_UTF16), sizeof(uint16_t), CH_UTF16));

9963

}

9964

NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.EncryptedPassword));

9965

if (r->in.EncryptedPassword) {

9966

NDR_CHECK(ndr_push_wkssvc_PasswordBuffer(ndr, NDR_SCALARS, r->in.EncryptedPassword));

9967

}

9968

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.Reserved));

9969

}

9970

if (flags & NDR_OUT) {

9971

NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));

9972

}

9973

return NDR_ERR_SUCCESS;

9974

}

9975

9976

static enum ndr_err_code ndr_pull_wkssvc_NetrRemoveAlternateComputerName(struct ndr_pull *ndr, int flags, struct wkssvc_NetrRemoveAlternateComputerName *r)

9977

{

9978

uint32_t _ptr_server_name;

9979

uint32_t _ptr_AlternateMachineNameToRemove;

9980

uint32_t _ptr_Account;

9981

uint32_t _ptr_EncryptedPassword;

9982

TALLOC_CTX *_mem_save_server_name_0;

9983

TALLOC_CTX *_mem_save_AlternateMachineNameToRemove_0;

9984

TALLOC_CTX *_mem_save_Account_0;

9985

TALLOC_CTX *_mem_save_EncryptedPassword_0;

9986

if (flags & NDR_IN) {

9987

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_name));

9988

if (_ptr_server_name) {

9989

NDR_PULL_ALLOC(ndr, r->in.server_name);

9990

} else {

9991

r->in.server_name = NULL;

9992

}

9993

if (r->in.server_name) {

9994

_mem_save_server_name_0 = NDR_PULL_GET_MEM_CTX(ndr);

9995

NDR_PULL_SET_MEM_CTX(ndr, r->in.server_name, 0);

9996

NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_name));

9997

NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_name));

9998

if (ndr_get_array_length(ndr, &r->in.server_name) > ndr_get_array_size(ndr, &r->in.server_name)) {

9999

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_name), ndr_get_array_length(ndr, &r->in.server_name));

10000

}

10001

NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server_name), sizeof(uint16_t)));

10002

NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server_name, ndr_get_array_length(ndr, &r->in.server_name), sizeof(uint16_t), CH_UTF16));

10003

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_name_0, 0);

10004

}

10005

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_AlternateMachineNameToRemove));

10006

if (_ptr_AlternateMachineNameToRemove) {

10007

NDR_PULL_ALLOC(ndr, r->in.AlternateMachineNameToRemove);

10008

} else {

10009

r->in.AlternateMachineNameToRemove = NULL;

10010

}

10011

if (r->in.AlternateMachineNameToRemove) {

10012

_mem_save_AlternateMachineNameToRemove_0 = NDR_PULL_GET_MEM_CTX(ndr);

10013

NDR_PULL_SET_MEM_CTX(ndr, r->in.AlternateMachineNameToRemove, 0);

10014

NDR_CHECK(ndr_pull_array_size(ndr, &r->in.AlternateMachineNameToRemove));

10015

NDR_CHECK(ndr_pull_array_length(ndr, &r->in.AlternateMachineNameToRemove));

10016

if (ndr_get_array_length(ndr, &r->in.AlternateMachineNameToRemove) > ndr_get_array_size(ndr, &r->in.AlternateMachineNameToRemove)) {

10017

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.AlternateMachineNameToRemove), ndr_get_array_length(ndr, &r->in.AlternateMachineNameToRemove));

10018

}

10019

NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.AlternateMachineNameToRemove), sizeof(uint16_t)));

10020

NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.AlternateMachineNameToRemove, ndr_get_array_length(ndr, &r->in.AlternateMachineNameToRemove), sizeof(uint16_t), CH_UTF16));

10021

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_AlternateMachineNameToRemove_0, 0);

10022

}

10023

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_Account));

10024

if (_ptr_Account) {

10025

NDR_PULL_ALLOC(ndr, r->in.Account);

10026

} else {

10027

r->in.Account = NULL;

10028

}

10029

if (r->in.Account) {

10030

_mem_save_Account_0 = NDR_PULL_GET_MEM_CTX(ndr);

10031

NDR_PULL_SET_MEM_CTX(ndr, r->in.Account, 0);

10032

NDR_CHECK(ndr_pull_array_size(ndr, &r->in.Account));

10033

NDR_CHECK(ndr_pull_array_length(ndr, &r->in.Account));

10034

if (ndr_get_array_length(ndr, &r->in.Account) > ndr_get_array_size(ndr, &r->in.Account)) {

10035

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.Account), ndr_get_array_length(ndr, &r->in.Account));

10036

}

10037

NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.Account), sizeof(uint16_t)));

10038

NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.Account, ndr_get_array_length(ndr, &r->in.Account), sizeof(uint16_t), CH_UTF16));

10039

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_Account_0, 0);

10040

}

10041

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_EncryptedPassword));

10042

if (_ptr_EncryptedPassword) {

10043

NDR_PULL_ALLOC(ndr, r->in.EncryptedPassword);

10044

} else {

10045

r->in.EncryptedPassword = NULL;

10046

}

10047

if (r->in.EncryptedPassword) {

10048

_mem_save_EncryptedPassword_0 = NDR_PULL_GET_MEM_CTX(ndr);

10049

NDR_PULL_SET_MEM_CTX(ndr, r->in.EncryptedPassword, 0);

10050

NDR_CHECK(ndr_pull_wkssvc_PasswordBuffer(ndr, NDR_SCALARS, r->in.EncryptedPassword));

10051

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_EncryptedPassword_0, 0);

10052

}

10053

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.Reserved));

10054

}

10055

if (flags & NDR_OUT) {

10056

NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));

10057

}

10058

return NDR_ERR_SUCCESS;

10059

}

10060

10061

_PUBLIC_ void ndr_print_wkssvc_NetrRemoveAlternateComputerName(struct ndr_print *ndr, const char *name, int flags, const struct wkssvc_NetrRemoveAlternateComputerName *r)

10062

{

10063

ndr_print_struct(ndr, name, "wkssvc_NetrRemoveAlternateComputerName");

10064

ndr->depth++;

10065

if (flags & NDR_SET_VALUES) {

10066

ndr->flags |= LIBNDR_PRINT_SET_VALUES;

10067

}

10068

if (flags & NDR_IN) {

10069

ndr_print_struct(ndr, "in", "wkssvc_NetrRemoveAlternateComputerName");

10070

ndr->depth++;

10071

ndr_print_ptr(ndr, "server_name", r->in.server_name);

10072

ndr->depth++;

10073

if (r->in.server_name) {

10074

ndr_print_string(ndr, "server_name", r->in.server_name);

10075

}

10076

ndr->depth--;

10077

ndr_print_ptr(ndr, "AlternateMachineNameToRemove", r->in.AlternateMachineNameToRemove);

10078

ndr->depth++;

10079

if (r->in.AlternateMachineNameToRemove) {

10080

ndr_print_string(ndr, "AlternateMachineNameToRemove", r->in.AlternateMachineNameToRemove);

10081

}

10082

ndr->depth--;

10083

ndr_print_ptr(ndr, "Account", r->in.Account);

10084

ndr->depth++;

10085

if (r->in.Account) {

10086

ndr_print_string(ndr, "Account", r->in.Account);

10087

}

10088

ndr->depth--;

10089

ndr_print_ptr(ndr, "EncryptedPassword", r->in.EncryptedPassword);

10090

ndr->depth++;

10091

if (r->in.EncryptedPassword) {

10092

ndr_print_wkssvc_PasswordBuffer(ndr, "EncryptedPassword", r->in.EncryptedPassword);

10093

}

10094

ndr->depth--;

10095

ndr_print_uint32(ndr, "Reserved", r->in.Reserved);

10096

ndr->depth--;

10097

}

10098

if (flags & NDR_OUT) {

10099

ndr_print_struct(ndr, "out", "wkssvc_NetrRemoveAlternateComputerName");

10100

ndr->depth++;

10101

ndr_print_WERROR(ndr, "result", r->out.result);

10102

ndr->depth--;

10103

}

10104

ndr->depth--;

10105

}

10106

10107

static enum ndr_err_code ndr_push_wkssvc_NetrSetPrimaryComputername(struct ndr_push *ndr, int flags, const struct wkssvc_NetrSetPrimaryComputername *r)

10108

{

10109

if (flags & NDR_IN) {

10110

NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server_name));

10111

if (r->in.server_name) {

10112

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));

10113

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));

10114

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));

10115

NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server_name, ndr_charset_length(r->in.server_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));

10116

}

10117

NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.primary_name));

10118

if (r->in.primary_name) {

10119

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.primary_name, CH_UTF16)));

10120

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));

10121

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.primary_name, CH_UTF16)));

10122

NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.primary_name, ndr_charset_length(r->in.primary_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));

10123

}

10124

NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.Account));

10125

if (r->in.Account) {

10126

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.Account, CH_UTF16)));

10127

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));

10128

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.Account, CH_UTF16)));

10129

NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.Account, ndr_charset_length(r->in.Account, CH_UTF16), sizeof(uint16_t), CH_UTF16));

10130

}

10131

NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.EncryptedPassword));

10132

if (r->in.EncryptedPassword) {

10133

NDR_CHECK(ndr_push_wkssvc_PasswordBuffer(ndr, NDR_SCALARS, r->in.EncryptedPassword));

10134

}

10135

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.Reserved));

10136

}

10137

if (flags & NDR_OUT) {

10138

NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));

10139

}

10140

return NDR_ERR_SUCCESS;

10141

}

10142

10143

static enum ndr_err_code ndr_pull_wkssvc_NetrSetPrimaryComputername(struct ndr_pull *ndr, int flags, struct wkssvc_NetrSetPrimaryComputername *r)

10144

{

10145

uint32_t _ptr_server_name;

10146

uint32_t _ptr_primary_name;

10147

uint32_t _ptr_Account;

10148

uint32_t _ptr_EncryptedPassword;

10149

TALLOC_CTX *_mem_save_server_name_0;

10150

TALLOC_CTX *_mem_save_primary_name_0;

10151

TALLOC_CTX *_mem_save_Account_0;

10152

TALLOC_CTX *_mem_save_EncryptedPassword_0;

10153

if (flags & NDR_IN) {

10154

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_name));

10155

if (_ptr_server_name) {

10156

NDR_PULL_ALLOC(ndr, r->in.server_name);

10157

} else {

10158

r->in.server_name = NULL;

10159

}

10160

if (r->in.server_name) {

10161

_mem_save_server_name_0 = NDR_PULL_GET_MEM_CTX(ndr);

10162

NDR_PULL_SET_MEM_CTX(ndr, r->in.server_name, 0);

10163

NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_name));

10164

NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_name));

10165

if (ndr_get_array_length(ndr, &r->in.server_name) > ndr_get_array_size(ndr, &r->in.server_name)) {

10166

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_name), ndr_get_array_length(ndr, &r->in.server_name));

10167

}

10168

NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server_name), sizeof(uint16_t)));

10169

NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server_name, ndr_get_array_length(ndr, &r->in.server_name), sizeof(uint16_t), CH_UTF16));

10170

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_name_0, 0);

10171

}

10172

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_primary_name));

10173

if (_ptr_primary_name) {

10174

NDR_PULL_ALLOC(ndr, r->in.primary_name);

10175

} else {

10176

r->in.primary_name = NULL;

10177

}

10178

if (r->in.primary_name) {

10179

_mem_save_primary_name_0 = NDR_PULL_GET_MEM_CTX(ndr);

10180

NDR_PULL_SET_MEM_CTX(ndr, r->in.primary_name, 0);

10181

NDR_CHECK(ndr_pull_array_size(ndr, &r->in.primary_name));

10182

NDR_CHECK(ndr_pull_array_length(ndr, &r->in.primary_name));

10183

if (ndr_get_array_length(ndr, &r->in.primary_name) > ndr_get_array_size(ndr, &r->in.primary_name)) {

10184

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.primary_name), ndr_get_array_length(ndr, &r->in.primary_name));

10185

}

10186

NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.primary_name), sizeof(uint16_t)));

10187

NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.primary_name, ndr_get_array_length(ndr, &r->in.primary_name), sizeof(uint16_t), CH_UTF16));

10188

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_primary_name_0, 0);

10189

}

10190

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_Account));

10191

if (_ptr_Account) {

10192

NDR_PULL_ALLOC(ndr, r->in.Account);

10193

} else {

10194

r->in.Account = NULL;

10195

}

10196

if (r->in.Account) {

10197

_mem_save_Account_0 = NDR_PULL_GET_MEM_CTX(ndr);

10198

NDR_PULL_SET_MEM_CTX(ndr, r->in.Account, 0);

10199

NDR_CHECK(ndr_pull_array_size(ndr, &r->in.Account));

10200

NDR_CHECK(ndr_pull_array_length(ndr, &r->in.Account));

10201

if (ndr_get_array_length(ndr, &r->in.Account) > ndr_get_array_size(ndr, &r->in.Account)) {

10202

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.Account), ndr_get_array_length(ndr, &r->in.Account));

10203

}

10204

NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.Account), sizeof(uint16_t)));

10205

NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.Account, ndr_get_array_length(ndr, &r->in.Account), sizeof(uint16_t), CH_UTF16));

10206

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_Account_0, 0);

10207

}

10208

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_EncryptedPassword));

10209

if (_ptr_EncryptedPassword) {

10210

NDR_PULL_ALLOC(ndr, r->in.EncryptedPassword);

10211

} else {

10212

r->in.EncryptedPassword = NULL;

10213

}

10214

if (r->in.EncryptedPassword) {

10215

_mem_save_EncryptedPassword_0 = NDR_PULL_GET_MEM_CTX(ndr);

10216

NDR_PULL_SET_MEM_CTX(ndr, r->in.EncryptedPassword, 0);

10217

NDR_CHECK(ndr_pull_wkssvc_PasswordBuffer(ndr, NDR_SCALARS, r->in.EncryptedPassword));

10218

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_EncryptedPassword_0, 0);

10219

}

10220

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.Reserved));

10221

}

10222

if (flags & NDR_OUT) {

10223

NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));

10224

}

10225

return NDR_ERR_SUCCESS;

10226

}

10227

10228

_PUBLIC_ void ndr_print_wkssvc_NetrSetPrimaryComputername(struct ndr_print *ndr, const char *name, int flags, const struct wkssvc_NetrSetPrimaryComputername *r)

10229

{

10230

ndr_print_struct(ndr, name, "wkssvc_NetrSetPrimaryComputername");

10231

ndr->depth++;

10232

if (flags & NDR_SET_VALUES) {

10233

ndr->flags |= LIBNDR_PRINT_SET_VALUES;

10234

}

10235

if (flags & NDR_IN) {

10236

ndr_print_struct(ndr, "in", "wkssvc_NetrSetPrimaryComputername");

10237

ndr->depth++;

10238

ndr_print_ptr(ndr, "server_name", r->in.server_name);

10239

ndr->depth++;

10240

if (r->in.server_name) {

10241

ndr_print_string(ndr, "server_name", r->in.server_name);

10242

}

10243

ndr->depth--;

10244

ndr_print_ptr(ndr, "primary_name", r->in.primary_name);

10245

ndr->depth++;

10246

if (r->in.primary_name) {

10247

ndr_print_string(ndr, "primary_name", r->in.primary_name);

10248

}

10249

ndr->depth--;

10250

ndr_print_ptr(ndr, "Account", r->in.Account);

10251

ndr->depth++;

10252

if (r->in.Account) {

10253

ndr_print_string(ndr, "Account", r->in.Account);

10254

}

10255

ndr->depth--;

10256

ndr_print_ptr(ndr, "EncryptedPassword", r->in.EncryptedPassword);

10257

ndr->depth++;

10258

if (r->in.EncryptedPassword) {

10259

ndr_print_wkssvc_PasswordBuffer(ndr, "EncryptedPassword", r->in.EncryptedPassword);

10260

}

10261

ndr->depth--;

10262

ndr_print_uint32(ndr, "Reserved", r->in.Reserved);

10263

ndr->depth--;

10264

}

10265

if (flags & NDR_OUT) {

10266

ndr_print_struct(ndr, "out", "wkssvc_NetrSetPrimaryComputername");

10267

ndr->depth++;

10268

ndr_print_WERROR(ndr, "result", r->out.result);

10269

ndr->depth--;

10270

}

10271

ndr->depth--;

10272

}

10273

10274

static enum ndr_err_code ndr_push_wkssvc_NetrEnumerateComputerNames(struct ndr_push *ndr, int flags, const struct wkssvc_NetrEnumerateComputerNames *r)

10275

{

10276

if (flags & NDR_IN) {

10277

NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server_name));

10278

if (r->in.server_name) {

10279

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));

10280

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));

10281

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));

10282

NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server_name, ndr_charset_length(r->in.server_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));

10283

}

10284

NDR_CHECK(ndr_push_wkssvc_ComputerNameType(ndr, NDR_SCALARS, r->in.name_type));

10285

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.Reserved));

10286

}

10287

if (flags & NDR_OUT) {

10288

if (r->out.ctr == NULL) {

10289

return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");

10290

}

10291

NDR_CHECK(ndr_push_unique_ptr(ndr, *r->out.ctr));

10292

if (*r->out.ctr) {

10293

NDR_CHECK(ndr_push_wkssvc_ComputerNamesCtr(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.ctr));

10294

}

10295

NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));

10296

}

10297

return NDR_ERR_SUCCESS;

10298

}

10299

10300

static enum ndr_err_code ndr_pull_wkssvc_NetrEnumerateComputerNames(struct ndr_pull *ndr, int flags, struct wkssvc_NetrEnumerateComputerNames *r)

10301

{

10302

uint32_t _ptr_server_name;

10303

uint32_t _ptr_ctr;

10304

TALLOC_CTX *_mem_save_server_name_0;

10305

TALLOC_CTX *_mem_save_ctr_0;

10306

TALLOC_CTX *_mem_save_ctr_1;

10307

if (flags & NDR_IN) {

10308

ZERO_STRUCT(r->out);

10309

10310

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_name));

10311

if (_ptr_server_name) {

10312

NDR_PULL_ALLOC(ndr, r->in.server_name);

10313

} else {

10314

r->in.server_name = NULL;

10315

}

10316

if (r->in.server_name) {

10317

_mem_save_server_name_0 = NDR_PULL_GET_MEM_CTX(ndr);

10318

NDR_PULL_SET_MEM_CTX(ndr, r->in.server_name, 0);

10319

NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_name));

10320

NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_name));

10321

if (ndr_get_array_length(ndr, &r->in.server_name) > ndr_get_array_size(ndr, &r->in.server_name)) {

10322

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_name), ndr_get_array_length(ndr, &r->in.server_name));

10323

}

10324

NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server_name), sizeof(uint16_t)));

10325

NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server_name, ndr_get_array_length(ndr, &r->in.server_name), sizeof(uint16_t), CH_UTF16));

10326

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_name_0, 0);

10327

}

10328

NDR_CHECK(ndr_pull_wkssvc_ComputerNameType(ndr, NDR_SCALARS, &r->in.name_type));

10329

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.Reserved));

10330

NDR_PULL_ALLOC(ndr, r->out.ctr);

10331

ZERO_STRUCTP(r->out.ctr);

10332

}

10333

if (flags & NDR_OUT) {

10334

if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {

10335

NDR_PULL_ALLOC(ndr, r->out.ctr);

10336

}

10337

_mem_save_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);

10338

NDR_PULL_SET_MEM_CTX(ndr, r->out.ctr, LIBNDR_FLAG_REF_ALLOC);

10339

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_ctr));

10340

if (_ptr_ctr) {

10341

NDR_PULL_ALLOC(ndr, *r->out.ctr);

10342

} else {

10343

*r->out.ctr = NULL;

10344

}

10345

if (*r->out.ctr) {

10346

_mem_save_ctr_1 = NDR_PULL_GET_MEM_CTX(ndr);

10347

NDR_PULL_SET_MEM_CTX(ndr, *r->out.ctr, 0);

10348

NDR_CHECK(ndr_pull_wkssvc_ComputerNamesCtr(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.ctr));

10349

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ctr_1, 0);

10350

}

10351

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ctr_0, LIBNDR_FLAG_REF_ALLOC);

10352

NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));

10353

}

10354

return NDR_ERR_SUCCESS;

10355

}

10356

10357

_PUBLIC_ void ndr_print_wkssvc_NetrEnumerateComputerNames(struct ndr_print *ndr, const char *name, int flags, const struct wkssvc_NetrEnumerateComputerNames *r)

10358

{

10359

ndr_print_struct(ndr, name, "wkssvc_NetrEnumerateComputerNames");

10360

ndr->depth++;

10361

if (flags & NDR_SET_VALUES) {

10362

ndr->flags |= LIBNDR_PRINT_SET_VALUES;

10363

}

10364

if (flags & NDR_IN) {

10365

ndr_print_struct(ndr, "in", "wkssvc_NetrEnumerateComputerNames");

10366

ndr->depth++;

10367

ndr_print_ptr(ndr, "server_name", r->in.server_name);

10368

ndr->depth++;

10369

if (r->in.server_name) {

10370

ndr_print_string(ndr, "server_name", r->in.server_name);

10371

}

10372

ndr->depth--;

10373

ndr_print_wkssvc_ComputerNameType(ndr, "name_type", r->in.name_type);

10374

ndr_print_uint32(ndr, "Reserved", r->in.Reserved);

10375

ndr->depth--;

10376

}

10377

if (flags & NDR_OUT) {

10378

ndr_print_struct(ndr, "out", "wkssvc_NetrEnumerateComputerNames");

10379

ndr->depth++;

10380

ndr_print_ptr(ndr, "ctr", r->out.ctr);

10381

ndr->depth++;

10382

ndr_print_ptr(ndr, "ctr", *r->out.ctr);

10383

ndr->depth++;

10384

if (*r->out.ctr) {

10385

ndr_print_wkssvc_ComputerNamesCtr(ndr, "ctr", *r->out.ctr);

10386

}

10387

ndr->depth--;

10388

ndr->depth--;

10389

ndr_print_WERROR(ndr, "result", r->out.result);

10390

ndr->depth--;

10391

}

10392

ndr->depth--;

10393

}

10394

10395

static const struct ndr_interface_call wkssvc_calls[] = {

10396

{

10397

"wkssvc_NetWkstaGetInfo",

10398

sizeof(struct wkssvc_NetWkstaGetInfo),

10399

(ndr_push_flags_fn_t) ndr_push_wkssvc_NetWkstaGetInfo,

10400

(ndr_pull_flags_fn_t) ndr_pull_wkssvc_NetWkstaGetInfo,

10401

(ndr_print_function_t) ndr_print_wkssvc_NetWkstaGetInfo,

10402

false,

10403

10404

{

10405

"wkssvc_NetWkstaSetInfo",

10406

sizeof(struct wkssvc_NetWkstaSetInfo),

10407

(ndr_push_flags_fn_t) ndr_push_wkssvc_NetWkstaSetInfo,

10408

(ndr_pull_flags_fn_t) ndr_pull_wkssvc_NetWkstaSetInfo,

10409

(ndr_print_function_t) ndr_print_wkssvc_NetWkstaSetInfo,

10410

false,

10411

10412

{

10413

"wkssvc_NetWkstaEnumUsers",

10414

sizeof(struct wkssvc_NetWkstaEnumUsers),

10415

(ndr_push_flags_fn_t) ndr_push_wkssvc_NetWkstaEnumUsers,

10416

(ndr_pull_flags_fn_t) ndr_pull_wkssvc_NetWkstaEnumUsers,

10417

(ndr_print_function_t) ndr_print_wkssvc_NetWkstaEnumUsers,

10418

false,

10419

10420

{

10421

"wkssvc_NetrWkstaUserGetInfo",

10422

sizeof(struct wkssvc_NetrWkstaUserGetInfo),

10423

(ndr_push_flags_fn_t) ndr_push_wkssvc_NetrWkstaUserGetInfo,

10424

(ndr_pull_flags_fn_t) ndr_pull_wkssvc_NetrWkstaUserGetInfo,

10425

(ndr_print_function_t) ndr_print_wkssvc_NetrWkstaUserGetInfo,

10426

false,

10427

10428

{

10429

"wkssvc_NetrWkstaUserSetInfo",

10430

sizeof(struct wkssvc_NetrWkstaUserSetInfo),

10431

(ndr_push_flags_fn_t) ndr_push_wkssvc_NetrWkstaUserSetInfo,

10432

(ndr_pull_flags_fn_t) ndr_pull_wkssvc_NetrWkstaUserSetInfo,

10433

(ndr_print_function_t) ndr_print_wkssvc_NetrWkstaUserSetInfo,

10434

false,

10435

10436

{

10437

"wkssvc_NetWkstaTransportEnum",

10438

sizeof(struct wkssvc_NetWkstaTransportEnum),

10439

(ndr_push_flags_fn_t) ndr_push_wkssvc_NetWkstaTransportEnum,

10440

(ndr_pull_flags_fn_t) ndr_pull_wkssvc_NetWkstaTransportEnum,

10441

(ndr_print_function_t) ndr_print_wkssvc_NetWkstaTransportEnum,

10442

false,

10443

10444

{

10445

"wkssvc_NetrWkstaTransportAdd",

10446

sizeof(struct wkssvc_NetrWkstaTransportAdd),

10447

(ndr_push_flags_fn_t) ndr_push_wkssvc_NetrWkstaTransportAdd,

10448

(ndr_pull_flags_fn_t) ndr_pull_wkssvc_NetrWkstaTransportAdd,

10449

(ndr_print_function_t) ndr_print_wkssvc_NetrWkstaTransportAdd,

10450

false,

10451

10452

{

10453

"wkssvc_NetrWkstaTransportDel",

10454

sizeof(struct wkssvc_NetrWkstaTransportDel),

10455

(ndr_push_flags_fn_t) ndr_push_wkssvc_NetrWkstaTransportDel,

10456

(ndr_pull_flags_fn_t) ndr_pull_wkssvc_NetrWkstaTransportDel,

10457

(ndr_print_function_t) ndr_print_wkssvc_NetrWkstaTransportDel,

10458

false,

10459

10460

{

10461

"wkssvc_NetrUseAdd",

10462

sizeof(struct wkssvc_NetrUseAdd),

10463

(ndr_push_flags_fn_t) ndr_push_wkssvc_NetrUseAdd,

10464

(ndr_pull_flags_fn_t) ndr_pull_wkssvc_NetrUseAdd,

10465

(ndr_print_function_t) ndr_print_wkssvc_NetrUseAdd,

10466

false,

10467

10468

{

10469

"wkssvc_NetrUseGetInfo",

10470

sizeof(struct wkssvc_NetrUseGetInfo),

10471

(ndr_push_flags_fn_t) ndr_push_wkssvc_NetrUseGetInfo,

10472

(ndr_pull_flags_fn_t) ndr_pull_wkssvc_NetrUseGetInfo,

10473

(ndr_print_function_t) ndr_print_wkssvc_NetrUseGetInfo,

10474

false,

10475

10476

{

10477

"wkssvc_NetrUseDel",

10478

sizeof(struct wkssvc_NetrUseDel),

10479

(ndr_push_flags_fn_t) ndr_push_wkssvc_NetrUseDel,

10480

(ndr_pull_flags_fn_t) ndr_pull_wkssvc_NetrUseDel,

10481

(ndr_print_function_t) ndr_print_wkssvc_NetrUseDel,

10482

false,

10483

10484

{

10485

"wkssvc_NetrUseEnum",

10486

sizeof(struct wkssvc_NetrUseEnum),

10487

(ndr_push_flags_fn_t) ndr_push_wkssvc_NetrUseEnum,

10488

(ndr_pull_flags_fn_t) ndr_pull_wkssvc_NetrUseEnum,

10489

(ndr_print_function_t) ndr_print_wkssvc_NetrUseEnum,

10490

false,

10491

10492

{

10493

"wkssvc_NetrMessageBufferSend",

10494

sizeof(struct wkssvc_NetrMessageBufferSend),

10495

(ndr_push_flags_fn_t) ndr_push_wkssvc_NetrMessageBufferSend,

10496

(ndr_pull_flags_fn_t) ndr_pull_wkssvc_NetrMessageBufferSend,

10497

(ndr_print_function_t) ndr_print_wkssvc_NetrMessageBufferSend,

10498

false,

10499

10500

{

10501

"wkssvc_NetrWorkstationStatisticsGet",

10502

sizeof(struct wkssvc_NetrWorkstationStatisticsGet),

10503

(ndr_push_flags_fn_t) ndr_push_wkssvc_NetrWorkstationStatisticsGet,

10504

(ndr_pull_flags_fn_t) ndr_pull_wkssvc_NetrWorkstationStatisticsGet,

10505

(ndr_print_function_t) ndr_print_wkssvc_NetrWorkstationStatisticsGet,

10506

false,

10507

10508

{

10509

"wkssvc_NetrLogonDomainNameAdd",

10510

sizeof(struct wkssvc_NetrLogonDomainNameAdd),

10511

(ndr_push_flags_fn_t) ndr_push_wkssvc_NetrLogonDomainNameAdd,

10512

(ndr_pull_flags_fn_t) ndr_pull_wkssvc_NetrLogonDomainNameAdd,

10513

(ndr_print_function_t) ndr_print_wkssvc_NetrLogonDomainNameAdd,

10514

false,

10515

10516

{

10517

"wkssvc_NetrLogonDomainNameDel",

10518

sizeof(struct wkssvc_NetrLogonDomainNameDel),

10519

(ndr_push_flags_fn_t) ndr_push_wkssvc_NetrLogonDomainNameDel,

10520

(ndr_pull_flags_fn_t) ndr_pull_wkssvc_NetrLogonDomainNameDel,

10521

(ndr_print_function_t) ndr_print_wkssvc_NetrLogonDomainNameDel,

10522

false,

10523

10524

{

10525

"wkssvc_NetrJoinDomain",

10526

sizeof(struct wkssvc_NetrJoinDomain),

10527

(ndr_push_flags_fn_t) ndr_push_wkssvc_NetrJoinDomain,

10528

(ndr_pull_flags_fn_t) ndr_pull_wkssvc_NetrJoinDomain,

10529

(ndr_print_function_t) ndr_print_wkssvc_NetrJoinDomain,

10530

false,

10531

10532

{

10533

"wkssvc_NetrUnjoinDomain",

10534

sizeof(struct wkssvc_NetrUnjoinDomain),

10535

(ndr_push_flags_fn_t) ndr_push_wkssvc_NetrUnjoinDomain,

10536

(ndr_pull_flags_fn_t) ndr_pull_wkssvc_NetrUnjoinDomain,

10537

(ndr_print_function_t) ndr_print_wkssvc_NetrUnjoinDomain,

10538

false,

10539

10540

{

10541

"wkssvc_NetrRenameMachineInDomain",

10542

sizeof(struct wkssvc_NetrRenameMachineInDomain),

10543

(ndr_push_flags_fn_t) ndr_push_wkssvc_NetrRenameMachineInDomain,

10544

(ndr_pull_flags_fn_t) ndr_pull_wkssvc_NetrRenameMachineInDomain,

10545

(ndr_print_function_t) ndr_print_wkssvc_NetrRenameMachineInDomain,

10546

false,

10547

10548

{

10549

"wkssvc_NetrValidateName",

10550

sizeof(struct wkssvc_NetrValidateName),

10551

(ndr_push_flags_fn_t) ndr_push_wkssvc_NetrValidateName,

10552

(ndr_pull_flags_fn_t) ndr_pull_wkssvc_NetrValidateName,

10553

(ndr_print_function_t) ndr_print_wkssvc_NetrValidateName,

10554

false,

10555

10556

{

10557

"wkssvc_NetrGetJoinInformation",

10558

sizeof(struct wkssvc_NetrGetJoinInformation),

10559

(ndr_push_flags_fn_t) ndr_push_wkssvc_NetrGetJoinInformation,

10560

(ndr_pull_flags_fn_t) ndr_pull_wkssvc_NetrGetJoinInformation,

10561

(ndr_print_function_t) ndr_print_wkssvc_NetrGetJoinInformation,

10562

false,

10563

10564

{

10565

"wkssvc_NetrGetJoinableOus",

10566

sizeof(struct wkssvc_NetrGetJoinableOus),

10567

(ndr_push_flags_fn_t) ndr_push_wkssvc_NetrGetJoinableOus,

10568

(ndr_pull_flags_fn_t) ndr_pull_wkssvc_NetrGetJoinableOus,

10569

(ndr_print_function_t) ndr_print_wkssvc_NetrGetJoinableOus,

10570

false,

10571

10572

{

10573

"wkssvc_NetrJoinDomain2",

10574

sizeof(struct wkssvc_NetrJoinDomain2),

10575

(ndr_push_flags_fn_t) ndr_push_wkssvc_NetrJoinDomain2,

10576

(ndr_pull_flags_fn_t) ndr_pull_wkssvc_NetrJoinDomain2,

10577

(ndr_print_function_t) ndr_print_wkssvc_NetrJoinDomain2,

10578

false,

10579

10580

{

10581

"wkssvc_NetrUnjoinDomain2",

10582

sizeof(struct wkssvc_NetrUnjoinDomain2),

10583

(ndr_push_flags_fn_t) ndr_push_wkssvc_NetrUnjoinDomain2,

10584

(ndr_pull_flags_fn_t) ndr_pull_wkssvc_NetrUnjoinDomain2,

10585

(ndr_print_function_t) ndr_print_wkssvc_NetrUnjoinDomain2,

10586

false,

10587

10588

{

10589

"wkssvc_NetrRenameMachineInDomain2",

10590

sizeof(struct wkssvc_NetrRenameMachineInDomain2),

10591

(ndr_push_flags_fn_t) ndr_push_wkssvc_NetrRenameMachineInDomain2,

10592

(ndr_pull_flags_fn_t) ndr_pull_wkssvc_NetrRenameMachineInDomain2,

10593

(ndr_print_function_t) ndr_print_wkssvc_NetrRenameMachineInDomain2,

10594

false,

10595

10596

{

10597

"wkssvc_NetrValidateName2",

10598

sizeof(struct wkssvc_NetrValidateName2),

10599

(ndr_push_flags_fn_t) ndr_push_wkssvc_NetrValidateName2,

10600

(ndr_pull_flags_fn_t) ndr_pull_wkssvc_NetrValidateName2,

10601

(ndr_print_function_t) ndr_print_wkssvc_NetrValidateName2,

10602

false,

10603

10604

{

10605

"wkssvc_NetrGetJoinableOus2",

10606

sizeof(struct wkssvc_NetrGetJoinableOus2),

10607

(ndr_push_flags_fn_t) ndr_push_wkssvc_NetrGetJoinableOus2,

10608

(ndr_pull_flags_fn_t) ndr_pull_wkssvc_NetrGetJoinableOus2,

10609

(ndr_print_function_t) ndr_print_wkssvc_NetrGetJoinableOus2,

10610

false,

10611

10612

{

10613

"wkssvc_NetrAddAlternateComputerName",

10614

sizeof(struct wkssvc_NetrAddAlternateComputerName),

10615

(ndr_push_flags_fn_t) ndr_push_wkssvc_NetrAddAlternateComputerName,

10616

(ndr_pull_flags_fn_t) ndr_pull_wkssvc_NetrAddAlternateComputerName,

10617

(ndr_print_function_t) ndr_print_wkssvc_NetrAddAlternateComputerName,

10618

false,

10619

10620

{

10621

"wkssvc_NetrRemoveAlternateComputerName",

10622

sizeof(struct wkssvc_NetrRemoveAlternateComputerName),

10623

(ndr_push_flags_fn_t) ndr_push_wkssvc_NetrRemoveAlternateComputerName,

10624

(ndr_pull_flags_fn_t) ndr_pull_wkssvc_NetrRemoveAlternateComputerName,

10625

(ndr_print_function_t) ndr_print_wkssvc_NetrRemoveAlternateComputerName,

10626

false,

10627

10628

{

10629

"wkssvc_NetrSetPrimaryComputername",

10630

sizeof(struct wkssvc_NetrSetPrimaryComputername),

10631

(ndr_push_flags_fn_t) ndr_push_wkssvc_NetrSetPrimaryComputername,

10632

(ndr_pull_flags_fn_t) ndr_pull_wkssvc_NetrSetPrimaryComputername,

10633

(ndr_print_function_t) ndr_print_wkssvc_NetrSetPrimaryComputername,

10634

false,

10635

10636

{

10637

"wkssvc_NetrEnumerateComputerNames",

10638

sizeof(struct wkssvc_NetrEnumerateComputerNames),

10639

(ndr_push_flags_fn_t) ndr_push_wkssvc_NetrEnumerateComputerNames,

10640

(ndr_pull_flags_fn_t) ndr_pull_wkssvc_NetrEnumerateComputerNames,

10641

(ndr_print_function_t) ndr_print_wkssvc_NetrEnumerateComputerNames,

10642

false,

10643

10644

{ NULL, 0, NULL, NULL, NULL, false }

10645

};

10646

10647

static const char * const wkssvc_endpoint_strings[] = {

10648

"ncacn_np:[\\pipe\\wkssvc]",

10649

"ncacn_ip_tcp:",

10650

"ncalrpc:",

10651

};

10652

10653

static const struct ndr_interface_string_array wkssvc_endpoints = {

10654

.count = 3,

10655

.names = wkssvc_endpoint_strings

10656

};

10657

10658

static const char * const wkssvc_authservice_strings[] = {

10659

"host",

10660

};

10661

10662

static const struct ndr_interface_string_array wkssvc_authservices = {

10663

.count = 1,

10664

.names = wkssvc_authservice_strings

10665

};

10666

10667

10668

const struct ndr_interface_table ndr_table_wkssvc = {

10669

.name = "wkssvc",

10670

.syntax_id = {

10671

{0x6bffd098,0xa112,0x3610,{0x98,0x33},{0x46,0xc3,0xf8,0x7e,0x34,0x5a}},

10672

NDR_WKSSVC_VERSION

10673

10674

.helpstring = NDR_WKSSVC_HELPSTRING,

10675

.num_calls = 31,

10676

.calls = wkssvc_calls,

10677

.endpoints = &wkssvc_endpoints,

10678

.authservices = &wkssvc_authservices

10679

};

10680