source: trunk/src/wnetap32/wnetap32.cpp@ 5514

Last change on this file since 5514 was 5472, checked in by sandervl, 25 years ago

compile fix
File size: 129.9 KB
Line 
1/* $Id: wnetap32.cpp,v 1.14 2001-04-04 09:02:16 sandervl Exp $ */
2
3/*
4 *
5 * Project Odin Software License can be found in LICENSE.TXT
6 *
7 */
8/*
9 * NETAPI32 stubs
10 *
11 * Copyright 1998 Patrick Haller
12 *
13 * Note: functions that return structures/buffers seem to append strings
14 * at the end of the buffer. Currently, we just allocate the strings
15 * "normally". Therefore a caller that just does a NetApiBufferFree() on the
16 * returned buffer will leak all allocated strings.
17 *
18 */
19/*****************************************************************************
20 * Name : WNETAP32.CPP
21 * Purpose : This module maps all Win32 functions contained in NETAPI32.DLL
22 * to their OS/2-specific counterparts as far as possible.
23 * Basis is 5.05.97 12.00 59152 MPR.DLL (NT4SP3)
24 *****************************************************************************/
25
26
27/****************************************************************************
28 * Includes *
29 ****************************************************************************/
30
31#include <odin.h>
32#include <odinwrap.h>
33#include <os2win.h>
34#include <misc.h>
35#include <unicode.h>
36#include <heapstring.h>
37#include <string.h>
38
39#include "oslibnet.h"
40#include "lanman.h"
41
42ODINDEBUGCHANNEL(WNETAP32-WNETAP32)
43
44
45/****************************************************************************
46 * Module Global Variables *
47 ****************************************************************************/
48
49#undef NET_API_STATUS
50#define NET_API_STATUS DWORD
51
52#define NERR_OK 0
53#define NERR_BASE 1 /* @@@PH DUMMY ! */
54
55#define NCBNAMSZ 16
56#define MAX_LANA 254
57
58typedef struct _NCB {
59 UCHAR ncb_command;
60 UCHAR ncb_retcode;
61 UCHAR ncb_lsn;
62 UCHAR ncb_num;
63 PUCHAR ncb_buffer;
64 WORD ncb_length;
65 UCHAR ncb_callname[NCBNAMSZ];
66 UCHAR ncb_name[NCBNAMSZ];
67 UCHAR ncb_rto;
68 UCHAR ncb_sto;
69 void (* CALLBACK ncb_post)( struct _NCB * );
70 UCHAR ncb_lana_num;
71 UCHAR ncb_cmd_cplt;
72 UCHAR ncb_reserve[10];
73 HANDLE ncb_event;
74} NCB, *PNCB;
75
76#define NRC_GOODRET 0x00
77#define NRC_BUFLEN 0x01
78#define NRC_ILLCMD 0x03
79#define NRC_CMDTMO 0x05
80#define NRC_INCOMP 0x06
81#define NRC_BADDR 0x07
82#define NRC_SNUMOUT 0x08
83#define NRC_NORES 0x09
84#define NRC_SCLOSED 0x0a
85#define NRC_CMDCAN 0x0b
86#define NRC_DUPNAME 0x0d
87#define NRC_NAMTFUL 0x0e
88#define NRC_ACTSES 0x0f
89#define NRC_LOCTFUL 0x11
90#define NRC_REMTFUL 0x12
91#define NRC_ILLNN 0x13
92#define NRC_NOCALL 0x14
93#define NRC_NOWILD 0x15
94#define NRC_INUSE 0x16
95#define NRC_NAMERR 0x17
96#define NRC_SABORT 0x18
97#define NRC_NAMCONF 0x19
98#define NRC_IFBUSY 0x21
99#define NRC_TOOMANY 0x22
100#define NRC_BRIDGE 0x23
101#define NRC_CANOCCR 0x24
102#define NRC_CANCEL 0x26
103#define NRC_DUPENV 0x30
104#define NRC_ENVNOTDEF 0x34
105#define NRC_OSRESNOTAV 0x35
106#define NRC_MAXAPPS 0x36
107#define NRC_NOSAPS 0x37
108#define NRC_NORESOURCES 0x38
109#define NRC_INVADDRESS 0x39
110#define NRC_INVDDID 0x3B
111#define NRC_LOCKFAIL 0x3C
112#define NRC_OPENERR 0x3f
113#define NRC_SYSTEM 0x40
114
115#define NRC_PENDING 0xff
116
117
118//******************************************************************************
119//******************************************************************************
120ODINFUNCTION1(UCHAR, OS2Netbios,
121 PNCB, pncb)
122{
123#ifdef DEBUG
124 WriteLog("OS2Netbios; pretend no network available\n");
125#endif
126 return(NRC_OPENERR);
127}
128//******************************************************************************
129//******************************************************************************
130
131/*****************************************************************************
132 * Name : NET_API_STATUS NetAlertRaise
133 * Purpose :
134 * Parameters: LPWSTR AlertEventName Pointer to a Unicode string that specifies
135 * the interrupting message to raise
136 * LPVOID Buffer Pointer to the data to be sent to the clients
137 * listening for this interrupting message
138 * DWORD BufferSize Specifies in bytes, the size of the buffer
139 * Variables :
140 * Result :
141 * Remark :
142 * Status : UNTESTED STUB
143 *
144 * Stub Generated through PE2LX Stubwizard 0.02 from Markus Montkowski
145 *
146 * Author : Markus Montkowski [09.07.98 19:40:30]
147 *****************************************************************************/
148
149ODINFUNCTION3(NET_API_STATUS, OS2NetAlertRaise,
150 LPWSTR, AlertEventName,
151 LPVOID, Buffer,
152 DWORD, BufferSize)
153{
154
155 dprintf(("NETAPI32: NetAlertRaise not implemented\n"));
156
157 return (NERR_BASE);
158}
159
160
161/*****************************************************************************
162 * Name : NET_API_STATUS NetAlertRaiseEx
163 * Purpose :
164 * Parameters: LPWSTR AlertEventName
165 * LPVOID VariableInfo
166 * DWORD VariableInfoSize
167 * LPWSTR ServiceName
168 * Variables :
169 * Result :
170 * Remark :
171 * Status : UNTESTED STUB
172 *
173 * Stub Generated through PE2LX Stubwizard 0.02 from Markus Montkowski
174 *
175 * Author : Markus Montkowski [09.07.98 19:44:43]
176 *****************************************************************************/
177
178ODINFUNCTION4(NET_API_STATUS, OS2NetAlertRaiseEx,
179 LPWSTR, AlertEventName,
180 LPVOID, VariableInfo,
181 DWORD, VariableInfoSize,
182 LPWSTR, ServiceName)
183
184{
185
186 dprintf(("NETAPI32: NetAlertRaiseEx not implemented\n"));
187
188 return (NERR_BASE);
189}
190
191
192/*****************************************************************************
193 * Name : NET_API_STATUS NetApiBufferAllocate
194 * Purpose :
195 * Parameters: DWORD ByteCount
196 * LPVOID *Buffer
197 * Variables :
198 * Result :
199 * Remark :
200 * Status : UNTESTED STUB
201 *
202 * Stub Generated through PE2LX Stubwizard 0.02 from Markus Montkowski
203 *
204 * Author : Markus Montkowski [09.07.98 19:46:46]
205 *****************************************************************************/
206
207ODINFUNCTION2(NET_API_STATUS, OS2NetApiBufferAllocate,
208 DWORD, ByteCount,
209 LPVOID *, Buffer)
210
211{
212 *Buffer = HEAP_malloc(ByteCount);
213 return (NERR_OK);
214}
215
216
217/*****************************************************************************
218 * Name : NET_API_STATUS NetApiBufferFree
219 * Purpose :
220 * Parameters: LPVOID Buffer
221 * Variables :
222 * Result :
223 * Remark :
224 * Status : UNTESTED STUB
225 *
226 * Stub Generated through PE2LX Stubwizard 0.02 from Markus Montkowski
227 *
228 * Author : Markus Montkowski [09.07.98 19:47:21]
229 *****************************************************************************/
230
231ODINFUNCTION1(NET_API_STATUS, OS2NetApiBufferFree,
232 LPVOID, Buffer)
233
234{
235 HEAP_free(Buffer);
236 return (NERR_OK);
237}
238
239
240/*****************************************************************************
241 * Name : NET_API_STATUS NetApiBufferReallocate
242 * Purpose :
243 * Parameters: LPVOID OldBuffer
244 * DWORD NewByteCount
245 * LPVOID NewBuffer
246 * Variables :
247 * Result :
248 * Remark :
249 * Status : UNTESTED STUB
250 *
251 * Stub Generated through PE2LX Stubwizard 0.02 from Markus Montkowski
252 *
253 * Author : Markus Montkowski [09.07.98 21:25:21]
254 *****************************************************************************/
255
256ODINFUNCTION3(NET_API_STATUS, OS2NetApiBufferReallocate,
257 LPVOID, OldBuffer,
258 DWORD, NewByteCount,
259 LPVOID*, NewBuffer)
260{
261 *NewBuffer = HEAP_realloc(OldBuffer, NewByteCount);
262 return (NERR_OK);
263}
264
265
266/*****************************************************************************
267 * Name : NET_API_STATUS NetApiBufferSize
268 * Purpose :
269 * Parameters: LPVOID buffer
270 * DWORD ByteCount
271 * Variables :
272 * Result :
273 * Remark :
274 * Status : UNTESTED STUB
275 *
276 * Stub Generated through PE2LX Stubwizard 0.02 from Markus Montkowski
277 *
278 * Author : Markus Montkowski [09.07.98 21:25:44]
279 *****************************************************************************/
280
281ODINFUNCTION2(NET_API_STATUS, OS2NetApiBufferSize,
282 LPVOID, buffer,
283 LPDWORD, lpByteCount)
284{
285 *lpByteCount = HEAP_size(buffer);
286 return (NERR_OK);
287}
288
289
290/*****************************************************************************
291 * Name : NET_API_STATUS NetFileEnum
292 * Purpose :
293 * Parameters: LPWSTR servername
294 * LPWSTR basepath
295 * LPWSTR username
296 * DWORD level
297 * LPBYTE *bufptr
298 * DWORD prefmaxlen
299 * LPDWORD entriesread
300 * LPDWORD totalentries
301 * LPDWORD resume_handle
302 * Variables :
303 * Result :
304 * Remark :
305 * Status : UNTESTED STUB
306 *
307 * Stub Generated through PE2LX Stubwizard 0.02 from Markus Montkowski
308 *
309 * Author : Markus Montkowski [09.07.98 21:27:44]
310 *****************************************************************************/
311
312ODINFUNCTION9(NET_API_STATUS, OS2NetFileEnum,
313 LPWSTR, servername,
314 LPWSTR, basepath,
315 LPWSTR, username,
316 DWORD, level,
317 LPBYTE *, bufptr,
318 DWORD, prefmaxlen,
319 LPDWORD, entriesread,
320 LPDWORD, totalentries,
321 LPDWORD, resume_handle)
322{
323 dprintf(("NETAPI32: NetFileEnum not implemented\n"));
324
325 return (NERR_BASE);
326}
327
328
329/*****************************************************************************
330 * Name : NET_API_STATUS NetFileGetInfo
331 * Purpose :
332 * Parameters: LPWSTR servername
333 * DWORD fileid
334 * DWORD level
335 * LPBYTE *bufptr
336 * Variables :
337 * Result :
338 * Remark :
339 * Status : UNTESTED STUB
340 *
341 * Stub Generated through PE2LX Stubwizard 0.02 from Markus Montkowski
342 *
343 * Author : Markus Montkowski [09.07.98 21:28:38]
344 *****************************************************************************/
345
346ODINFUNCTION4(NET_API_STATUS,OS2NetFileGetInfo,LPWSTR, servername,
347 DWORD, fileid,
348 DWORD, level,
349 LPBYTE*, bufptr)
350{
351 dprintf(("NETAPI32: NetFileGetInfo not implemented\n"));
352
353 return (NERR_BASE);
354}
355
356
357/*****************************************************************************
358 * Name : NET_API_STATUS NetGetAnyDCName
359 * Purpose :
360 * Parameters: LPCWSTR ServerName
361 * LPCWSTR DomainName
362 * LPBYTE *Buffer
363 * Variables :
364 * Result :
365 * Remark :
366 * Status : UNTESTED STUB
367 *
368 * Stub Generated through PE2LX Stubwizard 0.02 from Markus Montkowski
369 *
370 * Author : Markus Montkowski [09.07.98 21:29:52]
371 *****************************************************************************/
372
373ODINFUNCTION3(NET_API_STATUS, OS2NetGetAnyDCName,
374 LPCWSTR, ServerName,
375 LPCWSTR, DomainName,
376 LPBYTE *, Buffer)
377{
378 dprintf(("NETAPI32: NetGetAnyDCName not implemented\n"));
379
380 return (NERR_BASE);
381}
382
383
384/*****************************************************************************
385 * Name : NET_API_STATUS NetGetDCName
386 * Purpose :
387 * Parameters: LPWSTR servername
388 * LPWSTR domainname
389 * LPBYTE *bufptr
390 * Variables :
391 * Result :
392 * Remark :
393 * Status : UNTESTED STUB
394 *
395 * Stub Generated through PE2LX Stubwizard 0.02 from Markus Montkowski
396 *
397 * Author : Markus Montkowski [09.07.98 21:30:29]
398 *****************************************************************************/
399
400ODINFUNCTION3(NET_API_STATUS, OS2NetGetDCName,
401 LPWSTR, servername,
402 LPWSTR, domainname,
403 LPBYTE *, bufptr)
404{
405
406 dprintf(("NETAPI32: NetGetDCName not implemented\n"));
407
408 return (NERR_BASE);
409}
410
411
412/*****************************************************************************
413 * Name : NET_API_STATUS NetGetDisplayInformationIndex
414 * Purpose :
415 * Parameters: LPWSTR ServerName pointer to server to get information from
416 * DWORD Level level of information to retrieve
417 * LPWSTR Prefix pointer to prefix string
418 * LPDWORD Index receives index of entry
419 * Variables :
420 * Result :
421 * Remark :
422 * Status : UNTESTED STUB
423 *
424 * Stub Generated through PE2LX Stubwizard 0.02 from Markus Montkowski
425 *
426 * Author : Markus Montkowski [09.07.98 21:30:53]
427 *****************************************************************************/
428
429ODINFUNCTION4(NET_API_STATUS, OS2NetGetDisplayInformationIndex,
430 LPWSTR, ServerName,
431 DWORD, Level,
432 LPWSTR, Prefix,
433 LPDWORD, Index)
434{
435 dprintf(("NETAPI32: NetGetDisplayInformationIndex not implemented\n"));
436
437 return (NERR_BASE);
438}
439
440
441/*****************************************************************************
442 * Name : NET_API_STATUS NetGroupAdd
443 * Purpose :
444 * Parameters: LPWSTR servername
445 * DWORD level
446 * LPBYTE buf
447 * LPDWORD parm_err
448 * Variables :
449 * Result :
450 * Remark :
451 * Status : UNTESTED STUB
452 *
453 * Stub Generated through PE2LX Stubwizard 0.02 from Markus Montkowski
454 *
455 * Author : Markus Montkowski [09.07.98 21:31:17]
456 *****************************************************************************/
457
458ODINFUNCTION4(NET_API_STATUS, OS2NetGroupAdd,
459 LPWSTR, servername,
460 DWORD, level,
461 LPBYTE, buf,
462 LPDWORD, parm_err)
463{
464 dprintf(("NETAPI32: NetGroupAdd not implemented\n"));
465
466 return (NERR_BASE);
467}
468
469
470/*****************************************************************************
471 * Name : NET_API_STATUS NetGroupAddUser
472 * Purpose :
473 * Parameters: LPWSTR servername
474 * LPWSTR GroupName
475 * LPWSTR username
476 * Variables :
477 * Result :
478 * Remark :
479 * Status : UNTESTED STUB
480 *
481 * Stub Generated through PE2LX Stubwizard 0.02 from Markus Montkowski
482 *
483 * Author : Markus Montkowski [09.07.98 21:31:38]
484 *****************************************************************************/
485
486ODINFUNCTION3(NET_API_STATUS, OS2NetGroupAddUser,
487 LPWSTR, servername,
488 LPWSTR, GroupName,
489 LPWSTR, username)
490{
491 dprintf(("NETAPI32: NetGroupAddUser not implemented\n"));
492
493 return (NERR_BASE);
494}
495
496
497/*****************************************************************************
498 * Name : NET_API_STATUS NetGroupDel
499 * Purpose :
500 * Parameters: LPWSTR servername
501 * LPWSTR groupname
502 * Variables :
503 * Result :
504 * Remark :
505 * Status : UNTESTED STUB
506 *
507 * Stub Generated through PE2LX Stubwizard 0.02 from Markus Montkowski
508 *
509 * Author : Markus Montkowski [09.07.98 21:31:53]
510 *****************************************************************************/
511
512ODINFUNCTION2(NET_API_STATUS, OS2NetGroupDel,
513 LPWSTR, servername,
514 LPWSTR, groupname)
515{
516 dprintf(("NETAPI32: NetGroupDel not implemented\n"));
517
518 return (NERR_BASE);
519}
520
521
522/*****************************************************************************
523 * Name : NET_API_STATUS NetGroupDelUser
524 * Purpose :
525 * Parameters: LPWSTR servername
526 * LPWSTR GroupName
527 * LPWSTR Username
528 * Variables :
529 * Result :
530 * Remark :
531 * Status : UNTESTED STUB
532 *
533 * Stub Generated through PE2LX Stubwizard 0.02 from Markus Montkowski
534 *
535 * Author : Markus Montkowski [09.07.98 21:32:05]
536 *****************************************************************************/
537
538ODINFUNCTION3(NET_API_STATUS, OS2NetGroupDelUser,
539 LPWSTR, servername,
540 LPWSTR, GroupName,
541 LPWSTR, Username)
542{
543 dprintf(("NETAPI32: NetGroupDelUser not implemented\n"));
544
545 return (NERR_BASE);
546}
547
548
549/*****************************************************************************
550 * Name : NET_API_STATUS NetGroupEnum
551 * Purpose :
552 * Parameters: LPWSTR servername
553 * DWORD level
554 * LPBYTE *bufptr
555 * DWORD prefmaxlen
556 * LPDWORD entriesread
557 * LPDWORD totalentries
558 * LPDWORD resume_handle
559 * Variables :
560 * Result :
561 * Remark :
562 * Status : UNTESTED STUB
563 *
564 * Stub Generated through PE2LX Stubwizard 0.02 from Markus Montkowski
565 *
566 * Author : Markus Montkowski [09.07.98 21:32:38]
567 *****************************************************************************/
568
569ODINFUNCTION7(NET_API_STATUS, OS2NetGroupEnum,
570 LPWSTR, servername,
571 DWORD, level,
572 LPBYTE *, bufptr,
573 DWORD, prefmaxlen,
574 LPDWORD, entriesread,
575 LPDWORD, totalentries,
576 LPDWORD, resume_handle)
577{
578 dprintf(("NETAPI32: NetGroupEnum not implemented\n"));
579
580 return (NERR_BASE);
581}
582
583
584/*****************************************************************************
585 * Name : NET_API_STATUS NetGroupGetInfo
586 * Purpose :
587 * Parameters: LPWSTR servername
588 * LPWSTR groupname
589 * DWORD level
590 * LPBYTE *bufptr
591 * Variables :
592 * Result :
593 * Remark :
594 * Status : UNTESTED STUB
595 *
596 * Stub Generated through PE2LX Stubwizard 0.02 from Markus Montkowski
597 *
598 * Author : Markus Montkowski [09.07.98 21:33:13]
599 *****************************************************************************/
600
601ODINFUNCTION4(NET_API_STATUS, OS2NetGroupGetInfo,
602 LPWSTR, servername,
603 LPWSTR, groupname,
604 DWORD, level,
605 LPBYTE *, bufptr)
606{
607 dprintf(("NETAPI32: NetGroupGetInfo not implemented\n"));
608
609 return (NERR_BASE);
610}
611
612
613/*****************************************************************************
614 * Name : NET_API_STATUS NetGroupGetUsers
615 * Purpose :
616 * Parameters: LPWSTR servername
617 * LPWSTR groupname
618 * DWORD level
619 * LPBYTE *bufptr
620 * DWORD prefmaxlen
621 * LPDWORD entriesread
622 * LPDWORD totalentries
623 * LPDWORD resumeHandle
624 * Variables :
625 * Result :
626 * Remark :
627 * Status : UNTESTED STUB
628 *
629 * Stub Generated through PE2LX Stubwizard 0.02 from Markus Montkowski
630 *
631 * Author : Markus Montkowski [09.07.98 21:33:24]
632 *****************************************************************************/
633
634ODINFUNCTION8(NET_API_STATUS, OS2NetGroupGetUsers,
635 LPWSTR, servername,
636 LPWSTR, groupname,
637 DWORD, level,
638 LPBYTE *, bufptr,
639 DWORD, prefmaxlen,
640 LPDWORD, entriesread,
641 LPDWORD, totalentries,
642 LPDWORD, resumeHandle)
643{
644 dprintf(("NETAPI32: NetGroupGetUsers not implemented\n"));
645
646 return (NERR_BASE);
647}
648
649
650/*****************************************************************************
651 * Name : NET_API_STATUS NetGroupSetInfo
652 * Purpose :
653 * Parameters: LPWSTR servername
654 * LPWSTR groupname
655 * DWORD level
656 * LPBYTE buf
657 * LPDWORD parm_err
658 * Variables :
659 * Result :
660 * Remark :
661 * Status : UNTESTED STUB
662 *
663 * Stub Generated through PE2LX Stubwizard 0.02 from Markus Montkowski
664 *
665 * Author : Markus Montkowski [09.07.98 21:33:39]
666 *****************************************************************************/
667
668ODINFUNCTION5(NET_API_STATUS, OS2NetGroupSetInfo,
669 LPWSTR, servername,
670 LPWSTR, groupname,
671 DWORD, level,
672 LPBYTE, buf,
673 LPDWORD, parm_err)
674{
675 dprintf(("NETAPI32: NetGroupSetInfo not implemented\n"));
676
677 return (NERR_BASE);
678}
679
680
681/*****************************************************************************
682 * Name : NET_API_STATUS NetGroupSetUsers
683 * Purpose :
684 * Parameters: LPWSTR servername
685 * LPWSTR groupname
686 * DWORD level
687 * LPBYTE buf
688 * DWORD NewMemberCount
689 * Variables :
690 * Result :
691 * Remark :
692 * Status : UNTESTED STUB
693 *
694 * Stub Generated through PE2LX Stubwizard 0.02 from Markus Montkowski
695 *
696 * Author : Markus Montkowski [09.07.98 21:34:02]
697 *****************************************************************************/
698
699ODINFUNCTION5(NET_API_STATUS, OS2NetGroupSetUsers,
700 LPWSTR, servername,
701 LPWSTR, groupname,
702 DWORD, level,
703 LPBYTE, buf,
704 DWORD, NewMemberCount)
705{
706 dprintf(("NETAPI32: NetGroupSetUsers not implemented\n"));
707
708 return (NERR_BASE);
709}
710
711
712/*****************************************************************************
713 * Name : NET_API_STATUS NetHandleGetInfo
714 * Purpose :
715 * Parameters: UNSIGNED SHORT hHandle
716 * SHORT sLevel
717 * CHAR FAR *pbBuffer
718 * UNSIGNED SHORT cbBuffer
719 * UNSIGNED SHORT FAR *pcbTotalAvail
720 * Variables :
721 * Result :
722 * Remark :
723 * Status : UNTESTED STUB
724 *
725 * Stub Generated through PE2LX Stubwizard 0.02 from Markus Montkowski
726 *
727 * Author : Markus Montkowski [09.07.98 21:35:03]
728 *****************************************************************************/
729/* NOT in DLL but in SDK Documentation
730ODINFUNCTION5(NET_API_STATUS, OS2NetHandleGetInfo,
731 UNSIGNED, SHORT,
732 hHandle,, SHORT,
733 sLevel,, CHAR,
734 FAR *, pbBuffer,
735 UNSIGNED, SHORTcbBuffer,
736 UNSIGNED SHORT FAR *pcbTotalAvail
737 )
738
739{
740
741 dprintf(("NETAPI32: NetHandleGetInfo(%d, %d, %08x, %d, %08x) not implemented\n"
742 ,hHandle, sLevel, *pbBuffer, cbBuffer, *pcbTotalAvail
743 ));
744
745 return (NERR_BASE);
746}
747*/
748
749/*****************************************************************************
750 * Name : NET_API_STATUS NetHandleSetInfo
751 * Purpose :
752 * Parameters: UNSIGNED SHORT hHandle
753 * SHORT sLevel
754 * CHAR FAR *pbBuffer
755 * UNSIGNED SHORT cbBuffer
756 * UNSIGNED SHORT FAR *sParmNum
757 * Variables :
758 * Result :
759 * Remark :
760 * Status : UNTESTED STUB
761 *
762 * Stub Generated through PE2LX Stubwizard 0.02 from Markus Montkowski
763 *
764 * Author : Markus Montkowski [09.07.98 21:39:08]
765 *****************************************************************************/
766/* Not in DLL but in SDK Documentation
767ODINFUNCTION5(NET_API_STATUS, OS2NetHandleSetInfo,
768 UNSIGNED, SHORT,
769 hHandle,, SHORT,
770 sLevel,, CHAR,
771 FAR *, pbBuffer,
772 UNSIGNED, SHORTcbBuffer,
773 UNSIGNED SHORT FAR *sParmNum
774 )
775
776{
777
778 dprintf(("NETAPI32: NetHandleSetInfo(%d, %d, %08x, %d, %08x) not implemented\n"
779 ,hHandle, sLevel, *pbBuffer, cbBuffer, *sParmNum
780 ));
781
782 return (NERR_BASE);
783}
784
785*/
786/*****************************************************************************
787 * Name : NET_API_STATUS NetLocalGroupAdd
788 * Purpose :
789 * Parameters: LPWSTR servername
790 * DWORD level
791 * LPBYTE buf
792 * LPDWORD parm_err
793 * Variables :
794 * Result :
795 * Remark :
796 * Status : UNTESTED STUB
797 *
798 * Stub Generated through PE2LX Stubwizard 0.02 from Markus Montkowski
799 *
800 * Author : Markus Montkowski [09.07.98 21:40:13]
801 *****************************************************************************/
802ODINFUNCTION4(NET_API_STATUS, OS2NetLocalGroupAdd,
803 LPWSTR, servername,
804 DWORD, level,
805 LPBYTE, buf,
806 LPDWORD, parm_err)
807{
808
809 dprintf(("NETAPI32: NetLocalGroupAdd(%08x, %d, %08x, %08x) not implemented\n"
810 ,servername, level, buf, parm_err
811 ));
812
813 return (NERR_BASE);
814}
815
816/*****************************************************************************
817 * Name : NET_API_STATUS NetLocalGroupAddMembers
818 * Purpose :
819 * Parameters: LPWSTR servername
820 * LPWSTR LocalGroupName
821 * DWORD level
822 * LPBYTE buf
823 * DWORD membercount
824 * Variables :
825 * Result :
826 * Remark :
827 * Status : UNTESTED STUB
828 *
829 * Stub Generated through PE2LX Stubwizard 0.02 from Markus Montkowski
830 *
831 * Author : Markus Montkowski [09.07.98 21:40:51]
832 *****************************************************************************/
833ODINFUNCTION5(NET_API_STATUS, OS2NetLocalGroupAddMembers,
834 LPWSTR, servername,
835 LPWSTR, LocalGroupName,
836 DWORD, level,
837 LPBYTE, buf,
838 DWORD, membercount)
839
840{
841
842 dprintf(("NETAPI32: NetLocalGroupAddMembers(%08x, %08x, %d, %08x, %d) not implemented\n"
843 ,servername, LocalGroupName, level, buf, membercount
844 ));
845
846 return (NERR_BASE);
847}
848
849/*****************************************************************************
850 * Name : NET_API_STATUS NetLocalGroupDel
851 * Purpose :
852 * Parameters: LPWSTR servername
853 * LPWSTR LocalGroupName
854 * Variables :
855 * Result :
856 * Remark :
857 * Status : UNTESTED STUB
858 *
859 * Stub Generated through PE2LX Stubwizard 0.02 from Markus Montkowski
860 *
861 * Author : Markus Montkowski [09.07.98 21:41:03]
862 *****************************************************************************/
863ODINFUNCTION2(NET_API_STATUS, OS2NetLocalGroupDel,
864 LPWSTR, servername,
865 LPWSTR, LocalGroupName)
866
867{
868
869 dprintf(("NETAPI32: NetLocalGroupDel(%08x, %08x) not implemented\n"
870 ,servername, LocalGroupName
871 ));
872
873 return (NERR_BASE);
874}
875
876/*****************************************************************************
877 * Name : NET_API_STATUS NetLocalGroupDelMembers
878 * Purpose :
879 * Parameters: LPWSTR servername
880 * LPWSTR LocalGroupName
881 * DWORD level
882 * LPBYTE buf
883 * DWORD membercount
884 * Variables :
885 * Result :
886 * Remark :
887 * Status : UNTESTED STUB
888 *
889 * Stub Generated through PE2LX Stubwizard 0.02 from Markus Montkowski
890 *
891 * Author : Markus Montkowski [09.07.98 21:41:33]
892 *****************************************************************************/
893ODINFUNCTION5(NET_API_STATUS, OS2NetLocalGroupDelMembers,
894 LPWSTR, servername,
895 LPWSTR, LocalGroupName,
896 DWORD, level,
897 LPBYTE, buf,
898 DWORD, membercount)
899
900{
901
902 dprintf(("NETAPI32: NetLocalGroupDelMembers(%08x, %08x, %d, %08x, %d) not implemented\n"
903 ,servername, LocalGroupName, level, buf, membercount
904 ));
905
906 return (NERR_BASE);
907}
908
909/*****************************************************************************
910 * Name : NET_API_STATUS NetLocalGroupEnum
911 * Purpose :
912 * Parameters: LPWSTR servername
913 * DWORD level
914 * LPBYTE *bufptr
915 * DWORD prefmaxlen
916 * LPDWORD entriesread
917 * LPDWORD totalentries
918 * LPDWORD resumehandle
919 * Variables :
920 * Result :
921 * Remark :
922 * Status : UNTESTED STUB
923 *
924 * Stub Generated through PE2LX Stubwizard 0.02 from Markus Montkowski
925 *
926 * Author : Markus Montkowski [09.07.98 21:41:49]
927 *****************************************************************************/
928ODINFUNCTION7(NET_API_STATUS, OS2NetLocalGroupEnum,
929 LPWSTR, servername,
930 DWORD, level,
931 LPBYTE *, bufptr,
932 DWORD, prefmaxlen,
933 LPDWORD, entriesread,
934 LPDWORD, totalentries,
935 LPDWORD, resumehandle)
936
937{
938
939 dprintf(("NETAPI32: NetLocalGroupEnum(%08x, %d, %08x, %d, %08x, %08x, %08x) not implemented\n"
940 ,servername, level, *bufptr, prefmaxlen, entriesread, totalentries, resumehandle
941 ));
942
943 return (NERR_BASE);
944}
945
946/*****************************************************************************
947 * Name : NET_API_STATUS NetLocalGroupGetInfo
948 * Purpose :
949 * Parameters: LPWSTR servername
950 * LPWSTR LocalGroupName
951 * DWORD level
952 * LPBYTE *bufptr
953 * Variables :
954 * Result :
955 * Remark :
956 * Status : UNTESTED STUB
957 *
958 * Stub Generated through PE2LX Stubwizard 0.02 from Markus Montkowski
959 *
960 * Author : Markus Montkowski [09.07.98 21:42:02]
961 *****************************************************************************/
962ODINFUNCTION4(NET_API_STATUS, OS2NetLocalGroupGetInfo,
963 LPWSTR, servername,
964 LPWSTR, LocalGroupName,
965 DWORD, level,
966 LPBYTE *, bufptr)
967
968{
969
970 dprintf(("NETAPI32: NetLocalGroupGetInfo(%08x, %08x, %d, %08x) not implemented\n"
971 ,servername, LocalGroupName, level, *bufptr
972 ));
973
974 return (NERR_BASE);
975}
976
977/*****************************************************************************
978 * Name : NET_API_STATUS NetLocalGroupGetMembers
979 * Purpose :
980 * Parameters: LPWSTR servername
981 * LPWSTR localgroupname
982 * DWORD level
983 * LPBYTE *bufptr
984 * DWORD prefmaxlen
985 * LPDWORD entriesread
986 * LPDWORD totalentries
987 * LPDWORD resumehandle
988 * Variables :
989 * Result :
990 * Remark :
991 * Status : UNTESTED STUB
992 *
993 * Stub Generated through PE2LX Stubwizard 0.02 from Markus Montkowski
994 *
995 * Author : Markus Montkowski [09.07.98 21:42:16]
996 *****************************************************************************/
997ODINFUNCTION8(NET_API_STATUS, OS2NetLocalGroupGetMembers,
998 LPWSTR, servername,
999 LPWSTR, localgroupname,
1000 DWORD, level,
1001 LPBYTE *, bufptr,
1002 DWORD, prefmaxlen,
1003 LPDWORD, entriesread,
1004 LPDWORD, totalentries,
1005 LPDWORD, resumehandle)
1006
1007{
1008
1009 dprintf(("NETAPI32: NetLocalGroupGetMembers(%08x, %08x, %d, %08x, %d, %08x, %08x, %08x) not implemented\n"
1010 ,servername, localgroupname, level, *bufptr, prefmaxlen, entriesread, totalentries, resumehandle
1011 ));
1012
1013 return (NERR_BASE);
1014}
1015
1016/*****************************************************************************
1017 * Name : NET_API_STATUS NetLocalGroupSetInfo
1018 * Purpose :
1019 * Parameters: LPWSTR servername
1020 * LPWSTR LocalGroupName
1021 * DWORD level
1022 * LPBYTE buf
1023 * LPDWORD parm_err
1024 * Variables :
1025 * Result :
1026 * Remark :
1027 * Status : UNTESTED STUB
1028 *
1029 * Stub Generated through PE2LX Stubwizard 0.02 from Markus Montkowski
1030 *
1031 * Author : Markus Montkowski [09.07.98 21:42:27]
1032 *****************************************************************************/
1033ODINFUNCTION5(NET_API_STATUS, OS2NetLocalGroupSetInfo,
1034 LPWSTR, servername,
1035 LPWSTR, LocalGroupName,
1036 DWORD, level,
1037 LPBYTE, buf,
1038 LPDWORD, parm_err)
1039
1040{
1041
1042 dprintf(("NETAPI32: NetLocalGroupSetInfo(%08x, %08x, %d, %08x, %08x) not implemented\n"
1043 ,servername, LocalGroupName, level, buf, parm_err
1044 ));
1045
1046 return (NERR_BASE);
1047}
1048
1049/*****************************************************************************
1050 * Name : NET_API_STATUS NetLocalGroupSetMembers
1051 * Purpose :
1052 * Parameters: LPWSTR servername
1053 * LPWSTR LocalGroupName
1054 * DWORD level
1055 * LPBYTE buf
1056 * DWORD totalentries
1057 * Variables :
1058 * Result :
1059 * Remark :
1060 * Status : UNTESTED STUB
1061 *
1062 * Stub Generated through PE2LX Stubwizard 0.02 from Markus Montkowski
1063 *
1064 * Author : Markus Montkowski [09.07.98 21:42:49]
1065 *****************************************************************************/
1066ODINFUNCTION5(NET_API_STATUS, OS2NetLocalGroupSetMembers,
1067 LPWSTR, servername,
1068 LPWSTR, LocalGroupName,
1069 DWORD, level,
1070 LPBYTE, buf,
1071 DWORD, totalentries)
1072
1073{
1074
1075 dprintf(("NETAPI32: NetLocalGroupSetMembers(%08x, %08x, %d, %08x, %d) not implemented\n"
1076 ,servername, LocalGroupName, level, buf, totalentries
1077 ));
1078
1079 return (NERR_BASE);
1080}
1081
1082/*****************************************************************************
1083 * Name : NET_API_STATUS NetMessageBufferSend
1084 * Purpose :
1085 * Parameters: LPWSTR servername
1086 * LPWSTR msgname
1087 * LPWSTR fromname
1088 * LPBYTE buf
1089 * DWORD buflen
1090 * Variables :
1091 * Result :
1092 * Remark :
1093 * Status : UNTESTED STUB
1094 *
1095 * Stub Generated through PE2LX Stubwizard 0.02 from Markus Montkowski
1096 *
1097 * Author : Markus Montkowski [09.07.98 21:43:01]
1098 *****************************************************************************/
1099ODINFUNCTION5(NET_API_STATUS, OS2NetMessageBufferSend,
1100 LPWSTR, servername,
1101 LPWSTR, msgname,
1102 LPWSTR, fromname,
1103 LPBYTE, buf,
1104 DWORD, buflen)
1105
1106{
1107
1108 dprintf(("NETAPI32: NetMessageBufferSend(%s, %s, %s, %08x, %d) not implemented\n"
1109 ,servername, msgname, fromname, buf, buflen
1110 ));
1111
1112 return (NERR_BASE);
1113}
1114
1115
1116
1117/*****************************************************************************
1118 * Name : NET_API_STATUS NetMessageNameAdd
1119 * Purpose :
1120 * Parameters: LPWSTR servername
1121 * LPWSTR msgname
1122 * Variables :
1123 * Result :
1124 * Remark :
1125 * Status : UNTESTED STUB
1126 *
1127 * Stub Generated through PE2LX Stubwizard 0.02 from Markus Montkowski
1128 *
1129 * Author : Markus Montkowski [09.07.98 21:43:41]
1130 *****************************************************************************/
1131ODINFUNCTION2(NET_API_STATUS, OS2NetMessageNameAdd,
1132 LPWSTR, servername,
1133 LPWSTR, msgname)
1134
1135{
1136
1137 dprintf(("NETAPI32: NetMessageNameAdd(%s, %s) not implemented\n"
1138 ,servername, msgname
1139 ));
1140
1141 return (NERR_BASE);
1142}
1143
1144/*****************************************************************************
1145 * Name : NET_API_STATUS NetMessageNameDel
1146 * Purpose :
1147 * Parameters: LPWSTR servername
1148 * LPWSTR msgname
1149 * Variables :
1150 * Result :
1151 * Remark :
1152 * Status : UNTESTED STUB
1153 *
1154 * Stub Generated through PE2LX Stubwizard 0.02 from Markus Montkowski
1155 *
1156 * Author : Markus Montkowski [09.07.98 21:44:12]
1157 *****************************************************************************/
1158ODINFUNCTION2(NET_API_STATUS, OS2NetMessageNameDel,
1159 LPWSTR, servername,
1160 LPWSTR, msgname)
1161
1162{
1163
1164 dprintf(("NETAPI32: NetMessageNameDel(%s, %s) not implemented\n"
1165 ,servername, msgname
1166 ));
1167
1168 return (NERR_BASE);
1169}
1170
1171/*****************************************************************************
1172 * Name : NET_API_STATUS NetMessageNameEnum
1173 * Purpose :
1174 * Parameters: LPWSTR servername
1175 * DWORD level
1176 * LPBYTE *bufptr
1177 * DWORD prefmaxlen
1178 * LPDWORD entriesread
1179 * LPDWORD totalentries
1180 * LPDWORD resume_handle
1181 * Variables :
1182 * Result :
1183 * Remark :
1184 * Status : UNTESTED STUB
1185 *
1186 * Stub Generated through PE2LX Stubwizard 0.02 from Markus Montkowski
1187 *
1188 * Author : Markus Montkowski [09.07.98 21:45:05]
1189 *****************************************************************************/
1190ODINFUNCTION7(NET_API_STATUS, OS2NetMessageNameEnum,
1191 LPWSTR, servername,
1192 DWORD, level,
1193 LPBYTE *, bufptr,
1194 DWORD, prefmaxlen,
1195 LPDWORD, entriesread,
1196 LPDWORD, totalentries,
1197 LPDWORD, resume_handle)
1198
1199{
1200
1201 dprintf(("NETAPI32: NetMessageNameEnum(%s, %d, %08x, %d, %08x, %08x, %08x) not implemented\n"
1202 ,servername, level, *bufptr, prefmaxlen, entriesread, totalentries, resume_handle
1203 ));
1204
1205 return (NERR_BASE);
1206}
1207
1208
1209/*****************************************************************************
1210 * Name : NET_API_STATUS NetMessageNameGetInfo
1211 * Purpose :
1212 * Parameters: LPWSTR servername
1213 * LPWSTR msgname
1214 * DWORD level
1215 * LPBYTE *bufptr
1216 * Variables :
1217 * Result :
1218 * Remark :
1219 * Status : UNTESTED STUB
1220 *
1221 * Stub Generated through PE2LX Stubwizard 0.02 from Markus Montkowski
1222 *
1223 * Author : Markus Montkowski [09.07.98 21:45:40]
1224 *****************************************************************************/
1225ODINFUNCTION4(NET_API_STATUS, OS2NetMessageNameGetInfo,
1226 LPWSTR, servername,
1227 LPWSTR, msgname,
1228 DWORD, level,
1229 LPBYTE *, bufptr)
1230
1231{
1232
1233 dprintf(("NETAPI32: NetMessageNameGetInfo(%s, %s, %d, %08x) not implemented\n"
1234 ,servername, msgname, level, *bufptr
1235 ));
1236
1237 return (NERR_BASE);
1238}
1239/*****************************************************************************
1240 * Name : NET_API_STATUS NetQueryDisplayInformation
1241 * Purpose :
1242 * Parameters: LPWSTR ServerName
1243 * DWORD Level
1244 * DWORD Index
1245 * DWORD EntriesRequested
1246 * DWORD PreferredMaximumLength
1247 * LPDWORD ReturnedEntryCount
1248 * PVOID *SortedBuffer
1249 * Variables :
1250 * Result :
1251 * Remark :
1252 * Status : UNTESTED STUB
1253 *
1254 * Stub Generated through PE2LX Stubwizard 0.02 from Markus Montkowski
1255 *
1256 * Author : Markus Montkowski [09.07.98 21:46:40]
1257 *****************************************************************************/
1258ODINFUNCTION7(NET_API_STATUS, OS2NetQueryDisplayInformation,
1259 LPWSTR, ServerName,
1260 DWORD, Level,
1261 DWORD, Index,
1262 DWORD, EntriesRequested,
1263 DWORD, PreferredMaximumLength,
1264 LPDWORD, ReturnedEntryCount,
1265 PVOID *, SortedBuffer)
1266
1267{
1268
1269 dprintf(("NETAPI32: NetQueryDisplayInformation(%08x, %d, %d, %d, %d, %08x, %08x) not implemented\n"
1270 ,ServerName, Level, Index, EntriesRequested, PreferredMaximumLength, ReturnedEntryCount, *SortedBuffer
1271 ));
1272
1273 return (NERR_BASE);
1274}
1275
1276/*****************************************************************************
1277 * Name : NET_API_STATUS NetRemoteTOD
1278 * Purpose :
1279 * Parameters: LPWSTR UncServerName
1280 * LPBYTE *BufferPtr
1281 * Variables :
1282 * Result :
1283 * Remark :
1284 * Status : UNTESTED STUB
1285 *
1286 * Stub Generated through PE2LX Stubwizard 0.02 from Markus Montkowski
1287 *
1288 * Author : Markus Montkowski [09.07.98 21:47:20]
1289 *****************************************************************************/
1290ODINFUNCTION2(NET_API_STATUS, OS2NetRemoteTOD,
1291 LPWSTR, UncServerName,
1292 LPBYTE *, BufferPtr)
1293
1294{
1295
1296 dprintf(("NETAPI32: NetRemoteTOD(%s, %08x) not implemented\n"
1297 ,UncServerName, *BufferPtr
1298 ));
1299
1300 return (NERR_BASE);
1301}
1302
1303/*****************************************************************************
1304 * Name : NET_API_STATUS NetReplExportDirAdd
1305 * Purpose :
1306 * Parameters: LPWSTR servername
1307 * DWORD level
1308 * LPBYTE buf
1309 * LPDWORD parm_err
1310 * Variables :
1311 * Result :
1312 * Remark :
1313 * Status : UNTESTED STUB
1314 *
1315 * Stub Generated through PE2LX Stubwizard 0.02 from Markus Montkowski
1316 *
1317 * Author : Markus Montkowski [09.07.98 21:47:52]
1318 *****************************************************************************/
1319ODINFUNCTION4(NET_API_STATUS, OS2NetReplExportDirAdd,
1320 LPWSTR, servername,
1321 DWORD, level,
1322 LPBYTE, buf,
1323 LPDWORD, parm_err)
1324
1325{
1326
1327 dprintf(("NETAPI32: NetReplExportDirAdd(%s, %d, %08x, %08x) not implemented\n"
1328 ,servername, level, buf, parm_err
1329 ));
1330
1331 return (NERR_BASE);
1332}
1333
1334/*****************************************************************************
1335 * Name : NET_API_STATUS NetReplExportDirDel
1336 * Purpose :
1337 * Parameters: LPWSTR servername
1338 * LPWSTR dirname
1339 * Variables :
1340 * Result :
1341 * Remark :
1342 * Status : UNTESTED STUB
1343 *
1344 * Stub Generated through PE2LX Stubwizard 0.02 from Markus Montkowski
1345 *
1346 * Author : Markus Montkowski [09.07.98 21:48:42]
1347 *****************************************************************************/
1348ODINFUNCTION2(NET_API_STATUS, OS2NetReplExportDirDel,
1349 LPWSTR, servername,
1350 LPWSTR, dirname)
1351
1352{
1353
1354 dprintf(("NETAPI32: NetReplExportDirDel(%s, %s) not implemented\n"
1355 ,servername, dirname
1356 ));
1357
1358 return (NERR_BASE);
1359}
1360
1361
1362
1363/*****************************************************************************
1364 * Name : NET_API_STATUS NetReplExportDirEnum
1365 * Purpose :
1366 * Parameters: LPWSTR servername
1367 * DWORD level
1368 * LPBYTE *bufptr
1369 * DWORD prefmaxlen
1370 * LPDWORD entriesread
1371 * LPDWORD totalentries
1372 * LPDWORD resumehandle
1373 * Variables :
1374 * Result :
1375 * Remark :
1376 * Status : UNTESTED STUB
1377 *
1378 * Stub Generated through PE2LX Stubwizard 0.02 from Markus Montkowski
1379 *
1380 * Author : Markus Montkowski [09.07.98 21:49:05]
1381 *****************************************************************************/
1382ODINFUNCTION7(NET_API_STATUS, OS2NetReplExportDirEnum,
1383 LPWSTR, servername,
1384 DWORD, level,
1385 LPBYTE *, bufptr,
1386 DWORD, prefmaxlen,
1387 LPDWORD, entriesread,
1388 LPDWORD, totalentries,
1389 LPDWORD, resumehandle)
1390
1391{
1392
1393 dprintf(("NETAPI32: NetReplExportDirEnum(%s, %d, %08x, %d, %08x, %08x, %08x) not implemented\n"
1394 ,servername, level, *bufptr, prefmaxlen, entriesread, totalentries, resumehandle
1395 ));
1396
1397 return (NERR_BASE);
1398}
1399/*****************************************************************************
1400 * Name : NET_API_STATUS NetReplExportDirGetInfo
1401 * Purpose :
1402 * Parameters: LPWSTR servername
1403 * LPWSTR dirname
1404 * DWORD level
1405 * LPBYTE *bufptr
1406 * Variables :
1407 * Result :
1408 * Remark :
1409 * Status : UNTESTED STUB
1410 *
1411 * Stub Generated through PE2LX Stubwizard 0.02 from Markus Montkowski
1412 *
1413 * Author : Markus Montkowski [09.07.98 21:49:34]
1414 *****************************************************************************/
1415ODINFUNCTION4(NET_API_STATUS, OS2NetReplExportDirGetInfo,
1416 LPWSTR, servername,
1417 LPWSTR, dirname,
1418 DWORD, level,
1419 LPBYTE *, bufptr)
1420
1421{
1422
1423 dprintf(("NETAPI32: NetReplExportDirGetInfo(%s, %s, %d, %08x) not implemented\n"
1424 ,servername, dirname, level, *bufptr
1425 ));
1426
1427 return (NERR_BASE);
1428}
1429/*****************************************************************************
1430 * Name : NET_API_STATUS NetReplExportDirLock
1431 * Purpose :
1432 * Parameters: LPWSTR servername
1433 * LPWSTR dirname
1434 * Variables :
1435 * Result :
1436 * Remark :
1437 * Status : UNTESTED STUB
1438 *
1439 * Stub Generated through PE2LX Stubwizard 0.02 from Markus Montkowski
1440 *
1441 * Author : Markus Montkowski [09.07.98 21:49:58]
1442 *****************************************************************************/
1443ODINFUNCTION2(NET_API_STATUS, OS2NetReplExportDirLock,
1444 LPWSTR, servername,
1445 LPWSTR, dirname)
1446
1447{
1448
1449 dprintf(("NETAPI32: NetReplExportDirLock(%s, %s) not implemented\n"
1450 ,servername, dirname
1451 ));
1452
1453 return (NERR_BASE);
1454}
1455
1456/*****************************************************************************
1457 * Name : NET_API_STATUS NetReplExportDirSetInfo
1458 * Purpose :
1459 * Parameters: LPWSTR servername
1460 * LPWSTR dirname
1461 * DWORD level
1462 * LPBYTE buf
1463 * LPDWORD parm_err
1464 * Variables :
1465 * Result :
1466 * Remark :
1467 * Status : UNTESTED STUB
1468 *
1469 * Stub Generated through PE2LX Stubwizard 0.02 from Markus Montkowski
1470 *
1471 * Author : Markus Montkowski [09.07.98 21:50:31]
1472 *****************************************************************************/
1473ODINFUNCTION5(NET_API_STATUS, OS2NetReplExportDirSetInfo,
1474 LPWSTR, servername,
1475 LPWSTR, dirname,
1476 DWORD, level,
1477 LPBYTE, buf,
1478 LPDWORD, parm_err)
1479
1480{
1481
1482 dprintf(("NETAPI32: NetReplExportDirSetInfo(%s, %s, %d, %08x, %08x) not implemented\n"
1483 ,servername, dirname, level, buf, parm_err
1484 ));
1485
1486 return (NERR_BASE);
1487}
1488/*****************************************************************************
1489 * Name : NET_API_STATUS NetReplExportDirUnlock
1490 * Purpose :
1491 * Parameters: LPWSTR servername
1492 * LPWSTR dirname
1493 * DWORD unlockforce
1494 * Variables :
1495 * Result :
1496 * Remark :
1497 * Status : UNTESTED STUB
1498 *
1499 * Stub Generated through PE2LX Stubwizard 0.02 from Markus Montkowski
1500 *
1501 * Author : Markus Montkowski [09.07.98 21:51:12]
1502 *****************************************************************************/
1503ODINFUNCTION3(NET_API_STATUS, OS2NetReplExportDirUnlock,
1504 LPWSTR, servername,
1505 LPWSTR, dirname,
1506 DWORD, unlockforce)
1507
1508{
1509
1510 dprintf(("NETAPI32: NetReplExportDirUnlock(%s, %s, %d) not implemented\n"
1511 ,servername, dirname, unlockforce
1512 ));
1513
1514 return (NERR_BASE);
1515}
1516
1517
1518/*****************************************************************************
1519 * Name : NET_API_STATUS NetReplGetInfo
1520 * Purpose :
1521 * Parameters: LPWSTR servername
1522 * DWORD level
1523 * LPBYTE *bufptr
1524 * Variables :
1525 * Result :
1526 * Remark :
1527 * Status : UNTESTED STUB
1528 *
1529 * Stub Generated through PE2LX Stubwizard 0.02 from Markus Montkowski
1530 *
1531 * Author : Markus Montkowski [09.07.98 21:51:37]
1532 *****************************************************************************/
1533ODINFUNCTION3(NET_API_STATUS, OS2NetReplGetInfo,
1534 LPWSTR, servername,
1535 DWORD, level,
1536 LPBYTE *, bufptr)
1537
1538{
1539
1540 dprintf(("NETAPI32: NetReplGetInfo(%s, %d, %08x) not implemented\n"
1541 ,servername, level, *bufptr
1542 ));
1543
1544 return (NERR_BASE);
1545}
1546/*****************************************************************************
1547 * Name : NET_API_STATUS NetReplImportDirAdd
1548 * Purpose :
1549 * Parameters: LPWSTR servername
1550 * DWORD level
1551 * LPBYTE buf
1552 * LPDWORD parm_err
1553 * Variables :
1554 * Result :
1555 * Remark :
1556 * Status : UNTESTED STUB
1557 *
1558 * Stub Generated through PE2LX Stubwizard 0.02 from Markus Montkowski
1559 *
1560 * Author : Markus Montkowski [09.07.98 21:52:11]
1561 *****************************************************************************/
1562ODINFUNCTION4(NET_API_STATUS, OS2NetReplImportDirAdd,
1563 LPWSTR, servername,
1564 DWORD, level,
1565 LPBYTE, buf,
1566 LPDWORD, parm_err)
1567
1568{
1569
1570 dprintf(("NETAPI32: NetReplImportDirAdd(%s, %d, %08x, %08x) not implemented\n"
1571 ,servername, level, buf, parm_err
1572 ));
1573
1574 return (NERR_BASE);
1575}
1576
1577/*****************************************************************************
1578 * Name : NET_API_STATUS NetReplImportDirDel
1579 * Purpose :
1580 * Parameters: LPWSTR servername
1581 * LPWSTR dirname
1582 * Variables :
1583 * Result :
1584 * Remark :
1585 * Status : UNTESTED STUB
1586 *
1587 * Stub Generated through PE2LX Stubwizard 0.02 from Markus Montkowski
1588 *
1589 * Author : Markus Montkowski [09.07.98 21:52:36]
1590 *****************************************************************************/
1591ODINFUNCTION2(NET_API_STATUS, OS2NetReplImportDirDel,
1592 LPWSTR, servername,
1593 LPWSTR, dirname)
1594
1595{
1596
1597 dprintf(("NETAPI32: NetReplImportDirDel(%s, %s) not implemented\n"
1598 ,servername, dirname
1599 ));
1600
1601 return (NERR_BASE);
1602}
1603
1604/*****************************************************************************
1605 * Name : NET_API_STATUS NetReplImportDirEnum
1606 * Purpose :
1607 * Parameters: LPWSTR servername
1608 * DWORD level
1609 * LPBYTE *bufptr
1610 * DWORD prefmaxlen
1611 * LPDWORD entriesread
1612 * LPDWORD totalentries
1613 * LPDWORD resumehandle
1614 * Variables :
1615 * Result :
1616 * Remark :
1617 * Status : UNTESTED STUB
1618 *
1619 * Stub Generated through PE2LX Stubwizard 0.02 from Markus Montkowski
1620 *
1621 * Author : Markus Montkowski [09.07.98 21:52:56]
1622 *****************************************************************************/
1623ODINFUNCTION7(NET_API_STATUS, OS2NetReplImportDirEnum,
1624 LPWSTR, servername,
1625 DWORD, level,
1626 LPBYTE *, bufptr,
1627 DWORD, prefmaxlen,
1628 LPDWORD, entriesread,
1629 LPDWORD, totalentries,
1630 LPDWORD, resumehandle)
1631
1632{
1633
1634 dprintf(("NETAPI32: NetReplImportDirEnum(%s, %d, %08x, %d, %08x, %08x, %08x) not implemented\n"
1635 ,servername, level, *bufptr, prefmaxlen, entriesread, totalentries, resumehandle
1636 ));
1637
1638 return (NERR_BASE);
1639}
1640/*****************************************************************************
1641 * Name : NET_API_STATUS NetReplImportDirGetInfo
1642 * Purpose :
1643 * Parameters: LPWSTR servername
1644 * LPWSTR dirname
1645 * DWORD level
1646 * LPBYTE *bufptr
1647 * Variables :
1648 * Result :
1649 * Remark :
1650 * Status : UNTESTED STUB
1651 *
1652 * Stub Generated through PE2LX Stubwizard 0.02 from Markus Montkowski
1653 *
1654 * Author : Markus Montkowski [09.07.98 21:53:24]
1655 *****************************************************************************/
1656ODINFUNCTION4(NET_API_STATUS, OS2NetReplImportDirGetInfo,
1657 LPWSTR, servername,
1658 LPWSTR, dirname,
1659 DWORD, level,
1660 LPBYTE *, bufptr)
1661
1662{
1663
1664 dprintf(("NETAPI32: NetReplImportDirGetInfo(%s, %s, %d, %08x) not implemented\n"
1665 ,servername, dirname, level, *bufptr
1666 ));
1667
1668 return (NERR_BASE);
1669}
1670
1671/*****************************************************************************
1672 * Name : NET_API_STATUS NetReplImportDirLock
1673 * Purpose :
1674 * Parameters: LPWSTR servername
1675 * LPWSTR dirname
1676 * Variables :
1677 * Result :
1678 * Remark :
1679 * Status : UNTESTED STUB
1680 *
1681 * Stub Generated through PE2LX Stubwizard 0.02 from Markus Montkowski
1682 *
1683 * Author : Markus Montkowski [09.07.98 21:53:45]
1684 *****************************************************************************/
1685ODINFUNCTION2(NET_API_STATUS, OS2NetReplImportDirLock,
1686 LPWSTR, servername,
1687 LPWSTR, dirname)
1688
1689{
1690
1691 dprintf(("NETAPI32: NetReplImportDirLock(%s, %s) not implemented\n"
1692 ,servername, dirname
1693 ));
1694
1695 return (NERR_BASE);
1696}
1697
1698
1699/*****************************************************************************
1700 * Name : NET_API_STATUS NetReplImportDirUnlock
1701 * Purpose :
1702 * Parameters: LPWSTR servername
1703 * LPWSTR dirname
1704 * DWORD unlockforce
1705 * Variables :
1706 * Result :
1707 * Remark :
1708 * Status : UNTESTED STUB
1709 *
1710 * Stub Generated through PE2LX Stubwizard 0.02 from Markus Montkowski
1711 *
1712 * Author : Markus Montkowski [09.07.98 21:54:16]
1713 *****************************************************************************/
1714ODINFUNCTION3(NET_API_STATUS, OS2NetReplImportDirUnlock,
1715 LPWSTR, servername,
1716 LPWSTR, dirname,
1717 DWORD, unlockforce)
1718
1719{
1720
1721 dprintf(("NETAPI32: NetReplImportDirUnlock(%s, %s, %d) not implemented\n"
1722 ,servername, dirname, unlockforce
1723 ));
1724
1725 return (NERR_BASE);
1726}
1727/*****************************************************************************
1728 * Name : NET_API_STATUS NetReplSetInfo
1729 * Purpose :
1730 * Parameters: LPWSTR servername
1731 * DWORD level
1732 * LPBYTE buf
1733 * LPDWORD parm_err
1734 * Variables :
1735 * Result :
1736 * Remark :
1737 * Status : UNTESTED STUB
1738 *
1739 * Stub Generated through PE2LX Stubwizard 0.02 from Markus Montkowski
1740 *
1741 * Author : Markus Montkowski [09.07.98 21:54:38]
1742 *****************************************************************************/
1743ODINFUNCTION4(NET_API_STATUS, OS2NetReplSetInfo,
1744 LPWSTR, servername,
1745 DWORD, level,
1746 LPBYTE, buf,
1747 LPDWORD, parm_err)
1748
1749{
1750
1751 dprintf(("NETAPI32: NetReplSetInfo(%s, %d, %08x, %08x) not implemented\n"
1752 ,servername, level, buf, parm_err
1753 ));
1754
1755 return (NERR_BASE);
1756}
1757
1758
1759/*****************************************************************************
1760 * Name : NET_API_STATUS NetScheduleJobAdd
1761 * Purpose :
1762 * Parameters: LPWSTR Servername
1763 * LPBYTE Buffer
1764 * LPDWORD JobId
1765 * Variables :
1766 * Result :
1767 * Remark :
1768 * Status : UNTESTED STUB
1769 *
1770 * Stub Generated through PE2LX Stubwizard 0.02 from Markus Montkowski
1771 *
1772 * Author : Markus Montkowski [09.07.98 21:55:41]
1773 *****************************************************************************/
1774ODINFUNCTION3(NET_API_STATUS, OS2NetScheduleJobAdd,
1775 LPWSTR, Servername,
1776 LPBYTE, Buffer,
1777 LPDWORD, JobId)
1778
1779{
1780
1781 dprintf(("NETAPI32: NetScheduleJobAdd(%08x, %08x, %08x) not implemented\n"
1782 ,Servername, Buffer, JobId
1783 ));
1784
1785 return (NERR_BASE);
1786}
1787
1788/*****************************************************************************
1789 * Name : NET_API_STATUS NetScheduleJobDel
1790 * Purpose :
1791 * Parameters: LPWSTR Servername
1792 * DWORD MinJobId
1793 * DWORD MaxJobId
1794 * Variables :
1795 * Result :
1796 * Remark :
1797 * Status : UNTESTED STUB
1798 *
1799 * Stub Generated through PE2LX Stubwizard 0.02 from Markus Montkowski
1800 *
1801 * Author : Markus Montkowski [09.07.98 21:55:50]
1802 *****************************************************************************/
1803ODINFUNCTION3(NET_API_STATUS, OS2NetScheduleJobDel,
1804 LPWSTR, Servername,
1805 DWORD, MinJobId,
1806 DWORD, MaxJobId)
1807
1808{
1809
1810 dprintf(("NETAPI32: NetScheduleJobDel(%08x, %d, %d) not implemented\n"
1811 ,Servername, MinJobId, MaxJobId
1812 ));
1813
1814 return (NERR_BASE);
1815}
1816
1817/*****************************************************************************
1818 * Name : NET_API_STATUS NetScheduleJobEnum
1819 * Purpose :
1820 * Parameters: LPWSTR Servername
1821 * LPBYTE *PointerToBuffer
1822 * DWORD PreferredMaximumLength
1823 * LPDWORD EntriesRead
1824 * LPDWORD TotalEntries
1825 * LPDWORD ResumeHandle
1826 * Variables :
1827 * Result :
1828 * Remark :
1829 * Status : UNTESTED STUB
1830 *
1831 * Stub Generated through PE2LX Stubwizard 0.02 from Markus Montkowski
1832 *
1833 * Author : Markus Montkowski [09.07.98 21:56:02]
1834 *****************************************************************************/
1835ODINFUNCTION6(NET_API_STATUS, OS2NetScheduleJobEnum,
1836 LPWSTR, Servername,
1837 LPBYTE *, PointerToBuffer,
1838 DWORD, PreferredMaximumLength,
1839 LPDWORD, EntriesRead,
1840 LPDWORD, TotalEntries,
1841 LPDWORD, ResumeHandle)
1842
1843{
1844
1845 dprintf(("NETAPI32: NetScheduleJobEnum(%08x, %08x, %d, %08x, %08x, %08x) not implemented\n"
1846 ,Servername, *PointerToBuffer, PreferredMaximumLength, EntriesRead, TotalEntries, ResumeHandle
1847 ));
1848
1849 return (NERR_BASE);
1850}
1851
1852/*****************************************************************************
1853 * Name : NET_API_STATUS NetScheduleJobGetInfo
1854 * Purpose :
1855 * Parameters: LPWSTR Servername
1856 * DWORD JobId
1857 * LPBYTE *PointerToBuffer
1858 * Variables :
1859 * Result :
1860 * Remark :
1861 * Status : UNTESTED STUB
1862 *
1863 * Stub Generated through PE2LX Stubwizard 0.02 from Markus Montkowski
1864 *
1865 * Author : Markus Montkowski [09.07.98 21:56:23]
1866 *****************************************************************************/
1867ODINFUNCTION3(NET_API_STATUS, OS2NetScheduleJobGetInfo,
1868 LPWSTR, Servername,
1869 DWORD, JobId,
1870 LPBYTE *, PointerToBuffer)
1871
1872{
1873
1874 dprintf(("NETAPI32: NetScheduleJobGetInfo(%08x, %d, %08x) not implemented\n"
1875 ,Servername, JobId, *PointerToBuffer
1876 ));
1877
1878 return (NERR_BASE);
1879}
1880
1881/*****************************************************************************
1882 * Name : NET_API_STATUS NetServerDiskEnum
1883 * Purpose :
1884 * Parameters: LPWSTR servername
1885 * DWORD level
1886 * LPBYTE *bufptr
1887 * DWORD prefmaxlen
1888 * LPDWORD entriesread
1889 * LPDWORD totalentries
1890 * LPDWORD resume_handle
1891 * Variables :
1892 * Result :
1893 * Remark :
1894 * Status : UNTESTED STUB
1895 *
1896 * Stub Generated through PE2LX Stubwizard 0.02 from Markus Montkowski
1897 *
1898 * Author : Markus Montkowski [09.07.98 21:56:38]
1899 *****************************************************************************/
1900ODINFUNCTION7(NET_API_STATUS, OS2NetServerDiskEnum,
1901 LPWSTR, servername,
1902 DWORD, level,
1903 LPBYTE *, bufptr,
1904 DWORD, prefmaxlen,
1905 LPDWORD, entriesread,
1906 LPDWORD, totalentries,
1907 LPDWORD, resume_handle)
1908
1909{
1910
1911 dprintf(("NETAPI32: NetServerDiskEnum(%s, %d, %08x, %d, %08x, %08x, %08x) not implemented\n"
1912 ,servername, level, *bufptr, prefmaxlen, entriesread, totalentries, resume_handle
1913 ));
1914
1915 return (NERR_BASE);
1916}
1917/*****************************************************************************
1918 * Name : NET_API_STATUS NetServerEnum
1919 * Purpose :
1920 * Parameters: LPWSTR servername
1921 * DWORD level
1922 * LPBYTE *bufptr
1923 * DWORD prefmaxlen
1924 * LPDWORD entriesread
1925 * LPDWORD totalentries
1926 * DWORD servertype
1927 * LPWSTR domain
1928 * LPDWORD resume_handle
1929 * Variables :
1930 * Result :
1931 * Remark :
1932 * Status : UNTESTED STUB
1933 *
1934 * Stub Generated through PE2LX Stubwizard 0.02 from Markus Montkowski
1935 *
1936 * Author : Markus Montkowski [09.07.98 21:57:09]
1937 *****************************************************************************/
1938ODINFUNCTION9(NET_API_STATUS, OS2NetServerEnum,
1939 LPWSTR, servername,
1940 DWORD, level,
1941 LPBYTE *, bufptr,
1942 DWORD, prefmaxlen,
1943 LPDWORD, entriesread,
1944 LPDWORD, totalentries,
1945 DWORD, servertype,
1946 LPWSTR, domain,
1947 LPDWORD, resume_handle)
1948
1949{
1950
1951 dprintf(("NETAPI32: NetServerEnum(%s, %d, %08x, %d, %08x, %08x, %d, %s, %08x) not implemented\n"
1952 ,servername, level, *bufptr, prefmaxlen, entriesread, totalentries, servertype, domain, resume_handle
1953 ));
1954
1955 return (NERR_BASE);
1956}
1957/*****************************************************************************
1958 * Name : NET_API_STATUS NetServerGetInfo
1959 * Purpose :
1960 * Parameters: LPWSTR servername
1961 * DWORD level
1962 * LPBYTE *bufptr
1963 * Variables :
1964 * Result :
1965 * Remark :
1966 * Status : UNTESTED STUB
1967 *
1968 * Stub Generated through PE2LX Stubwizard 0.02 from Markus Montkowski
1969 *
1970 * Author : Markus Montkowski [09.07.98 21:57:43]
1971 *****************************************************************************/
1972ODINFUNCTION3(NET_API_STATUS, OS2NetServerGetInfo,
1973 LPWSTR, servername,
1974 DWORD, level,
1975 LPBYTE *, bufptr)
1976
1977{
1978
1979 dprintf(("NETAPI32: NetServerGetInfo(%s, %d, %08x) not implemented\n"
1980 ,servername, level, *bufptr
1981 ));
1982
1983 return (NERR_BASE);
1984}
1985
1986/*****************************************************************************
1987 * Name : NET_API_STATUS NetServerSetInfo
1988 * Purpose :
1989 * Parameters: LPWSTR servername
1990 * DWORD level
1991 * LPBYTE buf
1992 * LPDWORD ParmError
1993 * Variables :
1994 * Result :
1995 * Remark :
1996 * Status : UNTESTED STUB
1997 *
1998 * Stub Generated through PE2LX Stubwizard 0.02 from Markus Montkowski
1999 *
2000 * Author : Markus Montkowski [09.07.98 21:58:14]
2001 *****************************************************************************/
2002ODINFUNCTION4(NET_API_STATUS, OS2NetServerSetInfo,
2003 LPWSTR, servername,
2004 DWORD, level,
2005 LPBYTE, buf,
2006 LPDWORD, ParmError)
2007
2008{
2009
2010 dprintf(("NETAPI32: NetServerSetInfo(%s, %d, %08x, %08x) not implemented\n"
2011 ,servername, level, buf, ParmError
2012 ));
2013
2014 return (NERR_BASE);
2015}
2016
2017
2018/*****************************************************************************
2019 * Name : NET_API_STATUS NetServerTransportAdd
2020 * Purpose :
2021 * Parameters: LPWSTR servername
2022 * DWORD level
2023 * LPBYTE bufptr
2024 * Variables :
2025 * Result :
2026 * Remark :
2027 * Status : UNTESTED STUB
2028 *
2029 * Stub Generated through PE2LX Stubwizard 0.02 from Markus Montkowski
2030 *
2031 * Author : Markus Montkowski [09.07.98 21:58:34]
2032 *****************************************************************************/
2033ODINFUNCTION3(NET_API_STATUS, OS2NetServerTransportAdd,
2034 LPWSTR, servername,
2035 DWORD, level,
2036 LPBYTE, bufptr)
2037
2038{
2039
2040 dprintf(("NETAPI32: NetServerTransportAdd(%s, %d, %08x) not implemented\n"
2041 ,servername, level, bufptr
2042 ));
2043
2044 return (NERR_BASE);
2045}
2046
2047/*****************************************************************************
2048 * Name : NET_API_STATUS NetServerTransportDel
2049 * Purpose :
2050 * Parameters: LPWSTR servername
2051 * LPWSTR transportname
2052 * Variables :
2053 * Result :
2054 * Remark :
2055 * Status : UNTESTED STUB
2056 *
2057 * Stub Generated through PE2LX Stubwizard 0.02 from Markus Montkowski
2058 *
2059 * Author : Markus Montkowski [09.07.98 21:59:12]
2060 *****************************************************************************/
2061ODINFUNCTION2(NET_API_STATUS, OS2NetServerTransportDel,
2062 LPWSTR, servername,
2063 LPWSTR, transportname)
2064
2065{
2066
2067 dprintf(("NETAPI32: NetServerTransportDel(%08x, %08x) not implemented\n"
2068 ,servername, transportname
2069 ));
2070
2071 return (NERR_BASE);
2072}
2073
2074/*****************************************************************************
2075 * Name : NET_API_STATUS NetServerTransportEnum
2076 * Purpose :
2077 * Parameters: LPWSTR servername
2078 * DWORD level
2079 * LPBYTE *bufptr
2080 * DWORD prefmaxlen
2081 * LPDWORD entriesread
2082 * LPDWORD totalentries
2083 * LPDWORD resumehandle
2084 * Variables :
2085 * Result :
2086 * Remark :
2087 * Status : UNTESTED STUB
2088 *
2089 * Stub Generated through PE2LX Stubwizard 0.02 from Markus Montkowski
2090 *
2091 * Author : Markus Montkowski [09.07.98 21:59:37]
2092 *****************************************************************************/
2093ODINFUNCTION7(NET_API_STATUS, OS2NetServerTransportEnum,
2094 LPWSTR, servername,
2095 DWORD, level,
2096 LPBYTE *, bufptr,
2097 DWORD, prefmaxlen,
2098 LPDWORD, entriesread,
2099 LPDWORD, totalentries,
2100 LPDWORD, resumehandle)
2101
2102{
2103
2104 dprintf(("NETAPI32: NetServerTransportEnum(%s, %d, %08x, %d, %08x, %08x, %08x) not implemented\n"
2105 ,servername, level, *bufptr, prefmaxlen, entriesread, totalentries, resumehandle
2106 ));
2107
2108 return (NERR_BASE);
2109}
2110/*****************************************************************************
2111 * Name : NET_API_STATUS NetSessionDel
2112 * Purpose :
2113 * Parameters: LPWSTR servername
2114 * LPWSTR UncClientName
2115 * LPWSTR username
2116 * Variables :
2117 * Result :
2118 * Remark :
2119 * Status : UNTESTED STUB
2120 *
2121 * Stub Generated through PE2LX Stubwizard 0.02 from Markus Montkowski
2122 *
2123 * Author : Markus Montkowski [09.07.98 22:00:15]
2124 *****************************************************************************/
2125ODINFUNCTION3(NET_API_STATUS, OS2NetSessionDel,
2126 LPWSTR, servername,
2127 LPWSTR, UncClientName,
2128 LPWSTR, username)
2129
2130{
2131
2132 dprintf(("NETAPI32: NetSessionDel(%s, %s, %s) not implemented\n"
2133 ,servername, UncClientName, username
2134 ));
2135
2136 return (NERR_BASE);
2137}
2138
2139
2140/*****************************************************************************
2141 * Name : NET_API_STATUS NetSessionEnum
2142 * Purpose :
2143 * Parameters: LPWSTR servername
2144 * LPWSTR UncClientName
2145 * LPWSTR username
2146 * DWORD level
2147 * LPBYTE *bufptr
2148 * DWORD prefmaxlen
2149 * LPDWORD entriesread
2150 * LPDWORD totalentries
2151 * LPDWORD resume_handle
2152 * Variables :
2153 * Result :
2154 * Remark :
2155 * Status : UNTESTED STUB
2156 *
2157 * Stub Generated through PE2LX Stubwizard 0.02 from Markus Montkowski
2158 *
2159 * Author : Markus Montkowski [09.07.98 22:00:46]
2160 *****************************************************************************/
2161ODINFUNCTION9(NET_API_STATUS, OS2NetSessionEnum,
2162 LPWSTR, servername,
2163 LPWSTR, UncClientName,
2164 LPWSTR, username,
2165 DWORD, level,
2166 LPBYTE *, bufptr,
2167 DWORD, prefmaxlen,
2168 LPDWORD, entriesread,
2169 LPDWORD, totalentries,
2170 LPDWORD, resume_handle)
2171
2172{
2173
2174 dprintf(("NETAPI32: NetSessionEnum(%s, %s, %s, %d, %08x, %d, %08x, %08x, %08x) not implemented\n"
2175 ,servername, UncClientName, username, level, *bufptr, prefmaxlen, entriesread, totalentries, resume_handle
2176 ));
2177
2178 return (NERR_BASE);
2179}
2180
2181/*****************************************************************************
2182 * Name : NET_API_STATUS NetSessionGetInfo
2183 * Purpose :
2184 * Parameters: LPWSTR servername
2185 * LPWSTR UncClientName
2186 * LPWSTR username
2187 * DWORD level
2188 * LPBYTE *bufptr
2189 * Variables :
2190 * Result :
2191 * Remark :
2192 * Status : UNTESTED STUB
2193 *
2194 * Stub Generated through PE2LX Stubwizard 0.02 from Markus Montkowski
2195 *
2196 * Author : Markus Montkowski [09.07.98 22:01:17]
2197 *****************************************************************************/
2198ODINFUNCTION5(NET_API_STATUS, OS2NetSessionGetInfo,
2199 LPWSTR, servername,
2200 LPWSTR, UncClientName,
2201 LPWSTR, username,
2202 DWORD, level,
2203 LPBYTE *, bufptr)
2204
2205{
2206
2207 dprintf(("NETAPI32: NetSessionGetInfo(%s, %s, %s, %d, %08x) not implemented\n"
2208 ,servername, UncClientName, username, level, *bufptr
2209 ));
2210
2211 return (NERR_BASE);
2212}
2213/*****************************************************************************
2214 * Name : NET_API_STATUS NetShareAdd
2215 * Purpose :
2216 * Parameters: LPWSTR servername
2217 * DWORD level
2218 * LPBYTE buf
2219 * LPDWORD parm_err
2220 * Variables :
2221 * Result :
2222 * Remark :
2223 * Status : UNTESTED STUB
2224 *
2225 * Stub Generated through PE2LX Stubwizard 0.02 from Markus Montkowski
2226 *
2227 * Author : Markus Montkowski [09.07.98 22:01:48]
2228 *****************************************************************************/
2229ODINFUNCTION4(NET_API_STATUS, OS2NetShareAdd,
2230 LPWSTR, servername,
2231 DWORD, level,
2232 LPBYTE, buf,
2233 LPDWORD, parm_err)
2234
2235{
2236
2237 dprintf(("NETAPI32: NetShareAdd(%s, %d, %08x, %08x) not implemented\n"
2238 ,servername, level, buf, parm_err
2239 ));
2240
2241 return (NERR_BASE);
2242}
2243
2244
2245/*****************************************************************************
2246 * Name : NET_API_STATUS NetShareCheck
2247 * Purpose :
2248 * Parameters: LPWSTR servername
2249 * LPWSTR device
2250 * LPDWORD type
2251 * Variables :
2252 * Result :
2253 * Remark :
2254 * Status : UNTESTED STUB
2255 *
2256 * Stub Generated through PE2LX Stubwizard 0.02 from Markus Montkowski
2257 *
2258 * Author : Markus Montkowski [09.07.98 22:02:16]
2259 *****************************************************************************/
2260ODINFUNCTION3(NET_API_STATUS, OS2NetShareCheck,
2261 LPWSTR, servername,
2262 LPWSTR, device,
2263 LPDWORD, type)
2264
2265{
2266
2267 dprintf(("NETAPI32: NetShareCheck(%s, %s, %08x) not implemented\n"
2268 ,servername, device, type
2269 ));
2270
2271 return (NERR_BASE);
2272}
2273
2274
2275/*****************************************************************************
2276 * Name : NET_API_STATUS NetShareDel
2277 * Purpose :
2278 * Parameters: LPWSTR servername
2279 * LPWSTR netname
2280 * DWORD reserved
2281 * Variables :
2282 * Result :
2283 * Remark :
2284 * Status : UNTESTED STUB
2285 *
2286 * Stub Generated through PE2LX Stubwizard 0.02 from Markus Montkowski
2287 *
2288 * Author : Markus Montkowski [09.07.98 22:03:01]
2289 *****************************************************************************/
2290ODINFUNCTION3(NET_API_STATUS, OS2NetShareDel,
2291 LPWSTR, servername,
2292 LPWSTR, netname,
2293 DWORD, reserved)
2294
2295{
2296
2297 dprintf(("NETAPI32: NetShareDel(%s, %s, %d) not implemented\n"
2298 ,servername, netname, reserved
2299 ));
2300
2301 return (NERR_BASE);
2302}
2303
2304
2305/*****************************************************************************
2306 * Name : NET_API_STATUS NetShareGetInfo
2307 * Purpose :
2308 * Parameters: LPWSTR servername
2309 * LPWSTR netname
2310 * DWORD level
2311 * LPBYTE *bufptr
2312 * Variables :
2313 * Result :
2314 * Remark :
2315 * Status : UNTESTED STUB
2316 *
2317 * Stub Generated through PE2LX Stubwizard 0.02 from Markus Montkowski
2318 *
2319 * Author : Markus Montkowski [09.07.98 22:03:39]
2320 *****************************************************************************/
2321ODINFUNCTION4(NET_API_STATUS, OS2NetShareGetInfo,
2322 LPWSTR, servername,
2323 LPWSTR, netname,
2324 DWORD, level,
2325 LPBYTE *, bufptr)
2326
2327{
2328
2329 dprintf(("NETAPI32: NetShareGetInfo(%s, %s, %d, %08x) not implemented\n"
2330 ,servername, netname, level, *bufptr
2331 ));
2332
2333 return (NERR_BASE);
2334}
2335/*****************************************************************************
2336 * Name : NET_API_STATUS NetShareSetInfo
2337 * Purpose :
2338 * Parameters: LPWSTR servername
2339 * LPWSTR netname
2340 * DWORD level
2341 * LPBYTE buf
2342 * LPDWORD parm_err
2343 * Variables :
2344 * Result :
2345 * Remark :
2346 * Status : UNTESTED STUB
2347 *
2348 * Stub Generated through PE2LX Stubwizard 0.02 from Markus Montkowski
2349 *
2350 * Author : Markus Montkowski [09.07.98 22:04:00]
2351 *****************************************************************************/
2352ODINFUNCTION5(NET_API_STATUS, OS2NetShareSetInfo,
2353 LPWSTR, servername,
2354 LPWSTR, netname,
2355 DWORD, level,
2356 LPBYTE, buf,
2357 LPDWORD, parm_err)
2358
2359{
2360
2361 dprintf(("NETAPI32: NetShareSetInfo(%s, %s, %d, %08x, %08x) not implemented\n"
2362 ,servername, netname, level, buf, parm_err
2363 ));
2364
2365 return (NERR_BASE);
2366}
2367
2368/*****************************************************************************
2369 * Name : NET_API_STATUS NetStatisticsGet2
2370 * Purpose :
2371 * Parameters: LPWSTR server
2372 * LPWSTR service
2373 * DWORD level
2374 * DWORD options
2375 * LPBYTE *bufptr
2376 * Variables :
2377 * Result :
2378 * Remark :
2379 * Status : UNTESTED STUB
2380 *
2381 * Stub Generated through PE2LX Stubwizard 0.02 from Markus Montkowski
2382 *
2383 * Author : Markus Montkowski [09.07.98 22:04:44]
2384 *****************************************************************************/
2385/* Not in DLL but in SDK doc
2386ODINFUNCTION5(NET_API_STATUS, OS2NetStatisticsGet2,
2387 LPWSTR, server,
2388 LPWSTR, service,
2389 DWORD, level,
2390 DWORD, options,
2391 LPBYTE *, bufptr)
2392
2393{
2394
2395 dprintf(("NETAPI32: NetStatisticsGet2(%s, %s, %d, %d, %08x) not implemented\n"
2396 ,server, service, level, options, *bufptr
2397 ));
2398
2399 return (NERR_BASE);
2400}
2401*/
2402
2403/*****************************************************************************
2404 * Name : NET_API_STATUS NetUserAdd
2405 * Purpose :
2406 * Parameters: LPWSTR servername
2407 * DWORD level
2408 * LPBYTE buf
2409 * LPDWORD parm_err
2410 * Variables :
2411 * Result :
2412 * Remark :
2413 * Status : UNTESTED STUB
2414 *
2415 * Stub Generated through PE2LX Stubwizard 0.02 from Markus Montkowski
2416 *
2417 * Author : Markus Montkowski [09.07.98 22:06:02]
2418 *****************************************************************************/
2419ODINFUNCTION4(NET_API_STATUS, OS2NetUserAdd,
2420 LPWSTR, servername,
2421 DWORD, level,
2422 LPBYTE, buf,
2423 LPDWORD, parm_err)
2424
2425{
2426
2427 dprintf(("NETAPI32: NetUserAdd(%08x, %d, %08x, %08x) not implemented\n"
2428 ,servername, level, buf, parm_err
2429 ));
2430
2431 return (NERR_BASE);
2432}
2433
2434/*****************************************************************************
2435 * Name : NET_API_STATUS NetUserChangePassword
2436 * Purpose :
2437 * Parameters: LPWSTR domainname
2438 * LPWSTR username
2439 * LPWSTR oldpassword
2440 * LPWSTR newpassword
2441 * Variables :
2442 * Result :
2443 * Remark :
2444 * Status : UNTESTED STUB
2445 *
2446 * Stub Generated through PE2LX Stubwizard 0.02 from Markus Montkowski
2447 *
2448 * Author : Markus Montkowski [09.07.98 22:06:12]
2449 *****************************************************************************/
2450ODINFUNCTION4(NET_API_STATUS, OS2NetUserChangePassword,
2451 LPWSTR, domainname,
2452 LPWSTR, username,
2453 LPWSTR, oldpassword,
2454 LPWSTR, newpassword)
2455
2456{
2457
2458 dprintf(("NETAPI32: NetUserChangePassword(%08x, %08x, %08x, %08x) not implemented\n"
2459 ,domainname, username, oldpassword, newpassword
2460 ));
2461
2462 return (NERR_BASE);
2463}
2464
2465/*****************************************************************************
2466 * Name : NET_API_STATUS NetUserDel
2467 * Purpose :
2468 * Parameters: LPWSTR servername
2469 * LPWSTR username
2470 * Variables :
2471 * Result :
2472 * Remark :
2473 * Status : UNTESTED STUB
2474 *
2475 * Stub Generated through PE2LX Stubwizard 0.02 from Markus Montkowski
2476 *
2477 * Author : Markus Montkowski [09.07.98 22:06:25]
2478 *****************************************************************************/
2479ODINFUNCTION2(NET_API_STATUS, OS2NetUserDel,
2480 LPWSTR, servername,
2481 LPWSTR, username)
2482
2483{
2484
2485 dprintf(("NETAPI32: NetUserDel(%08x, %08x) not implemented\n"
2486 ,servername, username
2487 ));
2488
2489 return (NERR_BASE);
2490}
2491
2492/*****************************************************************************
2493 * Name : NET_API_STATUS NetUserEnum
2494 * Purpose :
2495 * Parameters: LPWSTR servername
2496 * DWORD level
2497 * DWORD filter
2498 * LPBYTE *bufptr
2499 * DWORD prefmaxlen
2500 * LPDWORD entriesread
2501 * LPDWORD totalentries
2502 * LPDWORD resume_handle
2503 * Variables :
2504 * Result :
2505 * Remark :
2506 * Status : UNTESTED STUB
2507 *
2508 * Stub Generated through PE2LX Stubwizard 0.02 from Markus Montkowski
2509 *
2510 * Author : Markus Montkowski [09.07.98 22:06:36]
2511 *****************************************************************************/
2512ODINFUNCTION8(NET_API_STATUS, OS2NetUserEnum,
2513 LPWSTR, servername,
2514 DWORD, level,
2515 DWORD, filter,
2516 LPBYTE *, bufptr,
2517 DWORD, prefmaxlen,
2518 LPDWORD, entriesread,
2519 LPDWORD, totalentries,
2520 LPDWORD, resume_handle)
2521
2522{
2523
2524 dprintf(("NETAPI32: NetUserEnum(%08x, %d, %d, %08x, %d, %08x, %08x, %08x) not implemented\n"
2525 ,servername, level, filter, *bufptr, prefmaxlen, entriesread, totalentries, resume_handle
2526 ));
2527
2528 return (NERR_BASE);
2529}
2530
2531/*****************************************************************************
2532 * Name : NET_API_STATUS NetUserGetGroups
2533 * Purpose :
2534 * Parameters: LPWSTR servername
2535 * LPWSTR username
2536 * DWORD level
2537 * LPBYTE *bufptr
2538 * DWORD prefmaxlen
2539 * LPDWORD entriesread
2540 * LPDWORD totalentries
2541 * Variables :
2542 * Result :
2543 * Remark :
2544 * Status : UNTESTED STUB
2545 *
2546 * Stub Generated through PE2LX Stubwizard 0.02 from Markus Montkowski
2547 *
2548 * Author : Markus Montkowski [09.07.98 22:06:50]
2549 *****************************************************************************/
2550ODINFUNCTION7(NET_API_STATUS, OS2NetUserGetGroups,
2551 LPWSTR, servername,
2552 LPWSTR, username,
2553 DWORD, level,
2554 LPBYTE *, bufptr,
2555 DWORD, prefmaxlen,
2556 LPDWORD, entriesread,
2557 LPDWORD, totalentries)
2558
2559{
2560
2561 dprintf(("NETAPI32: NetUserGetGroups(%08x, %08x, %d, %08x, %d, %08x, %08x) not implemented\n"
2562 ,servername, username, level, *bufptr, prefmaxlen, entriesread, totalentries
2563 ));
2564
2565 return (NERR_BASE);
2566}
2567
2568/*****************************************************************************
2569 * Name : NET_API_STATUS NetUserGetInfo
2570 * Purpose :
2571 * Parameters: LPWSTR servername
2572 * LPWSTR username
2573 * DWORD level
2574 * LPBYTE *bufptr
2575 * Variables :
2576 * Result :
2577 * Remark :
2578 * Status : UNTESTED STUB
2579 *
2580 * Stub Generated through PE2LX Stubwizard 0.02 from Markus Montkowski
2581 *
2582 * Author : Markus Montkowski [09.07.98 22:09:52]
2583 *****************************************************************************/
2584ODINFUNCTION4(NET_API_STATUS, OS2NetUserGetInfo,
2585 LPWSTR, servername,
2586 LPWSTR, username,
2587 DWORD, level,
2588 LPBYTE *, bufptr)
2589
2590{
2591
2592 dprintf(("NETAPI32: NetUserGetInfo(%08x, %08x, %d, %08x) not implemented\n"
2593 ,servername, username, level, *bufptr
2594 ));
2595
2596 return (NERR_BASE);
2597}
2598
2599/*****************************************************************************
2600 * Name : NET_API_STATUS NetUserGetLocalGroups
2601 * Purpose :
2602 * Parameters: LPWSTR servername
2603 * LPWSTR username
2604 * DWORD level
2605 * DWORD flags
2606 * LPBYTE *bufptr
2607 * DWORD prefmaxlen
2608 * LPDWORD entriesread
2609 * LPDWORD totalentries
2610 * Variables :
2611 * Result :
2612 * Remark :
2613 * Status : UNTESTED STUB
2614 *
2615 * Stub Generated through PE2LX Stubwizard 0.02 from Markus Montkowski
2616 *
2617 * Author : Markus Montkowski [09.07.98 22:10:01]
2618 *****************************************************************************/
2619ODINFUNCTION8(NET_API_STATUS, OS2NetUserGetLocalGroups,
2620 LPWSTR, servername,
2621 LPWSTR, username,
2622 DWORD, level,
2623 DWORD, flags,
2624 LPBYTE *, bufptr,
2625 DWORD, prefmaxlen,
2626 LPDWORD, entriesread,
2627 LPDWORD, totalentries)
2628
2629{
2630
2631 dprintf(("NETAPI32: NetUserGetLocalGroups(%08x, %08x, %d, %d, %08x, %d, %08x, %08x) not implemented\n"
2632 ,servername, username, level, flags, *bufptr, prefmaxlen, entriesread, totalentries
2633 ));
2634
2635 return (NERR_BASE);
2636}
2637
2638/*****************************************************************************
2639 * Name : NET_API_STATUS NetUserModalsGet
2640 * Purpose :
2641 * Parameters: LPWSTR servername
2642 * DWORD level
2643 * LPBYTE *bufptr
2644 * Variables :
2645 * Result :
2646 * Remark :
2647 * Status : UNTESTED STUB
2648 *
2649 * Stub Generated through PE2LX Stubwizard 0.02 from Markus Montkowski
2650 *
2651 * Author : Markus Montkowski [09.07.98 22:10:22]
2652 *****************************************************************************/
2653ODINFUNCTION3(NET_API_STATUS, OS2NetUserModalsGet,
2654 LPWSTR, servername,
2655 DWORD, level,
2656 LPBYTE *, bufptr)
2657
2658{
2659
2660 dprintf(("NETAPI32: NetUserModalsGet(%08x, %d, %08x) not implemented\n"
2661 ,servername, level, *bufptr
2662 ));
2663
2664 return (NERR_BASE);
2665}
2666
2667/*****************************************************************************
2668 * Name : NET_API_STATUS NetUserModalsSet
2669 * Purpose :
2670 * Parameters: LPWSTR servername
2671 * DWORD level
2672 * LPBYTE buf
2673 * LPDWORD parm_err
2674 * Variables :
2675 * Result :
2676 * Remark :
2677 * Status : UNTESTED STUB
2678 *
2679 * Stub Generated through PE2LX Stubwizard 0.02 from Markus Montkowski
2680 *
2681 * Author : Markus Montkowski [09.07.98 22:10:31]
2682 *****************************************************************************/
2683ODINFUNCTION4(NET_API_STATUS, OS2NetUserModalsSet,
2684 LPWSTR, servername,
2685 DWORD, level,
2686 LPBYTE, buf,
2687 LPDWORD, parm_err)
2688
2689{
2690
2691 dprintf(("NETAPI32: NetUserModalsSet(%08x, %d, %08x, %08x) not implemented\n"
2692 ,servername, level, buf, parm_err
2693 ));
2694
2695 return (NERR_BASE);
2696}
2697
2698/*****************************************************************************
2699 * Name : NET_API_STATUS NetUserSetGroups
2700 * Purpose :
2701 * Parameters: LPWSTR servername
2702 * LPWSTR username
2703 * DWORD level
2704 * LPBYTE buf
2705 * DWORD num_entries
2706 * Variables :
2707 * Result :
2708 * Remark :
2709 * Status : UNTESTED STUB
2710 *
2711 * Stub Generated through PE2LX Stubwizard 0.02 from Markus Montkowski
2712 *
2713 * Author : Markus Montkowski [09.07.98 22:10:44]
2714 *****************************************************************************/
2715ODINFUNCTION5(NET_API_STATUS, OS2NetUserSetGroups,
2716 LPWSTR, servername,
2717 LPWSTR, username,
2718 DWORD, level,
2719 LPBYTE, buf,
2720 DWORD, num_entries)
2721
2722{
2723
2724 dprintf(("NETAPI32: NetUserSetGroups(%08x, %08x, %d, %08x, %d) not implemented\n"
2725 ,servername, username, level, buf, num_entries
2726 ));
2727
2728 return (NERR_BASE);
2729}
2730
2731/*****************************************************************************
2732 * Name : NET_API_STATUS NetUserSetInfo
2733 * Purpose :
2734 * Parameters: LPWSTR servername
2735 * LPWSTR username
2736 * DWORD level
2737 * LPBYTE buf
2738 * LPDWORD parm_err
2739 * Variables :
2740 * Result :
2741 * Remark :
2742 * Status : UNTESTED STUB
2743 *
2744 * Stub Generated through PE2LX Stubwizard 0.02 from Markus Montkowski
2745 *
2746 * Author : Markus Montkowski [09.07.98 22:11:04]
2747 *****************************************************************************/
2748ODINFUNCTION5(NET_API_STATUS, OS2NetUserSetInfo,
2749 LPWSTR, servername,
2750 LPWSTR, username,
2751 DWORD, level,
2752 LPBYTE, buf,
2753 LPDWORD, parm_err)
2754
2755{
2756
2757 dprintf(("NETAPI32: NetUserSetInfo(%08x, %08x, %d, %08x, %08x) not implemented\n"
2758 ,servername, username, level, buf, parm_err
2759 ));
2760
2761 return (NERR_BASE);
2762}
2763
2764/*****************************************************************************
2765 * Name : NET_API_STATUS NetWkstaGetInfo
2766 * Purpose :
2767 * Parameters: LPWSTR servername
2768 * DWORD level
2769 * LPBYTE *bufptr
2770 * Variables :
2771 * Result :
2772 * Remark : NT understands modes 100, 101, 102, 302, 402, and 502
2773 * The APIs allocate the buffer dynamically.
2774 * Status : UNTESTED STUB
2775 *
2776 * Stub Generated through PE2LX Stubwizard 0.02 from Markus Montkowski
2777 *
2778 * Author : Markus Montkowski [09.07.98 22:11:21]
2779 *****************************************************************************/
2780ODINFUNCTION3(NET_API_STATUS, OS2NetWkstaGetInfo,
2781 LPWSTR, servername,
2782 DWORD, level,
2783 LPBYTE *, bufptr)
2784
2785{
2786 dprintf(("NETAPI32: NetWkstaGetInfo(%s, %d, %08x)\n"
2787 ,servername, level, *bufptr
2788 ));
2789
2790 // Convert servername to ASCII
2791 char *asciiServername = NULL;
2792 if (servername) asciiServername = UnicodeToAsciiString(servername);
2793
2794 // @@@PH convert information modes!
2795 int iOS2Level = 100;
2796 switch (level)
2797 {
2798 case 100: iOS2Level = 10; break;
2799 case 101: iOS2Level = 1; break;
2800 case 102: iOS2Level = 1; break;
2801 case 302: iOS2Level = 1; break;
2802 case 402: iOS2Level = 1; break;
2803 case 502: iOS2Level = 1; break;
2804 }
2805
2806 ULONG ulBytesAvailable;
2807 DWORD rc;
2808
2809 // determine required size of buffer
2810 char pOS2Buffer[4096];
2811 rc = OSLibNetWkstaGetInfo((const unsigned char*)asciiServername,
2812 iOS2Level,
2813 (unsigned char*)pOS2Buffer,
2814 sizeof(pOS2Buffer),
2815 &ulBytesAvailable);
2816 if (asciiServername) FreeAsciiString(asciiServername);
2817
2818 if (rc == NERR_OK)
2819 {
2820 // @@@PH now convert the requested structure to UNICODE
2821 switch (level)
2822 {
2823 case 100: // system information - guest access
2824 {
2825 PWKSTA_INFO_100 pwki100;
2826 struct wksta_info_10 *pOS2wki10 = (struct wksta_info_10 *)pOS2Buffer;
2827
2828 // calculate new size for target buffer
2829 int iSizeComputername = (lstrlenA((LPCSTR)pOS2wki10->wki10_computername) + 1) * 2;
2830 int iSizeLangroup = (lstrlenA((LPCSTR)pOS2wki10->wki10_langroup) + 1) * 2;
2831 int iSize = sizeof(WKSTA_INFO_100) + iSizeComputername + iSizeLangroup;
2832
2833 rc = OS2NetApiBufferAllocate(iSize, (LPVOID*)&pwki100);
2834 if (!rc)
2835 {
2836 // pointer to the data area
2837 PBYTE pData = (PBYTE)pwki100 + sizeof(WKSTA_INFO_100);
2838
2839 pwki100->wki100_platform_id = 0; //@@@PH dummy
2840 pwki100->wki100_computername = lstrcpyAtoW( (LPWSTR)pData, (LPCSTR)pOS2wki10->wki10_computername);
2841 pData += iSizeComputername;
2842 pwki100->wki100_langroup = lstrcpyAtoW( (LPWSTR)pData, (LPCSTR)pOS2wki10->wki10_langroup);
2843 pData += iSizeLangroup;
2844 pwki100->wki100_ver_major = pOS2wki10->wki10_ver_major;
2845 pwki100->wki100_ver_minor = pOS2wki10->wki10_ver_minor;
2846 }
2847
2848 // the caller is responsible for freeing the memory!
2849 *bufptr = (LPBYTE)pwki100;
2850 break;
2851 }
2852
2853
2854 case 101: // system information - guest access
2855 {
2856 PWKSTA_INFO_101 pwki101;
2857 struct wksta_info_1 *pOS2wki1 = (struct wksta_info_1 *)pOS2Buffer;
2858
2859 // calculate new size for target buffer
2860 int iSizeComputername = (lstrlenA((LPCSTR)pOS2wki1->wki1_computername) + 1) * 2;
2861 int iSizeLangroup = (lstrlenA((LPCSTR)pOS2wki1->wki1_langroup) + 1) * 2;
2862 int iSizeLanroot = (lstrlenA((LPCSTR)pOS2wki1->wki1_root) + 1) * 2;
2863 int iSize = sizeof(WKSTA_INFO_101) + iSizeComputername + iSizeLangroup + iSizeLanroot;
2864
2865 rc = OS2NetApiBufferAllocate(iSize, (LPVOID*)&pwki101);
2866 if (!rc)
2867 {
2868 // pointer to the data area
2869 PBYTE pData = (PBYTE)pwki101 + sizeof(WKSTA_INFO_101);
2870
2871 pwki101->wki101_platform_id = 0; //@@@PH dummy
2872 pwki101->wki101_computername = lstrcpyAtoW( (LPWSTR)pData, (LPCSTR)pOS2wki1->wki1_computername);
2873 pData += iSizeComputername;
2874 pwki101->wki101_langroup = lstrcpyAtoW( (LPWSTR)pData, (LPCSTR)pOS2wki1->wki1_langroup);
2875 pData += iSizeLangroup;
2876 pwki101->wki101_ver_major = pOS2wki1->wki1_ver_major;
2877 pwki101->wki101_ver_minor = pOS2wki1->wki1_ver_minor;
2878 pwki101->wki101_lanroot = lstrcpyAtoW( (LPWSTR)pData, (LPCSTR)pOS2wki1->wki1_root);
2879 pData += iSizeLanroot;
2880 }
2881
2882 // the caller is responsible for freeing the memory!
2883 *bufptr = (LPBYTE)pwki101;
2884 break;
2885 }
2886
2887
2888 case 102: // system information - guest access
2889 {
2890 PWKSTA_INFO_102 pwki102;
2891 struct wksta_info_1 *pOS2wki1 = (struct wksta_info_1 *)pOS2Buffer;
2892
2893 // calculate new size for target buffer
2894 int iSizeComputername = (lstrlenA((LPCSTR)pOS2wki1->wki1_computername) + 1) * 2;
2895 int iSizeLangroup = (lstrlenA((LPCSTR)pOS2wki1->wki1_langroup) + 1) * 2;
2896 int iSizeLanroot = (lstrlenA((LPCSTR)pOS2wki1->wki1_root) + 1) * 2;
2897 int iSize = sizeof(WKSTA_INFO_102) + iSizeComputername + iSizeLangroup + iSizeLanroot;
2898
2899 rc = OS2NetApiBufferAllocate(iSize, (LPVOID*)&pwki102);
2900 if (!rc)
2901 {
2902 // pointer to the data area
2903 PBYTE pData = (PBYTE)pwki102 + sizeof(WKSTA_INFO_102);
2904
2905 pwki102->wki102_platform_id = 0; //@@@PH dummy
2906 pwki102->wki102_computername = lstrcpyAtoW( (LPWSTR)pData, (LPCSTR)pOS2wki1->wki1_computername);
2907 pData += iSizeComputername;
2908 pwki102->wki102_langroup = lstrcpyAtoW( (LPWSTR)pData, (LPCSTR)pOS2wki1->wki1_langroup);
2909 pData += iSizeLangroup;
2910 pwki102->wki102_ver_major = pOS2wki1->wki1_ver_major;
2911 pwki102->wki102_ver_minor = pOS2wki1->wki1_ver_minor;
2912 pwki102->wki102_lanroot = lstrcpyAtoW( (LPWSTR)pData, (LPCSTR)pOS2wki1->wki1_root);
2913 pData += iSizeLanroot;
2914 pwki102->wki102_logged_on_users = 0; // @@@PH dummy
2915 }
2916
2917 // the caller is responsible for freeing the memory!
2918 *bufptr = (LPBYTE)pwki102;
2919 break;
2920 }
2921
2922
2923 case 502: // system information - guest access
2924 {
2925 PWKSTA_INFO_502 pwki502;
2926 struct wksta_info_1 *pOS2wki1 = (struct wksta_info_1 *)pOS2Buffer;
2927
2928 rc = OS2NetApiBufferAllocate(sizeof(WKSTA_INFO_502), (LPVOID*)&pwki502);;
2929 if (!rc)
2930 {
2931 char *hs = (char *)pOS2wki1->wki1_wrkheuristics;
2932
2933 pwki502->wki502_char_wait = pOS2wki1->wki1_charwait;
2934 pwki502->wki502_collection_time = pOS2wki1->wki1_chartime;
2935 pwki502->wki502_maximum_collection_count = pOS2wki1->wki1_charcount;
2936 pwki502->wki502_keep_conn = pOS2wki1->wki1_keepconn;
2937 pwki502->wki502_max_cmds = pOS2wki1->wki1_maxcmds;
2938 pwki502->wki502_sess_timeout = pOS2wki1->wki1_sesstimeout;
2939 pwki502->wki502_siz_char_buf = pOS2wki1->wki1_sizcharbuf;
2940 pwki502->wki502_max_threads = pOS2wki1->wki1_maxthreads;
2941
2942 pwki502->wki502_lock_quota = 0;
2943 pwki502->wki502_lock_increment = 0;
2944 pwki502->wki502_lock_maximum = 0;
2945 pwki502->wki502_pipe_increment = 0;
2946 pwki502->wki502_pipe_maximum = 0;
2947 pwki502->wki502_cache_file_timeout = 0;
2948 pwki502->wki502_dormant_file_limit = 0;
2949 pwki502->wki502_read_ahead_throughput = 0;
2950
2951 pwki502->wki502_num_mailslot_buffers = pOS2wki1->wki1_mailslots;
2952 pwki502->wki502_num_srv_announce_buffers = pOS2wki1->wki1_numdgrambuf;
2953 pwki502->wki502_max_illegal_datagram_events = 0;
2954 pwki502->wki502_illegal_datagram_event_reset_frequency = 0;
2955 pwki502->wki502_log_election_packets = FALSE;
2956
2957 pwki502->wki502_use_opportunistic_locking = (hs[0] != '0') ? TRUE : FALSE;
2958 pwki502->wki502_use_unlock_behind = (hs[1] != '0') ? TRUE : FALSE;
2959 pwki502->wki502_use_close_behind = (hs[2] != '0') ? TRUE : FALSE;
2960 pwki502->wki502_buf_named_pipes = (hs[3] != '0') ? TRUE : FALSE;
2961 pwki502->wki502_use_lock_read_unlock = (hs[4] != '0') ? TRUE : FALSE;
2962 pwki502->wki502_utilize_nt_caching = TRUE; // sure we do ;-)
2963 pwki502->wki502_use_raw_read = (hs[12] != '0') ? TRUE : FALSE;
2964 pwki502->wki502_use_raw_write = (hs[13] != '0') ? TRUE : FALSE;
2965 pwki502->wki502_use_write_raw_data = (hs[29] != '0') ? TRUE : FALSE;
2966 pwki502->wki502_use_encryption = (hs[21] != '0') ? TRUE : FALSE;
2967 pwki502->wki502_buf_files_deny_write = (hs[23] != '0') ? TRUE : FALSE;
2968 pwki502->wki502_buf_read_only_files = (hs[24] != '0') ? TRUE : FALSE;
2969 pwki502->wki502_force_core_create_mode = (hs[27] != '0') ? TRUE : FALSE;
2970 pwki502->wki502_use_512_byte_max_transfer = FALSE; // @@@PH
2971 }
2972
2973 // the caller is responsible for freeing the memory!
2974 *bufptr = (LPBYTE)pwki502;
2975 break;
2976 }
2977 }
2978 }
2979
2980 // @@@PH convert return code to NT code
2981 return (rc);
2982}
2983
2984
2985/*****************************************************************************
2986 * Name : NET_API_STATUS NetWkstaSetInfo
2987 * Purpose :
2988 * Parameters: LPWSTR servername
2989 * DWORD level
2990 * LPBYTE buffer
2991 * LPDWORD parm_err
2992 * Variables :
2993 * Result :
2994 * Remark :
2995 * Status : UNTESTED STUB
2996 *
2997 * Stub Generated through PE2LX Stubwizard 0.02 from Markus Montkowski
2998 *
2999 * Author : Markus Montkowski [09.07.98 22:11:39]
3000 *****************************************************************************/
3001ODINFUNCTION4(NET_API_STATUS, OS2NetWkstaSetInfo,
3002 LPWSTR, servername,
3003 DWORD, level,
3004 LPBYTE, buffer,
3005 LPDWORD, parm_err)
3006
3007{
3008
3009 dprintf(("NETAPI32: NetWkstaSetInfo(%s, %d, %08x, %08x) not implemented\n"
3010 ,servername, level, buffer, parm_err
3011 ));
3012
3013 return (NERR_BASE);
3014}
3015
3016/*****************************************************************************
3017 * Name : NET_API_STATUS NetWkstaTransportAdd
3018 * Purpose :
3019 * Parameters: LPWSTR servername
3020 * DWORD level
3021 * LPBYTE buf
3022 * Variables :
3023 * Result :
3024 * Remark :
3025 * Status : UNTESTED STUB
3026 *
3027 * Stub Generated through PE2LX Stubwizard 0.02 from Markus Montkowski
3028 *
3029 * Author : Markus Montkowski [09.07.98 22:12:18]
3030 *****************************************************************************/
3031ODINFUNCTION3(NET_API_STATUS, OS2NetWkstaTransportAdd,
3032 LPWSTR, servername,
3033 DWORD, level,
3034 LPBYTE, buf)
3035
3036{
3037
3038 dprintf(("NETAPI32: NetWkstaTransportAdd(%s, %d, %08x)not implemented\n"
3039 ,servername, level, buf
3040 ));
3041
3042 return (NERR_BASE);
3043}
3044
3045/*****************************************************************************
3046 * Name : NET_API_STATUS NetWkstaTransportDel
3047 * Purpose :
3048 * Parameters: LPWSTR servername
3049 * LPWSTR transportname
3050 * DWORD ucond
3051 * Variables :
3052 * Result :
3053 * Remark :
3054 * Status : UNTESTED STUB
3055 *
3056 * Stub Generated through PE2LX Stubwizard 0.02 from Markus Montkowski
3057 *
3058 * Author : Markus Montkowski [09.07.98 22:13:11]
3059 *****************************************************************************/
3060ODINFUNCTION3(NET_API_STATUS, OS2NetWkstaTransportDel,
3061 LPWSTR, servername,
3062 LPWSTR, transportname,
3063 DWORD, ucond)
3064
3065{
3066
3067 dprintf(("NETAPI32: NetWkstaTransportDel(%08x, %08x, %d) not implemented\n"
3068 ,servername, transportname, ucond
3069 ));
3070
3071 return (NERR_BASE);
3072}
3073
3074/*****************************************************************************
3075 * Name : NET_API_STATUS NetWkstaTransportEnum
3076 * Purpose :
3077 * Parameters: LPWSTR servername
3078 * DWORD level
3079 * LPBYTE *bufptr
3080 * DWORD prefmaxlen
3081 * LPDWORD entriesread
3082 * LPDWORD totalentries
3083 * LPDWORD resumehandle
3084 * Variables :
3085 * Result :
3086 * Remark :
3087 * Status : UNTESTED STUB
3088 *
3089 * Stub Generated through PE2LX Stubwizard 0.02 from Markus Montkowski
3090 *
3091 * Author : Markus Montkowski [09.07.98 22:13:44]
3092 *****************************************************************************/
3093ODINFUNCTION7(NET_API_STATUS, OS2NetWkstaTransportEnum,
3094 LPWSTR, servername,
3095 DWORD, level,
3096 LPBYTE *, bufptr,
3097 DWORD, prefmaxlen,
3098 LPDWORD, entriesread,
3099 LPDWORD, totalentries,
3100 LPDWORD, resumehandle)
3101
3102{
3103
3104 dprintf(("NETAPI32: NetWkstaTransportEnum(%08x, %d, %08x, %d, %08x, %08x, %08x) not implemented\n"
3105 ,servername, level, *bufptr, prefmaxlen, entriesread, totalentries, resumehandle
3106 ));
3107
3108 return (NERR_BASE);
3109}
3110
3111/*****************************************************************************
3112 * Name : NET_API_STATUS NetWkstaUserEnum
3113 * Purpose :
3114 * Parameters: LPWSTR servername
3115 * DWORD level
3116 * LPBYTE *bufptr
3117 * DWORD prefmaxlen
3118 * LPDWORD entriesread
3119 * LPDWORD totalentries
3120 * LPDWORD resumehandle
3121 * Variables :
3122 * Result :
3123 * Remark :
3124 * Status : UNTESTED STUB
3125 *
3126 * Stub Generated through PE2LX Stubwizard 0.02 from Markus Montkowski
3127 *
3128 * Author : Markus Montkowski [09.07.98 22:14:05]
3129 *****************************************************************************/
3130ODINFUNCTION7(NET_API_STATUS, OS2NetWkstaUserEnum,
3131 LPWSTR, servername,
3132 DWORD, level,
3133 LPBYTE *, bufptr,
3134 DWORD, prefmaxlen,
3135 LPDWORD, entriesread,
3136 LPDWORD, totalentries,
3137 LPDWORD, resumehandle)
3138
3139{
3140
3141 dprintf(("NETAPI32: NetWkstaUserEnum(%08x, %d, %08x, %d, %08x, %08x, %08x) not implemented\n"
3142 ,servername, level, *bufptr, prefmaxlen, entriesread, totalentries, resumehandle
3143 ));
3144
3145 return (NERR_BASE);
3146}
3147
3148/*****************************************************************************
3149 * Name : NET_API_STATUS NetWkstaUserGetInfo
3150 * Purpose :
3151 * Parameters: LPWSTR reserved
3152 * DWORD level
3153 * LPBYTE *bufptr
3154 * Variables :
3155 * Result :
3156 * Remark :
3157 * Status : UNTESTED STUB
3158 *
3159 * Stub Generated through PE2LX Stubwizard 0.02 from Markus Montkowski
3160 *
3161 * Author : Markus Montkowski [09.07.98 22:14:17]
3162 *****************************************************************************/
3163ODINFUNCTION3(NET_API_STATUS, OS2NetWkstaUserGetInfo,
3164 LPWSTR, reserved,
3165 DWORD, level,
3166 LPBYTE *, bufptr)
3167
3168{
3169
3170 dprintf(("NETAPI32: NetWkstaUserGetInfo(%08x, %d, %08x) not implemented\n"
3171 ,reserved, level, *bufptr
3172 ));
3173
3174 return (NERR_BASE);
3175}
3176
3177/*****************************************************************************
3178 * Name : NET_API_STATUS NetWkstaUserSetInfo
3179 * Purpose :
3180 * Parameters: LPWSTR reserved
3181 * DWORD level
3182 * LPBYTE buf
3183 * LPDWORD parm_err
3184 * Variables :
3185 * Result :
3186 * Remark :
3187 * Status : UNTESTED STUB
3188 *
3189 * Stub Generated through PE2LX Stubwizard 0.02 from Markus Montkowski
3190 *
3191 * Author : Markus Montkowski [09.07.98 22:16:08]
3192 *****************************************************************************/
3193ODINFUNCTION4(NET_API_STATUS, OS2NetWkstaUserSetInfo,
3194 LPWSTR, reserved,
3195 DWORD, level,
3196 LPBYTE, buf,
3197 LPDWORD, parm_err)
3198
3199{
3200
3201 dprintf(("NETAPI32: NetWkstaUserSetInfo(%08x, %d, %08x, %08x) not implemented\n"
3202 ,reserved, level, buf, parm_err
3203 ));
3204
3205 return (NERR_BASE);
3206}
3207
3208
3209
3210/*****************************************************************************
3211 * Name : NET_API_STATUS NetConfigSet
3212 * Purpose : configure a network component
3213 * Parameters: LPWSTR lpServer
3214 * LPWSTR lpReserved1
3215 * LPWSTR lpComponent
3216 * DWORD dwLevel
3217 * DWORD dwReserved2
3218 * LPBYTE lpBuf
3219 * DWORD dwReserved3
3220 * Variables :
3221 * Result :
3222 * Remark :
3223 * Status : UNTESTED STUB
3224 *
3225 * Author : Patrick Haller [Thu, 1999/08/18 00:15]
3226 *****************************************************************************/
3227
3228ODINFUNCTION7(NET_API_STATUS,OS2NetConfigSet,LPWSTR, lpServer,
3229 LPWSTR, lpReserved1,
3230 LPWSTR, lpComponent,
3231 DWORD, dwLevel,
3232 DWORD, dwReserved2,
3233 LPBYTE, lpBuf,
3234 DWORD, dwReserved3)
3235{
3236 dprintf(("NETAPI32: NetConfigSet not implemented\n"));
3237
3238 return (NERR_BASE);
3239}
3240
3241
3242/*****************************************************************************
3243 * Name : NET_API_STATUS NetConfigGet
3244 * Purpose : get configuration from a network component
3245 * Parameters: LPWSTR lpServer
3246 * LPWSTR lpComponent
3247 * LPWSTR lpParameter
3248 * LPBYTE lpBuf
3249 * Variables :
3250 * Result :
3251 * Remark :
3252 * Status : UNTESTED STUB
3253 *
3254 * Author : Patrick Haller [Thu, 1999/08/18 00:15]
3255 *****************************************************************************/
3256
3257ODINFUNCTION4(NET_API_STATUS,OS2NetConfigGet,LPWSTR, lpServer,
3258 LPWSTR, lpComponent,
3259 LPWSTR, lpParameter,
3260 LPBYTE, lpBuf)
3261{
3262 dprintf(("NETAPI32: NetConfigGet not implemented\n"));
3263
3264 return (NERR_BASE);
3265}
3266
3267
3268/*****************************************************************************
3269 * Name : NET_API_STATUS RxNetAccessSetInfo
3270 * Purpose :
3271 * Parameters: wrong
3272 * Variables :
3273 * Result :
3274 * Remark :
3275 * Status : UNTESTED STUB
3276 *
3277 * Author : Patrick Haller [Thu, 1999/08/18 00:15]
3278 *****************************************************************************/
3279
3280ODINFUNCTION6(NET_API_STATUS, OS2RxNetAccessSetInfo,
3281 DWORD, x1,
3282 DWORD, x2,
3283 DWORD, x3,
3284 DWORD, x4,
3285 DWORD, x5,
3286 DWORD, x6)
3287{
3288 dprintf(("NETAPI32: RxNetAccessSetInfo(%08x, %08xh, %08xh, %08xh, %08xh, %08xh) not implemented\n",
3289 x1,
3290 x2,
3291 x3,
3292 x4,
3293 x5,
3294 x6));
3295
3296 return (NERR_BASE);
3297}
3298
3299
3300/*****************************************************************************
3301 * Name : NET_API_STATUS RxNetAccessGetInfo
3302 * Purpose :
3303 * Parameters: wrong
3304 * Variables :
3305 * Result :
3306 * Remark :
3307 * Status : UNTESTED STUB
3308 *
3309 * Author : Patrick Haller [Thu, 1999/08/18 00:15]
3310 *****************************************************************************/
3311
3312ODINFUNCTION6(NET_API_STATUS, OS2RxNetAccessGetInfo,
3313 DWORD, x1,
3314 DWORD, x2,
3315 DWORD, x3,
3316 DWORD, x4,
3317 DWORD, x5,
3318 DWORD, x6)
3319{
3320 dprintf(("NETAPI32: RxNetAccessGetInfo(%08x, %08xh, %08xh, %08xh, %08xh, %08xh) not implemented\n",
3321 x1,
3322 x2,
3323 x3,
3324 x4,
3325 x5,
3326 x6));
3327
3328 return (NERR_BASE);
3329}
3330
3331
3332
3333/*****************************************************************************
3334 * Name : NET_API_STATUS I_NetGetDCList
3335 * Purpose :
3336 * Parameters: wrong
3337 * Variables :
3338 * Result :
3339 * Remark :
3340 * Status : UNTESTED STUB
3341 *
3342 * Author : Patrick Haller [Thu, 1999/08/18 00:15]
3343 *****************************************************************************/
3344
3345ODINFUNCTION6(NET_API_STATUS, OS2I_NetGetDCList,
3346 DWORD, x1,
3347 DWORD, x2,
3348 DWORD, x3,
3349 DWORD, x4,
3350 DWORD, x5,
3351 DWORD, x6)
3352{
3353 dprintf(("NETAPI32: I_NetGetDCList(%08x, %08xh, %08xh, %08xh, %08xh, %08xh) not implemented\n",
3354 x1,
3355 x2,
3356 x3,
3357 x4,
3358 x5,
3359 x6));
3360
3361 return (NERR_BASE);
3362}
3363
3364
3365/*****************************************************************************
3366 * Name : NET_API_STATUS I_NetNameCanonicalize
3367 * Purpose :
3368 * Parameters: wrong
3369 * Variables :
3370 * Result :
3371 * Remark :
3372 * Status : UNTESTED STUB
3373 *
3374 * Author : Patrick Haller [Thu, 1999/08/18 00:15]
3375 *****************************************************************************/
3376
3377ODINFUNCTION4(NET_API_STATUS, OS2I_NetNameCanonicalize,
3378 DWORD, x1,
3379 DWORD, x2,
3380 DWORD, x3,
3381 DWORD, x4)
3382{
3383 dprintf(("NETAPI32: I_NetNameCanonicalize(%08x, %08xh, %08xh, %08xh) not implemented\n",
3384 x1,
3385 x2,
3386 x3,
3387 x4));
3388
3389 return (NERR_BASE);
3390}
3391
3392
3393
3394/*****************************************************************************
3395 * Name : NET_API_STATUS I_NetNameCompare
3396 * Purpose :
3397 * Parameters: wrong
3398 * Variables :
3399 * Result :
3400 * Remark :
3401 * Status : UNTESTED STUB
3402 *
3403 * Author : Patrick Haller [Thu, 1999/08/18 00:15]
3404 *****************************************************************************/
3405
3406ODINFUNCTION4(NET_API_STATUS, OS2I_NetNameCompare,
3407 DWORD, x1,
3408 DWORD, x2,
3409 DWORD, x3,
3410 DWORD, x4)
3411{
3412 dprintf(("NETAPI32: I_NetNameCompare(%08x, %08xh, %08xh, %08xh) not implemented\n",
3413 x1,
3414 x2,
3415 x3,
3416 x4));
3417
3418 return (NERR_BASE);
3419}
3420
3421
3422/*****************************************************************************
3423 * Name : NET_API_STATUS I_NetNameValidate
3424 * Purpose :
3425 * Parameters: wrong
3426 * Variables :
3427 * Result :
3428 * Remark :
3429 * Status : UNTESTED STUB
3430 *
3431 * Author : Patrick Haller [Thu, 1999/08/18 00:15]
3432 *****************************************************************************/
3433
3434ODINFUNCTION3(NET_API_STATUS, OS2I_NetNameValidate,
3435 DWORD, x1,
3436 DWORD, x2,
3437 DWORD, x3)
3438{
3439 dprintf(("NETAPI32: I_NetNameValidate(%08x, %08xh, %08xh) not implemented\n",
3440 x1,
3441 x2,
3442 x3));
3443
3444 return (NERR_BASE);
3445}
3446
3447
3448/*****************************************************************************
3449 * Name : NET_API_STATUS I_NetPathCanonicalize
3450 * Purpose :
3451 * Parameters: wrong
3452 * Variables :
3453 * Result :
3454 * Remark :
3455 * Status : UNTESTED STUB
3456 *
3457 * Author : Patrick Haller [Thu, 1999/08/18 00:15]
3458 *****************************************************************************/
3459
3460ODINFUNCTION4(NET_API_STATUS, OS2I_NetPathCanonicalize,
3461 DWORD, x1,
3462 DWORD, x2,
3463 DWORD, x3,
3464 DWORD, x4)
3465{
3466 dprintf(("NETAPI32: I_NetPathCanonicalize(%08x, %08xh, %08xh, %08xh) not implemented\n",
3467 x1,
3468 x2,
3469 x3,
3470 x4));
3471
3472 return (NERR_BASE);
3473}
3474
3475
3476
3477/*****************************************************************************
3478 * Name : NET_API_STATUS I_NetPathCompare
3479 * Purpose :
3480 * Parameters: wrong
3481 * Variables :
3482 * Result :
3483 * Remark :
3484 * Status : UNTESTED STUB
3485 *
3486 * Author : Patrick Haller [Thu, 1999/08/18 00:15]
3487 *****************************************************************************/
3488
3489ODINFUNCTION4(NET_API_STATUS, OS2I_NetPathCompare,
3490 DWORD, x1,
3491 DWORD, x2,
3492 DWORD, x3,
3493 DWORD, x4)
3494{
3495 dprintf(("NETAPI32: I_NetPathCompare(%08x, %08xh, %08xh, %08xh) not implemented\n",
3496 x1,
3497 x2,
3498 x3,
3499 x4));
3500
3501 return (NERR_BASE);
3502}
3503
3504
3505/*****************************************************************************
3506 * Name : NET_API_STATUS I_NetPathType
3507 * Purpose :
3508 * Parameters: wrong
3509 * Variables :
3510 * Result :
3511 * Remark :
3512 * Status : UNTESTED STUB
3513 *
3514 * Author : Patrick Haller [Thu, 1999/08/18 00:15]
3515 *****************************************************************************/
3516
3517ODINFUNCTION2(NET_API_STATUS, OS2I_NetPathType,
3518 DWORD, x1,
3519 DWORD, x2)
3520{
3521 dprintf(("NETAPI32: I_NetPathType(%08x, %08xh) not implemented\n",
3522 x1,
3523 x2));
3524
3525 return (NERR_BASE);
3526}
3527
3528
3529/*****************************************************************************
3530 * Name : NET_API_STATUS NetapipBufferAllocate
3531 * Purpose :
3532 * Parameters: wrong
3533 * Variables :
3534 * Result :
3535 * Remark :
3536 * Status : UNTESTED STUB
3537 *
3538 * Author : Patrick Haller [Thu, 1999/08/18 00:15]
3539 *****************************************************************************/
3540
3541ODINFUNCTION3(NET_API_STATUS, OS2NetapipBufferAllocate,
3542 DWORD, x1,
3543 DWORD, x2,
3544 DWORD, x3)
3545{
3546 dprintf(("NETAPI32: NetapipBufferAllocate(%08x, %08xh, %08xh) not implemented\n",
3547 x1,
3548 x2,
3549 x3));
3550
3551 return (NERR_BASE);
3552}
3553
3554
3555/*****************************************************************************
3556 * Name : NET_API_STATUS NetUseAdd
3557 * Purpose : add remote device association
3558 * Parameters: LPWSTR lpUncServerName
3559 * DWORD dwLevel
3560 * LPBYTE lpBuf
3561 * LPDWORD lpParmError
3562 * Variables :
3563 * Result :
3564 * Remark :
3565 * Status : UNTESTED STUB
3566 *
3567 * Author : Patrick Haller [Thu, 1999/08/18 00:15]
3568 *****************************************************************************/
3569
3570ODINFUNCTION4(NET_API_STATUS, OS2NetUseAdd,
3571 LPWSTR, lpUncServerName,
3572 DWORD, dwLevel,
3573 LPBYTE, lpBuf,
3574 LPDWORD, lpParmError)
3575{
3576 dprintf(("NETAPI32: NetUseAdd(%08xh,%08xh,%08xh,%08xh) not implemented\n",
3577 lpUncServerName,
3578 dwLevel,
3579 lpBuf,
3580 lpParmError));
3581
3582 return (NERR_BASE);
3583}
3584
3585
3586/*****************************************************************************
3587 * Name : NET_API_STATUS NetUseDel
3588 * Purpose : remove remote device association
3589 * Parameters: LPWSTR lpUncServerName
3590 * LPWSTR lpUseName
3591 * DWORD dwForceCond
3592 * Variables :
3593 * Result :
3594 * Remark :
3595 * Status : UNTESTED STUB
3596 *
3597 * Author : Patrick Haller [Thu, 1999/08/18 00:15]
3598 *****************************************************************************/
3599
3600ODINFUNCTION3(NET_API_STATUS, OS2NetUseDel,
3601 LPWSTR, lpUncServerName,
3602 LPWSTR, lpUseName,
3603 DWORD, dwForceCond)
3604{
3605 dprintf(("NETAPI32: NetUseDel(%08xh,%08xh,%08xh) not implemented\n",
3606 lpUncServerName,
3607 lpUseName,
3608 dwForceCond));
3609
3610 return (NERR_BASE);
3611}
3612
3613
3614
3615/*****************************************************************************
3616 * Name : NET_API_STATUS NetServiceControl
3617 * Purpose : controls operations of network services
3618 * Parameters: LPWSTR lpServerName
3619 * LPWSTR lpService
3620 * DWORD dwOpcode
3621 * DWORD dwArgument
3622 * LPBYTE* bufptr
3623 * Variables :
3624 * Result :
3625 * Remark :
3626 * Status : UNTESTED STUB
3627 *
3628 * Author : Patrick Haller [Thu, 1999/08/18 00:15]
3629 *****************************************************************************/
3630
3631ODINFUNCTION5(NET_API_STATUS, OS2NetServiceControl,
3632 LPWSTR, lpServerName,
3633 LPWSTR, lpService,
3634 DWORD, dwOpcode,
3635 DWORD, dwArgument,
3636 LPBYTE*, bufptr)
3637{
3638 dprintf(("NETAPI32: NetServiceControl(%08xh,%08xh,%08xh,%08xh,%08xh) not implemented\n",
3639 lpServerName,
3640 lpService,
3641 dwOpcode,
3642 dwArgument,
3643 bufptr));
3644
3645 return (NERR_BASE);
3646}
3647
3648
3649/*****************************************************************************
3650 * Name : NET_API_STATUS NetServiceEnum
3651 * Purpose : retrieves information about all started services
3652 * Parameters: LPWSTR lpServerName
3653 * DWORD dwLevel
3654 * LPBYTE* bufptr
3655 * DWORD dwPrefMaxLen
3656 * LPDWORD lpdEntriesRead
3657 * LPDWORD lpdTotalEntries
3658 * LPDWORD lpdResumeHandle
3659 * Variables :
3660 * Result :
3661 * Remark :
3662 * Status : UNTESTED STUB
3663 *
3664 * Author : Patrick Haller [Thu, 1999/08/18 00:15]
3665 *****************************************************************************/
3666
3667ODINFUNCTION7(NET_API_STATUS, OS2NetServiceEnum,
3668 LPWSTR, lpServerName,
3669 DWORD, dwLevel,
3670 LPBYTE*, bufptr,
3671 DWORD, dwPrefMaxLen,
3672 LPDWORD, lpdEntriesRead,
3673 LPDWORD, lpdTotalEntries,
3674 LPDWORD, lpdResumeHandle)
3675{
3676 dprintf(("NETAPI32: NetServiceEnum(%08xh,%08xh,%08xh,%08xh,%08xh,%08xh,%08xh) not implemented\n",
3677 lpServerName,
3678 dwLevel,
3679 bufptr,
3680 dwPrefMaxLen,
3681 lpdEntriesRead,
3682 lpdTotalEntries,
3683 lpdResumeHandle));
3684
3685 return (NERR_BASE);
3686}
3687
3688
3689/*****************************************************************************
3690 * Name : NET_API_STATUS NetServiceGetInfo
3691 * Purpose : retrieves information about a particular started service
3692 * Parameters: LPWSTR lpServerName
3693 * LPWSTR lpService
3694 * DWORD dwLevel
3695 * LPBYTE* bufptr
3696 * Variables :
3697 * Result :
3698 * Remark :
3699 * Status : UNTESTED STUB
3700 *
3701 * Author : Patrick Haller [Thu, 1999/08/18 00:15]
3702 *****************************************************************************/
3703
3704ODINFUNCTION4(NET_API_STATUS, OS2NetServiceGetInfo,
3705 LPWSTR, lpServerName,
3706 LPWSTR, lpService,
3707 DWORD, dwLevel,
3708 LPBYTE*, bufptr)
3709{
3710 dprintf(("NETAPI32: NetServiceGetInfo(%08xh,%08xh,%08xh,%08xh) not implemented\n",
3711 lpServerName,
3712 lpService,
3713 dwLevel,
3714 bufptr));
3715
3716 return (NERR_BASE);
3717}
3718
3719
3720/*****************************************************************************
3721 * Name : NET_API_STATUS NetServiceInstall
3722 * Purpose : starts a network service
3723 * Parameters: LPWSTR lpServerName
3724 * LPWSTR lpService
3725 * DWORD argc
3726 * LPWSTR argv[]
3727 * LPBYTE* bufptr
3728 * Variables :
3729 * Result :
3730 * Remark :
3731 * Status : UNTESTED STUB
3732 *
3733 * Author : Patrick Haller [Thu, 1999/08/18 00:15]
3734 *****************************************************************************/
3735
3736ODINFUNCTION5(NET_API_STATUS, OS2NetServiceInstall,
3737 LPWSTR, lpServerName,
3738 LPWSTR, lpService,
3739 DWORD, argc,
3740 LPWSTR*, argv,
3741 LPBYTE*, bufptr)
3742{
3743 dprintf(("NETAPI32: NetServiceInstall not implemented\n"));
3744
3745 return (NERR_BASE);
3746}
3747
3748
3749/*****************************************************************************
3750 * Name : NET_API_STATUS I_NetLogonControl
3751 * Purpose :
3752 * Parameters: wrong
3753 * Variables :
3754 * Result :
3755 * Remark :
3756 * Status : UNTESTED STUB
3757 *
3758 * Author : Patrick Haller [Thu, 1999/08/18 00:15]
3759 *****************************************************************************/
3760
3761ODINFUNCTION6(NET_API_STATUS, OS2I_NetLogonControl,
3762 DWORD, x1,
3763 DWORD, x2,
3764 DWORD, x3,
3765 DWORD, x4,
3766 DWORD, x5,
3767 DWORD, x6)
3768{
3769 dprintf(("NETAPI32: I_NetLogonControl(%08x, %08xh, %08xh, %08xh, %08xh, %08xh) not implemented\n",
3770 x1,
3771 x2,
3772 x3,
3773 x4,
3774 x5,
3775 x6));
3776
3777 return (NERR_BASE);
3778}
3779
3780
3781/*****************************************************************************
3782 * Name : NET_API_STATUS RxNetAccessAdd
3783 * Purpose :
3784 * Parameters: wrong
3785 * Variables :
3786 * Result :
3787 * Remark :
3788 * Status : UNTESTED STUB
3789 *
3790 * Author : Patrick Haller [Thu, 1999/08/18 00:15]
3791 *****************************************************************************/
3792
3793ODINFUNCTION6(NET_API_STATUS, OS2RxNetAccessAdd,
3794 DWORD, x1,
3795 DWORD, x2,
3796 DWORD, x3,
3797 DWORD, x4,
3798 DWORD, x5,
3799 DWORD, x6)
3800{
3801 dprintf(("NETAPI32: RxNetAccessAdd(%08x, %08xh, %08xh, %08xh, %08xh, %08xh) not implemented\n",
3802 x1,
3803 x2,
3804 x3,
3805 x4,
3806 x5,
3807 x6));
3808
3809 return (NERR_BASE);
3810}
3811
3812
3813/*****************************************************************************
3814 * Name : NET_API_STATUS RxNetAccessDel
3815 * Purpose :
3816 * Parameters: wrong
3817 * Variables :
3818 * Result :
3819 * Remark :
3820 * Status : UNTESTED STUB
3821 *
3822 * Author : Patrick Haller [Thu, 1999/08/18 00:15]
3823 *****************************************************************************/
3824
3825ODINFUNCTION6(NET_API_STATUS, OS2RxNetAccessDel,
3826 DWORD, x1,
3827 DWORD, x2,
3828 DWORD, x3,
3829 DWORD, x4,
3830 DWORD, x5,
3831 DWORD, x6)
3832{
3833 dprintf(("NETAPI32: RxNetAccessDel(%08x, %08xh, %08xh, %08xh, %08xh, %08xh) not implemented\n",
3834 x1,
3835 x2,
3836 x3,
3837 x4,
3838 x5,
3839 x6));
3840
3841 return (NERR_BASE);
3842}
3843
3844
3845
3846/*****************************************************************************
3847 * Name : NET_API_STATUS RxNetAccessEnum
3848 * Purpose :
3849 * Parameters: wrong
3850 * Variables :
3851 * Result :
3852 * Remark :
3853 * Status : UNTESTED STUB
3854 *
3855 * Author : Patrick Haller [Thu, 1999/08/18 00:15]
3856 *****************************************************************************/
3857
3858ODINFUNCTION6(NET_API_STATUS, OS2RxNetAccessEnum,
3859 DWORD, x1,
3860 DWORD, x2,
3861 DWORD, x3,
3862 DWORD, x4,
3863 DWORD, x5,
3864 DWORD, x6)
3865{
3866 dprintf(("NETAPI32: RxNetAccessEnum(%08x, %08xh, %08xh, %08xh, %08xh, %08xh) not implemented\n",
3867 x1,
3868 x2,
3869 x3,
3870 x4,
3871 x5,
3872 x6));
3873
3874 return (NERR_BASE);
3875}
3876
3877
3878
3879/*****************************************************************************
3880 * Name : NET_API_STATUS RxNetAccessGetUserPerms
3881 * Purpose :
3882 * Parameters: wrong
3883 * Variables :
3884 * Result :
3885 * Remark :
3886 * Status : UNTESTED STUB
3887 *
3888 * Author : Patrick Haller [Thu, 1999/08/18 00:15]
3889 *****************************************************************************/
3890
3891ODINFUNCTION6(NET_API_STATUS, OS2RxNetAccessGetUserPerms,
3892 DWORD, x1,
3893 DWORD, x2,
3894 DWORD, x3,
3895 DWORD, x4,
3896 DWORD, x5,
3897 DWORD, x6)
3898{
3899 dprintf(("NETAPI32: RxNetAccessGetUserPerms(%08x, %08xh, %08xh, %08xh, %08xh, %08xh) not implemented\n",
3900 x1,
3901 x2,
3902 x3,
3903 x4,
3904 x5,
3905 x6));
3906
3907 return (NERR_BASE);
3908}
3909
3910
3911/*****************************************************************************
3912 * Name : NET_API_STATUS NetConfigGetAll
3913 * Purpose : retrieves all the configuration information for a given component
3914 * on a local or remote computer
3915 * Parameters: LPWSTR lpServerName
3916 * LPWSTR lpComponent
3917 * LPBYTE* bufptr
3918 * Variables :
3919 * Result :
3920 * Remark :
3921 * Status : UNTESTED STUB
3922 *
3923 * Author : Patrick Haller [Thu, 1999/08/18 00:15]
3924 *****************************************************************************/
3925
3926ODINFUNCTION3(NET_API_STATUS,OS2NetConfigGetAll,LPWSTR, lpServerName,
3927 LPWSTR, lpComponent,
3928 LPBYTE*, bufptr)
3929{
3930 dprintf(("NETAPI32: NetConfigGetAll not implemented\n"));
3931
3932 return (NERR_BASE);
3933}
3934
3935
3936
3937/*****************************************************************************
3938 * Name : NET_API_STATUS NetConnectionEnum
3939 * Purpose : lists all connections made to a shared resource
3940 * Parameters: LPWSTR lpServerName
3941 * LPWSTR lpQualifier
3942 * DWORD dwLevel
3943 * LPBYTE* bufptr
3944 * DWORD dwPrefMaxLen
3945 * LPDWORD dwEntriesRead
3946 * LPDWORD dwTotalEntries
3947 * LPDWORD dwResumeHandle
3948 * Variables :
3949 * Result :
3950 * Remark :
3951 * Status : UNTESTED STUB
3952 *
3953 * Author : Patrick Haller [Thu, 1999/08/18 00:15]
3954 *****************************************************************************/
3955
3956ODINFUNCTION8(NET_API_STATUS,OS2NetConnectionEnum,LPWSTR, lpServerName,
3957 LPWSTR, lpQualifier,
3958 DWORD, dwLevel,
3959 LPBYTE*, bufptr ,
3960 DWORD, dwPrefMaxLen,
3961 LPDWORD, dwEntriesRead,
3962 LPDWORD, dwTotalEntries,
3963 LPDWORD, dwResumeHandle)
3964{
3965 dprintf(("NETAPI32: NetConnectionEnum not implemented\n"));
3966
3967 return (NERR_BASE);
3968}
3969
3970
3971/*****************************************************************************
3972 * Name : NET_API_STATUS NetFileClose
3973 * Purpose : forces a resource to close
3974 * Parameters: LPWSTR lpServerName
3975 * DWORD fileid
3976 * Variables :
3977 * Result :
3978 * Remark :
3979 * Status : UNTESTED STUB
3980 *
3981 * Author : Patrick Haller [Thu, 1999/08/18 00:15]
3982 *****************************************************************************/
3983
3984ODINFUNCTION2(NET_API_STATUS,OS2NetFileClose,LPWSTR, lpServerName,
3985 DWORD, fileid)
3986{
3987 dprintf(("NETAPI32: NetFileClose not implemented\n"));
3988
3989 return (NERR_BASE);
3990}
3991
3992
3993/*****************************************************************************
3994 * Name : NET_API_STATUS NetLocalGroupAddMember
3995 * Purpose : gives an existing user account or global group membership in
3996 * an existing local group
3997 * Parameters: LPWSTR lpServerName
3998 * LPWSTR lpGroupName
3999 * PSID membersid
4000 * Variables :
4001 * Result :
4002 * Remark :
4003 * Status : UNTESTED STUB
4004 *
4005 * Author : Patrick Haller [Thu, 1999/08/18 00:15]
4006 *****************************************************************************/
4007
4008ODINFUNCTION3(NET_API_STATUS,OS2NetLocalGroupAddMember,LPWSTR, lpServerName,
4009 LPWSTR, lpGroupName,
4010 PSID, membersid)
4011{
4012 dprintf(("NETAPI32: NetLocalGroupAddMember not implemented\n"));
4013
4014 return (NERR_BASE);
4015}
4016
4017
4018/*****************************************************************************
4019 * Name : NET_API_STATUS NetShareDel
4020 * Purpose :
4021 * Parameters: LPWSTR servername
4022 * LPWSTR netname
4023 * DWORD reserved
4024 * Variables :
4025 * Result :
4026 * Remark :
4027 * Status : UNTESTED STUB
4028 *
4029 * Stub Generated through PE2LX Stubwizard 0.02 from Markus Montkowski
4030 *
4031 * Author : Markus Montkowski [09.07.98 22:03:01]
4032 *****************************************************************************/
4033
4034ODINFUNCTION3(NET_API_STATUS,OS2NetShareDelSticky,LPWSTR, servername,
4035 LPWSTR, netname,
4036 DWORD, reserved)
4037{
4038
4039 dprintf(("NETAPI32: NetShareDelSticky not implemented\n"));
4040
4041 return (NERR_BASE);
4042}
4043
4044
4045/*****************************************************************************
4046 * Name : NET_API_STATUS NetShareEnum
4047 * Purpose : retrieves information about all shared devices
4048 * Parameters: LPWSTR lpServerName
4049 * DWORD dwLevel
4050 * LPBYTE* bufptr
4051 * DWORD dwPrefMaxLen
4052 * LPDWORD lpdEntriesRead
4053 * LPDWORD lpdTotalEntries
4054 * LPDWORD lpdResumeHandle
4055 * Variables :
4056 * Result :
4057 * Remark :
4058 * Status : UNTESTED STUB
4059 *
4060 * Author : Patrick Haller [Thu, 1999/08/18 00:15]
4061 *****************************************************************************/
4062
4063ODINFUNCTION7(NET_API_STATUS,OS2NetShareEnum,LPWSTR, lpServerName,
4064 DWORD, dwLevel,
4065 LPBYTE*, bufptr,
4066 DWORD, dwPrefMaxLen,
4067 LPDWORD, lpdEntriesRead,
4068 LPDWORD, lpdTotalEntries,
4069 LPDWORD, lpdResumeHandle)
4070{
4071 dprintf(("NETAPI32: NetShareEnum not implemented\n"));
4072
4073 return (NERR_BASE);
4074}
4075
4076
4077
4078/*****************************************************************************
4079 * Name : NET_API_STATUS NetShareEnumSticky
4080 * Purpose : retrieves information about all sticky shared devices
4081 * Parameters: LPWSTR lpServerName
4082 * DWORD dwLevel
4083 * LPBYTE* bufptr
4084 * DWORD dwPrefMaxLen
4085 * LPDWORD lpdEntriesRead
4086 * LPDWORD lpdTotalEntries
4087 * LPDWORD lpdResumeHandle
4088 * Variables :
4089 * Result :
4090 * Remark :
4091 * Status : UNTESTED STUB
4092 *
4093 * Author : Patrick Haller [Thu, 1999/08/18 00:15]
4094 *****************************************************************************/
4095
4096ODINFUNCTION7(NET_API_STATUS,OS2NetShareEnumSticky,LPWSTR, lpServerName,
4097 DWORD, dwLevel,
4098 LPBYTE*, bufptr,
4099 DWORD, dwPrefMaxLen,
4100 LPDWORD, lpdEntriesRead,
4101 LPDWORD, lpdTotalEntries,
4102 LPDWORD, lpdResumeHandle)
4103{
4104 dprintf(("NETAPI32: NetShareEnumSticky not implemented\n"));
4105
4106 return (NERR_BASE);
4107}
4108
4109
4110/*****************************************************************************
4111 * Name : NET_API_STATUS NetUseEnum
4112 * Purpose : retrieves information about all used devices
4113 * Parameters: LPWSTR lpServerName
4114 * DWORD dwLevel
4115 * LPBYTE* bufptr
4116 * DWORD dwPrefMaxLen
4117 * LPDWORD lpdEntriesRead
4118 * LPDWORD lpdTotalEntries
4119 * LPDWORD lpdResumeHandle
4120 * Variables :
4121 * Result :
4122 * Remark :
4123 * Status : UNTESTED STUB
4124 *
4125 * Author : Patrick Haller [Thu, 1999/08/18 00:15]
4126 *****************************************************************************/
4127
4128ODINFUNCTION7(NET_API_STATUS,OS2NetUseEnum,LPWSTR, lpServerName,
4129 DWORD, dwLevel,
4130 LPBYTE*, bufptr,
4131 DWORD, dwPrefMaxLen,
4132 LPDWORD, lpdEntriesRead,
4133 LPDWORD, lpdTotalEntries,
4134 LPDWORD, lpdResumeHandle)
4135{
4136 dprintf(("NETAPI32: NetUseEnum not implemented\n"));
4137
4138 return (NERR_BASE);
4139}
4140
4141
4142/*****************************************************************************
4143 * Name : NET_API_STATUS NetUseGetInfo
4144 * Purpose :
4145 * Parameters: LPWSTR lpServerName
4146 * LPWSTR lpUseName
4147 * DWORD dwlevel
4148 * LPBYTE *bufptr
4149 * Variables :
4150 * Result :
4151 * Remark :
4152 * Status : UNTESTED STUB
4153 *
4154 * Stub Generated through PE2LX Stubwizard 0.02 from Markus Montkowski
4155 *
4156 * Author : Markus Montkowski [09.07.98 21:28:38]
4157 *****************************************************************************/
4158
4159ODINFUNCTION4(NET_API_STATUS,OS2NetUseGetInfo,LPWSTR, lpServerName,
4160 LPWSTR, lpUseName,
4161 DWORD, dwLevel,
4162 LPBYTE*, bufptr)
4163
4164{
4165
4166 dprintf(("NETAPI32: NetUseGetInfo not implemented\n"));
4167
4168 return (NERR_BASE);
4169}
4170
4171
4172/*****************************************************************************
4173 * Name : NET_API_STATUS NetStatisticsGet
4174 * Purpose : retrieves operating statistics for a service
4175 * Parameters: LPWSTR lpServerName
4176 * LPWSTR lpService
4177 * DWORD dwLevel
4178 * DWORD dwOptions
4179 * LPBYTE* bufptr
4180 * Variables :
4181 * Result :
4182 * Remark :
4183 * Status : UNTESTED STUB
4184 *
4185 * Author : Patrick Haller [Thu, 1999/08/18 00:15]
4186 *****************************************************************************/
4187
4188void UL2LI(PLARGE_INTEGER pli, ULONG ul)
4189{
4190 pli->LowPart = ul;
4191 pli->HighPart = 0;
4192}
4193
4194void LOHI2LI(PLARGE_INTEGER pli, ULONG lo, ULONG hi)
4195{
4196 pli->LowPart = lo;
4197 pli->HighPart = hi;
4198}
4199
4200
4201ODINFUNCTION5(NET_API_STATUS,OS2NetStatisticsGet,LPWSTR, lpServerName,
4202 LPWSTR, lpService,
4203 DWORD, dwLevel,
4204 DWORD, dwOptions,
4205 LPBYTE*, bufptr)
4206{
4207 // Note: as we use the static addresses of the strings
4208 // for a faster comparsion, the compiler may NOT
4209 // merge duplicate static const strings.
4210 static LPSTR SERVICE_SERVER = "SERVER";
4211 static LPSTR SERVICE_REQUESTER_NT = "REQUESTER";
4212 static LPSTR SERVICE_REQUESTER_LM = "REQUESTER";
4213 static LPSTR SERVICE_UNKNOWN = "UNKNOWN";
4214
4215 // Convert servername to ASCII
4216 // Convert service name to ASCII AND OS/2-Pendant
4217 // OS/2 only allowes "SERVER" and "REQUESTER"
4218 char *asciiServername = NULL;
4219 if (lpServerName) asciiServername = UnicodeToAsciiString(lpServerName);
4220
4221 // server remains
4222 LPSTR lpstrOS2Service = NULL;
4223 if (lpService != NULL)
4224 if (lstrcmpiW((LPCWSTR)L"WORKSTATION", (LPCWSTR)lpService) == 0) lpstrOS2Service = (LPSTR)SERVICE_REQUESTER_NT;
4225 else
4226 if (lstrcmpW((LPCWSTR)L"LanmanWorkstation", (LPCWSTR)lpService) == 0) lpstrOS2Service = (LPSTR)SERVICE_REQUESTER_LM;
4227 else
4228 if (lstrcmpiW((LPCWSTR)L"SERVER", (LPCWSTR)lpService) == 0) lpstrOS2Service = (LPSTR)SERVICE_SERVER;
4229 else
4230 if (lstrcmpW((LPCWSTR)L"LanmanServer", (LPCWSTR)lpService) == 0) lpstrOS2Service = (LPSTR)SERVICE_SERVER;
4231 else
4232 lpstrOS2Service = (LPSTR)SERVICE_UNKNOWN; // to prevent crashes in NETAPI
4233
4234 // Note: The Win32 docs say nothing about "LanmanWorkstation"
4235 // Probably this is a request for the LANMAN-Workstation specific data?
4236#ifdef DEBUG
4237 {
4238 char *asciiService = UnicodeToAsciiString(lpService);
4239 dprintf(("WINMM: NetStatisticsGet server=[%s], service=[%s]\n",
4240 asciiServername,
4241 asciiService));
4242 FreeAsciiString(asciiService);
4243 }
4244#endif
4245
4246
4247 // @@@PH convert information modes!
4248 int iOS2Level = dwLevel; // both must be 0
4249 int iOS2Options = dwOptions; // seems to be identical
4250
4251 ULONG ulBytesAvailable;
4252 DWORD rc;
4253
4254 // determine required size of buffer
4255 char pOS2Buffer[4096];
4256 rc = OSLibNetStatisticsGet((const unsigned char*)asciiServername,
4257 (const unsigned char*)lpstrOS2Service,
4258 0,
4259 iOS2Level,
4260 iOS2Options,
4261 (unsigned char*)pOS2Buffer,
4262 sizeof(pOS2Buffer),
4263 &ulBytesAvailable);
4264
4265 if (asciiServername) FreeAsciiString(asciiServername);
4266
4267 // convert the structures
4268 switch (dwLevel)
4269 {
4270 case 0:
4271 // Note: address comparsion is valid :)
4272 if (lpstrOS2Service == SERVICE_REQUESTER_NT)
4273 {
4274 PSTAT_WORKSTATION_NT_0 pstw0;
4275 struct stat_workstation_0 *pOS2stw0 = (struct stat_workstation_0 *)pOS2Buffer;
4276
4277 // calculate new size for target buffer
4278 rc = OS2NetApiBufferAllocate(sizeof(STAT_WORKSTATION_NT_0), (LPVOID*)&pstw0);
4279 if (!rc)
4280 {
4281 // buffer is zeroed?
4282 //memset(pstw0, 0, sizeof(STAT_WORKSTATION_0));
4283
4284 UL2LI (&pstw0->StatisticsStartTime, pOS2stw0->stw0_start);
4285 LOHI2LI(&pstw0->BytesReceived, pOS2stw0->stw0_bytesrcvd_r_lo, pOS2stw0->stw0_bytesrcvd_r_hi);
4286 pstw0->SmbsReceived;
4287 pstw0->PagingReadBytesRequested;
4288 pstw0->NonPagingReadBytesRequested;
4289 pstw0->CacheReadBytesRequested;
4290 pstw0->NetworkReadBytesRequested;
4291 LOHI2LI(&pstw0->BytesTransmitted, pOS2stw0->stw0_bytessent_r_lo, pOS2stw0->stw0_bytessent_r_hi);
4292 pstw0->SmbsTransmitted;
4293 pstw0->PagingWriteBytesRequested;
4294 pstw0->NonPagingWriteBytesRequested;
4295 pstw0->CacheWriteBytesRequested;
4296 pstw0->NetworkWriteBytesRequested;
4297
4298 pstw0->InitiallyFailedOperations;
4299 pstw0->FailedCompletionOperations;
4300 pstw0->ReadOperations;
4301 pstw0->RandomReadOperations;
4302 pstw0->ReadSmbs;
4303 pstw0->LargeReadSmbs;
4304 pstw0->SmallReadSmbs;
4305 pstw0->WriteOperations;
4306 pstw0->RandomWriteOperations;
4307 pstw0->WriteSmbs;
4308 pstw0->LargeWriteSmbs;
4309 pstw0->SmallWriteSmbs;
4310 pstw0->RawReadsDenied;
4311 pstw0->RawWritesDenied;
4312
4313 pstw0->NetworkErrors;
4314 pstw0->Sessions = pOS2stw0->stw0_sesstart;
4315 pstw0->FailedSessions = pOS2stw0->stw0_sessfailcon;
4316 pstw0->Reconnects = pOS2stw0->stw0_autorec;
4317 pstw0->CoreConnects;
4318 pstw0->Lanman20Connects;
4319 pstw0->Lanman21Connects;
4320 pstw0->LanmanNtConnects;
4321 pstw0->ServerDisconnects;
4322 pstw0->HungSessions = pOS2stw0->stw0_sessbroke;
4323 pstw0->UseCount = pOS2stw0->stw0_uses;
4324 pstw0->FailedUseCount = pOS2stw0->stw0_usefail;
4325 pstw0->CurrentCommands;
4326 }
4327 // the caller is responsible for freeing the memory!
4328 *bufptr = (LPBYTE)pstw0;
4329 }
4330 else
4331 if (lpstrOS2Service == SERVICE_REQUESTER_LM)
4332 {
4333 // LanmanWorkstation !
4334 PSTAT_WORKSTATION_LM_0 pstw0;
4335 struct stat_workstation_0 *pOS2stw0 = (struct stat_workstation_0 *)pOS2Buffer;
4336
4337 // calculate new size for target buffer
4338 rc = OS2NetApiBufferAllocate(sizeof(STAT_WORKSTATION_LM_0), (LPVOID*)&pstw0);
4339 if (!rc)
4340 {
4341 // Note: the really nice thing is, the lanman structures are
4342 // exactly identical between OS/2 and NT ... :)
4343 memcpy(pstw0,
4344 pOS2stw0,
4345 sizeof(STAT_WORKSTATION_LM_0));
4346 }
4347
4348 // the caller is responsible for freeing the memory!
4349 *bufptr = (LPBYTE)pstw0;
4350 }
4351 else
4352 if (lpstrOS2Service == SERVICE_SERVER)
4353 {
4354 // SERVER !
4355 PSTAT_SERVER_0 psts0;
4356 struct stat_server_0 *pOS2sts0 = (struct stat_server_0 *)pOS2Buffer;
4357
4358 // calculate new size for target buffer
4359 rc = OS2NetApiBufferAllocate(sizeof(STAT_SERVER_0), (LPVOID*)&psts0);
4360 if (!rc)
4361 {
4362 // Note: the really nice thing is, the server structures are
4363 // exactly identical between OS/2 and NT ... :)
4364 memcpy(psts0,
4365 pOS2sts0,
4366 sizeof(STAT_SERVER_0));
4367 }
4368
4369 // the caller is responsible for freeing the memory!
4370 *bufptr = (LPBYTE)psts0;
4371 }
4372
4373 break;
4374 }
4375
4376 return (rc);
4377}
4378
4379
Note: See TracBrowser for help on using the repository browser.