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

Last change on this file since 5120 was 4789, checked in by phaller, 25 years ago

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