?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
netapi32: The last parameter to Samba's NetShareAdd is not optional.
[wine/wine-gecko.git] / dlls / netapi32 / netapi32.c
blob832fdbe23127d4ed950ea678b4148783ba189384
1 /* Copyright 2001 Mike McCormack
2 * Copyright 2002 Andriy Palamarchuk
3 * Copyright 2003 Juan Lang
4 * Copyright 2005,2006 Paul Vriens
5 * Copyright 2006 Robert Reif
6 * Copyright 2013 Hans Leidekker for CodeWeavers
7 *
8 * This library is free software; you can redistribute it and/or
9 * modify it under the terms of the GNU Lesser General Public
10 * License as published by the Free Software Foundation; either
11 * version 2.1 of the License, or (at your option) any later version.
12 *
13 * This library is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16 * Lesser General Public License for more details.
17 *
18 * You should have received a copy of the GNU Lesser General Public
19 * License along with this library; if not, write to the Free Software
20 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
21 */
22
23 #include "config.h"
24 #include "wine/port.h"
25
26 #include <stdarg.h>
27 #include <fcntl.h>
28 #include <errno.h>
29 #ifdef HAVE_SYS_WAIT_H
30 #include <sys/wait.h>
31 #endif
32 #ifdef HAVE_UNISTD_H
33 #include <unistd.h>
34 #endif
35
36 #include "ntstatus.h"
37 #define WIN32_NO_STATUS
38 #include "windef.h"
39 #include "winbase.h"
40 #include "lm.h"
41 #include "lmaccess.h"
42 #include "lmat.h"
43 #include "lmapibuf.h"
44 #include "lmbrowsr.h"
45 #include "lmshare.h"
46 #include "lmwksta.h"
47 #include "netbios.h"
48 #include "ifmib.h"
49 #include "iphlpapi.h"
50 #include "ntsecapi.h"
51 #include "winnls.h"
52 #include "dsrole.h"
53 #include "dsgetdc.h"
54 #include "wine/debug.h"
55 #include "wine/library.h"
56 #include "wine/list.h"
57 #include "wine/unicode.h"
58
59 WINE_DEFAULT_DEBUG_CHANNEL(netapi32);
60
61 static char *strdup_unixcp( const WCHAR *str )
62 {
63 char *ret;
64 int len = WideCharToMultiByte( CP_UNIXCP, 0, str, -1, NULL, 0, NULL, NULL );
65 if ((ret = HeapAlloc( GetProcessHeap(), 0, len )))
66 WideCharToMultiByte( CP_UNIXCP, 0, str, -1, ret, len, NULL, NULL );
67 return ret;
68 }
69
70 #ifdef SONAME_LIBNETAPI
71
72 static void *libnetapi_handle;
73 static void *libnetapi_ctx;
74
75 static DWORD (*plibnetapi_init)(void **);
76 static DWORD (*plibnetapi_free)(void *);
77 static DWORD (*plibnetapi_set_debuglevel)(void *, const char *);
78 static DWORD (*plibnetapi_set_username)(void *, const char *);
79 static DWORD (*plibnetapi_set_password)(void *, const char *);
80
81 static NET_API_STATUS (*pNetApiBufferAllocate)(unsigned int, void **);
82 static NET_API_STATUS (*pNetApiBufferFree)(void *);
83 static NET_API_STATUS (*pNetServerGetInfo)(const char *, unsigned int, unsigned char **);
84 static NET_API_STATUS (*pNetShareAdd)(const char *, unsigned int, unsigned char *, unsigned int *);
85 static NET_API_STATUS (*pNetShareDel)(const char *, const char *, unsigned int);
86 static NET_API_STATUS (*pNetWkstaGetInfo)(const char *, unsigned int, unsigned char **);
87
88 static void destroy_context(void)
89 {
90 TRACE( "destroying %p\n", libnetapi_ctx );
91 plibnetapi_free( libnetapi_ctx );
92 libnetapi_ctx = NULL;
93 }
94
95 static BOOL init_context(void)
96 {
97 DWORD status;
98
99 if ((status = plibnetapi_init( &libnetapi_ctx )))
100 {
101 ERR( "Failed to initialize context %u\n", status );
102 return FALSE;
103 }
104 if (TRACE_ON( netapi32 ) && (status = plibnetapi_set_debuglevel( libnetapi_ctx, "10" )))
105 {
106 ERR( "Failed to set debug level %u\n", status );
107 destroy_context();
108 return FALSE;
109 }
110 /* perform an anonymous login by default (avoids a password prompt) */
111 if ((status = plibnetapi_set_username( libnetapi_ctx, "Guest" )))
112 {
113 ERR( "Failed to set username %u\n", status );
114 destroy_context();
115 return FALSE;
116 }
117 if ((status = plibnetapi_set_password( libnetapi_ctx, "" )))
118 {
119 ERR( "Failed to set password %u\n", status );
120 destroy_context();
121 return FALSE;
122 }
123 TRACE( "using %p\n", libnetapi_ctx );
124 return TRUE;
125 }
126
127 static BOOL libnetapi_init(void)
128 {
129 char buf[200];
130
131 if (libnetapi_handle) return TRUE;
132 if (!(libnetapi_handle = wine_dlopen( SONAME_LIBNETAPI, RTLD_NOW, buf, sizeof(buf) )))
133 {
134 WARN( "Failed to load libnetapi: %s\n", buf );
135 return FALSE;
136 }
137
138 #define LOAD_FUNCPTR(f) \
139 if (!(p##f = wine_dlsym( libnetapi_handle, #f, buf, sizeof(buf) ))) \
140 { \
141 ERR( "Failed to load %s: %s\n", #f, buf ); \
142 goto error; \
143 }
144
145 LOAD_FUNCPTR(libnetapi_init)
146 LOAD_FUNCPTR(libnetapi_free)
147 LOAD_FUNCPTR(libnetapi_set_debuglevel)
148 LOAD_FUNCPTR(libnetapi_set_username)
149 LOAD_FUNCPTR(libnetapi_set_password)
150
151 LOAD_FUNCPTR(NetApiBufferAllocate)
152 LOAD_FUNCPTR(NetApiBufferFree)
153 LOAD_FUNCPTR(NetServerGetInfo)
154 LOAD_FUNCPTR(NetShareAdd)
155 LOAD_FUNCPTR(NetShareDel)
156 LOAD_FUNCPTR(NetWkstaGetInfo)
157 #undef LOAD_FUNCPTR
158
159 if (init_context()) return TRUE;
160
161 error:
162 wine_dlclose( libnetapi_handle, NULL, 0 );
163 libnetapi_handle = NULL;
164 return FALSE;
165 }
166
167 struct server_info_101
168 {
169 unsigned int sv101_platform_id;
170 const char *sv101_name;
171 unsigned int sv101_version_major;
172 unsigned int sv101_version_minor;
173 unsigned int sv101_type;
174 const char *sv101_comment;
175 };
176
177 static NET_API_STATUS server_info_101_from_samba( const unsigned char *buf, BYTE **bufptr )
178 {
179 SERVER_INFO_101 *ret;
180 struct server_info_101 *info = (struct server_info_101 *)buf;
181 DWORD len = 0;
182 WCHAR *ptr;
183
184 if (info->sv101_name) len += MultiByteToWideChar( CP_UNIXCP, 0, info->sv101_name, -1, NULL, 0 );
185 if (info->sv101_comment) len += MultiByteToWideChar( CP_UNIXCP, 0, info->sv101_comment, -1, NULL, 0 );
186 if (!(ret = HeapAlloc( GetProcessHeap(), 0, sizeof(*ret) + (len * sizeof(WCHAR) ))))
187 return ERROR_OUTOFMEMORY;
188
189 ptr = (WCHAR *)(ret + 1);
190 ret->sv101_platform_id = info->sv101_platform_id;
191 if (!info->sv101_name) ret->sv101_name = NULL;
192 else
193 {
194 ret->sv101_name = ptr;
195 ptr += MultiByteToWideChar( CP_UNIXCP, 0, info->sv101_name, -1, ptr, len );
196 }
197 ret->sv101_version_major = info->sv101_version_major;
198 ret->sv101_version_minor = info->sv101_version_minor;
199 ret->sv101_type = info->sv101_type;
200 if (!info->sv101_comment) ret->sv101_comment = NULL;
201 else
202 {
203 ret->sv101_comment = ptr;
204 MultiByteToWideChar( CP_UNIXCP, 0, info->sv101_comment, -1, ptr, len );
205 }
206 *bufptr = (BYTE *)ret;
207 return NERR_Success;
208 }
209
210 static NET_API_STATUS server_info_from_samba( DWORD level, const unsigned char *buf, BYTE **bufptr )
211 {
212 switch (level)
213 {
214 case 101: return server_info_101_from_samba( buf, bufptr );
215 default:
216 FIXME( "level %u not supported\n", level );
217 return ERROR_NOT_SUPPORTED;
218 }
219 }
220
221 static NET_API_STATUS server_getinfo( LMSTR servername, DWORD level, LPBYTE *bufptr )
222 {
223 NET_API_STATUS status;
224 char *server = NULL;
225 unsigned char *buf = NULL;
226
227 if (servername && !(server = strdup_unixcp( servername ))) return ERROR_OUTOFMEMORY;
228 status = pNetServerGetInfo( server, level, &buf );
229 HeapFree( GetProcessHeap(), 0, server );
230 if (!status)
231 {
232 status = server_info_from_samba( level, buf, bufptr );
233 pNetApiBufferFree( buf );
234 }
235 return status;
236 }
237
238 struct share_info_2
239 {
240 const char *shi2_netname;
241 unsigned int shi2_type;
242 const char *shi2_remark;
243 unsigned int shi2_permissions;
244 unsigned int shi2_max_uses;
245 unsigned int shi2_current_uses;
246 const char *shi2_path;
247 const char *shi2_passwd;
248 };
249
250 static NET_API_STATUS share_info_2_to_samba( const BYTE *buf, unsigned char **bufptr )
251 {
252 struct share_info_2 *ret;
253 SHARE_INFO_2 *info = (SHARE_INFO_2 *)buf;
254 DWORD len = 0;
255 char *ptr;
256
257 if (info->shi2_netname)
258 len += WideCharToMultiByte( CP_UNIXCP, 0, info->shi2_netname, -1, NULL, 0, NULL, NULL );
259 if (info->shi2_remark)
260 len += WideCharToMultiByte( CP_UNIXCP, 0, info->shi2_remark, -1, NULL, 0, NULL, NULL );
261 if (info->shi2_path)
262 len += WideCharToMultiByte( CP_UNIXCP, 0, info->shi2_path, -1, NULL, 0, NULL, NULL );
263 if (info->shi2_passwd)
264 len += WideCharToMultiByte( CP_UNIXCP, 0, info->shi2_passwd, -1, NULL, 0, NULL, NULL );
265 if (!(ret = HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*ret) + len )))
266 return ERROR_OUTOFMEMORY;
267
268 ptr = (char *)(ret + 1);
269 if (!info->shi2_netname) ret->shi2_netname = NULL;
270 else
271 {
272 ret->shi2_netname = ptr;
273 ptr += WideCharToMultiByte( CP_UNIXCP, 0, info->shi2_netname, -1, ptr, len, NULL, NULL );
274 }
275 ret->shi2_type = info->shi2_type;
276 if (!info->shi2_remark) ret->shi2_remark = NULL;
277 else
278 {
279 ret->shi2_remark = ptr;
280 ptr += WideCharToMultiByte( CP_UNIXCP, 0, info->shi2_remark, -1, ptr, len, NULL, NULL );
281 }
282 ret->shi2_permissions = info->shi2_permissions;
283 ret->shi2_max_uses = info->shi2_max_uses;
284 ret->shi2_current_uses = info->shi2_current_uses;
285 if (!info->shi2_path) ret->shi2_path = NULL;
286 else
287 {
288 ret->shi2_path = ptr;
289 ptr += WideCharToMultiByte( CP_UNIXCP, 0, info->shi2_path, -1, ptr, len, NULL, NULL );
290 }
291 if (!info->shi2_passwd) ret->shi2_passwd = NULL;
292 else
293 {
294 ret->shi2_passwd = ptr;
295 WideCharToMultiByte( CP_UNIXCP, 0, info->shi2_passwd, -1, ptr, len, NULL, NULL );
296 }
297 *bufptr = (unsigned char *)ret;
298 return NERR_Success;
299 }
300
301 struct sid
302 {
303 unsigned char sid_rev_num;
304 unsigned char num_auths;
305 unsigned char id_auth[6];
306 unsigned int sub_auths[15];
307 };
308
309 enum ace_type
310 {
311 ACE_TYPE_ACCESS_ALLOWED,
312 ACE_TYPE_ACCESS_DENIED,
313 ACE_TYPE_SYSTEM_AUDIT,
314 ACE_TYPE_SYSTEM_ALARM,
315 ACE_TYPE_ALLOWED_COMPOUND,
316 ACE_TYPE_ACCESS_ALLOWED_OBJECT,
317 ACE_TYPE_ACCESS_DENIED_OBJECT,
318 ACE_TYPE_SYSTEM_AUDIT_OBJECT,
319 ACE_TYPE_SYSTEM_ALARM_OBJECT
320 };
321
322 #define SEC_ACE_FLAG_OBJECT_INHERIT 0x01
323 #define SEC_ACE_FLAG_CONTAINER_INHERIT 0x02
324 #define SEC_ACE_FLAG_NO_PROPAGATE_INHERIT 0x04
325 #define SEC_ACE_FLAG_INHERIT_ONLY 0x08
326 #define SEC_ACE_FLAG_INHERITED_ACE 0x10
327 #define SEC_ACE_FLAG_SUCCESSFUL_ACCESS 0x40
328 #define SEC_ACE_FLAG_FAILED_ACCESS 0x80
329
330 struct guid
331 {
332 unsigned int time_low;
333 unsigned short time_mid;
334 unsigned short time_hi_and_version;
335 unsigned char clock_seq[2];
336 unsigned char node[6];
337 };
338
339 union ace_object_type
340 {
341 struct guid type;
342 };
343
344 union ace_object_inherited_type
345 {
346 struct guid inherited_type;
347 };
348
349 struct ace_object
350 {
351 unsigned int flags;
352 union ace_object_type type;
353 union ace_object_inherited_type inherited_type;
354 };
355
356 union ace_object_ctr
357 {
358 struct ace_object object;
359 };
360
361 struct ace
362 {
363 enum ace_type type;
364 unsigned char flags;
365 unsigned short size;
366 unsigned int access_mask;
367 union ace_object_ctr object;
368 struct sid trustee;
369 };
370
371 enum acl_revision
372 {
373 ACL_REVISION_NT4 = 2,
374 ACL_REVISION_ADS = 4
375 };
376
377 struct acl
378 {
379 enum acl_revision revision;
380 unsigned short size;
381 unsigned int num_aces;
382 struct ace *aces;
383 };
384
385 enum security_descriptor_revision
386 {
387 SECURITY_DESCRIPTOR_REVISION_1 = 1
388 };
389
390 #define SEC_DESC_OWNER_DEFAULTED 0x0001
391 #define SEC_DESC_GROUP_DEFAULTED 0x0002
392 #define SEC_DESC_DACL_PRESENT 0x0004
393 #define SEC_DESC_DACL_DEFAULTED 0x0008
394 #define SEC_DESC_SACL_PRESENT 0x0010
395 #define SEC_DESC_SACL_DEFAULTED 0x0020
396 #define SEC_DESC_DACL_TRUSTED 0x0040
397 #define SEC_DESC_SERVER_SECURITY 0x0080
398 #define SEC_DESC_DACL_AUTO_INHERIT_REQ 0x0100
399 #define SEC_DESC_SACL_AUTO_INHERIT_REQ 0x0200
400 #define SEC_DESC_DACL_AUTO_INHERITED 0x0400
401 #define SEC_DESC_SACL_AUTO_INHERITED 0x0800
402 #define SEC_DESC_DACL_PROTECTED 0x1000
403 #define SEC_DESC_SACL_PROTECTED 0x2000
404 #define SEC_DESC_RM_CONTROL_VALID 0x4000
405 #define SEC_DESC_SELF_RELATIVE 0x8000
406
407 struct security_descriptor
408 {
409 enum security_descriptor_revision revision;
410 unsigned short type;
411 struct sid *owner_sid;
412 struct sid *group_sid;
413 struct acl *sacl;
414 struct acl *dacl;
415 };
416
417 struct share_info_502
418 {
419 const char *shi502_netname;
420 unsigned int shi502_type;
421 const char *shi502_remark;
422 unsigned int shi502_permissions;
423 unsigned int shi502_max_uses;
424 unsigned int shi502_current_uses;
425 const char *shi502_path;
426 const char *shi502_passwd;
427 unsigned int shi502_reserved;
428 struct security_descriptor *shi502_security_descriptor;
429 };
430
431 static unsigned short sd_control_to_samba( SECURITY_DESCRIPTOR_CONTROL control )
432 {
433 unsigned short ret = 0;
434
435 if (control & SE_OWNER_DEFAULTED) ret |= SEC_DESC_OWNER_DEFAULTED;
436 if (control & SE_GROUP_DEFAULTED) ret |= SEC_DESC_GROUP_DEFAULTED;
437 if (control & SE_DACL_PRESENT) ret |= SEC_DESC_DACL_PRESENT;
438 if (control & SE_DACL_DEFAULTED) ret |= SEC_DESC_DACL_DEFAULTED;
439 if (control & SE_SACL_PRESENT) ret |= SEC_DESC_SACL_PRESENT;
440 if (control & SE_SACL_DEFAULTED) ret |= SEC_DESC_SACL_DEFAULTED;
441 if (control & SE_DACL_AUTO_INHERIT_REQ) ret |= SEC_DESC_DACL_AUTO_INHERIT_REQ;
442 if (control & SE_SACL_AUTO_INHERIT_REQ) ret |= SEC_DESC_SACL_AUTO_INHERIT_REQ;
443 if (control & SE_DACL_AUTO_INHERITED) ret |= SEC_DESC_DACL_AUTO_INHERITED;
444 if (control & SE_SACL_AUTO_INHERITED) ret |= SEC_DESC_SACL_AUTO_INHERITED;
445 if (control & SE_DACL_PROTECTED) ret |= SEC_DESC_DACL_PROTECTED;
446 if (control & SE_SACL_PROTECTED) ret |= SEC_DESC_SACL_PROTECTED;
447 if (control & SE_RM_CONTROL_VALID) ret |= SEC_DESC_RM_CONTROL_VALID;
448 return ret;
449 }
450
451 static NET_API_STATUS sid_to_samba( const SID *src, struct sid *dst )
452 {
453 unsigned int i;
454
455 if (src->Revision != 1)
456 {
457 ERR( "unknown revision %u\n", src->Revision );
458 return ERROR_UNKNOWN_REVISION;
459 }
460 if (src->SubAuthorityCount > SID_MAX_SUB_AUTHORITIES)
461 {
462 WARN( "invalid subauthority count %u\n", src->SubAuthorityCount );
463 return ERROR_INVALID_PARAMETER;
464 }
465 dst->sid_rev_num = SECURITY_DESCRIPTOR_REVISION_1;
466 dst->num_auths = src->SubAuthorityCount;
467 for (i = 0; i < 6; i++) dst->id_auth[i] = src->IdentifierAuthority.Value[i];
468 for (i = 0; i < dst->num_auths; i++) dst->sub_auths[i] = src->SubAuthority[i];
469 return NERR_Success;
470 }
471
472 static enum ace_type ace_type_to_samba( BYTE type )
473 {
474 switch (type)
475 {
476 case ACCESS_ALLOWED_ACE_TYPE: return ACE_TYPE_ACCESS_ALLOWED;
477 case ACCESS_DENIED_ACE_TYPE: return ACE_TYPE_ACCESS_DENIED;
478 case SYSTEM_AUDIT_ACE_TYPE: return ACE_TYPE_SYSTEM_AUDIT;
479 case SYSTEM_ALARM_ACE_TYPE: return ACE_TYPE_SYSTEM_ALARM;
480 default:
481 ERR( "unhandled type %u\n", type );
482 return 0;
483 }
484 }
485
486 static unsigned char ace_flags_to_samba( BYTE flags )
487 {
488 static const BYTE known_flags =
489 OBJECT_INHERIT_ACE | CONTAINER_INHERIT_ACE | NO_PROPAGATE_INHERIT_ACE |
490 INHERIT_ONLY_ACE | INHERITED_ACE | SUCCESSFUL_ACCESS_ACE_FLAG | FAILED_ACCESS_ACE_FLAG;
491 unsigned char ret = 0;
492
493 if (flags & ~known_flags)
494 {
495 ERR( "unknown flags %x\n", flags & ~known_flags );
496 return 0;
497 }
498 if (flags & OBJECT_INHERIT_ACE) ret |= SEC_ACE_FLAG_OBJECT_INHERIT;
499 if (flags & CONTAINER_INHERIT_ACE) ret |= SEC_ACE_FLAG_NO_PROPAGATE_INHERIT;
500 if (flags & NO_PROPAGATE_INHERIT_ACE) ret |= SEC_ACE_FLAG_NO_PROPAGATE_INHERIT;
501 if (flags & INHERIT_ONLY_ACE) ret |= SEC_ACE_FLAG_INHERIT_ONLY;
502 if (flags & INHERITED_ACE) ret |= SEC_ACE_FLAG_INHERITED_ACE;
503 if (flags & SUCCESSFUL_ACCESS_ACE_FLAG) ret |= SEC_ACE_FLAG_SUCCESSFUL_ACCESS;
504 if (flags & FAILED_ACCESS_ACE_FLAG) ret |= SEC_ACE_FLAG_FAILED_ACCESS;
505 return ret;
506 }
507
508 #define GENERIC_ALL_ACCESS (1 << 28)
509 #define GENERIC_EXECUTE_ACCESS (1 << 29)
510 #define GENERIC_WRITE_ACCESS (1 << 30)
511 #define GENERIC_READ_ACCESS (1 << 31)
512
513 unsigned int access_mask_to_samba( DWORD mask )
514 {
515 static const DWORD known_rights =
516 GENERIC_ALL | GENERIC_EXECUTE | GENERIC_WRITE | GENERIC_READ;
517 unsigned int ret = 0;
518
519 if (mask & ~known_rights)
520 {
521 ERR( "unknown rights %x\n", mask & ~known_rights );
522 return 0;
523 }
524 if (mask & GENERIC_ALL) ret |= GENERIC_ALL_ACCESS;
525 if (mask & GENERIC_EXECUTE) ret |= GENERIC_EXECUTE_ACCESS;
526 if (mask & GENERIC_WRITE) ret |= GENERIC_WRITE_ACCESS;
527 if (mask & GENERIC_READ) ret |= GENERIC_READ_ACCESS;
528 return ret;
529 }
530
531 static NET_API_STATUS ace_to_samba( const ACE_HEADER *src, struct ace *dst )
532 {
533 dst->type = ace_type_to_samba( src->AceType );
534 dst->flags = ace_flags_to_samba( src->AceFlags );
535 dst->size = sizeof(*dst);
536 switch (src->AceType)
537 {
538 case ACCESS_ALLOWED_ACE_TYPE:
539 {
540 ACCESS_ALLOWED_ACE *ace = (ACCESS_ALLOWED_ACE *)src;
541 dst->access_mask = access_mask_to_samba( ace->Mask );
542 memset( &dst->object, 0, sizeof(dst->object) );
543 sid_to_samba( (const SID *)&ace->SidStart, &dst->trustee );
544 }
545 case ACCESS_DENIED_ACE_TYPE:
546 {
547 ACCESS_DENIED_ACE *ace = (ACCESS_DENIED_ACE *)src;
548 dst->access_mask = access_mask_to_samba( ace->Mask );
549 memset( &dst->object, 0, sizeof(dst->object) );
550 sid_to_samba( (const SID *)&ace->SidStart, &dst->trustee );
551 }
552 case SYSTEM_AUDIT_ACE_TYPE:
553 {
554 SYSTEM_AUDIT_ACE *ace = (SYSTEM_AUDIT_ACE *)src;
555 dst->access_mask = access_mask_to_samba( ace->Mask );
556 memset( &dst->object, 0, sizeof(dst->object) );
557 sid_to_samba( (const SID *)&ace->SidStart, &dst->trustee );
558 }
559 case SYSTEM_ALARM_ACE_TYPE:
560 {
561 SYSTEM_ALARM_ACE *ace = (SYSTEM_ALARM_ACE *)src;
562 dst->access_mask = access_mask_to_samba( ace->Mask );
563 memset( &dst->object, 0, sizeof(dst->object) );
564 sid_to_samba( (const SID *)&ace->SidStart, &dst->trustee );
565 }
566 default:
567 ERR( "unhandled type %u\n", src->AceType );
568 return ERROR_INVALID_PARAMETER;
569 }
570 return NERR_Success;
571 }
572
573 static NET_API_STATUS acl_to_samba( const ACL *src, struct acl *dst )
574 {
575 NET_API_STATUS status;
576 ACE_HEADER *src_ace;
577 unsigned int i;
578
579 switch (src->AclRevision)
580 {
581 case ACL_REVISION4:
582 dst->revision = ACL_REVISION_ADS;
583 break;
584 default:
585 ERR( "unkhandled revision %u\n", src->AclRevision );
586 return ERROR_UNKNOWN_REVISION;
587 }
588 dst->size = sizeof(*dst);
589 src_ace = (ACE_HEADER *)(src + 1);
590 dst->aces = (struct ace *)(dst + 1);
591 for (i = 0; i < src->AceCount; i++)
592 {
593 if ((status = ace_to_samba( src_ace, &dst->aces[i] ))) return status;
594 src_ace = (ACE_HEADER *)((char *)src_ace + src_ace->AceSize);
595 dst->size += dst->aces[i].size;
596 }
597 return NERR_Success;
598 }
599
600 #define SELF_RELATIVE_FIELD(sd,field)\
601 ((char *)(sd) + ((SECURITY_DESCRIPTOR_RELATIVE *)(sd))->field)
602
603 static NET_API_STATUS sd_to_samba( const SECURITY_DESCRIPTOR *src, struct security_descriptor *dst )
604 {
605 NET_API_STATUS status;
606 const SID *owner, *group;
607 const ACL *dacl, *sacl;
608 unsigned int offset = sizeof(*dst);
609
610 if (src->Revision != SECURITY_DESCRIPTOR_REVISION1)
611 return ERROR_UNKNOWN_REVISION;
612
613 dst->revision = SECURITY_DESCRIPTOR_REVISION_1;
614 dst->type = sd_control_to_samba( src->Control );
615
616 if (src->Control & SE_SELF_RELATIVE)
617 {
618 if (!src->Owner) dst->owner_sid = NULL;
619 else
620 {
621 dst->owner_sid = (struct sid *)((char *)dst + offset);
622 owner = (const SID *)SELF_RELATIVE_FIELD( src, Owner );
623 if ((status = sid_to_samba( owner, dst->owner_sid ))) return status;
624 offset += sizeof(struct sid);
625 }
626 if (!src->Group) dst->group_sid = NULL;
627 else
628 {
629 dst->group_sid = (struct sid *)((char *)dst + offset);
630 group = (const SID *)SELF_RELATIVE_FIELD( src, Group );
631 if ((status = sid_to_samba( group, dst->group_sid ))) return status;
632 offset += sizeof(struct sid);
633 }
634 if (!(src->Control & SE_SACL_PRESENT)) dst->sacl = NULL;
635 else
636 {
637 dst->sacl = (struct acl *)((char *)dst + offset);
638 sacl = (const ACL *)SELF_RELATIVE_FIELD( src, Sacl );
639 if ((status = acl_to_samba( sacl, dst->sacl ))) return status;
640 offset += dst->sacl->size;
641 }
642 if (!(src->Control & SE_DACL_PRESENT)) dst->dacl = NULL;
643 else
644 {
645 dst->dacl = (struct acl *)((char *)dst + offset);
646 dacl = (const ACL *)SELF_RELATIVE_FIELD( src, Dacl );
647 if ((status = acl_to_samba( dacl, dst->dacl ))) return status;
648 }
649 }
650 else
651 {
652 if (!src->Owner) dst->owner_sid = NULL;
653 else
654 {
655 dst->owner_sid = (struct sid *)((char *)dst + offset);
656 if ((status = sid_to_samba( src->Owner, dst->owner_sid ))) return status;
657 offset += sizeof(struct sid);
658 }
659 if (!src->Group) dst->group_sid = NULL;
660 else
661 {
662 dst->group_sid = (struct sid *)((char *)dst + offset);
663 if ((status = sid_to_samba( src->Group, dst->group_sid ))) return status;
664 offset += sizeof(struct sid);
665 }
666 if (!(src->Control & SE_SACL_PRESENT)) dst->sacl = NULL;
667 else
668 {
669 dst->sacl = (struct acl *)((char *)dst + offset);
670 if ((status = acl_to_samba( src->Sacl, dst->sacl ))) return status;
671 offset += dst->sacl->size;
672 }
673 if (!(src->Control & SE_DACL_PRESENT)) dst->dacl = NULL;
674 else
675 {
676 dst->dacl = (struct acl *)((char *)dst + offset);
677 if ((status = acl_to_samba( src->Dacl, dst->dacl ))) return status;
678 }
679 }
680 return NERR_Success;
681 }
682
683 static unsigned int sd_to_samba_size( const SECURITY_DESCRIPTOR *sd )
684 {
685 unsigned int ret = sizeof(struct security_descriptor);
686
687 if (sd->Owner) ret += sizeof(struct sid);
688 if (sd->Group) ret += sizeof(struct sid);
689 if (sd->Control & SE_SACL_PRESENT)
690 ret += sizeof(struct acl) + sd->Sacl->AceCount * sizeof(struct ace);
691 if (sd->Control & SE_DACL_PRESENT)
692 ret += sizeof(struct acl) + sd->Dacl->AceCount * sizeof(struct ace);
693 return ret;
694 }
695
696 static NET_API_STATUS share_info_502_to_samba( const BYTE *buf, unsigned char **bufptr )
697 {
698 NET_API_STATUS status;
699 struct share_info_502 *ret;
700 SHARE_INFO_502 *info = (SHARE_INFO_502 *)buf;
701 DWORD len = 0, size = 0;
702 char *ptr;
703
704 *bufptr = NULL;
705 if (info->shi502_netname)
706 len += WideCharToMultiByte( CP_UNIXCP, 0, info->shi502_netname, -1, NULL, 0, NULL, NULL );
707 if (info->shi502_remark)
708 len += WideCharToMultiByte( CP_UNIXCP, 0, info->shi502_remark, -1, NULL, 0, NULL, NULL );
709 if (info->shi502_path)
710 len += WideCharToMultiByte( CP_UNIXCP, 0, info->shi502_path, -1, NULL, 0, NULL, NULL );
711 if (info->shi502_passwd)
712 len += WideCharToMultiByte( CP_UNIXCP, 0, info->shi502_passwd, -1, NULL, 0, NULL, NULL );
713 if (info->shi502_security_descriptor)
714 size = sd_to_samba_size( info->shi502_security_descriptor );
715 if (!(ret = HeapAlloc( GetProcessHeap(), 0, sizeof(*ret) + (len * sizeof(WCHAR)) + size )))
716 return ERROR_OUTOFMEMORY;
717
718 ptr = (char *)(ret + 1);
719 if (!info->shi502_netname) ret->shi502_netname = NULL;
720 else
721 {
722 ret->shi502_netname = ptr;
723 ptr += WideCharToMultiByte( CP_UNIXCP, 0, info->shi502_netname, -1, ptr, len, NULL, NULL );
724 }
725 ret->shi502_type = info->shi502_type;
726 if (!info->shi502_remark) ret->shi502_remark = NULL;
727 else
728 {
729 ret->shi502_remark = ptr;
730 ptr += WideCharToMultiByte( CP_UNIXCP, 0, info->shi502_remark, -1, ptr, len, NULL, NULL );
731 }
732 ret->shi502_permissions = info->shi502_permissions;
733 ret->shi502_max_uses = info->shi502_max_uses;
734 ret->shi502_current_uses = info->shi502_current_uses;
735 if (!info->shi502_path) ret->shi502_path = NULL;
736 else
737 {
738 ret->shi502_path = ptr;
739 ptr += WideCharToMultiByte( CP_UNIXCP, 0, info->shi502_path, -1, ptr, len, NULL, NULL );
740 }
741 if (!info->shi502_passwd) ret->shi502_passwd = NULL;
742 else
743 {
744 ret->shi502_passwd = ptr;
745 ptr += WideCharToMultiByte( CP_UNIXCP, 0, info->shi502_passwd, -1, ptr, len, NULL, NULL );
746 }
747 ret->shi502_reserved = info->shi502_reserved;
748 if (!info->shi502_security_descriptor) ret->shi502_security_descriptor = NULL;
749 else
750 {
751 status = sd_to_samba( info->shi502_security_descriptor, (struct security_descriptor *)ptr );
752 if (status)
753 {
754 HeapFree( GetProcessHeap(), 0, ret );
755 return status;
756 }
757 ret->shi502_security_descriptor = (struct security_descriptor *)ptr;
758 }
759 *bufptr = (unsigned char *)ret;
760 return NERR_Success;
761 }
762
763 static NET_API_STATUS share_info_to_samba( DWORD level, const BYTE *buf, unsigned char **bufptr )
764 {
765 switch (level)
766 {
767 case 2: return share_info_2_to_samba( buf, bufptr );
768 case 502: return share_info_502_to_samba( buf, bufptr );
769 default:
770 FIXME( "level %u not supported\n", level );
771 return ERROR_NOT_SUPPORTED;
772 }
773 }
774
775 static NET_API_STATUS share_add( LMSTR servername, DWORD level, LPBYTE buf, LPDWORD parm_err )
776 {
777 char *server = NULL;
778 unsigned char *info;
779 NET_API_STATUS status;
780
781 if (servername && !(server = strdup_unixcp( servername ))) return ERROR_OUTOFMEMORY;
782 status = share_info_to_samba( level, buf, &info );
783 if (!status)
784 {
785 unsigned int err;
786
787 status = pNetShareAdd( server, level, info, &err );
788 HeapFree( GetProcessHeap(), 0, info );
789 if (parm_err) *parm_err = err;
790 }
791 HeapFree( GetProcessHeap(), 0, server );
792 return status;
793 }
794
795 static NET_API_STATUS share_del( LMSTR servername, LMSTR netname, DWORD reserved )
796 {
797 char *server = NULL, *share;
798 NET_API_STATUS status;
799
800 if (servername && !(server = strdup_unixcp( servername ))) return ERROR_OUTOFMEMORY;
801 if (!(share = strdup_unixcp( netname )))
802 {
803 HeapFree( GetProcessHeap(), 0, server );
804 return ERROR_OUTOFMEMORY;
805 }
806 status = pNetShareDel( server, share, reserved );
807 HeapFree( GetProcessHeap(), 0, server );
808 HeapFree( GetProcessHeap(), 0, share );
809 return status;
810 }
811
812 struct wksta_info_100
813 {
814 unsigned int wki100_platform_id;
815 const char *wki100_computername;
816 const char *wki100_langroup;
817 unsigned int wki100_ver_major;
818 unsigned int wki100_ver_minor;
819 };
820
821 static NET_API_STATUS wksta_info_100_from_samba( const unsigned char *buf, BYTE **bufptr )
822 {
823 WKSTA_INFO_100 *ret;
824 struct wksta_info_100 *info = (struct wksta_info_100 *)buf;
825 DWORD len = 0;
826 WCHAR *ptr;
827
828 if (info->wki100_computername)
829 len += MultiByteToWideChar( CP_UNIXCP, 0, info->wki100_computername, -1, NULL, 0 );
830 if (info->wki100_langroup)
831 len += MultiByteToWideChar( CP_UNIXCP, 0, info->wki100_langroup, -1, NULL, 0 );
832 if (!(ret = HeapAlloc( GetProcessHeap(), 0, sizeof(*ret) + (len * sizeof(WCHAR) ))))
833 return ERROR_OUTOFMEMORY;
834
835 ptr = (WCHAR *)(ret + 1);
836 ret->wki100_platform_id = info->wki100_platform_id;
837 if (!info->wki100_computername) ret->wki100_computername = NULL;
838 else
839 {
840 ret->wki100_computername = ptr;
841 ptr += MultiByteToWideChar( CP_UNIXCP, 0, info->wki100_computername, -1, ptr, len );
842 }
843 if (!info->wki100_langroup) ret->wki100_langroup = NULL;
844 else
845 {
846 ret->wki100_langroup = ptr;
847 MultiByteToWideChar( CP_UNIXCP, 0, info->wki100_langroup, -1, ptr, len );
848 }
849 ret->wki100_ver_major = info->wki100_ver_major;
850 ret->wki100_ver_minor = info->wki100_ver_minor;
851 *bufptr = (BYTE *)ret;
852 return NERR_Success;
853 }
854
855 static NET_API_STATUS wksta_info_from_samba( DWORD level, const unsigned char *buf, BYTE **bufptr )
856 {
857 switch (level)
858 {
859 case 100: return wksta_info_100_from_samba( buf, bufptr );
860 default:
861 FIXME( "level %u not supported\n", level );
862 return ERROR_NOT_SUPPORTED;
863 }
864 }
865
866 static NET_API_STATUS wksta_getinfo( LMSTR servername, DWORD level, LPBYTE *bufptr )
867 {
868 NET_API_STATUS status;
869 char *wksta = NULL;
870 unsigned char *buf = NULL;
871
872 if (servername && !(wksta = strdup_unixcp( servername ))) return ERROR_OUTOFMEMORY;
873 status = pNetWkstaGetInfo( wksta, level, &buf );
874 HeapFree( GetProcessHeap(), 0, wksta );
875 if (!status)
876 {
877 status = wksta_info_from_samba( level, buf, bufptr );
878 pNetApiBufferFree( buf );
879 }
880 return status;
881 }
882
883 #else
884
885 static BOOL libnetapi_init(void)
886 {
887 return FALSE;
888 }
889
890 static NET_API_STATUS server_getinfo( LMSTR servername, DWORD level, LPBYTE *bufptr )
891 {
892 ERR( "\n" );
893 return ERROR_NOT_SUPPORTED;
894 }
895 static NET_API_STATUS share_add( LMSTR servername, DWORD level, LPBYTE buf, LPDWORD parm_err )
896 {
897 ERR( "\n" );
898 return ERROR_NOT_SUPPORTED;
899 }
900 static NET_API_STATUS share_del( LMSTR servername, LMSTR netname, DWORD reserved )
901 {
902 ERR( "\n" );
903 return ERROR_NOT_SUPPORTED;
904 }
905 static NET_API_STATUS wksta_getinfo( LMSTR servername, DWORD level, LPBYTE *bufptr )
906 {
907 ERR( "\n" );
908 return ERROR_NOT_SUPPORTED;
909 }
910
911 #endif /* SONAME_LIBNETAPI */
912
913 /************************************************************
914 * NETAPI_IsLocalComputer
915 *
916 * Checks whether the server name indicates local machine.
917 */
918 static BOOL NETAPI_IsLocalComputer( LMCSTR name )
919 {
920 WCHAR buf[MAX_COMPUTERNAME_LENGTH + 1];
921 DWORD size = sizeof(buf) / sizeof(buf[0]);
922 BOOL ret;
923
924 if (!name || !name[0]) return TRUE;
925
926 ret = GetComputerNameW( buf, &size );
927 if (ret && name[0] == '\\' && name[1] == '\\') name += 2;
928 return ret && !strcmpiW( name, buf );
929 }
930
931 BOOL WINAPI DllMain (HINSTANCE hinstDLL, DWORD fdwReason, LPVOID lpvReserved)
932 {
933 TRACE("%p,%x,%p\n", hinstDLL, fdwReason, lpvReserved);
934
935 switch (fdwReason) {
936 case DLL_PROCESS_ATTACH:
937 DisableThreadLibraryCalls(hinstDLL);
938 NetBIOSInit();
939 NetBTInit();
940 break;
941 case DLL_PROCESS_DETACH:
942 if (lpvReserved) break;
943 NetBIOSShutdown();
944 break;
945 }
946
947 return TRUE;
948 }
949
950 /************************************************************
951 * NetServerEnum (NETAPI32.@)
952 */
953 NET_API_STATUS WINAPI NetServerEnum(
954 LMCSTR servername,
955 DWORD level,
956 LPBYTE* bufptr,
957 DWORD prefmaxlen,
958 LPDWORD entriesread,
959 LPDWORD totalentries,
960 DWORD servertype,
961 LMCSTR domain,
962 LPDWORD resume_handle
963 )
964 {
965 FIXME("Stub (%s %d %p %d %p %p %d %s %p)\n", debugstr_w(servername),
966 level, bufptr, prefmaxlen, entriesread, totalentries, servertype,
967 debugstr_w(domain), resume_handle);
968
969 return ERROR_NO_BROWSER_SERVERS_FOUND;
970 }
971
972 /************************************************************
973 * NetServerEnumEx (NETAPI32.@)
974 */
975 NET_API_STATUS WINAPI NetServerEnumEx(
976 LMCSTR ServerName,
977 DWORD Level,
978 LPBYTE *Bufptr,
979 DWORD PrefMaxlen,
980 LPDWORD EntriesRead,
981 LPDWORD totalentries,
982 DWORD servertype,
983 LMCSTR domain,
984 LMCSTR FirstNameToReturn)
985 {
986 FIXME("Stub (%s %d %p %d %p %p %d %s %s)\n",
987 debugstr_w(ServerName), Level, Bufptr, PrefMaxlen, EntriesRead, totalentries,
988 servertype, debugstr_w(domain), debugstr_w(FirstNameToReturn));
989
990 return ERROR_NO_BROWSER_SERVERS_FOUND;
991 }
992
993 /************************************************************
994 * NetServerDiskEnum (NETAPI32.@)
995 */
996 NET_API_STATUS WINAPI NetServerDiskEnum(
997 LMCSTR ServerName,
998 DWORD Level,
999 LPBYTE *Bufptr,
1000 DWORD PrefMaxlen,
1001 LPDWORD EntriesRead,
1002 LPDWORD totalentries,
1003 LPDWORD Resume_Handle)
1004 {
1005 FIXME("Stub (%s %d %p %d %p %p %p)\n", debugstr_w(ServerName),
1006 Level, Bufptr, PrefMaxlen, EntriesRead, totalentries, Resume_Handle);
1007
1008 return ERROR_NO_BROWSER_SERVERS_FOUND;
1009 }
1010
1011 /************************************************************
1012 * NetServerGetInfo (NETAPI32.@)
1013 */
1014 NET_API_STATUS WINAPI NetServerGetInfo(LMSTR servername, DWORD level, LPBYTE* bufptr)
1015 {
1016 NET_API_STATUS ret;
1017 BOOL local = NETAPI_IsLocalComputer( servername );
1018
1019 TRACE("%s %d %p\n", debugstr_w( servername ), level, bufptr );
1020
1021 if (!local)
1022 {
1023 if (libnetapi_init()) return server_getinfo( servername, level, bufptr );
1024 FIXME( "remote computers not supported\n" );
1025 return ERROR_INVALID_LEVEL;
1026 }
1027 if (!bufptr) return ERROR_INVALID_PARAMETER;
1028
1029 switch (level)
1030 {
1031 case 100:
1032 case 101:
1033 {
1034 DWORD computerNameLen, size;
1035 WCHAR computerName[MAX_COMPUTERNAME_LENGTH + 1];
1036
1037 computerNameLen = MAX_COMPUTERNAME_LENGTH + 1;
1038 GetComputerNameW(computerName, &computerNameLen);
1039 computerNameLen++; /* include NULL terminator */
1040
1041 size = sizeof(SERVER_INFO_101) + computerNameLen * sizeof(WCHAR);
1042 ret = NetApiBufferAllocate(size, (LPVOID *)bufptr);
1043 if (ret == NERR_Success)
1044 {
1045 /* INFO_100 structure is a subset of INFO_101 */
1046 PSERVER_INFO_101 info = (PSERVER_INFO_101)*bufptr;
1047 OSVERSIONINFOW verInfo;
1048
1049 info->sv101_platform_id = PLATFORM_ID_NT;
1050 info->sv101_name = (LMSTR)(*bufptr + sizeof(SERVER_INFO_101));
1051 memcpy(info->sv101_name, computerName,
1052 computerNameLen * sizeof(WCHAR));
1053 verInfo.dwOSVersionInfoSize = sizeof(verInfo);
1054 GetVersionExW(&verInfo);
1055 info->sv101_version_major = verInfo.dwMajorVersion;
1056 info->sv101_version_minor = verInfo.dwMinorVersion;
1057 /* Use generic type as no wine equivalent of DC / Server */
1058 info->sv101_type = SV_TYPE_NT;
1059 info->sv101_comment = NULL;
1060 }
1061 break;
1062 }
1063
1064 default:
1065 FIXME("level %d unimplemented\n", level);
1066 ret = ERROR_INVALID_LEVEL;
1067 }
1068 return ret;
1069 }
1070
1071
1072 /************************************************************
1073 * NetStatisticsGet (NETAPI32.@)
1074 */
1075 NET_API_STATUS WINAPI NetStatisticsGet(LMSTR server, LMSTR service,
1076 DWORD level, DWORD options,
1077 LPBYTE *bufptr)
1078 {
1079 TRACE("(%p, %p, %d, %d, %p)\n", server, service, level, options, bufptr);
1080 return NERR_InternalError;
1081 }
1082
1083 NET_API_STATUS WINAPI NetUseEnum(LMSTR server, DWORD level, LPBYTE* bufptr, DWORD prefmaxsize,
1084 LPDWORD entriesread, LPDWORD totalentries, LPDWORD resumehandle)
1085 {
1086 FIXME("stub (%p, %d, %p, %d, %p, %p, %p)\n", server, level, bufptr, prefmaxsize,
1087 entriesread, totalentries, resumehandle);
1088 return ERROR_NOT_SUPPORTED;
1089 }
1090
1091 NET_API_STATUS WINAPI NetScheduleJobAdd(LPCWSTR server, LPBYTE bufptr, LPDWORD jobid)
1092 {
1093 FIXME("stub (%s, %p, %p)\n", debugstr_w(server), bufptr, jobid);
1094 return NERR_Success;
1095 }
1096
1097 NET_API_STATUS WINAPI NetScheduleJobEnum(LPCWSTR server, LPBYTE* bufptr, DWORD prefmaxsize, LPDWORD entriesread,
1098 LPDWORD totalentries, LPDWORD resumehandle)
1099 {
1100 FIXME("stub (%s, %p, %d, %p, %p, %p)\n", debugstr_w(server), bufptr, prefmaxsize, entriesread, totalentries, resumehandle);
1101 *entriesread = 0;
1102 *totalentries = 0;
1103 return NERR_Success;
1104 }
1105
1106 NET_API_STATUS WINAPI NetUseGetInfo(LMSTR server, LMSTR name, DWORD level, LPBYTE *bufptr)
1107 {
1108 FIXME("stub (%p, %p, %d, %p)\n", server, name, level, bufptr);
1109 return ERROR_NOT_SUPPORTED;
1110
1111 }
1112
1113 /************************************************************
1114 * NetApiBufferAllocate (NETAPI32.@)
1115 */
1116 NET_API_STATUS WINAPI NetApiBufferAllocate(DWORD ByteCount, LPVOID* Buffer)
1117 {
1118 TRACE("(%d, %p)\n", ByteCount, Buffer);
1119
1120 if (Buffer == NULL) return ERROR_INVALID_PARAMETER;
1121 *Buffer = HeapAlloc(GetProcessHeap(), 0, ByteCount);
1122 if (*Buffer)
1123 return NERR_Success;
1124 else
1125 return GetLastError();
1126 }
1127
1128 /************************************************************
1129 * NetApiBufferFree (NETAPI32.@)
1130 */
1131 NET_API_STATUS WINAPI NetApiBufferFree(LPVOID Buffer)
1132 {
1133 TRACE("(%p)\n", Buffer);
1134 HeapFree(GetProcessHeap(), 0, Buffer);
1135 return NERR_Success;
1136 }
1137
1138 /************************************************************
1139 * NetApiBufferReallocate (NETAPI32.@)
1140 */
1141 NET_API_STATUS WINAPI NetApiBufferReallocate(LPVOID OldBuffer, DWORD NewByteCount,
1142 LPVOID* NewBuffer)
1143 {
1144 TRACE("(%p, %d, %p)\n", OldBuffer, NewByteCount, NewBuffer);
1145 if (NewByteCount)
1146 {
1147 if (OldBuffer)
1148 *NewBuffer = HeapReAlloc(GetProcessHeap(), 0, OldBuffer, NewByteCount);
1149 else
1150 *NewBuffer = HeapAlloc(GetProcessHeap(), 0, NewByteCount);
1151 return *NewBuffer ? NERR_Success : GetLastError();
1152 }
1153 else
1154 {
1155 if (!HeapFree(GetProcessHeap(), 0, OldBuffer)) return GetLastError();
1156 *NewBuffer = 0;
1157 return NERR_Success;
1158 }
1159 }
1160
1161 /************************************************************
1162 * NetApiBufferSize (NETAPI32.@)
1163 */
1164 NET_API_STATUS WINAPI NetApiBufferSize(LPVOID Buffer, LPDWORD ByteCount)
1165 {
1166 DWORD dw;
1167
1168 TRACE("(%p, %p)\n", Buffer, ByteCount);
1169 if (Buffer == NULL)
1170 return ERROR_INVALID_PARAMETER;
1171 dw = HeapSize(GetProcessHeap(), 0, Buffer);
1172 TRACE("size: %d\n", dw);
1173 if (dw != 0xFFFFFFFF)
1174 *ByteCount = dw;
1175 else
1176 *ByteCount = 0;
1177
1178 return NERR_Success;
1179 }
1180
1181 /************************************************************
1182 * NetSessionEnum (NETAPI32.@)
1183 *
1184 * PARAMS
1185 * servername [I] Pointer to a string with the name of the server
1186 * UncClientName [I] Pointer to a string with the name of the session
1187 * username [I] Pointer to a string with the name of the user
1188 * level [I] Data information level
1189 * bufptr [O] Buffer to the data
1190 * prefmaxlen [I] Preferred maximum length of the data
1191 * entriesread [O] Pointer to the number of entries enumerated
1192 * totalentries [O] Pointer to the possible number of entries
1193 * resume_handle [I/O] Pointer to a handle for subsequent searches
1194 *
1195 * RETURNS
1196 * If successful, the function returns NERR_Success
1197 * On failure it returns:
1198 * ERROR_ACCESS_DENIED User has no access to the requested information
1199 * ERROR_INVALID_LEVEL Value of 'level' is not correct
1200 * ERROR_INVALID_PARAMETER Wrong parameter
1201 * ERROR_MORE_DATA Need a larger buffer
1202 * ERROR_NOT_ENOUGH_MEMORY Not enough memory
1203 * NERR_ClientNameNotFound A session does not exist on a given computer
1204 * NERR_InvalidComputer Invalid computer name
1205 * NERR_UserNotFound User name could not be found.
1206 */
1207 NET_API_STATUS WINAPI NetSessionEnum(LMSTR servername, LMSTR UncClientName,
1208 LMSTR username, DWORD level, LPBYTE* bufptr, DWORD prefmaxlen, LPDWORD entriesread,
1209 LPDWORD totalentries, LPDWORD resume_handle)
1210 {
1211 FIXME("Stub (%s %s %s %d %p %d %p %p %p)\n", debugstr_w(servername),
1212 debugstr_w(UncClientName), debugstr_w(username),
1213 level, bufptr, prefmaxlen, entriesread, totalentries, resume_handle);
1214
1215 return NERR_Success;
1216 }
1217
1218 /************************************************************
1219 * NetShareEnum (NETAPI32.@)
1220 *
1221 * PARAMS
1222 * servername [I] Pointer to a string with the name of the server
1223 * level [I] Data information level
1224 * bufptr [O] Buffer to the data
1225 * prefmaxlen [I] Preferred maximum length of the data
1226 * entriesread [O] Pointer to the number of entries enumerated
1227 * totalentries [O] Pointer to the possible number of entries
1228 * resume_handle [I/O] Pointer to a handle for subsequent searches
1229 *
1230 * RETURNS
1231 * If successful, the function returns NERR_Success
1232 * On failure it returns a system error code (FIXME: find out which)
1233 *
1234 */
1235 NET_API_STATUS WINAPI NetShareEnum( LMSTR servername, DWORD level, LPBYTE* bufptr,
1236 DWORD prefmaxlen, LPDWORD entriesread, LPDWORD totalentries, LPDWORD resume_handle)
1237 {
1238 FIXME("Stub (%s %d %p %d %p %p %p)\n", debugstr_w(servername), level, bufptr,
1239 prefmaxlen, entriesread, totalentries, resume_handle);
1240
1241 return ERROR_NOT_SUPPORTED;
1242 }
1243
1244 /************************************************************
1245 * NetShareDel (NETAPI32.@)
1246 */
1247 NET_API_STATUS WINAPI NetShareDel(LMSTR servername, LMSTR netname, DWORD reserved)
1248 {
1249 BOOL local = NETAPI_IsLocalComputer( servername );
1250
1251 TRACE("%s %s %d\n", debugstr_w(servername), debugstr_w(netname), reserved);
1252
1253 if (!local)
1254 {
1255 if (libnetapi_init()) return share_del( servername, netname, reserved );
1256 FIXME( "remote computers not supported\n" );
1257 }
1258
1259 FIXME("%s %s %d\n", debugstr_w(servername), debugstr_w(netname), reserved);
1260 return NERR_Success;
1261 }
1262
1263 /************************************************************
1264 * NetShareGetInfo (NETAPI32.@)
1265 */
1266 NET_API_STATUS WINAPI NetShareGetInfo(LMSTR servername, LMSTR netname,
1267 DWORD level, LPBYTE *bufptr)
1268 {
1269 FIXME("Stub (%s %s %d %p)\n", debugstr_w(servername),
1270 debugstr_w(netname),level, bufptr);
1271 return NERR_NetNameNotFound;
1272 }
1273
1274 /************************************************************
1275 * NetShareAdd (NETAPI32.@)
1276 */
1277 NET_API_STATUS WINAPI NetShareAdd(LMSTR servername,
1278 DWORD level, LPBYTE buf, LPDWORD parm_err)
1279 {
1280 BOOL local = NETAPI_IsLocalComputer( servername );
1281
1282 TRACE("%s %d %p %p\n", debugstr_w(servername), level, buf, parm_err);
1283
1284 if (!local)
1285 {
1286 if (libnetapi_init()) return share_add( servername, level, buf, parm_err );
1287 FIXME( "remote computers not supported\n" );
1288 }
1289
1290 FIXME("%s %d %p %p\n", debugstr_w(servername), level, buf, parm_err);
1291 return ERROR_NOT_SUPPORTED;
1292 }
1293
1294 /************************************************************
1295 * NetFileEnum (NETAPI32.@)
1296 */
1297 NET_API_STATUS WINAPI NetFileEnum(
1298 LPWSTR ServerName, LPWSTR BasePath, LPWSTR UserName,
1299 DWORD Level, LPBYTE* BufPtr, DWORD PrefMaxLen,
1300 LPDWORD EntriesRead, LPDWORD TotalEntries, PDWORD_PTR ResumeHandle)
1301 {
1302 FIXME("(%s, %s, %s, %u): stub\n", debugstr_w(ServerName), debugstr_w(BasePath),
1303 debugstr_w(UserName), Level);
1304 return ERROR_NOT_SUPPORTED;
1305 }
1306
1307 static void wprint_mac(WCHAR* buffer, int len, const MIB_IFROW *ifRow)
1308 {
1309 int i;
1310 unsigned char val;
1311
1312 if (!buffer)
1313 return;
1314 if (len < 1)
1315 return;
1316 if (!ifRow)
1317 {
1318 *buffer = '\0';
1319 return;
1320 }
1321
1322 for (i = 0; i < ifRow->dwPhysAddrLen && 2 * i < len; i++)
1323 {
1324 val = ifRow->bPhysAddr[i];
1325 if ((val >>4) >9)
1326 buffer[2*i] = (WCHAR)((val >>4) + 'A' - 10);
1327 else
1328 buffer[2*i] = (WCHAR)((val >>4) + '0');
1329 if ((val & 0xf ) >9)
1330 buffer[2*i+1] = (WCHAR)((val & 0xf) + 'A' - 10);
1331 else
1332 buffer[2*i+1] = (WCHAR)((val & 0xf) + '0');
1333 }
1334 buffer[2*i]=0;
1335 }
1336
1337 /* Theoretically this could be too short, except that MS defines
1338 * MAX_ADAPTER_NAME as 128, and MAX_INTERFACE_NAME_LEN as 256, and both
1339 * represent a count of WCHARs, so even with an extraordinarily long header
1340 * this will be plenty
1341 */
1342 #define MAX_TRANSPORT_NAME MAX_INTERFACE_NAME_LEN
1343 #define MAX_TRANSPORT_ADDR 13
1344
1345 #define NBT_TRANSPORT_NAME_HEADER "\\Device\\NetBT_Tcpip_"
1346 #define UNKNOWN_TRANSPORT_NAME_HEADER "\\Device\\UnknownTransport_"
1347
1348 static void wprint_name(WCHAR *buffer, int len, ULONG transport,
1349 PMIB_IFROW ifRow)
1350 {
1351 WCHAR *ptr1, *ptr2;
1352 const char *name;
1353
1354 if (!buffer)
1355 return;
1356 if (!ifRow)
1357 {
1358 *buffer = '\0';
1359 return;
1360 }
1361
1362 if (!memcmp(&transport, TRANSPORT_NBT, sizeof(ULONG)))
1363 name = NBT_TRANSPORT_NAME_HEADER;
1364 else
1365 name = UNKNOWN_TRANSPORT_NAME_HEADER;
1366
1367 for (ptr1 = buffer; *name && ptr1 < buffer + len; ptr1++, name++)
1368 *ptr1 = *name;
1369 for (ptr2 = ifRow->wszName; *ptr2 && ptr1 < buffer + len; ptr1++, ptr2++)
1370 *ptr1 = *ptr2;
1371 *ptr1 = '\0';
1372 }
1373
1374 /***********************************************************************
1375 * NetWkstaTransportEnum (NETAPI32.@)
1376 */
1377
1378 struct WkstaTransportEnumData
1379 {
1380 UCHAR n_adapt;
1381 UCHAR n_read;
1382 DWORD prefmaxlen;
1383 LPBYTE *pbuf;
1384 NET_API_STATUS ret;
1385 };
1386
1387 /**********************************************************************/
1388
1389 static BOOL WkstaEnumAdaptersCallback(UCHAR totalLANAs, UCHAR lanaIndex,
1390 ULONG transport, const NetBIOSAdapterImpl *data, void *closure)
1391 {
1392 BOOL ret;
1393 struct WkstaTransportEnumData *enumData = closure;
1394
1395 if (enumData && enumData->pbuf)
1396 {
1397 if (lanaIndex == 0)
1398 {
1399 DWORD toAllocate;
1400
1401 enumData->n_adapt = totalLANAs;
1402 enumData->n_read = 0;
1403
1404 toAllocate = totalLANAs * (sizeof(WKSTA_TRANSPORT_INFO_0)
1405 + MAX_TRANSPORT_NAME * sizeof(WCHAR) +
1406 MAX_TRANSPORT_ADDR * sizeof(WCHAR));
1407 if (enumData->prefmaxlen != MAX_PREFERRED_LENGTH)
1408 toAllocate = enumData->prefmaxlen;
1409 NetApiBufferAllocate(toAllocate, (LPVOID *)enumData->pbuf);
1410 }
1411 if (*(enumData->pbuf))
1412 {
1413 UCHAR spaceFor;
1414
1415 if (enumData->prefmaxlen == MAX_PREFERRED_LENGTH)
1416 spaceFor = totalLANAs;
1417 else
1418 spaceFor = enumData->prefmaxlen /
1419 (sizeof(WKSTA_TRANSPORT_INFO_0) + (MAX_TRANSPORT_NAME +
1420 MAX_TRANSPORT_ADDR) * sizeof(WCHAR));
1421 if (enumData->n_read < spaceFor)
1422 {
1423 PWKSTA_TRANSPORT_INFO_0 ti;
1424 LMSTR transport_name, transport_addr;
1425 MIB_IFROW ifRow;
1426
1427 ti = (PWKSTA_TRANSPORT_INFO_0)(*(enumData->pbuf) +
1428 enumData->n_read * sizeof(WKSTA_TRANSPORT_INFO_0));
1429 transport_name = (LMSTR)(*(enumData->pbuf) +
1430 totalLANAs * sizeof(WKSTA_TRANSPORT_INFO_0) +
1431 enumData->n_read * MAX_TRANSPORT_NAME * sizeof(WCHAR));
1432 transport_addr = (LMSTR)(*(enumData->pbuf) +
1433 totalLANAs * (sizeof(WKSTA_TRANSPORT_INFO_0) +
1434 MAX_TRANSPORT_NAME * sizeof(WCHAR)) +
1435 enumData->n_read * MAX_TRANSPORT_ADDR * sizeof(WCHAR));
1436
1437 ifRow.dwIndex = data->ifIndex;
1438 GetIfEntry(&ifRow);
1439 ti->wkti0_quality_of_service = 0;
1440 ti->wkti0_number_of_vcs = 0;
1441 ti->wkti0_transport_name = transport_name;
1442 wprint_name(ti->wkti0_transport_name, MAX_TRANSPORT_NAME,
1443 transport, &ifRow);
1444 ti->wkti0_transport_address = transport_addr;
1445 wprint_mac(ti->wkti0_transport_address, MAX_TRANSPORT_ADDR,
1446 &ifRow);
1447 if (!memcmp(&transport, TRANSPORT_NBT, sizeof(ULONG)))
1448 ti->wkti0_wan_ish = TRUE;
1449 else
1450 ti->wkti0_wan_ish = FALSE;
1451 TRACE("%d of %d:ti at %p\n", lanaIndex, totalLANAs, ti);
1452 TRACE("transport_name at %p %s\n",
1453 ti->wkti0_transport_name,
1454 debugstr_w(ti->wkti0_transport_name));
1455 TRACE("transport_address at %p %s\n",
1456 ti->wkti0_transport_address,
1457 debugstr_w(ti->wkti0_transport_address));
1458 enumData->n_read++;
1459 enumData->ret = NERR_Success;
1460 ret = TRUE;
1461 }
1462 else
1463 {
1464 enumData->ret = ERROR_MORE_DATA;
1465 ret = FALSE;
1466 }
1467 }
1468 else
1469 {
1470 enumData->ret = ERROR_OUTOFMEMORY;
1471 ret = FALSE;
1472 }
1473 }
1474 else
1475 ret = FALSE;
1476 return ret;
1477 }
1478
1479 /**********************************************************************/
1480
1481 NET_API_STATUS WINAPI
1482 NetWkstaTransportEnum(LMSTR ServerName, DWORD level, PBYTE* pbuf,
1483 DWORD prefmaxlen, LPDWORD read_entries,
1484 PDWORD total_entries, PDWORD hresume)
1485 {
1486 NET_API_STATUS ret;
1487
1488 TRACE(":%s, 0x%08x, %p, 0x%08x, %p, %p, %p\n", debugstr_w(ServerName),
1489 level, pbuf, prefmaxlen, read_entries, total_entries,hresume);
1490 if (!NETAPI_IsLocalComputer(ServerName))
1491 {
1492 FIXME(":not implemented for non-local computers\n");
1493 ret = ERROR_INVALID_LEVEL;
1494 }
1495 else
1496 {
1497 if (hresume && *hresume)
1498 {
1499 FIXME(":resume handle not implemented\n");
1500 return ERROR_INVALID_LEVEL;
1501 }
1502
1503 switch (level)
1504 {
1505 case 0: /* transport info */
1506 {
1507 ULONG allTransports;
1508 struct WkstaTransportEnumData enumData;
1509
1510 if (NetBIOSNumAdapters() == 0)
1511 return ERROR_NETWORK_UNREACHABLE;
1512 if (!read_entries)
1513 return STATUS_ACCESS_VIOLATION;
1514 if (!total_entries || !pbuf)
1515 return RPC_X_NULL_REF_POINTER;
1516
1517 enumData.prefmaxlen = prefmaxlen;
1518 enumData.pbuf = pbuf;
1519 memcpy(&allTransports, ALL_TRANSPORTS, sizeof(ULONG));
1520 NetBIOSEnumAdapters(allTransports, WkstaEnumAdaptersCallback,
1521 &enumData);
1522 *read_entries = enumData.n_read;
1523 *total_entries = enumData.n_adapt;
1524 if (hresume) *hresume= 0;
1525 ret = enumData.ret;
1526 break;
1527 }
1528 default:
1529 TRACE("Invalid level %d is specified\n", level);
1530 ret = ERROR_INVALID_LEVEL;
1531 }
1532 }
1533 return ret;
1534 }
1535
1536 /************************************************************
1537 * NetWkstaUserGetInfo (NETAPI32.@)
1538 */
1539 NET_API_STATUS WINAPI NetWkstaUserGetInfo(LMSTR reserved, DWORD level,
1540 PBYTE* bufptr)
1541 {
1542 NET_API_STATUS nastatus;
1543
1544 TRACE("(%s, %d, %p)\n", debugstr_w(reserved), level, bufptr);
1545 switch (level)
1546 {
1547 case 0:
1548 {
1549 PWKSTA_USER_INFO_0 ui;
1550 DWORD dwSize = UNLEN + 1;
1551
1552 /* set up buffer */
1553 nastatus = NetApiBufferAllocate(sizeof(WKSTA_USER_INFO_0) + dwSize * sizeof(WCHAR),
1554 (LPVOID *) bufptr);
1555 if (nastatus != NERR_Success)
1556 return ERROR_NOT_ENOUGH_MEMORY;
1557
1558 ui = (PWKSTA_USER_INFO_0) *bufptr;
1559 ui->wkui0_username = (LMSTR) (*bufptr + sizeof(WKSTA_USER_INFO_0));
1560
1561 /* get data */
1562 if (!GetUserNameW(ui->wkui0_username, &dwSize))
1563 {
1564 NetApiBufferFree(ui);
1565 return ERROR_NOT_ENOUGH_MEMORY;
1566 }
1567 else {
1568 nastatus = NetApiBufferReallocate(
1569 *bufptr, sizeof(WKSTA_USER_INFO_0) +
1570 (lstrlenW(ui->wkui0_username) + 1) * sizeof(WCHAR),
1571 (LPVOID *) bufptr);
1572 if (nastatus != NERR_Success)
1573 return nastatus;
1574 }
1575 break;
1576 }
1577
1578 case 1:
1579 {
1580 PWKSTA_USER_INFO_1 ui;
1581 PWKSTA_USER_INFO_0 ui0;
1582 LSA_OBJECT_ATTRIBUTES ObjectAttributes;
1583 LSA_HANDLE PolicyHandle;
1584 PPOLICY_ACCOUNT_DOMAIN_INFO DomainInfo;
1585 NTSTATUS NtStatus;
1586
1587 /* sizes of the field buffers in WCHARS */
1588 int username_sz, logon_domain_sz, oth_domains_sz, logon_server_sz;
1589
1590 FIXME("Level 1 processing is partially implemented\n");
1591 oth_domains_sz = 1;
1592 logon_server_sz = 1;
1593
1594 /* get some information first to estimate size of the buffer */
1595 ui0 = NULL;
1596 nastatus = NetWkstaUserGetInfo(NULL, 0, (PBYTE *) &ui0);
1597 if (nastatus != NERR_Success)
1598 return nastatus;
1599 username_sz = lstrlenW(ui0->wkui0_username) + 1;
1600
1601 ZeroMemory(&ObjectAttributes, sizeof(ObjectAttributes));
1602 NtStatus = LsaOpenPolicy(NULL, &ObjectAttributes,
1603 POLICY_VIEW_LOCAL_INFORMATION,
1604 &PolicyHandle);
1605 if (NtStatus != STATUS_SUCCESS)
1606 {
1607 TRACE("LsaOpenPolicyFailed with NT status %x\n",
1608 LsaNtStatusToWinError(NtStatus));
1609 NetApiBufferFree(ui0);
1610 return ERROR_NOT_ENOUGH_MEMORY;
1611 }
1612 LsaQueryInformationPolicy(PolicyHandle, PolicyAccountDomainInformation,
1613 (PVOID*) &DomainInfo);
1614 logon_domain_sz = lstrlenW(DomainInfo->DomainName.Buffer) + 1;
1615 LsaClose(PolicyHandle);
1616
1617 /* set up buffer */
1618 nastatus = NetApiBufferAllocate(sizeof(WKSTA_USER_INFO_1) +
1619 (username_sz + logon_domain_sz +
1620 oth_domains_sz + logon_server_sz) * sizeof(WCHAR),
1621 (LPVOID *) bufptr);
1622 if (nastatus != NERR_Success) {
1623 NetApiBufferFree(ui0);
1624 return nastatus;
1625 }
1626 ui = (WKSTA_USER_INFO_1 *) *bufptr;
1627 ui->wkui1_username = (LMSTR) (*bufptr + sizeof(WKSTA_USER_INFO_1));
1628 ui->wkui1_logon_domain = (LMSTR) (
1629 ((PBYTE) ui->wkui1_username) + username_sz * sizeof(WCHAR));
1630 ui->wkui1_oth_domains = (LMSTR) (
1631 ((PBYTE) ui->wkui1_logon_domain) +
1632 logon_domain_sz * sizeof(WCHAR));
1633 ui->wkui1_logon_server = (LMSTR) (
1634 ((PBYTE) ui->wkui1_oth_domains) +
1635 oth_domains_sz * sizeof(WCHAR));
1636
1637 /* get data */
1638 lstrcpyW(ui->wkui1_username, ui0->wkui0_username);
1639 NetApiBufferFree(ui0);
1640
1641 lstrcpynW(ui->wkui1_logon_domain, DomainInfo->DomainName.Buffer,
1642 logon_domain_sz);
1643 LsaFreeMemory(DomainInfo);
1644
1645 /* FIXME. Not implemented. Populated with empty strings */
1646 ui->wkui1_oth_domains[0] = 0;
1647 ui->wkui1_logon_server[0] = 0;
1648 break;
1649 }
1650 case 1101:
1651 {
1652 PWKSTA_USER_INFO_1101 ui;
1653 DWORD dwSize = 1;
1654
1655 FIXME("Stub. Level 1101 processing is not implemented\n");
1656 /* FIXME see also wkui1_oth_domains for level 1 */
1657
1658 /* set up buffer */
1659 nastatus = NetApiBufferAllocate(sizeof(WKSTA_USER_INFO_1101) + dwSize * sizeof(WCHAR),
1660 (LPVOID *) bufptr);
1661 if (nastatus != NERR_Success)
1662 return nastatus;
1663 ui = (PWKSTA_USER_INFO_1101) *bufptr;
1664 ui->wkui1101_oth_domains = (LMSTR)(ui + 1);
1665
1666 /* get data */
1667 ui->wkui1101_oth_domains[0] = 0;
1668 break;
1669 }
1670 default:
1671 TRACE("Invalid level %d is specified\n", level);
1672 return ERROR_INVALID_LEVEL;
1673 }
1674 return NERR_Success;
1675 }
1676
1677 /************************************************************
1678 * NetWkstaUserEnum (NETAPI32.@)
1679 */
1680 NET_API_STATUS WINAPI
1681 NetWkstaUserEnum(LMSTR servername, DWORD level, LPBYTE* bufptr,
1682 DWORD prefmaxlen, LPDWORD entriesread,
1683 LPDWORD totalentries, LPDWORD resumehandle)
1684 {
1685 FIXME("(%s, %d, %p, %d, %p, %p, %p): stub!\n", debugstr_w(servername),
1686 level, bufptr, prefmaxlen, entriesread, totalentries, resumehandle);
1687 return ERROR_INVALID_PARAMETER;
1688 }
1689
1690 /************************************************************
1691 * NetpGetComputerName (NETAPI32.@)
1692 */
1693 NET_API_STATUS WINAPI NetpGetComputerName(LPWSTR *Buffer)
1694 {
1695 DWORD dwSize = MAX_COMPUTERNAME_LENGTH + 1;
1696
1697 TRACE("(%p)\n", Buffer);
1698 NetApiBufferAllocate(dwSize * sizeof(WCHAR), (LPVOID *) Buffer);
1699 if (GetComputerNameW(*Buffer, &dwSize))
1700 {
1701 return NetApiBufferReallocate(
1702 *Buffer, (dwSize + 1) * sizeof(WCHAR),
1703 (LPVOID *) Buffer);
1704 }
1705 else
1706 {
1707 NetApiBufferFree(*Buffer);
1708 return ERROR_NOT_ENOUGH_MEMORY;
1709 }
1710 }
1711
1712 NET_API_STATUS WINAPI I_NetNameCompare(LPVOID p1, LPWSTR wkgrp, LPWSTR comp,
1713 LPVOID p4, LPVOID p5)
1714 {
1715 FIXME("(%p %s %s %p %p): stub\n", p1, debugstr_w(wkgrp), debugstr_w(comp),
1716 p4, p5);
1717 return ERROR_INVALID_PARAMETER;
1718 }
1719
1720 NET_API_STATUS WINAPI I_NetNameValidate(LPVOID p1, LPWSTR wkgrp, LPVOID p3,
1721 LPVOID p4)
1722 {
1723 FIXME("(%p %s %p %p): stub\n", p1, debugstr_w(wkgrp), p3, p4);
1724 return ERROR_INVALID_PARAMETER;
1725 }
1726
1727 NET_API_STATUS WINAPI NetWkstaGetInfo( LMSTR servername, DWORD level,
1728 LPBYTE* bufptr)
1729 {
1730 NET_API_STATUS ret;
1731 BOOL local = NETAPI_IsLocalComputer( servername );
1732
1733 TRACE("%s %d %p\n", debugstr_w( servername ), level, bufptr );
1734
1735 if (!local)
1736 {
1737 if (libnetapi_init()) return wksta_getinfo( servername, level, bufptr );
1738 FIXME( "remote computers not supported\n" );
1739 return ERROR_INVALID_LEVEL;
1740 }
1741 if (!bufptr) return ERROR_INVALID_PARAMETER;
1742
1743 switch (level)
1744 {
1745 case 100:
1746 case 101:
1747 case 102:
1748 {
1749 static const WCHAR lanroot[] = {'c',':','\\','l','a','n','m','a','n',0}; /* FIXME */
1750 DWORD computerNameLen, domainNameLen, size;
1751 WCHAR computerName[MAX_COMPUTERNAME_LENGTH + 1];
1752 LSA_OBJECT_ATTRIBUTES ObjectAttributes;
1753 LSA_HANDLE PolicyHandle;
1754 NTSTATUS NtStatus;
1755
1756 computerNameLen = MAX_COMPUTERNAME_LENGTH + 1;
1757 GetComputerNameW(computerName, &computerNameLen);
1758 computerNameLen++; /* include NULL terminator */
1759
1760 ZeroMemory(&ObjectAttributes, sizeof(ObjectAttributes));
1761 NtStatus = LsaOpenPolicy(NULL, &ObjectAttributes,
1762 POLICY_VIEW_LOCAL_INFORMATION, &PolicyHandle);
1763 if (NtStatus != STATUS_SUCCESS)
1764 ret = LsaNtStatusToWinError(NtStatus);
1765 else
1766 {
1767 PPOLICY_ACCOUNT_DOMAIN_INFO DomainInfo;
1768
1769 LsaQueryInformationPolicy(PolicyHandle,
1770 PolicyAccountDomainInformation, (PVOID*)&DomainInfo);
1771 domainNameLen = lstrlenW(DomainInfo->DomainName.Buffer) + 1;
1772 size = sizeof(WKSTA_INFO_102) + computerNameLen * sizeof(WCHAR)
1773 + domainNameLen * sizeof(WCHAR) + sizeof(lanroot);
1774 ret = NetApiBufferAllocate(size, (LPVOID *)bufptr);
1775 if (ret == NERR_Success)
1776 {
1777 /* INFO_100 and INFO_101 structures are subsets of INFO_102 */
1778 PWKSTA_INFO_102 info = (PWKSTA_INFO_102)*bufptr;
1779 OSVERSIONINFOW verInfo;
1780
1781 info->wki102_platform_id = PLATFORM_ID_NT;
1782 info->wki102_computername = (LMSTR)(*bufptr +
1783 sizeof(WKSTA_INFO_102));
1784 memcpy(info->wki102_computername, computerName,
1785 computerNameLen * sizeof(WCHAR));
1786 info->wki102_langroup = info->wki102_computername + computerNameLen;
1787 memcpy(info->wki102_langroup, DomainInfo->DomainName.Buffer,
1788 domainNameLen * sizeof(WCHAR));
1789 info->wki102_lanroot = info->wki102_langroup + domainNameLen;
1790 memcpy(info->wki102_lanroot, lanroot, sizeof(lanroot));
1791 memset(&verInfo, 0, sizeof(verInfo));
1792 verInfo.dwOSVersionInfoSize = sizeof(verInfo);
1793 GetVersionExW(&verInfo);
1794 info->wki102_ver_major = verInfo.dwMajorVersion;
1795 info->wki102_ver_minor = verInfo.dwMinorVersion;
1796 info->wki102_logged_on_users = 1;
1797 }
1798 LsaFreeMemory(DomainInfo);
1799 LsaClose(PolicyHandle);
1800 }
1801 break;
1802 }
1803
1804 default:
1805 FIXME("level %d unimplemented\n", level);
1806 ret = ERROR_INVALID_LEVEL;
1807 }
1808 return ret;
1809 }
1810
1811 /************************************************************
1812 * NetGetJoinInformation (NETAPI32.@)
1813 */
1814 NET_API_STATUS NET_API_FUNCTION NetGetJoinInformation(
1815 LPCWSTR Server,
1816 LPWSTR *Name,
1817 PNETSETUP_JOIN_STATUS type)
1818 {
1819 static const WCHAR workgroupW[] = {'W','o','r','k','g','r','o','u','p',0};
1820
1821 FIXME("Semi-stub %s %p %p\n", wine_dbgstr_w(Server), Name, type);
1822
1823 if (!Name || !type)
1824 return ERROR_INVALID_PARAMETER;
1825
1826 NetApiBufferAllocate(sizeof(workgroupW), (LPVOID *)Name);
1827 lstrcpyW(*Name, workgroupW);
1828 *type = NetSetupWorkgroupName;
1829
1830 return NERR_Success;
1831 }
1832
1833 /************************************************************
1834 * NetUserGetGroups (NETAPI32.@)
1835 */
1836 NET_API_STATUS NET_API_FUNCTION NetUserGetGroups(
1837 LPCWSTR servername,
1838 LPCWSTR username,
1839 DWORD level,
1840 LPBYTE *bufptr,
1841 DWORD prefixmaxlen,
1842 LPDWORD entriesread,
1843 LPDWORD totalentries)
1844 {
1845 FIXME("%s %s %d %p %d %p %p stub\n", debugstr_w(servername),
1846 debugstr_w(username), level, bufptr, prefixmaxlen, entriesread,
1847 totalentries);
1848
1849 *bufptr = NULL;
1850 *entriesread = 0;
1851 *totalentries = 0;
1852
1853 return ERROR_INVALID_LEVEL;
1854 }
1855
1856 struct sam_user
1857 {
1858 struct list entry;
1859 WCHAR user_name[LM20_UNLEN+1];
1860 WCHAR user_password[PWLEN + 1];
1861 DWORD sec_since_passwd_change;
1862 DWORD user_priv;
1863 LPWSTR home_dir;
1864 LPWSTR user_comment;
1865 DWORD user_flags;
1866 LPWSTR user_logon_script_path;
1867 };
1868
1869 static struct list user_list = LIST_INIT( user_list );
1870
1871 /************************************************************
1872 * NETAPI_ValidateServername
1873 *
1874 * Validates server name
1875 */
1876 static NET_API_STATUS NETAPI_ValidateServername(LPCWSTR ServerName)
1877 {
1878 if (ServerName)
1879 {
1880 if (ServerName[0] == 0)
1881 return ERROR_BAD_NETPATH;
1882 else if (
1883 ((ServerName[0] == '\\') &&
1884 (ServerName[1] != '\\'))
1885 ||
1886 ((ServerName[0] == '\\') &&
1887 (ServerName[1] == '\\') &&
1888 (ServerName[2] == 0))
1889 )
1890 return ERROR_INVALID_NAME;
1891 }
1892 return NERR_Success;
1893 }
1894
1895 /************************************************************
1896 * NETAPI_FindUser
1897 *
1898 * Looks for a user in the user database.
1899 * Returns a pointer to the entry in the user list when the user
1900 * is found, NULL otherwise.
1901 */
1902 static struct sam_user* NETAPI_FindUser(LPCWSTR UserName)
1903 {
1904 struct sam_user *user;
1905
1906 LIST_FOR_EACH_ENTRY(user, &user_list, struct sam_user, entry)
1907 {
1908 if(lstrcmpW(user->user_name, UserName) == 0)
1909 return user;
1910 }
1911 return NULL;
1912 }
1913
1914 static BOOL NETAPI_IsCurrentUser(LPCWSTR username)
1915 {
1916 LPWSTR curr_user = NULL;
1917 DWORD dwSize;
1918 BOOL ret = FALSE;
1919
1920 dwSize = LM20_UNLEN+1;
1921 curr_user = HeapAlloc(GetProcessHeap(), 0, dwSize * sizeof(WCHAR));
1922 if(!curr_user)
1923 {
1924 ERR("Failed to allocate memory for user name.\n");
1925 goto end;
1926 }
1927 if(!GetUserNameW(curr_user, &dwSize))
1928 {
1929 ERR("Failed to get current user's user name.\n");
1930 goto end;
1931 }
1932 if (!lstrcmpW(curr_user, username))
1933 {
1934 ret = TRUE;
1935 }
1936
1937 end:
1938 HeapFree(GetProcessHeap(), 0, curr_user);
1939 return ret;
1940 }
1941
1942 /************************************************************
1943 * NetUserAdd (NETAPI32.@)
1944 */
1945 NET_API_STATUS WINAPI NetUserAdd(LPCWSTR servername,
1946 DWORD level, LPBYTE bufptr, LPDWORD parm_err)
1947 {
1948 NET_API_STATUS status;
1949 struct sam_user * su = NULL;
1950
1951 FIXME("(%s, %d, %p, %p) stub!\n", debugstr_w(servername), level, bufptr, parm_err);
1952
1953 if((status = NETAPI_ValidateServername(servername)) != NERR_Success)
1954 return status;
1955
1956 switch(level)
1957 {
1958 /* Level 3 and 4 are identical for the purposes of NetUserAdd */
1959 case 4:
1960 case 3:
1961 FIXME("Level 3 and 4 not implemented.\n");
1962 /* Fall through */
1963 case 2:
1964 FIXME("Level 2 not implemented.\n");
1965 /* Fall through */
1966 case 1:
1967 {
1968 PUSER_INFO_1 ui = (PUSER_INFO_1) bufptr;
1969 su = HeapAlloc(GetProcessHeap(), 0, sizeof(struct sam_user));
1970 if(!su)
1971 {
1972 status = NERR_InternalError;
1973 break;
1974 }
1975
1976 if(lstrlenW(ui->usri1_name) > LM20_UNLEN)
1977 {
1978 status = NERR_BadUsername;
1979 break;
1980 }
1981
1982 /*FIXME: do other checks for a valid username */
1983 lstrcpyW(su->user_name, ui->usri1_name);
1984
1985 if(lstrlenW(ui->usri1_password) > PWLEN)
1986 {
1987 /* Always return PasswordTooShort on invalid passwords. */
1988 status = NERR_PasswordTooShort;
1989 break;
1990 }
1991 lstrcpyW(su->user_password, ui->usri1_password);
1992
1993 su->sec_since_passwd_change = ui->usri1_password_age;
1994 su->user_priv = ui->usri1_priv;
1995 su->user_flags = ui->usri1_flags;
1996
1997 /*FIXME: set the other LPWSTRs to NULL for now */
1998 su->home_dir = NULL;
1999 su->user_comment = NULL;
2000 su->user_logon_script_path = NULL;
2001
2002 list_add_head(&user_list, &su->entry);
2003 return NERR_Success;
2004 }
2005 default:
2006 TRACE("Invalid level %d specified.\n", level);
2007 status = ERROR_INVALID_LEVEL;
2008 break;
2009 }
2010
2011 HeapFree(GetProcessHeap(), 0, su);
2012
2013 return status;
2014 }
2015
2016 /************************************************************
2017 * NetUserDel (NETAPI32.@)
2018 */
2019 NET_API_STATUS WINAPI NetUserDel(LPCWSTR servername, LPCWSTR username)
2020 {
2021 NET_API_STATUS status;
2022 struct sam_user *user;
2023
2024 TRACE("(%s, %s)\n", debugstr_w(servername), debugstr_w(username));
2025
2026 if((status = NETAPI_ValidateServername(servername))!= NERR_Success)
2027 return status;
2028
2029 if ((user = NETAPI_FindUser(username)) == NULL)
2030 return NERR_UserNotFound;
2031
2032 list_remove(&user->entry);
2033
2034 HeapFree(GetProcessHeap(), 0, user->home_dir);
2035 HeapFree(GetProcessHeap(), 0, user->user_comment);
2036 HeapFree(GetProcessHeap(), 0, user->user_logon_script_path);
2037 HeapFree(GetProcessHeap(), 0, user);
2038
2039 return NERR_Success;
2040 }
2041
2042 /************************************************************
2043 * NetUserGetInfo (NETAPI32.@)
2044 */
2045 NET_API_STATUS WINAPI
2046 NetUserGetInfo(LPCWSTR servername, LPCWSTR username, DWORD level,
2047 LPBYTE* bufptr)
2048 {
2049 NET_API_STATUS status;
2050 TRACE("(%s, %s, %d, %p)\n", debugstr_w(servername), debugstr_w(username),
2051 level, bufptr);
2052 status = NETAPI_ValidateServername(servername);
2053 if (status != NERR_Success)
2054 return status;
2055
2056 if(!NETAPI_IsLocalComputer(servername))
2057 {
2058 FIXME("Only implemented for local computer, but remote server"
2059 "%s was requested.\n", debugstr_w(servername));
2060 return NERR_InvalidComputer;
2061 }
2062
2063 if(!NETAPI_FindUser(username) && !NETAPI_IsCurrentUser(username))
2064 {
2065 TRACE("User %s is unknown.\n", debugstr_w(username));
2066 return NERR_UserNotFound;
2067 }
2068
2069 switch (level)
2070 {
2071 case 0:
2072 {
2073 PUSER_INFO_0 ui;
2074 int name_sz;
2075
2076 name_sz = lstrlenW(username) + 1;
2077
2078 /* set up buffer */
2079 NetApiBufferAllocate(sizeof(USER_INFO_0) + name_sz * sizeof(WCHAR),
2080 (LPVOID *) bufptr);
2081
2082 ui = (PUSER_INFO_0) *bufptr;
2083 ui->usri0_name = (LPWSTR) (*bufptr + sizeof(USER_INFO_0));
2084
2085 /* get data */
2086 lstrcpyW(ui->usri0_name, username);
2087 break;
2088 }
2089
2090 case 10:
2091 {
2092 PUSER_INFO_10 ui;
2093 PUSER_INFO_0 ui0;
2094 /* sizes of the field buffers in WCHARS */
2095 int name_sz, comment_sz, usr_comment_sz, full_name_sz;
2096
2097 comment_sz = 1;
2098 usr_comment_sz = 1;
2099 full_name_sz = 1;
2100
2101 /* get data */
2102 status = NetUserGetInfo(servername, username, 0, (LPBYTE *) &ui0);
2103 if (status != NERR_Success)
2104 {
2105 NetApiBufferFree(ui0);
2106 return status;
2107 }
2108 name_sz = lstrlenW(ui0->usri0_name) + 1;
2109
2110 /* set up buffer */
2111 NetApiBufferAllocate(sizeof(USER_INFO_10) +
2112 (name_sz + comment_sz + usr_comment_sz +
2113 full_name_sz) * sizeof(WCHAR),
2114 (LPVOID *) bufptr);
2115 ui = (PUSER_INFO_10) *bufptr;
2116 ui->usri10_name = (LPWSTR) (*bufptr + sizeof(USER_INFO_10));
2117 ui->usri10_comment = (LPWSTR) (
2118 ((PBYTE) ui->usri10_name) + name_sz * sizeof(WCHAR));
2119 ui->usri10_usr_comment = (LPWSTR) (
2120 ((PBYTE) ui->usri10_comment) + comment_sz * sizeof(WCHAR));
2121 ui->usri10_full_name = (LPWSTR) (
2122 ((PBYTE) ui->usri10_usr_comment) + usr_comment_sz * sizeof(WCHAR));
2123
2124 /* set data */
2125 lstrcpyW(ui->usri10_name, ui0->usri0_name);
2126 NetApiBufferFree(ui0);
2127 ui->usri10_comment[0] = 0;
2128 ui->usri10_usr_comment[0] = 0;
2129 ui->usri10_full_name[0] = 0;
2130 break;
2131 }
2132
2133 case 1:
2134 {
2135 static const WCHAR homedirW[] = {'H','O','M','E',0};
2136 PUSER_INFO_1 ui;
2137 PUSER_INFO_0 ui0;
2138 /* sizes of the field buffers in WCHARS */
2139 int name_sz, password_sz, home_dir_sz, comment_sz, script_path_sz;
2140
2141 password_sz = 1; /* not filled out for security reasons for NetUserGetInfo*/
2142 comment_sz = 1;
2143 script_path_sz = 1;
2144
2145 /* get data */
2146 status = NetUserGetInfo(servername, username, 0, (LPBYTE *) &ui0);
2147 if (status != NERR_Success)
2148 {
2149 NetApiBufferFree(ui0);
2150 return status;
2151 }
2152 name_sz = lstrlenW(ui0->usri0_name) + 1;
2153 home_dir_sz = GetEnvironmentVariableW(homedirW, NULL,0);
2154 /* set up buffer */
2155 NetApiBufferAllocate(sizeof(USER_INFO_1) +
2156 (name_sz + password_sz + home_dir_sz +
2157 comment_sz + script_path_sz) * sizeof(WCHAR),
2158 (LPVOID *) bufptr);
2159
2160 ui = (PUSER_INFO_1) *bufptr;
2161 ui->usri1_name = (LPWSTR) (ui + 1);
2162 ui->usri1_password = ui->usri1_name + name_sz;
2163 ui->usri1_home_dir = ui->usri1_password + password_sz;
2164 ui->usri1_comment = ui->usri1_home_dir + home_dir_sz;
2165 ui->usri1_script_path = ui->usri1_comment + comment_sz;
2166 /* set data */
2167 lstrcpyW(ui->usri1_name, ui0->usri0_name);
2168 NetApiBufferFree(ui0);
2169 ui->usri1_password[0] = 0;
2170 ui->usri1_password_age = 0;
2171 ui->usri1_priv = 0;
2172 GetEnvironmentVariableW(homedirW, ui->usri1_home_dir,home_dir_sz);
2173 ui->usri1_comment[0] = 0;
2174 ui->usri1_flags = 0;
2175 ui->usri1_script_path[0] = 0;
2176 break;
2177 }
2178 case 2:
2179 case 3:
2180 case 4:
2181 case 11:
2182 case 20:
2183 case 23:
2184 case 1003:
2185 case 1005:
2186 case 1006:
2187 case 1007:
2188 case 1008:
2189 case 1009:
2190 case 1010:
2191 case 1011:
2192 case 1012:
2193 case 1013:
2194 case 1014:
2195 case 1017:
2196 case 1018:
2197 case 1020:
2198 case 1023:
2199 case 1024:
2200 case 1025:
2201 case 1051:
2202 case 1052:
2203 case 1053:
2204 {
2205 FIXME("Level %d is not implemented\n", level);
2206 return NERR_InternalError;
2207 }
2208 default:
2209 TRACE("Invalid level %d is specified\n", level);
2210 return ERROR_INVALID_LEVEL;
2211 }
2212 return NERR_Success;
2213 }
2214
2215 /************************************************************
2216 * NetUserGetLocalGroups (NETAPI32.@)
2217 */
2218 NET_API_STATUS WINAPI
2219 NetUserGetLocalGroups(LPCWSTR servername, LPCWSTR username, DWORD level,
2220 DWORD flags, LPBYTE* bufptr, DWORD prefmaxlen,
2221 LPDWORD entriesread, LPDWORD totalentries)
2222 {
2223 NET_API_STATUS status;
2224 const WCHAR admins[] = {'A','d','m','i','n','i','s','t','r','a','t','o','r','s',0};
2225 LPWSTR currentuser;
2226 LOCALGROUP_USERS_INFO_0* info;
2227 DWORD size;
2228
2229 FIXME("(%s, %s, %d, %08x, %p %d, %p, %p) stub!\n",
2230 debugstr_w(servername), debugstr_w(username), level, flags, bufptr,
2231 prefmaxlen, entriesread, totalentries);
2232
2233 status = NETAPI_ValidateServername(servername);
2234 if (status != NERR_Success)
2235 return status;
2236
2237 size = UNLEN + 1;
2238 NetApiBufferAllocate(size * sizeof(WCHAR), (LPVOID*)&currentuser);
2239 if (!GetUserNameW(currentuser, &size)) {
2240 NetApiBufferFree(currentuser);
2241 return ERROR_NOT_ENOUGH_MEMORY;
2242 }
2243
2244 if (lstrcmpiW(username, currentuser) && NETAPI_FindUser(username))
2245 {
2246 NetApiBufferFree(currentuser);
2247 return NERR_UserNotFound;
2248 }
2249
2250 NetApiBufferFree(currentuser);
2251 *totalentries = 1;
2252 size = sizeof(*info) + sizeof(admins);
2253
2254 if(prefmaxlen < size)
2255 status = ERROR_MORE_DATA;
2256 else
2257 status = NetApiBufferAllocate(size, (LPVOID*)&info);
2258
2259 if(status != NERR_Success)
2260 {
2261 *bufptr = NULL;
2262 *entriesread = 0;
2263 return status;
2264 }
2265
2266 info->lgrui0_name = (LPWSTR)((LPBYTE)info + sizeof(*info));
2267 lstrcpyW(info->lgrui0_name, admins);
2268
2269 *bufptr = (LPBYTE)info;
2270 *entriesread = 1;
2271
2272 return NERR_Success;
2273 }
2274
2275 /************************************************************
2276 * NetUserEnum (NETAPI32.@)
2277 */
2278 NET_API_STATUS WINAPI
2279 NetUserEnum(LPCWSTR servername, DWORD level, DWORD filter, LPBYTE* bufptr,
2280 DWORD prefmaxlen, LPDWORD entriesread, LPDWORD totalentries,
2281 LPDWORD resume_handle)
2282 {
2283 FIXME("(%s,%d, 0x%d,%p,%d,%p,%p,%p) stub!\n", debugstr_w(servername), level,
2284 filter, bufptr, prefmaxlen, entriesread, totalentries, resume_handle);
2285
2286 return ERROR_ACCESS_DENIED;
2287 }
2288
2289 /************************************************************
2290 * ACCESS_QueryAdminDisplayInformation
2291 *
2292 * Creates a buffer with information for the Admin User
2293 */
2294 static void ACCESS_QueryAdminDisplayInformation(PNET_DISPLAY_USER *buf, PDWORD pdwSize)
2295 {
2296 static const WCHAR sAdminUserName[] = {
2297 'A','d','m','i','n','i','s','t','r','a','t','o','r',0};
2298
2299 /* sizes of the field buffers in WCHARS */
2300 int name_sz, comment_sz, full_name_sz;
2301 PNET_DISPLAY_USER usr;
2302
2303 /* set up buffer */
2304 name_sz = lstrlenW(sAdminUserName) + 1;
2305 comment_sz = 1;
2306 full_name_sz = 1;
2307
2308 *pdwSize = sizeof(NET_DISPLAY_USER);
2309 *pdwSize += (name_sz + comment_sz + full_name_sz) * sizeof(WCHAR);
2310 NetApiBufferAllocate(*pdwSize, (LPVOID *) buf);
2311
2312 usr = *buf;
2313 usr->usri1_name = (LPWSTR) ((PBYTE) usr + sizeof(NET_DISPLAY_USER));
2314 usr->usri1_comment = (LPWSTR) (
2315 ((PBYTE) usr->usri1_name) + name_sz * sizeof(WCHAR));
2316 usr->usri1_full_name = (LPWSTR) (
2317 ((PBYTE) usr->usri1_comment) + comment_sz * sizeof(WCHAR));
2318
2319 /* set data */
2320 lstrcpyW(usr->usri1_name, sAdminUserName);
2321 usr->usri1_comment[0] = 0;
2322 usr->usri1_flags = UF_SCRIPT | UF_NORMAL_ACCOUNT | UF_DONT_EXPIRE_PASSWD;
2323 usr->usri1_full_name[0] = 0;
2324 usr->usri1_user_id = DOMAIN_USER_RID_ADMIN;
2325 usr->usri1_next_index = 0;
2326 }
2327
2328 /************************************************************
2329 * ACCESS_QueryGuestDisplayInformation
2330 *
2331 * Creates a buffer with information for the Guest User
2332 */
2333 static void ACCESS_QueryGuestDisplayInformation(PNET_DISPLAY_USER *buf, PDWORD pdwSize)
2334 {
2335 static const WCHAR sGuestUserName[] = {
2336 'G','u','e','s','t',0 };
2337
2338 /* sizes of the field buffers in WCHARS */
2339 int name_sz, comment_sz, full_name_sz;
2340 PNET_DISPLAY_USER usr;
2341
2342 /* set up buffer */
2343 name_sz = lstrlenW(sGuestUserName) + 1;
2344 comment_sz = 1;
2345 full_name_sz = 1;
2346
2347 *pdwSize = sizeof(NET_DISPLAY_USER);
2348 *pdwSize += (name_sz + comment_sz + full_name_sz) * sizeof(WCHAR);
2349 NetApiBufferAllocate(*pdwSize, (LPVOID *) buf);
2350
2351 usr = *buf;
2352 usr->usri1_name = (LPWSTR) ((PBYTE) usr + sizeof(NET_DISPLAY_USER));
2353 usr->usri1_comment = (LPWSTR) (
2354 ((PBYTE) usr->usri1_name) + name_sz * sizeof(WCHAR));
2355 usr->usri1_full_name = (LPWSTR) (
2356 ((PBYTE) usr->usri1_comment) + comment_sz * sizeof(WCHAR));
2357
2358 /* set data */
2359 lstrcpyW(usr->usri1_name, sGuestUserName);
2360 usr->usri1_comment[0] = 0;
2361 usr->usri1_flags = UF_ACCOUNTDISABLE | UF_SCRIPT | UF_NORMAL_ACCOUNT |
2362 UF_DONT_EXPIRE_PASSWD;
2363 usr->usri1_full_name[0] = 0;
2364 usr->usri1_user_id = DOMAIN_USER_RID_GUEST;
2365 usr->usri1_next_index = 0;
2366 }
2367
2368 /************************************************************
2369 * Copies NET_DISPLAY_USER record.
2370 */
2371 static void ACCESS_CopyDisplayUser(const NET_DISPLAY_USER *dest, LPWSTR *dest_buf,
2372 PNET_DISPLAY_USER src)
2373 {
2374 LPWSTR str = *dest_buf;
2375
2376 src->usri1_name = str;
2377 lstrcpyW(src->usri1_name, dest->usri1_name);
2378 str = (LPWSTR) (
2379 ((PBYTE) str) + (lstrlenW(str) + 1) * sizeof(WCHAR));
2380
2381 src->usri1_comment = str;
2382 lstrcpyW(src->usri1_comment, dest->usri1_comment);
2383 str = (LPWSTR) (
2384 ((PBYTE) str) + (lstrlenW(str) + 1) * sizeof(WCHAR));
2385
2386 src->usri1_flags = dest->usri1_flags;
2387
2388 src->usri1_full_name = str;
2389 lstrcpyW(src->usri1_full_name, dest->usri1_full_name);
2390 str = (LPWSTR) (
2391 ((PBYTE) str) + (lstrlenW(str) + 1) * sizeof(WCHAR));
2392
2393 src->usri1_user_id = dest->usri1_user_id;
2394 src->usri1_next_index = dest->usri1_next_index;
2395 *dest_buf = str;
2396 }
2397
2398 /************************************************************
2399 * NetQueryDisplayInformation (NETAPI32.@)
2400 *
2401 * The buffer structure:
2402 * - array of fixed size record of the level type
2403 * - strings, referenced by the record of the level type
2404 */
2405 NET_API_STATUS WINAPI
2406 NetQueryDisplayInformation(
2407 LPCWSTR ServerName, DWORD Level, DWORD Index, DWORD EntriesRequested,
2408 DWORD PreferredMaximumLength, LPDWORD ReturnedEntryCount,
2409 PVOID *SortedBuffer)
2410 {
2411 TRACE("(%s, %d, %d, %d, %d, %p, %p)\n", debugstr_w(ServerName),
2412 Level, Index, EntriesRequested, PreferredMaximumLength,
2413 ReturnedEntryCount, SortedBuffer);
2414
2415 if(!NETAPI_IsLocalComputer(ServerName))
2416 {
2417 FIXME("Only implemented on local computer, but requested for "
2418 "remote server %s\n", debugstr_w(ServerName));
2419 return ERROR_ACCESS_DENIED;
2420 }
2421
2422 switch (Level)
2423 {
2424 case 1:
2425 {
2426 /* current record */
2427 PNET_DISPLAY_USER inf;
2428 /* current available strings buffer */
2429 LPWSTR str;
2430 PNET_DISPLAY_USER admin, guest;
2431 DWORD admin_size, guest_size;
2432 LPWSTR name = NULL;
2433 DWORD dwSize;
2434
2435 /* sizes of the field buffers in WCHARS */
2436 int name_sz, comment_sz, full_name_sz;
2437
2438 /* number of the records, returned in SortedBuffer
2439 3 - for current user, Administrator and Guest users
2440 */
2441 int records = 3;
2442
2443 FIXME("Level %d partially implemented\n", Level);
2444 *ReturnedEntryCount = records;
2445 comment_sz = 1;
2446 full_name_sz = 1;
2447
2448 /* get data */
2449 dwSize = UNLEN + 1;
2450 NetApiBufferAllocate(dwSize * sizeof(WCHAR), (LPVOID *) &name);
2451 if (!GetUserNameW(name, &dwSize))
2452 {
2453 NetApiBufferFree(name);
2454 return ERROR_ACCESS_DENIED;
2455 }
2456 name_sz = dwSize;
2457 ACCESS_QueryAdminDisplayInformation(&admin, &admin_size);
2458 ACCESS_QueryGuestDisplayInformation(&guest, &guest_size);
2459
2460 /* set up buffer */
2461 dwSize = sizeof(NET_DISPLAY_USER) * records;
2462 dwSize += (name_sz + comment_sz + full_name_sz) * sizeof(WCHAR);
2463
2464 NetApiBufferAllocate(dwSize +
2465 admin_size - sizeof(NET_DISPLAY_USER) +
2466 guest_size - sizeof(NET_DISPLAY_USER),
2467 SortedBuffer);
2468 inf = *SortedBuffer;
2469 str = (LPWSTR) ((PBYTE) inf + sizeof(NET_DISPLAY_USER) * records);
2470 inf->usri1_name = str;
2471 str = (LPWSTR) (
2472 ((PBYTE) str) + name_sz * sizeof(WCHAR));
2473 inf->usri1_comment = str;
2474 str = (LPWSTR) (
2475 ((PBYTE) str) + comment_sz * sizeof(WCHAR));
2476 inf->usri1_full_name = str;
2477 str = (LPWSTR) (
2478 ((PBYTE) str) + full_name_sz * sizeof(WCHAR));
2479
2480 /* set data */
2481 lstrcpyW(inf->usri1_name, name);
2482 NetApiBufferFree(name);
2483 inf->usri1_comment[0] = 0;
2484 inf->usri1_flags =
2485 UF_SCRIPT | UF_NORMAL_ACCOUNT | UF_DONT_EXPIRE_PASSWD;
2486 inf->usri1_full_name[0] = 0;
2487 inf->usri1_user_id = 0;
2488 inf->usri1_next_index = 0;
2489
2490 inf++;
2491 ACCESS_CopyDisplayUser(admin, &str, inf);
2492 NetApiBufferFree(admin);
2493
2494 inf++;
2495 ACCESS_CopyDisplayUser(guest, &str, inf);
2496 NetApiBufferFree(guest);
2497 break;
2498 }
2499
2500 case 2:
2501 case 3:
2502 {
2503 FIXME("Level %d is not implemented\n", Level);
2504 break;
2505 }
2506
2507 default:
2508 TRACE("Invalid level %d is specified\n", Level);
2509 return ERROR_INVALID_LEVEL;
2510 }
2511 return NERR_Success;
2512 }
2513
2514 /************************************************************
2515 * NetGetDCName (NETAPI32.@)
2516 *
2517 * Return the name of the primary domain controller (PDC)
2518 */
2519
2520 NET_API_STATUS WINAPI
2521 NetGetDCName(LPCWSTR servername, LPCWSTR domainname, LPBYTE *bufptr)
2522 {
2523 FIXME("(%s, %s, %p) stub!\n", debugstr_w(servername),
2524 debugstr_w(domainname), bufptr);
2525 return NERR_DCNotFound; /* say we can't find a domain controller */
2526 }
2527
2528 /************************************************************
2529 * NetGetAnyDCName (NETAPI32.@)
2530 *
2531 * Return the name of any domain controller (DC) for a
2532 * domain that is directly trusted by the specified server
2533 */
2534
2535 NET_API_STATUS WINAPI NetGetAnyDCName(LPCWSTR servername, LPCWSTR domainname, LPBYTE *bufptr)
2536 {
2537 FIXME("(%s, %s, %p) stub!\n", debugstr_w(servername),
2538 debugstr_w(domainname), bufptr);
2539 return ERROR_NO_SUCH_DOMAIN;
2540 }
2541
2542 /************************************************************
2543 * NetGroupEnum (NETAPI32.@)
2544 *
2545 */
2546 NET_API_STATUS WINAPI
2547 NetGroupEnum(LPCWSTR servername, DWORD level, LPBYTE *bufptr, DWORD prefmaxlen,
2548 LPDWORD entriesread, LPDWORD totalentries, LPDWORD resume_handle)
2549 {
2550 FIXME("(%s, %d, %p, %d, %p, %p, %p) stub!\n", debugstr_w(servername),
2551 level, bufptr, prefmaxlen, entriesread, totalentries, resume_handle);
2552 return ERROR_ACCESS_DENIED;
2553 }
2554
2555 /************************************************************
2556 * NetGroupGetInfo (NETAPI32.@)
2557 *
2558 */
2559 NET_API_STATUS WINAPI NetGroupGetInfo(LPCWSTR servername, LPCWSTR groupname, DWORD level, LPBYTE *bufptr)
2560 {
2561 FIXME("(%s, %s, %d, %p) stub!\n", debugstr_w(servername), debugstr_w(groupname), level, bufptr);
2562 return ERROR_ACCESS_DENIED;
2563 }
2564
2565 /******************************************************************************
2566 * NetUserModalsGet (NETAPI32.@)
2567 *
2568 * Retrieves global information for all users and global groups in the security
2569 * database.
2570 *
2571 * PARAMS
2572 * szServer [I] Specifies the DNS or the NetBIOS name of the remote server
2573 * on which the function is to execute.
2574 * level [I] Information level of the data.
2575 * 0 Return global passwords parameters. bufptr points to a
2576 * USER_MODALS_INFO_0 struct.
2577 * 1 Return logon server and domain controller information. bufptr
2578 * points to a USER_MODALS_INFO_1 struct.
2579 * 2 Return domain name and identifier. bufptr points to a
2580 * USER_MODALS_INFO_2 struct.
2581 * 3 Return lockout information. bufptr points to a USER_MODALS_INFO_3
2582 * struct.
2583 * pbuffer [I] Buffer that receives the data.
2584 *
2585 * RETURNS
2586 * Success: NERR_Success.
2587 * Failure:
2588 * ERROR_ACCESS_DENIED - the user does not have access to the info.
2589 * NERR_InvalidComputer - computer name is invalid.
2590 */
2591 NET_API_STATUS WINAPI NetUserModalsGet(
2592 LPCWSTR szServer, DWORD level, LPBYTE *pbuffer)
2593 {
2594 TRACE("(%s %d %p)\n", debugstr_w(szServer), level, pbuffer);
2595
2596 switch (level)
2597 {
2598 case 0:
2599 /* return global passwords parameters */
2600 FIXME("level 0 not implemented!\n");
2601 *pbuffer = NULL;
2602 return NERR_InternalError;
2603 case 1:
2604 /* return logon server and domain controller info */
2605 FIXME("level 1 not implemented!\n");
2606 *pbuffer = NULL;
2607 return NERR_InternalError;
2608 case 2:
2609 {
2610 /* return domain name and identifier */
2611 PUSER_MODALS_INFO_2 umi;
2612 LSA_HANDLE policyHandle;
2613 LSA_OBJECT_ATTRIBUTES objectAttributes;
2614 PPOLICY_ACCOUNT_DOMAIN_INFO domainInfo;
2615 NTSTATUS ntStatus;
2616 PSID domainIdentifier = NULL;
2617 int domainNameLen;
2618
2619 ZeroMemory(&objectAttributes, sizeof(objectAttributes));
2620 objectAttributes.Length = sizeof(objectAttributes);
2621
2622 ntStatus = LsaOpenPolicy(NULL, &objectAttributes,
2623 POLICY_VIEW_LOCAL_INFORMATION,
2624 &policyHandle);
2625 if (ntStatus != STATUS_SUCCESS)
2626 {
2627 WARN("LsaOpenPolicy failed with NT status %x\n",
2628 LsaNtStatusToWinError(ntStatus));
2629 return ntStatus;
2630 }
2631
2632 ntStatus = LsaQueryInformationPolicy(policyHandle,
2633 PolicyAccountDomainInformation,
2634 (PVOID *)&domainInfo);
2635 if (ntStatus != STATUS_SUCCESS)
2636 {
2637 WARN("LsaQueryInformationPolicy failed with NT status %x\n",
2638 LsaNtStatusToWinError(ntStatus));
2639 LsaClose(policyHandle);
2640 return ntStatus;
2641 }
2642
2643 domainIdentifier = domainInfo->DomainSid;
2644 domainNameLen = lstrlenW(domainInfo->DomainName.Buffer) + 1;
2645 LsaClose(policyHandle);
2646
2647 ntStatus = NetApiBufferAllocate(sizeof(USER_MODALS_INFO_2) +
2648 GetLengthSid(domainIdentifier) +
2649 domainNameLen * sizeof(WCHAR),
2650 (LPVOID *)pbuffer);
2651
2652 if (ntStatus != NERR_Success)
2653 {
2654 WARN("NetApiBufferAllocate() failed\n");
2655 LsaFreeMemory(domainInfo);
2656 return ntStatus;
2657 }
2658
2659 umi = (USER_MODALS_INFO_2 *) *pbuffer;
2660 umi->usrmod2_domain_id = *pbuffer + sizeof(USER_MODALS_INFO_2);
2661 umi->usrmod2_domain_name = (LPWSTR)(*pbuffer +
2662 sizeof(USER_MODALS_INFO_2) + GetLengthSid(domainIdentifier));
2663
2664 lstrcpynW(umi->usrmod2_domain_name,
2665 domainInfo->DomainName.Buffer,
2666 domainNameLen);
2667 CopySid(GetLengthSid(domainIdentifier), umi->usrmod2_domain_id,
2668 domainIdentifier);
2669
2670 LsaFreeMemory(domainInfo);
2671
2672 break;
2673 }
2674 case 3:
2675 /* return lockout information */
2676 FIXME("level 3 not implemented!\n");
2677 *pbuffer = NULL;
2678 return NERR_InternalError;
2679 default:
2680 TRACE("Invalid level %d is specified\n", level);
2681 *pbuffer = NULL;
2682 return ERROR_INVALID_LEVEL;
2683 }
2684
2685 return NERR_Success;
2686 }
2687
2688 static NET_API_STATUS change_password_smb( LPCWSTR domainname, LPCWSTR username,
2689 LPCWSTR oldpassword, LPCWSTR newpassword )
2690 {
2691 #ifdef HAVE_FORK
2692 NET_API_STATUS ret = NERR_Success;
2693 static char option_silent[] = "-s";
2694 static char option_user[] = "-U";
2695 static char option_remote[] = "-r";
2696 static char smbpasswd[] = "smbpasswd";
2697 int pipe_out[2];
2698 pid_t pid, wret;
2699 int status;
2700 char *server = NULL, *user, *argv[7], *old = NULL, *new = NULL;
2701
2702 if (domainname && !(server = strdup_unixcp( domainname ))) return ERROR_OUTOFMEMORY;
2703 if (!(user = strdup_unixcp( username )))
2704 {
2705 ret = ERROR_OUTOFMEMORY;
2706 goto end;
2707 }
2708 if (!(old = strdup_unixcp( oldpassword )))
2709 {
2710 ret = ERROR_OUTOFMEMORY;
2711 goto end;
2712 }
2713 if (!(new = strdup_unixcp( newpassword )))
2714 {
2715 ret = ERROR_OUTOFMEMORY;
2716 goto end;
2717 }
2718 argv[0] = smbpasswd;
2719 argv[1] = option_silent;
2720 argv[2] = option_user;
2721 argv[3] = user;
2722 if (server)
2723 {
2724 argv[4] = option_remote;
2725 argv[5] = server;
2726 argv[6] = NULL;
2727 }
2728 else argv[4] = NULL;
2729
2730 if (pipe( pipe_out ) == -1)
2731 {
2732 ret = NERR_InternalError;
2733 goto end;
2734 }
2735 fcntl( pipe_out[0], F_SETFD, FD_CLOEXEC );
2736 fcntl( pipe_out[1], F_SETFD, FD_CLOEXEC );
2737
2738 switch ((pid = fork()))
2739 {
2740 case -1:
2741 close( pipe_out[0] );
2742 close( pipe_out[1] );
2743 ret = NERR_InternalError;
2744 goto end;
2745 case 0:
2746 dup2( pipe_out[0], 0 );
2747 close( pipe_out[0] );
2748 close( pipe_out[1] );
2749 execvp( "smbpasswd", argv );
2750 ERR( "can't execute smbpasswd, is it installed?\n" );
2751 _exit(1);
2752 default:
2753 close( pipe_out[0] );
2754 break;
2755 }
2756 write( pipe_out[1], old, strlen( old ) );
2757 write( pipe_out[1], "\n", 1 );
2758 write( pipe_out[1], new, strlen( new ) );
2759 write( pipe_out[1], "\n", 1 );
2760 write( pipe_out[1], new, strlen( new ) );
2761 write( pipe_out[1], "\n", 1 );
2762 close( pipe_out[1] );
2763
2764 do {
2765 wret = waitpid(pid, &status, 0);
2766 } while (wret < 0 && errno == EINTR);
2767
2768 if (ret == NERR_Success && (wret < 0 || !WIFEXITED(status) || WEXITSTATUS(status)))
2769 ret = NERR_InternalError;
2770
2771 end:
2772 HeapFree( GetProcessHeap(), 0, server );
2773 HeapFree( GetProcessHeap(), 0, user );
2774 HeapFree( GetProcessHeap(), 0, old );
2775 HeapFree( GetProcessHeap(), 0, new );
2776 return ret;
2777 #else
2778 ERR( "no fork support on this platform\n" );
2779 return NERR_InternalError;
2780 #endif
2781 }
2782
2783 /******************************************************************************
2784 * NetUserChangePassword (NETAPI32.@)
2785 * PARAMS
2786 * domainname [I] Optional. Domain on which the user resides or the logon
2787 * domain of the current user if NULL.
2788 * username [I] Optional. Username to change the password for or the name
2789 * of the current user if NULL.
2790 * oldpassword [I] The user's current password.
2791 * newpassword [I] The password that the user will be changed to using.
2792 *
2793 * RETURNS
2794 * Success: NERR_Success.
2795 * Failure: NERR_* failure code or win error code.
2796 *
2797 */
2798 NET_API_STATUS WINAPI NetUserChangePassword(LPCWSTR domainname, LPCWSTR username,
2799 LPCWSTR oldpassword, LPCWSTR newpassword)
2800 {
2801 struct sam_user *user;
2802
2803 TRACE("(%s, %s, ..., ...)\n", debugstr_w(domainname), debugstr_w(username));
2804
2805 if (!change_password_smb( domainname, username, oldpassword, newpassword ))
2806 return NERR_Success;
2807
2808 if(domainname)
2809 FIXME("Ignoring domainname %s.\n", debugstr_w(domainname));
2810
2811 if((user = NETAPI_FindUser(username)) == NULL)
2812 return NERR_UserNotFound;
2813
2814 if(lstrcmpW(user->user_password, oldpassword) != 0)
2815 return ERROR_INVALID_PASSWORD;
2816
2817 if(lstrlenW(newpassword) > PWLEN)
2818 return ERROR_PASSWORD_RESTRICTION;
2819
2820 lstrcpyW(user->user_password, newpassword);
2821
2822 return NERR_Success;
2823 }
2824
2825 NET_API_STATUS WINAPI NetUseAdd(LMSTR servername, DWORD level, LPBYTE bufptr, LPDWORD parm_err)
2826 {
2827 FIXME("%s %d %p %p stub\n", debugstr_w(servername), level, bufptr, parm_err);
2828 return NERR_Success;
2829 }
2830
2831 NET_API_STATUS WINAPI NetUseDel(LMSTR servername, LMSTR usename, DWORD forcecond)
2832 {
2833 FIXME("%s %s %d stub\n", debugstr_w(servername), debugstr_w(usename), forcecond);
2834 return NERR_Success;
2835 }
2836
2837 /************************************************************
2838 * I_BrowserSetNetlogonState (NETAPI32.@)
2839 */
2840 NET_API_STATUS WINAPI I_BrowserSetNetlogonState(
2841 LPWSTR ServerName, LPWSTR DomainName, LPWSTR EmulatedServerName,
2842 DWORD Role)
2843 {
2844 return ERROR_NOT_SUPPORTED;
2845 }
2846
2847 /************************************************************
2848 * I_BrowserQueryEmulatedDomains (NETAPI32.@)
2849 */
2850 NET_API_STATUS WINAPI I_BrowserQueryEmulatedDomains(
2851 LPWSTR ServerName, PBROWSER_EMULATED_DOMAIN *EmulatedDomains,
2852 LPDWORD EntriesRead)
2853 {
2854 return ERROR_NOT_SUPPORTED;
2855 }
2856
2857 DWORD WINAPI DsGetDcNameW(LPCWSTR ComputerName, LPCWSTR AvoidDCName,
2858 GUID* DomainGuid, LPCWSTR SiteName, ULONG Flags,
2859 PDOMAIN_CONTROLLER_INFOW *DomainControllerInfo)
2860 {
2861 FIXME("(%s, %s, %s, %s, %08x, %p): stub\n", debugstr_w(ComputerName),
2862 debugstr_w(AvoidDCName), debugstr_guid(DomainGuid),
2863 debugstr_w(SiteName), Flags, DomainControllerInfo);
2864 return ERROR_CALL_NOT_IMPLEMENTED;
2865 }
2866
2867 DWORD WINAPI DsGetDcNameA(LPCSTR ComputerName, LPCSTR AvoidDCName,
2868 GUID* DomainGuid, LPCSTR SiteName, ULONG Flags,
2869 PDOMAIN_CONTROLLER_INFOA *DomainControllerInfo)
2870 {
2871 FIXME("(%s, %s, %s, %s, %08x, %p): stub\n", debugstr_a(ComputerName),
2872 debugstr_a(AvoidDCName), debugstr_guid(DomainGuid),
2873 debugstr_a(SiteName), Flags, DomainControllerInfo);
2874 return ERROR_CALL_NOT_IMPLEMENTED;
2875 }
2876
2877 DWORD WINAPI DsGetSiteNameW(LPCWSTR ComputerName, LPWSTR *SiteName)
2878 {
2879 FIXME("(%s, %p): stub\n", debugstr_w(ComputerName), SiteName);
2880 return ERROR_CALL_NOT_IMPLEMENTED;
2881 }
2882
2883 DWORD WINAPI DsGetSiteNameA(LPCSTR ComputerName, LPSTR *SiteName)
2884 {
2885 FIXME("(%s, %p): stub\n", debugstr_a(ComputerName), SiteName);
2886 return ERROR_CALL_NOT_IMPLEMENTED;
2887 }
2888
2889 /************************************************************
2890 * DsRoleFreeMemory (NETAPI32.@)
2891 *
2892 * PARAMS
2893 * Buffer [I] Pointer to the to-be-freed buffer.
2894 *
2895 * RETURNS
2896 * Nothing
2897 */
2898 VOID WINAPI DsRoleFreeMemory(PVOID Buffer)
2899 {
2900 TRACE("(%p)\n", Buffer);
2901 HeapFree(GetProcessHeap(), 0, Buffer);
2902 }
2903
2904 /************************************************************
2905 * DsRoleGetPrimaryDomainInformation (NETAPI32.@)
2906 *
2907 * PARAMS
2908 * lpServer [I] Pointer to UNICODE string with ComputerName
2909 * InfoLevel [I] Type of data to retrieve
2910 * Buffer [O] Pointer to to the requested data
2911 *
2912 * RETURNS
2913 *
2914 * NOTES
2915 * When lpServer is NULL, use the local computer
2916 */
2917 DWORD WINAPI DsRoleGetPrimaryDomainInformation(
2918 LPCWSTR lpServer, DSROLE_PRIMARY_DOMAIN_INFO_LEVEL InfoLevel,
2919 PBYTE* Buffer)
2920 {
2921 DWORD ret;
2922
2923 FIXME("(%p, %d, %p) stub\n", lpServer, InfoLevel, Buffer);
2924
2925 /* Check some input parameters */
2926
2927 if (!Buffer) return ERROR_INVALID_PARAMETER;
2928 if ((InfoLevel < DsRolePrimaryDomainInfoBasic) || (InfoLevel > DsRoleOperationState)) return ERROR_INVALID_PARAMETER;
2929
2930 *Buffer = NULL;
2931 switch (InfoLevel)
2932 {
2933 case DsRolePrimaryDomainInfoBasic:
2934 {
2935 LSA_OBJECT_ATTRIBUTES ObjectAttributes;
2936 LSA_HANDLE PolicyHandle;
2937 PPOLICY_ACCOUNT_DOMAIN_INFO DomainInfo;
2938 NTSTATUS NtStatus;
2939 int logon_domain_sz;
2940 DWORD size;
2941 PDSROLE_PRIMARY_DOMAIN_INFO_BASIC basic;
2942
2943 ZeroMemory(&ObjectAttributes, sizeof(ObjectAttributes));
2944 NtStatus = LsaOpenPolicy(NULL, &ObjectAttributes,
2945 POLICY_VIEW_LOCAL_INFORMATION, &PolicyHandle);
2946 if (NtStatus != STATUS_SUCCESS)
2947 {
2948 TRACE("LsaOpenPolicyFailed with NT status %x\n",
2949 LsaNtStatusToWinError(NtStatus));
2950 return ERROR_OUTOFMEMORY;
2951 }
2952 LsaQueryInformationPolicy(PolicyHandle,
2953 PolicyAccountDomainInformation, (PVOID*)&DomainInfo);
2954 logon_domain_sz = lstrlenW(DomainInfo->DomainName.Buffer) + 1;
2955 LsaClose(PolicyHandle);
2956
2957 size = sizeof(DSROLE_PRIMARY_DOMAIN_INFO_BASIC) +
2958 logon_domain_sz * sizeof(WCHAR);
2959 basic = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, size);
2960 if (basic)
2961 {
2962 basic->MachineRole = DsRole_RoleStandaloneWorkstation;
2963 basic->DomainNameFlat = (LPWSTR)((LPBYTE)basic +
2964 sizeof(DSROLE_PRIMARY_DOMAIN_INFO_BASIC));
2965 lstrcpyW(basic->DomainNameFlat, DomainInfo->DomainName.Buffer);
2966 ret = ERROR_SUCCESS;
2967 }
2968 else
2969 ret = ERROR_OUTOFMEMORY;
2970 *Buffer = (PBYTE)basic;
2971 LsaFreeMemory(DomainInfo);
2972 }
2973 break;
2974 default:
2975 ret = ERROR_CALL_NOT_IMPLEMENTED;
2976 }
2977 return ret;
2978 }
2979
2980 /************************************************************
2981 * NetLocalGroupAdd (NETAPI32.@)
2982 */
2983 NET_API_STATUS WINAPI NetLocalGroupAdd(
2984 LPCWSTR servername,
2985 DWORD level,
2986 LPBYTE buf,
2987 LPDWORD parm_err)
2988 {
2989 FIXME("(%s %d %p %p) stub!\n", debugstr_w(servername), level, buf,
2990 parm_err);
2991 return NERR_Success;
2992 }
2993
2994 /************************************************************
2995 * NetLocalGroupAddMember (NETAPI32.@)
2996 */
2997 NET_API_STATUS WINAPI NetLocalGroupAddMember(
2998 LPCWSTR servername,
2999 LPCWSTR groupname,
3000 PSID membersid)
3001 {
3002 FIXME("(%s %s %p) stub!\n", debugstr_w(servername),
3003 debugstr_w(groupname), membersid);
3004 return NERR_Success;
3005 }
3006
3007 /************************************************************
3008 * NetLocalGroupAddMembers (NETAPI32.@)
3009 */
3010 NET_API_STATUS WINAPI NetLocalGroupAddMembers(
3011 LPCWSTR servername,
3012 LPCWSTR groupname,
3013 DWORD level,
3014 LPBYTE buf,
3015 DWORD totalentries)
3016 {
3017 FIXME("(%s %s %d %p %d) stub!\n", debugstr_w(servername),
3018 debugstr_w(groupname), level, buf, totalentries);
3019 return NERR_Success;
3020 }
3021
3022 /************************************************************
3023 * NetLocalGroupDel (NETAPI32.@)
3024 */
3025 NET_API_STATUS WINAPI NetLocalGroupDel(
3026 LPCWSTR servername,
3027 LPCWSTR groupname)
3028 {
3029 FIXME("(%s %s) stub!\n", debugstr_w(servername), debugstr_w(groupname));
3030 return NERR_Success;
3031 }
3032
3033 /************************************************************
3034 * NetLocalGroupDelMember (NETAPI32.@)
3035 */
3036 NET_API_STATUS WINAPI NetLocalGroupDelMember(
3037 LPCWSTR servername,
3038 LPCWSTR groupname,
3039 PSID membersid)
3040 {
3041 FIXME("(%s %s %p) stub!\n", debugstr_w(servername),
3042 debugstr_w(groupname), membersid);
3043 return NERR_Success;
3044 }
3045
3046 /************************************************************
3047 * NetLocalGroupDelMembers (NETAPI32.@)
3048 */
3049 NET_API_STATUS WINAPI NetLocalGroupDelMembers(
3050 LPCWSTR servername,
3051 LPCWSTR groupname,
3052 DWORD level,
3053 LPBYTE buf,
3054 DWORD totalentries)
3055 {
3056 FIXME("(%s %s %d %p %d) stub!\n", debugstr_w(servername),
3057 debugstr_w(groupname), level, buf, totalentries);
3058 return NERR_Success;
3059 }
3060
3061 /************************************************************
3062 * NetLocalGroupEnum (NETAPI32.@)
3063 */
3064 NET_API_STATUS WINAPI NetLocalGroupEnum(
3065 LPCWSTR servername,
3066 DWORD level,
3067 LPBYTE* bufptr,
3068 DWORD prefmaxlen,
3069 LPDWORD entriesread,
3070 LPDWORD totalentries,
3071 PDWORD_PTR resumehandle)
3072 {
3073 FIXME("(%s %d %p %d %p %p %p) stub!\n", debugstr_w(servername),
3074 level, bufptr, prefmaxlen, entriesread, totalentries, resumehandle);
3075 *entriesread = 0;
3076 *totalentries = 0;
3077 return NERR_Success;
3078 }
3079
3080 /************************************************************
3081 * NetLocalGroupGetInfo (NETAPI32.@)
3082 */
3083 NET_API_STATUS WINAPI NetLocalGroupGetInfo(
3084 LPCWSTR servername,
3085 LPCWSTR groupname,
3086 DWORD level,
3087 LPBYTE* bufptr)
3088 {
3089 static const WCHAR commentW[]={'N','o',' ','c','o','m','m','e','n','t',0};
3090 LOCALGROUP_INFO_1* info;
3091 DWORD size;
3092
3093 FIXME("(%s %s %d %p) semi-stub!\n", debugstr_w(servername),
3094 debugstr_w(groupname), level, bufptr);
3095
3096 size = sizeof(*info) + sizeof(WCHAR) * (lstrlenW(groupname)+1) + sizeof(commentW);
3097 NetApiBufferAllocate(size, (LPVOID*)&info);
3098
3099 info->lgrpi1_name = (LPWSTR)(info + 1);
3100 lstrcpyW(info->lgrpi1_name, groupname);
3101
3102 info->lgrpi1_comment = info->lgrpi1_name + lstrlenW(groupname) + 1;
3103 lstrcpyW(info->lgrpi1_comment, commentW);
3104
3105 *bufptr = (LPBYTE)info;
3106
3107 return NERR_Success;
3108 }
3109
3110 /************************************************************
3111 * NetLocalGroupGetMembers (NETAPI32.@)
3112 */
3113 NET_API_STATUS WINAPI NetLocalGroupGetMembers(
3114 LPCWSTR servername,
3115 LPCWSTR localgroupname,
3116 DWORD level,
3117 LPBYTE* bufptr,
3118 DWORD prefmaxlen,
3119 LPDWORD entriesread,
3120 LPDWORD totalentries,
3121 PDWORD_PTR resumehandle)
3122 {
3123 FIXME("(%s %s %d %p %d, %p %p %p) stub!\n", debugstr_w(servername),
3124 debugstr_w(localgroupname), level, bufptr, prefmaxlen, entriesread,
3125 totalentries, resumehandle);
3126
3127 if (level == 3)
3128 {
3129 WCHAR userName[MAX_COMPUTERNAME_LENGTH + 1];
3130 DWORD userNameLen;
3131 DWORD len,needlen;
3132 PLOCALGROUP_MEMBERS_INFO_3 ptr;
3133
3134 /* still a stub, current user is belonging to all groups */
3135
3136 *totalentries = 1;
3137 *entriesread = 0;
3138
3139 userNameLen = MAX_COMPUTERNAME_LENGTH + 1;
3140 if (!GetUserNameW(userName,&userNameLen))
3141 return ERROR_NOT_ENOUGH_MEMORY;
3142
3143 needlen = sizeof(LOCALGROUP_MEMBERS_INFO_3) +
3144 (userNameLen+2) * sizeof(WCHAR);
3145 if (prefmaxlen != MAX_PREFERRED_LENGTH)
3146 len = min(prefmaxlen,needlen);
3147 else
3148 len = needlen;
3149
3150 NetApiBufferAllocate(len, (LPVOID *) bufptr);
3151 if (len < needlen)
3152 return ERROR_MORE_DATA;
3153
3154 ptr = (PLOCALGROUP_MEMBERS_INFO_3)*bufptr;
3155 ptr->lgrmi3_domainandname = (LPWSTR)(*bufptr+sizeof(LOCALGROUP_MEMBERS_INFO_3));
3156 lstrcpyW(ptr->lgrmi3_domainandname,userName);
3157
3158 *entriesread = 1;
3159 }
3160
3161 return NERR_Success;
3162 }
3163
3164 /************************************************************
3165 * NetLocalGroupSetInfo (NETAPI32.@)
3166 */
3167 NET_API_STATUS WINAPI NetLocalGroupSetInfo(
3168 LPCWSTR servername,
3169 LPCWSTR groupname,
3170 DWORD level,
3171 LPBYTE buf,
3172 LPDWORD parm_err)
3173 {
3174 FIXME("(%s %s %d %p %p) stub!\n", debugstr_w(servername),
3175 debugstr_w(groupname), level, buf, parm_err);
3176 return NERR_Success;
3177 }
3178
3179 /************************************************************
3180 * NetLocalGroupSetMember (NETAPI32.@)
3181 */
3182 NET_API_STATUS WINAPI NetLocalGroupSetMembers(
3183 LPCWSTR servername,
3184 LPCWSTR groupname,
3185 DWORD level,
3186 LPBYTE buf,
3187 DWORD totalentries)
3188 {
3189 FIXME("(%s %s %d %p %d) stub!\n", debugstr_w(servername),
3190 debugstr_w(groupname), level, buf, totalentries);
3191 return NERR_Success;
3192 }
Wine tree for Wine Gecko development