urlmon: Don't create stgmed_obj for binding to object.
[wine] / dlls / netapi32 / wksta.c
1 /* Copyright 2002 Andriy Palamarchuk
2  * Copyright (c) 2003 Juan Lang
3  *
4  * netapi32 user functions
5  *
6  * This library is free software; you can redistribute it and/or
7  * modify it under the terms of the GNU Lesser General Public
8  * License as published by the Free Software Foundation; either
9  * version 2.1 of the License, or (at your option) any later version.
10  *
11  * This library is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
14  * Lesser General Public License for more details.
15  *
16  * You should have received a copy of the GNU Lesser General Public
17  * License along with this library; if not, write to the Free Software
18  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
19  */
20
21 #include "config.h"
22 #include "wine/port.h"
23
24 #include <stdarg.h>
25 #include <stdlib.h>
26 #include "ntstatus.h"
27 #define WIN32_NO_STATUS
28 #include "windef.h"
29 #include "winbase.h"
30 #include "winsock2.h"
31 #include "nb30.h"
32 #include "lmcons.h"
33 #include "lmapibuf.h"
34 #include "lmerr.h"
35 #include "lmwksta.h"
36 #include "iphlpapi.h"
37 #include "winerror.h"
38 #include "ntsecapi.h"
39 #include "netbios.h"
40 #include "wine/debug.h"
41
42 WINE_DEFAULT_DEBUG_CHANNEL(netapi32);
43
44 /************************************************************
45  *                NETAPI_IsLocalComputer
46  *
47  * Checks whether the server name indicates local machine.
48  */
49 BOOL NETAPI_IsLocalComputer(LMCSTR ServerName)
50 {
51     if (!ServerName)
52     {
53         return TRUE;
54     }
55     else if (ServerName[0] == '\0')
56         return TRUE;
57     else
58     {
59         DWORD dwSize = MAX_COMPUTERNAME_LENGTH + 1;
60         BOOL Result;
61         LPWSTR buf;
62
63         NetApiBufferAllocate(dwSize * sizeof(WCHAR), (LPVOID *) &buf);
64         Result = GetComputerNameW(buf,  &dwSize);
65         if (Result && (ServerName[0] == '\\') && (ServerName[1] == '\\'))
66             ServerName += 2;
67         Result = Result && !lstrcmpW(ServerName, buf);
68         NetApiBufferFree(buf);
69
70         return Result;
71     }
72 }
73
74 static void wprint_mac(WCHAR* buffer, int len, const MIB_IFROW *ifRow)
75 {
76     int i;
77     unsigned char val;
78
79     if (!buffer)
80         return;
81     if (len < 1)
82         return;
83     if (!ifRow)
84     {
85         *buffer = '\0';
86         return;
87     }
88
89     for (i = 0; i < ifRow->dwPhysAddrLen && 2 * i < len; i++)
90     {
91         val = ifRow->bPhysAddr[i];
92         if ((val >>4) >9)
93             buffer[2*i] = (WCHAR)((val >>4) + 'A' - 10);
94         else
95             buffer[2*i] = (WCHAR)((val >>4) + '0');
96         if ((val & 0xf ) >9)
97             buffer[2*i+1] = (WCHAR)((val & 0xf) + 'A' - 10);
98         else
99             buffer[2*i+1] = (WCHAR)((val & 0xf) + '0');
100     }
101     buffer[2*i]=(WCHAR)0;
102 }
103
104 /* Theoretically this could be too short, except that MS defines
105  * MAX_ADAPTER_NAME as 128, and MAX_INTERFACE_NAME_LEN as 256, and both
106  * represent a count of WCHARs, so even with an extroardinarily long header
107  * this will be plenty
108  */
109 #define MAX_TRANSPORT_NAME MAX_INTERFACE_NAME_LEN
110 #define MAX_TRANSPORT_ADDR 13
111
112 #define NBT_TRANSPORT_NAME_HEADER "\\Device\\NetBT_Tcpip_"
113 #define UNKNOWN_TRANSPORT_NAME_HEADER "\\Device\\UnknownTransport_"
114
115 static void wprint_name(WCHAR *buffer, int len, ULONG transport,
116  PMIB_IFROW ifRow)
117 {
118     WCHAR *ptr1, *ptr2;
119     const char *name;
120
121     if (!buffer)
122         return;
123     if (!ifRow)
124     {
125         *buffer = '\0';
126         return;
127     }
128
129     if (!memcmp(&transport, TRANSPORT_NBT, sizeof(ULONG)))
130         name = NBT_TRANSPORT_NAME_HEADER;
131     else
132         name = UNKNOWN_TRANSPORT_NAME_HEADER;
133
134     for (ptr1 = buffer; *name && ptr1 < buffer + len; ptr1++, name++)
135         *ptr1 = *name;
136     for (ptr2 = ifRow->wszName; *ptr2 && ptr1 < buffer + len; ptr1++, ptr2++)
137         *ptr1 = *ptr2;
138     *ptr1 = '\0';
139 }
140
141 /***********************************************************************
142  *                NetWkstaTransportEnum  (NETAPI32.@)
143  */
144  
145 struct WkstaTransportEnumData
146 {
147     UCHAR          n_adapt;
148     UCHAR          n_read;
149     DWORD          prefmaxlen;
150     LPBYTE        *pbuf;
151     NET_API_STATUS ret;
152 };
153
154 /**********************************************************************/
155
156 static BOOL WkstaEnumAdaptersCallback(UCHAR totalLANAs, UCHAR lanaIndex,
157  ULONG transport, const NetBIOSAdapterImpl *data, void *closure)
158 {
159     BOOL ret;
160     struct WkstaTransportEnumData *enumData = (struct WkstaTransportEnumData *)
161      closure;
162
163     if (enumData && enumData->pbuf)
164     {
165         if (lanaIndex == 0)
166         {
167             DWORD toAllocate;
168
169             enumData->n_adapt = totalLANAs;
170             enumData->n_read = 0;
171
172             toAllocate = totalLANAs * (sizeof(WKSTA_TRANSPORT_INFO_0)
173              + MAX_TRANSPORT_NAME * sizeof(WCHAR) +
174              MAX_TRANSPORT_ADDR * sizeof(WCHAR));
175             if (enumData->prefmaxlen != MAX_PREFERRED_LENGTH)
176                 toAllocate = enumData->prefmaxlen;
177             NetApiBufferAllocate(toAllocate, (LPVOID *)enumData->pbuf);
178         }
179         if (*(enumData->pbuf))
180         {
181             UCHAR spaceFor;
182
183             if (enumData->prefmaxlen == MAX_PREFERRED_LENGTH)
184                 spaceFor = totalLANAs;
185             else
186                 spaceFor = enumData->prefmaxlen /
187                  (sizeof(WKSTA_TRANSPORT_INFO_0) + (MAX_TRANSPORT_NAME +
188                  MAX_TRANSPORT_ADDR) * sizeof(WCHAR));
189             if (enumData->n_read < spaceFor)
190             {
191                 PWKSTA_TRANSPORT_INFO_0 ti;
192                 LMSTR transport_name, transport_addr;
193                 MIB_IFROW ifRow;
194
195                 ti = (PWKSTA_TRANSPORT_INFO_0)(*(enumData->pbuf) +
196                  enumData->n_read * sizeof(WKSTA_TRANSPORT_INFO_0));
197                 transport_name = (LMSTR)(*(enumData->pbuf) +
198                  totalLANAs * sizeof(WKSTA_TRANSPORT_INFO_0) +
199                  enumData->n_read * MAX_TRANSPORT_NAME * sizeof(WCHAR));
200                 transport_addr = (LMSTR)(*(enumData->pbuf) +
201                  totalLANAs * (sizeof(WKSTA_TRANSPORT_INFO_0) +
202                  MAX_TRANSPORT_NAME * sizeof(WCHAR)) +
203                  enumData->n_read * MAX_TRANSPORT_ADDR * sizeof(WCHAR));
204
205                 ifRow.dwIndex = data->ifIndex;
206                 GetIfEntry(&ifRow);
207                 ti->wkti0_quality_of_service = 0;
208                 ti->wkti0_number_of_vcs = 0;
209                 ti->wkti0_transport_name = transport_name;
210                 wprint_name(ti->wkti0_transport_name, MAX_TRANSPORT_NAME,
211                  transport, &ifRow);
212                 ti->wkti0_transport_address = transport_addr;
213                 wprint_mac(ti->wkti0_transport_address, MAX_TRANSPORT_ADDR,
214                  &ifRow);
215                 if (!memcmp(&transport, TRANSPORT_NBT, sizeof(ULONG)))
216                     ti->wkti0_wan_ish = TRUE;
217                 else
218                     ti->wkti0_wan_ish = FALSE;
219                 TRACE("%d of %d:ti at %p\n", lanaIndex, totalLANAs, ti);
220                 TRACE("transport_name at %p %s\n",
221                  ti->wkti0_transport_name,
222                  debugstr_w(ti->wkti0_transport_name));
223                 TRACE("transport_address at %p %s\n",
224                  ti->wkti0_transport_address,
225                  debugstr_w(ti->wkti0_transport_address));
226                 enumData->n_read++;
227                 enumData->ret = NERR_Success;
228                 ret = TRUE;
229             }
230             else
231             {
232                 enumData->ret = ERROR_MORE_DATA;
233                 ret = FALSE;
234             }
235         }
236         else
237         {
238             enumData->ret = ERROR_OUTOFMEMORY;
239             ret = FALSE;
240         }
241     }
242     else
243         ret = FALSE;
244     return ret;
245 }
246
247 /**********************************************************************/
248
249 NET_API_STATUS WINAPI 
250 NetWkstaTransportEnum(LMSTR ServerName, DWORD level, PBYTE* pbuf,
251       DWORD prefmaxlen, LPDWORD read_entries,
252       PDWORD total_entries, PDWORD hresume)
253 {
254     NET_API_STATUS ret;
255
256     TRACE(":%s, 0x%08x, %p, 0x%08x, %p, %p, %p\n", debugstr_w(ServerName), 
257      level, pbuf, prefmaxlen, read_entries, total_entries,hresume);
258     if (!NETAPI_IsLocalComputer(ServerName))
259     {
260         FIXME(":not implemented for non-local computers\n");
261         ret = ERROR_INVALID_LEVEL;
262     }
263     else
264     {
265         if (hresume && *hresume)
266         {
267           FIXME(":resume handle not implemented\n");
268           return ERROR_INVALID_LEVEL;
269         }
270
271         switch (level)
272         {
273             case 0: /* transport info */
274             {
275                 ULONG allTransports;
276                 struct WkstaTransportEnumData enumData;
277
278                 if (NetBIOSNumAdapters() == 0)
279                   return ERROR_NETWORK_UNREACHABLE;
280                 if (!read_entries)
281                   return STATUS_ACCESS_VIOLATION;
282                 if (!total_entries || !pbuf)
283                   return RPC_X_NULL_REF_POINTER;
284
285                 enumData.prefmaxlen = prefmaxlen;
286                 enumData.pbuf = pbuf;
287                 memcpy(&allTransports, ALL_TRANSPORTS, sizeof(ULONG));
288                 NetBIOSEnumAdapters(allTransports, WkstaEnumAdaptersCallback,
289                  &enumData);
290                 *read_entries = enumData.n_read;
291                 *total_entries = enumData.n_adapt;
292                 if (hresume) *hresume= 0;
293                 ret = enumData.ret;
294                 break;
295             }
296             default:
297                 TRACE("Invalid level %d is specified\n", level);
298                 ret = ERROR_INVALID_LEVEL;
299         }
300     }
301     return ret;
302 }
303
304
305 /************************************************************
306  *                NetWkstaUserGetInfo  (NETAPI32.@)
307  */
308 NET_API_STATUS WINAPI NetWkstaUserGetInfo(LMSTR reserved, DWORD level,
309                                           PBYTE* bufptr)
310 {
311     TRACE("(%s, %d, %p)\n", debugstr_w(reserved), level, bufptr);
312     switch (level)
313     {
314     case 0:
315     {
316         PWKSTA_USER_INFO_0 ui;
317         DWORD dwSize = UNLEN + 1;
318
319         /* set up buffer */
320         NetApiBufferAllocate(sizeof(WKSTA_USER_INFO_0) + dwSize * sizeof(WCHAR),
321                              (LPVOID *) bufptr);
322
323         ui = (PWKSTA_USER_INFO_0) *bufptr;
324         ui->wkui0_username = (LMSTR) (*bufptr + sizeof(WKSTA_USER_INFO_0));
325
326         /* get data */
327         if (!GetUserNameW(ui->wkui0_username, &dwSize))
328         {
329             NetApiBufferFree(ui);
330             return ERROR_NOT_ENOUGH_MEMORY;
331         }
332         else
333             NetApiBufferReallocate(
334                 *bufptr, sizeof(WKSTA_USER_INFO_0) +
335                 (lstrlenW(ui->wkui0_username) + 1) * sizeof(WCHAR),
336                 (LPVOID *) bufptr);
337         break;
338     }
339
340     case 1:
341     {
342         PWKSTA_USER_INFO_1 ui;
343         PWKSTA_USER_INFO_0 ui0;
344         DWORD dwSize;
345         LSA_OBJECT_ATTRIBUTES ObjectAttributes;
346         LSA_HANDLE PolicyHandle;
347         PPOLICY_ACCOUNT_DOMAIN_INFO DomainInfo;
348         NTSTATUS NtStatus;
349
350         /* sizes of the field buffers in WCHARS */
351         int username_sz, logon_domain_sz, oth_domains_sz, logon_server_sz;
352
353         FIXME("Level 1 processing is partially implemented\n");
354         oth_domains_sz = 1;
355         logon_server_sz = 1;
356
357         /* get some information first to estimate size of the buffer */
358         ui0 = NULL;
359         NetWkstaUserGetInfo(NULL, 0, (PBYTE *) &ui0);
360         username_sz = lstrlenW(ui0->wkui0_username) + 1;
361
362         ZeroMemory(&ObjectAttributes, sizeof(ObjectAttributes));
363         NtStatus = LsaOpenPolicy(NULL, &ObjectAttributes,
364                                  POLICY_VIEW_LOCAL_INFORMATION,
365                                  &PolicyHandle);
366         if (NtStatus != STATUS_SUCCESS)
367         {
368             TRACE("LsaOpenPolicyFailed with NT status %x\n",
369                 LsaNtStatusToWinError(NtStatus));
370             NetApiBufferFree(ui0);
371             return ERROR_NOT_ENOUGH_MEMORY;
372         }
373         LsaQueryInformationPolicy(PolicyHandle, PolicyAccountDomainInformation,
374                                   (PVOID*) &DomainInfo);
375         logon_domain_sz = lstrlenW(DomainInfo->DomainName.Buffer) + 1;
376         LsaClose(PolicyHandle);
377
378         /* set up buffer */
379         NetApiBufferAllocate(sizeof(WKSTA_USER_INFO_1) +
380                              (username_sz + logon_domain_sz +
381                               oth_domains_sz + logon_server_sz) * sizeof(WCHAR),
382                              (LPVOID *) bufptr);
383         ui = (WKSTA_USER_INFO_1 *) *bufptr;
384         ui->wkui1_username = (LMSTR) (*bufptr + sizeof(WKSTA_USER_INFO_1));
385         ui->wkui1_logon_domain = (LMSTR) (
386             ((PBYTE) ui->wkui1_username) + username_sz * sizeof(WCHAR));
387         ui->wkui1_oth_domains = (LMSTR) (
388             ((PBYTE) ui->wkui1_logon_domain) +
389             logon_domain_sz * sizeof(WCHAR));
390         ui->wkui1_logon_server = (LMSTR) (
391             ((PBYTE) ui->wkui1_oth_domains) +
392             oth_domains_sz * sizeof(WCHAR));
393
394         /* get data */
395         dwSize = username_sz;
396         lstrcpyW(ui->wkui1_username, ui0->wkui0_username);
397         NetApiBufferFree(ui0);
398
399         lstrcpynW(ui->wkui1_logon_domain, DomainInfo->DomainName.Buffer,
400                 logon_domain_sz);
401         LsaFreeMemory(DomainInfo);
402
403         /* FIXME. Not implemented. Populated with empty strings */
404         ui->wkui1_oth_domains[0] = 0;
405         ui->wkui1_logon_server[0] = 0;
406         break;
407     }
408     case 1101:
409     {
410         PWKSTA_USER_INFO_1101 ui;
411         DWORD dwSize = 1;
412
413         FIXME("Stub. Level 1101 processing is not implemented\n");
414         /* FIXME see also wkui1_oth_domains for level 1 */
415
416         /* set up buffer */
417         NetApiBufferAllocate(sizeof(WKSTA_USER_INFO_1101) + dwSize * sizeof(WCHAR),
418                              (LPVOID *) bufptr);
419
420         ui = (PWKSTA_USER_INFO_1101) *bufptr;
421         ui->wkui1101_oth_domains = (LMSTR)(ui + 1);
422
423         /* get data */
424         ui->wkui1101_oth_domains[0] = 0;
425         break;
426     }
427     default:
428         TRACE("Invalid level %d is specified\n", level);
429         return ERROR_INVALID_LEVEL;
430     }
431     return NERR_Success;
432 }
433
434 /************************************************************
435  *                NetpGetComputerName  (NETAPI32.@)
436  */
437 NET_API_STATUS WINAPI NetpGetComputerName(LPWSTR *Buffer)
438 {
439     DWORD dwSize = MAX_COMPUTERNAME_LENGTH + 1;
440
441     TRACE("(%p)\n", Buffer);
442     NetApiBufferAllocate(dwSize * sizeof(WCHAR), (LPVOID *) Buffer);
443     if (GetComputerNameW(*Buffer,  &dwSize))
444     {
445         NetApiBufferReallocate(
446             *Buffer, (dwSize + 1) * sizeof(WCHAR),
447             (LPVOID *) Buffer);
448         return NERR_Success;
449     }
450     else
451     {
452         NetApiBufferFree(*Buffer);
453         return ERROR_NOT_ENOUGH_MEMORY;
454     }
455 }
456
457 NET_API_STATUS WINAPI I_NetNameCompare(LPVOID p1, LPWSTR wkgrp, LPWSTR comp,
458  LPVOID p4, LPVOID p5)
459 {
460     FIXME("(%p %s %s %p %p): stub\n", p1, debugstr_w(wkgrp), debugstr_w(comp),
461      p4, p5);
462     return ERROR_INVALID_PARAMETER;
463 }
464
465 NET_API_STATUS WINAPI I_NetNameValidate(LPVOID p1, LPWSTR wkgrp, LPVOID p3,
466  LPVOID p4)
467 {
468     FIXME("(%p %s %p %p): stub\n", p1, debugstr_w(wkgrp), p3, p4);
469     return ERROR_INVALID_PARAMETER;
470 }
471
472 NET_API_STATUS WINAPI NetWkstaGetInfo( LMSTR servername, DWORD level,
473                                        LPBYTE* bufptr)
474 {
475     NET_API_STATUS ret;
476
477     TRACE("%s %d %p\n", debugstr_w( servername ), level, bufptr );
478     if (servername)
479     {
480         if (!NETAPI_IsLocalComputer(servername))
481         {
482             FIXME("remote computers not supported\n");
483             return ERROR_INVALID_LEVEL;
484         }
485     }
486     if (!bufptr) return ERROR_INVALID_PARAMETER;
487
488     switch (level)
489     {
490         case 100:
491         case 101:
492         case 102:
493         {
494             static const WCHAR lanroot[] = {'c',':','\\','l','a','n','m','a','n',0};  /* FIXME */
495             DWORD computerNameLen, domainNameLen, size;
496             WCHAR computerName[MAX_COMPUTERNAME_LENGTH + 1];
497             LSA_OBJECT_ATTRIBUTES ObjectAttributes;
498             LSA_HANDLE PolicyHandle;
499             NTSTATUS NtStatus;
500            
501             computerNameLen = MAX_COMPUTERNAME_LENGTH + 1;
502             GetComputerNameW(computerName, &computerNameLen);
503             computerNameLen++; /* include NULL terminator */
504
505             ZeroMemory(&ObjectAttributes, sizeof(ObjectAttributes));
506             NtStatus = LsaOpenPolicy(NULL, &ObjectAttributes,
507              POLICY_VIEW_LOCAL_INFORMATION, &PolicyHandle);
508             if (NtStatus != STATUS_SUCCESS)
509                 ret = LsaNtStatusToWinError(NtStatus);
510             else
511             {
512                 PPOLICY_ACCOUNT_DOMAIN_INFO DomainInfo;
513
514                 LsaQueryInformationPolicy(PolicyHandle,
515                  PolicyAccountDomainInformation, (PVOID*)&DomainInfo);
516                 domainNameLen = lstrlenW(DomainInfo->DomainName.Buffer) + 1;
517                 size = sizeof(WKSTA_INFO_102) + computerNameLen * sizeof(WCHAR)
518                     + domainNameLen * sizeof(WCHAR) + sizeof(lanroot);
519                 ret = NetApiBufferAllocate(size, (LPVOID *)bufptr);
520                 if (ret == NERR_Success)
521                 {
522                     /* INFO_100 and INFO_101 structures are subsets of INFO_102 */
523                     PWKSTA_INFO_102 info = (PWKSTA_INFO_102)*bufptr;
524                     OSVERSIONINFOW verInfo;
525
526                     info->wki102_platform_id = PLATFORM_ID_NT;
527                     info->wki102_computername = (LMSTR)(*bufptr +
528                      sizeof(WKSTA_INFO_102));
529                     memcpy(info->wki102_computername, computerName,
530                      computerNameLen * sizeof(WCHAR));
531                     info->wki102_langroup = info->wki102_computername + computerNameLen;
532                     memcpy(info->wki102_langroup, DomainInfo->DomainName.Buffer,
533                      domainNameLen * sizeof(WCHAR));
534                     info->wki102_lanroot = info->wki102_langroup + domainNameLen;
535                     memcpy(info->wki102_lanroot, lanroot, sizeof(lanroot));
536                     memset(&verInfo, 0, sizeof(verInfo));
537                     verInfo.dwOSVersionInfoSize = sizeof(verInfo);
538                     GetVersionExW(&verInfo);
539                     info->wki102_ver_major = verInfo.dwMajorVersion;
540                     info->wki102_ver_minor = verInfo.dwMinorVersion;
541                     info->wki102_logged_on_users = 1;
542                 }
543                 LsaFreeMemory(DomainInfo);
544                 LsaClose(PolicyHandle);
545             }
546             break;
547         }
548
549         default:
550             FIXME("level %d unimplemented\n", level);
551             ret = ERROR_INVALID_LEVEL;
552     }
553     return ret;
554 }
555
556 /************************************************************
557  *                NetGetJoinInformation (NETAPI32.@)
558  */
559 NET_API_STATUS NET_API_FUNCTION NetGetJoinInformation(
560     LPCWSTR Server,
561     LPWSTR *Name,
562     PNETSETUP_JOIN_STATUS type)
563 {
564     FIXME("Stub %s %p %p\n", wine_dbgstr_w(Server), Name, type);
565
566     *Name = NULL;
567     *type = NetSetupUnknownStatus;
568
569     return NERR_Success;
570 }