?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
netapi: Add stub for NetGroupAddUser.
[wine.git] / dlls / netapi32 / netapi32.c
blob7a1d40845dbe6911b3dd18017bbf818f31390038
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 static 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 break;
545 }
546 case ACCESS_DENIED_ACE_TYPE:
547 {
548 ACCESS_DENIED_ACE *ace = (ACCESS_DENIED_ACE *)src;
549 dst->access_mask = access_mask_to_samba( ace->Mask );
550 memset( &dst->object, 0, sizeof(dst->object) );
551 sid_to_samba( (const SID *)&ace->SidStart, &dst->trustee );
552 break;
553 }
554 case SYSTEM_AUDIT_ACE_TYPE:
555 {
556 SYSTEM_AUDIT_ACE *ace = (SYSTEM_AUDIT_ACE *)src;
557 dst->access_mask = access_mask_to_samba( ace->Mask );
558 memset( &dst->object, 0, sizeof(dst->object) );
559 sid_to_samba( (const SID *)&ace->SidStart, &dst->trustee );
560 break;
561 }
562 case SYSTEM_ALARM_ACE_TYPE:
563 {
564 SYSTEM_ALARM_ACE *ace = (SYSTEM_ALARM_ACE *)src;
565 dst->access_mask = access_mask_to_samba( ace->Mask );
566 memset( &dst->object, 0, sizeof(dst->object) );
567 sid_to_samba( (const SID *)&ace->SidStart, &dst->trustee );
568 break;
569 }
570 default:
571 ERR( "unhandled type %u\n", src->AceType );
572 return ERROR_INVALID_PARAMETER;
573 }
574 return NERR_Success;
575 }
576
577 static NET_API_STATUS acl_to_samba( const ACL *src, struct acl *dst )
578 {
579 NET_API_STATUS status;
580 ACE_HEADER *src_ace;
581 unsigned int i;
582
583 switch (src->AclRevision)
584 {
585 case ACL_REVISION4:
586 dst->revision = ACL_REVISION_ADS;
587 break;
588 default:
589 ERR( "unkhandled revision %u\n", src->AclRevision );
590 return ERROR_UNKNOWN_REVISION;
591 }
592 dst->size = sizeof(*dst);
593 src_ace = (ACE_HEADER *)(src + 1);
594 dst->aces = (struct ace *)(dst + 1);
595 for (i = 0; i < src->AceCount; i++)
596 {
597 if ((status = ace_to_samba( src_ace, &dst->aces[i] ))) return status;
598 src_ace = (ACE_HEADER *)((char *)src_ace + src_ace->AceSize);
599 dst->size += dst->aces[i].size;
600 }
601 return NERR_Success;
602 }
603
604 #define SELF_RELATIVE_FIELD(sd,field)\
605 ((char *)(sd) + ((SECURITY_DESCRIPTOR_RELATIVE *)(sd))->field)
606
607 static NET_API_STATUS sd_to_samba( const SECURITY_DESCRIPTOR *src, struct security_descriptor *dst )
608 {
609 NET_API_STATUS status;
610 const SID *owner, *group;
611 const ACL *dacl, *sacl;
612 unsigned int offset = sizeof(*dst);
613
614 if (src->Revision != SECURITY_DESCRIPTOR_REVISION1)
615 return ERROR_UNKNOWN_REVISION;
616
617 dst->revision = SECURITY_DESCRIPTOR_REVISION_1;
618 dst->type = sd_control_to_samba( src->Control );
619
620 if (src->Control & SE_SELF_RELATIVE)
621 {
622 if (!src->Owner) dst->owner_sid = NULL;
623 else
624 {
625 dst->owner_sid = (struct sid *)((char *)dst + offset);
626 owner = (const SID *)SELF_RELATIVE_FIELD( src, Owner );
627 if ((status = sid_to_samba( owner, dst->owner_sid ))) return status;
628 offset += sizeof(struct sid);
629 }
630 if (!src->Group) dst->group_sid = NULL;
631 else
632 {
633 dst->group_sid = (struct sid *)((char *)dst + offset);
634 group = (const SID *)SELF_RELATIVE_FIELD( src, Group );
635 if ((status = sid_to_samba( group, dst->group_sid ))) return status;
636 offset += sizeof(struct sid);
637 }
638 if (!(src->Control & SE_SACL_PRESENT)) dst->sacl = NULL;
639 else
640 {
641 dst->sacl = (struct acl *)((char *)dst + offset);
642 sacl = (const ACL *)SELF_RELATIVE_FIELD( src, Sacl );
643 if ((status = acl_to_samba( sacl, dst->sacl ))) return status;
644 offset += dst->sacl->size;
645 }
646 if (!(src->Control & SE_DACL_PRESENT)) dst->dacl = NULL;
647 else
648 {
649 dst->dacl = (struct acl *)((char *)dst + offset);
650 dacl = (const ACL *)SELF_RELATIVE_FIELD( src, Dacl );
651 if ((status = acl_to_samba( dacl, dst->dacl ))) return status;
652 }
653 }
654 else
655 {
656 if (!src->Owner) dst->owner_sid = NULL;
657 else
658 {
659 dst->owner_sid = (struct sid *)((char *)dst + offset);
660 if ((status = sid_to_samba( src->Owner, dst->owner_sid ))) return status;
661 offset += sizeof(struct sid);
662 }
663 if (!src->Group) dst->group_sid = NULL;
664 else
665 {
666 dst->group_sid = (struct sid *)((char *)dst + offset);
667 if ((status = sid_to_samba( src->Group, dst->group_sid ))) return status;
668 offset += sizeof(struct sid);
669 }
670 if (!(src->Control & SE_SACL_PRESENT)) dst->sacl = NULL;
671 else
672 {
673 dst->sacl = (struct acl *)((char *)dst + offset);
674 if ((status = acl_to_samba( src->Sacl, dst->sacl ))) return status;
675 offset += dst->sacl->size;
676 }
677 if (!(src->Control & SE_DACL_PRESENT)) dst->dacl = NULL;
678 else
679 {
680 dst->dacl = (struct acl *)((char *)dst + offset);
681 if ((status = acl_to_samba( src->Dacl, dst->dacl ))) return status;
682 }
683 }
684 return NERR_Success;
685 }
686
687 static unsigned int sd_to_samba_size( const SECURITY_DESCRIPTOR *sd )
688 {
689 unsigned int ret = sizeof(struct security_descriptor);
690
691 if (sd->Owner) ret += sizeof(struct sid);
692 if (sd->Group) ret += sizeof(struct sid);
693 if (sd->Control & SE_SACL_PRESENT)
694 ret += sizeof(struct acl) + sd->Sacl->AceCount * sizeof(struct ace);
695 if (sd->Control & SE_DACL_PRESENT)
696 ret += sizeof(struct acl) + sd->Dacl->AceCount * sizeof(struct ace);
697 return ret;
698 }
699
700 static NET_API_STATUS share_info_502_to_samba( const BYTE *buf, unsigned char **bufptr )
701 {
702 NET_API_STATUS status;
703 struct share_info_502 *ret;
704 SHARE_INFO_502 *info = (SHARE_INFO_502 *)buf;
705 DWORD len = 0, size = 0;
706 char *ptr;
707
708 *bufptr = NULL;
709 if (info->shi502_netname)
710 len += WideCharToMultiByte( CP_UNIXCP, 0, info->shi502_netname, -1, NULL, 0, NULL, NULL );
711 if (info->shi502_remark)
712 len += WideCharToMultiByte( CP_UNIXCP, 0, info->shi502_remark, -1, NULL, 0, NULL, NULL );
713 if (info->shi502_path)
714 len += WideCharToMultiByte( CP_UNIXCP, 0, info->shi502_path, -1, NULL, 0, NULL, NULL );
715 if (info->shi502_passwd)
716 len += WideCharToMultiByte( CP_UNIXCP, 0, info->shi502_passwd, -1, NULL, 0, NULL, NULL );
717 if (info->shi502_security_descriptor)
718 size = sd_to_samba_size( info->shi502_security_descriptor );
719 if (!(ret = HeapAlloc( GetProcessHeap(), 0, sizeof(*ret) + (len * sizeof(WCHAR)) + size )))
720 return ERROR_OUTOFMEMORY;
721
722 ptr = (char *)(ret + 1);
723 if (!info->shi502_netname) ret->shi502_netname = NULL;
724 else
725 {
726 ret->shi502_netname = ptr;
727 ptr += WideCharToMultiByte( CP_UNIXCP, 0, info->shi502_netname, -1, ptr, len, NULL, NULL );
728 }
729 ret->shi502_type = info->shi502_type;
730 if (!info->shi502_remark) ret->shi502_remark = NULL;
731 else
732 {
733 ret->shi502_remark = ptr;
734 ptr += WideCharToMultiByte( CP_UNIXCP, 0, info->shi502_remark, -1, ptr, len, NULL, NULL );
735 }
736 ret->shi502_permissions = info->shi502_permissions;
737 ret->shi502_max_uses = info->shi502_max_uses;
738 ret->shi502_current_uses = info->shi502_current_uses;
739 if (!info->shi502_path) ret->shi502_path = NULL;
740 else
741 {
742 ret->shi502_path = ptr;
743 ptr += WideCharToMultiByte( CP_UNIXCP, 0, info->shi502_path, -1, ptr, len, NULL, NULL );
744 }
745 if (!info->shi502_passwd) ret->shi502_passwd = NULL;
746 else
747 {
748 ret->shi502_passwd = ptr;
749 ptr += WideCharToMultiByte( CP_UNIXCP, 0, info->shi502_passwd, -1, ptr, len, NULL, NULL );
750 }
751 ret->shi502_reserved = info->shi502_reserved;
752 if (!info->shi502_security_descriptor) ret->shi502_security_descriptor = NULL;
753 else
754 {
755 status = sd_to_samba( info->shi502_security_descriptor, (struct security_descriptor *)ptr );
756 if (status)
757 {
758 HeapFree( GetProcessHeap(), 0, ret );
759 return status;
760 }
761 ret->shi502_security_descriptor = (struct security_descriptor *)ptr;
762 }
763 *bufptr = (unsigned char *)ret;
764 return NERR_Success;
765 }
766
767 static NET_API_STATUS share_info_to_samba( DWORD level, const BYTE *buf, unsigned char **bufptr )
768 {
769 switch (level)
770 {
771 case 2: return share_info_2_to_samba( buf, bufptr );
772 case 502: return share_info_502_to_samba( buf, bufptr );
773 default:
774 FIXME( "level %u not supported\n", level );
775 return ERROR_NOT_SUPPORTED;
776 }
777 }
778
779 static NET_API_STATUS share_add( LMSTR servername, DWORD level, LPBYTE buf, LPDWORD parm_err )
780 {
781 char *server = NULL;
782 unsigned char *info;
783 NET_API_STATUS status;
784
785 if (servername && !(server = strdup_unixcp( servername ))) return ERROR_OUTOFMEMORY;
786 status = share_info_to_samba( level, buf, &info );
787 if (!status)
788 {
789 unsigned int err;
790
791 status = pNetShareAdd( server, level, info, &err );
792 HeapFree( GetProcessHeap(), 0, info );
793 if (parm_err) *parm_err = err;
794 }
795 HeapFree( GetProcessHeap(), 0, server );
796 return status;
797 }
798
799 static NET_API_STATUS share_del( LMSTR servername, LMSTR netname, DWORD reserved )
800 {
801 char *server = NULL, *share;
802 NET_API_STATUS status;
803
804 if (servername && !(server = strdup_unixcp( servername ))) return ERROR_OUTOFMEMORY;
805 if (!(share = strdup_unixcp( netname )))
806 {
807 HeapFree( GetProcessHeap(), 0, server );
808 return ERROR_OUTOFMEMORY;
809 }
810 status = pNetShareDel( server, share, reserved );
811 HeapFree( GetProcessHeap(), 0, server );
812 HeapFree( GetProcessHeap(), 0, share );
813 return status;
814 }
815
816 struct wksta_info_100
817 {
818 unsigned int wki100_platform_id;
819 const char *wki100_computername;
820 const char *wki100_langroup;
821 unsigned int wki100_ver_major;
822 unsigned int wki100_ver_minor;
823 };
824
825 static NET_API_STATUS wksta_info_100_from_samba( const unsigned char *buf, BYTE **bufptr )
826 {
827 WKSTA_INFO_100 *ret;
828 struct wksta_info_100 *info = (struct wksta_info_100 *)buf;
829 DWORD len = 0;
830 WCHAR *ptr;
831
832 if (info->wki100_computername)
833 len += MultiByteToWideChar( CP_UNIXCP, 0, info->wki100_computername, -1, NULL, 0 );
834 if (info->wki100_langroup)
835 len += MultiByteToWideChar( CP_UNIXCP, 0, info->wki100_langroup, -1, NULL, 0 );
836 if (!(ret = HeapAlloc( GetProcessHeap(), 0, sizeof(*ret) + (len * sizeof(WCHAR) ))))
837 return ERROR_OUTOFMEMORY;
838
839 ptr = (WCHAR *)(ret + 1);
840 ret->wki100_platform_id = info->wki100_platform_id;
841 if (!info->wki100_computername) ret->wki100_computername = NULL;
842 else
843 {
844 ret->wki100_computername = ptr;
845 ptr += MultiByteToWideChar( CP_UNIXCP, 0, info->wki100_computername, -1, ptr, len );
846 }
847 if (!info->wki100_langroup) ret->wki100_langroup = NULL;
848 else
849 {
850 ret->wki100_langroup = ptr;
851 MultiByteToWideChar( CP_UNIXCP, 0, info->wki100_langroup, -1, ptr, len );
852 }
853 ret->wki100_ver_major = info->wki100_ver_major;
854 ret->wki100_ver_minor = info->wki100_ver_minor;
855 *bufptr = (BYTE *)ret;
856 return NERR_Success;
857 }
858
859 static NET_API_STATUS wksta_info_from_samba( DWORD level, const unsigned char *buf, BYTE **bufptr )
860 {
861 switch (level)
862 {
863 case 100: return wksta_info_100_from_samba( buf, bufptr );
864 default:
865 FIXME( "level %u not supported\n", level );
866 return ERROR_NOT_SUPPORTED;
867 }
868 }
869
870 static NET_API_STATUS wksta_getinfo( LMSTR servername, DWORD level, LPBYTE *bufptr )
871 {
872 NET_API_STATUS status;
873 char *wksta = NULL;
874 unsigned char *buf = NULL;
875
876 if (servername && !(wksta = strdup_unixcp( servername ))) return ERROR_OUTOFMEMORY;
877 status = pNetWkstaGetInfo( wksta, level, &buf );
878 HeapFree( GetProcessHeap(), 0, wksta );
879 if (!status)
880 {
881 status = wksta_info_from_samba( level, buf, bufptr );
882 pNetApiBufferFree( buf );
883 }
884 return status;
885 }
886
887 #else
888
889 static BOOL libnetapi_init(void)
890 {
891 return FALSE;
892 }
893
894 static NET_API_STATUS server_getinfo( LMSTR servername, DWORD level, LPBYTE *bufptr )
895 {
896 ERR( "\n" );
897 return ERROR_NOT_SUPPORTED;
898 }
899 static NET_API_STATUS share_add( LMSTR servername, DWORD level, LPBYTE buf, LPDWORD parm_err )
900 {
901 ERR( "\n" );
902 return ERROR_NOT_SUPPORTED;
903 }
904 static NET_API_STATUS share_del( LMSTR servername, LMSTR netname, DWORD reserved )
905 {
906 ERR( "\n" );
907 return ERROR_NOT_SUPPORTED;
908 }
909 static NET_API_STATUS wksta_getinfo( LMSTR servername, DWORD level, LPBYTE *bufptr )
910 {
911 ERR( "\n" );
912 return ERROR_NOT_SUPPORTED;
913 }
914
915 #endif /* SONAME_LIBNETAPI */
916
917 /************************************************************
918 * NETAPI_IsLocalComputer
919 *
920 * Checks whether the server name indicates local machine.
921 */
922 static BOOL NETAPI_IsLocalComputer( LMCSTR name )
923 {
924 WCHAR buf[MAX_COMPUTERNAME_LENGTH + 1];
925 DWORD size = sizeof(buf) / sizeof(buf[0]);
926 BOOL ret;
927
928 if (!name || !name[0]) return TRUE;
929
930 ret = GetComputerNameW( buf, &size );
931 if (ret && name[0] == '\\' && name[1] == '\\') name += 2;
932 return ret && !strcmpiW( name, buf );
933 }
934
935 BOOL WINAPI DllMain (HINSTANCE hinstDLL, DWORD fdwReason, LPVOID lpvReserved)
936 {
937 TRACE("%p,%x,%p\n", hinstDLL, fdwReason, lpvReserved);
938
939 switch (fdwReason) {
940 case DLL_PROCESS_ATTACH:
941 DisableThreadLibraryCalls(hinstDLL);
942 NetBIOSInit();
943 NetBTInit();
944 break;
945 case DLL_PROCESS_DETACH:
946 if (lpvReserved) break;
947 NetBIOSShutdown();
948 break;
949 }
950
951 return TRUE;
952 }
953
954 /************************************************************
955 * NetServerEnum (NETAPI32.@)
956 */
957 NET_API_STATUS WINAPI NetServerEnum(
958 LMCSTR servername,
959 DWORD level,
960 LPBYTE* bufptr,
961 DWORD prefmaxlen,
962 LPDWORD entriesread,
963 LPDWORD totalentries,
964 DWORD servertype,
965 LMCSTR domain,
966 LPDWORD resume_handle
967 )
968 {
969 FIXME("Stub (%s %d %p %d %p %p %d %s %p)\n", debugstr_w(servername),
970 level, bufptr, prefmaxlen, entriesread, totalentries, servertype,
971 debugstr_w(domain), resume_handle);
972
973 return ERROR_NO_BROWSER_SERVERS_FOUND;
974 }
975
976 /************************************************************
977 * NetServerEnumEx (NETAPI32.@)
978 */
979 NET_API_STATUS WINAPI NetServerEnumEx(
980 LMCSTR ServerName,
981 DWORD Level,
982 LPBYTE *Bufptr,
983 DWORD PrefMaxlen,
984 LPDWORD EntriesRead,
985 LPDWORD totalentries,
986 DWORD servertype,
987 LMCSTR domain,
988 LMCSTR FirstNameToReturn)
989 {
990 FIXME("Stub (%s %d %p %d %p %p %d %s %s)\n",
991 debugstr_w(ServerName), Level, Bufptr, PrefMaxlen, EntriesRead, totalentries,
992 servertype, debugstr_w(domain), debugstr_w(FirstNameToReturn));
993
994 return ERROR_NO_BROWSER_SERVERS_FOUND;
995 }
996
997 /************************************************************
998 * NetServerDiskEnum (NETAPI32.@)
999 */
1000 NET_API_STATUS WINAPI NetServerDiskEnum(
1001 LMCSTR ServerName,
1002 DWORD Level,
1003 LPBYTE *Bufptr,
1004 DWORD PrefMaxlen,
1005 LPDWORD EntriesRead,
1006 LPDWORD totalentries,
1007 LPDWORD Resume_Handle)
1008 {
1009 FIXME("Stub (%s %d %p %d %p %p %p)\n", debugstr_w(ServerName),
1010 Level, Bufptr, PrefMaxlen, EntriesRead, totalentries, Resume_Handle);
1011
1012 return ERROR_NO_BROWSER_SERVERS_FOUND;
1013 }
1014
1015 /************************************************************
1016 * NetServerGetInfo (NETAPI32.@)
1017 */
1018 NET_API_STATUS WINAPI NetServerGetInfo(LMSTR servername, DWORD level, LPBYTE* bufptr)
1019 {
1020 NET_API_STATUS ret;
1021 BOOL local = NETAPI_IsLocalComputer( servername );
1022
1023 TRACE("%s %d %p\n", debugstr_w( servername ), level, bufptr );
1024
1025 if (!local)
1026 {
1027 if (libnetapi_init()) return server_getinfo( servername, level, bufptr );
1028 FIXME( "remote computers not supported\n" );
1029 return ERROR_INVALID_LEVEL;
1030 }
1031 if (!bufptr) return ERROR_INVALID_PARAMETER;
1032
1033 switch (level)
1034 {
1035 case 100:
1036 case 101:
1037 {
1038 DWORD computerNameLen, size;
1039 WCHAR computerName[MAX_COMPUTERNAME_LENGTH + 1];
1040
1041 computerNameLen = MAX_COMPUTERNAME_LENGTH + 1;
1042 GetComputerNameW(computerName, &computerNameLen);
1043 computerNameLen++; /* include NULL terminator */
1044
1045 /* Plus 1 for empty comment */
1046 size = sizeof(SERVER_INFO_101) + (computerNameLen + 1) * sizeof(WCHAR);
1047 ret = NetApiBufferAllocate(size, (LPVOID *)bufptr);
1048 if (ret == NERR_Success)
1049 {
1050 /* INFO_100 structure is a subset of INFO_101 */
1051 PSERVER_INFO_101 info = (PSERVER_INFO_101)*bufptr;
1052 OSVERSIONINFOW verInfo;
1053
1054 info->sv101_platform_id = PLATFORM_ID_NT;
1055 info->sv101_name = (LMSTR)(*bufptr + sizeof(SERVER_INFO_101));
1056 memcpy(info->sv101_name, computerName,
1057 computerNameLen * sizeof(WCHAR));
1058 verInfo.dwOSVersionInfoSize = sizeof(verInfo);
1059 GetVersionExW(&verInfo);
1060 info->sv101_version_major = verInfo.dwMajorVersion;
1061 info->sv101_version_minor = verInfo.dwMinorVersion;
1062 /* Use generic type as no wine equivalent of DC / Server */
1063 info->sv101_type = SV_TYPE_NT;
1064 info->sv101_comment = (LMSTR)(*bufptr + sizeof(SERVER_INFO_101)
1065 + computerNameLen * sizeof(WCHAR));
1066 info->sv101_comment[0] = '\0';
1067 }
1068 break;
1069 }
1070
1071 default:
1072 FIXME("level %d unimplemented\n", level);
1073 ret = ERROR_INVALID_LEVEL;
1074 }
1075 return ret;
1076 }
1077
1078
1079 /************************************************************
1080 * NetStatisticsGet (NETAPI32.@)
1081 */
1082 NET_API_STATUS WINAPI NetStatisticsGet(LMSTR server, LMSTR service,
1083 DWORD level, DWORD options,
1084 LPBYTE *bufptr)
1085 {
1086 int res;
1087 static const WCHAR SERVICE_WORKSTATION[] = {
1088 'L', 'a', 'n', 'm', 'a', 'n',
1089 'W', 'o', 'r', 'k', 's', 't', 'a', 't', 'i', 'o', 'n', '\0'};
1090 static const WCHAR SERVICE_SERVER[] = {
1091 'L', 'a', 'n', 'm', 'a', 'n',
1092 'S', 'e', 'r', 'v', 'e', 'r', '\0'};
1093 union
1094 {
1095 STAT_WORKSTATION_0 workst;
1096 STAT_SERVER_0 server;
1097 } *stat;
1098 void *dataptr;
1099
1100 TRACE("(server %s, service %s, level %d, options %d, buffer %p): stub\n",
1101 debugstr_w(server), debugstr_w(service), level, options, bufptr);
1102
1103 res = NetApiBufferAllocate(sizeof(*stat), &dataptr);
1104 if (res != NERR_Success) return res;
1105
1106 res = NERR_InternalError;
1107 stat = dataptr;
1108 switch (level)
1109 {
1110 case 0:
1111 if (!lstrcmpW(service, SERVICE_WORKSTATION))
1112 {
1113 /* Fill the struct STAT_WORKSTATION_0 properly */
1114 memset(&stat->workst, 0, sizeof(stat->workst));
1115 res = NERR_Success;
1116 }
1117 else if (!lstrcmpW(service, SERVICE_SERVER))
1118 {
1119 /* Fill the struct STAT_SERVER_0 properly */
1120 memset(&stat->server, 0, sizeof(stat->server));
1121 res = NERR_Success;
1122 }
1123 break;
1124 }
1125 if (res != NERR_Success)
1126 NetApiBufferFree(dataptr);
1127 else
1128 *bufptr = dataptr;
1129
1130 return res;
1131 }
1132
1133 NET_API_STATUS WINAPI NetUseEnum(LMSTR server, DWORD level, LPBYTE* bufptr, DWORD prefmaxsize,
1134 LPDWORD entriesread, LPDWORD totalentries, LPDWORD resumehandle)
1135 {
1136 FIXME("stub (%p, %d, %p, %d, %p, %p, %p)\n", server, level, bufptr, prefmaxsize,
1137 entriesread, totalentries, resumehandle);
1138 return ERROR_NOT_SUPPORTED;
1139 }
1140
1141 NET_API_STATUS WINAPI NetScheduleJobAdd(LPCWSTR server, LPBYTE bufptr, LPDWORD jobid)
1142 {
1143 FIXME("stub (%s, %p, %p)\n", debugstr_w(server), bufptr, jobid);
1144 return NERR_Success;
1145 }
1146
1147 NET_API_STATUS WINAPI NetScheduleJobDel(LPCWSTR server, DWORD minjobid, DWORD maxjobid)
1148 {
1149 FIXME("stub (%s, %d, %d)\n", debugstr_w(server), minjobid, maxjobid);
1150 return NERR_Success;
1151 }
1152
1153 NET_API_STATUS WINAPI NetScheduleJobEnum(LPCWSTR server, LPBYTE* bufptr, DWORD prefmaxsize, LPDWORD entriesread,
1154 LPDWORD totalentries, LPDWORD resumehandle)
1155 {
1156 FIXME("stub (%s, %p, %d, %p, %p, %p)\n", debugstr_w(server), bufptr, prefmaxsize, entriesread, totalentries, resumehandle);
1157 *entriesread = 0;
1158 *totalentries = 0;
1159 return NERR_Success;
1160 }
1161
1162 NET_API_STATUS WINAPI NetUseGetInfo(LMSTR server, LMSTR name, DWORD level, LPBYTE *bufptr)
1163 {
1164 FIXME("stub (%p, %p, %d, %p)\n", server, name, level, bufptr);
1165 return ERROR_NOT_SUPPORTED;
1166
1167 }
1168
1169 /************************************************************
1170 * NetApiBufferAllocate (NETAPI32.@)
1171 */
1172 NET_API_STATUS WINAPI NetApiBufferAllocate(DWORD ByteCount, LPVOID* Buffer)
1173 {
1174 TRACE("(%d, %p)\n", ByteCount, Buffer);
1175
1176 if (Buffer == NULL) return ERROR_INVALID_PARAMETER;
1177 *Buffer = HeapAlloc(GetProcessHeap(), 0, ByteCount);
1178 if (*Buffer)
1179 return NERR_Success;
1180 else
1181 return GetLastError();
1182 }
1183
1184 /************************************************************
1185 * NetApiBufferFree (NETAPI32.@)
1186 */
1187 NET_API_STATUS WINAPI NetApiBufferFree(LPVOID Buffer)
1188 {
1189 TRACE("(%p)\n", Buffer);
1190 HeapFree(GetProcessHeap(), 0, Buffer);
1191 return NERR_Success;
1192 }
1193
1194 /************************************************************
1195 * NetApiBufferReallocate (NETAPI32.@)
1196 */
1197 NET_API_STATUS WINAPI NetApiBufferReallocate(LPVOID OldBuffer, DWORD NewByteCount,
1198 LPVOID* NewBuffer)
1199 {
1200 TRACE("(%p, %d, %p)\n", OldBuffer, NewByteCount, NewBuffer);
1201 if (NewByteCount)
1202 {
1203 if (OldBuffer)
1204 *NewBuffer = HeapReAlloc(GetProcessHeap(), 0, OldBuffer, NewByteCount);
1205 else
1206 *NewBuffer = HeapAlloc(GetProcessHeap(), 0, NewByteCount);
1207 return *NewBuffer ? NERR_Success : GetLastError();
1208 }
1209 else
1210 {
1211 if (!HeapFree(GetProcessHeap(), 0, OldBuffer)) return GetLastError();
1212 *NewBuffer = 0;
1213 return NERR_Success;
1214 }
1215 }
1216
1217 /************************************************************
1218 * NetApiBufferSize (NETAPI32.@)
1219 */
1220 NET_API_STATUS WINAPI NetApiBufferSize(LPVOID Buffer, LPDWORD ByteCount)
1221 {
1222 DWORD dw;
1223
1224 TRACE("(%p, %p)\n", Buffer, ByteCount);
1225 if (Buffer == NULL)
1226 return ERROR_INVALID_PARAMETER;
1227 dw = HeapSize(GetProcessHeap(), 0, Buffer);
1228 TRACE("size: %d\n", dw);
1229 if (dw != 0xFFFFFFFF)
1230 *ByteCount = dw;
1231 else
1232 *ByteCount = 0;
1233
1234 return NERR_Success;
1235 }
1236
1237 /************************************************************
1238 * NetSessionEnum (NETAPI32.@)
1239 *
1240 * PARAMS
1241 * servername [I] Pointer to a string with the name of the server
1242 * UncClientName [I] Pointer to a string with the name of the session
1243 * username [I] Pointer to a string with the name of the user
1244 * level [I] Data information level
1245 * bufptr [O] Buffer to the data
1246 * prefmaxlen [I] Preferred maximum length of the data
1247 * entriesread [O] Pointer to the number of entries enumerated
1248 * totalentries [O] Pointer to the possible number of entries
1249 * resume_handle [I/O] Pointer to a handle for subsequent searches
1250 *
1251 * RETURNS
1252 * If successful, the function returns NERR_Success
1253 * On failure it returns:
1254 * ERROR_ACCESS_DENIED User has no access to the requested information
1255 * ERROR_INVALID_LEVEL Value of 'level' is not correct
1256 * ERROR_INVALID_PARAMETER Wrong parameter
1257 * ERROR_MORE_DATA Need a larger buffer
1258 * ERROR_NOT_ENOUGH_MEMORY Not enough memory
1259 * NERR_ClientNameNotFound A session does not exist on a given computer
1260 * NERR_InvalidComputer Invalid computer name
1261 * NERR_UserNotFound User name could not be found.
1262 */
1263 NET_API_STATUS WINAPI NetSessionEnum(LMSTR servername, LMSTR UncClientName,
1264 LMSTR username, DWORD level, LPBYTE* bufptr, DWORD prefmaxlen, LPDWORD entriesread,
1265 LPDWORD totalentries, LPDWORD resume_handle)
1266 {
1267 FIXME("Stub (%s %s %s %d %p %d %p %p %p)\n", debugstr_w(servername),
1268 debugstr_w(UncClientName), debugstr_w(username),
1269 level, bufptr, prefmaxlen, entriesread, totalentries, resume_handle);
1270
1271 return NERR_Success;
1272 }
1273
1274 /************************************************************
1275 * NetShareEnum (NETAPI32.@)
1276 *
1277 * PARAMS
1278 * servername [I] Pointer to a string with the name of the server
1279 * level [I] Data information level
1280 * bufptr [O] Buffer to the data
1281 * prefmaxlen [I] Preferred maximum length of the data
1282 * entriesread [O] Pointer to the number of entries enumerated
1283 * totalentries [O] Pointer to the possible number of entries
1284 * resume_handle [I/O] Pointer to a handle for subsequent searches
1285 *
1286 * RETURNS
1287 * If successful, the function returns NERR_Success
1288 * On failure it returns a system error code (FIXME: find out which)
1289 *
1290 */
1291 NET_API_STATUS WINAPI NetShareEnum( LMSTR servername, DWORD level, LPBYTE* bufptr,
1292 DWORD prefmaxlen, LPDWORD entriesread, LPDWORD totalentries, LPDWORD resume_handle)
1293 {
1294 FIXME("Stub (%s %d %p %d %p %p %p)\n", debugstr_w(servername), level, bufptr,
1295 prefmaxlen, entriesread, totalentries, resume_handle);
1296
1297 return ERROR_NOT_SUPPORTED;
1298 }
1299
1300 /************************************************************
1301 * NetShareDel (NETAPI32.@)
1302 */
1303 NET_API_STATUS WINAPI NetShareDel(LMSTR servername, LMSTR netname, DWORD reserved)
1304 {
1305 BOOL local = NETAPI_IsLocalComputer( servername );
1306
1307 TRACE("%s %s %d\n", debugstr_w(servername), debugstr_w(netname), reserved);
1308
1309 if (!local)
1310 {
1311 if (libnetapi_init()) return share_del( servername, netname, reserved );
1312 FIXME( "remote computers not supported\n" );
1313 }
1314
1315 FIXME("%s %s %d\n", debugstr_w(servername), debugstr_w(netname), reserved);
1316 return NERR_Success;
1317 }
1318
1319 /************************************************************
1320 * NetShareGetInfo (NETAPI32.@)
1321 */
1322 NET_API_STATUS WINAPI NetShareGetInfo(LMSTR servername, LMSTR netname,
1323 DWORD level, LPBYTE *bufptr)
1324 {
1325 FIXME("Stub (%s %s %d %p)\n", debugstr_w(servername),
1326 debugstr_w(netname),level, bufptr);
1327 return NERR_NetNameNotFound;
1328 }
1329
1330 /************************************************************
1331 * NetShareAdd (NETAPI32.@)
1332 */
1333 NET_API_STATUS WINAPI NetShareAdd(LMSTR servername,
1334 DWORD level, LPBYTE buf, LPDWORD parm_err)
1335 {
1336 BOOL local = NETAPI_IsLocalComputer( servername );
1337
1338 TRACE("%s %d %p %p\n", debugstr_w(servername), level, buf, parm_err);
1339
1340 if (!local)
1341 {
1342 if (libnetapi_init()) return share_add( servername, level, buf, parm_err );
1343 FIXME( "remote computers not supported\n" );
1344 }
1345
1346 FIXME("%s %d %p %p\n", debugstr_w(servername), level, buf, parm_err);
1347 return ERROR_NOT_SUPPORTED;
1348 }
1349
1350 /************************************************************
1351 * NetFileEnum (NETAPI32.@)
1352 */
1353 NET_API_STATUS WINAPI NetFileEnum(
1354 LPWSTR ServerName, LPWSTR BasePath, LPWSTR UserName,
1355 DWORD Level, LPBYTE* BufPtr, DWORD PrefMaxLen,
1356 LPDWORD EntriesRead, LPDWORD TotalEntries, PDWORD_PTR ResumeHandle)
1357 {
1358 FIXME("(%s, %s, %s, %u): stub\n", debugstr_w(ServerName), debugstr_w(BasePath),
1359 debugstr_w(UserName), Level);
1360 return ERROR_NOT_SUPPORTED;
1361 }
1362
1363 static void wprint_mac(WCHAR* buffer, int len, const MIB_IFROW *ifRow)
1364 {
1365 int i;
1366 unsigned char val;
1367
1368 if (!buffer)
1369 return;
1370 if (len < 1)
1371 return;
1372 if (!ifRow)
1373 {
1374 *buffer = '\0';
1375 return;
1376 }
1377
1378 for (i = 0; i < ifRow->dwPhysAddrLen && 2 * i < len; i++)
1379 {
1380 val = ifRow->bPhysAddr[i];
1381 if ((val >>4) >9)
1382 buffer[2*i] = (WCHAR)((val >>4) + 'A' - 10);
1383 else
1384 buffer[2*i] = (WCHAR)((val >>4) + '0');
1385 if ((val & 0xf ) >9)
1386 buffer[2*i+1] = (WCHAR)((val & 0xf) + 'A' - 10);
1387 else
1388 buffer[2*i+1] = (WCHAR)((val & 0xf) + '0');
1389 }
1390 buffer[2*i]=0;
1391 }
1392
1393 /* Theoretically this could be too short, except that MS defines
1394 * MAX_ADAPTER_NAME as 128, and MAX_INTERFACE_NAME_LEN as 256, and both
1395 * represent a count of WCHARs, so even with an extraordinarily long header
1396 * this will be plenty
1397 */
1398 #define MAX_TRANSPORT_NAME MAX_INTERFACE_NAME_LEN
1399 #define MAX_TRANSPORT_ADDR 13
1400
1401 #define NBT_TRANSPORT_NAME_HEADER "\\Device\\NetBT_Tcpip_"
1402 #define UNKNOWN_TRANSPORT_NAME_HEADER "\\Device\\UnknownTransport_"
1403
1404 static void wprint_name(WCHAR *buffer, int len, ULONG transport,
1405 PMIB_IFROW ifRow)
1406 {
1407 WCHAR *ptr1, *ptr2;
1408 const char *name;
1409
1410 if (!buffer)
1411 return;
1412 if (!ifRow)
1413 {
1414 *buffer = '\0';
1415 return;
1416 }
1417
1418 if (!memcmp(&transport, TRANSPORT_NBT, sizeof(ULONG)))
1419 name = NBT_TRANSPORT_NAME_HEADER;
1420 else
1421 name = UNKNOWN_TRANSPORT_NAME_HEADER;
1422
1423 for (ptr1 = buffer; *name && ptr1 < buffer + len; ptr1++, name++)
1424 *ptr1 = *name;
1425 for (ptr2 = ifRow->wszName; *ptr2 && ptr1 < buffer + len; ptr1++, ptr2++)
1426 *ptr1 = *ptr2;
1427 *ptr1 = '\0';
1428 }
1429
1430 /***********************************************************************
1431 * NetWkstaTransportEnum (NETAPI32.@)
1432 */
1433
1434 struct WkstaTransportEnumData
1435 {
1436 UCHAR n_adapt;
1437 UCHAR n_read;
1438 DWORD prefmaxlen;
1439 LPBYTE *pbuf;
1440 NET_API_STATUS ret;
1441 };
1442
1443 /**********************************************************************/
1444
1445 static BOOL WkstaEnumAdaptersCallback(UCHAR totalLANAs, UCHAR lanaIndex,
1446 ULONG transport, const NetBIOSAdapterImpl *data, void *closure)
1447 {
1448 BOOL ret;
1449 struct WkstaTransportEnumData *enumData = closure;
1450
1451 if (enumData && enumData->pbuf)
1452 {
1453 if (lanaIndex == 0)
1454 {
1455 DWORD toAllocate;
1456
1457 enumData->n_adapt = totalLANAs;
1458 enumData->n_read = 0;
1459
1460 toAllocate = totalLANAs * (sizeof(WKSTA_TRANSPORT_INFO_0)
1461 + MAX_TRANSPORT_NAME * sizeof(WCHAR) +
1462 MAX_TRANSPORT_ADDR * sizeof(WCHAR));
1463 if (enumData->prefmaxlen != MAX_PREFERRED_LENGTH)
1464 toAllocate = enumData->prefmaxlen;
1465 NetApiBufferAllocate(toAllocate, (LPVOID *)enumData->pbuf);
1466 }
1467 if (*(enumData->pbuf))
1468 {
1469 UCHAR spaceFor;
1470
1471 if (enumData->prefmaxlen == MAX_PREFERRED_LENGTH)
1472 spaceFor = totalLANAs;
1473 else
1474 spaceFor = enumData->prefmaxlen /
1475 (sizeof(WKSTA_TRANSPORT_INFO_0) + (MAX_TRANSPORT_NAME +
1476 MAX_TRANSPORT_ADDR) * sizeof(WCHAR));
1477 if (enumData->n_read < spaceFor)
1478 {
1479 PWKSTA_TRANSPORT_INFO_0 ti;
1480 LMSTR transport_name, transport_addr;
1481 MIB_IFROW ifRow;
1482
1483 ti = (PWKSTA_TRANSPORT_INFO_0)(*(enumData->pbuf) +
1484 enumData->n_read * sizeof(WKSTA_TRANSPORT_INFO_0));
1485 transport_name = (LMSTR)(*(enumData->pbuf) +
1486 totalLANAs * sizeof(WKSTA_TRANSPORT_INFO_0) +
1487 enumData->n_read * MAX_TRANSPORT_NAME * sizeof(WCHAR));
1488 transport_addr = (LMSTR)(*(enumData->pbuf) +
1489 totalLANAs * (sizeof(WKSTA_TRANSPORT_INFO_0) +
1490 MAX_TRANSPORT_NAME * sizeof(WCHAR)) +
1491 enumData->n_read * MAX_TRANSPORT_ADDR * sizeof(WCHAR));
1492
1493 ifRow.dwIndex = data->ifIndex;
1494 GetIfEntry(&ifRow);
1495 ti->wkti0_quality_of_service = 0;
1496 ti->wkti0_number_of_vcs = 0;
1497 ti->wkti0_transport_name = transport_name;
1498 wprint_name(ti->wkti0_transport_name, MAX_TRANSPORT_NAME,
1499 transport, &ifRow);
1500 ti->wkti0_transport_address = transport_addr;
1501 wprint_mac(ti->wkti0_transport_address, MAX_TRANSPORT_ADDR,
1502 &ifRow);
1503 if (!memcmp(&transport, TRANSPORT_NBT, sizeof(ULONG)))
1504 ti->wkti0_wan_ish = TRUE;
1505 else
1506 ti->wkti0_wan_ish = FALSE;
1507 TRACE("%d of %d:ti at %p\n", lanaIndex, totalLANAs, ti);
1508 TRACE("transport_name at %p %s\n",
1509 ti->wkti0_transport_name,
1510 debugstr_w(ti->wkti0_transport_name));
1511 TRACE("transport_address at %p %s\n",
1512 ti->wkti0_transport_address,
1513 debugstr_w(ti->wkti0_transport_address));
1514 enumData->n_read++;
1515 enumData->ret = NERR_Success;
1516 ret = TRUE;
1517 }
1518 else
1519 {
1520 enumData->ret = ERROR_MORE_DATA;
1521 ret = FALSE;
1522 }
1523 }
1524 else
1525 {
1526 enumData->ret = ERROR_OUTOFMEMORY;
1527 ret = FALSE;
1528 }
1529 }
1530 else
1531 ret = FALSE;
1532 return ret;
1533 }
1534
1535 /**********************************************************************/
1536
1537 NET_API_STATUS WINAPI
1538 NetWkstaTransportEnum(LMSTR ServerName, DWORD level, PBYTE* pbuf,
1539 DWORD prefmaxlen, LPDWORD read_entries,
1540 PDWORD total_entries, PDWORD hresume)
1541 {
1542 NET_API_STATUS ret;
1543
1544 TRACE(":%s, 0x%08x, %p, 0x%08x, %p, %p, %p\n", debugstr_w(ServerName),
1545 level, pbuf, prefmaxlen, read_entries, total_entries,hresume);
1546 if (!NETAPI_IsLocalComputer(ServerName))
1547 {
1548 FIXME(":not implemented for non-local computers\n");
1549 ret = ERROR_INVALID_LEVEL;
1550 }
1551 else
1552 {
1553 if (hresume && *hresume)
1554 {
1555 FIXME(":resume handle not implemented\n");
1556 return ERROR_INVALID_LEVEL;
1557 }
1558
1559 switch (level)
1560 {
1561 case 0: /* transport info */
1562 {
1563 ULONG allTransports;
1564 struct WkstaTransportEnumData enumData;
1565
1566 if (NetBIOSNumAdapters() == 0)
1567 return ERROR_NETWORK_UNREACHABLE;
1568 if (!read_entries)
1569 return STATUS_ACCESS_VIOLATION;
1570 if (!total_entries || !pbuf)
1571 return RPC_X_NULL_REF_POINTER;
1572
1573 enumData.prefmaxlen = prefmaxlen;
1574 enumData.pbuf = pbuf;
1575 memcpy(&allTransports, ALL_TRANSPORTS, sizeof(ULONG));
1576 NetBIOSEnumAdapters(allTransports, WkstaEnumAdaptersCallback,
1577 &enumData);
1578 *read_entries = enumData.n_read;
1579 *total_entries = enumData.n_adapt;
1580 if (hresume) *hresume= 0;
1581 ret = enumData.ret;
1582 break;
1583 }
1584 default:
1585 TRACE("Invalid level %d is specified\n", level);
1586 ret = ERROR_INVALID_LEVEL;
1587 }
1588 }
1589 return ret;
1590 }
1591
1592 /************************************************************
1593 * NetWkstaUserGetInfo (NETAPI32.@)
1594 */
1595 NET_API_STATUS WINAPI NetWkstaUserGetInfo(LMSTR reserved, DWORD level,
1596 PBYTE* bufptr)
1597 {
1598 NET_API_STATUS nastatus;
1599
1600 TRACE("(%s, %d, %p)\n", debugstr_w(reserved), level, bufptr);
1601 switch (level)
1602 {
1603 case 0:
1604 {
1605 PWKSTA_USER_INFO_0 ui;
1606 DWORD dwSize = UNLEN + 1;
1607
1608 /* set up buffer */
1609 nastatus = NetApiBufferAllocate(sizeof(WKSTA_USER_INFO_0) + dwSize * sizeof(WCHAR),
1610 (LPVOID *) bufptr);
1611 if (nastatus != NERR_Success)
1612 return ERROR_NOT_ENOUGH_MEMORY;
1613
1614 ui = (PWKSTA_USER_INFO_0) *bufptr;
1615 ui->wkui0_username = (LMSTR) (*bufptr + sizeof(WKSTA_USER_INFO_0));
1616
1617 /* get data */
1618 if (!GetUserNameW(ui->wkui0_username, &dwSize))
1619 {
1620 NetApiBufferFree(ui);
1621 return ERROR_NOT_ENOUGH_MEMORY;
1622 }
1623 else {
1624 nastatus = NetApiBufferReallocate(
1625 *bufptr, sizeof(WKSTA_USER_INFO_0) +
1626 (lstrlenW(ui->wkui0_username) + 1) * sizeof(WCHAR),
1627 (LPVOID *) bufptr);
1628 if (nastatus != NERR_Success)
1629 return nastatus;
1630 }
1631 break;
1632 }
1633
1634 case 1:
1635 {
1636 PWKSTA_USER_INFO_1 ui;
1637 PWKSTA_USER_INFO_0 ui0;
1638 LSA_OBJECT_ATTRIBUTES ObjectAttributes;
1639 LSA_HANDLE PolicyHandle;
1640 PPOLICY_ACCOUNT_DOMAIN_INFO DomainInfo;
1641 NTSTATUS NtStatus;
1642
1643 /* sizes of the field buffers in WCHARS */
1644 int username_sz, logon_domain_sz, oth_domains_sz, logon_server_sz;
1645
1646 FIXME("Level 1 processing is partially implemented\n");
1647 oth_domains_sz = 1;
1648 logon_server_sz = 1;
1649
1650 /* get some information first to estimate size of the buffer */
1651 ui0 = NULL;
1652 nastatus = NetWkstaUserGetInfo(NULL, 0, (PBYTE *) &ui0);
1653 if (nastatus != NERR_Success)
1654 return nastatus;
1655 username_sz = lstrlenW(ui0->wkui0_username) + 1;
1656
1657 ZeroMemory(&ObjectAttributes, sizeof(ObjectAttributes));
1658 NtStatus = LsaOpenPolicy(NULL, &ObjectAttributes,
1659 POLICY_VIEW_LOCAL_INFORMATION,
1660 &PolicyHandle);
1661 if (NtStatus != STATUS_SUCCESS)
1662 {
1663 TRACE("LsaOpenPolicyFailed with NT status %x\n",
1664 LsaNtStatusToWinError(NtStatus));
1665 NetApiBufferFree(ui0);
1666 return ERROR_NOT_ENOUGH_MEMORY;
1667 }
1668 LsaQueryInformationPolicy(PolicyHandle, PolicyAccountDomainInformation,
1669 (PVOID*) &DomainInfo);
1670 logon_domain_sz = lstrlenW(DomainInfo->DomainName.Buffer) + 1;
1671 LsaClose(PolicyHandle);
1672
1673 /* set up buffer */
1674 nastatus = NetApiBufferAllocate(sizeof(WKSTA_USER_INFO_1) +
1675 (username_sz + logon_domain_sz +
1676 oth_domains_sz + logon_server_sz) * sizeof(WCHAR),
1677 (LPVOID *) bufptr);
1678 if (nastatus != NERR_Success) {
1679 NetApiBufferFree(ui0);
1680 return nastatus;
1681 }
1682 ui = (WKSTA_USER_INFO_1 *) *bufptr;
1683 ui->wkui1_username = (LMSTR) (*bufptr + sizeof(WKSTA_USER_INFO_1));
1684 ui->wkui1_logon_domain = (LMSTR) (
1685 ((PBYTE) ui->wkui1_username) + username_sz * sizeof(WCHAR));
1686 ui->wkui1_oth_domains = (LMSTR) (
1687 ((PBYTE) ui->wkui1_logon_domain) +
1688 logon_domain_sz * sizeof(WCHAR));
1689 ui->wkui1_logon_server = (LMSTR) (
1690 ((PBYTE) ui->wkui1_oth_domains) +
1691 oth_domains_sz * sizeof(WCHAR));
1692
1693 /* get data */
1694 lstrcpyW(ui->wkui1_username, ui0->wkui0_username);
1695 NetApiBufferFree(ui0);
1696
1697 lstrcpynW(ui->wkui1_logon_domain, DomainInfo->DomainName.Buffer,
1698 logon_domain_sz);
1699 LsaFreeMemory(DomainInfo);
1700
1701 /* FIXME. Not implemented. Populated with empty strings */
1702 ui->wkui1_oth_domains[0] = 0;
1703 ui->wkui1_logon_server[0] = 0;
1704 break;
1705 }
1706 case 1101:
1707 {
1708 PWKSTA_USER_INFO_1101 ui;
1709 DWORD dwSize = 1;
1710
1711 FIXME("Stub. Level 1101 processing is not implemented\n");
1712 /* FIXME see also wkui1_oth_domains for level 1 */
1713
1714 /* set up buffer */
1715 nastatus = NetApiBufferAllocate(sizeof(WKSTA_USER_INFO_1101) + dwSize * sizeof(WCHAR),
1716 (LPVOID *) bufptr);
1717 if (nastatus != NERR_Success)
1718 return nastatus;
1719 ui = (PWKSTA_USER_INFO_1101) *bufptr;
1720 ui->wkui1101_oth_domains = (LMSTR)(ui + 1);
1721
1722 /* get data */
1723 ui->wkui1101_oth_domains[0] = 0;
1724 break;
1725 }
1726 default:
1727 TRACE("Invalid level %d is specified\n", level);
1728 return ERROR_INVALID_LEVEL;
1729 }
1730 return NERR_Success;
1731 }
1732
1733 /************************************************************
1734 * NetWkstaUserEnum (NETAPI32.@)
1735 */
1736 NET_API_STATUS WINAPI
1737 NetWkstaUserEnum(LMSTR servername, DWORD level, LPBYTE* bufptr,
1738 DWORD prefmaxlen, LPDWORD entriesread,
1739 LPDWORD totalentries, LPDWORD resumehandle)
1740 {
1741 FIXME("(%s, %d, %p, %d, %p, %p, %p): stub!\n", debugstr_w(servername),
1742 level, bufptr, prefmaxlen, entriesread, totalentries, resumehandle);
1743 return ERROR_INVALID_PARAMETER;
1744 }
1745
1746 /************************************************************
1747 * NetpGetComputerName (NETAPI32.@)
1748 */
1749 NET_API_STATUS WINAPI NetpGetComputerName(LPWSTR *Buffer)
1750 {
1751 DWORD dwSize = MAX_COMPUTERNAME_LENGTH + 1;
1752
1753 TRACE("(%p)\n", Buffer);
1754 NetApiBufferAllocate(dwSize * sizeof(WCHAR), (LPVOID *) Buffer);
1755 if (GetComputerNameW(*Buffer, &dwSize))
1756 {
1757 return NetApiBufferReallocate(
1758 *Buffer, (dwSize + 1) * sizeof(WCHAR),
1759 (LPVOID *) Buffer);
1760 }
1761 else
1762 {
1763 NetApiBufferFree(*Buffer);
1764 return ERROR_NOT_ENOUGH_MEMORY;
1765 }
1766 }
1767
1768 NET_API_STATUS WINAPI I_NetNameCompare(LPVOID p1, LPWSTR wkgrp, LPWSTR comp,
1769 LPVOID p4, LPVOID p5)
1770 {
1771 FIXME("(%p %s %s %p %p): stub\n", p1, debugstr_w(wkgrp), debugstr_w(comp),
1772 p4, p5);
1773 return ERROR_INVALID_PARAMETER;
1774 }
1775
1776 NET_API_STATUS WINAPI I_NetNameValidate(LPVOID p1, LPWSTR wkgrp, LPVOID p3,
1777 LPVOID p4)
1778 {
1779 FIXME("(%p %s %p %p): stub\n", p1, debugstr_w(wkgrp), p3, p4);
1780 return ERROR_INVALID_PARAMETER;
1781 }
1782
1783 NET_API_STATUS WINAPI NetWkstaGetInfo( LMSTR servername, DWORD level,
1784 LPBYTE* bufptr)
1785 {
1786 NET_API_STATUS ret;
1787 BOOL local = NETAPI_IsLocalComputer( servername );
1788
1789 TRACE("%s %d %p\n", debugstr_w( servername ), level, bufptr );
1790
1791 if (!local)
1792 {
1793 if (libnetapi_init()) return wksta_getinfo( servername, level, bufptr );
1794 FIXME( "remote computers not supported\n" );
1795 return ERROR_INVALID_LEVEL;
1796 }
1797 if (!bufptr) return ERROR_INVALID_PARAMETER;
1798
1799 switch (level)
1800 {
1801 case 100:
1802 case 101:
1803 case 102:
1804 {
1805 static const WCHAR lanroot[] = {'c',':','\\','l','a','n','m','a','n',0}; /* FIXME */
1806 DWORD computerNameLen, domainNameLen, size;
1807 WCHAR computerName[MAX_COMPUTERNAME_LENGTH + 1];
1808 LSA_OBJECT_ATTRIBUTES ObjectAttributes;
1809 LSA_HANDLE PolicyHandle;
1810 NTSTATUS NtStatus;
1811
1812 computerNameLen = MAX_COMPUTERNAME_LENGTH + 1;
1813 GetComputerNameW(computerName, &computerNameLen);
1814 computerNameLen++; /* include NULL terminator */
1815
1816 ZeroMemory(&ObjectAttributes, sizeof(ObjectAttributes));
1817 NtStatus = LsaOpenPolicy(NULL, &ObjectAttributes,
1818 POLICY_VIEW_LOCAL_INFORMATION, &PolicyHandle);
1819 if (NtStatus != STATUS_SUCCESS)
1820 ret = LsaNtStatusToWinError(NtStatus);
1821 else
1822 {
1823 PPOLICY_ACCOUNT_DOMAIN_INFO DomainInfo;
1824
1825 LsaQueryInformationPolicy(PolicyHandle,
1826 PolicyAccountDomainInformation, (PVOID*)&DomainInfo);
1827 domainNameLen = lstrlenW(DomainInfo->DomainName.Buffer) + 1;
1828 size = sizeof(WKSTA_INFO_102) + computerNameLen * sizeof(WCHAR)
1829 + domainNameLen * sizeof(WCHAR) + sizeof(lanroot);
1830 ret = NetApiBufferAllocate(size, (LPVOID *)bufptr);
1831 if (ret == NERR_Success)
1832 {
1833 /* INFO_100 and INFO_101 structures are subsets of INFO_102 */
1834 PWKSTA_INFO_102 info = (PWKSTA_INFO_102)*bufptr;
1835 OSVERSIONINFOW verInfo;
1836
1837 info->wki102_platform_id = PLATFORM_ID_NT;
1838 info->wki102_computername = (LMSTR)(*bufptr +
1839 sizeof(WKSTA_INFO_102));
1840 memcpy(info->wki102_computername, computerName,
1841 computerNameLen * sizeof(WCHAR));
1842 info->wki102_langroup = info->wki102_computername + computerNameLen;
1843 memcpy(info->wki102_langroup, DomainInfo->DomainName.Buffer,
1844 domainNameLen * sizeof(WCHAR));
1845 info->wki102_lanroot = info->wki102_langroup + domainNameLen;
1846 memcpy(info->wki102_lanroot, lanroot, sizeof(lanroot));
1847 memset(&verInfo, 0, sizeof(verInfo));
1848 verInfo.dwOSVersionInfoSize = sizeof(verInfo);
1849 GetVersionExW(&verInfo);
1850 info->wki102_ver_major = verInfo.dwMajorVersion;
1851 info->wki102_ver_minor = verInfo.dwMinorVersion;
1852 info->wki102_logged_on_users = 1;
1853 }
1854 LsaFreeMemory(DomainInfo);
1855 LsaClose(PolicyHandle);
1856 }
1857 break;
1858 }
1859
1860 default:
1861 FIXME("level %d unimplemented\n", level);
1862 ret = ERROR_INVALID_LEVEL;
1863 }
1864 return ret;
1865 }
1866
1867 /************************************************************
1868 * NetGetJoinInformation (NETAPI32.@)
1869 */
1870 NET_API_STATUS NET_API_FUNCTION NetGetJoinInformation(
1871 LPCWSTR Server,
1872 LPWSTR *Name,
1873 PNETSETUP_JOIN_STATUS type)
1874 {
1875 static const WCHAR workgroupW[] = {'W','o','r','k','g','r','o','u','p',0};
1876
1877 FIXME("Semi-stub %s %p %p\n", wine_dbgstr_w(Server), Name, type);
1878
1879 if (!Name || !type)
1880 return ERROR_INVALID_PARAMETER;
1881
1882 NetApiBufferAllocate(sizeof(workgroupW), (LPVOID *)Name);
1883 lstrcpyW(*Name, workgroupW);
1884 *type = NetSetupWorkgroupName;
1885
1886 return NERR_Success;
1887 }
1888
1889 /************************************************************
1890 * NetUserGetGroups (NETAPI32.@)
1891 */
1892 NET_API_STATUS NET_API_FUNCTION NetUserGetGroups(
1893 LPCWSTR servername,
1894 LPCWSTR username,
1895 DWORD level,
1896 LPBYTE *bufptr,
1897 DWORD prefixmaxlen,
1898 LPDWORD entriesread,
1899 LPDWORD totalentries)
1900 {
1901 FIXME("%s %s %d %p %d %p %p stub\n", debugstr_w(servername),
1902 debugstr_w(username), level, bufptr, prefixmaxlen, entriesread,
1903 totalentries);
1904
1905 *bufptr = NULL;
1906 *entriesread = 0;
1907 *totalentries = 0;
1908
1909 return ERROR_INVALID_LEVEL;
1910 }
1911
1912 struct sam_user
1913 {
1914 struct list entry;
1915 WCHAR user_name[LM20_UNLEN+1];
1916 WCHAR user_password[PWLEN + 1];
1917 DWORD sec_since_passwd_change;
1918 DWORD user_priv;
1919 LPWSTR home_dir;
1920 LPWSTR user_comment;
1921 DWORD user_flags;
1922 LPWSTR user_logon_script_path;
1923 };
1924
1925 static struct list user_list = LIST_INIT( user_list );
1926
1927 /************************************************************
1928 * NETAPI_ValidateServername
1929 *
1930 * Validates server name
1931 */
1932 static NET_API_STATUS NETAPI_ValidateServername(LPCWSTR ServerName)
1933 {
1934 if (ServerName)
1935 {
1936 if (ServerName[0] == 0)
1937 return ERROR_BAD_NETPATH;
1938 else if (
1939 ((ServerName[0] == '\\') &&
1940 (ServerName[1] != '\\'))
1941 ||
1942 ((ServerName[0] == '\\') &&
1943 (ServerName[1] == '\\') &&
1944 (ServerName[2] == 0))
1945 )
1946 return ERROR_INVALID_NAME;
1947 }
1948 return NERR_Success;
1949 }
1950
1951 /************************************************************
1952 * NETAPI_FindUser
1953 *
1954 * Looks for a user in the user database.
1955 * Returns a pointer to the entry in the user list when the user
1956 * is found, NULL otherwise.
1957 */
1958 static struct sam_user* NETAPI_FindUser(LPCWSTR UserName)
1959 {
1960 struct sam_user *user;
1961
1962 LIST_FOR_EACH_ENTRY(user, &user_list, struct sam_user, entry)
1963 {
1964 if(lstrcmpW(user->user_name, UserName) == 0)
1965 return user;
1966 }
1967 return NULL;
1968 }
1969
1970 static BOOL NETAPI_IsCurrentUser(LPCWSTR username)
1971 {
1972 LPWSTR curr_user = NULL;
1973 DWORD dwSize;
1974 BOOL ret = FALSE;
1975
1976 dwSize = LM20_UNLEN+1;
1977 curr_user = HeapAlloc(GetProcessHeap(), 0, dwSize * sizeof(WCHAR));
1978 if(!curr_user)
1979 {
1980 ERR("Failed to allocate memory for user name.\n");
1981 goto end;
1982 }
1983 if(!GetUserNameW(curr_user, &dwSize))
1984 {
1985 ERR("Failed to get current user's user name.\n");
1986 goto end;
1987 }
1988 if (!lstrcmpW(curr_user, username))
1989 {
1990 ret = TRUE;
1991 }
1992
1993 end:
1994 HeapFree(GetProcessHeap(), 0, curr_user);
1995 return ret;
1996 }
1997
1998 /************************************************************
1999 * NetUserAdd (NETAPI32.@)
2000 */
2001 NET_API_STATUS WINAPI NetUserAdd(LPCWSTR servername,
2002 DWORD level, LPBYTE bufptr, LPDWORD parm_err)
2003 {
2004 NET_API_STATUS status;
2005 struct sam_user * su = NULL;
2006
2007 FIXME("(%s, %d, %p, %p) stub!\n", debugstr_w(servername), level, bufptr, parm_err);
2008
2009 if((status = NETAPI_ValidateServername(servername)) != NERR_Success)
2010 return status;
2011
2012 switch(level)
2013 {
2014 /* Level 3 and 4 are identical for the purposes of NetUserAdd */
2015 case 4:
2016 case 3:
2017 FIXME("Level 3 and 4 not implemented.\n");
2018 /* Fall through */
2019 case 2:
2020 FIXME("Level 2 not implemented.\n");
2021 /* Fall through */
2022 case 1:
2023 {
2024 PUSER_INFO_1 ui = (PUSER_INFO_1) bufptr;
2025 su = HeapAlloc(GetProcessHeap(), 0, sizeof(struct sam_user));
2026 if(!su)
2027 {
2028 status = NERR_InternalError;
2029 break;
2030 }
2031
2032 if(lstrlenW(ui->usri1_name) > LM20_UNLEN)
2033 {
2034 status = NERR_BadUsername;
2035 break;
2036 }
2037
2038 /*FIXME: do other checks for a valid username */
2039 lstrcpyW(su->user_name, ui->usri1_name);
2040
2041 if(lstrlenW(ui->usri1_password) > PWLEN)
2042 {
2043 /* Always return PasswordTooShort on invalid passwords. */
2044 status = NERR_PasswordTooShort;
2045 break;
2046 }
2047 lstrcpyW(su->user_password, ui->usri1_password);
2048
2049 su->sec_since_passwd_change = ui->usri1_password_age;
2050 su->user_priv = ui->usri1_priv;
2051 su->user_flags = ui->usri1_flags;
2052
2053 /*FIXME: set the other LPWSTRs to NULL for now */
2054 su->home_dir = NULL;
2055 su->user_comment = NULL;
2056 su->user_logon_script_path = NULL;
2057
2058 list_add_head(&user_list, &su->entry);
2059 return NERR_Success;
2060 }
2061 default:
2062 TRACE("Invalid level %d specified.\n", level);
2063 status = ERROR_INVALID_LEVEL;
2064 break;
2065 }
2066
2067 HeapFree(GetProcessHeap(), 0, su);
2068
2069 return status;
2070 }
2071
2072 /************************************************************
2073 * NetUserDel (NETAPI32.@)
2074 */
2075 NET_API_STATUS WINAPI NetUserDel(LPCWSTR servername, LPCWSTR username)
2076 {
2077 NET_API_STATUS status;
2078 struct sam_user *user;
2079
2080 TRACE("(%s, %s)\n", debugstr_w(servername), debugstr_w(username));
2081
2082 if((status = NETAPI_ValidateServername(servername))!= NERR_Success)
2083 return status;
2084
2085 if ((user = NETAPI_FindUser(username)) == NULL)
2086 return NERR_UserNotFound;
2087
2088 list_remove(&user->entry);
2089
2090 HeapFree(GetProcessHeap(), 0, user->home_dir);
2091 HeapFree(GetProcessHeap(), 0, user->user_comment);
2092 HeapFree(GetProcessHeap(), 0, user->user_logon_script_path);
2093 HeapFree(GetProcessHeap(), 0, user);
2094
2095 return NERR_Success;
2096 }
2097
2098 /************************************************************
2099 * NetUserGetInfo (NETAPI32.@)
2100 */
2101 NET_API_STATUS WINAPI
2102 NetUserGetInfo(LPCWSTR servername, LPCWSTR username, DWORD level,
2103 LPBYTE* bufptr)
2104 {
2105 NET_API_STATUS status;
2106 TRACE("(%s, %s, %d, %p)\n", debugstr_w(servername), debugstr_w(username),
2107 level, bufptr);
2108 status = NETAPI_ValidateServername(servername);
2109 if (status != NERR_Success)
2110 return status;
2111
2112 if(!NETAPI_IsLocalComputer(servername))
2113 {
2114 FIXME("Only implemented for local computer, but remote server"
2115 "%s was requested.\n", debugstr_w(servername));
2116 return NERR_InvalidComputer;
2117 }
2118
2119 if(!NETAPI_FindUser(username) && !NETAPI_IsCurrentUser(username))
2120 {
2121 TRACE("User %s is unknown.\n", debugstr_w(username));
2122 return NERR_UserNotFound;
2123 }
2124
2125 switch (level)
2126 {
2127 case 0:
2128 {
2129 PUSER_INFO_0 ui;
2130 int name_sz;
2131
2132 name_sz = lstrlenW(username) + 1;
2133
2134 /* set up buffer */
2135 NetApiBufferAllocate(sizeof(USER_INFO_0) + name_sz * sizeof(WCHAR),
2136 (LPVOID *) bufptr);
2137
2138 ui = (PUSER_INFO_0) *bufptr;
2139 ui->usri0_name = (LPWSTR) (*bufptr + sizeof(USER_INFO_0));
2140
2141 /* get data */
2142 lstrcpyW(ui->usri0_name, username);
2143 break;
2144 }
2145
2146 case 10:
2147 {
2148 PUSER_INFO_10 ui;
2149 PUSER_INFO_0 ui0;
2150 /* sizes of the field buffers in WCHARS */
2151 int name_sz, comment_sz, usr_comment_sz, full_name_sz;
2152
2153 comment_sz = 1;
2154 usr_comment_sz = 1;
2155 full_name_sz = 1;
2156
2157 /* get data */
2158 status = NetUserGetInfo(servername, username, 0, (LPBYTE *) &ui0);
2159 if (status != NERR_Success)
2160 {
2161 NetApiBufferFree(ui0);
2162 return status;
2163 }
2164 name_sz = lstrlenW(ui0->usri0_name) + 1;
2165
2166 /* set up buffer */
2167 NetApiBufferAllocate(sizeof(USER_INFO_10) +
2168 (name_sz + comment_sz + usr_comment_sz +
2169 full_name_sz) * sizeof(WCHAR),
2170 (LPVOID *) bufptr);
2171 ui = (PUSER_INFO_10) *bufptr;
2172 ui->usri10_name = (LPWSTR) (*bufptr + sizeof(USER_INFO_10));
2173 ui->usri10_comment = (LPWSTR) (
2174 ((PBYTE) ui->usri10_name) + name_sz * sizeof(WCHAR));
2175 ui->usri10_usr_comment = (LPWSTR) (
2176 ((PBYTE) ui->usri10_comment) + comment_sz * sizeof(WCHAR));
2177 ui->usri10_full_name = (LPWSTR) (
2178 ((PBYTE) ui->usri10_usr_comment) + usr_comment_sz * sizeof(WCHAR));
2179
2180 /* set data */
2181 lstrcpyW(ui->usri10_name, ui0->usri0_name);
2182 NetApiBufferFree(ui0);
2183 ui->usri10_comment[0] = 0;
2184 ui->usri10_usr_comment[0] = 0;
2185 ui->usri10_full_name[0] = 0;
2186 break;
2187 }
2188
2189 case 1:
2190 {
2191 static const WCHAR homedirW[] = {'H','O','M','E',0};
2192 PUSER_INFO_1 ui;
2193 PUSER_INFO_0 ui0;
2194 /* sizes of the field buffers in WCHARS */
2195 int name_sz, password_sz, home_dir_sz, comment_sz, script_path_sz;
2196
2197 password_sz = 1; /* not filled out for security reasons for NetUserGetInfo*/
2198 comment_sz = 1;
2199 script_path_sz = 1;
2200
2201 /* get data */
2202 status = NetUserGetInfo(servername, username, 0, (LPBYTE *) &ui0);
2203 if (status != NERR_Success)
2204 {
2205 NetApiBufferFree(ui0);
2206 return status;
2207 }
2208 name_sz = lstrlenW(ui0->usri0_name) + 1;
2209 home_dir_sz = GetEnvironmentVariableW(homedirW, NULL,0);
2210 /* set up buffer */
2211 NetApiBufferAllocate(sizeof(USER_INFO_1) +
2212 (name_sz + password_sz + home_dir_sz +
2213 comment_sz + script_path_sz) * sizeof(WCHAR),
2214 (LPVOID *) bufptr);
2215
2216 ui = (PUSER_INFO_1) *bufptr;
2217 ui->usri1_name = (LPWSTR) (ui + 1);
2218 ui->usri1_password = ui->usri1_name + name_sz;
2219 ui->usri1_home_dir = ui->usri1_password + password_sz;
2220 ui->usri1_comment = ui->usri1_home_dir + home_dir_sz;
2221 ui->usri1_script_path = ui->usri1_comment + comment_sz;
2222 /* set data */
2223 lstrcpyW(ui->usri1_name, ui0->usri0_name);
2224 NetApiBufferFree(ui0);
2225 ui->usri1_password[0] = 0;
2226 ui->usri1_password_age = 0;
2227 ui->usri1_priv = 0;
2228 GetEnvironmentVariableW(homedirW, ui->usri1_home_dir,home_dir_sz);
2229 ui->usri1_comment[0] = 0;
2230 ui->usri1_flags = 0;
2231 ui->usri1_script_path[0] = 0;
2232 break;
2233 }
2234 case 2:
2235 case 3:
2236 case 4:
2237 case 11:
2238 case 20:
2239 case 23:
2240 case 1003:
2241 case 1005:
2242 case 1006:
2243 case 1007:
2244 case 1008:
2245 case 1009:
2246 case 1010:
2247 case 1011:
2248 case 1012:
2249 case 1013:
2250 case 1014:
2251 case 1017:
2252 case 1018:
2253 case 1020:
2254 case 1023:
2255 case 1024:
2256 case 1025:
2257 case 1051:
2258 case 1052:
2259 case 1053:
2260 {
2261 FIXME("Level %d is not implemented\n", level);
2262 return NERR_InternalError;
2263 }
2264 default:
2265 TRACE("Invalid level %d is specified\n", level);
2266 return ERROR_INVALID_LEVEL;
2267 }
2268 return NERR_Success;
2269 }
2270
2271 /************************************************************
2272 * NetUserGetLocalGroups (NETAPI32.@)
2273 */
2274 NET_API_STATUS WINAPI
2275 NetUserGetLocalGroups(LPCWSTR servername, LPCWSTR username, DWORD level,
2276 DWORD flags, LPBYTE* bufptr, DWORD prefmaxlen,
2277 LPDWORD entriesread, LPDWORD totalentries)
2278 {
2279 NET_API_STATUS status;
2280 const WCHAR admins[] = {'A','d','m','i','n','i','s','t','r','a','t','o','r','s',0};
2281 LPWSTR currentuser;
2282 LOCALGROUP_USERS_INFO_0* info;
2283 DWORD size;
2284
2285 FIXME("(%s, %s, %d, %08x, %p %d, %p, %p) stub!\n",
2286 debugstr_w(servername), debugstr_w(username), level, flags, bufptr,
2287 prefmaxlen, entriesread, totalentries);
2288
2289 status = NETAPI_ValidateServername(servername);
2290 if (status != NERR_Success)
2291 return status;
2292
2293 size = UNLEN + 1;
2294 NetApiBufferAllocate(size * sizeof(WCHAR), (LPVOID*)&currentuser);
2295 if (!GetUserNameW(currentuser, &size)) {
2296 NetApiBufferFree(currentuser);
2297 return ERROR_NOT_ENOUGH_MEMORY;
2298 }
2299
2300 if (lstrcmpiW(username, currentuser) && NETAPI_FindUser(username))
2301 {
2302 NetApiBufferFree(currentuser);
2303 return NERR_UserNotFound;
2304 }
2305
2306 NetApiBufferFree(currentuser);
2307 *totalentries = 1;
2308 size = sizeof(*info) + sizeof(admins);
2309
2310 if(prefmaxlen < size)
2311 status = ERROR_MORE_DATA;
2312 else
2313 status = NetApiBufferAllocate(size, (LPVOID*)&info);
2314
2315 if(status != NERR_Success)
2316 {
2317 *bufptr = NULL;
2318 *entriesread = 0;
2319 return status;
2320 }
2321
2322 info->lgrui0_name = (LPWSTR)((LPBYTE)info + sizeof(*info));
2323 lstrcpyW(info->lgrui0_name, admins);
2324
2325 *bufptr = (LPBYTE)info;
2326 *entriesread = 1;
2327
2328 return NERR_Success;
2329 }
2330
2331 /************************************************************
2332 * NetUserEnum (NETAPI32.@)
2333 */
2334 NET_API_STATUS WINAPI
2335 NetUserEnum(LPCWSTR servername, DWORD level, DWORD filter, LPBYTE* bufptr,
2336 DWORD prefmaxlen, LPDWORD entriesread, LPDWORD totalentries,
2337 LPDWORD resume_handle)
2338 {
2339 NET_API_STATUS status;
2340 WCHAR user[UNLEN + 1];
2341 DWORD size, len = sizeof(user)/sizeof(user[0]);
2342
2343 TRACE("(%s, %u, 0x%x, %p, %u, %p, %p, %p)\n", debugstr_w(servername), level,
2344 filter, bufptr, prefmaxlen, entriesread, totalentries, resume_handle);
2345
2346 status = NETAPI_ValidateServername(servername);
2347 if (status != NERR_Success)
2348 return status;
2349
2350 if (!NETAPI_IsLocalComputer(servername))
2351 {
2352 FIXME("Only implemented for local computer, but remote server"
2353 "%s was requested.\n", debugstr_w(servername));
2354 return NERR_InvalidComputer;
2355 }
2356
2357 if (!GetUserNameW(user, &len)) return GetLastError();
2358
2359 switch (level)
2360 {
2361 case 0:
2362 {
2363 USER_INFO_0 *info;
2364
2365 size = sizeof(*info) + (strlenW(user) + 1) * sizeof(WCHAR);
2366
2367 if (prefmaxlen < size)
2368 status = ERROR_MORE_DATA;
2369 else
2370 status = NetApiBufferAllocate(size, (void **)&info);
2371
2372 if (status != NERR_Success)
2373 return status;
2374
2375 info->usri0_name = (WCHAR *)((char *)info + sizeof(*info));
2376 strcpyW(info->usri0_name, user);
2377
2378 *bufptr = (BYTE *)info;
2379 *entriesread = *totalentries = 1;
2380 break;
2381 }
2382 case 20:
2383 {
2384 USER_INFO_20 *info;
2385 SID *sid;
2386 UCHAR *count;
2387 DWORD *rid;
2388 SID_NAME_USE use;
2389
2390 size = sizeof(*info) + (strlenW(user) + 1) * sizeof(WCHAR);
2391
2392 if (prefmaxlen < size)
2393 status = ERROR_MORE_DATA;
2394 else
2395 status = NetApiBufferAllocate(size, (void **)&info);
2396
2397 if (status != NERR_Success)
2398 return status;
2399
2400 size = len = 0;
2401 LookupAccountNameW(NULL, user, NULL, &size, NULL, &len, &use);
2402 if (GetLastError() != ERROR_INSUFFICIENT_BUFFER)
2403 return GetLastError();
2404
2405 status = NetApiBufferAllocate(size, (void **)&sid);
2406 if (status != NERR_Success)
2407 return status;
2408
2409 if (!LookupAccountNameW(NULL, user, sid, &size, NULL, &len, &use))
2410 return GetLastError();
2411
2412 count = GetSidSubAuthorityCount(sid);
2413 rid = GetSidSubAuthority(sid, *count - 1);
2414
2415 info->usri20_name = (WCHAR *)((char *)info + sizeof(*info));
2416 strcpyW(info->usri20_name, user);
2417 info->usri20_full_name = NULL;
2418 info->usri20_comment = NULL;
2419 info->usri20_flags = UF_NORMAL_ACCOUNT;
2420 info->usri20_user_id = *rid;
2421
2422 *bufptr = (BYTE *)info;
2423 *entriesread = *totalentries = 1;
2424
2425 NetApiBufferFree(sid);
2426 break;
2427 }
2428 default:
2429 FIXME("level %u not supported\n", level);
2430 return ERROR_INVALID_LEVEL;
2431 }
2432 return NERR_Success;
2433 }
2434
2435 /************************************************************
2436 * ACCESS_QueryAdminDisplayInformation
2437 *
2438 * Creates a buffer with information for the Admin User
2439 */
2440 static void ACCESS_QueryAdminDisplayInformation(PNET_DISPLAY_USER *buf, PDWORD pdwSize)
2441 {
2442 static const WCHAR sAdminUserName[] = {
2443 'A','d','m','i','n','i','s','t','r','a','t','o','r',0};
2444
2445 /* sizes of the field buffers in WCHARS */
2446 int name_sz, comment_sz, full_name_sz;
2447 PNET_DISPLAY_USER usr;
2448
2449 /* set up buffer */
2450 name_sz = lstrlenW(sAdminUserName) + 1;
2451 comment_sz = 1;
2452 full_name_sz = 1;
2453
2454 *pdwSize = sizeof(NET_DISPLAY_USER);
2455 *pdwSize += (name_sz + comment_sz + full_name_sz) * sizeof(WCHAR);
2456 NetApiBufferAllocate(*pdwSize, (LPVOID *) buf);
2457
2458 usr = *buf;
2459 usr->usri1_name = (LPWSTR) ((PBYTE) usr + sizeof(NET_DISPLAY_USER));
2460 usr->usri1_comment = (LPWSTR) (
2461 ((PBYTE) usr->usri1_name) + name_sz * sizeof(WCHAR));
2462 usr->usri1_full_name = (LPWSTR) (
2463 ((PBYTE) usr->usri1_comment) + comment_sz * sizeof(WCHAR));
2464
2465 /* set data */
2466 lstrcpyW(usr->usri1_name, sAdminUserName);
2467 usr->usri1_comment[0] = 0;
2468 usr->usri1_flags = UF_SCRIPT | UF_NORMAL_ACCOUNT | UF_DONT_EXPIRE_PASSWD;
2469 usr->usri1_full_name[0] = 0;
2470 usr->usri1_user_id = DOMAIN_USER_RID_ADMIN;
2471 usr->usri1_next_index = 0;
2472 }
2473
2474 /************************************************************
2475 * ACCESS_QueryGuestDisplayInformation
2476 *
2477 * Creates a buffer with information for the Guest User
2478 */
2479 static void ACCESS_QueryGuestDisplayInformation(PNET_DISPLAY_USER *buf, PDWORD pdwSize)
2480 {
2481 static const WCHAR sGuestUserName[] = {
2482 'G','u','e','s','t',0 };
2483
2484 /* sizes of the field buffers in WCHARS */
2485 int name_sz, comment_sz, full_name_sz;
2486 PNET_DISPLAY_USER usr;
2487
2488 /* set up buffer */
2489 name_sz = lstrlenW(sGuestUserName) + 1;
2490 comment_sz = 1;
2491 full_name_sz = 1;
2492
2493 *pdwSize = sizeof(NET_DISPLAY_USER);
2494 *pdwSize += (name_sz + comment_sz + full_name_sz) * sizeof(WCHAR);
2495 NetApiBufferAllocate(*pdwSize, (LPVOID *) buf);
2496
2497 usr = *buf;
2498 usr->usri1_name = (LPWSTR) ((PBYTE) usr + sizeof(NET_DISPLAY_USER));
2499 usr->usri1_comment = (LPWSTR) (
2500 ((PBYTE) usr->usri1_name) + name_sz * sizeof(WCHAR));
2501 usr->usri1_full_name = (LPWSTR) (
2502 ((PBYTE) usr->usri1_comment) + comment_sz * sizeof(WCHAR));
2503
2504 /* set data */
2505 lstrcpyW(usr->usri1_name, sGuestUserName);
2506 usr->usri1_comment[0] = 0;
2507 usr->usri1_flags = UF_ACCOUNTDISABLE | UF_SCRIPT | UF_NORMAL_ACCOUNT |
2508 UF_DONT_EXPIRE_PASSWD;
2509 usr->usri1_full_name[0] = 0;
2510 usr->usri1_user_id = DOMAIN_USER_RID_GUEST;
2511 usr->usri1_next_index = 0;
2512 }
2513
2514 /************************************************************
2515 * Copies NET_DISPLAY_USER record.
2516 */
2517 static void ACCESS_CopyDisplayUser(const NET_DISPLAY_USER *dest, LPWSTR *dest_buf,
2518 PNET_DISPLAY_USER src)
2519 {
2520 LPWSTR str = *dest_buf;
2521
2522 src->usri1_name = str;
2523 lstrcpyW(src->usri1_name, dest->usri1_name);
2524 str = (LPWSTR) (
2525 ((PBYTE) str) + (lstrlenW(str) + 1) * sizeof(WCHAR));
2526
2527 src->usri1_comment = str;
2528 lstrcpyW(src->usri1_comment, dest->usri1_comment);
2529 str = (LPWSTR) (
2530 ((PBYTE) str) + (lstrlenW(str) + 1) * sizeof(WCHAR));
2531
2532 src->usri1_flags = dest->usri1_flags;
2533
2534 src->usri1_full_name = str;
2535 lstrcpyW(src->usri1_full_name, dest->usri1_full_name);
2536 str = (LPWSTR) (
2537 ((PBYTE) str) + (lstrlenW(str) + 1) * sizeof(WCHAR));
2538
2539 src->usri1_user_id = dest->usri1_user_id;
2540 src->usri1_next_index = dest->usri1_next_index;
2541 *dest_buf = str;
2542 }
2543
2544 /************************************************************
2545 * NetQueryDisplayInformation (NETAPI32.@)
2546 *
2547 * The buffer structure:
2548 * - array of fixed size record of the level type
2549 * - strings, referenced by the record of the level type
2550 */
2551 NET_API_STATUS WINAPI
2552 NetQueryDisplayInformation(
2553 LPCWSTR ServerName, DWORD Level, DWORD Index, DWORD EntriesRequested,
2554 DWORD PreferredMaximumLength, LPDWORD ReturnedEntryCount,
2555 PVOID *SortedBuffer)
2556 {
2557 TRACE("(%s, %d, %d, %d, %d, %p, %p)\n", debugstr_w(ServerName),
2558 Level, Index, EntriesRequested, PreferredMaximumLength,
2559 ReturnedEntryCount, SortedBuffer);
2560
2561 if(!NETAPI_IsLocalComputer(ServerName))
2562 {
2563 FIXME("Only implemented on local computer, but requested for "
2564 "remote server %s\n", debugstr_w(ServerName));
2565 return ERROR_ACCESS_DENIED;
2566 }
2567
2568 switch (Level)
2569 {
2570 case 1:
2571 {
2572 /* current record */
2573 PNET_DISPLAY_USER inf;
2574 /* current available strings buffer */
2575 LPWSTR str;
2576 PNET_DISPLAY_USER admin, guest;
2577 DWORD admin_size, guest_size;
2578 LPWSTR name = NULL;
2579 DWORD dwSize;
2580
2581 /* sizes of the field buffers in WCHARS */
2582 int name_sz, comment_sz, full_name_sz;
2583
2584 /* number of the records, returned in SortedBuffer
2585 3 - for current user, Administrator and Guest users
2586 */
2587 int records = 3;
2588
2589 FIXME("Level %d partially implemented\n", Level);
2590 *ReturnedEntryCount = records;
2591 comment_sz = 1;
2592 full_name_sz = 1;
2593
2594 /* get data */
2595 dwSize = UNLEN + 1;
2596 NetApiBufferAllocate(dwSize * sizeof(WCHAR), (LPVOID *) &name);
2597 if (!GetUserNameW(name, &dwSize))
2598 {
2599 NetApiBufferFree(name);
2600 return ERROR_ACCESS_DENIED;
2601 }
2602 name_sz = dwSize;
2603 ACCESS_QueryAdminDisplayInformation(&admin, &admin_size);
2604 ACCESS_QueryGuestDisplayInformation(&guest, &guest_size);
2605
2606 /* set up buffer */
2607 dwSize = sizeof(NET_DISPLAY_USER) * records;
2608 dwSize += (name_sz + comment_sz + full_name_sz) * sizeof(WCHAR);
2609
2610 NetApiBufferAllocate(dwSize +
2611 admin_size - sizeof(NET_DISPLAY_USER) +
2612 guest_size - sizeof(NET_DISPLAY_USER),
2613 SortedBuffer);
2614 inf = *SortedBuffer;
2615 str = (LPWSTR) ((PBYTE) inf + sizeof(NET_DISPLAY_USER) * records);
2616 inf->usri1_name = str;
2617 str = (LPWSTR) (
2618 ((PBYTE) str) + name_sz * sizeof(WCHAR));
2619 inf->usri1_comment = str;
2620 str = (LPWSTR) (
2621 ((PBYTE) str) + comment_sz * sizeof(WCHAR));
2622 inf->usri1_full_name = str;
2623 str = (LPWSTR) (
2624 ((PBYTE) str) + full_name_sz * sizeof(WCHAR));
2625
2626 /* set data */
2627 lstrcpyW(inf->usri1_name, name);
2628 NetApiBufferFree(name);
2629 inf->usri1_comment[0] = 0;
2630 inf->usri1_flags =
2631 UF_SCRIPT | UF_NORMAL_ACCOUNT | UF_DONT_EXPIRE_PASSWD;
2632 inf->usri1_full_name[0] = 0;
2633 inf->usri1_user_id = 0;
2634 inf->usri1_next_index = 0;
2635
2636 inf++;
2637 ACCESS_CopyDisplayUser(admin, &str, inf);
2638 NetApiBufferFree(admin);
2639
2640 inf++;
2641 ACCESS_CopyDisplayUser(guest, &str, inf);
2642 NetApiBufferFree(guest);
2643 break;
2644 }
2645
2646 case 2:
2647 case 3:
2648 {
2649 FIXME("Level %d is not implemented\n", Level);
2650 break;
2651 }
2652
2653 default:
2654 TRACE("Invalid level %d is specified\n", Level);
2655 return ERROR_INVALID_LEVEL;
2656 }
2657 return NERR_Success;
2658 }
2659
2660 /************************************************************
2661 * NetGetDCName (NETAPI32.@)
2662 *
2663 * Return the name of the primary domain controller (PDC)
2664 */
2665
2666 NET_API_STATUS WINAPI
2667 NetGetDCName(LPCWSTR servername, LPCWSTR domainname, LPBYTE *bufptr)
2668 {
2669 FIXME("(%s, %s, %p) stub!\n", debugstr_w(servername),
2670 debugstr_w(domainname), bufptr);
2671 return NERR_DCNotFound; /* say we can't find a domain controller */
2672 }
2673
2674 /************************************************************
2675 * NetGetAnyDCName (NETAPI32.@)
2676 *
2677 * Return the name of any domain controller (DC) for a
2678 * domain that is directly trusted by the specified server
2679 */
2680
2681 NET_API_STATUS WINAPI NetGetAnyDCName(LPCWSTR servername, LPCWSTR domainname, LPBYTE *bufptr)
2682 {
2683 FIXME("(%s, %s, %p) stub!\n", debugstr_w(servername),
2684 debugstr_w(domainname), bufptr);
2685 return ERROR_NO_SUCH_DOMAIN;
2686 }
2687
2688 /************************************************************
2689 * NetGroupAddUser (NETAPI32.@)
2690 */
2691 NET_API_STATUS WINAPI
2692 NetGroupAddUser(LPCWSTR servername, LPCWSTR groupname, LPCWSTR username)
2693 {
2694 FIXME("(%s, %s, %s) stub!\n", debugstr_w(servername),
2695 debugstr_w(groupname), debugstr_w(username));
2696 return NERR_Success;
2697 }
2698
2699 /************************************************************
2700 * NetGroupEnum (NETAPI32.@)
2701 *
2702 */
2703 NET_API_STATUS WINAPI
2704 NetGroupEnum(LPCWSTR servername, DWORD level, LPBYTE *bufptr, DWORD prefmaxlen,
2705 LPDWORD entriesread, LPDWORD totalentries, LPDWORD resume_handle)
2706 {
2707 FIXME("(%s, %d, %p, %d, %p, %p, %p) stub!\n", debugstr_w(servername),
2708 level, bufptr, prefmaxlen, entriesread, totalentries, resume_handle);
2709 return ERROR_ACCESS_DENIED;
2710 }
2711
2712 /************************************************************
2713 * NetGroupGetInfo (NETAPI32.@)
2714 *
2715 */
2716 NET_API_STATUS WINAPI NetGroupGetInfo(LPCWSTR servername, LPCWSTR groupname, DWORD level, LPBYTE *bufptr)
2717 {
2718 FIXME("(%s, %s, %d, %p) stub!\n", debugstr_w(servername), debugstr_w(groupname), level, bufptr);
2719 return ERROR_ACCESS_DENIED;
2720 }
2721
2722 /******************************************************************************
2723 * NetUserModalsGet (NETAPI32.@)
2724 *
2725 * Retrieves global information for all users and global groups in the security
2726 * database.
2727 *
2728 * PARAMS
2729 * szServer [I] Specifies the DNS or the NetBIOS name of the remote server
2730 * on which the function is to execute.
2731 * level [I] Information level of the data.
2732 * 0 Return global passwords parameters. bufptr points to a
2733 * USER_MODALS_INFO_0 struct.
2734 * 1 Return logon server and domain controller information. bufptr
2735 * points to a USER_MODALS_INFO_1 struct.
2736 * 2 Return domain name and identifier. bufptr points to a
2737 * USER_MODALS_INFO_2 struct.
2738 * 3 Return lockout information. bufptr points to a USER_MODALS_INFO_3
2739 * struct.
2740 * pbuffer [I] Buffer that receives the data.
2741 *
2742 * RETURNS
2743 * Success: NERR_Success.
2744 * Failure:
2745 * ERROR_ACCESS_DENIED - the user does not have access to the info.
2746 * NERR_InvalidComputer - computer name is invalid.
2747 */
2748 NET_API_STATUS WINAPI NetUserModalsGet(
2749 LPCWSTR szServer, DWORD level, LPBYTE *pbuffer)
2750 {
2751 TRACE("(%s %d %p)\n", debugstr_w(szServer), level, pbuffer);
2752
2753 switch (level)
2754 {
2755 case 0:
2756 /* return global passwords parameters */
2757 FIXME("level 0 not implemented!\n");
2758 *pbuffer = NULL;
2759 return NERR_InternalError;
2760 case 1:
2761 /* return logon server and domain controller info */
2762 FIXME("level 1 not implemented!\n");
2763 *pbuffer = NULL;
2764 return NERR_InternalError;
2765 case 2:
2766 {
2767 /* return domain name and identifier */
2768 PUSER_MODALS_INFO_2 umi;
2769 LSA_HANDLE policyHandle;
2770 LSA_OBJECT_ATTRIBUTES objectAttributes;
2771 PPOLICY_ACCOUNT_DOMAIN_INFO domainInfo;
2772 NTSTATUS ntStatus;
2773 PSID domainIdentifier = NULL;
2774 int domainNameLen;
2775
2776 ZeroMemory(&objectAttributes, sizeof(objectAttributes));
2777 objectAttributes.Length = sizeof(objectAttributes);
2778
2779 ntStatus = LsaOpenPolicy(NULL, &objectAttributes,
2780 POLICY_VIEW_LOCAL_INFORMATION,
2781 &policyHandle);
2782 if (ntStatus != STATUS_SUCCESS)
2783 {
2784 WARN("LsaOpenPolicy failed with NT status %x\n",
2785 LsaNtStatusToWinError(ntStatus));
2786 return ntStatus;
2787 }
2788
2789 ntStatus = LsaQueryInformationPolicy(policyHandle,
2790 PolicyAccountDomainInformation,
2791 (PVOID *)&domainInfo);
2792 if (ntStatus != STATUS_SUCCESS)
2793 {
2794 WARN("LsaQueryInformationPolicy failed with NT status %x\n",
2795 LsaNtStatusToWinError(ntStatus));
2796 LsaClose(policyHandle);
2797 return ntStatus;
2798 }
2799
2800 domainIdentifier = domainInfo->DomainSid;
2801 domainNameLen = lstrlenW(domainInfo->DomainName.Buffer) + 1;
2802 LsaClose(policyHandle);
2803
2804 ntStatus = NetApiBufferAllocate(sizeof(USER_MODALS_INFO_2) +
2805 GetLengthSid(domainIdentifier) +
2806 domainNameLen * sizeof(WCHAR),
2807 (LPVOID *)pbuffer);
2808
2809 if (ntStatus != NERR_Success)
2810 {
2811 WARN("NetApiBufferAllocate() failed\n");
2812 LsaFreeMemory(domainInfo);
2813 return ntStatus;
2814 }
2815
2816 umi = (USER_MODALS_INFO_2 *) *pbuffer;
2817 umi->usrmod2_domain_id = *pbuffer + sizeof(USER_MODALS_INFO_2);
2818 umi->usrmod2_domain_name = (LPWSTR)(*pbuffer +
2819 sizeof(USER_MODALS_INFO_2) + GetLengthSid(domainIdentifier));
2820
2821 lstrcpynW(umi->usrmod2_domain_name,
2822 domainInfo->DomainName.Buffer,
2823 domainNameLen);
2824 CopySid(GetLengthSid(domainIdentifier), umi->usrmod2_domain_id,
2825 domainIdentifier);
2826
2827 LsaFreeMemory(domainInfo);
2828
2829 break;
2830 }
2831 case 3:
2832 /* return lockout information */
2833 FIXME("level 3 not implemented!\n");
2834 *pbuffer = NULL;
2835 return NERR_InternalError;
2836 default:
2837 TRACE("Invalid level %d is specified\n", level);
2838 *pbuffer = NULL;
2839 return ERROR_INVALID_LEVEL;
2840 }
2841
2842 return NERR_Success;
2843 }
2844
2845 static NET_API_STATUS change_password_smb( LPCWSTR domainname, LPCWSTR username,
2846 LPCWSTR oldpassword, LPCWSTR newpassword )
2847 {
2848 #ifdef HAVE_FORK
2849 NET_API_STATUS ret = NERR_Success;
2850 static char option_silent[] = "-s";
2851 static char option_user[] = "-U";
2852 static char option_remote[] = "-r";
2853 static char smbpasswd[] = "smbpasswd";
2854 int pipe_out[2];
2855 pid_t pid, wret;
2856 int status;
2857 char *server = NULL, *user, *argv[7], *old = NULL, *new = NULL;
2858
2859 if (domainname && !(server = strdup_unixcp( domainname ))) return ERROR_OUTOFMEMORY;
2860 if (!(user = strdup_unixcp( username )))
2861 {
2862 ret = ERROR_OUTOFMEMORY;
2863 goto end;
2864 }
2865 if (!(old = strdup_unixcp( oldpassword )))
2866 {
2867 ret = ERROR_OUTOFMEMORY;
2868 goto end;
2869 }
2870 if (!(new = strdup_unixcp( newpassword )))
2871 {
2872 ret = ERROR_OUTOFMEMORY;
2873 goto end;
2874 }
2875 argv[0] = smbpasswd;
2876 argv[1] = option_silent;
2877 argv[2] = option_user;
2878 argv[3] = user;
2879 if (server)
2880 {
2881 argv[4] = option_remote;
2882 argv[5] = server;
2883 argv[6] = NULL;
2884 }
2885 else argv[4] = NULL;
2886
2887 if (pipe( pipe_out ) == -1)
2888 {
2889 ret = NERR_InternalError;
2890 goto end;
2891 }
2892 fcntl( pipe_out[0], F_SETFD, FD_CLOEXEC );
2893 fcntl( pipe_out[1], F_SETFD, FD_CLOEXEC );
2894
2895 switch ((pid = fork()))
2896 {
2897 case -1:
2898 close( pipe_out[0] );
2899 close( pipe_out[1] );
2900 ret = NERR_InternalError;
2901 goto end;
2902 case 0:
2903 dup2( pipe_out[0], 0 );
2904 close( pipe_out[0] );
2905 close( pipe_out[1] );
2906 execvp( "smbpasswd", argv );
2907 ERR( "can't execute smbpasswd, is it installed?\n" );
2908 _exit(1);
2909 default:
2910 close( pipe_out[0] );
2911 break;
2912 }
2913 write( pipe_out[1], old, strlen( old ) );
2914 write( pipe_out[1], "\n", 1 );
2915 write( pipe_out[1], new, strlen( new ) );
2916 write( pipe_out[1], "\n", 1 );
2917 write( pipe_out[1], new, strlen( new ) );
2918 write( pipe_out[1], "\n", 1 );
2919 close( pipe_out[1] );
2920
2921 do {
2922 wret = waitpid(pid, &status, 0);
2923 } while (wret < 0 && errno == EINTR);
2924
2925 if (ret == NERR_Success && (wret < 0 || !WIFEXITED(status) || WEXITSTATUS(status)))
2926 ret = NERR_InternalError;
2927
2928 end:
2929 HeapFree( GetProcessHeap(), 0, server );
2930 HeapFree( GetProcessHeap(), 0, user );
2931 HeapFree( GetProcessHeap(), 0, old );
2932 HeapFree( GetProcessHeap(), 0, new );
2933 return ret;
2934 #else
2935 ERR( "no fork support on this platform\n" );
2936 return NERR_InternalError;
2937 #endif
2938 }
2939
2940 /******************************************************************************
2941 * NetUserChangePassword (NETAPI32.@)
2942 * PARAMS
2943 * domainname [I] Optional. Domain on which the user resides or the logon
2944 * domain of the current user if NULL.
2945 * username [I] Optional. Username to change the password for or the name
2946 * of the current user if NULL.
2947 * oldpassword [I] The user's current password.
2948 * newpassword [I] The password that the user will be changed to using.
2949 *
2950 * RETURNS
2951 * Success: NERR_Success.
2952 * Failure: NERR_* failure code or win error code.
2953 *
2954 */
2955 NET_API_STATUS WINAPI NetUserChangePassword(LPCWSTR domainname, LPCWSTR username,
2956 LPCWSTR oldpassword, LPCWSTR newpassword)
2957 {
2958 struct sam_user *user;
2959
2960 TRACE("(%s, %s, ..., ...)\n", debugstr_w(domainname), debugstr_w(username));
2961
2962 if (!change_password_smb( domainname, username, oldpassword, newpassword ))
2963 return NERR_Success;
2964
2965 if(domainname)
2966 FIXME("Ignoring domainname %s.\n", debugstr_w(domainname));
2967
2968 if((user = NETAPI_FindUser(username)) == NULL)
2969 return NERR_UserNotFound;
2970
2971 if(lstrcmpW(user->user_password, oldpassword) != 0)
2972 return ERROR_INVALID_PASSWORD;
2973
2974 if(lstrlenW(newpassword) > PWLEN)
2975 return ERROR_PASSWORD_RESTRICTION;
2976
2977 lstrcpyW(user->user_password, newpassword);
2978
2979 return NERR_Success;
2980 }
2981
2982 NET_API_STATUS WINAPI NetUseAdd(LMSTR servername, DWORD level, LPBYTE bufptr, LPDWORD parm_err)
2983 {
2984 FIXME("%s %d %p %p stub\n", debugstr_w(servername), level, bufptr, parm_err);
2985 return NERR_Success;
2986 }
2987
2988 NET_API_STATUS WINAPI NetUseDel(LMSTR servername, LMSTR usename, DWORD forcecond)
2989 {
2990 FIXME("%s %s %d stub\n", debugstr_w(servername), debugstr_w(usename), forcecond);
2991 return NERR_Success;
2992 }
2993
2994 /************************************************************
2995 * I_BrowserSetNetlogonState (NETAPI32.@)
2996 */
2997 NET_API_STATUS WINAPI I_BrowserSetNetlogonState(
2998 LPWSTR ServerName, LPWSTR DomainName, LPWSTR EmulatedServerName,
2999 DWORD Role)
3000 {
3001 return ERROR_NOT_SUPPORTED;
3002 }
3003
3004 /************************************************************
3005 * I_BrowserQueryEmulatedDomains (NETAPI32.@)
3006 */
3007 NET_API_STATUS WINAPI I_BrowserQueryEmulatedDomains(
3008 LPWSTR ServerName, PBROWSER_EMULATED_DOMAIN *EmulatedDomains,
3009 LPDWORD EntriesRead)
3010 {
3011 return ERROR_NOT_SUPPORTED;
3012 }
3013
3014 DWORD WINAPI DsGetDcNameW(LPCWSTR ComputerName, LPCWSTR AvoidDCName,
3015 GUID* DomainGuid, LPCWSTR SiteName, ULONG Flags,
3016 PDOMAIN_CONTROLLER_INFOW *DomainControllerInfo)
3017 {
3018 FIXME("(%s, %s, %s, %s, %08x, %p): stub\n", debugstr_w(ComputerName),
3019 debugstr_w(AvoidDCName), debugstr_guid(DomainGuid),
3020 debugstr_w(SiteName), Flags, DomainControllerInfo);
3021 return ERROR_CALL_NOT_IMPLEMENTED;
3022 }
3023
3024 DWORD WINAPI DsGetDcNameA(LPCSTR ComputerName, LPCSTR AvoidDCName,
3025 GUID* DomainGuid, LPCSTR SiteName, ULONG Flags,
3026 PDOMAIN_CONTROLLER_INFOA *DomainControllerInfo)
3027 {
3028 FIXME("(%s, %s, %s, %s, %08x, %p): stub\n", debugstr_a(ComputerName),
3029 debugstr_a(AvoidDCName), debugstr_guid(DomainGuid),
3030 debugstr_a(SiteName), Flags, DomainControllerInfo);
3031 return ERROR_CALL_NOT_IMPLEMENTED;
3032 }
3033
3034 DWORD WINAPI DsGetSiteNameW(LPCWSTR ComputerName, LPWSTR *SiteName)
3035 {
3036 FIXME("(%s, %p): stub\n", debugstr_w(ComputerName), SiteName);
3037 return ERROR_CALL_NOT_IMPLEMENTED;
3038 }
3039
3040 DWORD WINAPI DsGetSiteNameA(LPCSTR ComputerName, LPSTR *SiteName)
3041 {
3042 FIXME("(%s, %p): stub\n", debugstr_a(ComputerName), SiteName);
3043 return ERROR_CALL_NOT_IMPLEMENTED;
3044 }
3045
3046 /************************************************************
3047 * DsRoleFreeMemory (NETAPI32.@)
3048 *
3049 * PARAMS
3050 * Buffer [I] Pointer to the to-be-freed buffer.
3051 *
3052 * RETURNS
3053 * Nothing
3054 */
3055 VOID WINAPI DsRoleFreeMemory(PVOID Buffer)
3056 {
3057 TRACE("(%p)\n", Buffer);
3058 HeapFree(GetProcessHeap(), 0, Buffer);
3059 }
3060
3061 /************************************************************
3062 * DsRoleGetPrimaryDomainInformation (NETAPI32.@)
3063 *
3064 * PARAMS
3065 * lpServer [I] Pointer to UNICODE string with ComputerName
3066 * InfoLevel [I] Type of data to retrieve
3067 * Buffer [O] Pointer to to the requested data
3068 *
3069 * RETURNS
3070 *
3071 * NOTES
3072 * When lpServer is NULL, use the local computer
3073 */
3074 DWORD WINAPI DsRoleGetPrimaryDomainInformation(
3075 LPCWSTR lpServer, DSROLE_PRIMARY_DOMAIN_INFO_LEVEL InfoLevel,
3076 PBYTE* Buffer)
3077 {
3078 DWORD ret;
3079
3080 FIXME("(%p, %d, %p) stub\n", lpServer, InfoLevel, Buffer);
3081
3082 /* Check some input parameters */
3083
3084 if (!Buffer) return ERROR_INVALID_PARAMETER;
3085 if ((InfoLevel < DsRolePrimaryDomainInfoBasic) || (InfoLevel > DsRoleOperationState)) return ERROR_INVALID_PARAMETER;
3086
3087 *Buffer = NULL;
3088 switch (InfoLevel)
3089 {
3090 case DsRolePrimaryDomainInfoBasic:
3091 {
3092 LSA_OBJECT_ATTRIBUTES ObjectAttributes;
3093 LSA_HANDLE PolicyHandle;
3094 PPOLICY_ACCOUNT_DOMAIN_INFO DomainInfo;
3095 NTSTATUS NtStatus;
3096 int logon_domain_sz;
3097 DWORD size;
3098 PDSROLE_PRIMARY_DOMAIN_INFO_BASIC basic;
3099
3100 ZeroMemory(&ObjectAttributes, sizeof(ObjectAttributes));
3101 NtStatus = LsaOpenPolicy(NULL, &ObjectAttributes,
3102 POLICY_VIEW_LOCAL_INFORMATION, &PolicyHandle);
3103 if (NtStatus != STATUS_SUCCESS)
3104 {
3105 TRACE("LsaOpenPolicyFailed with NT status %x\n",
3106 LsaNtStatusToWinError(NtStatus));
3107 return ERROR_OUTOFMEMORY;
3108 }
3109 LsaQueryInformationPolicy(PolicyHandle,
3110 PolicyAccountDomainInformation, (PVOID*)&DomainInfo);
3111 logon_domain_sz = lstrlenW(DomainInfo->DomainName.Buffer) + 1;
3112 LsaClose(PolicyHandle);
3113
3114 size = sizeof(DSROLE_PRIMARY_DOMAIN_INFO_BASIC) +
3115 logon_domain_sz * sizeof(WCHAR);
3116 basic = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, size);
3117 if (basic)
3118 {
3119 basic->MachineRole = DsRole_RoleStandaloneWorkstation;
3120 basic->DomainNameFlat = (LPWSTR)((LPBYTE)basic +
3121 sizeof(DSROLE_PRIMARY_DOMAIN_INFO_BASIC));
3122 lstrcpyW(basic->DomainNameFlat, DomainInfo->DomainName.Buffer);
3123 ret = ERROR_SUCCESS;
3124 }
3125 else
3126 ret = ERROR_OUTOFMEMORY;
3127 *Buffer = (PBYTE)basic;
3128 LsaFreeMemory(DomainInfo);
3129 }
3130 break;
3131 default:
3132 ret = ERROR_CALL_NOT_IMPLEMENTED;
3133 }
3134 return ret;
3135 }
3136
3137 /************************************************************
3138 * NetLocalGroupAdd (NETAPI32.@)
3139 */
3140 NET_API_STATUS WINAPI NetLocalGroupAdd(
3141 LPCWSTR servername,
3142 DWORD level,
3143 LPBYTE buf,
3144 LPDWORD parm_err)
3145 {
3146 FIXME("(%s %d %p %p) stub!\n", debugstr_w(servername), level, buf,
3147 parm_err);
3148 return NERR_Success;
3149 }
3150
3151 /************************************************************
3152 * NetLocalGroupAddMember (NETAPI32.@)
3153 */
3154 NET_API_STATUS WINAPI NetLocalGroupAddMember(
3155 LPCWSTR servername,
3156 LPCWSTR groupname,
3157 PSID membersid)
3158 {
3159 FIXME("(%s %s %p) stub!\n", debugstr_w(servername),
3160 debugstr_w(groupname), membersid);
3161 return NERR_Success;
3162 }
3163
3164 /************************************************************
3165 * NetLocalGroupAddMembers (NETAPI32.@)
3166 */
3167 NET_API_STATUS WINAPI NetLocalGroupAddMembers(
3168 LPCWSTR servername,
3169 LPCWSTR groupname,
3170 DWORD level,
3171 LPBYTE buf,
3172 DWORD totalentries)
3173 {
3174 FIXME("(%s %s %d %p %d) stub!\n", debugstr_w(servername),
3175 debugstr_w(groupname), level, buf, totalentries);
3176 return NERR_Success;
3177 }
3178
3179 /************************************************************
3180 * NetLocalGroupDel (NETAPI32.@)
3181 */
3182 NET_API_STATUS WINAPI NetLocalGroupDel(
3183 LPCWSTR servername,
3184 LPCWSTR groupname)
3185 {
3186 FIXME("(%s %s) stub!\n", debugstr_w(servername), debugstr_w(groupname));
3187 return NERR_Success;
3188 }
3189
3190 /************************************************************
3191 * NetLocalGroupDelMember (NETAPI32.@)
3192 */
3193 NET_API_STATUS WINAPI NetLocalGroupDelMember(
3194 LPCWSTR servername,
3195 LPCWSTR groupname,
3196 PSID membersid)
3197 {
3198 FIXME("(%s %s %p) stub!\n", debugstr_w(servername),
3199 debugstr_w(groupname), membersid);
3200 return NERR_Success;
3201 }
3202
3203 /************************************************************
3204 * NetLocalGroupDelMembers (NETAPI32.@)
3205 */
3206 NET_API_STATUS WINAPI NetLocalGroupDelMembers(
3207 LPCWSTR servername,
3208 LPCWSTR groupname,
3209 DWORD level,
3210 LPBYTE buf,
3211 DWORD totalentries)
3212 {
3213 FIXME("(%s %s %d %p %d) stub!\n", debugstr_w(servername),
3214 debugstr_w(groupname), level, buf, totalentries);
3215 return NERR_Success;
3216 }
3217
3218 /************************************************************
3219 * NetLocalGroupEnum (NETAPI32.@)
3220 */
3221 NET_API_STATUS WINAPI NetLocalGroupEnum(
3222 LPCWSTR servername,
3223 DWORD level,
3224 LPBYTE* bufptr,
3225 DWORD prefmaxlen,
3226 LPDWORD entriesread,
3227 LPDWORD totalentries,
3228 PDWORD_PTR resumehandle)
3229 {
3230 FIXME("(%s %d %p %d %p %p %p) stub!\n", debugstr_w(servername),
3231 level, bufptr, prefmaxlen, entriesread, totalentries, resumehandle);
3232 *entriesread = 0;
3233 *totalentries = 0;
3234 return NERR_Success;
3235 }
3236
3237 /************************************************************
3238 * NetLocalGroupGetInfo (NETAPI32.@)
3239 */
3240 NET_API_STATUS WINAPI NetLocalGroupGetInfo(
3241 LPCWSTR servername,
3242 LPCWSTR groupname,
3243 DWORD level,
3244 LPBYTE* bufptr)
3245 {
3246 static const WCHAR commentW[]={'N','o',' ','c','o','m','m','e','n','t',0};
3247 LOCALGROUP_INFO_1* info;
3248 DWORD size;
3249
3250 FIXME("(%s %s %d %p) semi-stub!\n", debugstr_w(servername),
3251 debugstr_w(groupname), level, bufptr);
3252
3253 size = sizeof(*info) + sizeof(WCHAR) * (lstrlenW(groupname)+1) + sizeof(commentW);
3254 NetApiBufferAllocate(size, (LPVOID*)&info);
3255
3256 info->lgrpi1_name = (LPWSTR)(info + 1);
3257 lstrcpyW(info->lgrpi1_name, groupname);
3258
3259 info->lgrpi1_comment = info->lgrpi1_name + lstrlenW(groupname) + 1;
3260 lstrcpyW(info->lgrpi1_comment, commentW);
3261
3262 *bufptr = (LPBYTE)info;
3263
3264 return NERR_Success;
3265 }
3266
3267 /************************************************************
3268 * NetLocalGroupGetMembers (NETAPI32.@)
3269 */
3270 NET_API_STATUS WINAPI NetLocalGroupGetMembers(
3271 LPCWSTR servername,
3272 LPCWSTR localgroupname,
3273 DWORD level,
3274 LPBYTE* bufptr,
3275 DWORD prefmaxlen,
3276 LPDWORD entriesread,
3277 LPDWORD totalentries,
3278 PDWORD_PTR resumehandle)
3279 {
3280 FIXME("(%s %s %d %p %d, %p %p %p) stub!\n", debugstr_w(servername),
3281 debugstr_w(localgroupname), level, bufptr, prefmaxlen, entriesread,
3282 totalentries, resumehandle);
3283
3284 if (level == 3)
3285 {
3286 WCHAR userName[MAX_COMPUTERNAME_LENGTH + 1];
3287 DWORD userNameLen;
3288 DWORD len,needlen;
3289 PLOCALGROUP_MEMBERS_INFO_3 ptr;
3290
3291 /* still a stub, current user is belonging to all groups */
3292
3293 *totalentries = 1;
3294 *entriesread = 0;
3295
3296 userNameLen = MAX_COMPUTERNAME_LENGTH + 1;
3297 if (!GetUserNameW(userName,&userNameLen))
3298 return ERROR_NOT_ENOUGH_MEMORY;
3299
3300 needlen = sizeof(LOCALGROUP_MEMBERS_INFO_3) +
3301 (userNameLen+2) * sizeof(WCHAR);
3302 if (prefmaxlen != MAX_PREFERRED_LENGTH)
3303 len = min(prefmaxlen,needlen);
3304 else
3305 len = needlen;
3306
3307 NetApiBufferAllocate(len, (LPVOID *) bufptr);
3308 if (len < needlen)
3309 return ERROR_MORE_DATA;
3310
3311 ptr = (PLOCALGROUP_MEMBERS_INFO_3)*bufptr;
3312 ptr->lgrmi3_domainandname = (LPWSTR)(*bufptr+sizeof(LOCALGROUP_MEMBERS_INFO_3));
3313 lstrcpyW(ptr->lgrmi3_domainandname,userName);
3314
3315 *entriesread = 1;
3316 }
3317
3318 return NERR_Success;
3319 }
3320
3321 /************************************************************
3322 * NetLocalGroupSetInfo (NETAPI32.@)
3323 */
3324 NET_API_STATUS WINAPI NetLocalGroupSetInfo(
3325 LPCWSTR servername,
3326 LPCWSTR groupname,
3327 DWORD level,
3328 LPBYTE buf,
3329 LPDWORD parm_err)
3330 {
3331 FIXME("(%s %s %d %p %p) stub!\n", debugstr_w(servername),
3332 debugstr_w(groupname), level, buf, parm_err);
3333 return NERR_Success;
3334 }
3335
3336 /************************************************************
3337 * NetLocalGroupSetMember (NETAPI32.@)
3338 */
3339 NET_API_STATUS WINAPI NetLocalGroupSetMembers(
3340 LPCWSTR servername,
3341 LPCWSTR groupname,
3342 DWORD level,
3343 LPBYTE buf,
3344 DWORD totalentries)
3345 {
3346 FIXME("(%s %s %d %p %d) stub!\n", debugstr_w(servername),
3347 debugstr_w(groupname), level, buf, totalentries);
3348 return NERR_Success;
3349 }
Windows API implementation