?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
d3d8: Get rid of the format switching code in d3d8_device_CopyRects().
[wine.git] / dlls / netapi32 / netapi32.c
blobd2a61fab26408ad7f0b590c23a7a4380d2a4bd84
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 size = sizeof(SERVER_INFO_101) + computerNameLen * sizeof(WCHAR);
1046 ret = NetApiBufferAllocate(size, (LPVOID *)bufptr);
1047 if (ret == NERR_Success)
1048 {
1049 /* INFO_100 structure is a subset of INFO_101 */
1050 PSERVER_INFO_101 info = (PSERVER_INFO_101)*bufptr;
1051 OSVERSIONINFOW verInfo;
1052
1053 info->sv101_platform_id = PLATFORM_ID_NT;
1054 info->sv101_name = (LMSTR)(*bufptr + sizeof(SERVER_INFO_101));
1055 memcpy(info->sv101_name, computerName,
1056 computerNameLen * sizeof(WCHAR));
1057 verInfo.dwOSVersionInfoSize = sizeof(verInfo);
1058 GetVersionExW(&verInfo);
1059 info->sv101_version_major = verInfo.dwMajorVersion;
1060 info->sv101_version_minor = verInfo.dwMinorVersion;
1061 /* Use generic type as no wine equivalent of DC / Server */
1062 info->sv101_type = SV_TYPE_NT;
1063 info->sv101_comment = NULL;
1064 }
1065 break;
1066 }
1067
1068 default:
1069 FIXME("level %d unimplemented\n", level);
1070 ret = ERROR_INVALID_LEVEL;
1071 }
1072 return ret;
1073 }
1074
1075
1076 /************************************************************
1077 * NetStatisticsGet (NETAPI32.@)
1078 */
1079 NET_API_STATUS WINAPI NetStatisticsGet(LMSTR server, LMSTR service,
1080 DWORD level, DWORD options,
1081 LPBYTE *bufptr)
1082 {
1083 TRACE("(%p, %p, %d, %d, %p)\n", server, service, level, options, bufptr);
1084 return NERR_InternalError;
1085 }
1086
1087 NET_API_STATUS WINAPI NetUseEnum(LMSTR server, DWORD level, LPBYTE* bufptr, DWORD prefmaxsize,
1088 LPDWORD entriesread, LPDWORD totalentries, LPDWORD resumehandle)
1089 {
1090 FIXME("stub (%p, %d, %p, %d, %p, %p, %p)\n", server, level, bufptr, prefmaxsize,
1091 entriesread, totalentries, resumehandle);
1092 return ERROR_NOT_SUPPORTED;
1093 }
1094
1095 NET_API_STATUS WINAPI NetScheduleJobAdd(LPCWSTR server, LPBYTE bufptr, LPDWORD jobid)
1096 {
1097 FIXME("stub (%s, %p, %p)\n", debugstr_w(server), bufptr, jobid);
1098 return NERR_Success;
1099 }
1100
1101 NET_API_STATUS WINAPI NetScheduleJobDel(LPCWSTR server, DWORD minjobid, DWORD maxjobid)
1102 {
1103 FIXME("stub (%s, %d, %d)\n", debugstr_w(server), minjobid, maxjobid);
1104 return NERR_Success;
1105 }
1106
1107 NET_API_STATUS WINAPI NetScheduleJobEnum(LPCWSTR server, LPBYTE* bufptr, DWORD prefmaxsize, LPDWORD entriesread,
1108 LPDWORD totalentries, LPDWORD resumehandle)
1109 {
1110 FIXME("stub (%s, %p, %d, %p, %p, %p)\n", debugstr_w(server), bufptr, prefmaxsize, entriesread, totalentries, resumehandle);
1111 *entriesread = 0;
1112 *totalentries = 0;
1113 return NERR_Success;
1114 }
1115
1116 NET_API_STATUS WINAPI NetUseGetInfo(LMSTR server, LMSTR name, DWORD level, LPBYTE *bufptr)
1117 {
1118 FIXME("stub (%p, %p, %d, %p)\n", server, name, level, bufptr);
1119 return ERROR_NOT_SUPPORTED;
1120
1121 }
1122
1123 /************************************************************
1124 * NetApiBufferAllocate (NETAPI32.@)
1125 */
1126 NET_API_STATUS WINAPI NetApiBufferAllocate(DWORD ByteCount, LPVOID* Buffer)
1127 {
1128 TRACE("(%d, %p)\n", ByteCount, Buffer);
1129
1130 if (Buffer == NULL) return ERROR_INVALID_PARAMETER;
1131 *Buffer = HeapAlloc(GetProcessHeap(), 0, ByteCount);
1132 if (*Buffer)
1133 return NERR_Success;
1134 else
1135 return GetLastError();
1136 }
1137
1138 /************************************************************
1139 * NetApiBufferFree (NETAPI32.@)
1140 */
1141 NET_API_STATUS WINAPI NetApiBufferFree(LPVOID Buffer)
1142 {
1143 TRACE("(%p)\n", Buffer);
1144 HeapFree(GetProcessHeap(), 0, Buffer);
1145 return NERR_Success;
1146 }
1147
1148 /************************************************************
1149 * NetApiBufferReallocate (NETAPI32.@)
1150 */
1151 NET_API_STATUS WINAPI NetApiBufferReallocate(LPVOID OldBuffer, DWORD NewByteCount,
1152 LPVOID* NewBuffer)
1153 {
1154 TRACE("(%p, %d, %p)\n", OldBuffer, NewByteCount, NewBuffer);
1155 if (NewByteCount)
1156 {
1157 if (OldBuffer)
1158 *NewBuffer = HeapReAlloc(GetProcessHeap(), 0, OldBuffer, NewByteCount);
1159 else
1160 *NewBuffer = HeapAlloc(GetProcessHeap(), 0, NewByteCount);
1161 return *NewBuffer ? NERR_Success : GetLastError();
1162 }
1163 else
1164 {
1165 if (!HeapFree(GetProcessHeap(), 0, OldBuffer)) return GetLastError();
1166 *NewBuffer = 0;
1167 return NERR_Success;
1168 }
1169 }
1170
1171 /************************************************************
1172 * NetApiBufferSize (NETAPI32.@)
1173 */
1174 NET_API_STATUS WINAPI NetApiBufferSize(LPVOID Buffer, LPDWORD ByteCount)
1175 {
1176 DWORD dw;
1177
1178 TRACE("(%p, %p)\n", Buffer, ByteCount);
1179 if (Buffer == NULL)
1180 return ERROR_INVALID_PARAMETER;
1181 dw = HeapSize(GetProcessHeap(), 0, Buffer);
1182 TRACE("size: %d\n", dw);
1183 if (dw != 0xFFFFFFFF)
1184 *ByteCount = dw;
1185 else
1186 *ByteCount = 0;
1187
1188 return NERR_Success;
1189 }
1190
1191 /************************************************************
1192 * NetSessionEnum (NETAPI32.@)
1193 *
1194 * PARAMS
1195 * servername [I] Pointer to a string with the name of the server
1196 * UncClientName [I] Pointer to a string with the name of the session
1197 * username [I] Pointer to a string with the name of the user
1198 * level [I] Data information level
1199 * bufptr [O] Buffer to the data
1200 * prefmaxlen [I] Preferred maximum length of the data
1201 * entriesread [O] Pointer to the number of entries enumerated
1202 * totalentries [O] Pointer to the possible number of entries
1203 * resume_handle [I/O] Pointer to a handle for subsequent searches
1204 *
1205 * RETURNS
1206 * If successful, the function returns NERR_Success
1207 * On failure it returns:
1208 * ERROR_ACCESS_DENIED User has no access to the requested information
1209 * ERROR_INVALID_LEVEL Value of 'level' is not correct
1210 * ERROR_INVALID_PARAMETER Wrong parameter
1211 * ERROR_MORE_DATA Need a larger buffer
1212 * ERROR_NOT_ENOUGH_MEMORY Not enough memory
1213 * NERR_ClientNameNotFound A session does not exist on a given computer
1214 * NERR_InvalidComputer Invalid computer name
1215 * NERR_UserNotFound User name could not be found.
1216 */
1217 NET_API_STATUS WINAPI NetSessionEnum(LMSTR servername, LMSTR UncClientName,
1218 LMSTR username, DWORD level, LPBYTE* bufptr, DWORD prefmaxlen, LPDWORD entriesread,
1219 LPDWORD totalentries, LPDWORD resume_handle)
1220 {
1221 FIXME("Stub (%s %s %s %d %p %d %p %p %p)\n", debugstr_w(servername),
1222 debugstr_w(UncClientName), debugstr_w(username),
1223 level, bufptr, prefmaxlen, entriesread, totalentries, resume_handle);
1224
1225 return NERR_Success;
1226 }
1227
1228 /************************************************************
1229 * NetShareEnum (NETAPI32.@)
1230 *
1231 * PARAMS
1232 * servername [I] Pointer to a string with the name of the server
1233 * level [I] Data information level
1234 * bufptr [O] Buffer to the data
1235 * prefmaxlen [I] Preferred maximum length of the data
1236 * entriesread [O] Pointer to the number of entries enumerated
1237 * totalentries [O] Pointer to the possible number of entries
1238 * resume_handle [I/O] Pointer to a handle for subsequent searches
1239 *
1240 * RETURNS
1241 * If successful, the function returns NERR_Success
1242 * On failure it returns a system error code (FIXME: find out which)
1243 *
1244 */
1245 NET_API_STATUS WINAPI NetShareEnum( LMSTR servername, DWORD level, LPBYTE* bufptr,
1246 DWORD prefmaxlen, LPDWORD entriesread, LPDWORD totalentries, LPDWORD resume_handle)
1247 {
1248 FIXME("Stub (%s %d %p %d %p %p %p)\n", debugstr_w(servername), level, bufptr,
1249 prefmaxlen, entriesread, totalentries, resume_handle);
1250
1251 return ERROR_NOT_SUPPORTED;
1252 }
1253
1254 /************************************************************
1255 * NetShareDel (NETAPI32.@)
1256 */
1257 NET_API_STATUS WINAPI NetShareDel(LMSTR servername, LMSTR netname, DWORD reserved)
1258 {
1259 BOOL local = NETAPI_IsLocalComputer( servername );
1260
1261 TRACE("%s %s %d\n", debugstr_w(servername), debugstr_w(netname), reserved);
1262
1263 if (!local)
1264 {
1265 if (libnetapi_init()) return share_del( servername, netname, reserved );
1266 FIXME( "remote computers not supported\n" );
1267 }
1268
1269 FIXME("%s %s %d\n", debugstr_w(servername), debugstr_w(netname), reserved);
1270 return NERR_Success;
1271 }
1272
1273 /************************************************************
1274 * NetShareGetInfo (NETAPI32.@)
1275 */
1276 NET_API_STATUS WINAPI NetShareGetInfo(LMSTR servername, LMSTR netname,
1277 DWORD level, LPBYTE *bufptr)
1278 {
1279 FIXME("Stub (%s %s %d %p)\n", debugstr_w(servername),
1280 debugstr_w(netname),level, bufptr);
1281 return NERR_NetNameNotFound;
1282 }
1283
1284 /************************************************************
1285 * NetShareAdd (NETAPI32.@)
1286 */
1287 NET_API_STATUS WINAPI NetShareAdd(LMSTR servername,
1288 DWORD level, LPBYTE buf, LPDWORD parm_err)
1289 {
1290 BOOL local = NETAPI_IsLocalComputer( servername );
1291
1292 TRACE("%s %d %p %p\n", debugstr_w(servername), level, buf, parm_err);
1293
1294 if (!local)
1295 {
1296 if (libnetapi_init()) return share_add( servername, level, buf, parm_err );
1297 FIXME( "remote computers not supported\n" );
1298 }
1299
1300 FIXME("%s %d %p %p\n", debugstr_w(servername), level, buf, parm_err);
1301 return ERROR_NOT_SUPPORTED;
1302 }
1303
1304 /************************************************************
1305 * NetFileEnum (NETAPI32.@)
1306 */
1307 NET_API_STATUS WINAPI NetFileEnum(
1308 LPWSTR ServerName, LPWSTR BasePath, LPWSTR UserName,
1309 DWORD Level, LPBYTE* BufPtr, DWORD PrefMaxLen,
1310 LPDWORD EntriesRead, LPDWORD TotalEntries, PDWORD_PTR ResumeHandle)
1311 {
1312 FIXME("(%s, %s, %s, %u): stub\n", debugstr_w(ServerName), debugstr_w(BasePath),
1313 debugstr_w(UserName), Level);
1314 return ERROR_NOT_SUPPORTED;
1315 }
1316
1317 static void wprint_mac(WCHAR* buffer, int len, const MIB_IFROW *ifRow)
1318 {
1319 int i;
1320 unsigned char val;
1321
1322 if (!buffer)
1323 return;
1324 if (len < 1)
1325 return;
1326 if (!ifRow)
1327 {
1328 *buffer = '\0';
1329 return;
1330 }
1331
1332 for (i = 0; i < ifRow->dwPhysAddrLen && 2 * i < len; i++)
1333 {
1334 val = ifRow->bPhysAddr[i];
1335 if ((val >>4) >9)
1336 buffer[2*i] = (WCHAR)((val >>4) + 'A' - 10);
1337 else
1338 buffer[2*i] = (WCHAR)((val >>4) + '0');
1339 if ((val & 0xf ) >9)
1340 buffer[2*i+1] = (WCHAR)((val & 0xf) + 'A' - 10);
1341 else
1342 buffer[2*i+1] = (WCHAR)((val & 0xf) + '0');
1343 }
1344 buffer[2*i]=0;
1345 }
1346
1347 /* Theoretically this could be too short, except that MS defines
1348 * MAX_ADAPTER_NAME as 128, and MAX_INTERFACE_NAME_LEN as 256, and both
1349 * represent a count of WCHARs, so even with an extraordinarily long header
1350 * this will be plenty
1351 */
1352 #define MAX_TRANSPORT_NAME MAX_INTERFACE_NAME_LEN
1353 #define MAX_TRANSPORT_ADDR 13
1354
1355 #define NBT_TRANSPORT_NAME_HEADER "\\Device\\NetBT_Tcpip_"
1356 #define UNKNOWN_TRANSPORT_NAME_HEADER "\\Device\\UnknownTransport_"
1357
1358 static void wprint_name(WCHAR *buffer, int len, ULONG transport,
1359 PMIB_IFROW ifRow)
1360 {
1361 WCHAR *ptr1, *ptr2;
1362 const char *name;
1363
1364 if (!buffer)
1365 return;
1366 if (!ifRow)
1367 {
1368 *buffer = '\0';
1369 return;
1370 }
1371
1372 if (!memcmp(&transport, TRANSPORT_NBT, sizeof(ULONG)))
1373 name = NBT_TRANSPORT_NAME_HEADER;
1374 else
1375 name = UNKNOWN_TRANSPORT_NAME_HEADER;
1376
1377 for (ptr1 = buffer; *name && ptr1 < buffer + len; ptr1++, name++)
1378 *ptr1 = *name;
1379 for (ptr2 = ifRow->wszName; *ptr2 && ptr1 < buffer + len; ptr1++, ptr2++)
1380 *ptr1 = *ptr2;
1381 *ptr1 = '\0';
1382 }
1383
1384 /***********************************************************************
1385 * NetWkstaTransportEnum (NETAPI32.@)
1386 */
1387
1388 struct WkstaTransportEnumData
1389 {
1390 UCHAR n_adapt;
1391 UCHAR n_read;
1392 DWORD prefmaxlen;
1393 LPBYTE *pbuf;
1394 NET_API_STATUS ret;
1395 };
1396
1397 /**********************************************************************/
1398
1399 static BOOL WkstaEnumAdaptersCallback(UCHAR totalLANAs, UCHAR lanaIndex,
1400 ULONG transport, const NetBIOSAdapterImpl *data, void *closure)
1401 {
1402 BOOL ret;
1403 struct WkstaTransportEnumData *enumData = closure;
1404
1405 if (enumData && enumData->pbuf)
1406 {
1407 if (lanaIndex == 0)
1408 {
1409 DWORD toAllocate;
1410
1411 enumData->n_adapt = totalLANAs;
1412 enumData->n_read = 0;
1413
1414 toAllocate = totalLANAs * (sizeof(WKSTA_TRANSPORT_INFO_0)
1415 + MAX_TRANSPORT_NAME * sizeof(WCHAR) +
1416 MAX_TRANSPORT_ADDR * sizeof(WCHAR));
1417 if (enumData->prefmaxlen != MAX_PREFERRED_LENGTH)
1418 toAllocate = enumData->prefmaxlen;
1419 NetApiBufferAllocate(toAllocate, (LPVOID *)enumData->pbuf);
1420 }
1421 if (*(enumData->pbuf))
1422 {
1423 UCHAR spaceFor;
1424
1425 if (enumData->prefmaxlen == MAX_PREFERRED_LENGTH)
1426 spaceFor = totalLANAs;
1427 else
1428 spaceFor = enumData->prefmaxlen /
1429 (sizeof(WKSTA_TRANSPORT_INFO_0) + (MAX_TRANSPORT_NAME +
1430 MAX_TRANSPORT_ADDR) * sizeof(WCHAR));
1431 if (enumData->n_read < spaceFor)
1432 {
1433 PWKSTA_TRANSPORT_INFO_0 ti;
1434 LMSTR transport_name, transport_addr;
1435 MIB_IFROW ifRow;
1436
1437 ti = (PWKSTA_TRANSPORT_INFO_0)(*(enumData->pbuf) +
1438 enumData->n_read * sizeof(WKSTA_TRANSPORT_INFO_0));
1439 transport_name = (LMSTR)(*(enumData->pbuf) +
1440 totalLANAs * sizeof(WKSTA_TRANSPORT_INFO_0) +
1441 enumData->n_read * MAX_TRANSPORT_NAME * sizeof(WCHAR));
1442 transport_addr = (LMSTR)(*(enumData->pbuf) +
1443 totalLANAs * (sizeof(WKSTA_TRANSPORT_INFO_0) +
1444 MAX_TRANSPORT_NAME * sizeof(WCHAR)) +
1445 enumData->n_read * MAX_TRANSPORT_ADDR * sizeof(WCHAR));
1446
1447 ifRow.dwIndex = data->ifIndex;
1448 GetIfEntry(&ifRow);
1449 ti->wkti0_quality_of_service = 0;
1450 ti->wkti0_number_of_vcs = 0;
1451 ti->wkti0_transport_name = transport_name;
1452 wprint_name(ti->wkti0_transport_name, MAX_TRANSPORT_NAME,
1453 transport, &ifRow);
1454 ti->wkti0_transport_address = transport_addr;
1455 wprint_mac(ti->wkti0_transport_address, MAX_TRANSPORT_ADDR,
1456 &ifRow);
1457 if (!memcmp(&transport, TRANSPORT_NBT, sizeof(ULONG)))
1458 ti->wkti0_wan_ish = TRUE;
1459 else
1460 ti->wkti0_wan_ish = FALSE;
1461 TRACE("%d of %d:ti at %p\n", lanaIndex, totalLANAs, ti);
1462 TRACE("transport_name at %p %s\n",
1463 ti->wkti0_transport_name,
1464 debugstr_w(ti->wkti0_transport_name));
1465 TRACE("transport_address at %p %s\n",
1466 ti->wkti0_transport_address,
1467 debugstr_w(ti->wkti0_transport_address));
1468 enumData->n_read++;
1469 enumData->ret = NERR_Success;
1470 ret = TRUE;
1471 }
1472 else
1473 {
1474 enumData->ret = ERROR_MORE_DATA;
1475 ret = FALSE;
1476 }
1477 }
1478 else
1479 {
1480 enumData->ret = ERROR_OUTOFMEMORY;
1481 ret = FALSE;
1482 }
1483 }
1484 else
1485 ret = FALSE;
1486 return ret;
1487 }
1488
1489 /**********************************************************************/
1490
1491 NET_API_STATUS WINAPI
1492 NetWkstaTransportEnum(LMSTR ServerName, DWORD level, PBYTE* pbuf,
1493 DWORD prefmaxlen, LPDWORD read_entries,
1494 PDWORD total_entries, PDWORD hresume)
1495 {
1496 NET_API_STATUS ret;
1497
1498 TRACE(":%s, 0x%08x, %p, 0x%08x, %p, %p, %p\n", debugstr_w(ServerName),
1499 level, pbuf, prefmaxlen, read_entries, total_entries,hresume);
1500 if (!NETAPI_IsLocalComputer(ServerName))
1501 {
1502 FIXME(":not implemented for non-local computers\n");
1503 ret = ERROR_INVALID_LEVEL;
1504 }
1505 else
1506 {
1507 if (hresume && *hresume)
1508 {
1509 FIXME(":resume handle not implemented\n");
1510 return ERROR_INVALID_LEVEL;
1511 }
1512
1513 switch (level)
1514 {
1515 case 0: /* transport info */
1516 {
1517 ULONG allTransports;
1518 struct WkstaTransportEnumData enumData;
1519
1520 if (NetBIOSNumAdapters() == 0)
1521 return ERROR_NETWORK_UNREACHABLE;
1522 if (!read_entries)
1523 return STATUS_ACCESS_VIOLATION;
1524 if (!total_entries || !pbuf)
1525 return RPC_X_NULL_REF_POINTER;
1526
1527 enumData.prefmaxlen = prefmaxlen;
1528 enumData.pbuf = pbuf;
1529 memcpy(&allTransports, ALL_TRANSPORTS, sizeof(ULONG));
1530 NetBIOSEnumAdapters(allTransports, WkstaEnumAdaptersCallback,
1531 &enumData);
1532 *read_entries = enumData.n_read;
1533 *total_entries = enumData.n_adapt;
1534 if (hresume) *hresume= 0;
1535 ret = enumData.ret;
1536 break;
1537 }
1538 default:
1539 TRACE("Invalid level %d is specified\n", level);
1540 ret = ERROR_INVALID_LEVEL;
1541 }
1542 }
1543 return ret;
1544 }
1545
1546 /************************************************************
1547 * NetWkstaUserGetInfo (NETAPI32.@)
1548 */
1549 NET_API_STATUS WINAPI NetWkstaUserGetInfo(LMSTR reserved, DWORD level,
1550 PBYTE* bufptr)
1551 {
1552 NET_API_STATUS nastatus;
1553
1554 TRACE("(%s, %d, %p)\n", debugstr_w(reserved), level, bufptr);
1555 switch (level)
1556 {
1557 case 0:
1558 {
1559 PWKSTA_USER_INFO_0 ui;
1560 DWORD dwSize = UNLEN + 1;
1561
1562 /* set up buffer */
1563 nastatus = NetApiBufferAllocate(sizeof(WKSTA_USER_INFO_0) + dwSize * sizeof(WCHAR),
1564 (LPVOID *) bufptr);
1565 if (nastatus != NERR_Success)
1566 return ERROR_NOT_ENOUGH_MEMORY;
1567
1568 ui = (PWKSTA_USER_INFO_0) *bufptr;
1569 ui->wkui0_username = (LMSTR) (*bufptr + sizeof(WKSTA_USER_INFO_0));
1570
1571 /* get data */
1572 if (!GetUserNameW(ui->wkui0_username, &dwSize))
1573 {
1574 NetApiBufferFree(ui);
1575 return ERROR_NOT_ENOUGH_MEMORY;
1576 }
1577 else {
1578 nastatus = NetApiBufferReallocate(
1579 *bufptr, sizeof(WKSTA_USER_INFO_0) +
1580 (lstrlenW(ui->wkui0_username) + 1) * sizeof(WCHAR),
1581 (LPVOID *) bufptr);
1582 if (nastatus != NERR_Success)
1583 return nastatus;
1584 }
1585 break;
1586 }
1587
1588 case 1:
1589 {
1590 PWKSTA_USER_INFO_1 ui;
1591 PWKSTA_USER_INFO_0 ui0;
1592 LSA_OBJECT_ATTRIBUTES ObjectAttributes;
1593 LSA_HANDLE PolicyHandle;
1594 PPOLICY_ACCOUNT_DOMAIN_INFO DomainInfo;
1595 NTSTATUS NtStatus;
1596
1597 /* sizes of the field buffers in WCHARS */
1598 int username_sz, logon_domain_sz, oth_domains_sz, logon_server_sz;
1599
1600 FIXME("Level 1 processing is partially implemented\n");
1601 oth_domains_sz = 1;
1602 logon_server_sz = 1;
1603
1604 /* get some information first to estimate size of the buffer */
1605 ui0 = NULL;
1606 nastatus = NetWkstaUserGetInfo(NULL, 0, (PBYTE *) &ui0);
1607 if (nastatus != NERR_Success)
1608 return nastatus;
1609 username_sz = lstrlenW(ui0->wkui0_username) + 1;
1610
1611 ZeroMemory(&ObjectAttributes, sizeof(ObjectAttributes));
1612 NtStatus = LsaOpenPolicy(NULL, &ObjectAttributes,
1613 POLICY_VIEW_LOCAL_INFORMATION,
1614 &PolicyHandle);
1615 if (NtStatus != STATUS_SUCCESS)
1616 {
1617 TRACE("LsaOpenPolicyFailed with NT status %x\n",
1618 LsaNtStatusToWinError(NtStatus));
1619 NetApiBufferFree(ui0);
1620 return ERROR_NOT_ENOUGH_MEMORY;
1621 }
1622 LsaQueryInformationPolicy(PolicyHandle, PolicyAccountDomainInformation,
1623 (PVOID*) &DomainInfo);
1624 logon_domain_sz = lstrlenW(DomainInfo->DomainName.Buffer) + 1;
1625 LsaClose(PolicyHandle);
1626
1627 /* set up buffer */
1628 nastatus = NetApiBufferAllocate(sizeof(WKSTA_USER_INFO_1) +
1629 (username_sz + logon_domain_sz +
1630 oth_domains_sz + logon_server_sz) * sizeof(WCHAR),
1631 (LPVOID *) bufptr);
1632 if (nastatus != NERR_Success) {
1633 NetApiBufferFree(ui0);
1634 return nastatus;
1635 }
1636 ui = (WKSTA_USER_INFO_1 *) *bufptr;
1637 ui->wkui1_username = (LMSTR) (*bufptr + sizeof(WKSTA_USER_INFO_1));
1638 ui->wkui1_logon_domain = (LMSTR) (
1639 ((PBYTE) ui->wkui1_username) + username_sz * sizeof(WCHAR));
1640 ui->wkui1_oth_domains = (LMSTR) (
1641 ((PBYTE) ui->wkui1_logon_domain) +
1642 logon_domain_sz * sizeof(WCHAR));
1643 ui->wkui1_logon_server = (LMSTR) (
1644 ((PBYTE) ui->wkui1_oth_domains) +
1645 oth_domains_sz * sizeof(WCHAR));
1646
1647 /* get data */
1648 lstrcpyW(ui->wkui1_username, ui0->wkui0_username);
1649 NetApiBufferFree(ui0);
1650
1651 lstrcpynW(ui->wkui1_logon_domain, DomainInfo->DomainName.Buffer,
1652 logon_domain_sz);
1653 LsaFreeMemory(DomainInfo);
1654
1655 /* FIXME. Not implemented. Populated with empty strings */
1656 ui->wkui1_oth_domains[0] = 0;
1657 ui->wkui1_logon_server[0] = 0;
1658 break;
1659 }
1660 case 1101:
1661 {
1662 PWKSTA_USER_INFO_1101 ui;
1663 DWORD dwSize = 1;
1664
1665 FIXME("Stub. Level 1101 processing is not implemented\n");
1666 /* FIXME see also wkui1_oth_domains for level 1 */
1667
1668 /* set up buffer */
1669 nastatus = NetApiBufferAllocate(sizeof(WKSTA_USER_INFO_1101) + dwSize * sizeof(WCHAR),
1670 (LPVOID *) bufptr);
1671 if (nastatus != NERR_Success)
1672 return nastatus;
1673 ui = (PWKSTA_USER_INFO_1101) *bufptr;
1674 ui->wkui1101_oth_domains = (LMSTR)(ui + 1);
1675
1676 /* get data */
1677 ui->wkui1101_oth_domains[0] = 0;
1678 break;
1679 }
1680 default:
1681 TRACE("Invalid level %d is specified\n", level);
1682 return ERROR_INVALID_LEVEL;
1683 }
1684 return NERR_Success;
1685 }
1686
1687 /************************************************************
1688 * NetWkstaUserEnum (NETAPI32.@)
1689 */
1690 NET_API_STATUS WINAPI
1691 NetWkstaUserEnum(LMSTR servername, DWORD level, LPBYTE* bufptr,
1692 DWORD prefmaxlen, LPDWORD entriesread,
1693 LPDWORD totalentries, LPDWORD resumehandle)
1694 {
1695 FIXME("(%s, %d, %p, %d, %p, %p, %p): stub!\n", debugstr_w(servername),
1696 level, bufptr, prefmaxlen, entriesread, totalentries, resumehandle);
1697 return ERROR_INVALID_PARAMETER;
1698 }
1699
1700 /************************************************************
1701 * NetpGetComputerName (NETAPI32.@)
1702 */
1703 NET_API_STATUS WINAPI NetpGetComputerName(LPWSTR *Buffer)
1704 {
1705 DWORD dwSize = MAX_COMPUTERNAME_LENGTH + 1;
1706
1707 TRACE("(%p)\n", Buffer);
1708 NetApiBufferAllocate(dwSize * sizeof(WCHAR), (LPVOID *) Buffer);
1709 if (GetComputerNameW(*Buffer, &dwSize))
1710 {
1711 return NetApiBufferReallocate(
1712 *Buffer, (dwSize + 1) * sizeof(WCHAR),
1713 (LPVOID *) Buffer);
1714 }
1715 else
1716 {
1717 NetApiBufferFree(*Buffer);
1718 return ERROR_NOT_ENOUGH_MEMORY;
1719 }
1720 }
1721
1722 NET_API_STATUS WINAPI I_NetNameCompare(LPVOID p1, LPWSTR wkgrp, LPWSTR comp,
1723 LPVOID p4, LPVOID p5)
1724 {
1725 FIXME("(%p %s %s %p %p): stub\n", p1, debugstr_w(wkgrp), debugstr_w(comp),
1726 p4, p5);
1727 return ERROR_INVALID_PARAMETER;
1728 }
1729
1730 NET_API_STATUS WINAPI I_NetNameValidate(LPVOID p1, LPWSTR wkgrp, LPVOID p3,
1731 LPVOID p4)
1732 {
1733 FIXME("(%p %s %p %p): stub\n", p1, debugstr_w(wkgrp), p3, p4);
1734 return ERROR_INVALID_PARAMETER;
1735 }
1736
1737 NET_API_STATUS WINAPI NetWkstaGetInfo( LMSTR servername, DWORD level,
1738 LPBYTE* bufptr)
1739 {
1740 NET_API_STATUS ret;
1741 BOOL local = NETAPI_IsLocalComputer( servername );
1742
1743 TRACE("%s %d %p\n", debugstr_w( servername ), level, bufptr );
1744
1745 if (!local)
1746 {
1747 if (libnetapi_init()) return wksta_getinfo( servername, level, bufptr );
1748 FIXME( "remote computers not supported\n" );
1749 return ERROR_INVALID_LEVEL;
1750 }
1751 if (!bufptr) return ERROR_INVALID_PARAMETER;
1752
1753 switch (level)
1754 {
1755 case 100:
1756 case 101:
1757 case 102:
1758 {
1759 static const WCHAR lanroot[] = {'c',':','\\','l','a','n','m','a','n',0}; /* FIXME */
1760 DWORD computerNameLen, domainNameLen, size;
1761 WCHAR computerName[MAX_COMPUTERNAME_LENGTH + 1];
1762 LSA_OBJECT_ATTRIBUTES ObjectAttributes;
1763 LSA_HANDLE PolicyHandle;
1764 NTSTATUS NtStatus;
1765
1766 computerNameLen = MAX_COMPUTERNAME_LENGTH + 1;
1767 GetComputerNameW(computerName, &computerNameLen);
1768 computerNameLen++; /* include NULL terminator */
1769
1770 ZeroMemory(&ObjectAttributes, sizeof(ObjectAttributes));
1771 NtStatus = LsaOpenPolicy(NULL, &ObjectAttributes,
1772 POLICY_VIEW_LOCAL_INFORMATION, &PolicyHandle);
1773 if (NtStatus != STATUS_SUCCESS)
1774 ret = LsaNtStatusToWinError(NtStatus);
1775 else
1776 {
1777 PPOLICY_ACCOUNT_DOMAIN_INFO DomainInfo;
1778
1779 LsaQueryInformationPolicy(PolicyHandle,
1780 PolicyAccountDomainInformation, (PVOID*)&DomainInfo);
1781 domainNameLen = lstrlenW(DomainInfo->DomainName.Buffer) + 1;
1782 size = sizeof(WKSTA_INFO_102) + computerNameLen * sizeof(WCHAR)
1783 + domainNameLen * sizeof(WCHAR) + sizeof(lanroot);
1784 ret = NetApiBufferAllocate(size, (LPVOID *)bufptr);
1785 if (ret == NERR_Success)
1786 {
1787 /* INFO_100 and INFO_101 structures are subsets of INFO_102 */
1788 PWKSTA_INFO_102 info = (PWKSTA_INFO_102)*bufptr;
1789 OSVERSIONINFOW verInfo;
1790
1791 info->wki102_platform_id = PLATFORM_ID_NT;
1792 info->wki102_computername = (LMSTR)(*bufptr +
1793 sizeof(WKSTA_INFO_102));
1794 memcpy(info->wki102_computername, computerName,
1795 computerNameLen * sizeof(WCHAR));
1796 info->wki102_langroup = info->wki102_computername + computerNameLen;
1797 memcpy(info->wki102_langroup, DomainInfo->DomainName.Buffer,
1798 domainNameLen * sizeof(WCHAR));
1799 info->wki102_lanroot = info->wki102_langroup + domainNameLen;
1800 memcpy(info->wki102_lanroot, lanroot, sizeof(lanroot));
1801 memset(&verInfo, 0, sizeof(verInfo));
1802 verInfo.dwOSVersionInfoSize = sizeof(verInfo);
1803 GetVersionExW(&verInfo);
1804 info->wki102_ver_major = verInfo.dwMajorVersion;
1805 info->wki102_ver_minor = verInfo.dwMinorVersion;
1806 info->wki102_logged_on_users = 1;
1807 }
1808 LsaFreeMemory(DomainInfo);
1809 LsaClose(PolicyHandle);
1810 }
1811 break;
1812 }
1813
1814 default:
1815 FIXME("level %d unimplemented\n", level);
1816 ret = ERROR_INVALID_LEVEL;
1817 }
1818 return ret;
1819 }
1820
1821 /************************************************************
1822 * NetGetJoinInformation (NETAPI32.@)
1823 */
1824 NET_API_STATUS NET_API_FUNCTION NetGetJoinInformation(
1825 LPCWSTR Server,
1826 LPWSTR *Name,
1827 PNETSETUP_JOIN_STATUS type)
1828 {
1829 static const WCHAR workgroupW[] = {'W','o','r','k','g','r','o','u','p',0};
1830
1831 FIXME("Semi-stub %s %p %p\n", wine_dbgstr_w(Server), Name, type);
1832
1833 if (!Name || !type)
1834 return ERROR_INVALID_PARAMETER;
1835
1836 NetApiBufferAllocate(sizeof(workgroupW), (LPVOID *)Name);
1837 lstrcpyW(*Name, workgroupW);
1838 *type = NetSetupWorkgroupName;
1839
1840 return NERR_Success;
1841 }
1842
1843 /************************************************************
1844 * NetUserGetGroups (NETAPI32.@)
1845 */
1846 NET_API_STATUS NET_API_FUNCTION NetUserGetGroups(
1847 LPCWSTR servername,
1848 LPCWSTR username,
1849 DWORD level,
1850 LPBYTE *bufptr,
1851 DWORD prefixmaxlen,
1852 LPDWORD entriesread,
1853 LPDWORD totalentries)
1854 {
1855 FIXME("%s %s %d %p %d %p %p stub\n", debugstr_w(servername),
1856 debugstr_w(username), level, bufptr, prefixmaxlen, entriesread,
1857 totalentries);
1858
1859 *bufptr = NULL;
1860 *entriesread = 0;
1861 *totalentries = 0;
1862
1863 return ERROR_INVALID_LEVEL;
1864 }
1865
1866 struct sam_user
1867 {
1868 struct list entry;
1869 WCHAR user_name[LM20_UNLEN+1];
1870 WCHAR user_password[PWLEN + 1];
1871 DWORD sec_since_passwd_change;
1872 DWORD user_priv;
1873 LPWSTR home_dir;
1874 LPWSTR user_comment;
1875 DWORD user_flags;
1876 LPWSTR user_logon_script_path;
1877 };
1878
1879 static struct list user_list = LIST_INIT( user_list );
1880
1881 /************************************************************
1882 * NETAPI_ValidateServername
1883 *
1884 * Validates server name
1885 */
1886 static NET_API_STATUS NETAPI_ValidateServername(LPCWSTR ServerName)
1887 {
1888 if (ServerName)
1889 {
1890 if (ServerName[0] == 0)
1891 return ERROR_BAD_NETPATH;
1892 else if (
1893 ((ServerName[0] == '\\') &&
1894 (ServerName[1] != '\\'))
1895 ||
1896 ((ServerName[0] == '\\') &&
1897 (ServerName[1] == '\\') &&
1898 (ServerName[2] == 0))
1899 )
1900 return ERROR_INVALID_NAME;
1901 }
1902 return NERR_Success;
1903 }
1904
1905 /************************************************************
1906 * NETAPI_FindUser
1907 *
1908 * Looks for a user in the user database.
1909 * Returns a pointer to the entry in the user list when the user
1910 * is found, NULL otherwise.
1911 */
1912 static struct sam_user* NETAPI_FindUser(LPCWSTR UserName)
1913 {
1914 struct sam_user *user;
1915
1916 LIST_FOR_EACH_ENTRY(user, &user_list, struct sam_user, entry)
1917 {
1918 if(lstrcmpW(user->user_name, UserName) == 0)
1919 return user;
1920 }
1921 return NULL;
1922 }
1923
1924 static BOOL NETAPI_IsCurrentUser(LPCWSTR username)
1925 {
1926 LPWSTR curr_user = NULL;
1927 DWORD dwSize;
1928 BOOL ret = FALSE;
1929
1930 dwSize = LM20_UNLEN+1;
1931 curr_user = HeapAlloc(GetProcessHeap(), 0, dwSize * sizeof(WCHAR));
1932 if(!curr_user)
1933 {
1934 ERR("Failed to allocate memory for user name.\n");
1935 goto end;
1936 }
1937 if(!GetUserNameW(curr_user, &dwSize))
1938 {
1939 ERR("Failed to get current user's user name.\n");
1940 goto end;
1941 }
1942 if (!lstrcmpW(curr_user, username))
1943 {
1944 ret = TRUE;
1945 }
1946
1947 end:
1948 HeapFree(GetProcessHeap(), 0, curr_user);
1949 return ret;
1950 }
1951
1952 /************************************************************
1953 * NetUserAdd (NETAPI32.@)
1954 */
1955 NET_API_STATUS WINAPI NetUserAdd(LPCWSTR servername,
1956 DWORD level, LPBYTE bufptr, LPDWORD parm_err)
1957 {
1958 NET_API_STATUS status;
1959 struct sam_user * su = NULL;
1960
1961 FIXME("(%s, %d, %p, %p) stub!\n", debugstr_w(servername), level, bufptr, parm_err);
1962
1963 if((status = NETAPI_ValidateServername(servername)) != NERR_Success)
1964 return status;
1965
1966 switch(level)
1967 {
1968 /* Level 3 and 4 are identical for the purposes of NetUserAdd */
1969 case 4:
1970 case 3:
1971 FIXME("Level 3 and 4 not implemented.\n");
1972 /* Fall through */
1973 case 2:
1974 FIXME("Level 2 not implemented.\n");
1975 /* Fall through */
1976 case 1:
1977 {
1978 PUSER_INFO_1 ui = (PUSER_INFO_1) bufptr;
1979 su = HeapAlloc(GetProcessHeap(), 0, sizeof(struct sam_user));
1980 if(!su)
1981 {
1982 status = NERR_InternalError;
1983 break;
1984 }
1985
1986 if(lstrlenW(ui->usri1_name) > LM20_UNLEN)
1987 {
1988 status = NERR_BadUsername;
1989 break;
1990 }
1991
1992 /*FIXME: do other checks for a valid username */
1993 lstrcpyW(su->user_name, ui->usri1_name);
1994
1995 if(lstrlenW(ui->usri1_password) > PWLEN)
1996 {
1997 /* Always return PasswordTooShort on invalid passwords. */
1998 status = NERR_PasswordTooShort;
1999 break;
2000 }
2001 lstrcpyW(su->user_password, ui->usri1_password);
2002
2003 su->sec_since_passwd_change = ui->usri1_password_age;
2004 su->user_priv = ui->usri1_priv;
2005 su->user_flags = ui->usri1_flags;
2006
2007 /*FIXME: set the other LPWSTRs to NULL for now */
2008 su->home_dir = NULL;
2009 su->user_comment = NULL;
2010 su->user_logon_script_path = NULL;
2011
2012 list_add_head(&user_list, &su->entry);
2013 return NERR_Success;
2014 }
2015 default:
2016 TRACE("Invalid level %d specified.\n", level);
2017 status = ERROR_INVALID_LEVEL;
2018 break;
2019 }
2020
2021 HeapFree(GetProcessHeap(), 0, su);
2022
2023 return status;
2024 }
2025
2026 /************************************************************
2027 * NetUserDel (NETAPI32.@)
2028 */
2029 NET_API_STATUS WINAPI NetUserDel(LPCWSTR servername, LPCWSTR username)
2030 {
2031 NET_API_STATUS status;
2032 struct sam_user *user;
2033
2034 TRACE("(%s, %s)\n", debugstr_w(servername), debugstr_w(username));
2035
2036 if((status = NETAPI_ValidateServername(servername))!= NERR_Success)
2037 return status;
2038
2039 if ((user = NETAPI_FindUser(username)) == NULL)
2040 return NERR_UserNotFound;
2041
2042 list_remove(&user->entry);
2043
2044 HeapFree(GetProcessHeap(), 0, user->home_dir);
2045 HeapFree(GetProcessHeap(), 0, user->user_comment);
2046 HeapFree(GetProcessHeap(), 0, user->user_logon_script_path);
2047 HeapFree(GetProcessHeap(), 0, user);
2048
2049 return NERR_Success;
2050 }
2051
2052 /************************************************************
2053 * NetUserGetInfo (NETAPI32.@)
2054 */
2055 NET_API_STATUS WINAPI
2056 NetUserGetInfo(LPCWSTR servername, LPCWSTR username, DWORD level,
2057 LPBYTE* bufptr)
2058 {
2059 NET_API_STATUS status;
2060 TRACE("(%s, %s, %d, %p)\n", debugstr_w(servername), debugstr_w(username),
2061 level, bufptr);
2062 status = NETAPI_ValidateServername(servername);
2063 if (status != NERR_Success)
2064 return status;
2065
2066 if(!NETAPI_IsLocalComputer(servername))
2067 {
2068 FIXME("Only implemented for local computer, but remote server"
2069 "%s was requested.\n", debugstr_w(servername));
2070 return NERR_InvalidComputer;
2071 }
2072
2073 if(!NETAPI_FindUser(username) && !NETAPI_IsCurrentUser(username))
2074 {
2075 TRACE("User %s is unknown.\n", debugstr_w(username));
2076 return NERR_UserNotFound;
2077 }
2078
2079 switch (level)
2080 {
2081 case 0:
2082 {
2083 PUSER_INFO_0 ui;
2084 int name_sz;
2085
2086 name_sz = lstrlenW(username) + 1;
2087
2088 /* set up buffer */
2089 NetApiBufferAllocate(sizeof(USER_INFO_0) + name_sz * sizeof(WCHAR),
2090 (LPVOID *) bufptr);
2091
2092 ui = (PUSER_INFO_0) *bufptr;
2093 ui->usri0_name = (LPWSTR) (*bufptr + sizeof(USER_INFO_0));
2094
2095 /* get data */
2096 lstrcpyW(ui->usri0_name, username);
2097 break;
2098 }
2099
2100 case 10:
2101 {
2102 PUSER_INFO_10 ui;
2103 PUSER_INFO_0 ui0;
2104 /* sizes of the field buffers in WCHARS */
2105 int name_sz, comment_sz, usr_comment_sz, full_name_sz;
2106
2107 comment_sz = 1;
2108 usr_comment_sz = 1;
2109 full_name_sz = 1;
2110
2111 /* get data */
2112 status = NetUserGetInfo(servername, username, 0, (LPBYTE *) &ui0);
2113 if (status != NERR_Success)
2114 {
2115 NetApiBufferFree(ui0);
2116 return status;
2117 }
2118 name_sz = lstrlenW(ui0->usri0_name) + 1;
2119
2120 /* set up buffer */
2121 NetApiBufferAllocate(sizeof(USER_INFO_10) +
2122 (name_sz + comment_sz + usr_comment_sz +
2123 full_name_sz) * sizeof(WCHAR),
2124 (LPVOID *) bufptr);
2125 ui = (PUSER_INFO_10) *bufptr;
2126 ui->usri10_name = (LPWSTR) (*bufptr + sizeof(USER_INFO_10));
2127 ui->usri10_comment = (LPWSTR) (
2128 ((PBYTE) ui->usri10_name) + name_sz * sizeof(WCHAR));
2129 ui->usri10_usr_comment = (LPWSTR) (
2130 ((PBYTE) ui->usri10_comment) + comment_sz * sizeof(WCHAR));
2131 ui->usri10_full_name = (LPWSTR) (
2132 ((PBYTE) ui->usri10_usr_comment) + usr_comment_sz * sizeof(WCHAR));
2133
2134 /* set data */
2135 lstrcpyW(ui->usri10_name, ui0->usri0_name);
2136 NetApiBufferFree(ui0);
2137 ui->usri10_comment[0] = 0;
2138 ui->usri10_usr_comment[0] = 0;
2139 ui->usri10_full_name[0] = 0;
2140 break;
2141 }
2142
2143 case 1:
2144 {
2145 static const WCHAR homedirW[] = {'H','O','M','E',0};
2146 PUSER_INFO_1 ui;
2147 PUSER_INFO_0 ui0;
2148 /* sizes of the field buffers in WCHARS */
2149 int name_sz, password_sz, home_dir_sz, comment_sz, script_path_sz;
2150
2151 password_sz = 1; /* not filled out for security reasons for NetUserGetInfo*/
2152 comment_sz = 1;
2153 script_path_sz = 1;
2154
2155 /* get data */
2156 status = NetUserGetInfo(servername, username, 0, (LPBYTE *) &ui0);
2157 if (status != NERR_Success)
2158 {
2159 NetApiBufferFree(ui0);
2160 return status;
2161 }
2162 name_sz = lstrlenW(ui0->usri0_name) + 1;
2163 home_dir_sz = GetEnvironmentVariableW(homedirW, NULL,0);
2164 /* set up buffer */
2165 NetApiBufferAllocate(sizeof(USER_INFO_1) +
2166 (name_sz + password_sz + home_dir_sz +
2167 comment_sz + script_path_sz) * sizeof(WCHAR),
2168 (LPVOID *) bufptr);
2169
2170 ui = (PUSER_INFO_1) *bufptr;
2171 ui->usri1_name = (LPWSTR) (ui + 1);
2172 ui->usri1_password = ui->usri1_name + name_sz;
2173 ui->usri1_home_dir = ui->usri1_password + password_sz;
2174 ui->usri1_comment = ui->usri1_home_dir + home_dir_sz;
2175 ui->usri1_script_path = ui->usri1_comment + comment_sz;
2176 /* set data */
2177 lstrcpyW(ui->usri1_name, ui0->usri0_name);
2178 NetApiBufferFree(ui0);
2179 ui->usri1_password[0] = 0;
2180 ui->usri1_password_age = 0;
2181 ui->usri1_priv = 0;
2182 GetEnvironmentVariableW(homedirW, ui->usri1_home_dir,home_dir_sz);
2183 ui->usri1_comment[0] = 0;
2184 ui->usri1_flags = 0;
2185 ui->usri1_script_path[0] = 0;
2186 break;
2187 }
2188 case 2:
2189 case 3:
2190 case 4:
2191 case 11:
2192 case 20:
2193 case 23:
2194 case 1003:
2195 case 1005:
2196 case 1006:
2197 case 1007:
2198 case 1008:
2199 case 1009:
2200 case 1010:
2201 case 1011:
2202 case 1012:
2203 case 1013:
2204 case 1014:
2205 case 1017:
2206 case 1018:
2207 case 1020:
2208 case 1023:
2209 case 1024:
2210 case 1025:
2211 case 1051:
2212 case 1052:
2213 case 1053:
2214 {
2215 FIXME("Level %d is not implemented\n", level);
2216 return NERR_InternalError;
2217 }
2218 default:
2219 TRACE("Invalid level %d is specified\n", level);
2220 return ERROR_INVALID_LEVEL;
2221 }
2222 return NERR_Success;
2223 }
2224
2225 /************************************************************
2226 * NetUserGetLocalGroups (NETAPI32.@)
2227 */
2228 NET_API_STATUS WINAPI
2229 NetUserGetLocalGroups(LPCWSTR servername, LPCWSTR username, DWORD level,
2230 DWORD flags, LPBYTE* bufptr, DWORD prefmaxlen,
2231 LPDWORD entriesread, LPDWORD totalentries)
2232 {
2233 NET_API_STATUS status;
2234 const WCHAR admins[] = {'A','d','m','i','n','i','s','t','r','a','t','o','r','s',0};
2235 LPWSTR currentuser;
2236 LOCALGROUP_USERS_INFO_0* info;
2237 DWORD size;
2238
2239 FIXME("(%s, %s, %d, %08x, %p %d, %p, %p) stub!\n",
2240 debugstr_w(servername), debugstr_w(username), level, flags, bufptr,
2241 prefmaxlen, entriesread, totalentries);
2242
2243 status = NETAPI_ValidateServername(servername);
2244 if (status != NERR_Success)
2245 return status;
2246
2247 size = UNLEN + 1;
2248 NetApiBufferAllocate(size * sizeof(WCHAR), (LPVOID*)&currentuser);
2249 if (!GetUserNameW(currentuser, &size)) {
2250 NetApiBufferFree(currentuser);
2251 return ERROR_NOT_ENOUGH_MEMORY;
2252 }
2253
2254 if (lstrcmpiW(username, currentuser) && NETAPI_FindUser(username))
2255 {
2256 NetApiBufferFree(currentuser);
2257 return NERR_UserNotFound;
2258 }
2259
2260 NetApiBufferFree(currentuser);
2261 *totalentries = 1;
2262 size = sizeof(*info) + sizeof(admins);
2263
2264 if(prefmaxlen < size)
2265 status = ERROR_MORE_DATA;
2266 else
2267 status = NetApiBufferAllocate(size, (LPVOID*)&info);
2268
2269 if(status != NERR_Success)
2270 {
2271 *bufptr = NULL;
2272 *entriesread = 0;
2273 return status;
2274 }
2275
2276 info->lgrui0_name = (LPWSTR)((LPBYTE)info + sizeof(*info));
2277 lstrcpyW(info->lgrui0_name, admins);
2278
2279 *bufptr = (LPBYTE)info;
2280 *entriesread = 1;
2281
2282 return NERR_Success;
2283 }
2284
2285 /************************************************************
2286 * NetUserEnum (NETAPI32.@)
2287 */
2288 NET_API_STATUS WINAPI
2289 NetUserEnum(LPCWSTR servername, DWORD level, DWORD filter, LPBYTE* bufptr,
2290 DWORD prefmaxlen, LPDWORD entriesread, LPDWORD totalentries,
2291 LPDWORD resume_handle)
2292 {
2293 FIXME("(%s,%d, 0x%d,%p,%d,%p,%p,%p) stub!\n", debugstr_w(servername), level,
2294 filter, bufptr, prefmaxlen, entriesread, totalentries, resume_handle);
2295
2296 return ERROR_ACCESS_DENIED;
2297 }
2298
2299 /************************************************************
2300 * ACCESS_QueryAdminDisplayInformation
2301 *
2302 * Creates a buffer with information for the Admin User
2303 */
2304 static void ACCESS_QueryAdminDisplayInformation(PNET_DISPLAY_USER *buf, PDWORD pdwSize)
2305 {
2306 static const WCHAR sAdminUserName[] = {
2307 'A','d','m','i','n','i','s','t','r','a','t','o','r',0};
2308
2309 /* sizes of the field buffers in WCHARS */
2310 int name_sz, comment_sz, full_name_sz;
2311 PNET_DISPLAY_USER usr;
2312
2313 /* set up buffer */
2314 name_sz = lstrlenW(sAdminUserName) + 1;
2315 comment_sz = 1;
2316 full_name_sz = 1;
2317
2318 *pdwSize = sizeof(NET_DISPLAY_USER);
2319 *pdwSize += (name_sz + comment_sz + full_name_sz) * sizeof(WCHAR);
2320 NetApiBufferAllocate(*pdwSize, (LPVOID *) buf);
2321
2322 usr = *buf;
2323 usr->usri1_name = (LPWSTR) ((PBYTE) usr + sizeof(NET_DISPLAY_USER));
2324 usr->usri1_comment = (LPWSTR) (
2325 ((PBYTE) usr->usri1_name) + name_sz * sizeof(WCHAR));
2326 usr->usri1_full_name = (LPWSTR) (
2327 ((PBYTE) usr->usri1_comment) + comment_sz * sizeof(WCHAR));
2328
2329 /* set data */
2330 lstrcpyW(usr->usri1_name, sAdminUserName);
2331 usr->usri1_comment[0] = 0;
2332 usr->usri1_flags = UF_SCRIPT | UF_NORMAL_ACCOUNT | UF_DONT_EXPIRE_PASSWD;
2333 usr->usri1_full_name[0] = 0;
2334 usr->usri1_user_id = DOMAIN_USER_RID_ADMIN;
2335 usr->usri1_next_index = 0;
2336 }
2337
2338 /************************************************************
2339 * ACCESS_QueryGuestDisplayInformation
2340 *
2341 * Creates a buffer with information for the Guest User
2342 */
2343 static void ACCESS_QueryGuestDisplayInformation(PNET_DISPLAY_USER *buf, PDWORD pdwSize)
2344 {
2345 static const WCHAR sGuestUserName[] = {
2346 'G','u','e','s','t',0 };
2347
2348 /* sizes of the field buffers in WCHARS */
2349 int name_sz, comment_sz, full_name_sz;
2350 PNET_DISPLAY_USER usr;
2351
2352 /* set up buffer */
2353 name_sz = lstrlenW(sGuestUserName) + 1;
2354 comment_sz = 1;
2355 full_name_sz = 1;
2356
2357 *pdwSize = sizeof(NET_DISPLAY_USER);
2358 *pdwSize += (name_sz + comment_sz + full_name_sz) * sizeof(WCHAR);
2359 NetApiBufferAllocate(*pdwSize, (LPVOID *) buf);
2360
2361 usr = *buf;
2362 usr->usri1_name = (LPWSTR) ((PBYTE) usr + sizeof(NET_DISPLAY_USER));
2363 usr->usri1_comment = (LPWSTR) (
2364 ((PBYTE) usr->usri1_name) + name_sz * sizeof(WCHAR));
2365 usr->usri1_full_name = (LPWSTR) (
2366 ((PBYTE) usr->usri1_comment) + comment_sz * sizeof(WCHAR));
2367
2368 /* set data */
2369 lstrcpyW(usr->usri1_name, sGuestUserName);
2370 usr->usri1_comment[0] = 0;
2371 usr->usri1_flags = UF_ACCOUNTDISABLE | UF_SCRIPT | UF_NORMAL_ACCOUNT |
2372 UF_DONT_EXPIRE_PASSWD;
2373 usr->usri1_full_name[0] = 0;
2374 usr->usri1_user_id = DOMAIN_USER_RID_GUEST;
2375 usr->usri1_next_index = 0;
2376 }
2377
2378 /************************************************************
2379 * Copies NET_DISPLAY_USER record.
2380 */
2381 static void ACCESS_CopyDisplayUser(const NET_DISPLAY_USER *dest, LPWSTR *dest_buf,
2382 PNET_DISPLAY_USER src)
2383 {
2384 LPWSTR str = *dest_buf;
2385
2386 src->usri1_name = str;
2387 lstrcpyW(src->usri1_name, dest->usri1_name);
2388 str = (LPWSTR) (
2389 ((PBYTE) str) + (lstrlenW(str) + 1) * sizeof(WCHAR));
2390
2391 src->usri1_comment = str;
2392 lstrcpyW(src->usri1_comment, dest->usri1_comment);
2393 str = (LPWSTR) (
2394 ((PBYTE) str) + (lstrlenW(str) + 1) * sizeof(WCHAR));
2395
2396 src->usri1_flags = dest->usri1_flags;
2397
2398 src->usri1_full_name = str;
2399 lstrcpyW(src->usri1_full_name, dest->usri1_full_name);
2400 str = (LPWSTR) (
2401 ((PBYTE) str) + (lstrlenW(str) + 1) * sizeof(WCHAR));
2402
2403 src->usri1_user_id = dest->usri1_user_id;
2404 src->usri1_next_index = dest->usri1_next_index;
2405 *dest_buf = str;
2406 }
2407
2408 /************************************************************
2409 * NetQueryDisplayInformation (NETAPI32.@)
2410 *
2411 * The buffer structure:
2412 * - array of fixed size record of the level type
2413 * - strings, referenced by the record of the level type
2414 */
2415 NET_API_STATUS WINAPI
2416 NetQueryDisplayInformation(
2417 LPCWSTR ServerName, DWORD Level, DWORD Index, DWORD EntriesRequested,
2418 DWORD PreferredMaximumLength, LPDWORD ReturnedEntryCount,
2419 PVOID *SortedBuffer)
2420 {
2421 TRACE("(%s, %d, %d, %d, %d, %p, %p)\n", debugstr_w(ServerName),
2422 Level, Index, EntriesRequested, PreferredMaximumLength,
2423 ReturnedEntryCount, SortedBuffer);
2424
2425 if(!NETAPI_IsLocalComputer(ServerName))
2426 {
2427 FIXME("Only implemented on local computer, but requested for "
2428 "remote server %s\n", debugstr_w(ServerName));
2429 return ERROR_ACCESS_DENIED;
2430 }
2431
2432 switch (Level)
2433 {
2434 case 1:
2435 {
2436 /* current record */
2437 PNET_DISPLAY_USER inf;
2438 /* current available strings buffer */
2439 LPWSTR str;
2440 PNET_DISPLAY_USER admin, guest;
2441 DWORD admin_size, guest_size;
2442 LPWSTR name = NULL;
2443 DWORD dwSize;
2444
2445 /* sizes of the field buffers in WCHARS */
2446 int name_sz, comment_sz, full_name_sz;
2447
2448 /* number of the records, returned in SortedBuffer
2449 3 - for current user, Administrator and Guest users
2450 */
2451 int records = 3;
2452
2453 FIXME("Level %d partially implemented\n", Level);
2454 *ReturnedEntryCount = records;
2455 comment_sz = 1;
2456 full_name_sz = 1;
2457
2458 /* get data */
2459 dwSize = UNLEN + 1;
2460 NetApiBufferAllocate(dwSize * sizeof(WCHAR), (LPVOID *) &name);
2461 if (!GetUserNameW(name, &dwSize))
2462 {
2463 NetApiBufferFree(name);
2464 return ERROR_ACCESS_DENIED;
2465 }
2466 name_sz = dwSize;
2467 ACCESS_QueryAdminDisplayInformation(&admin, &admin_size);
2468 ACCESS_QueryGuestDisplayInformation(&guest, &guest_size);
2469
2470 /* set up buffer */
2471 dwSize = sizeof(NET_DISPLAY_USER) * records;
2472 dwSize += (name_sz + comment_sz + full_name_sz) * sizeof(WCHAR);
2473
2474 NetApiBufferAllocate(dwSize +
2475 admin_size - sizeof(NET_DISPLAY_USER) +
2476 guest_size - sizeof(NET_DISPLAY_USER),
2477 SortedBuffer);
2478 inf = *SortedBuffer;
2479 str = (LPWSTR) ((PBYTE) inf + sizeof(NET_DISPLAY_USER) * records);
2480 inf->usri1_name = str;
2481 str = (LPWSTR) (
2482 ((PBYTE) str) + name_sz * sizeof(WCHAR));
2483 inf->usri1_comment = str;
2484 str = (LPWSTR) (
2485 ((PBYTE) str) + comment_sz * sizeof(WCHAR));
2486 inf->usri1_full_name = str;
2487 str = (LPWSTR) (
2488 ((PBYTE) str) + full_name_sz * sizeof(WCHAR));
2489
2490 /* set data */
2491 lstrcpyW(inf->usri1_name, name);
2492 NetApiBufferFree(name);
2493 inf->usri1_comment[0] = 0;
2494 inf->usri1_flags =
2495 UF_SCRIPT | UF_NORMAL_ACCOUNT | UF_DONT_EXPIRE_PASSWD;
2496 inf->usri1_full_name[0] = 0;
2497 inf->usri1_user_id = 0;
2498 inf->usri1_next_index = 0;
2499
2500 inf++;
2501 ACCESS_CopyDisplayUser(admin, &str, inf);
2502 NetApiBufferFree(admin);
2503
2504 inf++;
2505 ACCESS_CopyDisplayUser(guest, &str, inf);
2506 NetApiBufferFree(guest);
2507 break;
2508 }
2509
2510 case 2:
2511 case 3:
2512 {
2513 FIXME("Level %d is not implemented\n", Level);
2514 break;
2515 }
2516
2517 default:
2518 TRACE("Invalid level %d is specified\n", Level);
2519 return ERROR_INVALID_LEVEL;
2520 }
2521 return NERR_Success;
2522 }
2523
2524 /************************************************************
2525 * NetGetDCName (NETAPI32.@)
2526 *
2527 * Return the name of the primary domain controller (PDC)
2528 */
2529
2530 NET_API_STATUS WINAPI
2531 NetGetDCName(LPCWSTR servername, LPCWSTR domainname, LPBYTE *bufptr)
2532 {
2533 FIXME("(%s, %s, %p) stub!\n", debugstr_w(servername),
2534 debugstr_w(domainname), bufptr);
2535 return NERR_DCNotFound; /* say we can't find a domain controller */
2536 }
2537
2538 /************************************************************
2539 * NetGetAnyDCName (NETAPI32.@)
2540 *
2541 * Return the name of any domain controller (DC) for a
2542 * domain that is directly trusted by the specified server
2543 */
2544
2545 NET_API_STATUS WINAPI NetGetAnyDCName(LPCWSTR servername, LPCWSTR domainname, LPBYTE *bufptr)
2546 {
2547 FIXME("(%s, %s, %p) stub!\n", debugstr_w(servername),
2548 debugstr_w(domainname), bufptr);
2549 return ERROR_NO_SUCH_DOMAIN;
2550 }
2551
2552 /************************************************************
2553 * NetGroupEnum (NETAPI32.@)
2554 *
2555 */
2556 NET_API_STATUS WINAPI
2557 NetGroupEnum(LPCWSTR servername, DWORD level, LPBYTE *bufptr, DWORD prefmaxlen,
2558 LPDWORD entriesread, LPDWORD totalentries, LPDWORD resume_handle)
2559 {
2560 FIXME("(%s, %d, %p, %d, %p, %p, %p) stub!\n", debugstr_w(servername),
2561 level, bufptr, prefmaxlen, entriesread, totalentries, resume_handle);
2562 return ERROR_ACCESS_DENIED;
2563 }
2564
2565 /************************************************************
2566 * NetGroupGetInfo (NETAPI32.@)
2567 *
2568 */
2569 NET_API_STATUS WINAPI NetGroupGetInfo(LPCWSTR servername, LPCWSTR groupname, DWORD level, LPBYTE *bufptr)
2570 {
2571 FIXME("(%s, %s, %d, %p) stub!\n", debugstr_w(servername), debugstr_w(groupname), level, bufptr);
2572 return ERROR_ACCESS_DENIED;
2573 }
2574
2575 /******************************************************************************
2576 * NetUserModalsGet (NETAPI32.@)
2577 *
2578 * Retrieves global information for all users and global groups in the security
2579 * database.
2580 *
2581 * PARAMS
2582 * szServer [I] Specifies the DNS or the NetBIOS name of the remote server
2583 * on which the function is to execute.
2584 * level [I] Information level of the data.
2585 * 0 Return global passwords parameters. bufptr points to a
2586 * USER_MODALS_INFO_0 struct.
2587 * 1 Return logon server and domain controller information. bufptr
2588 * points to a USER_MODALS_INFO_1 struct.
2589 * 2 Return domain name and identifier. bufptr points to a
2590 * USER_MODALS_INFO_2 struct.
2591 * 3 Return lockout information. bufptr points to a USER_MODALS_INFO_3
2592 * struct.
2593 * pbuffer [I] Buffer that receives the data.
2594 *
2595 * RETURNS
2596 * Success: NERR_Success.
2597 * Failure:
2598 * ERROR_ACCESS_DENIED - the user does not have access to the info.
2599 * NERR_InvalidComputer - computer name is invalid.
2600 */
2601 NET_API_STATUS WINAPI NetUserModalsGet(
2602 LPCWSTR szServer, DWORD level, LPBYTE *pbuffer)
2603 {
2604 TRACE("(%s %d %p)\n", debugstr_w(szServer), level, pbuffer);
2605
2606 switch (level)
2607 {
2608 case 0:
2609 /* return global passwords parameters */
2610 FIXME("level 0 not implemented!\n");
2611 *pbuffer = NULL;
2612 return NERR_InternalError;
2613 case 1:
2614 /* return logon server and domain controller info */
2615 FIXME("level 1 not implemented!\n");
2616 *pbuffer = NULL;
2617 return NERR_InternalError;
2618 case 2:
2619 {
2620 /* return domain name and identifier */
2621 PUSER_MODALS_INFO_2 umi;
2622 LSA_HANDLE policyHandle;
2623 LSA_OBJECT_ATTRIBUTES objectAttributes;
2624 PPOLICY_ACCOUNT_DOMAIN_INFO domainInfo;
2625 NTSTATUS ntStatus;
2626 PSID domainIdentifier = NULL;
2627 int domainNameLen;
2628
2629 ZeroMemory(&objectAttributes, sizeof(objectAttributes));
2630 objectAttributes.Length = sizeof(objectAttributes);
2631
2632 ntStatus = LsaOpenPolicy(NULL, &objectAttributes,
2633 POLICY_VIEW_LOCAL_INFORMATION,
2634 &policyHandle);
2635 if (ntStatus != STATUS_SUCCESS)
2636 {
2637 WARN("LsaOpenPolicy failed with NT status %x\n",
2638 LsaNtStatusToWinError(ntStatus));
2639 return ntStatus;
2640 }
2641
2642 ntStatus = LsaQueryInformationPolicy(policyHandle,
2643 PolicyAccountDomainInformation,
2644 (PVOID *)&domainInfo);
2645 if (ntStatus != STATUS_SUCCESS)
2646 {
2647 WARN("LsaQueryInformationPolicy failed with NT status %x\n",
2648 LsaNtStatusToWinError(ntStatus));
2649 LsaClose(policyHandle);
2650 return ntStatus;
2651 }
2652
2653 domainIdentifier = domainInfo->DomainSid;
2654 domainNameLen = lstrlenW(domainInfo->DomainName.Buffer) + 1;
2655 LsaClose(policyHandle);
2656
2657 ntStatus = NetApiBufferAllocate(sizeof(USER_MODALS_INFO_2) +
2658 GetLengthSid(domainIdentifier) +
2659 domainNameLen * sizeof(WCHAR),
2660 (LPVOID *)pbuffer);
2661
2662 if (ntStatus != NERR_Success)
2663 {
2664 WARN("NetApiBufferAllocate() failed\n");
2665 LsaFreeMemory(domainInfo);
2666 return ntStatus;
2667 }
2668
2669 umi = (USER_MODALS_INFO_2 *) *pbuffer;
2670 umi->usrmod2_domain_id = *pbuffer + sizeof(USER_MODALS_INFO_2);
2671 umi->usrmod2_domain_name = (LPWSTR)(*pbuffer +
2672 sizeof(USER_MODALS_INFO_2) + GetLengthSid(domainIdentifier));
2673
2674 lstrcpynW(umi->usrmod2_domain_name,
2675 domainInfo->DomainName.Buffer,
2676 domainNameLen);
2677 CopySid(GetLengthSid(domainIdentifier), umi->usrmod2_domain_id,
2678 domainIdentifier);
2679
2680 LsaFreeMemory(domainInfo);
2681
2682 break;
2683 }
2684 case 3:
2685 /* return lockout information */
2686 FIXME("level 3 not implemented!\n");
2687 *pbuffer = NULL;
2688 return NERR_InternalError;
2689 default:
2690 TRACE("Invalid level %d is specified\n", level);
2691 *pbuffer = NULL;
2692 return ERROR_INVALID_LEVEL;
2693 }
2694
2695 return NERR_Success;
2696 }
2697
2698 static NET_API_STATUS change_password_smb( LPCWSTR domainname, LPCWSTR username,
2699 LPCWSTR oldpassword, LPCWSTR newpassword )
2700 {
2701 #ifdef HAVE_FORK
2702 NET_API_STATUS ret = NERR_Success;
2703 static char option_silent[] = "-s";
2704 static char option_user[] = "-U";
2705 static char option_remote[] = "-r";
2706 static char smbpasswd[] = "smbpasswd";
2707 int pipe_out[2];
2708 pid_t pid, wret;
2709 int status;
2710 char *server = NULL, *user, *argv[7], *old = NULL, *new = NULL;
2711
2712 if (domainname && !(server = strdup_unixcp( domainname ))) return ERROR_OUTOFMEMORY;
2713 if (!(user = strdup_unixcp( username )))
2714 {
2715 ret = ERROR_OUTOFMEMORY;
2716 goto end;
2717 }
2718 if (!(old = strdup_unixcp( oldpassword )))
2719 {
2720 ret = ERROR_OUTOFMEMORY;
2721 goto end;
2722 }
2723 if (!(new = strdup_unixcp( newpassword )))
2724 {
2725 ret = ERROR_OUTOFMEMORY;
2726 goto end;
2727 }
2728 argv[0] = smbpasswd;
2729 argv[1] = option_silent;
2730 argv[2] = option_user;
2731 argv[3] = user;
2732 if (server)
2733 {
2734 argv[4] = option_remote;
2735 argv[5] = server;
2736 argv[6] = NULL;
2737 }
2738 else argv[4] = NULL;
2739
2740 if (pipe( pipe_out ) == -1)
2741 {
2742 ret = NERR_InternalError;
2743 goto end;
2744 }
2745 fcntl( pipe_out[0], F_SETFD, FD_CLOEXEC );
2746 fcntl( pipe_out[1], F_SETFD, FD_CLOEXEC );
2747
2748 switch ((pid = fork()))
2749 {
2750 case -1:
2751 close( pipe_out[0] );
2752 close( pipe_out[1] );
2753 ret = NERR_InternalError;
2754 goto end;
2755 case 0:
2756 dup2( pipe_out[0], 0 );
2757 close( pipe_out[0] );
2758 close( pipe_out[1] );
2759 execvp( "smbpasswd", argv );
2760 ERR( "can't execute smbpasswd, is it installed?\n" );
2761 _exit(1);
2762 default:
2763 close( pipe_out[0] );
2764 break;
2765 }
2766 write( pipe_out[1], old, strlen( old ) );
2767 write( pipe_out[1], "\n", 1 );
2768 write( pipe_out[1], new, strlen( new ) );
2769 write( pipe_out[1], "\n", 1 );
2770 write( pipe_out[1], new, strlen( new ) );
2771 write( pipe_out[1], "\n", 1 );
2772 close( pipe_out[1] );
2773
2774 do {
2775 wret = waitpid(pid, &status, 0);
2776 } while (wret < 0 && errno == EINTR);
2777
2778 if (ret == NERR_Success && (wret < 0 || !WIFEXITED(status) || WEXITSTATUS(status)))
2779 ret = NERR_InternalError;
2780
2781 end:
2782 HeapFree( GetProcessHeap(), 0, server );
2783 HeapFree( GetProcessHeap(), 0, user );
2784 HeapFree( GetProcessHeap(), 0, old );
2785 HeapFree( GetProcessHeap(), 0, new );
2786 return ret;
2787 #else
2788 ERR( "no fork support on this platform\n" );
2789 return NERR_InternalError;
2790 #endif
2791 }
2792
2793 /******************************************************************************
2794 * NetUserChangePassword (NETAPI32.@)
2795 * PARAMS
2796 * domainname [I] Optional. Domain on which the user resides or the logon
2797 * domain of the current user if NULL.
2798 * username [I] Optional. Username to change the password for or the name
2799 * of the current user if NULL.
2800 * oldpassword [I] The user's current password.
2801 * newpassword [I] The password that the user will be changed to using.
2802 *
2803 * RETURNS
2804 * Success: NERR_Success.
2805 * Failure: NERR_* failure code or win error code.
2806 *
2807 */
2808 NET_API_STATUS WINAPI NetUserChangePassword(LPCWSTR domainname, LPCWSTR username,
2809 LPCWSTR oldpassword, LPCWSTR newpassword)
2810 {
2811 struct sam_user *user;
2812
2813 TRACE("(%s, %s, ..., ...)\n", debugstr_w(domainname), debugstr_w(username));
2814
2815 if (!change_password_smb( domainname, username, oldpassword, newpassword ))
2816 return NERR_Success;
2817
2818 if(domainname)
2819 FIXME("Ignoring domainname %s.\n", debugstr_w(domainname));
2820
2821 if((user = NETAPI_FindUser(username)) == NULL)
2822 return NERR_UserNotFound;
2823
2824 if(lstrcmpW(user->user_password, oldpassword) != 0)
2825 return ERROR_INVALID_PASSWORD;
2826
2827 if(lstrlenW(newpassword) > PWLEN)
2828 return ERROR_PASSWORD_RESTRICTION;
2829
2830 lstrcpyW(user->user_password, newpassword);
2831
2832 return NERR_Success;
2833 }
2834
2835 NET_API_STATUS WINAPI NetUseAdd(LMSTR servername, DWORD level, LPBYTE bufptr, LPDWORD parm_err)
2836 {
2837 FIXME("%s %d %p %p stub\n", debugstr_w(servername), level, bufptr, parm_err);
2838 return NERR_Success;
2839 }
2840
2841 NET_API_STATUS WINAPI NetUseDel(LMSTR servername, LMSTR usename, DWORD forcecond)
2842 {
2843 FIXME("%s %s %d stub\n", debugstr_w(servername), debugstr_w(usename), forcecond);
2844 return NERR_Success;
2845 }
2846
2847 /************************************************************
2848 * I_BrowserSetNetlogonState (NETAPI32.@)
2849 */
2850 NET_API_STATUS WINAPI I_BrowserSetNetlogonState(
2851 LPWSTR ServerName, LPWSTR DomainName, LPWSTR EmulatedServerName,
2852 DWORD Role)
2853 {
2854 return ERROR_NOT_SUPPORTED;
2855 }
2856
2857 /************************************************************
2858 * I_BrowserQueryEmulatedDomains (NETAPI32.@)
2859 */
2860 NET_API_STATUS WINAPI I_BrowserQueryEmulatedDomains(
2861 LPWSTR ServerName, PBROWSER_EMULATED_DOMAIN *EmulatedDomains,
2862 LPDWORD EntriesRead)
2863 {
2864 return ERROR_NOT_SUPPORTED;
2865 }
2866
2867 DWORD WINAPI DsGetDcNameW(LPCWSTR ComputerName, LPCWSTR AvoidDCName,
2868 GUID* DomainGuid, LPCWSTR SiteName, ULONG Flags,
2869 PDOMAIN_CONTROLLER_INFOW *DomainControllerInfo)
2870 {
2871 FIXME("(%s, %s, %s, %s, %08x, %p): stub\n", debugstr_w(ComputerName),
2872 debugstr_w(AvoidDCName), debugstr_guid(DomainGuid),
2873 debugstr_w(SiteName), Flags, DomainControllerInfo);
2874 return ERROR_CALL_NOT_IMPLEMENTED;
2875 }
2876
2877 DWORD WINAPI DsGetDcNameA(LPCSTR ComputerName, LPCSTR AvoidDCName,
2878 GUID* DomainGuid, LPCSTR SiteName, ULONG Flags,
2879 PDOMAIN_CONTROLLER_INFOA *DomainControllerInfo)
2880 {
2881 FIXME("(%s, %s, %s, %s, %08x, %p): stub\n", debugstr_a(ComputerName),
2882 debugstr_a(AvoidDCName), debugstr_guid(DomainGuid),
2883 debugstr_a(SiteName), Flags, DomainControllerInfo);
2884 return ERROR_CALL_NOT_IMPLEMENTED;
2885 }
2886
2887 DWORD WINAPI DsGetSiteNameW(LPCWSTR ComputerName, LPWSTR *SiteName)
2888 {
2889 FIXME("(%s, %p): stub\n", debugstr_w(ComputerName), SiteName);
2890 return ERROR_CALL_NOT_IMPLEMENTED;
2891 }
2892
2893 DWORD WINAPI DsGetSiteNameA(LPCSTR ComputerName, LPSTR *SiteName)
2894 {
2895 FIXME("(%s, %p): stub\n", debugstr_a(ComputerName), SiteName);
2896 return ERROR_CALL_NOT_IMPLEMENTED;
2897 }
2898
2899 /************************************************************
2900 * DsRoleFreeMemory (NETAPI32.@)
2901 *
2902 * PARAMS
2903 * Buffer [I] Pointer to the to-be-freed buffer.
2904 *
2905 * RETURNS
2906 * Nothing
2907 */
2908 VOID WINAPI DsRoleFreeMemory(PVOID Buffer)
2909 {
2910 TRACE("(%p)\n", Buffer);
2911 HeapFree(GetProcessHeap(), 0, Buffer);
2912 }
2913
2914 /************************************************************
2915 * DsRoleGetPrimaryDomainInformation (NETAPI32.@)
2916 *
2917 * PARAMS
2918 * lpServer [I] Pointer to UNICODE string with ComputerName
2919 * InfoLevel [I] Type of data to retrieve
2920 * Buffer [O] Pointer to to the requested data
2921 *
2922 * RETURNS
2923 *
2924 * NOTES
2925 * When lpServer is NULL, use the local computer
2926 */
2927 DWORD WINAPI DsRoleGetPrimaryDomainInformation(
2928 LPCWSTR lpServer, DSROLE_PRIMARY_DOMAIN_INFO_LEVEL InfoLevel,
2929 PBYTE* Buffer)
2930 {
2931 DWORD ret;
2932
2933 FIXME("(%p, %d, %p) stub\n", lpServer, InfoLevel, Buffer);
2934
2935 /* Check some input parameters */
2936
2937 if (!Buffer) return ERROR_INVALID_PARAMETER;
2938 if ((InfoLevel < DsRolePrimaryDomainInfoBasic) || (InfoLevel > DsRoleOperationState)) return ERROR_INVALID_PARAMETER;
2939
2940 *Buffer = NULL;
2941 switch (InfoLevel)
2942 {
2943 case DsRolePrimaryDomainInfoBasic:
2944 {
2945 LSA_OBJECT_ATTRIBUTES ObjectAttributes;
2946 LSA_HANDLE PolicyHandle;
2947 PPOLICY_ACCOUNT_DOMAIN_INFO DomainInfo;
2948 NTSTATUS NtStatus;
2949 int logon_domain_sz;
2950 DWORD size;
2951 PDSROLE_PRIMARY_DOMAIN_INFO_BASIC basic;
2952
2953 ZeroMemory(&ObjectAttributes, sizeof(ObjectAttributes));
2954 NtStatus = LsaOpenPolicy(NULL, &ObjectAttributes,
2955 POLICY_VIEW_LOCAL_INFORMATION, &PolicyHandle);
2956 if (NtStatus != STATUS_SUCCESS)
2957 {
2958 TRACE("LsaOpenPolicyFailed with NT status %x\n",
2959 LsaNtStatusToWinError(NtStatus));
2960 return ERROR_OUTOFMEMORY;
2961 }
2962 LsaQueryInformationPolicy(PolicyHandle,
2963 PolicyAccountDomainInformation, (PVOID*)&DomainInfo);
2964 logon_domain_sz = lstrlenW(DomainInfo->DomainName.Buffer) + 1;
2965 LsaClose(PolicyHandle);
2966
2967 size = sizeof(DSROLE_PRIMARY_DOMAIN_INFO_BASIC) +
2968 logon_domain_sz * sizeof(WCHAR);
2969 basic = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, size);
2970 if (basic)
2971 {
2972 basic->MachineRole = DsRole_RoleStandaloneWorkstation;
2973 basic->DomainNameFlat = (LPWSTR)((LPBYTE)basic +
2974 sizeof(DSROLE_PRIMARY_DOMAIN_INFO_BASIC));
2975 lstrcpyW(basic->DomainNameFlat, DomainInfo->DomainName.Buffer);
2976 ret = ERROR_SUCCESS;
2977 }
2978 else
2979 ret = ERROR_OUTOFMEMORY;
2980 *Buffer = (PBYTE)basic;
2981 LsaFreeMemory(DomainInfo);
2982 }
2983 break;
2984 default:
2985 ret = ERROR_CALL_NOT_IMPLEMENTED;
2986 }
2987 return ret;
2988 }
2989
2990 /************************************************************
2991 * NetLocalGroupAdd (NETAPI32.@)
2992 */
2993 NET_API_STATUS WINAPI NetLocalGroupAdd(
2994 LPCWSTR servername,
2995 DWORD level,
2996 LPBYTE buf,
2997 LPDWORD parm_err)
2998 {
2999 FIXME("(%s %d %p %p) stub!\n", debugstr_w(servername), level, buf,
3000 parm_err);
3001 return NERR_Success;
3002 }
3003
3004 /************************************************************
3005 * NetLocalGroupAddMember (NETAPI32.@)
3006 */
3007 NET_API_STATUS WINAPI NetLocalGroupAddMember(
3008 LPCWSTR servername,
3009 LPCWSTR groupname,
3010 PSID membersid)
3011 {
3012 FIXME("(%s %s %p) stub!\n", debugstr_w(servername),
3013 debugstr_w(groupname), membersid);
3014 return NERR_Success;
3015 }
3016
3017 /************************************************************
3018 * NetLocalGroupAddMembers (NETAPI32.@)
3019 */
3020 NET_API_STATUS WINAPI NetLocalGroupAddMembers(
3021 LPCWSTR servername,
3022 LPCWSTR groupname,
3023 DWORD level,
3024 LPBYTE buf,
3025 DWORD totalentries)
3026 {
3027 FIXME("(%s %s %d %p %d) stub!\n", debugstr_w(servername),
3028 debugstr_w(groupname), level, buf, totalentries);
3029 return NERR_Success;
3030 }
3031
3032 /************************************************************
3033 * NetLocalGroupDel (NETAPI32.@)
3034 */
3035 NET_API_STATUS WINAPI NetLocalGroupDel(
3036 LPCWSTR servername,
3037 LPCWSTR groupname)
3038 {
3039 FIXME("(%s %s) stub!\n", debugstr_w(servername), debugstr_w(groupname));
3040 return NERR_Success;
3041 }
3042
3043 /************************************************************
3044 * NetLocalGroupDelMember (NETAPI32.@)
3045 */
3046 NET_API_STATUS WINAPI NetLocalGroupDelMember(
3047 LPCWSTR servername,
3048 LPCWSTR groupname,
3049 PSID membersid)
3050 {
3051 FIXME("(%s %s %p) stub!\n", debugstr_w(servername),
3052 debugstr_w(groupname), membersid);
3053 return NERR_Success;
3054 }
3055
3056 /************************************************************
3057 * NetLocalGroupDelMembers (NETAPI32.@)
3058 */
3059 NET_API_STATUS WINAPI NetLocalGroupDelMembers(
3060 LPCWSTR servername,
3061 LPCWSTR groupname,
3062 DWORD level,
3063 LPBYTE buf,
3064 DWORD totalentries)
3065 {
3066 FIXME("(%s %s %d %p %d) stub!\n", debugstr_w(servername),
3067 debugstr_w(groupname), level, buf, totalentries);
3068 return NERR_Success;
3069 }
3070
3071 /************************************************************
3072 * NetLocalGroupEnum (NETAPI32.@)
3073 */
3074 NET_API_STATUS WINAPI NetLocalGroupEnum(
3075 LPCWSTR servername,
3076 DWORD level,
3077 LPBYTE* bufptr,
3078 DWORD prefmaxlen,
3079 LPDWORD entriesread,
3080 LPDWORD totalentries,
3081 PDWORD_PTR resumehandle)
3082 {
3083 FIXME("(%s %d %p %d %p %p %p) stub!\n", debugstr_w(servername),
3084 level, bufptr, prefmaxlen, entriesread, totalentries, resumehandle);
3085 *entriesread = 0;
3086 *totalentries = 0;
3087 return NERR_Success;
3088 }
3089
3090 /************************************************************
3091 * NetLocalGroupGetInfo (NETAPI32.@)
3092 */
3093 NET_API_STATUS WINAPI NetLocalGroupGetInfo(
3094 LPCWSTR servername,
3095 LPCWSTR groupname,
3096 DWORD level,
3097 LPBYTE* bufptr)
3098 {
3099 static const WCHAR commentW[]={'N','o',' ','c','o','m','m','e','n','t',0};
3100 LOCALGROUP_INFO_1* info;
3101 DWORD size;
3102
3103 FIXME("(%s %s %d %p) semi-stub!\n", debugstr_w(servername),
3104 debugstr_w(groupname), level, bufptr);
3105
3106 size = sizeof(*info) + sizeof(WCHAR) * (lstrlenW(groupname)+1) + sizeof(commentW);
3107 NetApiBufferAllocate(size, (LPVOID*)&info);
3108
3109 info->lgrpi1_name = (LPWSTR)(info + 1);
3110 lstrcpyW(info->lgrpi1_name, groupname);
3111
3112 info->lgrpi1_comment = info->lgrpi1_name + lstrlenW(groupname) + 1;
3113 lstrcpyW(info->lgrpi1_comment, commentW);
3114
3115 *bufptr = (LPBYTE)info;
3116
3117 return NERR_Success;
3118 }
3119
3120 /************************************************************
3121 * NetLocalGroupGetMembers (NETAPI32.@)
3122 */
3123 NET_API_STATUS WINAPI NetLocalGroupGetMembers(
3124 LPCWSTR servername,
3125 LPCWSTR localgroupname,
3126 DWORD level,
3127 LPBYTE* bufptr,
3128 DWORD prefmaxlen,
3129 LPDWORD entriesread,
3130 LPDWORD totalentries,
3131 PDWORD_PTR resumehandle)
3132 {
3133 FIXME("(%s %s %d %p %d, %p %p %p) stub!\n", debugstr_w(servername),
3134 debugstr_w(localgroupname), level, bufptr, prefmaxlen, entriesread,
3135 totalentries, resumehandle);
3136
3137 if (level == 3)
3138 {
3139 WCHAR userName[MAX_COMPUTERNAME_LENGTH + 1];
3140 DWORD userNameLen;
3141 DWORD len,needlen;
3142 PLOCALGROUP_MEMBERS_INFO_3 ptr;
3143
3144 /* still a stub, current user is belonging to all groups */
3145
3146 *totalentries = 1;
3147 *entriesread = 0;
3148
3149 userNameLen = MAX_COMPUTERNAME_LENGTH + 1;
3150 if (!GetUserNameW(userName,&userNameLen))
3151 return ERROR_NOT_ENOUGH_MEMORY;
3152
3153 needlen = sizeof(LOCALGROUP_MEMBERS_INFO_3) +
3154 (userNameLen+2) * sizeof(WCHAR);
3155 if (prefmaxlen != MAX_PREFERRED_LENGTH)
3156 len = min(prefmaxlen,needlen);
3157 else
3158 len = needlen;
3159
3160 NetApiBufferAllocate(len, (LPVOID *) bufptr);
3161 if (len < needlen)
3162 return ERROR_MORE_DATA;
3163
3164 ptr = (PLOCALGROUP_MEMBERS_INFO_3)*bufptr;
3165 ptr->lgrmi3_domainandname = (LPWSTR)(*bufptr+sizeof(LOCALGROUP_MEMBERS_INFO_3));
3166 lstrcpyW(ptr->lgrmi3_domainandname,userName);
3167
3168 *entriesread = 1;
3169 }
3170
3171 return NERR_Success;
3172 }
3173
3174 /************************************************************
3175 * NetLocalGroupSetInfo (NETAPI32.@)
3176 */
3177 NET_API_STATUS WINAPI NetLocalGroupSetInfo(
3178 LPCWSTR servername,
3179 LPCWSTR groupname,
3180 DWORD level,
3181 LPBYTE buf,
3182 LPDWORD parm_err)
3183 {
3184 FIXME("(%s %s %d %p %p) stub!\n", debugstr_w(servername),
3185 debugstr_w(groupname), level, buf, parm_err);
3186 return NERR_Success;
3187 }
3188
3189 /************************************************************
3190 * NetLocalGroupSetMember (NETAPI32.@)
3191 */
3192 NET_API_STATUS WINAPI NetLocalGroupSetMembers(
3193 LPCWSTR servername,
3194 LPCWSTR groupname,
3195 DWORD level,
3196 LPBYTE buf,
3197 DWORD totalentries)
3198 {
3199 FIXME("(%s %s %d %p %d) stub!\n", debugstr_w(servername),
3200 debugstr_w(groupname), level, buf, totalentries);
3201 return NERR_Success;
3202 }
Windows API implementation