00001
00002
00003 #include "includes.h"
00004 #include "librpc/gen_ndr/ndr_wkssvc.h"
00005
00006 #include "librpc/gen_ndr/ndr_srvsvc.h"
00007 NTSTATUS ndr_push_wkssvc_NetWkstaInfo100(struct ndr_push *ndr, int ndr_flags, const struct wkssvc_NetWkstaInfo100 *r)
00008 {
00009 if (ndr_flags & NDR_SCALARS) {
00010 NDR_CHECK(ndr_push_align(ndr, 4));
00011 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->platform_id));
00012 NDR_CHECK(ndr_push_unique_ptr(ndr, r->server_name));
00013 NDR_CHECK(ndr_push_unique_ptr(ndr, r->domain_name));
00014 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->version_major));
00015 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->version_minor));
00016 }
00017 if (ndr_flags & NDR_BUFFERS) {
00018 if (r->server_name) {
00019 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->server_name, CH_UTF16)));
00020 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
00021 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->server_name, CH_UTF16)));
00022 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->server_name, ndr_charset_length(r->server_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
00023 }
00024 if (r->domain_name) {
00025 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->domain_name, CH_UTF16)));
00026 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
00027 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->domain_name, CH_UTF16)));
00028 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->domain_name, ndr_charset_length(r->domain_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
00029 }
00030 }
00031 return NT_STATUS_OK;
00032 }
00033
00034 NTSTATUS ndr_pull_wkssvc_NetWkstaInfo100(struct ndr_pull *ndr, int ndr_flags, struct wkssvc_NetWkstaInfo100 *r)
00035 {
00036 uint32_t _ptr_server_name;
00037 TALLOC_CTX *_mem_save_server_name_0;
00038 uint32_t _ptr_domain_name;
00039 TALLOC_CTX *_mem_save_domain_name_0;
00040 if (ndr_flags & NDR_SCALARS) {
00041 NDR_CHECK(ndr_pull_align(ndr, 4));
00042 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->platform_id));
00043 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_name));
00044 if (_ptr_server_name) {
00045 NDR_PULL_ALLOC(ndr, r->server_name);
00046 } else {
00047 r->server_name = NULL;
00048 }
00049 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_domain_name));
00050 if (_ptr_domain_name) {
00051 NDR_PULL_ALLOC(ndr, r->domain_name);
00052 } else {
00053 r->domain_name = NULL;
00054 }
00055 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version_major));
00056 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version_minor));
00057 }
00058 if (ndr_flags & NDR_BUFFERS) {
00059 if (r->server_name) {
00060 _mem_save_server_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
00061 NDR_PULL_SET_MEM_CTX(ndr, r->server_name, 0);
00062 NDR_CHECK(ndr_pull_array_size(ndr, &r->server_name));
00063 NDR_CHECK(ndr_pull_array_length(ndr, &r->server_name));
00064 if (ndr_get_array_length(ndr, &r->server_name) > ndr_get_array_size(ndr, &r->server_name)) {
00065 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));
00066 }
00067 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->server_name), sizeof(uint16_t)));
00068 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->server_name, ndr_get_array_length(ndr, &r->server_name), sizeof(uint16_t), CH_UTF16));
00069 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_name_0, 0);
00070 }
00071 if (r->domain_name) {
00072 _mem_save_domain_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
00073 NDR_PULL_SET_MEM_CTX(ndr, r->domain_name, 0);
00074 NDR_CHECK(ndr_pull_array_size(ndr, &r->domain_name));
00075 NDR_CHECK(ndr_pull_array_length(ndr, &r->domain_name));
00076 if (ndr_get_array_length(ndr, &r->domain_name) > ndr_get_array_size(ndr, &r->domain_name)) {
00077 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));
00078 }
00079 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->domain_name), sizeof(uint16_t)));
00080 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->domain_name, ndr_get_array_length(ndr, &r->domain_name), sizeof(uint16_t), CH_UTF16));
00081 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domain_name_0, 0);
00082 }
00083 }
00084 return NT_STATUS_OK;
00085 }
00086
00087 _PUBLIC_ void ndr_print_wkssvc_NetWkstaInfo100(struct ndr_print *ndr, const char *name, const struct wkssvc_NetWkstaInfo100 *r)
00088 {
00089 ndr_print_struct(ndr, name, "wkssvc_NetWkstaInfo100");
00090 ndr->depth++;
00091 ndr_print_uint16(ndr, "platform_id", r->platform_id);
00092 ndr_print_ptr(ndr, "server_name", r->server_name);
00093 ndr->depth++;
00094 if (r->server_name) {
00095 ndr_print_string(ndr, "server_name", r->server_name);
00096 }
00097 ndr->depth--;
00098 ndr_print_ptr(ndr, "domain_name", r->domain_name);
00099 ndr->depth++;
00100 if (r->domain_name) {
00101 ndr_print_string(ndr, "domain_name", r->domain_name);
00102 }
00103 ndr->depth--;
00104 ndr_print_uint32(ndr, "version_major", r->version_major);
00105 ndr_print_uint32(ndr, "version_minor", r->version_minor);
00106 ndr->depth--;
00107 }
00108
00109 NTSTATUS ndr_push_wkssvc_NetWkstaInfo101(struct ndr_push *ndr, int ndr_flags, const struct wkssvc_NetWkstaInfo101 *r)
00110 {
00111 if (ndr_flags & NDR_SCALARS) {
00112 NDR_CHECK(ndr_push_align(ndr, 4));
00113 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->platform_id));
00114 NDR_CHECK(ndr_push_unique_ptr(ndr, r->server_name));
00115 NDR_CHECK(ndr_push_unique_ptr(ndr, r->domain_name));
00116 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->version_major));
00117 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->version_minor));
00118 NDR_CHECK(ndr_push_unique_ptr(ndr, r->lan_root));
00119 }
00120 if (ndr_flags & NDR_BUFFERS) {
00121 if (r->server_name) {
00122 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->server_name, CH_UTF16)));
00123 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
00124 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->server_name, CH_UTF16)));
00125 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->server_name, ndr_charset_length(r->server_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
00126 }
00127 if (r->domain_name) {
00128 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->domain_name, CH_UTF16)));
00129 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
00130 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->domain_name, CH_UTF16)));
00131 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->domain_name, ndr_charset_length(r->domain_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
00132 }
00133 if (r->lan_root) {
00134 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->lan_root, CH_UTF16)));
00135 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
00136 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->lan_root, CH_UTF16)));
00137 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->lan_root, ndr_charset_length(r->lan_root, CH_UTF16), sizeof(uint16_t), CH_UTF16));
00138 }
00139 }
00140 return NT_STATUS_OK;
00141 }
00142
00143 NTSTATUS ndr_pull_wkssvc_NetWkstaInfo101(struct ndr_pull *ndr, int ndr_flags, struct wkssvc_NetWkstaInfo101 *r)
00144 {
00145 uint32_t _ptr_server_name;
00146 TALLOC_CTX *_mem_save_server_name_0;
00147 uint32_t _ptr_domain_name;
00148 TALLOC_CTX *_mem_save_domain_name_0;
00149 uint32_t _ptr_lan_root;
00150 TALLOC_CTX *_mem_save_lan_root_0;
00151 if (ndr_flags & NDR_SCALARS) {
00152 NDR_CHECK(ndr_pull_align(ndr, 4));
00153 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->platform_id));
00154 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_name));
00155 if (_ptr_server_name) {
00156 NDR_PULL_ALLOC(ndr, r->server_name);
00157 } else {
00158 r->server_name = NULL;
00159 }
00160 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_domain_name));
00161 if (_ptr_domain_name) {
00162 NDR_PULL_ALLOC(ndr, r->domain_name);
00163 } else {
00164 r->domain_name = NULL;
00165 }
00166 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version_major));
00167 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version_minor));
00168 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_lan_root));
00169 if (_ptr_lan_root) {
00170 NDR_PULL_ALLOC(ndr, r->lan_root);
00171 } else {
00172 r->lan_root = NULL;
00173 }
00174 }
00175 if (ndr_flags & NDR_BUFFERS) {
00176 if (r->server_name) {
00177 _mem_save_server_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
00178 NDR_PULL_SET_MEM_CTX(ndr, r->server_name, 0);
00179 NDR_CHECK(ndr_pull_array_size(ndr, &r->server_name));
00180 NDR_CHECK(ndr_pull_array_length(ndr, &r->server_name));
00181 if (ndr_get_array_length(ndr, &r->server_name) > ndr_get_array_size(ndr, &r->server_name)) {
00182 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));
00183 }
00184 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->server_name), sizeof(uint16_t)));
00185 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->server_name, ndr_get_array_length(ndr, &r->server_name), sizeof(uint16_t), CH_UTF16));
00186 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_name_0, 0);
00187 }
00188 if (r->domain_name) {
00189 _mem_save_domain_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
00190 NDR_PULL_SET_MEM_CTX(ndr, r->domain_name, 0);
00191 NDR_CHECK(ndr_pull_array_size(ndr, &r->domain_name));
00192 NDR_CHECK(ndr_pull_array_length(ndr, &r->domain_name));
00193 if (ndr_get_array_length(ndr, &r->domain_name) > ndr_get_array_size(ndr, &r->domain_name)) {
00194 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));
00195 }
00196 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->domain_name), sizeof(uint16_t)));
00197 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->domain_name, ndr_get_array_length(ndr, &r->domain_name), sizeof(uint16_t), CH_UTF16));
00198 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domain_name_0, 0);
00199 }
00200 if (r->lan_root) {
00201 _mem_save_lan_root_0 = NDR_PULL_GET_MEM_CTX(ndr);
00202 NDR_PULL_SET_MEM_CTX(ndr, r->lan_root, 0);
00203 NDR_CHECK(ndr_pull_array_size(ndr, &r->lan_root));
00204 NDR_CHECK(ndr_pull_array_length(ndr, &r->lan_root));
00205 if (ndr_get_array_length(ndr, &r->lan_root) > ndr_get_array_size(ndr, &r->lan_root)) {
00206 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));
00207 }
00208 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->lan_root), sizeof(uint16_t)));
00209 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->lan_root, ndr_get_array_length(ndr, &r->lan_root), sizeof(uint16_t), CH_UTF16));
00210 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_lan_root_0, 0);
00211 }
00212 }
00213 return NT_STATUS_OK;
00214 }
00215
00216 _PUBLIC_ void ndr_print_wkssvc_NetWkstaInfo101(struct ndr_print *ndr, const char *name, const struct wkssvc_NetWkstaInfo101 *r)
00217 {
00218 ndr_print_struct(ndr, name, "wkssvc_NetWkstaInfo101");
00219 ndr->depth++;
00220 ndr_print_uint16(ndr, "platform_id", r->platform_id);
00221 ndr_print_ptr(ndr, "server_name", r->server_name);
00222 ndr->depth++;
00223 if (r->server_name) {
00224 ndr_print_string(ndr, "server_name", r->server_name);
00225 }
00226 ndr->depth--;
00227 ndr_print_ptr(ndr, "domain_name", r->domain_name);
00228 ndr->depth++;
00229 if (r->domain_name) {
00230 ndr_print_string(ndr, "domain_name", r->domain_name);
00231 }
00232 ndr->depth--;
00233 ndr_print_uint32(ndr, "version_major", r->version_major);
00234 ndr_print_uint32(ndr, "version_minor", r->version_minor);
00235 ndr_print_ptr(ndr, "lan_root", r->lan_root);
00236 ndr->depth++;
00237 if (r->lan_root) {
00238 ndr_print_string(ndr, "lan_root", r->lan_root);
00239 }
00240 ndr->depth--;
00241 ndr->depth--;
00242 }
00243
00244 NTSTATUS ndr_push_wkssvc_NetWkstaInfo102(struct ndr_push *ndr, int ndr_flags, const struct wkssvc_NetWkstaInfo102 *r)
00245 {
00246 if (ndr_flags & NDR_SCALARS) {
00247 NDR_CHECK(ndr_push_align(ndr, 4));
00248 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->platform_id));
00249 NDR_CHECK(ndr_push_unique_ptr(ndr, r->server_name));
00250 NDR_CHECK(ndr_push_unique_ptr(ndr, r->domain_name));
00251 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->version_major));
00252 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->version_minor));
00253 NDR_CHECK(ndr_push_unique_ptr(ndr, r->lan_root));
00254 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->logged_on_users));
00255 }
00256 if (ndr_flags & NDR_BUFFERS) {
00257 if (r->server_name) {
00258 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->server_name, CH_UTF16)));
00259 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
00260 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->server_name, CH_UTF16)));
00261 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->server_name, ndr_charset_length(r->server_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
00262 }
00263 if (r->domain_name) {
00264 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->domain_name, CH_UTF16)));
00265 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
00266 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->domain_name, CH_UTF16)));
00267 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->domain_name, ndr_charset_length(r->domain_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
00268 }
00269 if (r->lan_root) {
00270 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->lan_root, CH_UTF16)));
00271 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
00272 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->lan_root, CH_UTF16)));
00273 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->lan_root, ndr_charset_length(r->lan_root, CH_UTF16), sizeof(uint16_t), CH_UTF16));
00274 }
00275 }
00276 return NT_STATUS_OK;
00277 }
00278
00279 NTSTATUS ndr_pull_wkssvc_NetWkstaInfo102(struct ndr_pull *ndr, int ndr_flags, struct wkssvc_NetWkstaInfo102 *r)
00280 {
00281 uint32_t _ptr_server_name;
00282 TALLOC_CTX *_mem_save_server_name_0;
00283 uint32_t _ptr_domain_name;
00284 TALLOC_CTX *_mem_save_domain_name_0;
00285 uint32_t _ptr_lan_root;
00286 TALLOC_CTX *_mem_save_lan_root_0;
00287 if (ndr_flags & NDR_SCALARS) {
00288 NDR_CHECK(ndr_pull_align(ndr, 4));
00289 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->platform_id));
00290 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_name));
00291 if (_ptr_server_name) {
00292 NDR_PULL_ALLOC(ndr, r->server_name);
00293 } else {
00294 r->server_name = NULL;
00295 }
00296 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_domain_name));
00297 if (_ptr_domain_name) {
00298 NDR_PULL_ALLOC(ndr, r->domain_name);
00299 } else {
00300 r->domain_name = NULL;
00301 }
00302 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version_major));
00303 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version_minor));
00304 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_lan_root));
00305 if (_ptr_lan_root) {
00306 NDR_PULL_ALLOC(ndr, r->lan_root);
00307 } else {
00308 r->lan_root = NULL;
00309 }
00310 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->logged_on_users));
00311 }
00312 if (ndr_flags & NDR_BUFFERS) {
00313 if (r->server_name) {
00314 _mem_save_server_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
00315 NDR_PULL_SET_MEM_CTX(ndr, r->server_name, 0);
00316 NDR_CHECK(ndr_pull_array_size(ndr, &r->server_name));
00317 NDR_CHECK(ndr_pull_array_length(ndr, &r->server_name));
00318 if (ndr_get_array_length(ndr, &r->server_name) > ndr_get_array_size(ndr, &r->server_name)) {
00319 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));
00320 }
00321 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->server_name), sizeof(uint16_t)));
00322 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->server_name, ndr_get_array_length(ndr, &r->server_name), sizeof(uint16_t), CH_UTF16));
00323 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_name_0, 0);
00324 }
00325 if (r->domain_name) {
00326 _mem_save_domain_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
00327 NDR_PULL_SET_MEM_CTX(ndr, r->domain_name, 0);
00328 NDR_CHECK(ndr_pull_array_size(ndr, &r->domain_name));
00329 NDR_CHECK(ndr_pull_array_length(ndr, &r->domain_name));
00330 if (ndr_get_array_length(ndr, &r->domain_name) > ndr_get_array_size(ndr, &r->domain_name)) {
00331 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));
00332 }
00333 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->domain_name), sizeof(uint16_t)));
00334 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->domain_name, ndr_get_array_length(ndr, &r->domain_name), sizeof(uint16_t), CH_UTF16));
00335 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domain_name_0, 0);
00336 }
00337 if (r->lan_root) {
00338 _mem_save_lan_root_0 = NDR_PULL_GET_MEM_CTX(ndr);
00339 NDR_PULL_SET_MEM_CTX(ndr, r->lan_root, 0);
00340 NDR_CHECK(ndr_pull_array_size(ndr, &r->lan_root));
00341 NDR_CHECK(ndr_pull_array_length(ndr, &r->lan_root));
00342 if (ndr_get_array_length(ndr, &r->lan_root) > ndr_get_array_size(ndr, &r->lan_root)) {
00343 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));
00344 }
00345 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->lan_root), sizeof(uint16_t)));
00346 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->lan_root, ndr_get_array_length(ndr, &r->lan_root), sizeof(uint16_t), CH_UTF16));
00347 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_lan_root_0, 0);
00348 }
00349 }
00350 return NT_STATUS_OK;
00351 }
00352
00353 _PUBLIC_ void ndr_print_wkssvc_NetWkstaInfo102(struct ndr_print *ndr, const char *name, const struct wkssvc_NetWkstaInfo102 *r)
00354 {
00355 ndr_print_struct(ndr, name, "wkssvc_NetWkstaInfo102");
00356 ndr->depth++;
00357 ndr_print_uint16(ndr, "platform_id", r->platform_id);
00358 ndr_print_ptr(ndr, "server_name", r->server_name);
00359 ndr->depth++;
00360 if (r->server_name) {
00361 ndr_print_string(ndr, "server_name", r->server_name);
00362 }
00363 ndr->depth--;
00364 ndr_print_ptr(ndr, "domain_name", r->domain_name);
00365 ndr->depth++;
00366 if (r->domain_name) {
00367 ndr_print_string(ndr, "domain_name", r->domain_name);
00368 }
00369 ndr->depth--;
00370 ndr_print_uint32(ndr, "version_major", r->version_major);
00371 ndr_print_uint32(ndr, "version_minor", r->version_minor);
00372 ndr_print_ptr(ndr, "lan_root", r->lan_root);
00373 ndr->depth++;
00374 if (r->lan_root) {
00375 ndr_print_string(ndr, "lan_root", r->lan_root);
00376 }
00377 ndr->depth--;
00378 ndr_print_uint32(ndr, "logged_on_users", r->logged_on_users);
00379 ndr->depth--;
00380 }
00381
00382 NTSTATUS ndr_push_wkssvc_NetWkstaInfo502(struct ndr_push *ndr, int ndr_flags, const struct wkssvc_NetWkstaInfo502 *r)
00383 {
00384 if (ndr_flags & NDR_SCALARS) {
00385 NDR_CHECK(ndr_push_align(ndr, 4));
00386 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->char_wait));
00387 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->collection_time));
00388 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->maximum_collection_count));
00389 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->keep_connection));
00390 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->max_commands));
00391 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->session_timeout));
00392 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size_char_buf));
00393 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->max_threads));
00394 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->lock_quota));
00395 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->lock_increment));
00396 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->lock_maximum));
00397 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->pipe_increment));
00398 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->pipe_maximum));
00399 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->cache_file_timeout));
00400 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->dormant_file_limit));
00401 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->read_ahead_throughput));
00402 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_mailslot_buffers));
00403 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_srv_announce_buffers));
00404 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->max_illegal_dgram_events));
00405 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->dgram_event_reset_freq));
00406 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->log_election_packets));
00407 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->use_opportunistic_locking));
00408 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->use_unlock_behind));
00409 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->use_close_behind));
00410 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->buf_named_pipes));
00411 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->use_lock_read_unlock));
00412 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->utilize_nt_caching));
00413 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->use_raw_read));
00414 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->use_raw_write));
00415 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->use_write_raw_data));
00416 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->use_encryption));
00417 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->buf_files_deny_write));
00418 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->buf_read_only_files));
00419 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->force_core_create_mode));
00420 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->use_512_byte_max_transfer));
00421 }
00422 if (ndr_flags & NDR_BUFFERS) {
00423 }
00424 return NT_STATUS_OK;
00425 }
00426
00427 NTSTATUS ndr_pull_wkssvc_NetWkstaInfo502(struct ndr_pull *ndr, int ndr_flags, struct wkssvc_NetWkstaInfo502 *r)
00428 {
00429 if (ndr_flags & NDR_SCALARS) {
00430 NDR_CHECK(ndr_pull_align(ndr, 4));
00431 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->char_wait));
00432 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->collection_time));
00433 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->maximum_collection_count));
00434 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->keep_connection));
00435 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->max_commands));
00436 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->session_timeout));
00437 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size_char_buf));
00438 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->max_threads));
00439 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->lock_quota));
00440 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->lock_increment));
00441 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->lock_maximum));
00442 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->pipe_increment));
00443 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->pipe_maximum));
00444 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->cache_file_timeout));
00445 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->dormant_file_limit));
00446 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->read_ahead_throughput));
00447 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_mailslot_buffers));
00448 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_srv_announce_buffers));
00449 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->max_illegal_dgram_events));
00450 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->dgram_event_reset_freq));
00451 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->log_election_packets));
00452 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->use_opportunistic_locking));
00453 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->use_unlock_behind));
00454 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->use_close_behind));
00455 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->buf_named_pipes));
00456 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->use_lock_read_unlock));
00457 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->utilize_nt_caching));
00458 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->use_raw_read));
00459 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->use_raw_write));
00460 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->use_write_raw_data));
00461 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->use_encryption));
00462 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->buf_files_deny_write));
00463 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->buf_read_only_files));
00464 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->force_core_create_mode));
00465 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->use_512_byte_max_transfer));
00466 }
00467 if (ndr_flags & NDR_BUFFERS) {
00468 }
00469 return NT_STATUS_OK;
00470 }
00471
00472 _PUBLIC_ void ndr_print_wkssvc_NetWkstaInfo502(struct ndr_print *ndr, const char *name, const struct wkssvc_NetWkstaInfo502 *r)
00473 {
00474 ndr_print_struct(ndr, name, "wkssvc_NetWkstaInfo502");
00475 ndr->depth++;
00476 ndr_print_uint32(ndr, "char_wait", r->char_wait);
00477 ndr_print_uint32(ndr, "collection_time", r->collection_time);
00478 ndr_print_uint32(ndr, "maximum_collection_count", r->maximum_collection_count);
00479 ndr_print_uint32(ndr, "keep_connection", r->keep_connection);
00480 ndr_print_uint32(ndr, "max_commands", r->max_commands);
00481 ndr_print_uint32(ndr, "session_timeout", r->session_timeout);
00482 ndr_print_uint32(ndr, "size_char_buf", r->size_char_buf);
00483 ndr_print_uint32(ndr, "max_threads", r->max_threads);
00484 ndr_print_uint32(ndr, "lock_quota", r->lock_quota);
00485 ndr_print_uint32(ndr, "lock_increment", r->lock_increment);
00486 ndr_print_uint32(ndr, "lock_maximum", r->lock_maximum);
00487 ndr_print_uint32(ndr, "pipe_increment", r->pipe_increment);
00488 ndr_print_uint32(ndr, "pipe_maximum", r->pipe_maximum);
00489 ndr_print_uint32(ndr, "cache_file_timeout", r->cache_file_timeout);
00490 ndr_print_uint32(ndr, "dormant_file_limit", r->dormant_file_limit);
00491 ndr_print_uint32(ndr, "read_ahead_throughput", r->read_ahead_throughput);
00492 ndr_print_uint32(ndr, "num_mailslot_buffers", r->num_mailslot_buffers);
00493 ndr_print_uint32(ndr, "num_srv_announce_buffers", r->num_srv_announce_buffers);
00494 ndr_print_uint32(ndr, "max_illegal_dgram_events", r->max_illegal_dgram_events);
00495 ndr_print_uint32(ndr, "dgram_event_reset_freq", r->dgram_event_reset_freq);
00496 ndr_print_uint32(ndr, "log_election_packets", r->log_election_packets);
00497 ndr_print_uint32(ndr, "use_opportunistic_locking", r->use_opportunistic_locking);
00498 ndr_print_uint32(ndr, "use_unlock_behind", r->use_unlock_behind);
00499 ndr_print_uint32(ndr, "use_close_behind", r->use_close_behind);
00500 ndr_print_uint32(ndr, "buf_named_pipes", r->buf_named_pipes);
00501 ndr_print_uint32(ndr, "use_lock_read_unlock", r->use_lock_read_unlock);
00502 ndr_print_uint32(ndr, "utilize_nt_caching", r->utilize_nt_caching);
00503 ndr_print_uint32(ndr, "use_raw_read", r->use_raw_read);
00504 ndr_print_uint32(ndr, "use_raw_write", r->use_raw_write);
00505 ndr_print_uint32(ndr, "use_write_raw_data", r->use_write_raw_data);
00506 ndr_print_uint32(ndr, "use_encryption", r->use_encryption);
00507 ndr_print_uint32(ndr, "buf_files_deny_write", r->buf_files_deny_write);
00508 ndr_print_uint32(ndr, "buf_read_only_files", r->buf_read_only_files);
00509 ndr_print_uint32(ndr, "force_core_create_mode", r->force_core_create_mode);
00510 ndr_print_uint32(ndr, "use_512_byte_max_transfer", r->use_512_byte_max_transfer);
00511 ndr->depth--;
00512 }
00513
00514 NTSTATUS ndr_push_wkssvc_NetWkstaInfo1010(struct ndr_push *ndr, int ndr_flags, const struct wkssvc_NetWkstaInfo1010 *r)
00515 {
00516 if (ndr_flags & NDR_SCALARS) {
00517 NDR_CHECK(ndr_push_align(ndr, 4));
00518 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->char_wait));
00519 }
00520 if (ndr_flags & NDR_BUFFERS) {
00521 }
00522 return NT_STATUS_OK;
00523 }
00524
00525 NTSTATUS ndr_pull_wkssvc_NetWkstaInfo1010(struct ndr_pull *ndr, int ndr_flags, struct wkssvc_NetWkstaInfo1010 *r)
00526 {
00527 if (ndr_flags & NDR_SCALARS) {
00528 NDR_CHECK(ndr_pull_align(ndr, 4));
00529 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->char_wait));
00530 }
00531 if (ndr_flags & NDR_BUFFERS) {
00532 }
00533 return NT_STATUS_OK;
00534 }
00535
00536 _PUBLIC_ void ndr_print_wkssvc_NetWkstaInfo1010(struct ndr_print *ndr, const char *name, const struct wkssvc_NetWkstaInfo1010 *r)
00537 {
00538 ndr_print_struct(ndr, name, "wkssvc_NetWkstaInfo1010");
00539 ndr->depth++;
00540 ndr_print_uint32(ndr, "char_wait", r->char_wait);
00541 ndr->depth--;
00542 }
00543
00544 NTSTATUS ndr_push_wkssvc_NetWkstaInfo1011(struct ndr_push *ndr, int ndr_flags, const struct wkssvc_NetWkstaInfo1011 *r)
00545 {
00546 if (ndr_flags & NDR_SCALARS) {
00547 NDR_CHECK(ndr_push_align(ndr, 4));
00548 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->collection_time));
00549 }
00550 if (ndr_flags & NDR_BUFFERS) {
00551 }
00552 return NT_STATUS_OK;
00553 }
00554
00555 NTSTATUS ndr_pull_wkssvc_NetWkstaInfo1011(struct ndr_pull *ndr, int ndr_flags, struct wkssvc_NetWkstaInfo1011 *r)
00556 {
00557 if (ndr_flags & NDR_SCALARS) {
00558 NDR_CHECK(ndr_pull_align(ndr, 4));
00559 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->collection_time));
00560 }
00561 if (ndr_flags & NDR_BUFFERS) {
00562 }
00563 return NT_STATUS_OK;
00564 }
00565
00566 _PUBLIC_ void ndr_print_wkssvc_NetWkstaInfo1011(struct ndr_print *ndr, const char *name, const struct wkssvc_NetWkstaInfo1011 *r)
00567 {
00568 ndr_print_struct(ndr, name, "wkssvc_NetWkstaInfo1011");
00569 ndr->depth++;
00570 ndr_print_uint32(ndr, "collection_time", r->collection_time);
00571 ndr->depth--;
00572 }
00573
00574 NTSTATUS ndr_push_wkssvc_NetWkstaInfo1012(struct ndr_push *ndr, int ndr_flags, const struct wkssvc_NetWkstaInfo1012 *r)
00575 {
00576 if (ndr_flags & NDR_SCALARS) {
00577 NDR_CHECK(ndr_push_align(ndr, 4));
00578 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->maximum_collection_count));
00579 }
00580 if (ndr_flags & NDR_BUFFERS) {
00581 }
00582 return NT_STATUS_OK;
00583 }
00584
00585 NTSTATUS ndr_pull_wkssvc_NetWkstaInfo1012(struct ndr_pull *ndr, int ndr_flags, struct wkssvc_NetWkstaInfo1012 *r)
00586 {
00587 if (ndr_flags & NDR_SCALARS) {
00588 NDR_CHECK(ndr_pull_align(ndr, 4));
00589 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->maximum_collection_count));
00590 }
00591 if (ndr_flags & NDR_BUFFERS) {
00592 }
00593 return NT_STATUS_OK;
00594 }
00595
00596 _PUBLIC_ void ndr_print_wkssvc_NetWkstaInfo1012(struct ndr_print *ndr, const char *name, const struct wkssvc_NetWkstaInfo1012 *r)
00597 {
00598 ndr_print_struct(ndr, name, "wkssvc_NetWkstaInfo1012");
00599 ndr->depth++;
00600 ndr_print_uint32(ndr, "maximum_collection_count", r->maximum_collection_count);
00601 ndr->depth--;
00602 }
00603
00604 NTSTATUS ndr_push_wkssvc_NetWkstaInfo1013(struct ndr_push *ndr, int ndr_flags, const struct wkssvc_NetWkstaInfo1013 *r)
00605 {
00606 if (ndr_flags & NDR_SCALARS) {
00607 NDR_CHECK(ndr_push_align(ndr, 4));
00608 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->keep_connection));
00609 }
00610 if (ndr_flags & NDR_BUFFERS) {
00611 }
00612 return NT_STATUS_OK;
00613 }
00614
00615 NTSTATUS ndr_pull_wkssvc_NetWkstaInfo1013(struct ndr_pull *ndr, int ndr_flags, struct wkssvc_NetWkstaInfo1013 *r)
00616 {
00617 if (ndr_flags & NDR_SCALARS) {
00618 NDR_CHECK(ndr_pull_align(ndr, 4));
00619 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->keep_connection));
00620 }
00621 if (ndr_flags & NDR_BUFFERS) {
00622 }
00623 return NT_STATUS_OK;
00624 }
00625
00626 _PUBLIC_ void ndr_print_wkssvc_NetWkstaInfo1013(struct ndr_print *ndr, const char *name, const struct wkssvc_NetWkstaInfo1013 *r)
00627 {
00628 ndr_print_struct(ndr, name, "wkssvc_NetWkstaInfo1013");
00629 ndr->depth++;
00630 ndr_print_uint32(ndr, "keep_connection", r->keep_connection);
00631 ndr->depth--;
00632 }
00633
00634 NTSTATUS ndr_push_wkssvc_NetWkstaInfo1018(struct ndr_push *ndr, int ndr_flags, const struct wkssvc_NetWkstaInfo1018 *r)
00635 {
00636 if (ndr_flags & NDR_SCALARS) {
00637 NDR_CHECK(ndr_push_align(ndr, 4));
00638 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->session_timeout));
00639 }
00640 if (ndr_flags & NDR_BUFFERS) {
00641 }
00642 return NT_STATUS_OK;
00643 }
00644
00645 NTSTATUS ndr_pull_wkssvc_NetWkstaInfo1018(struct ndr_pull *ndr, int ndr_flags, struct wkssvc_NetWkstaInfo1018 *r)
00646 {
00647 if (ndr_flags & NDR_SCALARS) {
00648 NDR_CHECK(ndr_pull_align(ndr, 4));
00649 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->session_timeout));
00650 }
00651 if (ndr_flags & NDR_BUFFERS) {
00652 }
00653 return NT_STATUS_OK;
00654 }
00655
00656 _PUBLIC_ void ndr_print_wkssvc_NetWkstaInfo1018(struct ndr_print *ndr, const char *name, const struct wkssvc_NetWkstaInfo1018 *r)
00657 {
00658 ndr_print_struct(ndr, name, "wkssvc_NetWkstaInfo1018");
00659 ndr->depth++;
00660 ndr_print_uint32(ndr, "session_timeout", r->session_timeout);
00661 ndr->depth--;
00662 }
00663
00664 NTSTATUS ndr_push_wkssvc_NetWkstaInfo1023(struct ndr_push *ndr, int ndr_flags, const struct wkssvc_NetWkstaInfo1023 *r)
00665 {
00666 if (ndr_flags & NDR_SCALARS) {
00667 NDR_CHECK(ndr_push_align(ndr, 4));
00668 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size_char_buf));
00669 }
00670 if (ndr_flags & NDR_BUFFERS) {
00671 }
00672 return NT_STATUS_OK;
00673 }
00674
00675 NTSTATUS ndr_pull_wkssvc_NetWkstaInfo1023(struct ndr_pull *ndr, int ndr_flags, struct wkssvc_NetWkstaInfo1023 *r)
00676 {
00677 if (ndr_flags & NDR_SCALARS) {
00678 NDR_CHECK(ndr_pull_align(ndr, 4));
00679 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size_char_buf));
00680 }
00681 if (ndr_flags & NDR_BUFFERS) {
00682 }
00683 return NT_STATUS_OK;
00684 }
00685
00686 _PUBLIC_ void ndr_print_wkssvc_NetWkstaInfo1023(struct ndr_print *ndr, const char *name, const struct wkssvc_NetWkstaInfo1023 *r)
00687 {
00688 ndr_print_struct(ndr, name, "wkssvc_NetWkstaInfo1023");
00689 ndr->depth++;
00690 ndr_print_uint32(ndr, "size_char_buf", r->size_char_buf);
00691 ndr->depth--;
00692 }
00693
00694 NTSTATUS ndr_push_wkssvc_NetWkstaInfo1027(struct ndr_push *ndr, int ndr_flags, const struct wkssvc_NetWkstaInfo1027 *r)
00695 {
00696 if (ndr_flags & NDR_SCALARS) {
00697 NDR_CHECK(ndr_push_align(ndr, 4));
00698 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->errorlog_sz));
00699 }
00700 if (ndr_flags & NDR_BUFFERS) {
00701 }
00702 return NT_STATUS_OK;
00703 }
00704
00705 NTSTATUS ndr_pull_wkssvc_NetWkstaInfo1027(struct ndr_pull *ndr, int ndr_flags, struct wkssvc_NetWkstaInfo1027 *r)
00706 {
00707 if (ndr_flags & NDR_SCALARS) {
00708 NDR_CHECK(ndr_pull_align(ndr, 4));
00709 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->errorlog_sz));
00710 }
00711 if (ndr_flags & NDR_BUFFERS) {
00712 }
00713 return NT_STATUS_OK;
00714 }
00715
00716 _PUBLIC_ void ndr_print_wkssvc_NetWkstaInfo1027(struct ndr_print *ndr, const char *name, const struct wkssvc_NetWkstaInfo1027 *r)
00717 {
00718 ndr_print_struct(ndr, name, "wkssvc_NetWkstaInfo1027");
00719 ndr->depth++;
00720 ndr_print_uint32(ndr, "errorlog_sz", r->errorlog_sz);
00721 ndr->depth--;
00722 }
00723
00724 NTSTATUS ndr_push_wkssvc_NetWkstaInfo1033(struct ndr_push *ndr, int ndr_flags, const struct wkssvc_NetWkstaInfo1033 *r)
00725 {
00726 if (ndr_flags & NDR_SCALARS) {
00727 NDR_CHECK(ndr_push_align(ndr, 4));
00728 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->max_threads));
00729 }
00730 if (ndr_flags & NDR_BUFFERS) {
00731 }
00732 return NT_STATUS_OK;
00733 }
00734
00735 NTSTATUS ndr_pull_wkssvc_NetWkstaInfo1033(struct ndr_pull *ndr, int ndr_flags, struct wkssvc_NetWkstaInfo1033 *r)
00736 {
00737 if (ndr_flags & NDR_SCALARS) {
00738 NDR_CHECK(ndr_pull_align(ndr, 4));
00739 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->max_threads));
00740 }
00741 if (ndr_flags & NDR_BUFFERS) {
00742 }
00743 return NT_STATUS_OK;
00744 }
00745
00746 _PUBLIC_ void ndr_print_wkssvc_NetWkstaInfo1033(struct ndr_print *ndr, const char *name, const struct wkssvc_NetWkstaInfo1033 *r)
00747 {
00748 ndr_print_struct(ndr, name, "wkssvc_NetWkstaInfo1033");
00749 ndr->depth++;
00750 ndr_print_uint32(ndr, "max_threads", r->max_threads);
00751 ndr->depth--;
00752 }
00753
00754 NTSTATUS ndr_push_wkssvc_NetWkstaInfo(struct ndr_push *ndr, int ndr_flags, const union wkssvc_NetWkstaInfo *r)
00755 {
00756 int level;
00757 level = ndr_push_get_switch_value(ndr, r);
00758 if (ndr_flags & NDR_SCALARS) {
00759 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
00760 switch (level) {
00761 case 100:
00762 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info100));
00763 break;
00764
00765 case 101:
00766 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info101));
00767 break;
00768
00769 case 102:
00770 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info102));
00771 break;
00772
00773 case 502:
00774 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info502));
00775 break;
00776
00777 case 1010:
00778 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1010));
00779 break;
00780
00781 case 1011:
00782 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1011));
00783 break;
00784
00785 case 1012:
00786 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1012));
00787 break;
00788
00789 case 1013:
00790 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1013));
00791 break;
00792
00793 case 1018:
00794 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1018));
00795 break;
00796
00797 case 1023:
00798 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1023));
00799 break;
00800
00801 case 1027:
00802 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1027));
00803 break;
00804
00805 case 1033:
00806 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1033));
00807 break;
00808
00809 default:
00810 break;
00811
00812 }
00813 }
00814 if (ndr_flags & NDR_BUFFERS) {
00815 switch (level) {
00816 case 100:
00817 if (r->info100) {
00818 NDR_CHECK(ndr_push_wkssvc_NetWkstaInfo100(ndr, NDR_SCALARS|NDR_BUFFERS, r->info100));
00819 }
00820 break;
00821
00822 case 101:
00823 if (r->info101) {
00824 NDR_CHECK(ndr_push_wkssvc_NetWkstaInfo101(ndr, NDR_SCALARS|NDR_BUFFERS, r->info101));
00825 }
00826 break;
00827
00828 case 102:
00829 if (r->info102) {
00830 NDR_CHECK(ndr_push_wkssvc_NetWkstaInfo102(ndr, NDR_SCALARS|NDR_BUFFERS, r->info102));
00831 }
00832 break;
00833
00834 case 502:
00835 if (r->info502) {
00836 NDR_CHECK(ndr_push_wkssvc_NetWkstaInfo502(ndr, NDR_SCALARS, r->info502));
00837 }
00838 break;
00839
00840 case 1010:
00841 if (r->info1010) {
00842 NDR_CHECK(ndr_push_wkssvc_NetWkstaInfo1010(ndr, NDR_SCALARS, r->info1010));
00843 }
00844 break;
00845
00846 case 1011:
00847 if (r->info1011) {
00848 NDR_CHECK(ndr_push_wkssvc_NetWkstaInfo1011(ndr, NDR_SCALARS, r->info1011));
00849 }
00850 break;
00851
00852 case 1012:
00853 if (r->info1012) {
00854 NDR_CHECK(ndr_push_wkssvc_NetWkstaInfo1012(ndr, NDR_SCALARS, r->info1012));
00855 }
00856 break;
00857
00858 case 1013:
00859 if (r->info1013) {
00860 NDR_CHECK(ndr_push_wkssvc_NetWkstaInfo1013(ndr, NDR_SCALARS, r->info1013));
00861 }
00862 break;
00863
00864 case 1018:
00865 if (r->info1018) {
00866 NDR_CHECK(ndr_push_wkssvc_NetWkstaInfo1018(ndr, NDR_SCALARS, r->info1018));
00867 }
00868 break;
00869
00870 case 1023:
00871 if (r->info1023) {
00872 NDR_CHECK(ndr_push_wkssvc_NetWkstaInfo1023(ndr, NDR_SCALARS, r->info1023));
00873 }
00874 break;
00875
00876 case 1027:
00877 if (r->info1027) {
00878 NDR_CHECK(ndr_push_wkssvc_NetWkstaInfo1027(ndr, NDR_SCALARS, r->info1027));
00879 }
00880 break;
00881
00882 case 1033:
00883 if (r->info1033) {
00884 NDR_CHECK(ndr_push_wkssvc_NetWkstaInfo1033(ndr, NDR_SCALARS, r->info1033));
00885 }
00886 break;
00887
00888 default:
00889 break;
00890
00891 }
00892 }
00893 return NT_STATUS_OK;
00894 }
00895
00896 NTSTATUS ndr_pull_wkssvc_NetWkstaInfo(struct ndr_pull *ndr, int ndr_flags, union wkssvc_NetWkstaInfo *r)
00897 {
00898 int level;
00899 uint32_t _level;
00900 TALLOC_CTX *_mem_save_info100_0;
00901 TALLOC_CTX *_mem_save_info101_0;
00902 TALLOC_CTX *_mem_save_info102_0;
00903 TALLOC_CTX *_mem_save_info502_0;
00904 TALLOC_CTX *_mem_save_info1010_0;
00905 TALLOC_CTX *_mem_save_info1011_0;
00906 TALLOC_CTX *_mem_save_info1012_0;
00907 TALLOC_CTX *_mem_save_info1013_0;
00908 TALLOC_CTX *_mem_save_info1018_0;
00909 TALLOC_CTX *_mem_save_info1023_0;
00910 TALLOC_CTX *_mem_save_info1027_0;
00911 TALLOC_CTX *_mem_save_info1033_0;
00912 level = ndr_pull_get_switch_value(ndr, r);
00913 if (ndr_flags & NDR_SCALARS) {
00914 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
00915 if (_level != level) {
00916 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for wkssvc_NetWkstaInfo", _level);
00917 }
00918 switch (level) {
00919 case 100: {
00920 uint32_t _ptr_info100;
00921 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info100));
00922 if (_ptr_info100) {
00923 NDR_PULL_ALLOC(ndr, r->info100);
00924 } else {
00925 r->info100 = NULL;
00926 }
00927 break; }
00928
00929 case 101: {
00930 uint32_t _ptr_info101;
00931 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info101));
00932 if (_ptr_info101) {
00933 NDR_PULL_ALLOC(ndr, r->info101);
00934 } else {
00935 r->info101 = NULL;
00936 }
00937 break; }
00938
00939 case 102: {
00940 uint32_t _ptr_info102;
00941 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info102));
00942 if (_ptr_info102) {
00943 NDR_PULL_ALLOC(ndr, r->info102);
00944 } else {
00945 r->info102 = NULL;
00946 }
00947 break; }
00948
00949 case 502: {
00950 uint32_t _ptr_info502;
00951 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info502));
00952 if (_ptr_info502) {
00953 NDR_PULL_ALLOC(ndr, r->info502);
00954 } else {
00955 r->info502 = NULL;
00956 }
00957 break; }
00958
00959 case 1010: {
00960 uint32_t _ptr_info1010;
00961 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1010));
00962 if (_ptr_info1010) {
00963 NDR_PULL_ALLOC(ndr, r->info1010);
00964 } else {
00965 r->info1010 = NULL;
00966 }
00967 break; }
00968
00969 case 1011: {
00970 uint32_t _ptr_info1011;
00971 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1011));
00972 if (_ptr_info1011) {
00973 NDR_PULL_ALLOC(ndr, r->info1011);
00974 } else {
00975 r->info1011 = NULL;
00976 }
00977 break; }
00978
00979 case 1012: {
00980 uint32_t _ptr_info1012;
00981 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1012));
00982 if (_ptr_info1012) {
00983 NDR_PULL_ALLOC(ndr, r->info1012);
00984 } else {
00985 r->info1012 = NULL;
00986 }
00987 break; }
00988
00989 case 1013: {
00990 uint32_t _ptr_info1013;
00991 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1013));
00992 if (_ptr_info1013) {
00993 NDR_PULL_ALLOC(ndr, r->info1013);
00994 } else {
00995 r->info1013 = NULL;
00996 }
00997 break; }
00998
00999 case 1018: {
01000 uint32_t _ptr_info1018;
01001 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1018));
01002 if (_ptr_info1018) {
01003 NDR_PULL_ALLOC(ndr, r->info1018);
01004 } else {
01005 r->info1018 = NULL;
01006 }
01007 break; }
01008
01009 case 1023: {
01010 uint32_t _ptr_info1023;
01011 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1023));
01012 if (_ptr_info1023) {
01013 NDR_PULL_ALLOC(ndr, r->info1023);
01014 } else {
01015 r->info1023 = NULL;
01016 }
01017 break; }
01018
01019 case 1027: {
01020 uint32_t _ptr_info1027;
01021 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1027));
01022 if (_ptr_info1027) {
01023 NDR_PULL_ALLOC(ndr, r->info1027);
01024 } else {
01025 r->info1027 = NULL;
01026 }
01027 break; }
01028
01029 case 1033: {
01030 uint32_t _ptr_info1033;
01031 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1033));
01032 if (_ptr_info1033) {
01033 NDR_PULL_ALLOC(ndr, r->info1033);
01034 } else {
01035 r->info1033 = NULL;
01036 }
01037 break; }
01038
01039 default: {
01040 break; }
01041
01042 }
01043 }
01044 if (ndr_flags & NDR_BUFFERS) {
01045 switch (level) {
01046 case 100:
01047 if (r->info100) {
01048 _mem_save_info100_0 = NDR_PULL_GET_MEM_CTX(ndr);
01049 NDR_PULL_SET_MEM_CTX(ndr, r->info100, 0);
01050 NDR_CHECK(ndr_pull_wkssvc_NetWkstaInfo100(ndr, NDR_SCALARS|NDR_BUFFERS, r->info100));
01051 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info100_0, 0);
01052 }
01053 break;
01054
01055 case 101:
01056 if (r->info101) {
01057 _mem_save_info101_0 = NDR_PULL_GET_MEM_CTX(ndr);
01058 NDR_PULL_SET_MEM_CTX(ndr, r->info101, 0);
01059 NDR_CHECK(ndr_pull_wkssvc_NetWkstaInfo101(ndr, NDR_SCALARS|NDR_BUFFERS, r->info101));
01060 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info101_0, 0);
01061 }
01062 break;
01063
01064 case 102:
01065 if (r->info102) {
01066 _mem_save_info102_0 = NDR_PULL_GET_MEM_CTX(ndr);
01067 NDR_PULL_SET_MEM_CTX(ndr, r->info102, 0);
01068 NDR_CHECK(ndr_pull_wkssvc_NetWkstaInfo102(ndr, NDR_SCALARS|NDR_BUFFERS, r->info102));
01069 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info102_0, 0);
01070 }
01071 break;
01072
01073 case 502:
01074 if (r->info502) {
01075 _mem_save_info502_0 = NDR_PULL_GET_MEM_CTX(ndr);
01076 NDR_PULL_SET_MEM_CTX(ndr, r->info502, 0);
01077 NDR_CHECK(ndr_pull_wkssvc_NetWkstaInfo502(ndr, NDR_SCALARS, r->info502));
01078 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info502_0, 0);
01079 }
01080 break;
01081
01082 case 1010:
01083 if (r->info1010) {
01084 _mem_save_info1010_0 = NDR_PULL_GET_MEM_CTX(ndr);
01085 NDR_PULL_SET_MEM_CTX(ndr, r->info1010, 0);
01086 NDR_CHECK(ndr_pull_wkssvc_NetWkstaInfo1010(ndr, NDR_SCALARS, r->info1010));
01087 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1010_0, 0);
01088 }
01089 break;
01090
01091 case 1011:
01092 if (r->info1011) {
01093 _mem_save_info1011_0 = NDR_PULL_GET_MEM_CTX(ndr);
01094 NDR_PULL_SET_MEM_CTX(ndr, r->info1011, 0);
01095 NDR_CHECK(ndr_pull_wkssvc_NetWkstaInfo1011(ndr, NDR_SCALARS, r->info1011));
01096 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1011_0, 0);
01097 }
01098 break;
01099
01100 case 1012:
01101 if (r->info1012) {
01102 _mem_save_info1012_0 = NDR_PULL_GET_MEM_CTX(ndr);
01103 NDR_PULL_SET_MEM_CTX(ndr, r->info1012, 0);
01104 NDR_CHECK(ndr_pull_wkssvc_NetWkstaInfo1012(ndr, NDR_SCALARS, r->info1012));
01105 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1012_0, 0);
01106 }
01107 break;
01108
01109 case 1013:
01110 if (r->info1013) {
01111 _mem_save_info1013_0 = NDR_PULL_GET_MEM_CTX(ndr);
01112 NDR_PULL_SET_MEM_CTX(ndr, r->info1013, 0);
01113 NDR_CHECK(ndr_pull_wkssvc_NetWkstaInfo1013(ndr, NDR_SCALARS, r->info1013));
01114 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1013_0, 0);
01115 }
01116 break;
01117
01118 case 1018:
01119 if (r->info1018) {
01120 _mem_save_info1018_0 = NDR_PULL_GET_MEM_CTX(ndr);
01121 NDR_PULL_SET_MEM_CTX(ndr, r->info1018, 0);
01122 NDR_CHECK(ndr_pull_wkssvc_NetWkstaInfo1018(ndr, NDR_SCALARS, r->info1018));
01123 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1018_0, 0);
01124 }
01125 break;
01126
01127 case 1023:
01128 if (r->info1023) {
01129 _mem_save_info1023_0 = NDR_PULL_GET_MEM_CTX(ndr);
01130 NDR_PULL_SET_MEM_CTX(ndr, r->info1023, 0);
01131 NDR_CHECK(ndr_pull_wkssvc_NetWkstaInfo1023(ndr, NDR_SCALARS, r->info1023));
01132 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1023_0, 0);
01133 }
01134 break;
01135
01136 case 1027:
01137 if (r->info1027) {
01138 _mem_save_info1027_0 = NDR_PULL_GET_MEM_CTX(ndr);
01139 NDR_PULL_SET_MEM_CTX(ndr, r->info1027, 0);
01140 NDR_CHECK(ndr_pull_wkssvc_NetWkstaInfo1027(ndr, NDR_SCALARS, r->info1027));
01141 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1027_0, 0);
01142 }
01143 break;
01144
01145 case 1033:
01146 if (r->info1033) {
01147 _mem_save_info1033_0 = NDR_PULL_GET_MEM_CTX(ndr);
01148 NDR_PULL_SET_MEM_CTX(ndr, r->info1033, 0);
01149 NDR_CHECK(ndr_pull_wkssvc_NetWkstaInfo1033(ndr, NDR_SCALARS, r->info1033));
01150 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1033_0, 0);
01151 }
01152 break;
01153
01154 default:
01155 break;
01156
01157 }
01158 }
01159 return NT_STATUS_OK;
01160 }
01161
01162 _PUBLIC_ void ndr_print_wkssvc_NetWkstaInfo(struct ndr_print *ndr, const char *name, const union wkssvc_NetWkstaInfo *r)
01163 {
01164 int level;
01165 level = ndr_print_get_switch_value(ndr, r);
01166 ndr_print_union(ndr, name, level, "wkssvc_NetWkstaInfo");
01167 switch (level) {
01168 case 100:
01169 ndr_print_ptr(ndr, "info100", r->info100);
01170 ndr->depth++;
01171 if (r->info100) {
01172 ndr_print_wkssvc_NetWkstaInfo100(ndr, "info100", r->info100);
01173 }
01174 ndr->depth--;
01175 break;
01176
01177 case 101:
01178 ndr_print_ptr(ndr, "info101", r->info101);
01179 ndr->depth++;
01180 if (r->info101) {
01181 ndr_print_wkssvc_NetWkstaInfo101(ndr, "info101", r->info101);
01182 }
01183 ndr->depth--;
01184 break;
01185
01186 case 102:
01187 ndr_print_ptr(ndr, "info102", r->info102);
01188 ndr->depth++;
01189 if (r->info102) {
01190 ndr_print_wkssvc_NetWkstaInfo102(ndr, "info102", r->info102);
01191 }
01192 ndr->depth--;
01193 break;
01194
01195 case 502:
01196 ndr_print_ptr(ndr, "info502", r->info502);
01197 ndr->depth++;
01198 if (r->info502) {
01199 ndr_print_wkssvc_NetWkstaInfo502(ndr, "info502", r->info502);
01200 }
01201 ndr->depth--;
01202 break;
01203
01204 case 1010:
01205 ndr_print_ptr(ndr, "info1010", r->info1010);
01206 ndr->depth++;
01207 if (r->info1010) {
01208 ndr_print_wkssvc_NetWkstaInfo1010(ndr, "info1010", r->info1010);
01209 }
01210 ndr->depth--;
01211 break;
01212
01213 case 1011:
01214 ndr_print_ptr(ndr, "info1011", r->info1011);
01215 ndr->depth++;
01216 if (r->info1011) {
01217 ndr_print_wkssvc_NetWkstaInfo1011(ndr, "info1011", r->info1011);
01218 }
01219 ndr->depth--;
01220 break;
01221
01222 case 1012:
01223 ndr_print_ptr(ndr, "info1012", r->info1012);
01224 ndr->depth++;
01225 if (r->info1012) {
01226 ndr_print_wkssvc_NetWkstaInfo1012(ndr, "info1012", r->info1012);
01227 }
01228 ndr->depth--;
01229 break;
01230
01231 case 1013:
01232 ndr_print_ptr(ndr, "info1013", r->info1013);
01233 ndr->depth++;
01234 if (r->info1013) {
01235 ndr_print_wkssvc_NetWkstaInfo1013(ndr, "info1013", r->info1013);
01236 }
01237 ndr->depth--;
01238 break;
01239
01240 case 1018:
01241 ndr_print_ptr(ndr, "info1018", r->info1018);
01242 ndr->depth++;
01243 if (r->info1018) {
01244 ndr_print_wkssvc_NetWkstaInfo1018(ndr, "info1018", r->info1018);
01245 }
01246 ndr->depth--;
01247 break;
01248
01249 case 1023:
01250 ndr_print_ptr(ndr, "info1023", r->info1023);
01251 ndr->depth++;
01252 if (r->info1023) {
01253 ndr_print_wkssvc_NetWkstaInfo1023(ndr, "info1023", r->info1023);
01254 }
01255 ndr->depth--;
01256 break;
01257
01258 case 1027:
01259 ndr_print_ptr(ndr, "info1027", r->info1027);
01260 ndr->depth++;
01261 if (r->info1027) {
01262 ndr_print_wkssvc_NetWkstaInfo1027(ndr, "info1027", r->info1027);
01263 }
01264 ndr->depth--;
01265 break;
01266
01267 case 1033:
01268 ndr_print_ptr(ndr, "info1033", r->info1033);
01269 ndr->depth++;
01270 if (r->info1033) {
01271 ndr_print_wkssvc_NetWkstaInfo1033(ndr, "info1033", r->info1033);
01272 }
01273 ndr->depth--;
01274 break;
01275
01276 default:
01277 break;
01278
01279 }
01280 }
01281
01282 NTSTATUS ndr_push_USER_INFO_0(struct ndr_push *ndr, int ndr_flags, const struct USER_INFO_0 *r)
01283 {
01284 if (ndr_flags & NDR_SCALARS) {
01285 NDR_CHECK(ndr_push_align(ndr, 4));
01286 NDR_CHECK(ndr_push_unique_ptr(ndr, r->user));
01287 }
01288 if (ndr_flags & NDR_BUFFERS) {
01289 if (r->user) {
01290 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->user, CH_UTF16)));
01291 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
01292 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->user, CH_UTF16)));
01293 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->user, ndr_charset_length(r->user, CH_UTF16), sizeof(uint16_t), CH_UTF16));
01294 }
01295 }
01296 return NT_STATUS_OK;
01297 }
01298
01299 NTSTATUS ndr_pull_USER_INFO_0(struct ndr_pull *ndr, int ndr_flags, struct USER_INFO_0 *r)
01300 {
01301 uint32_t _ptr_user;
01302 TALLOC_CTX *_mem_save_user_0;
01303 if (ndr_flags & NDR_SCALARS) {
01304 NDR_CHECK(ndr_pull_align(ndr, 4));
01305 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_user));
01306 if (_ptr_user) {
01307 NDR_PULL_ALLOC(ndr, r->user);
01308 } else {
01309 r->user = NULL;
01310 }
01311 }
01312 if (ndr_flags & NDR_BUFFERS) {
01313 if (r->user) {
01314 _mem_save_user_0 = NDR_PULL_GET_MEM_CTX(ndr);
01315 NDR_PULL_SET_MEM_CTX(ndr, r->user, 0);
01316 NDR_CHECK(ndr_pull_array_size(ndr, &r->user));
01317 NDR_CHECK(ndr_pull_array_length(ndr, &r->user));
01318 if (ndr_get_array_length(ndr, &r->user) > ndr_get_array_size(ndr, &r->user)) {
01319 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->user), ndr_get_array_length(ndr, &r->user));
01320 }
01321 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->user), sizeof(uint16_t)));
01322 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->user, ndr_get_array_length(ndr, &r->user), sizeof(uint16_t), CH_UTF16));
01323 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_0, 0);
01324 }
01325 }
01326 return NT_STATUS_OK;
01327 }
01328
01329 _PUBLIC_ void ndr_print_USER_INFO_0(struct ndr_print *ndr, const char *name, const struct USER_INFO_0 *r)
01330 {
01331 ndr_print_struct(ndr, name, "USER_INFO_0");
01332 ndr->depth++;
01333 ndr_print_ptr(ndr, "user", r->user);
01334 ndr->depth++;
01335 if (r->user) {
01336 ndr_print_string(ndr, "user", r->user);
01337 }
01338 ndr->depth--;
01339 ndr->depth--;
01340 }
01341
01342 NTSTATUS ndr_push_USER_INFO_0_CONTAINER(struct ndr_push *ndr, int ndr_flags, const struct USER_INFO_0_CONTAINER *r)
01343 {
01344 uint32_t cntr_user0_1;
01345 if (ndr_flags & NDR_SCALARS) {
01346 NDR_CHECK(ndr_push_align(ndr, 4));
01347 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->entries_read));
01348 NDR_CHECK(ndr_push_unique_ptr(ndr, r->user0));
01349 }
01350 if (ndr_flags & NDR_BUFFERS) {
01351 if (r->user0) {
01352 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->entries_read));
01353 for (cntr_user0_1 = 0; cntr_user0_1 < r->entries_read; cntr_user0_1++) {
01354 NDR_CHECK(ndr_push_USER_INFO_0(ndr, NDR_SCALARS, &r->user0[cntr_user0_1]));
01355 }
01356 for (cntr_user0_1 = 0; cntr_user0_1 < r->entries_read; cntr_user0_1++) {
01357 NDR_CHECK(ndr_push_USER_INFO_0(ndr, NDR_BUFFERS, &r->user0[cntr_user0_1]));
01358 }
01359 }
01360 }
01361 return NT_STATUS_OK;
01362 }
01363
01364 NTSTATUS ndr_pull_USER_INFO_0_CONTAINER(struct ndr_pull *ndr, int ndr_flags, struct USER_INFO_0_CONTAINER *r)
01365 {
01366 uint32_t _ptr_user0;
01367 uint32_t cntr_user0_1;
01368 TALLOC_CTX *_mem_save_user0_0;
01369 TALLOC_CTX *_mem_save_user0_1;
01370 if (ndr_flags & NDR_SCALARS) {
01371 NDR_CHECK(ndr_pull_align(ndr, 4));
01372 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->entries_read));
01373 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_user0));
01374 if (_ptr_user0) {
01375 NDR_PULL_ALLOC(ndr, r->user0);
01376 } else {
01377 r->user0 = NULL;
01378 }
01379 }
01380 if (ndr_flags & NDR_BUFFERS) {
01381 if (r->user0) {
01382 _mem_save_user0_0 = NDR_PULL_GET_MEM_CTX(ndr);
01383 NDR_PULL_SET_MEM_CTX(ndr, r->user0, 0);
01384 NDR_CHECK(ndr_pull_array_size(ndr, &r->user0));
01385 NDR_PULL_ALLOC_N(ndr, r->user0, ndr_get_array_size(ndr, &r->user0));
01386 _mem_save_user0_1 = NDR_PULL_GET_MEM_CTX(ndr);
01387 NDR_PULL_SET_MEM_CTX(ndr, r->user0, 0);
01388 for (cntr_user0_1 = 0; cntr_user0_1 < r->entries_read; cntr_user0_1++) {
01389 NDR_CHECK(ndr_pull_USER_INFO_0(ndr, NDR_SCALARS, &r->user0[cntr_user0_1]));
01390 }
01391 for (cntr_user0_1 = 0; cntr_user0_1 < r->entries_read; cntr_user0_1++) {
01392 NDR_CHECK(ndr_pull_USER_INFO_0(ndr, NDR_BUFFERS, &r->user0[cntr_user0_1]));
01393 }
01394 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user0_1, 0);
01395 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user0_0, 0);
01396 }
01397 if (r->user0) {
01398 NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->user0, r->entries_read));
01399 }
01400 }
01401 return NT_STATUS_OK;
01402 }
01403
01404 _PUBLIC_ void ndr_print_USER_INFO_0_CONTAINER(struct ndr_print *ndr, const char *name, const struct USER_INFO_0_CONTAINER *r)
01405 {
01406 uint32_t cntr_user0_1;
01407 ndr_print_struct(ndr, name, "USER_INFO_0_CONTAINER");
01408 ndr->depth++;
01409 ndr_print_uint32(ndr, "entries_read", r->entries_read);
01410 ndr_print_ptr(ndr, "user0", r->user0);
01411 ndr->depth++;
01412 if (r->user0) {
01413 ndr->print(ndr, "%s: ARRAY(%d)", "user0", r->entries_read);
01414 ndr->depth++;
01415 for (cntr_user0_1=0;cntr_user0_1<r->entries_read;cntr_user0_1++) {
01416 char *idx_1=NULL;
01417 asprintf(&idx_1, "[%d]", cntr_user0_1);
01418 if (idx_1) {
01419 ndr_print_USER_INFO_0(ndr, "user0", &r->user0[cntr_user0_1]);
01420 free(idx_1);
01421 }
01422 }
01423 ndr->depth--;
01424 }
01425 ndr->depth--;
01426 ndr->depth--;
01427 }
01428
01429 NTSTATUS ndr_push_USER_INFO_1(struct ndr_push *ndr, int ndr_flags, const struct USER_INFO_1 *r)
01430 {
01431 if (ndr_flags & NDR_SCALARS) {
01432 NDR_CHECK(ndr_push_align(ndr, 4));
01433 NDR_CHECK(ndr_push_unique_ptr(ndr, r->user_name));
01434 NDR_CHECK(ndr_push_unique_ptr(ndr, r->logon_domain));
01435 NDR_CHECK(ndr_push_unique_ptr(ndr, r->other_domains));
01436 NDR_CHECK(ndr_push_unique_ptr(ndr, r->logon_server));
01437 }
01438 if (ndr_flags & NDR_BUFFERS) {
01439 if (r->user_name) {
01440 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->user_name, CH_UTF16)));
01441 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
01442 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->user_name, CH_UTF16)));
01443 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->user_name, ndr_charset_length(r->user_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
01444 }
01445 if (r->logon_domain) {
01446 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->logon_domain, CH_UTF16)));
01447 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
01448 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->logon_domain, CH_UTF16)));
01449 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->logon_domain, ndr_charset_length(r->logon_domain, CH_UTF16), sizeof(uint16_t), CH_UTF16));
01450 }
01451 if (r->other_domains) {
01452 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->other_domains, CH_UTF16)));
01453 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
01454 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->other_domains, CH_UTF16)));
01455 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->other_domains, ndr_charset_length(r->other_domains, CH_UTF16), sizeof(uint16_t), CH_UTF16));
01456 }
01457 if (r->logon_server) {
01458 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->logon_server, CH_UTF16)));
01459 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
01460 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->logon_server, CH_UTF16)));
01461 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->logon_server, ndr_charset_length(r->logon_server, CH_UTF16), sizeof(uint16_t), CH_UTF16));
01462 }
01463 }
01464 return NT_STATUS_OK;
01465 }
01466
01467 NTSTATUS ndr_pull_USER_INFO_1(struct ndr_pull *ndr, int ndr_flags, struct USER_INFO_1 *r)
01468 {
01469 uint32_t _ptr_user_name;
01470 TALLOC_CTX *_mem_save_user_name_0;
01471 uint32_t _ptr_logon_domain;
01472 TALLOC_CTX *_mem_save_logon_domain_0;
01473 uint32_t _ptr_other_domains;
01474 TALLOC_CTX *_mem_save_other_domains_0;
01475 uint32_t _ptr_logon_server;
01476 TALLOC_CTX *_mem_save_logon_server_0;
01477 if (ndr_flags & NDR_SCALARS) {
01478 NDR_CHECK(ndr_pull_align(ndr, 4));
01479 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_user_name));
01480 if (_ptr_user_name) {
01481 NDR_PULL_ALLOC(ndr, r->user_name);
01482 } else {
01483 r->user_name = NULL;
01484 }
01485 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_logon_domain));
01486 if (_ptr_logon_domain) {
01487 NDR_PULL_ALLOC(ndr, r->logon_domain);
01488 } else {
01489 r->logon_domain = NULL;
01490 }
01491 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_other_domains));
01492 if (_ptr_other_domains) {
01493 NDR_PULL_ALLOC(ndr, r->other_domains);
01494 } else {
01495 r->other_domains = NULL;
01496 }
01497 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_logon_server));
01498 if (_ptr_logon_server) {
01499 NDR_PULL_ALLOC(ndr, r->logon_server);
01500 } else {
01501 r->logon_server = NULL;
01502 }
01503 }
01504 if (ndr_flags & NDR_BUFFERS) {
01505 if (r->user_name) {
01506 _mem_save_user_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
01507 NDR_PULL_SET_MEM_CTX(ndr, r->user_name, 0);
01508 NDR_CHECK(ndr_pull_array_size(ndr, &r->user_name));
01509 NDR_CHECK(ndr_pull_array_length(ndr, &r->user_name));
01510 if (ndr_get_array_length(ndr, &r->user_name) > ndr_get_array_size(ndr, &r->user_name)) {
01511 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));
01512 }
01513 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->user_name), sizeof(uint16_t)));
01514 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->user_name, ndr_get_array_length(ndr, &r->user_name), sizeof(uint16_t), CH_UTF16));
01515 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_name_0, 0);
01516 }
01517 if (r->logon_domain) {
01518 _mem_save_logon_domain_0 = NDR_PULL_GET_MEM_CTX(ndr);
01519 NDR_PULL_SET_MEM_CTX(ndr, r->logon_domain, 0);
01520 NDR_CHECK(ndr_pull_array_size(ndr, &r->logon_domain));
01521 NDR_CHECK(ndr_pull_array_length(ndr, &r->logon_domain));
01522 if (ndr_get_array_length(ndr, &r->logon_domain) > ndr_get_array_size(ndr, &r->logon_domain)) {
01523 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));
01524 }
01525 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->logon_domain), sizeof(uint16_t)));
01526 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->logon_domain, ndr_get_array_length(ndr, &r->logon_domain), sizeof(uint16_t), CH_UTF16));
01527 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_logon_domain_0, 0);
01528 }
01529 if (r->other_domains) {
01530 _mem_save_other_domains_0 = NDR_PULL_GET_MEM_CTX(ndr);
01531 NDR_PULL_SET_MEM_CTX(ndr, r->other_domains, 0);
01532 NDR_CHECK(ndr_pull_array_size(ndr, &r->other_domains));
01533 NDR_CHECK(ndr_pull_array_length(ndr, &r->other_domains));
01534 if (ndr_get_array_length(ndr, &r->other_domains) > ndr_get_array_size(ndr, &r->other_domains)) {
01535 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));
01536 }
01537 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->other_domains), sizeof(uint16_t)));
01538 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->other_domains, ndr_get_array_length(ndr, &r->other_domains), sizeof(uint16_t), CH_UTF16));
01539 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_other_domains_0, 0);
01540 }
01541 if (r->logon_server) {
01542 _mem_save_logon_server_0 = NDR_PULL_GET_MEM_CTX(ndr);
01543 NDR_PULL_SET_MEM_CTX(ndr, r->logon_server, 0);
01544 NDR_CHECK(ndr_pull_array_size(ndr, &r->logon_server));
01545 NDR_CHECK(ndr_pull_array_length(ndr, &r->logon_server));
01546 if (ndr_get_array_length(ndr, &r->logon_server) > ndr_get_array_size(ndr, &r->logon_server)) {
01547 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));
01548 }
01549 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->logon_server), sizeof(uint16_t)));
01550 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->logon_server, ndr_get_array_length(ndr, &r->logon_server), sizeof(uint16_t), CH_UTF16));
01551 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_logon_server_0, 0);
01552 }
01553 }
01554 return NT_STATUS_OK;
01555 }
01556
01557 _PUBLIC_ void ndr_print_USER_INFO_1(struct ndr_print *ndr, const char *name, const struct USER_INFO_1 *r)
01558 {
01559 ndr_print_struct(ndr, name, "USER_INFO_1");
01560 ndr->depth++;
01561 ndr_print_ptr(ndr, "user_name", r->user_name);
01562 ndr->depth++;
01563 if (r->user_name) {
01564 ndr_print_string(ndr, "user_name", r->user_name);
01565 }
01566 ndr->depth--;
01567 ndr_print_ptr(ndr, "logon_domain", r->logon_domain);
01568 ndr->depth++;
01569 if (r->logon_domain) {
01570 ndr_print_string(ndr, "logon_domain", r->logon_domain);
01571 }
01572 ndr->depth--;
01573 ndr_print_ptr(ndr, "other_domains", r->other_domains);
01574 ndr->depth++;
01575 if (r->other_domains) {
01576 ndr_print_string(ndr, "other_domains", r->other_domains);
01577 }
01578 ndr->depth--;
01579 ndr_print_ptr(ndr, "logon_server", r->logon_server);
01580 ndr->depth++;
01581 if (r->logon_server) {
01582 ndr_print_string(ndr, "logon_server", r->logon_server);
01583 }
01584 ndr->depth--;
01585 ndr->depth--;
01586 }
01587
01588 NTSTATUS ndr_push_USER_INFO_1_CONTAINER(struct ndr_push *ndr, int ndr_flags, const struct USER_INFO_1_CONTAINER *r)
01589 {
01590 uint32_t cntr_user1_1;
01591 if (ndr_flags & NDR_SCALARS) {
01592 NDR_CHECK(ndr_push_align(ndr, 4));
01593 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->entries_read));
01594 NDR_CHECK(ndr_push_unique_ptr(ndr, r->user1));
01595 }
01596 if (ndr_flags & NDR_BUFFERS) {
01597 if (r->user1) {
01598 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->entries_read));
01599 for (cntr_user1_1 = 0; cntr_user1_1 < r->entries_read; cntr_user1_1++) {
01600 NDR_CHECK(ndr_push_USER_INFO_1(ndr, NDR_SCALARS, &r->user1[cntr_user1_1]));
01601 }
01602 for (cntr_user1_1 = 0; cntr_user1_1 < r->entries_read; cntr_user1_1++) {
01603 NDR_CHECK(ndr_push_USER_INFO_1(ndr, NDR_BUFFERS, &r->user1[cntr_user1_1]));
01604 }
01605 }
01606 }
01607 return NT_STATUS_OK;
01608 }
01609
01610 NTSTATUS ndr_pull_USER_INFO_1_CONTAINER(struct ndr_pull *ndr, int ndr_flags, struct USER_INFO_1_CONTAINER *r)
01611 {
01612 uint32_t _ptr_user1;
01613 uint32_t cntr_user1_1;
01614 TALLOC_CTX *_mem_save_user1_0;
01615 TALLOC_CTX *_mem_save_user1_1;
01616 if (ndr_flags & NDR_SCALARS) {
01617 NDR_CHECK(ndr_pull_align(ndr, 4));
01618 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->entries_read));
01619 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_user1));
01620 if (_ptr_user1) {
01621 NDR_PULL_ALLOC(ndr, r->user1);
01622 } else {
01623 r->user1 = NULL;
01624 }
01625 }
01626 if (ndr_flags & NDR_BUFFERS) {
01627 if (r->user1) {
01628 _mem_save_user1_0 = NDR_PULL_GET_MEM_CTX(ndr);
01629 NDR_PULL_SET_MEM_CTX(ndr, r->user1, 0);
01630 NDR_CHECK(ndr_pull_array_size(ndr, &r->user1));
01631 NDR_PULL_ALLOC_N(ndr, r->user1, ndr_get_array_size(ndr, &r->user1));
01632 _mem_save_user1_1 = NDR_PULL_GET_MEM_CTX(ndr);
01633 NDR_PULL_SET_MEM_CTX(ndr, r->user1, 0);
01634 for (cntr_user1_1 = 0; cntr_user1_1 < r->entries_read; cntr_user1_1++) {
01635 NDR_CHECK(ndr_pull_USER_INFO_1(ndr, NDR_SCALARS, &r->user1[cntr_user1_1]));
01636 }
01637 for (cntr_user1_1 = 0; cntr_user1_1 < r->entries_read; cntr_user1_1++) {
01638 NDR_CHECK(ndr_pull_USER_INFO_1(ndr, NDR_BUFFERS, &r->user1[cntr_user1_1]));
01639 }
01640 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user1_1, 0);
01641 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user1_0, 0);
01642 }
01643 if (r->user1) {
01644 NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->user1, r->entries_read));
01645 }
01646 }
01647 return NT_STATUS_OK;
01648 }
01649
01650 _PUBLIC_ void ndr_print_USER_INFO_1_CONTAINER(struct ndr_print *ndr, const char *name, const struct USER_INFO_1_CONTAINER *r)
01651 {
01652 uint32_t cntr_user1_1;
01653 ndr_print_struct(ndr, name, "USER_INFO_1_CONTAINER");
01654 ndr->depth++;
01655 ndr_print_uint32(ndr, "entries_read", r->entries_read);
01656 ndr_print_ptr(ndr, "user1", r->user1);
01657 ndr->depth++;
01658 if (r->user1) {
01659 ndr->print(ndr, "%s: ARRAY(%d)", "user1", r->entries_read);
01660 ndr->depth++;
01661 for (cntr_user1_1=0;cntr_user1_1<r->entries_read;cntr_user1_1++) {
01662 char *idx_1=NULL;
01663 asprintf(&idx_1, "[%d]", cntr_user1_1);
01664 if (idx_1) {
01665 ndr_print_USER_INFO_1(ndr, "user1", &r->user1[cntr_user1_1]);
01666 free(idx_1);
01667 }
01668 }
01669 ndr->depth--;
01670 }
01671 ndr->depth--;
01672 ndr->depth--;
01673 }
01674
01675 NTSTATUS ndr_push_WKS_USER_ENUM_UNION(struct ndr_push *ndr, int ndr_flags, const union WKS_USER_ENUM_UNION *r)
01676 {
01677 int level;
01678 level = ndr_push_get_switch_value(ndr, r);
01679 if (ndr_flags & NDR_SCALARS) {
01680 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
01681 switch (level) {
01682 case 0:
01683 NDR_CHECK(ndr_push_unique_ptr(ndr, r->user0));
01684 break;
01685
01686 case 1:
01687 NDR_CHECK(ndr_push_unique_ptr(ndr, r->user1));
01688 break;
01689
01690 default:
01691 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
01692 }
01693 }
01694 if (ndr_flags & NDR_BUFFERS) {
01695 switch (level) {
01696 case 0:
01697 if (r->user0) {
01698 NDR_CHECK(ndr_push_USER_INFO_0_CONTAINER(ndr, NDR_SCALARS|NDR_BUFFERS, r->user0));
01699 }
01700 break;
01701
01702 case 1:
01703 if (r->user1) {
01704 NDR_CHECK(ndr_push_USER_INFO_1_CONTAINER(ndr, NDR_SCALARS|NDR_BUFFERS, r->user1));
01705 }
01706 break;
01707
01708 default:
01709 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
01710 }
01711 }
01712 return NT_STATUS_OK;
01713 }
01714
01715 NTSTATUS ndr_pull_WKS_USER_ENUM_UNION(struct ndr_pull *ndr, int ndr_flags, union WKS_USER_ENUM_UNION *r)
01716 {
01717 int level;
01718 uint32_t _level;
01719 TALLOC_CTX *_mem_save_user0_0;
01720 TALLOC_CTX *_mem_save_user1_0;
01721 level = ndr_pull_get_switch_value(ndr, r);
01722 if (ndr_flags & NDR_SCALARS) {
01723 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
01724 if (_level != level) {
01725 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for WKS_USER_ENUM_UNION", _level);
01726 }
01727 switch (level) {
01728 case 0: {
01729 uint32_t _ptr_user0;
01730 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_user0));
01731 if (_ptr_user0) {
01732 NDR_PULL_ALLOC(ndr, r->user0);
01733 } else {
01734 r->user0 = NULL;
01735 }
01736 break; }
01737
01738 case 1: {
01739 uint32_t _ptr_user1;
01740 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_user1));
01741 if (_ptr_user1) {
01742 NDR_PULL_ALLOC(ndr, r->user1);
01743 } else {
01744 r->user1 = NULL;
01745 }
01746 break; }
01747
01748 default:
01749 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
01750 }
01751 }
01752 if (ndr_flags & NDR_BUFFERS) {
01753 switch (level) {
01754 case 0:
01755 if (r->user0) {
01756 _mem_save_user0_0 = NDR_PULL_GET_MEM_CTX(ndr);
01757 NDR_PULL_SET_MEM_CTX(ndr, r->user0, 0);
01758 NDR_CHECK(ndr_pull_USER_INFO_0_CONTAINER(ndr, NDR_SCALARS|NDR_BUFFERS, r->user0));
01759 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user0_0, 0);
01760 }
01761 break;
01762
01763 case 1:
01764 if (r->user1) {
01765 _mem_save_user1_0 = NDR_PULL_GET_MEM_CTX(ndr);
01766 NDR_PULL_SET_MEM_CTX(ndr, r->user1, 0);
01767 NDR_CHECK(ndr_pull_USER_INFO_1_CONTAINER(ndr, NDR_SCALARS|NDR_BUFFERS, r->user1));
01768 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user1_0, 0);
01769 }
01770 break;
01771
01772 default:
01773 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
01774 }
01775 }
01776 return NT_STATUS_OK;
01777 }
01778
01779 _PUBLIC_ void ndr_print_WKS_USER_ENUM_UNION(struct ndr_print *ndr, const char *name, const union WKS_USER_ENUM_UNION *r)
01780 {
01781 int level;
01782 level = ndr_print_get_switch_value(ndr, r);
01783 ndr_print_union(ndr, name, level, "WKS_USER_ENUM_UNION");
01784 switch (level) {
01785 case 0:
01786 ndr_print_ptr(ndr, "user0", r->user0);
01787 ndr->depth++;
01788 if (r->user0) {
01789 ndr_print_USER_INFO_0_CONTAINER(ndr, "user0", r->user0);
01790 }
01791 ndr->depth--;
01792 break;
01793
01794 case 1:
01795 ndr_print_ptr(ndr, "user1", r->user1);
01796 ndr->depth++;
01797 if (r->user1) {
01798 ndr_print_USER_INFO_1_CONTAINER(ndr, "user1", r->user1);
01799 }
01800 ndr->depth--;
01801 break;
01802
01803 default:
01804 ndr_print_bad_level(ndr, name, level);
01805 }
01806 }
01807
01808 NTSTATUS ndr_push_wkssvc_NetWkstaTransportInfo0(struct ndr_push *ndr, int ndr_flags, const struct wkssvc_NetWkstaTransportInfo0 *r)
01809 {
01810 if (ndr_flags & NDR_SCALARS) {
01811 NDR_CHECK(ndr_push_align(ndr, 4));
01812 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->quality_of_service));
01813 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->vc_count));
01814 NDR_CHECK(ndr_push_unique_ptr(ndr, r->name));
01815 NDR_CHECK(ndr_push_unique_ptr(ndr, r->address));
01816 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->wan_link));
01817 }
01818 if (ndr_flags & NDR_BUFFERS) {
01819 if (r->name) {
01820 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->name, CH_UTF16)));
01821 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
01822 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->name, CH_UTF16)));
01823 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->name, ndr_charset_length(r->name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
01824 }
01825 if (r->address) {
01826 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->address, CH_UTF16)));
01827 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
01828 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->address, CH_UTF16)));
01829 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->address, ndr_charset_length(r->address, CH_UTF16), sizeof(uint16_t), CH_UTF16));
01830 }
01831 }
01832 return NT_STATUS_OK;
01833 }
01834
01835 NTSTATUS ndr_pull_wkssvc_NetWkstaTransportInfo0(struct ndr_pull *ndr, int ndr_flags, struct wkssvc_NetWkstaTransportInfo0 *r)
01836 {
01837 uint32_t _ptr_name;
01838 TALLOC_CTX *_mem_save_name_0;
01839 uint32_t _ptr_address;
01840 TALLOC_CTX *_mem_save_address_0;
01841 if (ndr_flags & NDR_SCALARS) {
01842 NDR_CHECK(ndr_pull_align(ndr, 4));
01843 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->quality_of_service));
01844 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->vc_count));
01845 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_name));
01846 if (_ptr_name) {
01847 NDR_PULL_ALLOC(ndr, r->name);
01848 } else {
01849 r->name = NULL;
01850 }
01851 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_address));
01852 if (_ptr_address) {
01853 NDR_PULL_ALLOC(ndr, r->address);
01854 } else {
01855 r->address = NULL;
01856 }
01857 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->wan_link));
01858 }
01859 if (ndr_flags & NDR_BUFFERS) {
01860 if (r->name) {
01861 _mem_save_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
01862 NDR_PULL_SET_MEM_CTX(ndr, r->name, 0);
01863 NDR_CHECK(ndr_pull_array_size(ndr, &r->name));
01864 NDR_CHECK(ndr_pull_array_length(ndr, &r->name));
01865 if (ndr_get_array_length(ndr, &r->name) > ndr_get_array_size(ndr, &r->name)) {
01866 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));
01867 }
01868 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->name), sizeof(uint16_t)));
01869 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->name, ndr_get_array_length(ndr, &r->name), sizeof(uint16_t), CH_UTF16));
01870 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_name_0, 0);
01871 }
01872 if (r->address) {
01873 _mem_save_address_0 = NDR_PULL_GET_MEM_CTX(ndr);
01874 NDR_PULL_SET_MEM_CTX(ndr, r->address, 0);
01875 NDR_CHECK(ndr_pull_array_size(ndr, &r->address));
01876 NDR_CHECK(ndr_pull_array_length(ndr, &r->address));
01877 if (ndr_get_array_length(ndr, &r->address) > ndr_get_array_size(ndr, &r->address)) {
01878 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));
01879 }
01880 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->address), sizeof(uint16_t)));
01881 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->address, ndr_get_array_length(ndr, &r->address), sizeof(uint16_t), CH_UTF16));
01882 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_address_0, 0);
01883 }
01884 }
01885 return NT_STATUS_OK;
01886 }
01887
01888 _PUBLIC_ void ndr_print_wkssvc_NetWkstaTransportInfo0(struct ndr_print *ndr, const char *name, const struct wkssvc_NetWkstaTransportInfo0 *r)
01889 {
01890 ndr_print_struct(ndr, name, "wkssvc_NetWkstaTransportInfo0");
01891 ndr->depth++;
01892 ndr_print_uint32(ndr, "quality_of_service", r->quality_of_service);
01893 ndr_print_uint32(ndr, "vc_count", r->vc_count);
01894 ndr_print_ptr(ndr, "name", r->name);
01895 ndr->depth++;
01896 if (r->name) {
01897 ndr_print_string(ndr, "name", r->name);
01898 }
01899 ndr->depth--;
01900 ndr_print_ptr(ndr, "address", r->address);
01901 ndr->depth++;
01902 if (r->address) {
01903 ndr_print_string(ndr, "address", r->address);
01904 }
01905 ndr->depth--;
01906 ndr_print_uint32(ndr, "wan_link", r->wan_link);
01907 ndr->depth--;
01908 }
01909
01910 NTSTATUS ndr_push_wkssvc_NetWkstaTransportCtr0(struct ndr_push *ndr, int ndr_flags, const struct wkssvc_NetWkstaTransportCtr0 *r)
01911 {
01912 uint32_t cntr_array_1;
01913 if (ndr_flags & NDR_SCALARS) {
01914 NDR_CHECK(ndr_push_align(ndr, 4));
01915 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
01916 NDR_CHECK(ndr_push_unique_ptr(ndr, r->array));
01917 }
01918 if (ndr_flags & NDR_BUFFERS) {
01919 if (r->array) {
01920 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
01921 for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
01922 NDR_CHECK(ndr_push_wkssvc_NetWkstaTransportInfo0(ndr, NDR_SCALARS, &r->array[cntr_array_1]));
01923 }
01924 for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
01925 NDR_CHECK(ndr_push_wkssvc_NetWkstaTransportInfo0(ndr, NDR_BUFFERS, &r->array[cntr_array_1]));
01926 }
01927 }
01928 }
01929 return NT_STATUS_OK;
01930 }
01931
01932 NTSTATUS ndr_pull_wkssvc_NetWkstaTransportCtr0(struct ndr_pull *ndr, int ndr_flags, struct wkssvc_NetWkstaTransportCtr0 *r)
01933 {
01934 uint32_t _ptr_array;
01935 uint32_t cntr_array_1;
01936 TALLOC_CTX *_mem_save_array_0;
01937 TALLOC_CTX *_mem_save_array_1;
01938 if (ndr_flags & NDR_SCALARS) {
01939 NDR_CHECK(ndr_pull_align(ndr, 4));
01940 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
01941 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_array));
01942 if (_ptr_array) {
01943 NDR_PULL_ALLOC(ndr, r->array);
01944 } else {
01945 r->array = NULL;
01946 }
01947 }
01948 if (ndr_flags & NDR_BUFFERS) {
01949 if (r->array) {
01950 _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
01951 NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
01952 NDR_CHECK(ndr_pull_array_size(ndr, &r->array));
01953 NDR_PULL_ALLOC_N(ndr, r->array, ndr_get_array_size(ndr, &r->array));
01954 _mem_save_array_1 = NDR_PULL_GET_MEM_CTX(ndr);
01955 NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
01956 for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
01957 NDR_CHECK(ndr_pull_wkssvc_NetWkstaTransportInfo0(ndr, NDR_SCALARS, &r->array[cntr_array_1]));
01958 }
01959 for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
01960 NDR_CHECK(ndr_pull_wkssvc_NetWkstaTransportInfo0(ndr, NDR_BUFFERS, &r->array[cntr_array_1]));
01961 }
01962 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_1, 0);
01963 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
01964 }
01965 if (r->array) {
01966 NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->array, r->count));
01967 }
01968 }
01969 return NT_STATUS_OK;
01970 }
01971
01972 _PUBLIC_ void ndr_print_wkssvc_NetWkstaTransportCtr0(struct ndr_print *ndr, const char *name, const struct wkssvc_NetWkstaTransportCtr0 *r)
01973 {
01974 uint32_t cntr_array_1;
01975 ndr_print_struct(ndr, name, "wkssvc_NetWkstaTransportCtr0");
01976 ndr->depth++;
01977 ndr_print_uint32(ndr, "count", r->count);
01978 ndr_print_ptr(ndr, "array", r->array);
01979 ndr->depth++;
01980 if (r->array) {
01981 ndr->print(ndr, "%s: ARRAY(%d)", "array", r->count);
01982 ndr->depth++;
01983 for (cntr_array_1=0;cntr_array_1<r->count;cntr_array_1++) {
01984 char *idx_1=NULL;
01985 asprintf(&idx_1, "[%d]", cntr_array_1);
01986 if (idx_1) {
01987 ndr_print_wkssvc_NetWkstaTransportInfo0(ndr, "array", &r->array[cntr_array_1]);
01988 free(idx_1);
01989 }
01990 }
01991 ndr->depth--;
01992 }
01993 ndr->depth--;
01994 ndr->depth--;
01995 }
01996
01997 NTSTATUS ndr_push_wkssvc_NetWkstaTransportCtr(struct ndr_push *ndr, int ndr_flags, const union wkssvc_NetWkstaTransportCtr *r)
01998 {
01999 int level;
02000 level = ndr_push_get_switch_value(ndr, r);
02001 if (ndr_flags & NDR_SCALARS) {
02002 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
02003 switch (level) {
02004 case 0:
02005 NDR_CHECK(ndr_push_unique_ptr(ndr, r->ctr0));
02006 break;
02007
02008 default:
02009 break;
02010
02011 }
02012 }
02013 if (ndr_flags & NDR_BUFFERS) {
02014 switch (level) {
02015 case 0:
02016 if (r->ctr0) {
02017 NDR_CHECK(ndr_push_wkssvc_NetWkstaTransportCtr0(ndr, NDR_SCALARS|NDR_BUFFERS, r->ctr0));
02018 }
02019 break;
02020
02021 default:
02022 break;
02023
02024 }
02025 }
02026 return NT_STATUS_OK;
02027 }
02028
02029 NTSTATUS ndr_pull_wkssvc_NetWkstaTransportCtr(struct ndr_pull *ndr, int ndr_flags, union wkssvc_NetWkstaTransportCtr *r)
02030 {
02031 int level;
02032 uint32_t _level;
02033 TALLOC_CTX *_mem_save_ctr0_0;
02034 level = ndr_pull_get_switch_value(ndr, r);
02035 if (ndr_flags & NDR_SCALARS) {
02036 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
02037 if (_level != level) {
02038 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for wkssvc_NetWkstaTransportCtr", _level);
02039 }
02040 switch (level) {
02041 case 0: {
02042 uint32_t _ptr_ctr0;
02043 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_ctr0));
02044 if (_ptr_ctr0) {
02045 NDR_PULL_ALLOC(ndr, r->ctr0);
02046 } else {
02047 r->ctr0 = NULL;
02048 }
02049 break; }
02050
02051 default: {
02052 break; }
02053
02054 }
02055 }
02056 if (ndr_flags & NDR_BUFFERS) {
02057 switch (level) {
02058 case 0:
02059 if (r->ctr0) {
02060 _mem_save_ctr0_0 = NDR_PULL_GET_MEM_CTX(ndr);
02061 NDR_PULL_SET_MEM_CTX(ndr, r->ctr0, 0);
02062 NDR_CHECK(ndr_pull_wkssvc_NetWkstaTransportCtr0(ndr, NDR_SCALARS|NDR_BUFFERS, r->ctr0));
02063 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ctr0_0, 0);
02064 }
02065 break;
02066
02067 default:
02068 break;
02069
02070 }
02071 }
02072 return NT_STATUS_OK;
02073 }
02074
02075 _PUBLIC_ void ndr_print_wkssvc_NetWkstaTransportCtr(struct ndr_print *ndr, const char *name, const union wkssvc_NetWkstaTransportCtr *r)
02076 {
02077 int level;
02078 level = ndr_print_get_switch_value(ndr, r);
02079 ndr_print_union(ndr, name, level, "wkssvc_NetWkstaTransportCtr");
02080 switch (level) {
02081 case 0:
02082 ndr_print_ptr(ndr, "ctr0", r->ctr0);
02083 ndr->depth++;
02084 if (r->ctr0) {
02085 ndr_print_wkssvc_NetWkstaTransportCtr0(ndr, "ctr0", r->ctr0);
02086 }
02087 ndr->depth--;
02088 break;
02089
02090 default:
02091 break;
02092
02093 }
02094 }
02095
02096 NTSTATUS ndr_push_wkssvc_PasswordBuffer(struct ndr_push *ndr, int ndr_flags, const struct wkssvc_PasswordBuffer *r)
02097 {
02098 if (ndr_flags & NDR_SCALARS) {
02099 NDR_CHECK(ndr_push_align(ndr, 1));
02100 NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->data, 524));
02101 }
02102 if (ndr_flags & NDR_BUFFERS) {
02103 }
02104 return NT_STATUS_OK;
02105 }
02106
02107 NTSTATUS ndr_pull_wkssvc_PasswordBuffer(struct ndr_pull *ndr, int ndr_flags, struct wkssvc_PasswordBuffer *r)
02108 {
02109 if (ndr_flags & NDR_SCALARS) {
02110 NDR_CHECK(ndr_pull_align(ndr, 1));
02111 NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->data, 524));
02112 }
02113 if (ndr_flags & NDR_BUFFERS) {
02114 }
02115 return NT_STATUS_OK;
02116 }
02117
02118 _PUBLIC_ void ndr_print_wkssvc_PasswordBuffer(struct ndr_print *ndr, const char *name, const struct wkssvc_PasswordBuffer *r)
02119 {
02120 ndr_print_struct(ndr, name, "wkssvc_PasswordBuffer");
02121 ndr->depth++;
02122 ndr_print_array_uint8(ndr, "data", r->data, 524);
02123 ndr->depth--;
02124 }
02125
02126 NTSTATUS ndr_push_wkssvc_joinflags(struct ndr_push *ndr, int ndr_flags, uint32_t r)
02127 {
02128 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
02129 return NT_STATUS_OK;
02130 }
02131
02132 NTSTATUS ndr_pull_wkssvc_joinflags(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
02133 {
02134 uint32_t v;
02135 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
02136 *r = v;
02137 return NT_STATUS_OK;
02138 }
02139
02140 _PUBLIC_ void ndr_print_wkssvc_joinflags(struct ndr_print *ndr, const char *name, uint32_t r)
02141 {
02142 ndr_print_uint32(ndr, name, r);
02143 ndr->depth++;
02144 ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "WKSSVC_JOIN_FLAGS_DEFER_SPN", WKSSVC_JOIN_FLAGS_DEFER_SPN, r);
02145 ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "WKSSVC_JOIN_FLAGS_MACHINE_PWD_PASSED", WKSSVC_JOIN_FLAGS_MACHINE_PWD_PASSED, r);
02146 ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "WKSSVC_JOIN_FLAGS_JOIN_UNSECURE", WKSSVC_JOIN_FLAGS_JOIN_UNSECURE, r);
02147 ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "WKSSVC_JOIN_FLAGS_DOMAIN_JOIN_IF_JOINED", WKSSVC_JOIN_FLAGS_DOMAIN_JOIN_IF_JOINED, r);
02148 ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "WKSSVC_JOIN_FLAGS_WIN9X_UPGRADE", WKSSVC_JOIN_FLAGS_WIN9X_UPGRADE, r);
02149 ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "WKSSVC_JOIN_FLAGS_ACCOUNT_DELETE", WKSSVC_JOIN_FLAGS_ACCOUNT_DELETE, r);
02150 ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "WKSSVC_JOIN_FLAGS_ACCOUNT_CREATE", WKSSVC_JOIN_FLAGS_ACCOUNT_CREATE, r);
02151 ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "WKSSVC_JOIN_FLAGS_JOIN_TYPE", WKSSVC_JOIN_FLAGS_JOIN_TYPE, r);
02152 ndr->depth--;
02153 }
02154
02155 NTSTATUS ndr_push_wkssvc_renameflags(struct ndr_push *ndr, int ndr_flags, uint32_t r)
02156 {
02157 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
02158 return NT_STATUS_OK;
02159 }
02160
02161 NTSTATUS ndr_pull_wkssvc_renameflags(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
02162 {
02163 uint32_t v;
02164 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
02165 *r = v;
02166 return NT_STATUS_OK;
02167 }
02168
02169 _PUBLIC_ void ndr_print_wkssvc_renameflags(struct ndr_print *ndr, const char *name, uint32_t r)
02170 {
02171 ndr_print_uint32(ndr, name, r);
02172 ndr->depth++;
02173 ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "WKSSVC_JOIN_FLAGS_ACCOUNT_CREATE", WKSSVC_JOIN_FLAGS_ACCOUNT_CREATE, r);
02174 ndr->depth--;
02175 }
02176
02177 NTSTATUS ndr_push_wkssvc_NetWkstaGetInfo(struct ndr_push *ndr, int flags, const struct wkssvc_NetWkstaGetInfo *r)
02178 {
02179 if (flags & NDR_IN) {
02180 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server_name));
02181 if (r->in.server_name) {
02182 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
02183 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
02184 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
02185 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));
02186 }
02187 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
02188 }
02189 if (flags & NDR_OUT) {
02190 if (r->out.info == NULL) return NT_STATUS_INVALID_PARAMETER_MIX;
02191 NDR_CHECK(ndr_push_set_switch_value(ndr, r->out.info, r->in.level));
02192 NDR_CHECK(ndr_push_wkssvc_NetWkstaInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.info));
02193 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
02194 }
02195 return NT_STATUS_OK;
02196 }
02197
02198 NTSTATUS ndr_pull_wkssvc_NetWkstaGetInfo(struct ndr_pull *ndr, int flags, struct wkssvc_NetWkstaGetInfo *r)
02199 {
02200 uint32_t _ptr_server_name;
02201 TALLOC_CTX *_mem_save_server_name_0;
02202 TALLOC_CTX *_mem_save_info_0;
02203 if (flags & NDR_IN) {
02204 ZERO_STRUCT(r->out);
02205
02206 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_name));
02207 if (_ptr_server_name) {
02208 NDR_PULL_ALLOC(ndr, r->in.server_name);
02209 } else {
02210 r->in.server_name = NULL;
02211 }
02212 if (r->in.server_name) {
02213 _mem_save_server_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
02214 NDR_PULL_SET_MEM_CTX(ndr, r->in.server_name, 0);
02215 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_name));
02216 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_name));
02217 if (ndr_get_array_length(ndr, &r->in.server_name) > ndr_get_array_size(ndr, &r->in.server_name)) {
02218 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));
02219 }
02220 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server_name), sizeof(uint16_t)));
02221 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));
02222 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_name_0, 0);
02223 }
02224 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
02225 NDR_PULL_ALLOC(ndr, r->out.info);
02226 ZERO_STRUCTP(r->out.info);
02227 }
02228 if (flags & NDR_OUT) {
02229 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
02230 NDR_PULL_ALLOC(ndr, r->out.info);
02231 }
02232 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
02233 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, LIBNDR_FLAG_REF_ALLOC);
02234 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->out.info, r->in.level));
02235 NDR_CHECK(ndr_pull_wkssvc_NetWkstaInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.info));
02236 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, LIBNDR_FLAG_REF_ALLOC);
02237 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
02238 }
02239 return NT_STATUS_OK;
02240 }
02241
02242 _PUBLIC_ void ndr_print_wkssvc_NetWkstaGetInfo(struct ndr_print *ndr, const char *name, int flags, const struct wkssvc_NetWkstaGetInfo *r)
02243 {
02244 ndr_print_struct(ndr, name, "wkssvc_NetWkstaGetInfo");
02245 ndr->depth++;
02246 if (flags & NDR_SET_VALUES) {
02247 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
02248 }
02249 if (flags & NDR_IN) {
02250 ndr_print_struct(ndr, "in", "wkssvc_NetWkstaGetInfo");
02251 ndr->depth++;
02252 ndr_print_ptr(ndr, "server_name", r->in.server_name);
02253 ndr->depth++;
02254 if (r->in.server_name) {
02255 ndr_print_string(ndr, "server_name", r->in.server_name);
02256 }
02257 ndr->depth--;
02258 ndr_print_uint32(ndr, "level", r->in.level);
02259 ndr->depth--;
02260 }
02261 if (flags & NDR_OUT) {
02262 ndr_print_struct(ndr, "out", "wkssvc_NetWkstaGetInfo");
02263 ndr->depth++;
02264 ndr_print_ptr(ndr, "info", r->out.info);
02265 ndr->depth++;
02266 ndr_print_set_switch_value(ndr, r->out.info, r->in.level);
02267 ndr_print_wkssvc_NetWkstaInfo(ndr, "info", r->out.info);
02268 ndr->depth--;
02269 ndr_print_WERROR(ndr, "result", r->out.result);
02270 ndr->depth--;
02271 }
02272 ndr->depth--;
02273 }
02274
02275 NTSTATUS ndr_push_wkssvc_NetWkstaSetInfo(struct ndr_push *ndr, int flags, const struct wkssvc_NetWkstaSetInfo *r)
02276 {
02277 if (flags & NDR_IN) {
02278 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server_name));
02279 if (r->in.server_name) {
02280 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
02281 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
02282 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
02283 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));
02284 }
02285 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
02286 if (r->in.info == NULL) return NT_STATUS_INVALID_PARAMETER_MIX;
02287 NDR_CHECK(ndr_push_set_switch_value(ndr, r->in.info, r->in.level));
02288 NDR_CHECK(ndr_push_wkssvc_NetWkstaInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info));
02289 if (r->in.parm_error == NULL) return NT_STATUS_INVALID_PARAMETER_MIX;
02290 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->in.parm_error));
02291 }
02292 if (flags & NDR_OUT) {
02293 if (r->out.parm_error == NULL) return NT_STATUS_INVALID_PARAMETER_MIX;
02294 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.parm_error));
02295 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
02296 }
02297 return NT_STATUS_OK;
02298 }
02299
02300 NTSTATUS ndr_pull_wkssvc_NetWkstaSetInfo(struct ndr_pull *ndr, int flags, struct wkssvc_NetWkstaSetInfo *r)
02301 {
02302 uint32_t _ptr_server_name;
02303 TALLOC_CTX *_mem_save_server_name_0;
02304 TALLOC_CTX *_mem_save_info_0;
02305 TALLOC_CTX *_mem_save_parm_error_0;
02306 if (flags & NDR_IN) {
02307 ZERO_STRUCT(r->out);
02308
02309 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_name));
02310 if (_ptr_server_name) {
02311 NDR_PULL_ALLOC(ndr, r->in.server_name);
02312 } else {
02313 r->in.server_name = NULL;
02314 }
02315 if (r->in.server_name) {
02316 _mem_save_server_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
02317 NDR_PULL_SET_MEM_CTX(ndr, r->in.server_name, 0);
02318 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_name));
02319 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_name));
02320 if (ndr_get_array_length(ndr, &r->in.server_name) > ndr_get_array_size(ndr, &r->in.server_name)) {
02321 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));
02322 }
02323 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server_name), sizeof(uint16_t)));
02324 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));
02325 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_name_0, 0);
02326 }
02327 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
02328 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
02329 NDR_PULL_ALLOC(ndr, r->in.info);
02330 }
02331 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
02332 NDR_PULL_SET_MEM_CTX(ndr, r->in.info, LIBNDR_FLAG_REF_ALLOC);
02333 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->in.info, r->in.level));
02334 NDR_CHECK(ndr_pull_wkssvc_NetWkstaInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info));
02335 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, LIBNDR_FLAG_REF_ALLOC);
02336 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
02337 NDR_PULL_ALLOC(ndr, r->in.parm_error);
02338 }
02339 _mem_save_parm_error_0 = NDR_PULL_GET_MEM_CTX(ndr);
02340 NDR_PULL_SET_MEM_CTX(ndr, r->in.parm_error, LIBNDR_FLAG_REF_ALLOC);
02341 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->in.parm_error));
02342 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_parm_error_0, LIBNDR_FLAG_REF_ALLOC);
02343 NDR_PULL_ALLOC(ndr, r->out.parm_error);
02344 *r->out.parm_error = *r->in.parm_error;
02345 }
02346 if (flags & NDR_OUT) {
02347 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
02348 NDR_PULL_ALLOC(ndr, r->out.parm_error);
02349 }
02350 _mem_save_parm_error_0 = NDR_PULL_GET_MEM_CTX(ndr);
02351 NDR_PULL_SET_MEM_CTX(ndr, r->out.parm_error, LIBNDR_FLAG_REF_ALLOC);
02352 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.parm_error));
02353 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_parm_error_0, LIBNDR_FLAG_REF_ALLOC);
02354 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
02355 }
02356 return NT_STATUS_OK;
02357 }
02358
02359 _PUBLIC_ void ndr_print_wkssvc_NetWkstaSetInfo(struct ndr_print *ndr, const char *name, int flags, const struct wkssvc_NetWkstaSetInfo *r)
02360 {
02361 ndr_print_struct(ndr, name, "wkssvc_NetWkstaSetInfo");
02362 ndr->depth++;
02363 if (flags & NDR_SET_VALUES) {
02364 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
02365 }
02366 if (flags & NDR_IN) {
02367 ndr_print_struct(ndr, "in", "wkssvc_NetWkstaSetInfo");
02368 ndr->depth++;
02369 ndr_print_ptr(ndr, "server_name", r->in.server_name);
02370 ndr->depth++;
02371 if (r->in.server_name) {
02372 ndr_print_string(ndr, "server_name", r->in.server_name);
02373 }
02374 ndr->depth--;
02375 ndr_print_uint32(ndr, "level", r->in.level);
02376 ndr_print_ptr(ndr, "info", r->in.info);
02377 ndr->depth++;
02378 ndr_print_set_switch_value(ndr, r->in.info, r->in.level);
02379 ndr_print_wkssvc_NetWkstaInfo(ndr, "info", r->in.info);
02380 ndr->depth--;
02381 ndr_print_ptr(ndr, "parm_error", r->in.parm_error);
02382 ndr->depth++;
02383 ndr_print_uint32(ndr, "parm_error", *r->in.parm_error);
02384 ndr->depth--;
02385 ndr->depth--;
02386 }
02387 if (flags & NDR_OUT) {
02388 ndr_print_struct(ndr, "out", "wkssvc_NetWkstaSetInfo");
02389 ndr->depth++;
02390 ndr_print_ptr(ndr, "parm_error", r->out.parm_error);
02391 ndr->depth++;
02392 ndr_print_uint32(ndr, "parm_error", *r->out.parm_error);
02393 ndr->depth--;
02394 ndr_print_WERROR(ndr, "result", r->out.result);
02395 ndr->depth--;
02396 }
02397 ndr->depth--;
02398 }
02399
02400 NTSTATUS ndr_push_wkssvc_NetWkstaEnumUsers(struct ndr_push *ndr, int flags, const struct wkssvc_NetWkstaEnumUsers *r)
02401 {
02402 if (flags & NDR_IN) {
02403 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server_name));
02404 if (r->in.server_name) {
02405 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
02406 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
02407 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
02408 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));
02409 }
02410 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
02411 if (r->in.users == NULL) return NT_STATUS_INVALID_PARAMETER_MIX;
02412 NDR_CHECK(ndr_push_WKS_USER_ENUM_UNION(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.users));
02413 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.prefmaxlen));
02414 if (r->in.resumehandle == NULL) return NT_STATUS_INVALID_PARAMETER_MIX;
02415 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->in.resumehandle));
02416 }
02417 if (flags & NDR_OUT) {
02418 if (r->out.users == NULL) return NT_STATUS_INVALID_PARAMETER_MIX;
02419 NDR_CHECK(ndr_push_WKS_USER_ENUM_UNION(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.users));
02420 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.entriesread));
02421 if (r->out.entriesread) {
02422 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.entriesread));
02423 }
02424 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.totalentries));
02425 if (r->out.totalentries) {
02426 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.totalentries));
02427 }
02428 if (r->out.resumehandle == NULL) return NT_STATUS_INVALID_PARAMETER_MIX;
02429 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.resumehandle));
02430 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
02431 }
02432 return NT_STATUS_OK;
02433 }
02434
02435 NTSTATUS ndr_pull_wkssvc_NetWkstaEnumUsers(struct ndr_pull *ndr, int flags, struct wkssvc_NetWkstaEnumUsers *r)
02436 {
02437 uint32_t _ptr_server_name;
02438 uint32_t _ptr_entriesread;
02439 uint32_t _ptr_totalentries;
02440 TALLOC_CTX *_mem_save_server_name_0;
02441 TALLOC_CTX *_mem_save_users_0;
02442 TALLOC_CTX *_mem_save_entriesread_0;
02443 TALLOC_CTX *_mem_save_totalentries_0;
02444 TALLOC_CTX *_mem_save_resumehandle_0;
02445 if (flags & NDR_IN) {
02446 ZERO_STRUCT(r->out);
02447
02448 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_name));
02449 if (_ptr_server_name) {
02450 NDR_PULL_ALLOC(ndr, r->in.server_name);
02451 } else {
02452 r->in.server_name = NULL;
02453 }
02454 if (r->in.server_name) {
02455 _mem_save_server_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
02456 NDR_PULL_SET_MEM_CTX(ndr, r->in.server_name, 0);
02457 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_name));
02458 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_name));
02459 if (ndr_get_array_length(ndr, &r->in.server_name) > ndr_get_array_size(ndr, &r->in.server_name)) {
02460 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));
02461 }
02462 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server_name), sizeof(uint16_t)));
02463 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));
02464 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_name_0, 0);
02465 }
02466 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
02467 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
02468 NDR_PULL_ALLOC(ndr, r->in.users);
02469 }
02470 _mem_save_users_0 = NDR_PULL_GET_MEM_CTX(ndr);
02471 NDR_PULL_SET_MEM_CTX(ndr, r->in.users, LIBNDR_FLAG_REF_ALLOC);
02472 NDR_CHECK(ndr_pull_WKS_USER_ENUM_UNION(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.users));
02473 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_users_0, LIBNDR_FLAG_REF_ALLOC);
02474 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.prefmaxlen));
02475 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
02476 NDR_PULL_ALLOC(ndr, r->in.resumehandle);
02477 }
02478 _mem_save_resumehandle_0 = NDR_PULL_GET_MEM_CTX(ndr);
02479 NDR_PULL_SET_MEM_CTX(ndr, r->in.resumehandle, LIBNDR_FLAG_REF_ALLOC);
02480 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->in.resumehandle));
02481 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_resumehandle_0, LIBNDR_FLAG_REF_ALLOC);
02482 NDR_PULL_ALLOC(ndr, r->out.users);
02483 *r->out.users = *r->in.users;
02484 NDR_PULL_ALLOC(ndr, r->out.resumehandle);
02485 *r->out.resumehandle = *r->in.resumehandle;
02486 }
02487 if (flags & NDR_OUT) {
02488 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
02489 NDR_PULL_ALLOC(ndr, r->out.users);
02490 }
02491 _mem_save_users_0 = NDR_PULL_GET_MEM_CTX(ndr);
02492 NDR_PULL_SET_MEM_CTX(ndr, r->out.users, LIBNDR_FLAG_REF_ALLOC);
02493 NDR_CHECK(ndr_pull_WKS_USER_ENUM_UNION(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.users));
02494 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_users_0, LIBNDR_FLAG_REF_ALLOC);
02495 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_entriesread));
02496 if (_ptr_entriesread) {
02497 NDR_PULL_ALLOC(ndr, r->out.entriesread);
02498 } else {
02499 r->out.entriesread = NULL;
02500 }
02501 if (r->out.entriesread) {
02502 _mem_save_entriesread_0 = NDR_PULL_GET_MEM_CTX(ndr);
02503 NDR_PULL_SET_MEM_CTX(ndr, r->out.entriesread, 0);
02504 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.entriesread));
02505 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_entriesread_0, 0);
02506 }
02507 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_totalentries));
02508 if (_ptr_totalentries) {
02509 NDR_PULL_ALLOC(ndr, r->out.totalentries);
02510 } else {
02511 r->out.totalentries = NULL;
02512 }
02513 if (r->out.totalentries) {
02514 _mem_save_totalentries_0 = NDR_PULL_GET_MEM_CTX(ndr);
02515 NDR_PULL_SET_MEM_CTX(ndr, r->out.totalentries, 0);
02516 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.totalentries));
02517 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_totalentries_0, 0);
02518 }
02519 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
02520 NDR_PULL_ALLOC(ndr, r->out.resumehandle);
02521 }
02522 _mem_save_resumehandle_0 = NDR_PULL_GET_MEM_CTX(ndr);
02523 NDR_PULL_SET_MEM_CTX(ndr, r->out.resumehandle, LIBNDR_FLAG_REF_ALLOC);
02524 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.resumehandle));
02525 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_resumehandle_0, LIBNDR_FLAG_REF_ALLOC);
02526 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
02527 }
02528 return NT_STATUS_OK;
02529 }
02530
02531 _PUBLIC_ void ndr_print_wkssvc_NetWkstaEnumUsers(struct ndr_print *ndr, const char *name, int flags, const struct wkssvc_NetWkstaEnumUsers *r)
02532 {
02533 ndr_print_struct(ndr, name, "wkssvc_NetWkstaEnumUsers");
02534 ndr->depth++;
02535 if (flags & NDR_SET_VALUES) {
02536 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
02537 }
02538 if (flags & NDR_IN) {
02539 ndr_print_struct(ndr, "in", "wkssvc_NetWkstaEnumUsers");
02540 ndr->depth++;
02541 ndr_print_ptr(ndr, "server_name", r->in.server_name);
02542 ndr->depth++;
02543 if (r->in.server_name) {
02544 ndr_print_string(ndr, "server_name", r->in.server_name);
02545 }
02546 ndr->depth--;
02547 ndr_print_uint32(ndr, "level", r->in.level);
02548 ndr_print_ptr(ndr, "users", r->in.users);
02549 ndr->depth++;
02550 ndr_print_WKS_USER_ENUM_UNION(ndr, "users", r->in.users);
02551 ndr->depth--;
02552 ndr_print_uint32(ndr, "prefmaxlen", r->in.prefmaxlen);
02553 ndr_print_ptr(ndr, "resumehandle", r->in.resumehandle);
02554 ndr->depth++;
02555 ndr_print_uint32(ndr, "resumehandle", *r->in.resumehandle);
02556 ndr->depth--;
02557 ndr->depth--;
02558 }
02559 if (flags & NDR_OUT) {
02560 ndr_print_struct(ndr, "out", "wkssvc_NetWkstaEnumUsers");
02561 ndr->depth++;
02562 ndr_print_ptr(ndr, "users", r->out.users);
02563 ndr->depth++;
02564 ndr_print_WKS_USER_ENUM_UNION(ndr, "users", r->out.users);
02565 ndr->depth--;
02566 ndr_print_ptr(ndr, "entriesread", r->out.entriesread);
02567 ndr->depth++;
02568 if (r->out.entriesread) {
02569 ndr_print_uint32(ndr, "entriesread", *r->out.entriesread);
02570 }
02571 ndr->depth--;
02572 ndr_print_ptr(ndr, "totalentries", r->out.totalentries);
02573 ndr->depth++;
02574 if (r->out.totalentries) {
02575 ndr_print_uint32(ndr, "totalentries", *r->out.totalentries);
02576 }
02577 ndr->depth--;
02578 ndr_print_ptr(ndr, "resumehandle", r->out.resumehandle);
02579 ndr->depth++;
02580 ndr_print_uint32(ndr, "resumehandle", *r->out.resumehandle);
02581 ndr->depth--;
02582 ndr_print_WERROR(ndr, "result", r->out.result);
02583 ndr->depth--;
02584 }
02585 ndr->depth--;
02586 }
02587
02588 NTSTATUS ndr_push_WKSSVC_NETRWKSTAUSERGETINFO(struct ndr_push *ndr, int flags, const struct WKSSVC_NETRWKSTAUSERGETINFO *r)
02589 {
02590 if (flags & NDR_IN) {
02591 }
02592 if (flags & NDR_OUT) {
02593 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
02594 }
02595 return NT_STATUS_OK;
02596 }
02597
02598 NTSTATUS ndr_pull_WKSSVC_NETRWKSTAUSERGETINFO(struct ndr_pull *ndr, int flags, struct WKSSVC_NETRWKSTAUSERGETINFO *r)
02599 {
02600 if (flags & NDR_IN) {
02601 }
02602 if (flags & NDR_OUT) {
02603 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
02604 }
02605 return NT_STATUS_OK;
02606 }
02607
02608 _PUBLIC_ void ndr_print_WKSSVC_NETRWKSTAUSERGETINFO(struct ndr_print *ndr, const char *name, int flags, const struct WKSSVC_NETRWKSTAUSERGETINFO *r)
02609 {
02610 ndr_print_struct(ndr, name, "WKSSVC_NETRWKSTAUSERGETINFO");
02611 ndr->depth++;
02612 if (flags & NDR_SET_VALUES) {
02613 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
02614 }
02615 if (flags & NDR_IN) {
02616 ndr_print_struct(ndr, "in", "WKSSVC_NETRWKSTAUSERGETINFO");
02617 ndr->depth++;
02618 ndr->depth--;
02619 }
02620 if (flags & NDR_OUT) {
02621 ndr_print_struct(ndr, "out", "WKSSVC_NETRWKSTAUSERGETINFO");
02622 ndr->depth++;
02623 ndr_print_WERROR(ndr, "result", r->out.result);
02624 ndr->depth--;
02625 }
02626 ndr->depth--;
02627 }
02628
02629 NTSTATUS ndr_push_WKSSVC_NETRWKSTAUSERSETINFO(struct ndr_push *ndr, int flags, const struct WKSSVC_NETRWKSTAUSERSETINFO *r)
02630 {
02631 if (flags & NDR_IN) {
02632 }
02633 if (flags & NDR_OUT) {
02634 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
02635 }
02636 return NT_STATUS_OK;
02637 }
02638
02639 NTSTATUS ndr_pull_WKSSVC_NETRWKSTAUSERSETINFO(struct ndr_pull *ndr, int flags, struct WKSSVC_NETRWKSTAUSERSETINFO *r)
02640 {
02641 if (flags & NDR_IN) {
02642 }
02643 if (flags & NDR_OUT) {
02644 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
02645 }
02646 return NT_STATUS_OK;
02647 }
02648
02649 _PUBLIC_ void ndr_print_WKSSVC_NETRWKSTAUSERSETINFO(struct ndr_print *ndr, const char *name, int flags, const struct WKSSVC_NETRWKSTAUSERSETINFO *r)
02650 {
02651 ndr_print_struct(ndr, name, "WKSSVC_NETRWKSTAUSERSETINFO");
02652 ndr->depth++;
02653 if (flags & NDR_SET_VALUES) {
02654 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
02655 }
02656 if (flags & NDR_IN) {
02657 ndr_print_struct(ndr, "in", "WKSSVC_NETRWKSTAUSERSETINFO");
02658 ndr->depth++;
02659 ndr->depth--;
02660 }
02661 if (flags & NDR_OUT) {
02662 ndr_print_struct(ndr, "out", "WKSSVC_NETRWKSTAUSERSETINFO");
02663 ndr->depth++;
02664 ndr_print_WERROR(ndr, "result", r->out.result);
02665 ndr->depth--;
02666 }
02667 ndr->depth--;
02668 }
02669
02670 NTSTATUS ndr_push_wkssvc_NetWkstaTransportEnum(struct ndr_push *ndr, int flags, const struct wkssvc_NetWkstaTransportEnum *r)
02671 {
02672 if (flags & NDR_IN) {
02673 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server_name));
02674 if (r->in.server_name) {
02675 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
02676 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
02677 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
02678 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));
02679 }
02680 if (r->in.level == NULL) return NT_STATUS_INVALID_PARAMETER_MIX;
02681 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->in.level));
02682 if (r->in.ctr == NULL) return NT_STATUS_INVALID_PARAMETER_MIX;
02683 NDR_CHECK(ndr_push_set_switch_value(ndr, r->in.ctr, *r->in.level));
02684 NDR_CHECK(ndr_push_wkssvc_NetWkstaTransportCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.ctr));
02685 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.max_buffer));
02686 if (r->in.resume_handle == NULL) return NT_STATUS_INVALID_PARAMETER_MIX;
02687 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->in.resume_handle));
02688 }
02689 if (flags & NDR_OUT) {
02690 if (r->out.level == NULL) return NT_STATUS_INVALID_PARAMETER_MIX;
02691 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.level));
02692 if (r->out.ctr == NULL) return NT_STATUS_INVALID_PARAMETER_MIX;
02693 NDR_CHECK(ndr_push_set_switch_value(ndr, r->out.ctr, *r->out.level));
02694 NDR_CHECK(ndr_push_wkssvc_NetWkstaTransportCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.ctr));
02695 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.totalentries));
02696 if (r->out.totalentries) {
02697 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.totalentries));
02698 }
02699 if (r->out.resume_handle == NULL) return NT_STATUS_INVALID_PARAMETER_MIX;
02700 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.resume_handle));
02701 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
02702 }
02703 return NT_STATUS_OK;
02704 }
02705
02706 NTSTATUS ndr_pull_wkssvc_NetWkstaTransportEnum(struct ndr_pull *ndr, int flags, struct wkssvc_NetWkstaTransportEnum *r)
02707 {
02708 uint32_t _ptr_server_name;
02709 uint32_t _ptr_totalentries;
02710 TALLOC_CTX *_mem_save_server_name_0;
02711 TALLOC_CTX *_mem_save_level_0;
02712 TALLOC_CTX *_mem_save_ctr_0;
02713 TALLOC_CTX *_mem_save_totalentries_0;
02714 TALLOC_CTX *_mem_save_resume_handle_0;
02715 if (flags & NDR_IN) {
02716 ZERO_STRUCT(r->out);
02717
02718 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_name));
02719 if (_ptr_server_name) {
02720 NDR_PULL_ALLOC(ndr, r->in.server_name);
02721 } else {
02722 r->in.server_name = NULL;
02723 }
02724 if (r->in.server_name) {
02725 _mem_save_server_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
02726 NDR_PULL_SET_MEM_CTX(ndr, r->in.server_name, 0);
02727 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_name));
02728 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_name));
02729 if (ndr_get_array_length(ndr, &r->in.server_name) > ndr_get_array_size(ndr, &r->in.server_name)) {
02730 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));
02731 }
02732 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server_name), sizeof(uint16_t)));
02733 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));
02734 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_name_0, 0);
02735 }
02736 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
02737 NDR_PULL_ALLOC(ndr, r->in.level);
02738 }
02739 _mem_save_level_0 = NDR_PULL_GET_MEM_CTX(ndr);
02740 NDR_PULL_SET_MEM_CTX(ndr, r->in.level, LIBNDR_FLAG_REF_ALLOC);
02741 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->in.level));
02742 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_level_0, LIBNDR_FLAG_REF_ALLOC);
02743 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
02744 NDR_PULL_ALLOC(ndr, r->in.ctr);
02745 }
02746 _mem_save_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
02747 NDR_PULL_SET_MEM_CTX(ndr, r->in.ctr, LIBNDR_FLAG_REF_ALLOC);
02748 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->in.ctr, *r->in.level));
02749 NDR_CHECK(ndr_pull_wkssvc_NetWkstaTransportCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.ctr));
02750 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ctr_0, LIBNDR_FLAG_REF_ALLOC);
02751 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.max_buffer));
02752 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
02753 NDR_PULL_ALLOC(ndr, r->in.resume_handle);
02754 }
02755 _mem_save_resume_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
02756 NDR_PULL_SET_MEM_CTX(ndr, r->in.resume_handle, LIBNDR_FLAG_REF_ALLOC);
02757 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->in.resume_handle));
02758 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_resume_handle_0, LIBNDR_FLAG_REF_ALLOC);
02759 NDR_PULL_ALLOC(ndr, r->out.level);
02760 *r->out.level = *r->in.level;
02761 NDR_PULL_ALLOC(ndr, r->out.ctr);
02762 *r->out.ctr = *r->in.ctr;
02763 NDR_PULL_ALLOC(ndr, r->out.resume_handle);
02764 *r->out.resume_handle = *r->in.resume_handle;
02765 }
02766 if (flags & NDR_OUT) {
02767 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
02768 NDR_PULL_ALLOC(ndr, r->out.level);
02769 }
02770 _mem_save_level_0 = NDR_PULL_GET_MEM_CTX(ndr);
02771 NDR_PULL_SET_MEM_CTX(ndr, r->out.level, LIBNDR_FLAG_REF_ALLOC);
02772 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.level));
02773 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_level_0, LIBNDR_FLAG_REF_ALLOC);
02774 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
02775 NDR_PULL_ALLOC(ndr, r->out.ctr);
02776 }
02777 _mem_save_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
02778 NDR_PULL_SET_MEM_CTX(ndr, r->out.ctr, LIBNDR_FLAG_REF_ALLOC);
02779 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->out.ctr, *r->out.level));
02780 NDR_CHECK(ndr_pull_wkssvc_NetWkstaTransportCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.ctr));
02781 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ctr_0, LIBNDR_FLAG_REF_ALLOC);
02782 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_totalentries));
02783 if (_ptr_totalentries) {
02784 NDR_PULL_ALLOC(ndr, r->out.totalentries);
02785 } else {
02786 r->out.totalentries = NULL;
02787 }
02788 if (r->out.totalentries) {
02789 _mem_save_totalentries_0 = NDR_PULL_GET_MEM_CTX(ndr);
02790 NDR_PULL_SET_MEM_CTX(ndr, r->out.totalentries, 0);
02791 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.totalentries));
02792 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_totalentries_0, 0);
02793 }
02794 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
02795 NDR_PULL_ALLOC(ndr, r->out.resume_handle);
02796 }
02797 _mem_save_resume_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
02798 NDR_PULL_SET_MEM_CTX(ndr, r->out.resume_handle, LIBNDR_FLAG_REF_ALLOC);
02799 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.resume_handle));
02800 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_resume_handle_0, LIBNDR_FLAG_REF_ALLOC);
02801 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
02802 }
02803 return NT_STATUS_OK;
02804 }
02805
02806 _PUBLIC_ void ndr_print_wkssvc_NetWkstaTransportEnum(struct ndr_print *ndr, const char *name, int flags, const struct wkssvc_NetWkstaTransportEnum *r)
02807 {
02808 ndr_print_struct(ndr, name, "wkssvc_NetWkstaTransportEnum");
02809 ndr->depth++;
02810 if (flags & NDR_SET_VALUES) {
02811 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
02812 }
02813 if (flags & NDR_IN) {
02814 ndr_print_struct(ndr, "in", "wkssvc_NetWkstaTransportEnum");
02815 ndr->depth++;
02816 ndr_print_ptr(ndr, "server_name", r->in.server_name);
02817 ndr->depth++;
02818 if (r->in.server_name) {
02819 ndr_print_string(ndr, "server_name", r->in.server_name);
02820 }
02821 ndr->depth--;
02822 ndr_print_ptr(ndr, "level", r->in.level);
02823 ndr->depth++;
02824 ndr_print_uint32(ndr, "level", *r->in.level);
02825 ndr->depth--;
02826 ndr_print_ptr(ndr, "ctr", r->in.ctr);
02827 ndr->depth++;
02828 ndr_print_set_switch_value(ndr, r->in.ctr, *r->in.level);
02829 ndr_print_wkssvc_NetWkstaTransportCtr(ndr, "ctr", r->in.ctr);
02830 ndr->depth--;
02831 ndr_print_uint32(ndr, "max_buffer", r->in.max_buffer);
02832 ndr_print_ptr(ndr, "resume_handle", r->in.resume_handle);
02833 ndr->depth++;
02834 ndr_print_uint32(ndr, "resume_handle", *r->in.resume_handle);
02835 ndr->depth--;
02836 ndr->depth--;
02837 }
02838 if (flags & NDR_OUT) {
02839 ndr_print_struct(ndr, "out", "wkssvc_NetWkstaTransportEnum");
02840 ndr->depth++;
02841 ndr_print_ptr(ndr, "level", r->out.level);
02842 ndr->depth++;
02843 ndr_print_uint32(ndr, "level", *r->out.level);
02844 ndr->depth--;
02845 ndr_print_ptr(ndr, "ctr", r->out.ctr);
02846 ndr->depth++;
02847 ndr_print_set_switch_value(ndr, r->out.ctr, *r->out.level);
02848 ndr_print_wkssvc_NetWkstaTransportCtr(ndr, "ctr", r->out.ctr);
02849 ndr->depth--;
02850 ndr_print_ptr(ndr, "totalentries", r->out.totalentries);
02851 ndr->depth++;
02852 if (r->out.totalentries) {
02853 ndr_print_uint32(ndr, "totalentries", *r->out.totalentries);
02854 }
02855 ndr->depth--;
02856 ndr_print_ptr(ndr, "resume_handle", r->out.resume_handle);
02857 ndr->depth++;
02858 ndr_print_uint32(ndr, "resume_handle", *r->out.resume_handle);
02859 ndr->depth--;
02860 ndr_print_WERROR(ndr, "result", r->out.result);
02861 ndr->depth--;
02862 }
02863 ndr->depth--;
02864 }
02865
02866 NTSTATUS ndr_push_WKSSVC_NETRWKSTATRANSPORTADD(struct ndr_push *ndr, int flags, const struct WKSSVC_NETRWKSTATRANSPORTADD *r)
02867 {
02868 if (flags & NDR_IN) {
02869 }
02870 if (flags & NDR_OUT) {
02871 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
02872 }
02873 return NT_STATUS_OK;
02874 }
02875
02876 NTSTATUS ndr_pull_WKSSVC_NETRWKSTATRANSPORTADD(struct ndr_pull *ndr, int flags, struct WKSSVC_NETRWKSTATRANSPORTADD *r)
02877 {
02878 if (flags & NDR_IN) {
02879 }
02880 if (flags & NDR_OUT) {
02881 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
02882 }
02883 return NT_STATUS_OK;
02884 }
02885
02886 _PUBLIC_ void ndr_print_WKSSVC_NETRWKSTATRANSPORTADD(struct ndr_print *ndr, const char *name, int flags, const struct WKSSVC_NETRWKSTATRANSPORTADD *r)
02887 {
02888 ndr_print_struct(ndr, name, "WKSSVC_NETRWKSTATRANSPORTADD");
02889 ndr->depth++;
02890 if (flags & NDR_SET_VALUES) {
02891 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
02892 }
02893 if (flags & NDR_IN) {
02894 ndr_print_struct(ndr, "in", "WKSSVC_NETRWKSTATRANSPORTADD");
02895 ndr->depth++;
02896 ndr->depth--;
02897 }
02898 if (flags & NDR_OUT) {
02899 ndr_print_struct(ndr, "out", "WKSSVC_NETRWKSTATRANSPORTADD");
02900 ndr->depth++;
02901 ndr_print_WERROR(ndr, "result", r->out.result);
02902 ndr->depth--;
02903 }
02904 ndr->depth--;
02905 }
02906
02907 NTSTATUS ndr_push_WKSSVC_NETRWKSTATRANSPORTDEL(struct ndr_push *ndr, int flags, const struct WKSSVC_NETRWKSTATRANSPORTDEL *r)
02908 {
02909 if (flags & NDR_IN) {
02910 }
02911 if (flags & NDR_OUT) {
02912 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
02913 }
02914 return NT_STATUS_OK;
02915 }
02916
02917 NTSTATUS ndr_pull_WKSSVC_NETRWKSTATRANSPORTDEL(struct ndr_pull *ndr, int flags, struct WKSSVC_NETRWKSTATRANSPORTDEL *r)
02918 {
02919 if (flags & NDR_IN) {
02920 }
02921 if (flags & NDR_OUT) {
02922 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
02923 }
02924 return NT_STATUS_OK;
02925 }
02926
02927 _PUBLIC_ void ndr_print_WKSSVC_NETRWKSTATRANSPORTDEL(struct ndr_print *ndr, const char *name, int flags, const struct WKSSVC_NETRWKSTATRANSPORTDEL *r)
02928 {
02929 ndr_print_struct(ndr, name, "WKSSVC_NETRWKSTATRANSPORTDEL");
02930 ndr->depth++;
02931 if (flags & NDR_SET_VALUES) {
02932 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
02933 }
02934 if (flags & NDR_IN) {
02935 ndr_print_struct(ndr, "in", "WKSSVC_NETRWKSTATRANSPORTDEL");
02936 ndr->depth++;
02937 ndr->depth--;
02938 }
02939 if (flags & NDR_OUT) {
02940 ndr_print_struct(ndr, "out", "WKSSVC_NETRWKSTATRANSPORTDEL");
02941 ndr->depth++;
02942 ndr_print_WERROR(ndr, "result", r->out.result);
02943 ndr->depth--;
02944 }
02945 ndr->depth--;
02946 }
02947
02948 NTSTATUS ndr_push_WKSSVC_NETRUSEADD(struct ndr_push *ndr, int flags, const struct WKSSVC_NETRUSEADD *r)
02949 {
02950 if (flags & NDR_IN) {
02951 }
02952 if (flags & NDR_OUT) {
02953 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
02954 }
02955 return NT_STATUS_OK;
02956 }
02957
02958 NTSTATUS ndr_pull_WKSSVC_NETRUSEADD(struct ndr_pull *ndr, int flags, struct WKSSVC_NETRUSEADD *r)
02959 {
02960 if (flags & NDR_IN) {
02961 }
02962 if (flags & NDR_OUT) {
02963 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
02964 }
02965 return NT_STATUS_OK;
02966 }
02967
02968 _PUBLIC_ void ndr_print_WKSSVC_NETRUSEADD(struct ndr_print *ndr, const char *name, int flags, const struct WKSSVC_NETRUSEADD *r)
02969 {
02970 ndr_print_struct(ndr, name, "WKSSVC_NETRUSEADD");
02971 ndr->depth++;
02972 if (flags & NDR_SET_VALUES) {
02973 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
02974 }
02975 if (flags & NDR_IN) {
02976 ndr_print_struct(ndr, "in", "WKSSVC_NETRUSEADD");
02977 ndr->depth++;
02978 ndr->depth--;
02979 }
02980 if (flags & NDR_OUT) {
02981 ndr_print_struct(ndr, "out", "WKSSVC_NETRUSEADD");
02982 ndr->depth++;
02983 ndr_print_WERROR(ndr, "result", r->out.result);
02984 ndr->depth--;
02985 }
02986 ndr->depth--;
02987 }
02988
02989 NTSTATUS ndr_push_WKSSVC_NETRUSEGETINFO(struct ndr_push *ndr, int flags, const struct WKSSVC_NETRUSEGETINFO *r)
02990 {
02991 if (flags & NDR_IN) {
02992 }
02993 if (flags & NDR_OUT) {
02994 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
02995 }
02996 return NT_STATUS_OK;
02997 }
02998
02999 NTSTATUS ndr_pull_WKSSVC_NETRUSEGETINFO(struct ndr_pull *ndr, int flags, struct WKSSVC_NETRUSEGETINFO *r)
03000 {
03001 if (flags & NDR_IN) {
03002 }
03003 if (flags & NDR_OUT) {
03004 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
03005 }
03006 return NT_STATUS_OK;
03007 }
03008
03009 _PUBLIC_ void ndr_print_WKSSVC_NETRUSEGETINFO(struct ndr_print *ndr, const char *name, int flags, const struct WKSSVC_NETRUSEGETINFO *r)
03010 {
03011 ndr_print_struct(ndr, name, "WKSSVC_NETRUSEGETINFO");
03012 ndr->depth++;
03013 if (flags & NDR_SET_VALUES) {
03014 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
03015 }
03016 if (flags & NDR_IN) {
03017 ndr_print_struct(ndr, "in", "WKSSVC_NETRUSEGETINFO");
03018 ndr->depth++;
03019 ndr->depth--;
03020 }
03021 if (flags & NDR_OUT) {
03022 ndr_print_struct(ndr, "out", "WKSSVC_NETRUSEGETINFO");
03023 ndr->depth++;
03024 ndr_print_WERROR(ndr, "result", r->out.result);
03025 ndr->depth--;
03026 }
03027 ndr->depth--;
03028 }
03029
03030 NTSTATUS ndr_push_WKSSVC_NETRUSEDEL(struct ndr_push *ndr, int flags, const struct WKSSVC_NETRUSEDEL *r)
03031 {
03032 if (flags & NDR_IN) {
03033 }
03034 if (flags & NDR_OUT) {
03035 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
03036 }
03037 return NT_STATUS_OK;
03038 }
03039
03040 NTSTATUS ndr_pull_WKSSVC_NETRUSEDEL(struct ndr_pull *ndr, int flags, struct WKSSVC_NETRUSEDEL *r)
03041 {
03042 if (flags & NDR_IN) {
03043 }
03044 if (flags & NDR_OUT) {
03045 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
03046 }
03047 return NT_STATUS_OK;
03048 }
03049
03050 _PUBLIC_ void ndr_print_WKSSVC_NETRUSEDEL(struct ndr_print *ndr, const char *name, int flags, const struct WKSSVC_NETRUSEDEL *r)
03051 {
03052 ndr_print_struct(ndr, name, "WKSSVC_NETRUSEDEL");
03053 ndr->depth++;
03054 if (flags & NDR_SET_VALUES) {
03055 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
03056 }
03057 if (flags & NDR_IN) {
03058 ndr_print_struct(ndr, "in", "WKSSVC_NETRUSEDEL");
03059 ndr->depth++;
03060 ndr->depth--;
03061 }
03062 if (flags & NDR_OUT) {
03063 ndr_print_struct(ndr, "out", "WKSSVC_NETRUSEDEL");
03064 ndr->depth++;
03065 ndr_print_WERROR(ndr, "result", r->out.result);
03066 ndr->depth--;
03067 }
03068 ndr->depth--;
03069 }
03070
03071 NTSTATUS ndr_push_WKSSVC_NETRUSEENUM(struct ndr_push *ndr, int flags, const struct WKSSVC_NETRUSEENUM *r)
03072 {
03073 if (flags & NDR_IN) {
03074 }
03075 if (flags & NDR_OUT) {
03076 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
03077 }
03078 return NT_STATUS_OK;
03079 }
03080
03081 NTSTATUS ndr_pull_WKSSVC_NETRUSEENUM(struct ndr_pull *ndr, int flags, struct WKSSVC_NETRUSEENUM *r)
03082 {
03083 if (flags & NDR_IN) {
03084 }
03085 if (flags & NDR_OUT) {
03086 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
03087 }
03088 return NT_STATUS_OK;
03089 }
03090
03091 _PUBLIC_ void ndr_print_WKSSVC_NETRUSEENUM(struct ndr_print *ndr, const char *name, int flags, const struct WKSSVC_NETRUSEENUM *r)
03092 {
03093 ndr_print_struct(ndr, name, "WKSSVC_NETRUSEENUM");
03094 ndr->depth++;
03095 if (flags & NDR_SET_VALUES) {
03096 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
03097 }
03098 if (flags & NDR_IN) {
03099 ndr_print_struct(ndr, "in", "WKSSVC_NETRUSEENUM");
03100 ndr->depth++;
03101 ndr->depth--;
03102 }
03103 if (flags & NDR_OUT) {
03104 ndr_print_struct(ndr, "out", "WKSSVC_NETRUSEENUM");
03105 ndr->depth++;
03106 ndr_print_WERROR(ndr, "result", r->out.result);
03107 ndr->depth--;
03108 }
03109 ndr->depth--;
03110 }
03111
03112 NTSTATUS ndr_push_WKSSVC_NETRMESSAGEBUFFERSEND(struct ndr_push *ndr, int flags, const struct WKSSVC_NETRMESSAGEBUFFERSEND *r)
03113 {
03114 if (flags & NDR_IN) {
03115 }
03116 if (flags & NDR_OUT) {
03117 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
03118 }
03119 return NT_STATUS_OK;
03120 }
03121
03122 NTSTATUS ndr_pull_WKSSVC_NETRMESSAGEBUFFERSEND(struct ndr_pull *ndr, int flags, struct WKSSVC_NETRMESSAGEBUFFERSEND *r)
03123 {
03124 if (flags & NDR_IN) {
03125 }
03126 if (flags & NDR_OUT) {
03127 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
03128 }
03129 return NT_STATUS_OK;
03130 }
03131
03132 _PUBLIC_ void ndr_print_WKSSVC_NETRMESSAGEBUFFERSEND(struct ndr_print *ndr, const char *name, int flags, const struct WKSSVC_NETRMESSAGEBUFFERSEND *r)
03133 {
03134 ndr_print_struct(ndr, name, "WKSSVC_NETRMESSAGEBUFFERSEND");
03135 ndr->depth++;
03136 if (flags & NDR_SET_VALUES) {
03137 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
03138 }
03139 if (flags & NDR_IN) {
03140 ndr_print_struct(ndr, "in", "WKSSVC_NETRMESSAGEBUFFERSEND");
03141 ndr->depth++;
03142 ndr->depth--;
03143 }
03144 if (flags & NDR_OUT) {
03145 ndr_print_struct(ndr, "out", "WKSSVC_NETRMESSAGEBUFFERSEND");
03146 ndr->depth++;
03147 ndr_print_WERROR(ndr, "result", r->out.result);
03148 ndr->depth--;
03149 }
03150 ndr->depth--;
03151 }
03152
03153 NTSTATUS ndr_push_WKSSVC_NETRWORKSTATIONSTATISTICSGET(struct ndr_push *ndr, int flags, const struct WKSSVC_NETRWORKSTATIONSTATISTICSGET *r)
03154 {
03155 if (flags & NDR_IN) {
03156 }
03157 if (flags & NDR_OUT) {
03158 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
03159 }
03160 return NT_STATUS_OK;
03161 }
03162
03163 NTSTATUS ndr_pull_WKSSVC_NETRWORKSTATIONSTATISTICSGET(struct ndr_pull *ndr, int flags, struct WKSSVC_NETRWORKSTATIONSTATISTICSGET *r)
03164 {
03165 if (flags & NDR_IN) {
03166 }
03167 if (flags & NDR_OUT) {
03168 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
03169 }
03170 return NT_STATUS_OK;
03171 }
03172
03173 _PUBLIC_ void ndr_print_WKSSVC_NETRWORKSTATIONSTATISTICSGET(struct ndr_print *ndr, const char *name, int flags, const struct WKSSVC_NETRWORKSTATIONSTATISTICSGET *r)
03174 {
03175 ndr_print_struct(ndr, name, "WKSSVC_NETRWORKSTATIONSTATISTICSGET");
03176 ndr->depth++;
03177 if (flags & NDR_SET_VALUES) {
03178 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
03179 }
03180 if (flags & NDR_IN) {
03181 ndr_print_struct(ndr, "in", "WKSSVC_NETRWORKSTATIONSTATISTICSGET");
03182 ndr->depth++;
03183 ndr->depth--;
03184 }
03185 if (flags & NDR_OUT) {
03186 ndr_print_struct(ndr, "out", "WKSSVC_NETRWORKSTATIONSTATISTICSGET");
03187 ndr->depth++;
03188 ndr_print_WERROR(ndr, "result", r->out.result);
03189 ndr->depth--;
03190 }
03191 ndr->depth--;
03192 }
03193
03194 NTSTATUS ndr_push_WKSSVC_NETRLOGONDOMAINNAMEADD(struct ndr_push *ndr, int flags, const struct WKSSVC_NETRLOGONDOMAINNAMEADD *r)
03195 {
03196 if (flags & NDR_IN) {
03197 }
03198 if (flags & NDR_OUT) {
03199 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
03200 }
03201 return NT_STATUS_OK;
03202 }
03203
03204 NTSTATUS ndr_pull_WKSSVC_NETRLOGONDOMAINNAMEADD(struct ndr_pull *ndr, int flags, struct WKSSVC_NETRLOGONDOMAINNAMEADD *r)
03205 {
03206 if (flags & NDR_IN) {
03207 }
03208 if (flags & NDR_OUT) {
03209 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
03210 }
03211 return NT_STATUS_OK;
03212 }
03213
03214 _PUBLIC_ void ndr_print_WKSSVC_NETRLOGONDOMAINNAMEADD(struct ndr_print *ndr, const char *name, int flags, const struct WKSSVC_NETRLOGONDOMAINNAMEADD *r)
03215 {
03216 ndr_print_struct(ndr, name, "WKSSVC_NETRLOGONDOMAINNAMEADD");
03217 ndr->depth++;
03218 if (flags & NDR_SET_VALUES) {
03219 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
03220 }
03221 if (flags & NDR_IN) {
03222 ndr_print_struct(ndr, "in", "WKSSVC_NETRLOGONDOMAINNAMEADD");
03223 ndr->depth++;
03224 ndr->depth--;
03225 }
03226 if (flags & NDR_OUT) {
03227 ndr_print_struct(ndr, "out", "WKSSVC_NETRLOGONDOMAINNAMEADD");
03228 ndr->depth++;
03229 ndr_print_WERROR(ndr, "result", r->out.result);
03230 ndr->depth--;
03231 }
03232 ndr->depth--;
03233 }
03234
03235 NTSTATUS ndr_push_WKSSVC_NETRLOGONDOMAINNAMEDEL(struct ndr_push *ndr, int flags, const struct WKSSVC_NETRLOGONDOMAINNAMEDEL *r)
03236 {
03237 if (flags & NDR_IN) {
03238 }
03239 if (flags & NDR_OUT) {
03240 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
03241 }
03242 return NT_STATUS_OK;
03243 }
03244
03245 NTSTATUS ndr_pull_WKSSVC_NETRLOGONDOMAINNAMEDEL(struct ndr_pull *ndr, int flags, struct WKSSVC_NETRLOGONDOMAINNAMEDEL *r)
03246 {
03247 if (flags & NDR_IN) {
03248 }
03249 if (flags & NDR_OUT) {
03250 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
03251 }
03252 return NT_STATUS_OK;
03253 }
03254
03255 _PUBLIC_ void ndr_print_WKSSVC_NETRLOGONDOMAINNAMEDEL(struct ndr_print *ndr, const char *name, int flags, const struct WKSSVC_NETRLOGONDOMAINNAMEDEL *r)
03256 {
03257 ndr_print_struct(ndr, name, "WKSSVC_NETRLOGONDOMAINNAMEDEL");
03258 ndr->depth++;
03259 if (flags & NDR_SET_VALUES) {
03260 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
03261 }
03262 if (flags & NDR_IN) {
03263 ndr_print_struct(ndr, "in", "WKSSVC_NETRLOGONDOMAINNAMEDEL");
03264 ndr->depth++;
03265 ndr->depth--;
03266 }
03267 if (flags & NDR_OUT) {
03268 ndr_print_struct(ndr, "out", "WKSSVC_NETRLOGONDOMAINNAMEDEL");
03269 ndr->depth++;
03270 ndr_print_WERROR(ndr, "result", r->out.result);
03271 ndr->depth--;
03272 }
03273 ndr->depth--;
03274 }
03275
03276 NTSTATUS ndr_push_WKSSVC_NETRJOINDOMAIN(struct ndr_push *ndr, int flags, const struct WKSSVC_NETRJOINDOMAIN *r)
03277 {
03278 if (flags & NDR_IN) {
03279 }
03280 if (flags & NDR_OUT) {
03281 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
03282 }
03283 return NT_STATUS_OK;
03284 }
03285
03286 NTSTATUS ndr_pull_WKSSVC_NETRJOINDOMAIN(struct ndr_pull *ndr, int flags, struct WKSSVC_NETRJOINDOMAIN *r)
03287 {
03288 if (flags & NDR_IN) {
03289 }
03290 if (flags & NDR_OUT) {
03291 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
03292 }
03293 return NT_STATUS_OK;
03294 }
03295
03296 _PUBLIC_ void ndr_print_WKSSVC_NETRJOINDOMAIN(struct ndr_print *ndr, const char *name, int flags, const struct WKSSVC_NETRJOINDOMAIN *r)
03297 {
03298 ndr_print_struct(ndr, name, "WKSSVC_NETRJOINDOMAIN");
03299 ndr->depth++;
03300 if (flags & NDR_SET_VALUES) {
03301 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
03302 }
03303 if (flags & NDR_IN) {
03304 ndr_print_struct(ndr, "in", "WKSSVC_NETRJOINDOMAIN");
03305 ndr->depth++;
03306 ndr->depth--;
03307 }
03308 if (flags & NDR_OUT) {
03309 ndr_print_struct(ndr, "out", "WKSSVC_NETRJOINDOMAIN");
03310 ndr->depth++;
03311 ndr_print_WERROR(ndr, "result", r->out.result);
03312 ndr->depth--;
03313 }
03314 ndr->depth--;
03315 }
03316
03317 NTSTATUS ndr_push_WKSSVC_NETRUNJOINDOMAIN(struct ndr_push *ndr, int flags, const struct WKSSVC_NETRUNJOINDOMAIN *r)
03318 {
03319 if (flags & NDR_IN) {
03320 }
03321 if (flags & NDR_OUT) {
03322 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
03323 }
03324 return NT_STATUS_OK;
03325 }
03326
03327 NTSTATUS ndr_pull_WKSSVC_NETRUNJOINDOMAIN(struct ndr_pull *ndr, int flags, struct WKSSVC_NETRUNJOINDOMAIN *r)
03328 {
03329 if (flags & NDR_IN) {
03330 }
03331 if (flags & NDR_OUT) {
03332 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
03333 }
03334 return NT_STATUS_OK;
03335 }
03336
03337 _PUBLIC_ void ndr_print_WKSSVC_NETRUNJOINDOMAIN(struct ndr_print *ndr, const char *name, int flags, const struct WKSSVC_NETRUNJOINDOMAIN *r)
03338 {
03339 ndr_print_struct(ndr, name, "WKSSVC_NETRUNJOINDOMAIN");
03340 ndr->depth++;
03341 if (flags & NDR_SET_VALUES) {
03342 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
03343 }
03344 if (flags & NDR_IN) {
03345 ndr_print_struct(ndr, "in", "WKSSVC_NETRUNJOINDOMAIN");
03346 ndr->depth++;
03347 ndr->depth--;
03348 }
03349 if (flags & NDR_OUT) {
03350 ndr_print_struct(ndr, "out", "WKSSVC_NETRUNJOINDOMAIN");
03351 ndr->depth++;
03352 ndr_print_WERROR(ndr, "result", r->out.result);
03353 ndr->depth--;
03354 }
03355 ndr->depth--;
03356 }
03357
03358 NTSTATUS ndr_push_WKSSVC_NETRRENAMEMACHINEINDOMAIN(struct ndr_push *ndr, int flags, const struct WKSSVC_NETRRENAMEMACHINEINDOMAIN *r)
03359 {
03360 if (flags & NDR_IN) {
03361 }
03362 if (flags & NDR_OUT) {
03363 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
03364 }
03365 return NT_STATUS_OK;
03366 }
03367
03368 NTSTATUS ndr_pull_WKSSVC_NETRRENAMEMACHINEINDOMAIN(struct ndr_pull *ndr, int flags, struct WKSSVC_NETRRENAMEMACHINEINDOMAIN *r)
03369 {
03370 if (flags & NDR_IN) {
03371 }
03372 if (flags & NDR_OUT) {
03373 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
03374 }
03375 return NT_STATUS_OK;
03376 }
03377
03378 _PUBLIC_ void ndr_print_WKSSVC_NETRRENAMEMACHINEINDOMAIN(struct ndr_print *ndr, const char *name, int flags, const struct WKSSVC_NETRRENAMEMACHINEINDOMAIN *r)
03379 {
03380 ndr_print_struct(ndr, name, "WKSSVC_NETRRENAMEMACHINEINDOMAIN");
03381 ndr->depth++;
03382 if (flags & NDR_SET_VALUES) {
03383 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
03384 }
03385 if (flags & NDR_IN) {
03386 ndr_print_struct(ndr, "in", "WKSSVC_NETRRENAMEMACHINEINDOMAIN");
03387 ndr->depth++;
03388 ndr->depth--;
03389 }
03390 if (flags & NDR_OUT) {
03391 ndr_print_struct(ndr, "out", "WKSSVC_NETRRENAMEMACHINEINDOMAIN");
03392 ndr->depth++;
03393 ndr_print_WERROR(ndr, "result", r->out.result);
03394 ndr->depth--;
03395 }
03396 ndr->depth--;
03397 }
03398
03399 NTSTATUS ndr_push_WKSSVC_NETRVALIDATENAME(struct ndr_push *ndr, int flags, const struct WKSSVC_NETRVALIDATENAME *r)
03400 {
03401 if (flags & NDR_IN) {
03402 }
03403 if (flags & NDR_OUT) {
03404 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
03405 }
03406 return NT_STATUS_OK;
03407 }
03408
03409 NTSTATUS ndr_pull_WKSSVC_NETRVALIDATENAME(struct ndr_pull *ndr, int flags, struct WKSSVC_NETRVALIDATENAME *r)
03410 {
03411 if (flags & NDR_IN) {
03412 }
03413 if (flags & NDR_OUT) {
03414 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
03415 }
03416 return NT_STATUS_OK;
03417 }
03418
03419 _PUBLIC_ void ndr_print_WKSSVC_NETRVALIDATENAME(struct ndr_print *ndr, const char *name, int flags, const struct WKSSVC_NETRVALIDATENAME *r)
03420 {
03421 ndr_print_struct(ndr, name, "WKSSVC_NETRVALIDATENAME");
03422 ndr->depth++;
03423 if (flags & NDR_SET_VALUES) {
03424 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
03425 }
03426 if (flags & NDR_IN) {
03427 ndr_print_struct(ndr, "in", "WKSSVC_NETRVALIDATENAME");
03428 ndr->depth++;
03429 ndr->depth--;
03430 }
03431 if (flags & NDR_OUT) {
03432 ndr_print_struct(ndr, "out", "WKSSVC_NETRVALIDATENAME");
03433 ndr->depth++;
03434 ndr_print_WERROR(ndr, "result", r->out.result);
03435 ndr->depth--;
03436 }
03437 ndr->depth--;
03438 }
03439
03440 NTSTATUS ndr_push_WKSSVC_NETRGETJOININFORMATION(struct ndr_push *ndr, int flags, const struct WKSSVC_NETRGETJOININFORMATION *r)
03441 {
03442 if (flags & NDR_IN) {
03443 }
03444 if (flags & NDR_OUT) {
03445 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
03446 }
03447 return NT_STATUS_OK;
03448 }
03449
03450 NTSTATUS ndr_pull_WKSSVC_NETRGETJOININFORMATION(struct ndr_pull *ndr, int flags, struct WKSSVC_NETRGETJOININFORMATION *r)
03451 {
03452 if (flags & NDR_IN) {
03453 }
03454 if (flags & NDR_OUT) {
03455 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
03456 }
03457 return NT_STATUS_OK;
03458 }
03459
03460 _PUBLIC_ void ndr_print_WKSSVC_NETRGETJOININFORMATION(struct ndr_print *ndr, const char *name, int flags, const struct WKSSVC_NETRGETJOININFORMATION *r)
03461 {
03462 ndr_print_struct(ndr, name, "WKSSVC_NETRGETJOININFORMATION");
03463 ndr->depth++;
03464 if (flags & NDR_SET_VALUES) {
03465 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
03466 }
03467 if (flags & NDR_IN) {
03468 ndr_print_struct(ndr, "in", "WKSSVC_NETRGETJOININFORMATION");
03469 ndr->depth++;
03470 ndr->depth--;
03471 }
03472 if (flags & NDR_OUT) {
03473 ndr_print_struct(ndr, "out", "WKSSVC_NETRGETJOININFORMATION");
03474 ndr->depth++;
03475 ndr_print_WERROR(ndr, "result", r->out.result);
03476 ndr->depth--;
03477 }
03478 ndr->depth--;
03479 }
03480
03481 NTSTATUS ndr_push_WKSSVC_NETRGETJOINABLEOUS(struct ndr_push *ndr, int flags, const struct WKSSVC_NETRGETJOINABLEOUS *r)
03482 {
03483 if (flags & NDR_IN) {
03484 }
03485 if (flags & NDR_OUT) {
03486 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
03487 }
03488 return NT_STATUS_OK;
03489 }
03490
03491 NTSTATUS ndr_pull_WKSSVC_NETRGETJOINABLEOUS(struct ndr_pull *ndr, int flags, struct WKSSVC_NETRGETJOINABLEOUS *r)
03492 {
03493 if (flags & NDR_IN) {
03494 }
03495 if (flags & NDR_OUT) {
03496 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
03497 }
03498 return NT_STATUS_OK;
03499 }
03500
03501 _PUBLIC_ void ndr_print_WKSSVC_NETRGETJOINABLEOUS(struct ndr_print *ndr, const char *name, int flags, const struct WKSSVC_NETRGETJOINABLEOUS *r)
03502 {
03503 ndr_print_struct(ndr, name, "WKSSVC_NETRGETJOINABLEOUS");
03504 ndr->depth++;
03505 if (flags & NDR_SET_VALUES) {
03506 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
03507 }
03508 if (flags & NDR_IN) {
03509 ndr_print_struct(ndr, "in", "WKSSVC_NETRGETJOINABLEOUS");
03510 ndr->depth++;
03511 ndr->depth--;
03512 }
03513 if (flags & NDR_OUT) {
03514 ndr_print_struct(ndr, "out", "WKSSVC_NETRGETJOINABLEOUS");
03515 ndr->depth++;
03516 ndr_print_WERROR(ndr, "result", r->out.result);
03517 ndr->depth--;
03518 }
03519 ndr->depth--;
03520 }
03521
03522 NTSTATUS ndr_push_wkssvc_NetrJoinDomain2(struct ndr_push *ndr, int flags, const struct wkssvc_NetrJoinDomain2 *r)
03523 {
03524 if (flags & NDR_IN) {
03525 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server_name));
03526 if (r->in.server_name) {
03527 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
03528 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
03529 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
03530 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));
03531 }
03532 if (r->in.domain_name == NULL) return NT_STATUS_INVALID_PARAMETER_MIX;
03533 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.domain_name, CH_UTF16)));
03534 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
03535 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.domain_name, CH_UTF16)));
03536 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));
03537 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.account_name));
03538 if (r->in.account_name) {
03539 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.account_name, CH_UTF16)));
03540 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
03541 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.account_name, CH_UTF16)));
03542 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.account_name, ndr_charset_length(r->in.account_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
03543 }
03544 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.admin_account));
03545 if (r->in.admin_account) {
03546 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.admin_account, CH_UTF16)));
03547 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
03548 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.admin_account, CH_UTF16)));
03549 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));
03550 }
03551 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.encrypted_password));
03552 if (r->in.encrypted_password) {
03553 NDR_CHECK(ndr_push_wkssvc_PasswordBuffer(ndr, NDR_SCALARS, r->in.encrypted_password));
03554 }
03555 NDR_CHECK(ndr_push_wkssvc_joinflags(ndr, NDR_SCALARS, r->in.join_flags));
03556 }
03557 if (flags & NDR_OUT) {
03558 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
03559 }
03560 return NT_STATUS_OK;
03561 }
03562
03563 NTSTATUS ndr_pull_wkssvc_NetrJoinDomain2(struct ndr_pull *ndr, int flags, struct wkssvc_NetrJoinDomain2 *r)
03564 {
03565 uint32_t _ptr_server_name;
03566 uint32_t _ptr_account_name;
03567 uint32_t _ptr_admin_account;
03568 uint32_t _ptr_encrypted_password;
03569 TALLOC_CTX *_mem_save_server_name_0;
03570 TALLOC_CTX *_mem_save_account_name_0;
03571 TALLOC_CTX *_mem_save_admin_account_0;
03572 TALLOC_CTX *_mem_save_encrypted_password_0;
03573 if (flags & NDR_IN) {
03574 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_name));
03575 if (_ptr_server_name) {
03576 NDR_PULL_ALLOC(ndr, r->in.server_name);
03577 } else {
03578 r->in.server_name = NULL;
03579 }
03580 if (r->in.server_name) {
03581 _mem_save_server_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
03582 NDR_PULL_SET_MEM_CTX(ndr, r->in.server_name, 0);
03583 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_name));
03584 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_name));
03585 if (ndr_get_array_length(ndr, &r->in.server_name) > ndr_get_array_size(ndr, &r->in.server_name)) {
03586 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));
03587 }
03588 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server_name), sizeof(uint16_t)));
03589 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));
03590 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_name_0, 0);
03591 }
03592 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.domain_name));
03593 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.domain_name));
03594 if (ndr_get_array_length(ndr, &r->in.domain_name) > ndr_get_array_size(ndr, &r->in.domain_name)) {
03595 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));
03596 }
03597 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.domain_name), sizeof(uint16_t)));
03598 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));
03599 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_account_name));
03600 if (_ptr_account_name) {
03601 NDR_PULL_ALLOC(ndr, r->in.account_name);
03602 } else {
03603 r->in.account_name = NULL;
03604 }
03605 if (r->in.account_name) {
03606 _mem_save_account_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
03607 NDR_PULL_SET_MEM_CTX(ndr, r->in.account_name, 0);
03608 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.account_name));
03609 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.account_name));
03610 if (ndr_get_array_length(ndr, &r->in.account_name) > ndr_get_array_size(ndr, &r->in.account_name)) {
03611 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_name), ndr_get_array_length(ndr, &r->in.account_name));
03612 }
03613 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.account_name), sizeof(uint16_t)));
03614 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.account_name, ndr_get_array_length(ndr, &r->in.account_name), sizeof(uint16_t), CH_UTF16));
03615 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_account_name_0, 0);
03616 }
03617 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_admin_account));
03618 if (_ptr_admin_account) {
03619 NDR_PULL_ALLOC(ndr, r->in.admin_account);
03620 } else {
03621 r->in.admin_account = NULL;
03622 }
03623 if (r->in.admin_account) {
03624 _mem_save_admin_account_0 = NDR_PULL_GET_MEM_CTX(ndr);
03625 NDR_PULL_SET_MEM_CTX(ndr, r->in.admin_account, 0);
03626 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.admin_account));
03627 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.admin_account));
03628 if (ndr_get_array_length(ndr, &r->in.admin_account) > ndr_get_array_size(ndr, &r->in.admin_account)) {
03629 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));
03630 }
03631 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.admin_account), sizeof(uint16_t)));
03632 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));
03633 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_admin_account_0, 0);
03634 }
03635 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_encrypted_password));
03636 if (_ptr_encrypted_password) {
03637 NDR_PULL_ALLOC(ndr, r->in.encrypted_password);
03638 } else {
03639 r->in.encrypted_password = NULL;
03640 }
03641 if (r->in.encrypted_password) {
03642 _mem_save_encrypted_password_0 = NDR_PULL_GET_MEM_CTX(ndr);
03643 NDR_PULL_SET_MEM_CTX(ndr, r->in.encrypted_password, 0);
03644 NDR_CHECK(ndr_pull_wkssvc_PasswordBuffer(ndr, NDR_SCALARS, r->in.encrypted_password));
03645 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_encrypted_password_0, 0);
03646 }
03647 NDR_CHECK(ndr_pull_wkssvc_joinflags(ndr, NDR_SCALARS, &r->in.join_flags));
03648 }
03649 if (flags & NDR_OUT) {
03650 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
03651 }
03652 return NT_STATUS_OK;
03653 }
03654
03655 _PUBLIC_ void ndr_print_wkssvc_NetrJoinDomain2(struct ndr_print *ndr, const char *name, int flags, const struct wkssvc_NetrJoinDomain2 *r)
03656 {
03657 ndr_print_struct(ndr, name, "wkssvc_NetrJoinDomain2");
03658 ndr->depth++;
03659 if (flags & NDR_SET_VALUES) {
03660 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
03661 }
03662 if (flags & NDR_IN) {
03663 ndr_print_struct(ndr, "in", "wkssvc_NetrJoinDomain2");
03664 ndr->depth++;
03665 ndr_print_ptr(ndr, "server_name", r->in.server_name);
03666 ndr->depth++;
03667 if (r->in.server_name) {
03668 ndr_print_string(ndr, "server_name", r->in.server_name);
03669 }
03670 ndr->depth--;
03671 ndr_print_ptr(ndr, "domain_name", r->in.domain_name);
03672 ndr->depth++;
03673 ndr_print_string(ndr, "domain_name", r->in.domain_name);
03674 ndr->depth--;
03675 ndr_print_ptr(ndr, "account_name", r->in.account_name);
03676 ndr->depth++;
03677 if (r->in.account_name) {
03678 ndr_print_string(ndr, "account_name", r->in.account_name);
03679 }
03680 ndr->depth--;
03681 ndr_print_ptr(ndr, "admin_account", r->in.admin_account);
03682 ndr->depth++;
03683 if (r->in.admin_account) {
03684 ndr_print_string(ndr, "admin_account", r->in.admin_account);
03685 }
03686 ndr->depth--;
03687 ndr_print_ptr(ndr, "encrypted_password", r->in.encrypted_password);
03688 ndr->depth++;
03689 if (r->in.encrypted_password) {
03690 ndr_print_wkssvc_PasswordBuffer(ndr, "encrypted_password", r->in.encrypted_password);
03691 }
03692 ndr->depth--;
03693 ndr_print_wkssvc_joinflags(ndr, "join_flags", r->in.join_flags);
03694 ndr->depth--;
03695 }
03696 if (flags & NDR_OUT) {
03697 ndr_print_struct(ndr, "out", "wkssvc_NetrJoinDomain2");
03698 ndr->depth++;
03699 ndr_print_WERROR(ndr, "result", r->out.result);
03700 ndr->depth--;
03701 }
03702 ndr->depth--;
03703 }
03704
03705 NTSTATUS ndr_push_wkssvc_NetrUnjoinDomain2(struct ndr_push *ndr, int flags, const struct wkssvc_NetrUnjoinDomain2 *r)
03706 {
03707 if (flags & NDR_IN) {
03708 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server_name));
03709 if (r->in.server_name) {
03710 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
03711 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
03712 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
03713 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));
03714 }
03715 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.account));
03716 if (r->in.account) {
03717 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.account, CH_UTF16)));
03718 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
03719 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.account, CH_UTF16)));
03720 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.account, ndr_charset_length(r->in.account, CH_UTF16), sizeof(uint16_t), CH_UTF16));
03721 }
03722 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.encrypted_password));
03723 if (r->in.encrypted_password) {
03724 NDR_CHECK(ndr_push_wkssvc_PasswordBuffer(ndr, NDR_SCALARS, r->in.encrypted_password));
03725 }
03726 NDR_CHECK(ndr_push_wkssvc_joinflags(ndr, NDR_SCALARS, r->in.unjoin_flags));
03727 }
03728 if (flags & NDR_OUT) {
03729 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
03730 }
03731 return NT_STATUS_OK;
03732 }
03733
03734 NTSTATUS ndr_pull_wkssvc_NetrUnjoinDomain2(struct ndr_pull *ndr, int flags, struct wkssvc_NetrUnjoinDomain2 *r)
03735 {
03736 uint32_t _ptr_server_name;
03737 uint32_t _ptr_account;
03738 uint32_t _ptr_encrypted_password;
03739 TALLOC_CTX *_mem_save_server_name_0;
03740 TALLOC_CTX *_mem_save_account_0;
03741 TALLOC_CTX *_mem_save_encrypted_password_0;
03742 if (flags & NDR_IN) {
03743 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_name));
03744 if (_ptr_server_name) {
03745 NDR_PULL_ALLOC(ndr, r->in.server_name);
03746 } else {
03747 r->in.server_name = NULL;
03748 }
03749 if (r->in.server_name) {
03750 _mem_save_server_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
03751 NDR_PULL_SET_MEM_CTX(ndr, r->in.server_name, 0);
03752 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_name));
03753 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_name));
03754 if (ndr_get_array_length(ndr, &r->in.server_name) > ndr_get_array_size(ndr, &r->in.server_name)) {
03755 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));
03756 }
03757 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server_name), sizeof(uint16_t)));
03758 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));
03759 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_name_0, 0);
03760 }
03761 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_account));
03762 if (_ptr_account) {
03763 NDR_PULL_ALLOC(ndr, r->in.account);
03764 } else {
03765 r->in.account = NULL;
03766 }
03767 if (r->in.account) {
03768 _mem_save_account_0 = NDR_PULL_GET_MEM_CTX(ndr);
03769 NDR_PULL_SET_MEM_CTX(ndr, r->in.account, 0);
03770 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.account));
03771 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.account));
03772 if (ndr_get_array_length(ndr, &r->in.account) > ndr_get_array_size(ndr, &r->in.account)) {
03773 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));
03774 }
03775 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.account), sizeof(uint16_t)));
03776 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.account, ndr_get_array_length(ndr, &r->in.account), sizeof(uint16_t), CH_UTF16));
03777 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_account_0, 0);
03778 }
03779 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_encrypted_password));
03780 if (_ptr_encrypted_password) {
03781 NDR_PULL_ALLOC(ndr, r->in.encrypted_password);
03782 } else {
03783 r->in.encrypted_password = NULL;
03784 }
03785 if (r->in.encrypted_password) {
03786 _mem_save_encrypted_password_0 = NDR_PULL_GET_MEM_CTX(ndr);
03787 NDR_PULL_SET_MEM_CTX(ndr, r->in.encrypted_password, 0);
03788 NDR_CHECK(ndr_pull_wkssvc_PasswordBuffer(ndr, NDR_SCALARS, r->in.encrypted_password));
03789 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_encrypted_password_0, 0);
03790 }
03791 NDR_CHECK(ndr_pull_wkssvc_joinflags(ndr, NDR_SCALARS, &r->in.unjoin_flags));
03792 }
03793 if (flags & NDR_OUT) {
03794 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
03795 }
03796 return NT_STATUS_OK;
03797 }
03798
03799 _PUBLIC_ void ndr_print_wkssvc_NetrUnjoinDomain2(struct ndr_print *ndr, const char *name, int flags, const struct wkssvc_NetrUnjoinDomain2 *r)
03800 {
03801 ndr_print_struct(ndr, name, "wkssvc_NetrUnjoinDomain2");
03802 ndr->depth++;
03803 if (flags & NDR_SET_VALUES) {
03804 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
03805 }
03806 if (flags & NDR_IN) {
03807 ndr_print_struct(ndr, "in", "wkssvc_NetrUnjoinDomain2");
03808 ndr->depth++;
03809 ndr_print_ptr(ndr, "server_name", r->in.server_name);
03810 ndr->depth++;
03811 if (r->in.server_name) {
03812 ndr_print_string(ndr, "server_name", r->in.server_name);
03813 }
03814 ndr->depth--;
03815 ndr_print_ptr(ndr, "account", r->in.account);
03816 ndr->depth++;
03817 if (r->in.account) {
03818 ndr_print_string(ndr, "account", r->in.account);
03819 }
03820 ndr->depth--;
03821 ndr_print_ptr(ndr, "encrypted_password", r->in.encrypted_password);
03822 ndr->depth++;
03823 if (r->in.encrypted_password) {
03824 ndr_print_wkssvc_PasswordBuffer(ndr, "encrypted_password", r->in.encrypted_password);
03825 }
03826 ndr->depth--;
03827 ndr_print_wkssvc_joinflags(ndr, "unjoin_flags", r->in.unjoin_flags);
03828 ndr->depth--;
03829 }
03830 if (flags & NDR_OUT) {
03831 ndr_print_struct(ndr, "out", "wkssvc_NetrUnjoinDomain2");
03832 ndr->depth++;
03833 ndr_print_WERROR(ndr, "result", r->out.result);
03834 ndr->depth--;
03835 }
03836 ndr->depth--;
03837 }
03838
03839 NTSTATUS ndr_push_wkssvc_NetrRenameMachineInDomain2(struct ndr_push *ndr, int flags, const struct wkssvc_NetrRenameMachineInDomain2 *r)
03840 {
03841 if (flags & NDR_IN) {
03842 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server_name));
03843 if (r->in.server_name) {
03844 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
03845 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
03846 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
03847 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));
03848 }
03849 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.NewMachineName));
03850 if (r->in.NewMachineName) {
03851 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.NewMachineName, CH_UTF16)));
03852 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
03853 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.NewMachineName, CH_UTF16)));
03854 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.NewMachineName, ndr_charset_length(r->in.NewMachineName, CH_UTF16), sizeof(uint16_t), CH_UTF16));
03855 }
03856 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.Account));
03857 if (r->in.Account) {
03858 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.Account, CH_UTF16)));
03859 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
03860 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.Account, CH_UTF16)));
03861 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.Account, ndr_charset_length(r->in.Account, CH_UTF16), sizeof(uint16_t), CH_UTF16));
03862 }
03863 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.EncryptedPassword));
03864 if (r->in.EncryptedPassword) {
03865 NDR_CHECK(ndr_push_wkssvc_PasswordBuffer(ndr, NDR_SCALARS, r->in.EncryptedPassword));
03866 }
03867 NDR_CHECK(ndr_push_wkssvc_renameflags(ndr, NDR_SCALARS, r->in.RenameOptions));
03868 }
03869 if (flags & NDR_OUT) {
03870 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
03871 }
03872 return NT_STATUS_OK;
03873 }
03874
03875 NTSTATUS ndr_pull_wkssvc_NetrRenameMachineInDomain2(struct ndr_pull *ndr, int flags, struct wkssvc_NetrRenameMachineInDomain2 *r)
03876 {
03877 uint32_t _ptr_server_name;
03878 uint32_t _ptr_NewMachineName;
03879 uint32_t _ptr_Account;
03880 uint32_t _ptr_EncryptedPassword;
03881 TALLOC_CTX *_mem_save_server_name_0;
03882 TALLOC_CTX *_mem_save_NewMachineName_0;
03883 TALLOC_CTX *_mem_save_Account_0;
03884 TALLOC_CTX *_mem_save_EncryptedPassword_0;
03885 if (flags & NDR_IN) {
03886 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_name));
03887 if (_ptr_server_name) {
03888 NDR_PULL_ALLOC(ndr, r->in.server_name);
03889 } else {
03890 r->in.server_name = NULL;
03891 }
03892 if (r->in.server_name) {
03893 _mem_save_server_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
03894 NDR_PULL_SET_MEM_CTX(ndr, r->in.server_name, 0);
03895 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_name));
03896 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_name));
03897 if (ndr_get_array_length(ndr, &r->in.server_name) > ndr_get_array_size(ndr, &r->in.server_name)) {
03898 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));
03899 }
03900 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server_name), sizeof(uint16_t)));
03901 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));
03902 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_name_0, 0);
03903 }
03904 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_NewMachineName));
03905 if (_ptr_NewMachineName) {
03906 NDR_PULL_ALLOC(ndr, r->in.NewMachineName);
03907 } else {
03908 r->in.NewMachineName = NULL;
03909 }
03910 if (r->in.NewMachineName) {
03911 _mem_save_NewMachineName_0 = NDR_PULL_GET_MEM_CTX(ndr);
03912 NDR_PULL_SET_MEM_CTX(ndr, r->in.NewMachineName, 0);
03913 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.NewMachineName));
03914 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.NewMachineName));
03915 if (ndr_get_array_length(ndr, &r->in.NewMachineName) > ndr_get_array_size(ndr, &r->in.NewMachineName)) {
03916 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));
03917 }
03918 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.NewMachineName), sizeof(uint16_t)));
03919 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.NewMachineName, ndr_get_array_length(ndr, &r->in.NewMachineName), sizeof(uint16_t), CH_UTF16));
03920 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_NewMachineName_0, 0);
03921 }
03922 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_Account));
03923 if (_ptr_Account) {
03924 NDR_PULL_ALLOC(ndr, r->in.Account);
03925 } else {
03926 r->in.Account = NULL;
03927 }
03928 if (r->in.Account) {
03929 _mem_save_Account_0 = NDR_PULL_GET_MEM_CTX(ndr);
03930 NDR_PULL_SET_MEM_CTX(ndr, r->in.Account, 0);
03931 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.Account));
03932 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.Account));
03933 if (ndr_get_array_length(ndr, &r->in.Account) > ndr_get_array_size(ndr, &r->in.Account)) {
03934 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));
03935 }
03936 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.Account), sizeof(uint16_t)));
03937 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.Account, ndr_get_array_length(ndr, &r->in.Account), sizeof(uint16_t), CH_UTF16));
03938 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_Account_0, 0);
03939 }
03940 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_EncryptedPassword));
03941 if (_ptr_EncryptedPassword) {
03942 NDR_PULL_ALLOC(ndr, r->in.EncryptedPassword);
03943 } else {
03944 r->in.EncryptedPassword = NULL;
03945 }
03946 if (r->in.EncryptedPassword) {
03947 _mem_save_EncryptedPassword_0 = NDR_PULL_GET_MEM_CTX(ndr);
03948 NDR_PULL_SET_MEM_CTX(ndr, r->in.EncryptedPassword, 0);
03949 NDR_CHECK(ndr_pull_wkssvc_PasswordBuffer(ndr, NDR_SCALARS, r->in.EncryptedPassword));
03950 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_EncryptedPassword_0, 0);
03951 }
03952 NDR_CHECK(ndr_pull_wkssvc_renameflags(ndr, NDR_SCALARS, &r->in.RenameOptions));
03953 }
03954 if (flags & NDR_OUT) {
03955 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
03956 }
03957 return NT_STATUS_OK;
03958 }
03959
03960 _PUBLIC_ void ndr_print_wkssvc_NetrRenameMachineInDomain2(struct ndr_print *ndr, const char *name, int flags, const struct wkssvc_NetrRenameMachineInDomain2 *r)
03961 {
03962 ndr_print_struct(ndr, name, "wkssvc_NetrRenameMachineInDomain2");
03963 ndr->depth++;
03964 if (flags & NDR_SET_VALUES) {
03965 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
03966 }
03967 if (flags & NDR_IN) {
03968 ndr_print_struct(ndr, "in", "wkssvc_NetrRenameMachineInDomain2");
03969 ndr->depth++;
03970 ndr_print_ptr(ndr, "server_name", r->in.server_name);
03971 ndr->depth++;
03972 if (r->in.server_name) {
03973 ndr_print_string(ndr, "server_name", r->in.server_name);
03974 }
03975 ndr->depth--;
03976 ndr_print_ptr(ndr, "NewMachineName", r->in.NewMachineName);
03977 ndr->depth++;
03978 if (r->in.NewMachineName) {
03979 ndr_print_string(ndr, "NewMachineName", r->in.NewMachineName);
03980 }
03981 ndr->depth--;
03982 ndr_print_ptr(ndr, "Account", r->in.Account);
03983 ndr->depth++;
03984 if (r->in.Account) {
03985 ndr_print_string(ndr, "Account", r->in.Account);
03986 }
03987 ndr->depth--;
03988 ndr_print_ptr(ndr, "EncryptedPassword", r->in.EncryptedPassword);
03989 ndr->depth++;
03990 if (r->in.EncryptedPassword) {
03991 ndr_print_wkssvc_PasswordBuffer(ndr, "EncryptedPassword", r->in.EncryptedPassword);
03992 }
03993 ndr->depth--;
03994 ndr_print_wkssvc_renameflags(ndr, "RenameOptions", r->in.RenameOptions);
03995 ndr->depth--;
03996 }
03997 if (flags & NDR_OUT) {
03998 ndr_print_struct(ndr, "out", "wkssvc_NetrRenameMachineInDomain2");
03999 ndr->depth++;
04000 ndr_print_WERROR(ndr, "result", r->out.result);
04001 ndr->depth--;
04002 }
04003 ndr->depth--;
04004 }
04005
04006 NTSTATUS ndr_push_WKSSVC_NETRVALIDATENAME2(struct ndr_push *ndr, int flags, const struct WKSSVC_NETRVALIDATENAME2 *r)
04007 {
04008 if (flags & NDR_IN) {
04009 }
04010 if (flags & NDR_OUT) {
04011 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
04012 }
04013 return NT_STATUS_OK;
04014 }
04015
04016 NTSTATUS ndr_pull_WKSSVC_NETRVALIDATENAME2(struct ndr_pull *ndr, int flags, struct WKSSVC_NETRVALIDATENAME2 *r)
04017 {
04018 if (flags & NDR_IN) {
04019 }
04020 if (flags & NDR_OUT) {
04021 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
04022 }
04023 return NT_STATUS_OK;
04024 }
04025
04026 _PUBLIC_ void ndr_print_WKSSVC_NETRVALIDATENAME2(struct ndr_print *ndr, const char *name, int flags, const struct WKSSVC_NETRVALIDATENAME2 *r)
04027 {
04028 ndr_print_struct(ndr, name, "WKSSVC_NETRVALIDATENAME2");
04029 ndr->depth++;
04030 if (flags & NDR_SET_VALUES) {
04031 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
04032 }
04033 if (flags & NDR_IN) {
04034 ndr_print_struct(ndr, "in", "WKSSVC_NETRVALIDATENAME2");
04035 ndr->depth++;
04036 ndr->depth--;
04037 }
04038 if (flags & NDR_OUT) {
04039 ndr_print_struct(ndr, "out", "WKSSVC_NETRVALIDATENAME2");
04040 ndr->depth++;
04041 ndr_print_WERROR(ndr, "result", r->out.result);
04042 ndr->depth--;
04043 }
04044 ndr->depth--;
04045 }
04046
04047 NTSTATUS ndr_push_WKSSVC_NETRGETJOINABLEOUS2(struct ndr_push *ndr, int flags, const struct WKSSVC_NETRGETJOINABLEOUS2 *r)
04048 {
04049 if (flags & NDR_IN) {
04050 }
04051 if (flags & NDR_OUT) {
04052 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
04053 }
04054 return NT_STATUS_OK;
04055 }
04056
04057 NTSTATUS ndr_pull_WKSSVC_NETRGETJOINABLEOUS2(struct ndr_pull *ndr, int flags, struct WKSSVC_NETRGETJOINABLEOUS2 *r)
04058 {
04059 if (flags & NDR_IN) {
04060 }
04061 if (flags & NDR_OUT) {
04062 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
04063 }
04064 return NT_STATUS_OK;
04065 }
04066
04067 _PUBLIC_ void ndr_print_WKSSVC_NETRGETJOINABLEOUS2(struct ndr_print *ndr, const char *name, int flags, const struct WKSSVC_NETRGETJOINABLEOUS2 *r)
04068 {
04069 ndr_print_struct(ndr, name, "WKSSVC_NETRGETJOINABLEOUS2");
04070 ndr->depth++;
04071 if (flags & NDR_SET_VALUES) {
04072 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
04073 }
04074 if (flags & NDR_IN) {
04075 ndr_print_struct(ndr, "in", "WKSSVC_NETRGETJOINABLEOUS2");
04076 ndr->depth++;
04077 ndr->depth--;
04078 }
04079 if (flags & NDR_OUT) {
04080 ndr_print_struct(ndr, "out", "WKSSVC_NETRGETJOINABLEOUS2");
04081 ndr->depth++;
04082 ndr_print_WERROR(ndr, "result", r->out.result);
04083 ndr->depth--;
04084 }
04085 ndr->depth--;
04086 }
04087
04088 NTSTATUS ndr_push_wkssvc_NetrAddAlternateComputerName(struct ndr_push *ndr, int flags, const struct wkssvc_NetrAddAlternateComputerName *r)
04089 {
04090 if (flags & NDR_IN) {
04091 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server_name));
04092 if (r->in.server_name) {
04093 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
04094 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
04095 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
04096 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));
04097 }
04098 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.NewAlternateMachineName));
04099 if (r->in.NewAlternateMachineName) {
04100 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.NewAlternateMachineName, CH_UTF16)));
04101 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
04102 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.NewAlternateMachineName, CH_UTF16)));
04103 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.NewAlternateMachineName, ndr_charset_length(r->in.NewAlternateMachineName, CH_UTF16), sizeof(uint16_t), CH_UTF16));
04104 }
04105 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.Account));
04106 if (r->in.Account) {
04107 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.Account, CH_UTF16)));
04108 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
04109 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.Account, CH_UTF16)));
04110 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.Account, ndr_charset_length(r->in.Account, CH_UTF16), sizeof(uint16_t), CH_UTF16));
04111 }
04112 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.EncryptedPassword));
04113 if (r->in.EncryptedPassword) {
04114 NDR_CHECK(ndr_push_wkssvc_PasswordBuffer(ndr, NDR_SCALARS, r->in.EncryptedPassword));
04115 }
04116 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.Reserved));
04117 }
04118 if (flags & NDR_OUT) {
04119 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
04120 }
04121 return NT_STATUS_OK;
04122 }
04123
04124 NTSTATUS ndr_pull_wkssvc_NetrAddAlternateComputerName(struct ndr_pull *ndr, int flags, struct wkssvc_NetrAddAlternateComputerName *r)
04125 {
04126 uint32_t _ptr_server_name;
04127 uint32_t _ptr_NewAlternateMachineName;
04128 uint32_t _ptr_Account;
04129 uint32_t _ptr_EncryptedPassword;
04130 TALLOC_CTX *_mem_save_server_name_0;
04131 TALLOC_CTX *_mem_save_NewAlternateMachineName_0;
04132 TALLOC_CTX *_mem_save_Account_0;
04133 TALLOC_CTX *_mem_save_EncryptedPassword_0;
04134 if (flags & NDR_IN) {
04135 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_name));
04136 if (_ptr_server_name) {
04137 NDR_PULL_ALLOC(ndr, r->in.server_name);
04138 } else {
04139 r->in.server_name = NULL;
04140 }
04141 if (r->in.server_name) {
04142 _mem_save_server_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
04143 NDR_PULL_SET_MEM_CTX(ndr, r->in.server_name, 0);
04144 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_name));
04145 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_name));
04146 if (ndr_get_array_length(ndr, &r->in.server_name) > ndr_get_array_size(ndr, &r->in.server_name)) {
04147 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));
04148 }
04149 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server_name), sizeof(uint16_t)));
04150 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));
04151 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_name_0, 0);
04152 }
04153 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_NewAlternateMachineName));
04154 if (_ptr_NewAlternateMachineName) {
04155 NDR_PULL_ALLOC(ndr, r->in.NewAlternateMachineName);
04156 } else {
04157 r->in.NewAlternateMachineName = NULL;
04158 }
04159 if (r->in.NewAlternateMachineName) {
04160 _mem_save_NewAlternateMachineName_0 = NDR_PULL_GET_MEM_CTX(ndr);
04161 NDR_PULL_SET_MEM_CTX(ndr, r->in.NewAlternateMachineName, 0);
04162 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.NewAlternateMachineName));
04163 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.NewAlternateMachineName));
04164 if (ndr_get_array_length(ndr, &r->in.NewAlternateMachineName) > ndr_get_array_size(ndr, &r->in.NewAlternateMachineName)) {
04165 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));
04166 }
04167 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.NewAlternateMachineName), sizeof(uint16_t)));
04168 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.NewAlternateMachineName, ndr_get_array_length(ndr, &r->in.NewAlternateMachineName), sizeof(uint16_t), CH_UTF16));
04169 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_NewAlternateMachineName_0, 0);
04170 }
04171 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_Account));
04172 if (_ptr_Account) {
04173 NDR_PULL_ALLOC(ndr, r->in.Account);
04174 } else {
04175 r->in.Account = NULL;
04176 }
04177 if (r->in.Account) {
04178 _mem_save_Account_0 = NDR_PULL_GET_MEM_CTX(ndr);
04179 NDR_PULL_SET_MEM_CTX(ndr, r->in.Account, 0);
04180 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.Account));
04181 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.Account));
04182 if (ndr_get_array_length(ndr, &r->in.Account) > ndr_get_array_size(ndr, &r->in.Account)) {
04183 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));
04184 }
04185 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.Account), sizeof(uint16_t)));
04186 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.Account, ndr_get_array_length(ndr, &r->in.Account), sizeof(uint16_t), CH_UTF16));
04187 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_Account_0, 0);
04188 }
04189 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_EncryptedPassword));
04190 if (_ptr_EncryptedPassword) {
04191 NDR_PULL_ALLOC(ndr, r->in.EncryptedPassword);
04192 } else {
04193 r->in.EncryptedPassword = NULL;
04194 }
04195 if (r->in.EncryptedPassword) {
04196 _mem_save_EncryptedPassword_0 = NDR_PULL_GET_MEM_CTX(ndr);
04197 NDR_PULL_SET_MEM_CTX(ndr, r->in.EncryptedPassword, 0);
04198 NDR_CHECK(ndr_pull_wkssvc_PasswordBuffer(ndr, NDR_SCALARS, r->in.EncryptedPassword));
04199 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_EncryptedPassword_0, 0);
04200 }
04201 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.Reserved));
04202 }
04203 if (flags & NDR_OUT) {
04204 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
04205 }
04206 return NT_STATUS_OK;
04207 }
04208
04209 _PUBLIC_ void ndr_print_wkssvc_NetrAddAlternateComputerName(struct ndr_print *ndr, const char *name, int flags, const struct wkssvc_NetrAddAlternateComputerName *r)
04210 {
04211 ndr_print_struct(ndr, name, "wkssvc_NetrAddAlternateComputerName");
04212 ndr->depth++;
04213 if (flags & NDR_SET_VALUES) {
04214 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
04215 }
04216 if (flags & NDR_IN) {
04217 ndr_print_struct(ndr, "in", "wkssvc_NetrAddAlternateComputerName");
04218 ndr->depth++;
04219 ndr_print_ptr(ndr, "server_name", r->in.server_name);
04220 ndr->depth++;
04221 if (r->in.server_name) {
04222 ndr_print_string(ndr, "server_name", r->in.server_name);
04223 }
04224 ndr->depth--;
04225 ndr_print_ptr(ndr, "NewAlternateMachineName", r->in.NewAlternateMachineName);
04226 ndr->depth++;
04227 if (r->in.NewAlternateMachineName) {
04228 ndr_print_string(ndr, "NewAlternateMachineName", r->in.NewAlternateMachineName);
04229 }
04230 ndr->depth--;
04231 ndr_print_ptr(ndr, "Account", r->in.Account);
04232 ndr->depth++;
04233 if (r->in.Account) {
04234 ndr_print_string(ndr, "Account", r->in.Account);
04235 }
04236 ndr->depth--;
04237 ndr_print_ptr(ndr, "EncryptedPassword", r->in.EncryptedPassword);
04238 ndr->depth++;
04239 if (r->in.EncryptedPassword) {
04240 ndr_print_wkssvc_PasswordBuffer(ndr, "EncryptedPassword", r->in.EncryptedPassword);
04241 }
04242 ndr->depth--;
04243 ndr_print_uint32(ndr, "Reserved", r->in.Reserved);
04244 ndr->depth--;
04245 }
04246 if (flags & NDR_OUT) {
04247 ndr_print_struct(ndr, "out", "wkssvc_NetrAddAlternateComputerName");
04248 ndr->depth++;
04249 ndr_print_WERROR(ndr, "result", r->out.result);
04250 ndr->depth--;
04251 }
04252 ndr->depth--;
04253 }
04254
04255 NTSTATUS ndr_push_wkssvc_NetrRemoveAlternateComputerName(struct ndr_push *ndr, int flags, const struct wkssvc_NetrRemoveAlternateComputerName *r)
04256 {
04257 if (flags & NDR_IN) {
04258 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server_name));
04259 if (r->in.server_name) {
04260 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
04261 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
04262 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
04263 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));
04264 }
04265 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.AlternateMachineNameToRemove));
04266 if (r->in.AlternateMachineNameToRemove) {
04267 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.AlternateMachineNameToRemove, CH_UTF16)));
04268 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
04269 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.AlternateMachineNameToRemove, CH_UTF16)));
04270 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.AlternateMachineNameToRemove, ndr_charset_length(r->in.AlternateMachineNameToRemove, CH_UTF16), sizeof(uint16_t), CH_UTF16));
04271 }
04272 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.Account));
04273 if (r->in.Account) {
04274 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.Account, CH_UTF16)));
04275 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
04276 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.Account, CH_UTF16)));
04277 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.Account, ndr_charset_length(r->in.Account, CH_UTF16), sizeof(uint16_t), CH_UTF16));
04278 }
04279 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.EncryptedPassword));
04280 if (r->in.EncryptedPassword) {
04281 NDR_CHECK(ndr_push_wkssvc_PasswordBuffer(ndr, NDR_SCALARS, r->in.EncryptedPassword));
04282 }
04283 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.Reserved));
04284 }
04285 if (flags & NDR_OUT) {
04286 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
04287 }
04288 return NT_STATUS_OK;
04289 }
04290
04291 NTSTATUS ndr_pull_wkssvc_NetrRemoveAlternateComputerName(struct ndr_pull *ndr, int flags, struct wkssvc_NetrRemoveAlternateComputerName *r)
04292 {
04293 uint32_t _ptr_server_name;
04294 uint32_t _ptr_AlternateMachineNameToRemove;
04295 uint32_t _ptr_Account;
04296 uint32_t _ptr_EncryptedPassword;
04297 TALLOC_CTX *_mem_save_server_name_0;
04298 TALLOC_CTX *_mem_save_AlternateMachineNameToRemove_0;
04299 TALLOC_CTX *_mem_save_Account_0;
04300 TALLOC_CTX *_mem_save_EncryptedPassword_0;
04301 if (flags & NDR_IN) {
04302 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_name));
04303 if (_ptr_server_name) {
04304 NDR_PULL_ALLOC(ndr, r->in.server_name);
04305 } else {
04306 r->in.server_name = NULL;
04307 }
04308 if (r->in.server_name) {
04309 _mem_save_server_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
04310 NDR_PULL_SET_MEM_CTX(ndr, r->in.server_name, 0);
04311 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_name));
04312 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_name));
04313 if (ndr_get_array_length(ndr, &r->in.server_name) > ndr_get_array_size(ndr, &r->in.server_name)) {
04314 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));
04315 }
04316 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server_name), sizeof(uint16_t)));
04317 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));
04318 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_name_0, 0);
04319 }
04320 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_AlternateMachineNameToRemove));
04321 if (_ptr_AlternateMachineNameToRemove) {
04322 NDR_PULL_ALLOC(ndr, r->in.AlternateMachineNameToRemove);
04323 } else {
04324 r->in.AlternateMachineNameToRemove = NULL;
04325 }
04326 if (r->in.AlternateMachineNameToRemove) {
04327 _mem_save_AlternateMachineNameToRemove_0 = NDR_PULL_GET_MEM_CTX(ndr);
04328 NDR_PULL_SET_MEM_CTX(ndr, r->in.AlternateMachineNameToRemove, 0);
04329 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.AlternateMachineNameToRemove));
04330 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.AlternateMachineNameToRemove));
04331 if (ndr_get_array_length(ndr, &r->in.AlternateMachineNameToRemove) > ndr_get_array_size(ndr, &r->in.AlternateMachineNameToRemove)) {
04332 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));
04333 }
04334 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.AlternateMachineNameToRemove), sizeof(uint16_t)));
04335 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.AlternateMachineNameToRemove, ndr_get_array_length(ndr, &r->in.AlternateMachineNameToRemove), sizeof(uint16_t), CH_UTF16));
04336 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_AlternateMachineNameToRemove_0, 0);
04337 }
04338 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_Account));
04339 if (_ptr_Account) {
04340 NDR_PULL_ALLOC(ndr, r->in.Account);
04341 } else {
04342 r->in.Account = NULL;
04343 }
04344 if (r->in.Account) {
04345 _mem_save_Account_0 = NDR_PULL_GET_MEM_CTX(ndr);
04346 NDR_PULL_SET_MEM_CTX(ndr, r->in.Account, 0);
04347 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.Account));
04348 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.Account));
04349 if (ndr_get_array_length(ndr, &r->in.Account) > ndr_get_array_size(ndr, &r->in.Account)) {
04350 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));
04351 }
04352 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.Account), sizeof(uint16_t)));
04353 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.Account, ndr_get_array_length(ndr, &r->in.Account), sizeof(uint16_t), CH_UTF16));
04354 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_Account_0, 0);
04355 }
04356 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_EncryptedPassword));
04357 if (_ptr_EncryptedPassword) {
04358 NDR_PULL_ALLOC(ndr, r->in.EncryptedPassword);
04359 } else {
04360 r->in.EncryptedPassword = NULL;
04361 }
04362 if (r->in.EncryptedPassword) {
04363 _mem_save_EncryptedPassword_0 = NDR_PULL_GET_MEM_CTX(ndr);
04364 NDR_PULL_SET_MEM_CTX(ndr, r->in.EncryptedPassword, 0);
04365 NDR_CHECK(ndr_pull_wkssvc_PasswordBuffer(ndr, NDR_SCALARS, r->in.EncryptedPassword));
04366 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_EncryptedPassword_0, 0);
04367 }
04368 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.Reserved));
04369 }
04370 if (flags & NDR_OUT) {
04371 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
04372 }
04373 return NT_STATUS_OK;
04374 }
04375
04376 _PUBLIC_ void ndr_print_wkssvc_NetrRemoveAlternateComputerName(struct ndr_print *ndr, const char *name, int flags, const struct wkssvc_NetrRemoveAlternateComputerName *r)
04377 {
04378 ndr_print_struct(ndr, name, "wkssvc_NetrRemoveAlternateComputerName");
04379 ndr->depth++;
04380 if (flags & NDR_SET_VALUES) {
04381 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
04382 }
04383 if (flags & NDR_IN) {
04384 ndr_print_struct(ndr, "in", "wkssvc_NetrRemoveAlternateComputerName");
04385 ndr->depth++;
04386 ndr_print_ptr(ndr, "server_name", r->in.server_name);
04387 ndr->depth++;
04388 if (r->in.server_name) {
04389 ndr_print_string(ndr, "server_name", r->in.server_name);
04390 }
04391 ndr->depth--;
04392 ndr_print_ptr(ndr, "AlternateMachineNameToRemove", r->in.AlternateMachineNameToRemove);
04393 ndr->depth++;
04394 if (r->in.AlternateMachineNameToRemove) {
04395 ndr_print_string(ndr, "AlternateMachineNameToRemove", r->in.AlternateMachineNameToRemove);
04396 }
04397 ndr->depth--;
04398 ndr_print_ptr(ndr, "Account", r->in.Account);
04399 ndr->depth++;
04400 if (r->in.Account) {
04401 ndr_print_string(ndr, "Account", r->in.Account);
04402 }
04403 ndr->depth--;
04404 ndr_print_ptr(ndr, "EncryptedPassword", r->in.EncryptedPassword);
04405 ndr->depth++;
04406 if (r->in.EncryptedPassword) {
04407 ndr_print_wkssvc_PasswordBuffer(ndr, "EncryptedPassword", r->in.EncryptedPassword);
04408 }
04409 ndr->depth--;
04410 ndr_print_uint32(ndr, "Reserved", r->in.Reserved);
04411 ndr->depth--;
04412 }
04413 if (flags & NDR_OUT) {
04414 ndr_print_struct(ndr, "out", "wkssvc_NetrRemoveAlternateComputerName");
04415 ndr->depth++;
04416 ndr_print_WERROR(ndr, "result", r->out.result);
04417 ndr->depth--;
04418 }
04419 ndr->depth--;
04420 }
04421
04422 NTSTATUS ndr_push_WKSSVC_NETRSETPRIMARYCOMPUTERNAME(struct ndr_push *ndr, int flags, const struct WKSSVC_NETRSETPRIMARYCOMPUTERNAME *r)
04423 {
04424 if (flags & NDR_IN) {
04425 }
04426 if (flags & NDR_OUT) {
04427 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
04428 }
04429 return NT_STATUS_OK;
04430 }
04431
04432 NTSTATUS ndr_pull_WKSSVC_NETRSETPRIMARYCOMPUTERNAME(struct ndr_pull *ndr, int flags, struct WKSSVC_NETRSETPRIMARYCOMPUTERNAME *r)
04433 {
04434 if (flags & NDR_IN) {
04435 }
04436 if (flags & NDR_OUT) {
04437 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
04438 }
04439 return NT_STATUS_OK;
04440 }
04441
04442 _PUBLIC_ void ndr_print_WKSSVC_NETRSETPRIMARYCOMPUTERNAME(struct ndr_print *ndr, const char *name, int flags, const struct WKSSVC_NETRSETPRIMARYCOMPUTERNAME *r)
04443 {
04444 ndr_print_struct(ndr, name, "WKSSVC_NETRSETPRIMARYCOMPUTERNAME");
04445 ndr->depth++;
04446 if (flags & NDR_SET_VALUES) {
04447 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
04448 }
04449 if (flags & NDR_IN) {
04450 ndr_print_struct(ndr, "in", "WKSSVC_NETRSETPRIMARYCOMPUTERNAME");
04451 ndr->depth++;
04452 ndr->depth--;
04453 }
04454 if (flags & NDR_OUT) {
04455 ndr_print_struct(ndr, "out", "WKSSVC_NETRSETPRIMARYCOMPUTERNAME");
04456 ndr->depth++;
04457 ndr_print_WERROR(ndr, "result", r->out.result);
04458 ndr->depth--;
04459 }
04460 ndr->depth--;
04461 }
04462
04463 NTSTATUS ndr_push_WKSSVC_NETRENUMERATECOMPUTERNAMES(struct ndr_push *ndr, int flags, const struct WKSSVC_NETRENUMERATECOMPUTERNAMES *r)
04464 {
04465 if (flags & NDR_IN) {
04466 }
04467 if (flags & NDR_OUT) {
04468 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
04469 }
04470 return NT_STATUS_OK;
04471 }
04472
04473 NTSTATUS ndr_pull_WKSSVC_NETRENUMERATECOMPUTERNAMES(struct ndr_pull *ndr, int flags, struct WKSSVC_NETRENUMERATECOMPUTERNAMES *r)
04474 {
04475 if (flags & NDR_IN) {
04476 }
04477 if (flags & NDR_OUT) {
04478 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
04479 }
04480 return NT_STATUS_OK;
04481 }
04482
04483 _PUBLIC_ void ndr_print_WKSSVC_NETRENUMERATECOMPUTERNAMES(struct ndr_print *ndr, const char *name, int flags, const struct WKSSVC_NETRENUMERATECOMPUTERNAMES *r)
04484 {
04485 ndr_print_struct(ndr, name, "WKSSVC_NETRENUMERATECOMPUTERNAMES");
04486 ndr->depth++;
04487 if (flags & NDR_SET_VALUES) {
04488 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
04489 }
04490 if (flags & NDR_IN) {
04491 ndr_print_struct(ndr, "in", "WKSSVC_NETRENUMERATECOMPUTERNAMES");
04492 ndr->depth++;
04493 ndr->depth--;
04494 }
04495 if (flags & NDR_OUT) {
04496 ndr_print_struct(ndr, "out", "WKSSVC_NETRENUMERATECOMPUTERNAMES");
04497 ndr->depth++;
04498 ndr_print_WERROR(ndr, "result", r->out.result);
04499 ndr->depth--;
04500 }
04501 ndr->depth--;
04502 }
04503
04504 const struct dcerpc_interface_call wkssvc_calls[] = {
04505 {
04506 "wkssvc_NetWkstaGetInfo",
04507 sizeof(struct wkssvc_NetWkstaGetInfo),
04508 (ndr_push_flags_fn_t) ndr_push_wkssvc_NetWkstaGetInfo,
04509 (ndr_pull_flags_fn_t) ndr_pull_wkssvc_NetWkstaGetInfo,
04510 (ndr_print_function_t) ndr_print_wkssvc_NetWkstaGetInfo,
04511 False,
04512 },
04513 {
04514 "wkssvc_NetWkstaSetInfo",
04515 sizeof(struct wkssvc_NetWkstaSetInfo),
04516 (ndr_push_flags_fn_t) ndr_push_wkssvc_NetWkstaSetInfo,
04517 (ndr_pull_flags_fn_t) ndr_pull_wkssvc_NetWkstaSetInfo,
04518 (ndr_print_function_t) ndr_print_wkssvc_NetWkstaSetInfo,
04519 False,
04520 },
04521 {
04522 "wkssvc_NetWkstaEnumUsers",
04523 sizeof(struct wkssvc_NetWkstaEnumUsers),
04524 (ndr_push_flags_fn_t) ndr_push_wkssvc_NetWkstaEnumUsers,
04525 (ndr_pull_flags_fn_t) ndr_pull_wkssvc_NetWkstaEnumUsers,
04526 (ndr_print_function_t) ndr_print_wkssvc_NetWkstaEnumUsers,
04527 False,
04528 },
04529 {
04530 "WKSSVC_NETRWKSTAUSERGETINFO",
04531 sizeof(struct WKSSVC_NETRWKSTAUSERGETINFO),
04532 (ndr_push_flags_fn_t) ndr_push_WKSSVC_NETRWKSTAUSERGETINFO,
04533 (ndr_pull_flags_fn_t) ndr_pull_WKSSVC_NETRWKSTAUSERGETINFO,
04534 (ndr_print_function_t) ndr_print_WKSSVC_NETRWKSTAUSERGETINFO,
04535 False,
04536 },
04537 {
04538 "WKSSVC_NETRWKSTAUSERSETINFO",
04539 sizeof(struct WKSSVC_NETRWKSTAUSERSETINFO),
04540 (ndr_push_flags_fn_t) ndr_push_WKSSVC_NETRWKSTAUSERSETINFO,
04541 (ndr_pull_flags_fn_t) ndr_pull_WKSSVC_NETRWKSTAUSERSETINFO,
04542 (ndr_print_function_t) ndr_print_WKSSVC_NETRWKSTAUSERSETINFO,
04543 False,
04544 },
04545 {
04546 "wkssvc_NetWkstaTransportEnum",
04547 sizeof(struct wkssvc_NetWkstaTransportEnum),
04548 (ndr_push_flags_fn_t) ndr_push_wkssvc_NetWkstaTransportEnum,
04549 (ndr_pull_flags_fn_t) ndr_pull_wkssvc_NetWkstaTransportEnum,
04550 (ndr_print_function_t) ndr_print_wkssvc_NetWkstaTransportEnum,
04551 False,
04552 },
04553 {
04554 "WKSSVC_NETRWKSTATRANSPORTADD",
04555 sizeof(struct WKSSVC_NETRWKSTATRANSPORTADD),
04556 (ndr_push_flags_fn_t) ndr_push_WKSSVC_NETRWKSTATRANSPORTADD,
04557 (ndr_pull_flags_fn_t) ndr_pull_WKSSVC_NETRWKSTATRANSPORTADD,
04558 (ndr_print_function_t) ndr_print_WKSSVC_NETRWKSTATRANSPORTADD,
04559 False,
04560 },
04561 {
04562 "WKSSVC_NETRWKSTATRANSPORTDEL",
04563 sizeof(struct WKSSVC_NETRWKSTATRANSPORTDEL),
04564 (ndr_push_flags_fn_t) ndr_push_WKSSVC_NETRWKSTATRANSPORTDEL,
04565 (ndr_pull_flags_fn_t) ndr_pull_WKSSVC_NETRWKSTATRANSPORTDEL,
04566 (ndr_print_function_t) ndr_print_WKSSVC_NETRWKSTATRANSPORTDEL,
04567 False,
04568 },
04569 {
04570 "WKSSVC_NETRUSEADD",
04571 sizeof(struct WKSSVC_NETRUSEADD),
04572 (ndr_push_flags_fn_t) ndr_push_WKSSVC_NETRUSEADD,
04573 (ndr_pull_flags_fn_t) ndr_pull_WKSSVC_NETRUSEADD,
04574 (ndr_print_function_t) ndr_print_WKSSVC_NETRUSEADD,
04575 False,
04576 },
04577 {
04578 "WKSSVC_NETRUSEGETINFO",
04579 sizeof(struct WKSSVC_NETRUSEGETINFO),
04580 (ndr_push_flags_fn_t) ndr_push_WKSSVC_NETRUSEGETINFO,
04581 (ndr_pull_flags_fn_t) ndr_pull_WKSSVC_NETRUSEGETINFO,
04582 (ndr_print_function_t) ndr_print_WKSSVC_NETRUSEGETINFO,
04583 False,
04584 },
04585 {
04586 "WKSSVC_NETRUSEDEL",
04587 sizeof(struct WKSSVC_NETRUSEDEL),
04588 (ndr_push_flags_fn_t) ndr_push_WKSSVC_NETRUSEDEL,
04589 (ndr_pull_flags_fn_t) ndr_pull_WKSSVC_NETRUSEDEL,
04590 (ndr_print_function_t) ndr_print_WKSSVC_NETRUSEDEL,
04591 False,
04592 },
04593 {
04594 "WKSSVC_NETRUSEENUM",
04595 sizeof(struct WKSSVC_NETRUSEENUM),
04596 (ndr_push_flags_fn_t) ndr_push_WKSSVC_NETRUSEENUM,
04597 (ndr_pull_flags_fn_t) ndr_pull_WKSSVC_NETRUSEENUM,
04598 (ndr_print_function_t) ndr_print_WKSSVC_NETRUSEENUM,
04599 False,
04600 },
04601 {
04602 "WKSSVC_NETRMESSAGEBUFFERSEND",
04603 sizeof(struct WKSSVC_NETRMESSAGEBUFFERSEND),
04604 (ndr_push_flags_fn_t) ndr_push_WKSSVC_NETRMESSAGEBUFFERSEND,
04605 (ndr_pull_flags_fn_t) ndr_pull_WKSSVC_NETRMESSAGEBUFFERSEND,
04606 (ndr_print_function_t) ndr_print_WKSSVC_NETRMESSAGEBUFFERSEND,
04607 False,
04608 },
04609 {
04610 "WKSSVC_NETRWORKSTATIONSTATISTICSGET",
04611 sizeof(struct WKSSVC_NETRWORKSTATIONSTATISTICSGET),
04612 (ndr_push_flags_fn_t) ndr_push_WKSSVC_NETRWORKSTATIONSTATISTICSGET,
04613 (ndr_pull_flags_fn_t) ndr_pull_WKSSVC_NETRWORKSTATIONSTATISTICSGET,
04614 (ndr_print_function_t) ndr_print_WKSSVC_NETRWORKSTATIONSTATISTICSGET,
04615 False,
04616 },
04617 {
04618 "WKSSVC_NETRLOGONDOMAINNAMEADD",
04619 sizeof(struct WKSSVC_NETRLOGONDOMAINNAMEADD),
04620 (ndr_push_flags_fn_t) ndr_push_WKSSVC_NETRLOGONDOMAINNAMEADD,
04621 (ndr_pull_flags_fn_t) ndr_pull_WKSSVC_NETRLOGONDOMAINNAMEADD,
04622 (ndr_print_function_t) ndr_print_WKSSVC_NETRLOGONDOMAINNAMEADD,
04623 False,
04624 },
04625 {
04626 "WKSSVC_NETRLOGONDOMAINNAMEDEL",
04627 sizeof(struct WKSSVC_NETRLOGONDOMAINNAMEDEL),
04628 (ndr_push_flags_fn_t) ndr_push_WKSSVC_NETRLOGONDOMAINNAMEDEL,
04629 (ndr_pull_flags_fn_t) ndr_pull_WKSSVC_NETRLOGONDOMAINNAMEDEL,
04630 (ndr_print_function_t) ndr_print_WKSSVC_NETRLOGONDOMAINNAMEDEL,
04631 False,
04632 },
04633 {
04634 "WKSSVC_NETRJOINDOMAIN",
04635 sizeof(struct WKSSVC_NETRJOINDOMAIN),
04636 (ndr_push_flags_fn_t) ndr_push_WKSSVC_NETRJOINDOMAIN,
04637 (ndr_pull_flags_fn_t) ndr_pull_WKSSVC_NETRJOINDOMAIN,
04638 (ndr_print_function_t) ndr_print_WKSSVC_NETRJOINDOMAIN,
04639 False,
04640 },
04641 {
04642 "WKSSVC_NETRUNJOINDOMAIN",
04643 sizeof(struct WKSSVC_NETRUNJOINDOMAIN),
04644 (ndr_push_flags_fn_t) ndr_push_WKSSVC_NETRUNJOINDOMAIN,
04645 (ndr_pull_flags_fn_t) ndr_pull_WKSSVC_NETRUNJOINDOMAIN,
04646 (ndr_print_function_t) ndr_print_WKSSVC_NETRUNJOINDOMAIN,
04647 False,
04648 },
04649 {
04650 "WKSSVC_NETRRENAMEMACHINEINDOMAIN",
04651 sizeof(struct WKSSVC_NETRRENAMEMACHINEINDOMAIN),
04652 (ndr_push_flags_fn_t) ndr_push_WKSSVC_NETRRENAMEMACHINEINDOMAIN,
04653 (ndr_pull_flags_fn_t) ndr_pull_WKSSVC_NETRRENAMEMACHINEINDOMAIN,
04654 (ndr_print_function_t) ndr_print_WKSSVC_NETRRENAMEMACHINEINDOMAIN,
04655 False,
04656 },
04657 {
04658 "WKSSVC_NETRVALIDATENAME",
04659 sizeof(struct WKSSVC_NETRVALIDATENAME),
04660 (ndr_push_flags_fn_t) ndr_push_WKSSVC_NETRVALIDATENAME,
04661 (ndr_pull_flags_fn_t) ndr_pull_WKSSVC_NETRVALIDATENAME,
04662 (ndr_print_function_t) ndr_print_WKSSVC_NETRVALIDATENAME,
04663 False,
04664 },
04665 {
04666 "WKSSVC_NETRGETJOININFORMATION",
04667 sizeof(struct WKSSVC_NETRGETJOININFORMATION),
04668 (ndr_push_flags_fn_t) ndr_push_WKSSVC_NETRGETJOININFORMATION,
04669 (ndr_pull_flags_fn_t) ndr_pull_WKSSVC_NETRGETJOININFORMATION,
04670 (ndr_print_function_t) ndr_print_WKSSVC_NETRGETJOININFORMATION,
04671 False,
04672 },
04673 {
04674 "WKSSVC_NETRGETJOINABLEOUS",
04675 sizeof(struct WKSSVC_NETRGETJOINABLEOUS),
04676 (ndr_push_flags_fn_t) ndr_push_WKSSVC_NETRGETJOINABLEOUS,
04677 (ndr_pull_flags_fn_t) ndr_pull_WKSSVC_NETRGETJOINABLEOUS,
04678 (ndr_print_function_t) ndr_print_WKSSVC_NETRGETJOINABLEOUS,
04679 False,
04680 },
04681 {
04682 "wkssvc_NetrJoinDomain2",
04683 sizeof(struct wkssvc_NetrJoinDomain2),
04684 (ndr_push_flags_fn_t) ndr_push_wkssvc_NetrJoinDomain2,
04685 (ndr_pull_flags_fn_t) ndr_pull_wkssvc_NetrJoinDomain2,
04686 (ndr_print_function_t) ndr_print_wkssvc_NetrJoinDomain2,
04687 False,
04688 },
04689 {
04690 "wkssvc_NetrUnjoinDomain2",
04691 sizeof(struct wkssvc_NetrUnjoinDomain2),
04692 (ndr_push_flags_fn_t) ndr_push_wkssvc_NetrUnjoinDomain2,
04693 (ndr_pull_flags_fn_t) ndr_pull_wkssvc_NetrUnjoinDomain2,
04694 (ndr_print_function_t) ndr_print_wkssvc_NetrUnjoinDomain2,
04695 False,
04696 },
04697 {
04698 "wkssvc_NetrRenameMachineInDomain2",
04699 sizeof(struct wkssvc_NetrRenameMachineInDomain2),
04700 (ndr_push_flags_fn_t) ndr_push_wkssvc_NetrRenameMachineInDomain2,
04701 (ndr_pull_flags_fn_t) ndr_pull_wkssvc_NetrRenameMachineInDomain2,
04702 (ndr_print_function_t) ndr_print_wkssvc_NetrRenameMachineInDomain2,
04703 False,
04704 },
04705 {
04706 "WKSSVC_NETRVALIDATENAME2",
04707 sizeof(struct WKSSVC_NETRVALIDATENAME2),
04708 (ndr_push_flags_fn_t) ndr_push_WKSSVC_NETRVALIDATENAME2,
04709 (ndr_pull_flags_fn_t) ndr_pull_WKSSVC_NETRVALIDATENAME2,
04710 (ndr_print_function_t) ndr_print_WKSSVC_NETRVALIDATENAME2,
04711 False,
04712 },
04713 {
04714 "WKSSVC_NETRGETJOINABLEOUS2",
04715 sizeof(struct WKSSVC_NETRGETJOINABLEOUS2),
04716 (ndr_push_flags_fn_t) ndr_push_WKSSVC_NETRGETJOINABLEOUS2,
04717 (ndr_pull_flags_fn_t) ndr_pull_WKSSVC_NETRGETJOINABLEOUS2,
04718 (ndr_print_function_t) ndr_print_WKSSVC_NETRGETJOINABLEOUS2,
04719 False,
04720 },
04721 {
04722 "wkssvc_NetrAddAlternateComputerName",
04723 sizeof(struct wkssvc_NetrAddAlternateComputerName),
04724 (ndr_push_flags_fn_t) ndr_push_wkssvc_NetrAddAlternateComputerName,
04725 (ndr_pull_flags_fn_t) ndr_pull_wkssvc_NetrAddAlternateComputerName,
04726 (ndr_print_function_t) ndr_print_wkssvc_NetrAddAlternateComputerName,
04727 False,
04728 },
04729 {
04730 "wkssvc_NetrRemoveAlternateComputerName",
04731 sizeof(struct wkssvc_NetrRemoveAlternateComputerName),
04732 (ndr_push_flags_fn_t) ndr_push_wkssvc_NetrRemoveAlternateComputerName,
04733 (ndr_pull_flags_fn_t) ndr_pull_wkssvc_NetrRemoveAlternateComputerName,
04734 (ndr_print_function_t) ndr_print_wkssvc_NetrRemoveAlternateComputerName,
04735 False,
04736 },
04737 {
04738 "WKSSVC_NETRSETPRIMARYCOMPUTERNAME",
04739 sizeof(struct WKSSVC_NETRSETPRIMARYCOMPUTERNAME),
04740 (ndr_push_flags_fn_t) ndr_push_WKSSVC_NETRSETPRIMARYCOMPUTERNAME,
04741 (ndr_pull_flags_fn_t) ndr_pull_WKSSVC_NETRSETPRIMARYCOMPUTERNAME,
04742 (ndr_print_function_t) ndr_print_WKSSVC_NETRSETPRIMARYCOMPUTERNAME,
04743 False,
04744 },
04745 {
04746 "WKSSVC_NETRENUMERATECOMPUTERNAMES",
04747 sizeof(struct WKSSVC_NETRENUMERATECOMPUTERNAMES),
04748 (ndr_push_flags_fn_t) ndr_push_WKSSVC_NETRENUMERATECOMPUTERNAMES,
04749 (ndr_pull_flags_fn_t) ndr_pull_WKSSVC_NETRENUMERATECOMPUTERNAMES,
04750 (ndr_print_function_t) ndr_print_WKSSVC_NETRENUMERATECOMPUTERNAMES,
04751 False,
04752 },
04753 { NULL, 0, NULL, NULL, NULL, False }
04754 };
04755
04756 const char * const wkssvc_endpoint_strings[] = {
04757 "ncacn_np:[\\pipe\\wkssvc]",
04758 };
04759
04760 const struct dcerpc_endpoint_list wkssvc_endpoints = {
04761 .count = 1,
04762 .names = wkssvc_endpoint_strings
04763 };
04764
04765 const char * const wkssvc_authservice_strings[] = {
04766 "host",
04767 };
04768
04769 const struct dcerpc_authservice_list wkssvc_authservices = {
04770 .count = 1,
04771 .names = wkssvc_authservice_strings
04772 };
04773
04774
04775 const struct dcerpc_interface_table dcerpc_table_wkssvc = {
04776 .name = "wkssvc",
04777 .syntax_id = {
04778 {0x6bffd098,0xa112,0x3610,{0x98,0x33},{0x46,0xc3,0xf8,0x7e,0x34,0x5a}},
04779 DCERPC_WKSSVC_VERSION
04780 },
04781 .helpstring = DCERPC_WKSSVC_HELPSTRING,
04782 .num_calls = 31,
04783 .calls = wkssvc_calls,
04784 .endpoints = &wkssvc_endpoints,
04785 .authservices = &wkssvc_authservices
04786 };
04787
