Changeset 6672 for trunk/src


Ignore:
Timestamp:
Sep 7, 2001, 12:23:41 AM (24 years ago)
Author:
phaller
Message:

.

Location:
trunk/src/wnetap32
Files:
7 added
7 edited

Legend:

Unmodified
Added
Removed
  • trunk/src/wnetap32/errorlog.cpp

    r4789 r6672  
    1 /* $Id: errorlog.cpp,v 1.1 2000-12-12 02:43:25 phaller Exp $ */
     1/* $Id: errorlog.cpp,v 1.2 2001-09-06 22:23:38 phaller Exp $ */
    22
    33/*
     
    4444 * Module Global Variables                                                  *
    4545 ****************************************************************************/
    46 
    47 #define NERR_OK   0
    48 #define NERR_BASE 1 /* @@@PH DUMMY ! */
    49 
    50 
    51 #undef NET_API_STATUS
    52 #define NET_API_STATUS DWORD
    5346
    5447typedef unsigned long LPHLOG;
  • trunk/src/wnetap32/lanman.h

    r4394 r6672  
    1 /* $Id: lanman.h,v 1.1 2000-10-02 21:20:08 phaller Exp $ */
     1/* $Id: lanman.h,v 1.2 2001-09-06 22:23:39 phaller Exp $ */
    22/*
    33 * Wrappers for NT/LAN Manager specific data structures
     
    1717 ****************************************************************************/
    1818#pragma pack(1)
     19
     20
     21#define CNLEN           15                  /* Computer name length     */
     22#define UNCLEN          (CNLEN+2)           /* UNC computer name length */
     23#define NNLEN           12                  /* 8.3 Net name length      */
     24#define RMLEN           (UNCLEN+1+NNLEN)    /* Maximum remote name length */
     25
    1926
    2027struct wksta_info_0 {
     
    193200
    194201
    195 
     202struct server_info_1 {
     203  unsigned char         sv1_name[CNLEN + 1];
     204  unsigned char         sv1_version_major;
     205  unsigned char         sv1_version_minor;
     206  unsigned long         sv1_type;
     207  unsigned char *       sv1_comment;
     208}; /* server_info_1 */
    196209
    197210
     
    459472
    460473
     474typedef struct _SERVER_INFO_100 {
     475     DWORD          sv100_platform_id;
     476     LPWSTR         sv100_name;
     477} SERVER_INFO_100, *PSERVER_INFO_100, *LPSERVER_INFO_100;
     478
     479
     480typedef struct _SERVER_INFO_101 {
     481     DWORD          sv101_platform_id;
     482     LPWSTR         sv101_name;
     483     DWORD          sv101_version_major;
     484     DWORD          sv101_version_minor;
     485     DWORD          sv101_type;
     486     LPWSTR         sv101_comment;
     487} SERVER_INFO_101, *PSERVER_INFO_101, *LPSERVER_INFO_101;
     488
     489
    461490#endif
  • trunk/src/wnetap32/makefile

    r4789 r6672  
    1 # $Id: makefile,v 1.17 2000-12-12 02:43:26 phaller Exp $
     1# $Id: makefile,v 1.18 2001-09-06 22:23:39 phaller Exp $
    22
    33#
     
    1919OBJS = \
    2020$(OBJDIR)\wnetap32.obj \
     21$(OBJDIR)\group.obj \
     22$(OBJDIR)\server.obj \
     23$(OBJDIR)\user.obj \
     24$(OBJDIR)\wksta.obj \
     25$(OBJDIR)\repl.obj \
     26$(OBJDIR)\schedule.obj \
     27$(OBJDIR)\mem.obj \
    2128$(OBJDIR)\errorlog.obj \
    2229$(OBJDIR)\oslibnet.obj \
  • trunk/src/wnetap32/netapi32.def

    r4809 r6672  
    1 ; $Id: netapi32.def,v 1.4 2000-12-16 22:53:50 bird Exp $
     1; $Id: netapi32.def,v 1.5 2001-09-06 22:23:39 phaller Exp $
    22
    33LIBRARY WNETAP32 INITINSTANCE
     
    1111    Net32WkstaGetInfo   = NETAPI32.146
    1212    Net32WkstaSetInfo   = NETAPI32.147
     13    Net32ServerEnum2    = NETAPI32.101
    1314
    1415EXPORTS
     
    6162  NetAlertRaise                = _OS2NetAlertRaise@12                  @46    ;stubonly
    6263  NetAlertRaiseEx              = _OS2NetAlertRaiseEx@16                @47    ;stubonly
    63   NetApiBufferAllocate                 = _OS2NetApiBufferAllocate@8            @48    ;stubonly
     64  NetApiBufferAllocate         = _OS2NetApiBufferAllocate@8            @48    ;stubonly
    6465  NetApiBufferFree             = _OS2NetApiBufferFree@4                @49    ;stubonly
    6566  NetApiBufferReallocate       = _OS2NetApiBufferReallocate@12         @50    ;stubonly
  • trunk/src/wnetap32/oslibnet.cpp

    r6639 r6672  
    1 /*  $Id: oslibnet.cpp,v 1.4 2001-09-05 10:27:54 bird Exp $
     1/*  $Id: oslibnet.cpp,v 1.5 2001-09-06 22:23:40 phaller Exp $
    22 *
    33 * Wrappers for OS/2 Netbios/Network/LAN API
     
    2929#include <neterr.h>
    3030#include <netstats.h>
     31#include <server.h>
    3132
    3233
     
    264265  return rc;
    265266}
     267
     268
     269/*****************************************************************************
     270 * Name      : NET_API_STATUS OSLibNetStatisticsGet
     271 * Purpose   :
     272 * Parameters:
     273 * Variables :
     274 * Result    :
     275 * Remark    :
     276 * Status    : UNTESTED STUB
     277 *
     278 * Author    : Patrick Haller 2000/01/10 01:42
     279 *****************************************************************************/
     280
     281DWORD OSLibNetServerEnum(const unsigned char * pszServer,
     282                         unsigned long         ulLevel,
     283                         unsigned char       * pbBuffer,
     284                         unsigned long         ulBufferLength,
     285                         unsigned long       * pulEntriesReturned,
     286                         unsigned long       * pulEntriesAvail,
     287                         unsigned long         ulServerType,
     288                         unsigned char       * pszDomain)
     289{
     290  USHORT sel = RestoreOS2FS();
     291 
     292  APIRET rc = error2WinError(Net32ServerEnum2(pszServer,
     293                                              ulLevel,
     294                                              pbBuffer,
     295                                              ulBufferLength,
     296                                              pulEntriesReturned,
     297                                              pulEntriesAvail,
     298                                              ulServerType,
     299                                              pszDomain));
     300  SetFS(sel);
     301  return rc;
     302}
  • trunk/src/wnetap32/oslibnet.h

    r4394 r6672  
    1 /* $Id */
     1/* $Id: oslibnet.h,v 1.3 2001-09-06 22:23:40 phaller Exp $ */
    22/*
    33 * Wrappers for OS/2 Netbios/Network/LAN API
     
    1111#ifndef __OSLIBNET_H__
    1212#define __OSLIBNET_H__
     13
     14
     15#undef NET_API_STATUS
     16#define NET_API_STATUS DWORD
     17
     18#define NERR_OK   0
     19#define NERR_BASE 1 /* @@@PH DUMMY ! */
     20
     21
     22
     23// forwarders to NETAPI32 internal APIs
     24NET_API_STATUS WIN32API OS2NetApiBufferAllocate(DWORD ByteCount,
     25                                                LPVOID * Buffer);
     26
     27NET_API_STATUS WIN32API OS2NetApiBufferFree(LPVOID Buffer);
     28
     29NET_API_STATUS WIN32API OS2NetApiBufferReallocate(LPVOID OldBuffer,
     30                                                  DWORD NewByteCount,
     31                                                  LPVOID* NewBuffer);
     32
     33NET_API_STATUS WIN32API OS2NetApiBufferSize(LPVOID buffer,
     34                                            LPDWORD lpByteCount);
     35
     36
     37// forwarders to OS/2 Lan Manager APIs
    1338
    1439DWORD OSLibNetWkstaGetInfo (const unsigned char * pszServer,
     
    2752                            unsigned long       * pulTotalAvail);
    2853
     54DWORD OSLibNetServerEnum(const unsigned char * pszServer,
     55                         unsigned long         ulLevel,
     56                         unsigned char       * pbBuffer,
     57                         unsigned long         ulBufferLength,
     58                         unsigned long       * pulEntriesReturned,
     59                         unsigned long       * pulEntriesAvail,
     60                         unsigned long         ulServerType,
     61                         unsigned char       * pszDomain);
     62
    2963#endif
  • trunk/src/wnetap32/wnetap32.cpp

    r5472 r6672  
    1 /* $Id: wnetap32.cpp,v 1.14 2001-04-04 09:02:16 sandervl Exp $ */
     1/* $Id: wnetap32.cpp,v 1.15 2001-09-06 22:23:41 phaller Exp $ */
    22
    33/*
     
    3636#include <heapstring.h>
    3737#include <string.h>
     38#include <winconst.h>
    3839
    3940#include "oslibnet.h"
     
    4647 * Module Global Variables                                                  *
    4748 ****************************************************************************/
    48 
    49 #undef NET_API_STATUS
    50 #define NET_API_STATUS DWORD
    51 
    52 #define NERR_OK   0
    53 #define NERR_BASE 1 /* @@@PH DUMMY ! */
    5449
    5550#define NCBNAMSZ        16
     
    191186
    192187/*****************************************************************************
    193  * Name      : NET_API_STATUS NetApiBufferAllocate
    194  * Purpose   :
    195  * Parameters: DWORD ByteCount
    196  *             LPVOID *Buffer
    197  * Variables :
    198  * Result    :
    199  * Remark    :
    200  * Status    : UNTESTED STUB
    201  *
    202  * Stub Generated through PE2LX Stubwizard 0.02 from Markus Montkowski
    203  *
    204  * Author    : Markus Montkowski [09.07.98 19:46:46]
    205  *****************************************************************************/
    206 
    207 ODINFUNCTION2(NET_API_STATUS, OS2NetApiBufferAllocate,
    208               DWORD, ByteCount,
    209               LPVOID *, Buffer)
    210 
    211 {
    212   *Buffer = HEAP_malloc(ByteCount);
    213   return (NERR_OK);
    214 }
    215 
    216 
    217 /*****************************************************************************
    218  * Name      : NET_API_STATUS NetApiBufferFree
    219  * Purpose   :
    220  * Parameters: LPVOID Buffer
    221  * Variables :
    222  * Result    :
    223  * Remark    :
    224  * Status    : UNTESTED STUB
    225  *
    226  * Stub Generated through PE2LX Stubwizard 0.02 from Markus Montkowski
    227  *
    228  * Author    : Markus Montkowski [09.07.98 19:47:21]
    229  *****************************************************************************/
    230 
    231 ODINFUNCTION1(NET_API_STATUS, OS2NetApiBufferFree,
    232               LPVOID, Buffer)
    233 
    234 {
    235   HEAP_free(Buffer);
    236   return (NERR_OK);
    237 }
    238 
    239 
    240 /*****************************************************************************
    241  * Name      : NET_API_STATUS NetApiBufferReallocate
    242  * Purpose   :
    243  * Parameters: LPVOID OldBuffer
    244  *             DWORD NewByteCount
    245  *             LPVOID NewBuffer
    246  * Variables :
    247  * Result    :
    248  * Remark    :
    249  * Status    : UNTESTED STUB
    250  *
    251  * Stub Generated through PE2LX Stubwizard 0.02 from Markus Montkowski
    252  *
    253  * Author    : Markus Montkowski [09.07.98 21:25:21]
    254  *****************************************************************************/
    255 
    256 ODINFUNCTION3(NET_API_STATUS, OS2NetApiBufferReallocate,
    257               LPVOID, OldBuffer,
    258               DWORD, NewByteCount,
    259               LPVOID*, NewBuffer)
    260 {
    261   *NewBuffer = HEAP_realloc(OldBuffer, NewByteCount);
    262   return (NERR_OK);
    263 }
    264 
    265 
    266 /*****************************************************************************
    267  * Name      : NET_API_STATUS NetApiBufferSize
    268  * Purpose   :
    269  * Parameters: LPVOID buffer
    270  *             DWORD ByteCount
    271  * Variables :
    272  * Result    :
    273  * Remark    :
    274  * Status    : UNTESTED STUB
    275  *
    276  * Stub Generated through PE2LX Stubwizard 0.02 from Markus Montkowski
    277  *
    278  * Author    : Markus Montkowski [09.07.98 21:25:44]
    279  *****************************************************************************/
    280 
    281 ODINFUNCTION2(NET_API_STATUS, OS2NetApiBufferSize,
    282               LPVOID, buffer,
    283               LPDWORD, lpByteCount)
    284 {
    285   *lpByteCount = HEAP_size(buffer);
    286   return (NERR_OK);
    287 }
    288 
    289 
    290 /*****************************************************************************
    291188 * Name      : NET_API_STATUS NetFileEnum
    292189 * Purpose   :
     
    440337
    441338/*****************************************************************************
    442  * Name      : NET_API_STATUS NetGroupAdd
    443  * Purpose   :
    444  * Parameters: LPWSTR servername
    445  *             DWORD level
    446  *             LPBYTE buf
    447  *             LPDWORD parm_err
    448  * Variables :
    449  * Result    :
    450  * Remark    :
    451  * Status    : UNTESTED STUB
    452  *
    453  * Stub Generated through PE2LX Stubwizard 0.02 from Markus Montkowski
    454  *
    455  * Author    : Markus Montkowski [09.07.98 21:31:17]
    456  *****************************************************************************/
    457 
    458 ODINFUNCTION4(NET_API_STATUS, OS2NetGroupAdd,
    459               LPWSTR, servername,
    460               DWORD, level,
    461               LPBYTE, buf,
    462               LPDWORD, parm_err)
    463 {
    464   dprintf(("NETAPI32: NetGroupAdd not implemented\n"));
    465 
    466   return (NERR_BASE);
    467 }
    468 
    469 
    470 /*****************************************************************************
    471  * Name      : NET_API_STATUS NetGroupAddUser
    472  * Purpose   :
    473  * Parameters: LPWSTR servername
    474  *             LPWSTR GroupName
    475  *             LPWSTR username
    476  * Variables :
    477  * Result    :
    478  * Remark    :
    479  * Status    : UNTESTED STUB
    480  *
    481  * Stub Generated through PE2LX Stubwizard 0.02 from Markus Montkowski
    482  *
    483  * Author    : Markus Montkowski [09.07.98 21:31:38]
    484  *****************************************************************************/
    485 
    486 ODINFUNCTION3(NET_API_STATUS, OS2NetGroupAddUser,
    487               LPWSTR, servername,
    488               LPWSTR, GroupName,
    489               LPWSTR, username)
    490 {
    491   dprintf(("NETAPI32: NetGroupAddUser not implemented\n"));
    492 
    493   return (NERR_BASE);
    494 }
    495 
    496 
    497 /*****************************************************************************
    498  * Name      : NET_API_STATUS NetGroupDel
    499  * Purpose   :
    500  * Parameters: LPWSTR servername
    501  *             LPWSTR groupname
    502  * Variables :
    503  * Result    :
    504  * Remark    :
    505  * Status    : UNTESTED STUB
    506  *
    507  * Stub Generated through PE2LX Stubwizard 0.02 from Markus Montkowski
    508  *
    509  * Author    : Markus Montkowski [09.07.98 21:31:53]
    510  *****************************************************************************/
    511 
    512 ODINFUNCTION2(NET_API_STATUS, OS2NetGroupDel,
    513               LPWSTR, servername,
    514               LPWSTR, groupname)
    515 {
    516   dprintf(("NETAPI32: NetGroupDel not implemented\n"));
    517 
    518   return (NERR_BASE);
    519 }
    520 
    521 
    522 /*****************************************************************************
    523  * Name      : NET_API_STATUS NetGroupDelUser
    524  * Purpose   :
    525  * Parameters: LPWSTR servername
    526  *             LPWSTR GroupName
    527  *             LPWSTR Username
    528  * Variables :
    529  * Result    :
    530  * Remark    :
    531  * Status    : UNTESTED STUB
    532  *
    533  * Stub Generated through PE2LX Stubwizard 0.02 from Markus Montkowski
    534  *
    535  * Author    : Markus Montkowski [09.07.98 21:32:05]
    536  *****************************************************************************/
    537 
    538 ODINFUNCTION3(NET_API_STATUS, OS2NetGroupDelUser,
    539               LPWSTR, servername,
    540               LPWSTR, GroupName,
    541               LPWSTR, Username)
    542 {
    543   dprintf(("NETAPI32: NetGroupDelUser not implemented\n"));
    544 
    545   return (NERR_BASE);
    546 }
    547 
    548 
    549 /*****************************************************************************
    550  * Name      : NET_API_STATUS NetGroupEnum
    551  * Purpose   :
    552  * Parameters: LPWSTR servername
    553  *             DWORD level
    554  *             LPBYTE *bufptr
    555  *             DWORD prefmaxlen
    556  *             LPDWORD entriesread
    557  *             LPDWORD totalentries
    558  *             LPDWORD resume_handle
    559  * Variables :
    560  * Result    :
    561  * Remark    :
    562  * Status    : UNTESTED STUB
    563  *
    564  * Stub Generated through PE2LX Stubwizard 0.02 from Markus Montkowski
    565  *
    566  * Author    : Markus Montkowski [09.07.98 21:32:38]
    567  *****************************************************************************/
    568 
    569 ODINFUNCTION7(NET_API_STATUS, OS2NetGroupEnum,
    570               LPWSTR, servername,
    571               DWORD, level,
    572               LPBYTE *, bufptr,
    573               DWORD, prefmaxlen,
    574               LPDWORD, entriesread,
    575               LPDWORD, totalentries,
    576               LPDWORD, resume_handle)
    577 {
    578   dprintf(("NETAPI32: NetGroupEnum not implemented\n"));
    579 
    580   return (NERR_BASE);
    581 }
    582 
    583 
    584 /*****************************************************************************
    585  * Name      : NET_API_STATUS NetGroupGetInfo
    586  * Purpose   :
    587  * Parameters: LPWSTR servername
    588  *             LPWSTR groupname
    589  *             DWORD level
    590  *             LPBYTE *bufptr
    591  * Variables :
    592  * Result    :
    593  * Remark    :
    594  * Status    : UNTESTED STUB
    595  *
    596  * Stub Generated through PE2LX Stubwizard 0.02 from Markus Montkowski
    597  *
    598  * Author    : Markus Montkowski [09.07.98 21:33:13]
    599  *****************************************************************************/
    600 
    601 ODINFUNCTION4(NET_API_STATUS, OS2NetGroupGetInfo,
    602               LPWSTR, servername,
    603               LPWSTR, groupname,
    604               DWORD, level,
    605               LPBYTE *, bufptr)
    606 {
    607   dprintf(("NETAPI32: NetGroupGetInfo not implemented\n"));
    608 
    609   return (NERR_BASE);
    610 }
    611 
    612 
    613 /*****************************************************************************
    614  * Name      : NET_API_STATUS NetGroupGetUsers
    615  * Purpose   :
    616  * Parameters: LPWSTR servername
    617  *             LPWSTR groupname
    618  *             DWORD level
    619  *             LPBYTE *bufptr
    620  *             DWORD prefmaxlen
    621  *             LPDWORD entriesread
    622  *             LPDWORD totalentries
    623  *             LPDWORD resumeHandle
    624  * Variables :
    625  * Result    :
    626  * Remark    :
    627  * Status    : UNTESTED STUB
    628  *
    629  * Stub Generated through PE2LX Stubwizard 0.02 from Markus Montkowski
    630  *
    631  * Author    : Markus Montkowski [09.07.98 21:33:24]
    632  *****************************************************************************/
    633 
    634 ODINFUNCTION8(NET_API_STATUS, OS2NetGroupGetUsers,
    635               LPWSTR, servername,
    636               LPWSTR, groupname,
    637               DWORD, level,
    638               LPBYTE *, bufptr,
    639               DWORD, prefmaxlen,
    640               LPDWORD, entriesread,
    641               LPDWORD, totalentries,
    642               LPDWORD, resumeHandle)
    643 {
    644   dprintf(("NETAPI32: NetGroupGetUsers not implemented\n"));
    645 
    646   return (NERR_BASE);
    647 }
    648 
    649 
    650 /*****************************************************************************
    651  * Name      : NET_API_STATUS NetGroupSetInfo
    652  * Purpose   :
    653  * Parameters: LPWSTR servername
    654  *             LPWSTR groupname
    655  *             DWORD level
    656  *             LPBYTE buf
    657  *             LPDWORD parm_err
    658  * Variables :
    659  * Result    :
    660  * Remark    :
    661  * Status    : UNTESTED STUB
    662  *
    663  * Stub Generated through PE2LX Stubwizard 0.02 from Markus Montkowski
    664  *
    665  * Author    : Markus Montkowski [09.07.98 21:33:39]
    666  *****************************************************************************/
    667 
    668 ODINFUNCTION5(NET_API_STATUS, OS2NetGroupSetInfo,
    669               LPWSTR, servername,
    670               LPWSTR, groupname,
    671               DWORD, level,
    672               LPBYTE, buf,
    673               LPDWORD, parm_err)
    674 {
    675   dprintf(("NETAPI32: NetGroupSetInfo not implemented\n"));
    676 
    677   return (NERR_BASE);
    678 }
    679 
    680 
    681 /*****************************************************************************
    682  * Name      : NET_API_STATUS NetGroupSetUsers
    683  * Purpose   :
    684  * Parameters: LPWSTR servername
    685  *             LPWSTR groupname
    686  *             DWORD level
    687  *             LPBYTE buf
    688  *             DWORD NewMemberCount
    689  * Variables :
    690  * Result    :
    691  * Remark    :
    692  * Status    : UNTESTED STUB
    693  *
    694  * Stub Generated through PE2LX Stubwizard 0.02 from Markus Montkowski
    695  *
    696  * Author    : Markus Montkowski [09.07.98 21:34:02]
    697  *****************************************************************************/
    698 
    699 ODINFUNCTION5(NET_API_STATUS, OS2NetGroupSetUsers,
    700               LPWSTR, servername,
    701               LPWSTR, groupname,
    702               DWORD, level,
    703               LPBYTE, buf,
    704               DWORD, NewMemberCount)
    705 {
    706   dprintf(("NETAPI32: NetGroupSetUsers not implemented\n"));
    707 
    708   return (NERR_BASE);
    709 }
    710 
    711 
    712 /*****************************************************************************
    713339 * Name      : NET_API_STATUS NetHandleGetInfo
    714340 * Purpose   :
     
    784410
    785411*/
    786 /*****************************************************************************
    787  * Name      : NET_API_STATUS NetLocalGroupAdd
    788  * Purpose   :
    789  * Parameters: LPWSTR servername
    790  *             DWORD level
    791  *             LPBYTE buf
    792  *             LPDWORD parm_err
    793  * Variables :
    794  * Result    :
    795  * Remark    :
    796  * Status    : UNTESTED STUB
    797  *
    798  * Stub Generated through PE2LX Stubwizard 0.02 from Markus Montkowski
    799  *
    800  * Author    : Markus Montkowski [09.07.98 21:40:13]
    801  *****************************************************************************/
    802 ODINFUNCTION4(NET_API_STATUS, OS2NetLocalGroupAdd,
    803               LPWSTR, servername,
    804               DWORD, level,
    805               LPBYTE, buf,
    806               LPDWORD, parm_err)
    807 {
    808 
    809   dprintf(("NETAPI32: NetLocalGroupAdd(%08x, %d, %08x, %08x) not implemented\n"
    810            ,servername, level, buf, parm_err
    811          ));
    812 
    813   return (NERR_BASE);
    814 }
    815 
    816 /*****************************************************************************
    817  * Name      : NET_API_STATUS NetLocalGroupAddMembers
    818  * Purpose   :
    819  * Parameters: LPWSTR servername
    820  *             LPWSTR LocalGroupName
    821  *             DWORD level
    822  *             LPBYTE buf
    823  *             DWORD membercount
    824  * Variables :
    825  * Result    :
    826  * Remark    :
    827  * Status    : UNTESTED STUB
    828  *
    829  * Stub Generated through PE2LX Stubwizard 0.02 from Markus Montkowski
    830  *
    831  * Author    : Markus Montkowski [09.07.98 21:40:51]
    832  *****************************************************************************/
    833 ODINFUNCTION5(NET_API_STATUS, OS2NetLocalGroupAddMembers,
    834               LPWSTR, servername,
    835               LPWSTR, LocalGroupName,
    836               DWORD, level,
    837               LPBYTE, buf,
    838               DWORD, membercount)
    839 
    840 {
    841 
    842   dprintf(("NETAPI32: NetLocalGroupAddMembers(%08x, %08x, %d, %08x, %d) not implemented\n"
    843            ,servername, LocalGroupName, level, buf, membercount
    844          ));
    845 
    846   return (NERR_BASE);
    847 }
    848 
    849 /*****************************************************************************
    850  * Name      : NET_API_STATUS NetLocalGroupDel
    851  * Purpose   :
    852  * Parameters: LPWSTR servername
    853  *             LPWSTR LocalGroupName
    854  * Variables :
    855  * Result    :
    856  * Remark    :
    857  * Status    : UNTESTED STUB
    858  *
    859  * Stub Generated through PE2LX Stubwizard 0.02 from Markus Montkowski
    860  *
    861  * Author    : Markus Montkowski [09.07.98 21:41:03]
    862  *****************************************************************************/
    863 ODINFUNCTION2(NET_API_STATUS, OS2NetLocalGroupDel,
    864               LPWSTR, servername,
    865               LPWSTR, LocalGroupName)
    866 
    867 {
    868 
    869   dprintf(("NETAPI32: NetLocalGroupDel(%08x, %08x) not implemented\n"
    870            ,servername, LocalGroupName
    871          ));
    872 
    873   return (NERR_BASE);
    874 }
    875 
    876 /*****************************************************************************
    877  * Name      : NET_API_STATUS NetLocalGroupDelMembers
    878  * Purpose   :
    879  * Parameters: LPWSTR servername
    880  *             LPWSTR LocalGroupName
    881  *             DWORD level
    882  *             LPBYTE buf
    883  *             DWORD membercount
    884  * Variables :
    885  * Result    :
    886  * Remark    :
    887  * Status    : UNTESTED STUB
    888  *
    889  * Stub Generated through PE2LX Stubwizard 0.02 from Markus Montkowski
    890  *
    891  * Author    : Markus Montkowski [09.07.98 21:41:33]
    892  *****************************************************************************/
    893 ODINFUNCTION5(NET_API_STATUS, OS2NetLocalGroupDelMembers,
    894               LPWSTR, servername,
    895               LPWSTR, LocalGroupName,
    896               DWORD, level,
    897               LPBYTE, buf,
    898               DWORD, membercount)
    899 
    900 {
    901 
    902   dprintf(("NETAPI32: NetLocalGroupDelMembers(%08x, %08x, %d, %08x, %d) not implemented\n"
    903            ,servername, LocalGroupName, level, buf, membercount
    904          ));
    905 
    906   return (NERR_BASE);
    907 }
    908 
    909 /*****************************************************************************
    910  * Name      : NET_API_STATUS NetLocalGroupEnum
    911  * Purpose   :
    912  * Parameters: LPWSTR servername
    913  *             DWORD level
    914  *             LPBYTE *bufptr
    915  *             DWORD prefmaxlen
    916  *             LPDWORD entriesread
    917  *             LPDWORD totalentries
    918  *             LPDWORD resumehandle
    919  * Variables :
    920  * Result    :
    921  * Remark    :
    922  * Status    : UNTESTED STUB
    923  *
    924  * Stub Generated through PE2LX Stubwizard 0.02 from Markus Montkowski
    925  *
    926  * Author    : Markus Montkowski [09.07.98 21:41:49]
    927  *****************************************************************************/
    928 ODINFUNCTION7(NET_API_STATUS, OS2NetLocalGroupEnum,
    929               LPWSTR, servername,
    930               DWORD, level,
    931               LPBYTE *, bufptr,
    932               DWORD, prefmaxlen,
    933               LPDWORD, entriesread,
    934               LPDWORD, totalentries,
    935               LPDWORD, resumehandle)
    936 
    937 {
    938 
    939   dprintf(("NETAPI32: NetLocalGroupEnum(%08x, %d, %08x, %d, %08x, %08x, %08x) not implemented\n"
    940            ,servername, level, *bufptr, prefmaxlen, entriesread, totalentries, resumehandle
    941          ));
    942 
    943   return (NERR_BASE);
    944 }
    945 
    946 /*****************************************************************************
    947  * Name      : NET_API_STATUS NetLocalGroupGetInfo
    948  * Purpose   :
    949  * Parameters: LPWSTR servername
    950  *             LPWSTR LocalGroupName
    951  *             DWORD level
    952  *             LPBYTE *bufptr
    953  * Variables :
    954  * Result    :
    955  * Remark    :
    956  * Status    : UNTESTED STUB
    957  *
    958  * Stub Generated through PE2LX Stubwizard 0.02 from Markus Montkowski
    959  *
    960  * Author    : Markus Montkowski [09.07.98 21:42:02]
    961  *****************************************************************************/
    962 ODINFUNCTION4(NET_API_STATUS, OS2NetLocalGroupGetInfo,
    963               LPWSTR, servername,
    964               LPWSTR, LocalGroupName,
    965               DWORD, level,
    966               LPBYTE *, bufptr)
    967 
    968 {
    969 
    970   dprintf(("NETAPI32: NetLocalGroupGetInfo(%08x, %08x, %d, %08x) not implemented\n"
    971            ,servername, LocalGroupName, level, *bufptr
    972          ));
    973 
    974   return (NERR_BASE);
    975 }
    976 
    977 /*****************************************************************************
    978  * Name      : NET_API_STATUS NetLocalGroupGetMembers
    979  * Purpose   :
    980  * Parameters: LPWSTR servername
    981  *             LPWSTR localgroupname
    982  *             DWORD level
    983  *             LPBYTE *bufptr
    984  *             DWORD prefmaxlen
    985  *             LPDWORD entriesread
    986  *             LPDWORD totalentries
    987  *             LPDWORD resumehandle
    988  * Variables :
    989  * Result    :
    990  * Remark    :
    991  * Status    : UNTESTED STUB
    992  *
    993  * Stub Generated through PE2LX Stubwizard 0.02 from Markus Montkowski
    994  *
    995  * Author    : Markus Montkowski [09.07.98 21:42:16]
    996  *****************************************************************************/
    997 ODINFUNCTION8(NET_API_STATUS, OS2NetLocalGroupGetMembers,
    998               LPWSTR, servername,
    999               LPWSTR, localgroupname,
    1000               DWORD, level,
    1001               LPBYTE *, bufptr,
    1002               DWORD, prefmaxlen,
    1003               LPDWORD, entriesread,
    1004               LPDWORD, totalentries,
    1005               LPDWORD, resumehandle)
    1006 
    1007 {
    1008 
    1009   dprintf(("NETAPI32: NetLocalGroupGetMembers(%08x, %08x, %d, %08x, %d, %08x, %08x, %08x) not implemented\n"
    1010            ,servername, localgroupname, level, *bufptr, prefmaxlen, entriesread, totalentries, resumehandle
    1011          ));
    1012 
    1013   return (NERR_BASE);
    1014 }
    1015 
    1016 /*****************************************************************************
    1017  * Name      : NET_API_STATUS NetLocalGroupSetInfo
    1018  * Purpose   :
    1019  * Parameters: LPWSTR servername
    1020  *             LPWSTR LocalGroupName
    1021  *             DWORD level
    1022  *             LPBYTE buf
    1023  *             LPDWORD parm_err
    1024  * Variables :
    1025  * Result    :
    1026  * Remark    :
    1027  * Status    : UNTESTED STUB
    1028  *
    1029  * Stub Generated through PE2LX Stubwizard 0.02 from Markus Montkowski
    1030  *
    1031  * Author    : Markus Montkowski [09.07.98 21:42:27]
    1032  *****************************************************************************/
    1033 ODINFUNCTION5(NET_API_STATUS, OS2NetLocalGroupSetInfo,
    1034               LPWSTR, servername,
    1035               LPWSTR, LocalGroupName,
    1036               DWORD, level,
    1037               LPBYTE, buf,
    1038               LPDWORD, parm_err)
    1039 
    1040 {
    1041 
    1042   dprintf(("NETAPI32: NetLocalGroupSetInfo(%08x, %08x, %d, %08x, %08x) not implemented\n"
    1043            ,servername, LocalGroupName, level, buf, parm_err
    1044          ));
    1045 
    1046   return (NERR_BASE);
    1047 }
    1048 
    1049 /*****************************************************************************
    1050  * Name      : NET_API_STATUS NetLocalGroupSetMembers
    1051  * Purpose   :
    1052  * Parameters: LPWSTR servername
    1053  *             LPWSTR LocalGroupName
    1054  *             DWORD level
    1055  *             LPBYTE buf
    1056  *             DWORD totalentries
    1057  * Variables :
    1058  * Result    :
    1059  * Remark    :
    1060  * Status    : UNTESTED STUB
    1061  *
    1062  * Stub Generated through PE2LX Stubwizard 0.02 from Markus Montkowski
    1063  *
    1064  * Author    : Markus Montkowski [09.07.98 21:42:49]
    1065  *****************************************************************************/
    1066 ODINFUNCTION5(NET_API_STATUS, OS2NetLocalGroupSetMembers,
    1067               LPWSTR, servername,
    1068               LPWSTR, LocalGroupName,
    1069               DWORD, level,
    1070               LPBYTE, buf,
    1071               DWORD, totalentries)
    1072 
    1073 {
    1074 
    1075   dprintf(("NETAPI32: NetLocalGroupSetMembers(%08x, %08x, %d, %08x, %d) not implemented\n"
    1076            ,servername, LocalGroupName, level, buf, totalentries
    1077          ));
    1078 
    1079   return (NERR_BASE);
    1080 }
     412
    1081413
    1082414/*****************************************************************************
     
    1301633}
    1302634
    1303 /*****************************************************************************
    1304  * Name      : NET_API_STATUS NetReplExportDirAdd
    1305  * Purpose   :
    1306  * Parameters: LPWSTR servername
    1307  *             DWORD level
    1308  *             LPBYTE buf
    1309  *             LPDWORD parm_err
    1310  * Variables :
    1311  * Result    :
    1312  * Remark    :
    1313  * Status    : UNTESTED STUB
    1314  *
    1315  * Stub Generated through PE2LX Stubwizard 0.02 from Markus Montkowski
    1316  *
    1317  * Author    : Markus Montkowski [09.07.98 21:47:52]
    1318  *****************************************************************************/
    1319 ODINFUNCTION4(NET_API_STATUS, OS2NetReplExportDirAdd,
    1320               LPWSTR, servername,
    1321               DWORD, level,
    1322               LPBYTE, buf,
    1323               LPDWORD, parm_err)
    1324 
    1325 {
    1326 
    1327   dprintf(("NETAPI32: NetReplExportDirAdd(%s, %d, %08x, %08x) not implemented\n"
    1328            ,servername, level, buf, parm_err
    1329          ));
    1330 
    1331   return (NERR_BASE);
    1332 }
    1333 
    1334 /*****************************************************************************
    1335  * Name      : NET_API_STATUS NetReplExportDirDel
    1336  * Purpose   :
    1337  * Parameters: LPWSTR servername
    1338  *             LPWSTR dirname
    1339  * Variables :
    1340  * Result    :
    1341  * Remark    :
    1342  * Status    : UNTESTED STUB
    1343  *
    1344  * Stub Generated through PE2LX Stubwizard 0.02 from Markus Montkowski
    1345  *
    1346  * Author    : Markus Montkowski [09.07.98 21:48:42]
    1347  *****************************************************************************/
    1348 ODINFUNCTION2(NET_API_STATUS, OS2NetReplExportDirDel,
    1349               LPWSTR, servername,
    1350               LPWSTR, dirname)
    1351 
    1352 {
    1353 
    1354   dprintf(("NETAPI32: NetReplExportDirDel(%s, %s) not implemented\n"
    1355            ,servername, dirname
    1356          ));
    1357 
    1358   return (NERR_BASE);
    1359 }
    1360 
    1361 
    1362 
    1363 /*****************************************************************************
    1364  * Name      : NET_API_STATUS NetReplExportDirEnum
    1365  * Purpose   :
    1366  * Parameters: LPWSTR servername
    1367  *             DWORD level
    1368  *             LPBYTE *bufptr
    1369  *             DWORD prefmaxlen
    1370  *             LPDWORD entriesread
    1371  *             LPDWORD totalentries
    1372  *             LPDWORD resumehandle
    1373  * Variables :
    1374  * Result    :
    1375  * Remark    :
    1376  * Status    : UNTESTED STUB
    1377  *
    1378  * Stub Generated through PE2LX Stubwizard 0.02 from Markus Montkowski
    1379  *
    1380  * Author    : Markus Montkowski [09.07.98 21:49:05]
    1381  *****************************************************************************/
    1382 ODINFUNCTION7(NET_API_STATUS, OS2NetReplExportDirEnum,
    1383               LPWSTR, servername,
    1384               DWORD, level,
    1385               LPBYTE *, bufptr,
    1386               DWORD, prefmaxlen,
    1387               LPDWORD, entriesread,
    1388               LPDWORD, totalentries,
    1389               LPDWORD, resumehandle)
    1390 
    1391 {
    1392 
    1393   dprintf(("NETAPI32: NetReplExportDirEnum(%s, %d, %08x, %d, %08x, %08x, %08x) not implemented\n"
    1394            ,servername, level, *bufptr, prefmaxlen, entriesread, totalentries, resumehandle
    1395          ));
    1396 
    1397   return (NERR_BASE);
    1398 }
    1399 /*****************************************************************************
    1400  * Name      : NET_API_STATUS NetReplExportDirGetInfo
    1401  * Purpose   :
    1402  * Parameters: LPWSTR servername
    1403  *             LPWSTR dirname
    1404  *             DWORD level
    1405  *             LPBYTE *bufptr
    1406  * Variables :
    1407  * Result    :
    1408  * Remark    :
    1409  * Status    : UNTESTED STUB
    1410  *
    1411  * Stub Generated through PE2LX Stubwizard 0.02 from Markus Montkowski
    1412  *
    1413  * Author    : Markus Montkowski [09.07.98 21:49:34]
    1414  *****************************************************************************/
    1415 ODINFUNCTION4(NET_API_STATUS, OS2NetReplExportDirGetInfo,
    1416               LPWSTR, servername,
    1417               LPWSTR, dirname,
    1418               DWORD, level,
    1419               LPBYTE *, bufptr)
    1420 
    1421 {
    1422 
    1423   dprintf(("NETAPI32: NetReplExportDirGetInfo(%s, %s, %d, %08x) not implemented\n"
    1424            ,servername, dirname, level, *bufptr
    1425          ));
    1426 
    1427   return (NERR_BASE);
    1428 }
    1429 /*****************************************************************************
    1430  * Name      : NET_API_STATUS NetReplExportDirLock
    1431  * Purpose   :
    1432  * Parameters: LPWSTR servername
    1433  *             LPWSTR dirname
    1434  * Variables :
    1435  * Result    :
    1436  * Remark    :
    1437  * Status    : UNTESTED STUB
    1438  *
    1439  * Stub Generated through PE2LX Stubwizard 0.02 from Markus Montkowski
    1440  *
    1441  * Author    : Markus Montkowski [09.07.98 21:49:58]
    1442  *****************************************************************************/
    1443 ODINFUNCTION2(NET_API_STATUS, OS2NetReplExportDirLock,
    1444               LPWSTR, servername,
    1445               LPWSTR, dirname)
    1446 
    1447 {
    1448 
    1449   dprintf(("NETAPI32: NetReplExportDirLock(%s, %s) not implemented\n"
    1450            ,servername, dirname
    1451          ));
    1452 
    1453   return (NERR_BASE);
    1454 }
    1455 
    1456 /*****************************************************************************
    1457  * Name      : NET_API_STATUS NetReplExportDirSetInfo
    1458  * Purpose   :
    1459  * Parameters: LPWSTR servername
    1460  *             LPWSTR dirname
    1461  *             DWORD level
    1462  *             LPBYTE buf
    1463  *             LPDWORD parm_err
    1464  * Variables :
    1465  * Result    :
    1466  * Remark    :
    1467  * Status    : UNTESTED STUB
    1468  *
    1469  * Stub Generated through PE2LX Stubwizard 0.02 from Markus Montkowski
    1470  *
    1471  * Author    : Markus Montkowski [09.07.98 21:50:31]
    1472  *****************************************************************************/
    1473 ODINFUNCTION5(NET_API_STATUS, OS2NetReplExportDirSetInfo,
    1474               LPWSTR, servername,
    1475               LPWSTR, dirname,
    1476               DWORD, level,
    1477               LPBYTE, buf,
    1478               LPDWORD, parm_err)
    1479 
    1480 {
    1481 
    1482   dprintf(("NETAPI32: NetReplExportDirSetInfo(%s, %s, %d, %08x, %08x) not implemented\n"
    1483            ,servername, dirname, level, buf, parm_err
    1484          ));
    1485 
    1486   return (NERR_BASE);
    1487 }
    1488 /*****************************************************************************
    1489  * Name      : NET_API_STATUS NetReplExportDirUnlock
    1490  * Purpose   :
    1491  * Parameters: LPWSTR servername
    1492  *             LPWSTR dirname
    1493  *             DWORD unlockforce
    1494  * Variables :
    1495  * Result    :
    1496  * Remark    :
    1497  * Status    : UNTESTED STUB
    1498  *
    1499  * Stub Generated through PE2LX Stubwizard 0.02 from Markus Montkowski
    1500  *
    1501  * Author    : Markus Montkowski [09.07.98 21:51:12]
    1502  *****************************************************************************/
    1503 ODINFUNCTION3(NET_API_STATUS, OS2NetReplExportDirUnlock,
    1504               LPWSTR, servername,
    1505               LPWSTR, dirname,
    1506               DWORD, unlockforce)
    1507 
    1508 {
    1509 
    1510   dprintf(("NETAPI32: NetReplExportDirUnlock(%s, %s, %d) not implemented\n"
    1511            ,servername, dirname, unlockforce
    1512          ));
    1513 
    1514   return (NERR_BASE);
    1515 }
    1516 
    1517 
    1518 /*****************************************************************************
    1519  * Name      : NET_API_STATUS NetReplGetInfo
    1520  * Purpose   :
    1521  * Parameters: LPWSTR servername
    1522  *             DWORD level
    1523  *             LPBYTE *bufptr
    1524  * Variables :
    1525  * Result    :
    1526  * Remark    :
    1527  * Status    : UNTESTED STUB
    1528  *
    1529  * Stub Generated through PE2LX Stubwizard 0.02 from Markus Montkowski
    1530  *
    1531  * Author    : Markus Montkowski [09.07.98 21:51:37]
    1532  *****************************************************************************/
    1533 ODINFUNCTION3(NET_API_STATUS, OS2NetReplGetInfo,
    1534               LPWSTR, servername,
    1535               DWORD, level,
    1536               LPBYTE *, bufptr)
    1537 
    1538 {
    1539 
    1540   dprintf(("NETAPI32: NetReplGetInfo(%s, %d, %08x) not implemented\n"
    1541            ,servername, level, *bufptr
    1542          ));
    1543 
    1544   return (NERR_BASE);
    1545 }
    1546 /*****************************************************************************
    1547  * Name      : NET_API_STATUS NetReplImportDirAdd
    1548  * Purpose   :
    1549  * Parameters: LPWSTR servername
    1550  *             DWORD level
    1551  *             LPBYTE buf
    1552  *             LPDWORD parm_err
    1553  * Variables :
    1554  * Result    :
    1555  * Remark    :
    1556  * Status    : UNTESTED STUB
    1557  *
    1558  * Stub Generated through PE2LX Stubwizard 0.02 from Markus Montkowski
    1559  *
    1560  * Author    : Markus Montkowski [09.07.98 21:52:11]
    1561  *****************************************************************************/
    1562 ODINFUNCTION4(NET_API_STATUS, OS2NetReplImportDirAdd,
    1563               LPWSTR, servername,
    1564               DWORD, level,
    1565               LPBYTE, buf,
    1566               LPDWORD, parm_err)
    1567 
    1568 {
    1569 
    1570   dprintf(("NETAPI32: NetReplImportDirAdd(%s, %d, %08x, %08x) not implemented\n"
    1571            ,servername, level, buf, parm_err
    1572          ));
    1573 
    1574   return (NERR_BASE);
    1575 }
    1576 
    1577 /*****************************************************************************
    1578  * Name      : NET_API_STATUS NetReplImportDirDel
    1579  * Purpose   :
    1580  * Parameters: LPWSTR servername
    1581  *             LPWSTR dirname
    1582  * Variables :
    1583  * Result    :
    1584  * Remark    :
    1585  * Status    : UNTESTED STUB
    1586  *
    1587  * Stub Generated through PE2LX Stubwizard 0.02 from Markus Montkowski
    1588  *
    1589  * Author    : Markus Montkowski [09.07.98 21:52:36]
    1590  *****************************************************************************/
    1591 ODINFUNCTION2(NET_API_STATUS, OS2NetReplImportDirDel,
    1592               LPWSTR, servername,
    1593               LPWSTR, dirname)
    1594 
    1595 {
    1596 
    1597   dprintf(("NETAPI32: NetReplImportDirDel(%s, %s) not implemented\n"
    1598            ,servername, dirname
    1599          ));
    1600 
    1601   return (NERR_BASE);
    1602 }
    1603 
    1604 /*****************************************************************************
    1605  * Name      : NET_API_STATUS NetReplImportDirEnum
    1606  * Purpose   :
    1607  * Parameters: LPWSTR servername
    1608  *             DWORD level
    1609  *             LPBYTE *bufptr
    1610  *             DWORD prefmaxlen
    1611  *             LPDWORD entriesread
    1612  *             LPDWORD totalentries
    1613  *             LPDWORD resumehandle
    1614  * Variables :
    1615  * Result    :
    1616  * Remark    :
    1617  * Status    : UNTESTED STUB
    1618  *
    1619  * Stub Generated through PE2LX Stubwizard 0.02 from Markus Montkowski
    1620  *
    1621  * Author    : Markus Montkowski [09.07.98 21:52:56]
    1622  *****************************************************************************/
    1623 ODINFUNCTION7(NET_API_STATUS, OS2NetReplImportDirEnum,
    1624               LPWSTR, servername,
    1625               DWORD, level,
    1626               LPBYTE *, bufptr,
    1627               DWORD, prefmaxlen,
    1628               LPDWORD, entriesread,
    1629               LPDWORD, totalentries,
    1630               LPDWORD, resumehandle)
    1631 
    1632 {
    1633 
    1634   dprintf(("NETAPI32: NetReplImportDirEnum(%s, %d, %08x, %d, %08x, %08x, %08x) not implemented\n"
    1635            ,servername, level, *bufptr, prefmaxlen, entriesread, totalentries, resumehandle
    1636          ));
    1637 
    1638   return (NERR_BASE);
    1639 }
    1640 /*****************************************************************************
    1641  * Name      : NET_API_STATUS NetReplImportDirGetInfo
    1642  * Purpose   :
    1643  * Parameters: LPWSTR servername
    1644  *             LPWSTR dirname
    1645  *             DWORD level
    1646  *             LPBYTE *bufptr
    1647  * Variables :
    1648  * Result    :
    1649  * Remark    :
    1650  * Status    : UNTESTED STUB
    1651  *
    1652  * Stub Generated through PE2LX Stubwizard 0.02 from Markus Montkowski
    1653  *
    1654  * Author    : Markus Montkowski [09.07.98 21:53:24]
    1655  *****************************************************************************/
    1656 ODINFUNCTION4(NET_API_STATUS, OS2NetReplImportDirGetInfo,
    1657               LPWSTR, servername,
    1658               LPWSTR, dirname,
    1659               DWORD, level,
    1660               LPBYTE *, bufptr)
    1661 
    1662 {
    1663 
    1664   dprintf(("NETAPI32: NetReplImportDirGetInfo(%s, %s, %d, %08x) not implemented\n"
    1665            ,servername, dirname, level, *bufptr
    1666          ));
    1667 
    1668   return (NERR_BASE);
    1669 }
    1670 
    1671 /*****************************************************************************
    1672  * Name      : NET_API_STATUS NetReplImportDirLock
    1673  * Purpose   :
    1674  * Parameters: LPWSTR servername
    1675  *             LPWSTR dirname
    1676  * Variables :
    1677  * Result    :
    1678  * Remark    :
    1679  * Status    : UNTESTED STUB
    1680  *
    1681  * Stub Generated through PE2LX Stubwizard 0.02 from Markus Montkowski
    1682  *
    1683  * Author    : Markus Montkowski [09.07.98 21:53:45]
    1684  *****************************************************************************/
    1685 ODINFUNCTION2(NET_API_STATUS, OS2NetReplImportDirLock,
    1686               LPWSTR, servername,
    1687               LPWSTR, dirname)
    1688 
    1689 {
    1690 
    1691   dprintf(("NETAPI32: NetReplImportDirLock(%s, %s) not implemented\n"
    1692            ,servername, dirname
    1693          ));
    1694 
    1695   return (NERR_BASE);
    1696 }
    1697 
    1698 
    1699 /*****************************************************************************
    1700  * Name      : NET_API_STATUS NetReplImportDirUnlock
    1701  * Purpose   :
    1702  * Parameters: LPWSTR servername
    1703  *             LPWSTR dirname
    1704  *             DWORD unlockforce
    1705  * Variables :
    1706  * Result    :
    1707  * Remark    :
    1708  * Status    : UNTESTED STUB
    1709  *
    1710  * Stub Generated through PE2LX Stubwizard 0.02 from Markus Montkowski
    1711  *
    1712  * Author    : Markus Montkowski [09.07.98 21:54:16]
    1713  *****************************************************************************/
    1714 ODINFUNCTION3(NET_API_STATUS, OS2NetReplImportDirUnlock,
    1715               LPWSTR, servername,
    1716               LPWSTR, dirname,
    1717               DWORD, unlockforce)
    1718 
    1719 {
    1720 
    1721   dprintf(("NETAPI32: NetReplImportDirUnlock(%s, %s, %d) not implemented\n"
    1722            ,servername, dirname, unlockforce
    1723          ));
    1724 
    1725   return (NERR_BASE);
    1726 }
    1727 /*****************************************************************************
    1728  * Name      : NET_API_STATUS NetReplSetInfo
    1729  * Purpose   :
    1730  * Parameters: LPWSTR servername
    1731  *             DWORD level
    1732  *             LPBYTE buf
    1733  *             LPDWORD parm_err
    1734  * Variables :
    1735  * Result    :
    1736  * Remark    :
    1737  * Status    : UNTESTED STUB
    1738  *
    1739  * Stub Generated through PE2LX Stubwizard 0.02 from Markus Montkowski
    1740  *
    1741  * Author    : Markus Montkowski [09.07.98 21:54:38]
    1742  *****************************************************************************/
    1743 ODINFUNCTION4(NET_API_STATUS, OS2NetReplSetInfo,
    1744               LPWSTR, servername,
    1745               DWORD, level,
    1746               LPBYTE, buf,
    1747               LPDWORD, parm_err)
    1748 
    1749 {
    1750 
    1751   dprintf(("NETAPI32: NetReplSetInfo(%s, %d, %08x, %08x) not implemented\n"
    1752            ,servername, level, buf, parm_err
    1753          ));
    1754 
    1755   return (NERR_BASE);
    1756 }
    1757 
    1758 
    1759 /*****************************************************************************
    1760  * Name      : NET_API_STATUS NetScheduleJobAdd
    1761  * Purpose   :
    1762  * Parameters: LPWSTR Servername
    1763  *             LPBYTE Buffer
    1764  *             LPDWORD JobId
    1765  * Variables :
    1766  * Result    :
    1767  * Remark    :
    1768  * Status    : UNTESTED STUB
    1769  *
    1770  * Stub Generated through PE2LX Stubwizard 0.02 from Markus Montkowski
    1771  *
    1772  * Author    : Markus Montkowski [09.07.98 21:55:41]
    1773  *****************************************************************************/
    1774 ODINFUNCTION3(NET_API_STATUS, OS2NetScheduleJobAdd,
    1775               LPWSTR, Servername,
    1776               LPBYTE, Buffer,
    1777               LPDWORD, JobId)
    1778 
    1779 {
    1780 
    1781   dprintf(("NETAPI32: NetScheduleJobAdd(%08x, %08x, %08x) not implemented\n"
    1782            ,Servername, Buffer, JobId
    1783          ));
    1784 
    1785   return (NERR_BASE);
    1786 }
    1787 
    1788 /*****************************************************************************
    1789  * Name      : NET_API_STATUS NetScheduleJobDel
    1790  * Purpose   :
    1791  * Parameters: LPWSTR Servername
    1792  *             DWORD MinJobId
    1793  *             DWORD MaxJobId
    1794  * Variables :
    1795  * Result    :
    1796  * Remark    :
    1797  * Status    : UNTESTED STUB
    1798  *
    1799  * Stub Generated through PE2LX Stubwizard 0.02 from Markus Montkowski
    1800  *
    1801  * Author    : Markus Montkowski [09.07.98 21:55:50]
    1802  *****************************************************************************/
    1803 ODINFUNCTION3(NET_API_STATUS, OS2NetScheduleJobDel,
    1804               LPWSTR, Servername,
    1805               DWORD, MinJobId,
    1806               DWORD, MaxJobId)
    1807 
    1808 {
    1809 
    1810   dprintf(("NETAPI32: NetScheduleJobDel(%08x, %d, %d) not implemented\n"
    1811            ,Servername, MinJobId, MaxJobId
    1812          ));
    1813 
    1814   return (NERR_BASE);
    1815 }
    1816 
    1817 /*****************************************************************************
    1818  * Name      : NET_API_STATUS NetScheduleJobEnum
    1819  * Purpose   :
    1820  * Parameters: LPWSTR Servername
    1821  *             LPBYTE *PointerToBuffer
    1822  *             DWORD PreferredMaximumLength
    1823  *             LPDWORD EntriesRead
    1824  *             LPDWORD TotalEntries
    1825  *             LPDWORD ResumeHandle
    1826  * Variables :
    1827  * Result    :
    1828  * Remark    :
    1829  * Status    : UNTESTED STUB
    1830  *
    1831  * Stub Generated through PE2LX Stubwizard 0.02 from Markus Montkowski
    1832  *
    1833  * Author    : Markus Montkowski [09.07.98 21:56:02]
    1834  *****************************************************************************/
    1835 ODINFUNCTION6(NET_API_STATUS, OS2NetScheduleJobEnum,
    1836               LPWSTR, Servername,
    1837               LPBYTE *, PointerToBuffer,
    1838               DWORD, PreferredMaximumLength,
    1839               LPDWORD, EntriesRead,
    1840               LPDWORD, TotalEntries,
    1841               LPDWORD, ResumeHandle)
    1842 
    1843 {
    1844 
    1845   dprintf(("NETAPI32: NetScheduleJobEnum(%08x, %08x, %d, %08x, %08x, %08x) not implemented\n"
    1846            ,Servername, *PointerToBuffer, PreferredMaximumLength, EntriesRead, TotalEntries, ResumeHandle
    1847          ));
    1848 
    1849   return (NERR_BASE);
    1850 }
    1851 
    1852 /*****************************************************************************
    1853  * Name      : NET_API_STATUS NetScheduleJobGetInfo
    1854  * Purpose   :
    1855  * Parameters: LPWSTR Servername
    1856  *             DWORD JobId
    1857  *             LPBYTE *PointerToBuffer
    1858  * Variables :
    1859  * Result    :
    1860  * Remark    :
    1861  * Status    : UNTESTED STUB
    1862  *
    1863  * Stub Generated through PE2LX Stubwizard 0.02 from Markus Montkowski
    1864  *
    1865  * Author    : Markus Montkowski [09.07.98 21:56:23]
    1866  *****************************************************************************/
    1867 ODINFUNCTION3(NET_API_STATUS, OS2NetScheduleJobGetInfo,
    1868               LPWSTR, Servername,
    1869               DWORD, JobId,
    1870               LPBYTE *, PointerToBuffer)
    1871 
    1872 {
    1873 
    1874   dprintf(("NETAPI32: NetScheduleJobGetInfo(%08x, %d, %08x) not implemented\n"
    1875            ,Servername, JobId, *PointerToBuffer
    1876          ));
    1877 
    1878   return (NERR_BASE);
    1879 }
    1880 
    1881 /*****************************************************************************
    1882  * Name      : NET_API_STATUS NetServerDiskEnum
    1883  * Purpose   :
    1884  * Parameters: LPWSTR servername
    1885  *             DWORD level
    1886  *             LPBYTE *bufptr
    1887  *             DWORD prefmaxlen
    1888  *             LPDWORD entriesread
    1889  *             LPDWORD totalentries
    1890  *             LPDWORD resume_handle
    1891  * Variables :
    1892  * Result    :
    1893  * Remark    :
    1894  * Status    : UNTESTED STUB
    1895  *
    1896  * Stub Generated through PE2LX Stubwizard 0.02 from Markus Montkowski
    1897  *
    1898  * Author    : Markus Montkowski [09.07.98 21:56:38]
    1899  *****************************************************************************/
    1900 ODINFUNCTION7(NET_API_STATUS, OS2NetServerDiskEnum,
    1901               LPWSTR, servername,
    1902               DWORD, level,
    1903               LPBYTE *, bufptr,
    1904               DWORD, prefmaxlen,
    1905               LPDWORD, entriesread,
    1906               LPDWORD, totalentries,
    1907               LPDWORD, resume_handle)
    1908 
    1909 {
    1910 
    1911   dprintf(("NETAPI32: NetServerDiskEnum(%s, %d, %08x, %d, %08x, %08x, %08x) not implemented\n"
    1912            ,servername, level, *bufptr, prefmaxlen, entriesread, totalentries, resume_handle
    1913          ));
    1914 
    1915   return (NERR_BASE);
    1916 }
    1917 /*****************************************************************************
    1918  * Name      : NET_API_STATUS NetServerEnum
    1919  * Purpose   :
    1920  * Parameters: LPWSTR servername
    1921  *             DWORD level
    1922  *             LPBYTE *bufptr
    1923  *             DWORD prefmaxlen
    1924  *             LPDWORD entriesread
    1925  *             LPDWORD totalentries
    1926  *             DWORD servertype
    1927  *             LPWSTR domain
    1928  *             LPDWORD resume_handle
    1929  * Variables :
    1930  * Result    :
    1931  * Remark    :
    1932  * Status    : UNTESTED STUB
    1933  *
    1934  * Stub Generated through PE2LX Stubwizard 0.02 from Markus Montkowski
    1935  *
    1936  * Author    : Markus Montkowski [09.07.98 21:57:09]
    1937  *****************************************************************************/
    1938 ODINFUNCTION9(NET_API_STATUS, OS2NetServerEnum,
    1939               LPWSTR, servername,
    1940               DWORD, level,
    1941               LPBYTE *, bufptr,
    1942               DWORD, prefmaxlen,
    1943               LPDWORD, entriesread,
    1944               LPDWORD, totalentries,
    1945               DWORD, servertype,
    1946               LPWSTR, domain,
    1947               LPDWORD, resume_handle)
    1948 
    1949 {
    1950 
    1951   dprintf(("NETAPI32: NetServerEnum(%s, %d, %08x, %d, %08x, %08x, %d, %s, %08x) not implemented\n"
    1952            ,servername, level, *bufptr, prefmaxlen, entriesread, totalentries, servertype, domain, resume_handle
    1953          ));
    1954 
    1955   return (NERR_BASE);
    1956 }
    1957 /*****************************************************************************
    1958  * Name      : NET_API_STATUS NetServerGetInfo
    1959  * Purpose   :
    1960  * Parameters: LPWSTR servername
    1961  *             DWORD level
    1962  *             LPBYTE *bufptr
    1963  * Variables :
    1964  * Result    :
    1965  * Remark    :
    1966  * Status    : UNTESTED STUB
    1967  *
    1968  * Stub Generated through PE2LX Stubwizard 0.02 from Markus Montkowski
    1969  *
    1970  * Author    : Markus Montkowski [09.07.98 21:57:43]
    1971  *****************************************************************************/
    1972 ODINFUNCTION3(NET_API_STATUS, OS2NetServerGetInfo,
    1973               LPWSTR, servername,
    1974               DWORD, level,
    1975               LPBYTE *, bufptr)
    1976 
    1977 {
    1978 
    1979   dprintf(("NETAPI32: NetServerGetInfo(%s, %d, %08x) not implemented\n"
    1980            ,servername, level, *bufptr
    1981          ));
    1982 
    1983   return (NERR_BASE);
    1984 }
    1985 
    1986 /*****************************************************************************
    1987  * Name      : NET_API_STATUS NetServerSetInfo
    1988  * Purpose   :
    1989  * Parameters: LPWSTR servername
    1990  *             DWORD level
    1991  *             LPBYTE buf
    1992  *             LPDWORD ParmError
    1993  * Variables :
    1994  * Result    :
    1995  * Remark    :
    1996  * Status    : UNTESTED STUB
    1997  *
    1998  * Stub Generated through PE2LX Stubwizard 0.02 from Markus Montkowski
    1999  *
    2000  * Author    : Markus Montkowski [09.07.98 21:58:14]
    2001  *****************************************************************************/
    2002 ODINFUNCTION4(NET_API_STATUS, OS2NetServerSetInfo,
    2003               LPWSTR, servername,
    2004               DWORD, level,
    2005               LPBYTE, buf,
    2006               LPDWORD, ParmError)
    2007 
    2008 {
    2009 
    2010   dprintf(("NETAPI32: NetServerSetInfo(%s, %d, %08x, %08x) not implemented\n"
    2011            ,servername, level, buf, ParmError
    2012          ));
    2013 
    2014   return (NERR_BASE);
    2015 }
    2016 
    2017 
    2018 /*****************************************************************************
    2019  * Name      : NET_API_STATUS NetServerTransportAdd
    2020  * Purpose   :
    2021  * Parameters: LPWSTR servername
    2022  *             DWORD level
    2023  *             LPBYTE bufptr
    2024  * Variables :
    2025  * Result    :
    2026  * Remark    :
    2027  * Status    : UNTESTED STUB
    2028  *
    2029  * Stub Generated through PE2LX Stubwizard 0.02 from Markus Montkowski
    2030  *
    2031  * Author    : Markus Montkowski [09.07.98 21:58:34]
    2032  *****************************************************************************/
    2033 ODINFUNCTION3(NET_API_STATUS, OS2NetServerTransportAdd,
    2034               LPWSTR, servername,
    2035               DWORD, level,
    2036               LPBYTE, bufptr)
    2037 
    2038 {
    2039 
    2040   dprintf(("NETAPI32: NetServerTransportAdd(%s, %d, %08x) not implemented\n"
    2041            ,servername, level, bufptr
    2042          ));
    2043 
    2044   return (NERR_BASE);
    2045 }
    2046 
    2047 /*****************************************************************************
    2048  * Name      : NET_API_STATUS NetServerTransportDel
    2049  * Purpose   :
    2050  * Parameters: LPWSTR servername
    2051  *             LPWSTR transportname
    2052  * Variables :
    2053  * Result    :
    2054  * Remark    :
    2055  * Status    : UNTESTED STUB
    2056  *
    2057  * Stub Generated through PE2LX Stubwizard 0.02 from Markus Montkowski
    2058  *
    2059  * Author    : Markus Montkowski [09.07.98 21:59:12]
    2060  *****************************************************************************/
    2061 ODINFUNCTION2(NET_API_STATUS, OS2NetServerTransportDel,
    2062               LPWSTR, servername,
    2063               LPWSTR, transportname)
    2064 
    2065 {
    2066 
    2067   dprintf(("NETAPI32: NetServerTransportDel(%08x, %08x) not implemented\n"
    2068            ,servername, transportname
    2069          ));
    2070 
    2071   return (NERR_BASE);
    2072 }
    2073 
    2074 /*****************************************************************************
    2075  * Name      : NET_API_STATUS NetServerTransportEnum
    2076  * Purpose   :
    2077  * Parameters: LPWSTR servername
    2078  *             DWORD level
    2079  *             LPBYTE *bufptr
    2080  *             DWORD prefmaxlen
    2081  *             LPDWORD entriesread
    2082  *             LPDWORD totalentries
    2083  *             LPDWORD resumehandle
    2084  * Variables :
    2085  * Result    :
    2086  * Remark    :
    2087  * Status    : UNTESTED STUB
    2088  *
    2089  * Stub Generated through PE2LX Stubwizard 0.02 from Markus Montkowski
    2090  *
    2091  * Author    : Markus Montkowski [09.07.98 21:59:37]
    2092  *****************************************************************************/
    2093 ODINFUNCTION7(NET_API_STATUS, OS2NetServerTransportEnum,
    2094               LPWSTR, servername,
    2095               DWORD, level,
    2096               LPBYTE *, bufptr,
    2097               DWORD, prefmaxlen,
    2098               LPDWORD, entriesread,
    2099               LPDWORD, totalentries,
    2100               LPDWORD, resumehandle)
    2101 
    2102 {
    2103 
    2104   dprintf(("NETAPI32: NetServerTransportEnum(%s, %d, %08x, %d, %08x, %08x, %08x) not implemented\n"
    2105            ,servername, level, *bufptr, prefmaxlen, entriesread, totalentries, resumehandle
    2106          ));
    2107 
    2108   return (NERR_BASE);
    2109 }
     635
    2110636/*****************************************************************************
    2111637 * Name      : NET_API_STATUS NetSessionDel
     
    2401927*/
    2402928
    2403 /*****************************************************************************
    2404  * Name      : NET_API_STATUS NetUserAdd
    2405  * Purpose   :
    2406  * Parameters: LPWSTR servername
    2407  *             DWORD level
    2408  *             LPBYTE buf
    2409  *             LPDWORD parm_err
    2410  * Variables :
    2411  * Result    :
    2412  * Remark    :
    2413  * Status    : UNTESTED STUB
    2414  *
    2415  * Stub Generated through PE2LX Stubwizard 0.02 from Markus Montkowski
    2416  *
    2417  * Author    : Markus Montkowski [09.07.98 22:06:02]
    2418  *****************************************************************************/
    2419 ODINFUNCTION4(NET_API_STATUS, OS2NetUserAdd,
    2420               LPWSTR, servername,
    2421               DWORD, level,
    2422               LPBYTE, buf,
    2423               LPDWORD, parm_err)
    2424 
    2425 {
    2426 
    2427   dprintf(("NETAPI32: NetUserAdd(%08x, %d, %08x, %08x) not implemented\n"
    2428            ,servername, level, buf, parm_err
    2429          ));
    2430 
    2431   return (NERR_BASE);
    2432 }
    2433 
    2434 /*****************************************************************************
    2435  * Name      : NET_API_STATUS NetUserChangePassword
    2436  * Purpose   :
    2437  * Parameters: LPWSTR domainname
    2438  *             LPWSTR username
    2439  *             LPWSTR oldpassword
    2440  *             LPWSTR newpassword
    2441  * Variables :
    2442  * Result    :
    2443  * Remark    :
    2444  * Status    : UNTESTED STUB
    2445  *
    2446  * Stub Generated through PE2LX Stubwizard 0.02 from Markus Montkowski
    2447  *
    2448  * Author    : Markus Montkowski [09.07.98 22:06:12]
    2449  *****************************************************************************/
    2450 ODINFUNCTION4(NET_API_STATUS, OS2NetUserChangePassword,
    2451               LPWSTR, domainname,
    2452               LPWSTR, username,
    2453               LPWSTR, oldpassword,
    2454               LPWSTR, newpassword)
    2455 
    2456 {
    2457 
    2458   dprintf(("NETAPI32: NetUserChangePassword(%08x, %08x, %08x, %08x) not implemented\n"
    2459            ,domainname, username, oldpassword, newpassword
    2460          ));
    2461 
    2462   return (NERR_BASE);
    2463 }
    2464 
    2465 /*****************************************************************************
    2466  * Name      : NET_API_STATUS NetUserDel
    2467  * Purpose   :
    2468  * Parameters: LPWSTR servername
    2469  *             LPWSTR username
    2470  * Variables :
    2471  * Result    :
    2472  * Remark    :
    2473  * Status    : UNTESTED STUB
    2474  *
    2475  * Stub Generated through PE2LX Stubwizard 0.02 from Markus Montkowski
    2476  *
    2477  * Author    : Markus Montkowski [09.07.98 22:06:25]
    2478  *****************************************************************************/
    2479 ODINFUNCTION2(NET_API_STATUS, OS2NetUserDel,
    2480               LPWSTR, servername,
    2481               LPWSTR, username)
    2482 
    2483 {
    2484 
    2485   dprintf(("NETAPI32: NetUserDel(%08x, %08x) not implemented\n"
    2486            ,servername, username
    2487          ));
    2488 
    2489   return (NERR_BASE);
    2490 }
    2491 
    2492 /*****************************************************************************
    2493  * Name      : NET_API_STATUS NetUserEnum
    2494  * Purpose   :
    2495  * Parameters: LPWSTR servername
    2496  *             DWORD level
    2497  *             DWORD filter
    2498  *             LPBYTE *bufptr
    2499  *             DWORD prefmaxlen
    2500  *             LPDWORD entriesread
    2501  *             LPDWORD totalentries
    2502  *             LPDWORD resume_handle
    2503  * Variables :
    2504  * Result    :
    2505  * Remark    :
    2506  * Status    : UNTESTED STUB
    2507  *
    2508  * Stub Generated through PE2LX Stubwizard 0.02 from Markus Montkowski
    2509  *
    2510  * Author    : Markus Montkowski [09.07.98 22:06:36]
    2511  *****************************************************************************/
    2512 ODINFUNCTION8(NET_API_STATUS, OS2NetUserEnum,
    2513               LPWSTR, servername,
    2514               DWORD, level,
    2515               DWORD, filter,
    2516               LPBYTE *, bufptr,
    2517               DWORD, prefmaxlen,
    2518               LPDWORD, entriesread,
    2519               LPDWORD, totalentries,
    2520               LPDWORD, resume_handle)
    2521 
    2522 {
    2523 
    2524   dprintf(("NETAPI32: NetUserEnum(%08x, %d, %d, %08x, %d, %08x, %08x, %08x) not implemented\n"
    2525            ,servername, level, filter, *bufptr, prefmaxlen, entriesread, totalentries, resume_handle
    2526          ));
    2527 
    2528   return (NERR_BASE);
    2529 }
    2530 
    2531 /*****************************************************************************
    2532  * Name      : NET_API_STATUS NetUserGetGroups
    2533  * Purpose   :
    2534  * Parameters: LPWSTR servername
    2535  *             LPWSTR username
    2536  *             DWORD level
    2537  *             LPBYTE *bufptr
    2538  *             DWORD prefmaxlen
    2539  *             LPDWORD entriesread
    2540  *             LPDWORD totalentries
    2541  * Variables :
    2542  * Result    :
    2543  * Remark    :
    2544  * Status    : UNTESTED STUB
    2545  *
    2546  * Stub Generated through PE2LX Stubwizard 0.02 from Markus Montkowski
    2547  *
    2548  * Author    : Markus Montkowski [09.07.98 22:06:50]
    2549  *****************************************************************************/
    2550 ODINFUNCTION7(NET_API_STATUS, OS2NetUserGetGroups,
    2551               LPWSTR, servername,
    2552               LPWSTR, username,
    2553               DWORD, level,
    2554               LPBYTE *, bufptr,
    2555               DWORD, prefmaxlen,
    2556               LPDWORD, entriesread,
    2557               LPDWORD, totalentries)
    2558 
    2559 {
    2560 
    2561   dprintf(("NETAPI32: NetUserGetGroups(%08x, %08x, %d, %08x, %d, %08x, %08x) not implemented\n"
    2562            ,servername, username, level, *bufptr, prefmaxlen, entriesread, totalentries
    2563          ));
    2564 
    2565   return (NERR_BASE);
    2566 }
    2567 
    2568 /*****************************************************************************
    2569  * Name      : NET_API_STATUS NetUserGetInfo
    2570  * Purpose   :
    2571  * Parameters: LPWSTR servername
    2572  *             LPWSTR username
    2573  *             DWORD level
    2574  *             LPBYTE *bufptr
    2575  * Variables :
    2576  * Result    :
    2577  * Remark    :
    2578  * Status    : UNTESTED STUB
    2579  *
    2580  * Stub Generated through PE2LX Stubwizard 0.02 from Markus Montkowski
    2581  *
    2582  * Author    : Markus Montkowski [09.07.98 22:09:52]
    2583  *****************************************************************************/
    2584 ODINFUNCTION4(NET_API_STATUS, OS2NetUserGetInfo,
    2585               LPWSTR, servername,
    2586               LPWSTR, username,
    2587               DWORD, level,
    2588               LPBYTE *, bufptr)
    2589 
    2590 {
    2591 
    2592   dprintf(("NETAPI32: NetUserGetInfo(%08x, %08x, %d, %08x) not implemented\n"
    2593            ,servername, username, level, *bufptr
    2594          ));
    2595 
    2596   return (NERR_BASE);
    2597 }
    2598 
    2599 /*****************************************************************************
    2600  * Name      : NET_API_STATUS NetUserGetLocalGroups
    2601  * Purpose   :
    2602  * Parameters: LPWSTR servername
    2603  *             LPWSTR username
    2604  *             DWORD level
    2605  *             DWORD flags
    2606  *             LPBYTE *bufptr
    2607  *             DWORD prefmaxlen
    2608  *             LPDWORD entriesread
    2609  *             LPDWORD totalentries
    2610  * Variables :
    2611  * Result    :
    2612  * Remark    :
    2613  * Status    : UNTESTED STUB
    2614  *
    2615  * Stub Generated through PE2LX Stubwizard 0.02 from Markus Montkowski
    2616  *
    2617  * Author    : Markus Montkowski [09.07.98 22:10:01]
    2618  *****************************************************************************/
    2619 ODINFUNCTION8(NET_API_STATUS, OS2NetUserGetLocalGroups,
    2620               LPWSTR, servername,
    2621               LPWSTR, username,
    2622               DWORD, level,
    2623               DWORD, flags,
    2624               LPBYTE *, bufptr,
    2625               DWORD, prefmaxlen,
    2626               LPDWORD, entriesread,
    2627               LPDWORD, totalentries)
    2628 
    2629 {
    2630 
    2631   dprintf(("NETAPI32: NetUserGetLocalGroups(%08x, %08x, %d, %d, %08x, %d, %08x, %08x) not implemented\n"
    2632            ,servername, username, level, flags, *bufptr, prefmaxlen, entriesread, totalentries
    2633          ));
    2634 
    2635   return (NERR_BASE);
    2636 }
    2637 
    2638 /*****************************************************************************
    2639  * Name      : NET_API_STATUS NetUserModalsGet
    2640  * Purpose   :
    2641  * Parameters: LPWSTR servername
    2642  *             DWORD level
    2643  *             LPBYTE *bufptr
    2644  * Variables :
    2645  * Result    :
    2646  * Remark    :
    2647  * Status    : UNTESTED STUB
    2648  *
    2649  * Stub Generated through PE2LX Stubwizard 0.02 from Markus Montkowski
    2650  *
    2651  * Author    : Markus Montkowski [09.07.98 22:10:22]
    2652  *****************************************************************************/
    2653 ODINFUNCTION3(NET_API_STATUS, OS2NetUserModalsGet,
    2654               LPWSTR, servername,
    2655               DWORD, level,
    2656               LPBYTE *, bufptr)
    2657 
    2658 {
    2659 
    2660   dprintf(("NETAPI32: NetUserModalsGet(%08x, %d, %08x) not implemented\n"
    2661            ,servername, level, *bufptr
    2662          ));
    2663 
    2664   return (NERR_BASE);
    2665 }
    2666 
    2667 /*****************************************************************************
    2668  * Name      : NET_API_STATUS NetUserModalsSet
    2669  * Purpose   :
    2670  * Parameters: LPWSTR servername
    2671  *             DWORD level
    2672  *             LPBYTE buf
    2673  *             LPDWORD parm_err
    2674  * Variables :
    2675  * Result    :
    2676  * Remark    :
    2677  * Status    : UNTESTED STUB
    2678  *
    2679  * Stub Generated through PE2LX Stubwizard 0.02 from Markus Montkowski
    2680  *
    2681  * Author    : Markus Montkowski [09.07.98 22:10:31]
    2682  *****************************************************************************/
    2683 ODINFUNCTION4(NET_API_STATUS, OS2NetUserModalsSet,
    2684               LPWSTR, servername,
    2685               DWORD, level,
    2686               LPBYTE, buf,
    2687               LPDWORD, parm_err)
    2688 
    2689 {
    2690 
    2691   dprintf(("NETAPI32: NetUserModalsSet(%08x, %d, %08x, %08x) not implemented\n"
    2692            ,servername, level, buf, parm_err
    2693          ));
    2694 
    2695   return (NERR_BASE);
    2696 }
    2697 
    2698 /*****************************************************************************
    2699  * Name      : NET_API_STATUS NetUserSetGroups
    2700  * Purpose   :
    2701  * Parameters: LPWSTR servername
    2702  *             LPWSTR username
    2703  *             DWORD level
    2704  *             LPBYTE buf
    2705  *             DWORD num_entries
    2706  * Variables :
    2707  * Result    :
    2708  * Remark    :
    2709  * Status    : UNTESTED STUB
    2710  *
    2711  * Stub Generated through PE2LX Stubwizard 0.02 from Markus Montkowski
    2712  *
    2713  * Author    : Markus Montkowski [09.07.98 22:10:44]
    2714  *****************************************************************************/
    2715 ODINFUNCTION5(NET_API_STATUS, OS2NetUserSetGroups,
    2716               LPWSTR, servername,
    2717               LPWSTR, username,
    2718               DWORD, level,
    2719               LPBYTE, buf,
    2720               DWORD, num_entries)
    2721 
    2722 {
    2723 
    2724   dprintf(("NETAPI32: NetUserSetGroups(%08x, %08x, %d, %08x, %d) not implemented\n"
    2725            ,servername, username, level, buf, num_entries
    2726          ));
    2727 
    2728   return (NERR_BASE);
    2729 }
    2730 
    2731 /*****************************************************************************
    2732  * Name      : NET_API_STATUS NetUserSetInfo
    2733  * Purpose   :
    2734  * Parameters: LPWSTR servername
    2735  *             LPWSTR username
    2736  *             DWORD level
    2737  *             LPBYTE buf
    2738  *             LPDWORD parm_err
    2739  * Variables :
    2740  * Result    :
    2741  * Remark    :
    2742  * Status    : UNTESTED STUB
    2743  *
    2744  * Stub Generated through PE2LX Stubwizard 0.02 from Markus Montkowski
    2745  *
    2746  * Author    : Markus Montkowski [09.07.98 22:11:04]
    2747  *****************************************************************************/
    2748 ODINFUNCTION5(NET_API_STATUS, OS2NetUserSetInfo,
    2749               LPWSTR, servername,
    2750               LPWSTR, username,
    2751               DWORD, level,
    2752               LPBYTE, buf,
    2753               LPDWORD, parm_err)
    2754 
    2755 {
    2756 
    2757   dprintf(("NETAPI32: NetUserSetInfo(%08x, %08x, %d, %08x, %08x) not implemented\n"
    2758            ,servername, username, level, buf, parm_err
    2759          ));
    2760 
    2761   return (NERR_BASE);
    2762 }
    2763 
    2764 /*****************************************************************************
    2765  * Name      : NET_API_STATUS NetWkstaGetInfo
    2766  * Purpose   :
    2767  * Parameters: LPWSTR servername
    2768  *             DWORD level
    2769  *             LPBYTE *bufptr
    2770  * Variables :
    2771  * Result    :
    2772  * Remark    : NT understands modes 100, 101, 102, 302, 402, and 502
    2773  *             The APIs allocate the buffer dynamically.
    2774  * Status    : UNTESTED STUB
    2775  *
    2776  * Stub Generated through PE2LX Stubwizard 0.02 from Markus Montkowski
    2777  *
    2778  * Author    : Markus Montkowski [09.07.98 22:11:21]
    2779  *****************************************************************************/
    2780 ODINFUNCTION3(NET_API_STATUS, OS2NetWkstaGetInfo,
    2781               LPWSTR, servername,
    2782               DWORD, level,
    2783               LPBYTE *, bufptr)
    2784 
    2785 {
    2786   dprintf(("NETAPI32: NetWkstaGetInfo(%s, %d, %08x)\n"
    2787            ,servername, level, *bufptr
    2788          ));
    2789  
    2790   // Convert servername to ASCII
    2791   char *asciiServername = NULL;
    2792   if (servername) asciiServername = UnicodeToAsciiString(servername);
    2793  
    2794   // @@@PH convert information modes!
    2795   int iOS2Level = 100;
    2796   switch (level)
    2797   {
    2798     case 100: iOS2Level = 10; break;
    2799     case 101: iOS2Level = 1; break;
    2800     case 102: iOS2Level = 1; break;
    2801     case 302: iOS2Level = 1; break;
    2802     case 402: iOS2Level = 1; break;
    2803     case 502: iOS2Level = 1; break;
    2804   }
    2805  
    2806   ULONG  ulBytesAvailable;
    2807   DWORD  rc;
    2808  
    2809   // determine required size of buffer
    2810   char pOS2Buffer[4096];
    2811   rc = OSLibNetWkstaGetInfo((const unsigned char*)asciiServername,
    2812                             iOS2Level,
    2813                             (unsigned char*)pOS2Buffer,
    2814                             sizeof(pOS2Buffer),
    2815                             &ulBytesAvailable);
    2816   if (asciiServername) FreeAsciiString(asciiServername);
    2817  
    2818   if (rc == NERR_OK)
    2819   {
    2820     // @@@PH now convert the requested structure to UNICODE
    2821     switch (level)
    2822     {
    2823       case 100: // system information - guest access
    2824       {
    2825         PWKSTA_INFO_100 pwki100;
    2826         struct wksta_info_10 *pOS2wki10 = (struct wksta_info_10 *)pOS2Buffer;
    2827        
    2828         // calculate new size for target buffer
    2829         int iSizeComputername = (lstrlenA((LPCSTR)pOS2wki10->wki10_computername) + 1) * 2;
    2830         int iSizeLangroup = (lstrlenA((LPCSTR)pOS2wki10->wki10_langroup) + 1) * 2;
    2831         int iSize = sizeof(WKSTA_INFO_100) + iSizeComputername + iSizeLangroup;
    2832 
    2833         rc = OS2NetApiBufferAllocate(iSize, (LPVOID*)&pwki100);
    2834         if (!rc)
    2835         {
    2836           // pointer to the data area
    2837           PBYTE pData = (PBYTE)pwki100 + sizeof(WKSTA_INFO_100);
    2838          
    2839           pwki100->wki100_platform_id = 0; //@@@PH dummy
    2840           pwki100->wki100_computername = lstrcpyAtoW( (LPWSTR)pData, (LPCSTR)pOS2wki10->wki10_computername);
    2841           pData += iSizeComputername;
    2842           pwki100->wki100_langroup = lstrcpyAtoW( (LPWSTR)pData, (LPCSTR)pOS2wki10->wki10_langroup);
    2843           pData += iSizeLangroup;
    2844           pwki100->wki100_ver_major = pOS2wki10->wki10_ver_major;
    2845           pwki100->wki100_ver_minor = pOS2wki10->wki10_ver_minor;
    2846         }
    2847 
    2848         // the caller is responsible for freeing the memory!
    2849         *bufptr = (LPBYTE)pwki100;
    2850         break;
    2851       }
    2852      
    2853      
    2854       case 101: // system information - guest access
    2855       {
    2856         PWKSTA_INFO_101 pwki101;
    2857         struct wksta_info_1 *pOS2wki1 = (struct wksta_info_1 *)pOS2Buffer;
    2858        
    2859         // calculate new size for target buffer
    2860         int iSizeComputername = (lstrlenA((LPCSTR)pOS2wki1->wki1_computername) + 1) * 2;
    2861         int iSizeLangroup = (lstrlenA((LPCSTR)pOS2wki1->wki1_langroup) + 1) * 2;
    2862         int iSizeLanroot  = (lstrlenA((LPCSTR)pOS2wki1->wki1_root) + 1) * 2;
    2863         int iSize = sizeof(WKSTA_INFO_101) + iSizeComputername + iSizeLangroup + iSizeLanroot;
    2864 
    2865         rc = OS2NetApiBufferAllocate(iSize, (LPVOID*)&pwki101);
    2866         if (!rc)
    2867         {
    2868           // pointer to the data area
    2869           PBYTE pData = (PBYTE)pwki101 + sizeof(WKSTA_INFO_101);
    2870        
    2871           pwki101->wki101_platform_id = 0; //@@@PH dummy
    2872           pwki101->wki101_computername = lstrcpyAtoW( (LPWSTR)pData, (LPCSTR)pOS2wki1->wki1_computername);
    2873           pData += iSizeComputername;
    2874           pwki101->wki101_langroup = lstrcpyAtoW( (LPWSTR)pData, (LPCSTR)pOS2wki1->wki1_langroup);
    2875           pData += iSizeLangroup;
    2876           pwki101->wki101_ver_major = pOS2wki1->wki1_ver_major;
    2877           pwki101->wki101_ver_minor = pOS2wki1->wki1_ver_minor;
    2878           pwki101->wki101_lanroot = lstrcpyAtoW( (LPWSTR)pData, (LPCSTR)pOS2wki1->wki1_root);
    2879           pData += iSizeLanroot;
    2880         }
    2881 
    2882         // the caller is responsible for freeing the memory!
    2883         *bufptr = (LPBYTE)pwki101;
    2884         break;
    2885       }
    2886      
    2887      
    2888       case 102: // system information - guest access
    2889       {
    2890         PWKSTA_INFO_102 pwki102;
    2891         struct wksta_info_1 *pOS2wki1 = (struct wksta_info_1 *)pOS2Buffer;
    2892        
    2893         // calculate new size for target buffer
    2894         int iSizeComputername = (lstrlenA((LPCSTR)pOS2wki1->wki1_computername) + 1) * 2;
    2895         int iSizeLangroup = (lstrlenA((LPCSTR)pOS2wki1->wki1_langroup) + 1) * 2;
    2896         int iSizeLanroot  = (lstrlenA((LPCSTR)pOS2wki1->wki1_root) + 1) * 2;
    2897         int iSize = sizeof(WKSTA_INFO_102) + iSizeComputername + iSizeLangroup + iSizeLanroot;
    2898 
    2899         rc = OS2NetApiBufferAllocate(iSize, (LPVOID*)&pwki102);
    2900         if (!rc)
    2901         {
    2902           // pointer to the data area
    2903           PBYTE pData = (PBYTE)pwki102 + sizeof(WKSTA_INFO_102);
    2904        
    2905           pwki102->wki102_platform_id = 0; //@@@PH dummy
    2906           pwki102->wki102_computername = lstrcpyAtoW( (LPWSTR)pData, (LPCSTR)pOS2wki1->wki1_computername);
    2907           pData += iSizeComputername;
    2908           pwki102->wki102_langroup = lstrcpyAtoW( (LPWSTR)pData, (LPCSTR)pOS2wki1->wki1_langroup);
    2909           pData += iSizeLangroup;
    2910           pwki102->wki102_ver_major = pOS2wki1->wki1_ver_major;
    2911           pwki102->wki102_ver_minor = pOS2wki1->wki1_ver_minor;
    2912           pwki102->wki102_lanroot = lstrcpyAtoW( (LPWSTR)pData, (LPCSTR)pOS2wki1->wki1_root);
    2913           pData += iSizeLanroot;
    2914           pwki102->wki102_logged_on_users = 0; // @@@PH dummy
    2915         }
    2916 
    2917         // the caller is responsible for freeing the memory!
    2918         *bufptr = (LPBYTE)pwki102;
    2919         break;
    2920       }
    2921      
    2922      
    2923       case 502: // system information - guest access
    2924       {
    2925         PWKSTA_INFO_502 pwki502;
    2926         struct wksta_info_1 *pOS2wki1 = (struct wksta_info_1 *)pOS2Buffer;
    2927        
    2928         rc = OS2NetApiBufferAllocate(sizeof(WKSTA_INFO_502), (LPVOID*)&pwki502);;
    2929         if (!rc)
    2930         {
    2931           char *hs = (char *)pOS2wki1->wki1_wrkheuristics;
    2932          
    2933           pwki502->wki502_char_wait = pOS2wki1->wki1_charwait;
    2934           pwki502->wki502_collection_time = pOS2wki1->wki1_chartime;
    2935           pwki502->wki502_maximum_collection_count = pOS2wki1->wki1_charcount;
    2936           pwki502->wki502_keep_conn = pOS2wki1->wki1_keepconn;
    2937           pwki502->wki502_max_cmds = pOS2wki1->wki1_maxcmds;
    2938           pwki502->wki502_sess_timeout = pOS2wki1->wki1_sesstimeout;
    2939           pwki502->wki502_siz_char_buf = pOS2wki1->wki1_sizcharbuf;
    2940           pwki502->wki502_max_threads = pOS2wki1->wki1_maxthreads;
    2941          
    2942           pwki502->wki502_lock_quota = 0;
    2943           pwki502->wki502_lock_increment = 0;
    2944           pwki502->wki502_lock_maximum = 0;
    2945           pwki502->wki502_pipe_increment = 0;
    2946           pwki502->wki502_pipe_maximum = 0;
    2947           pwki502->wki502_cache_file_timeout = 0;
    2948           pwki502->wki502_dormant_file_limit = 0;
    2949           pwki502->wki502_read_ahead_throughput = 0;
    2950          
    2951           pwki502->wki502_num_mailslot_buffers = pOS2wki1->wki1_mailslots;
    2952           pwki502->wki502_num_srv_announce_buffers = pOS2wki1->wki1_numdgrambuf;
    2953           pwki502->wki502_max_illegal_datagram_events = 0;
    2954           pwki502->wki502_illegal_datagram_event_reset_frequency = 0;
    2955           pwki502->wki502_log_election_packets = FALSE;
    2956          
    2957           pwki502->wki502_use_opportunistic_locking = (hs[0] != '0') ? TRUE : FALSE;
    2958           pwki502->wki502_use_unlock_behind = (hs[1] != '0') ? TRUE : FALSE;
    2959           pwki502->wki502_use_close_behind = (hs[2] != '0') ? TRUE : FALSE;
    2960           pwki502->wki502_buf_named_pipes = (hs[3] != '0') ? TRUE : FALSE;
    2961           pwki502->wki502_use_lock_read_unlock = (hs[4] != '0') ? TRUE : FALSE;
    2962           pwki502->wki502_utilize_nt_caching = TRUE; // sure we do ;-)
    2963           pwki502->wki502_use_raw_read = (hs[12] != '0') ? TRUE : FALSE;
    2964           pwki502->wki502_use_raw_write = (hs[13] != '0') ? TRUE : FALSE;
    2965           pwki502->wki502_use_write_raw_data = (hs[29] != '0') ? TRUE : FALSE;
    2966           pwki502->wki502_use_encryption = (hs[21] != '0') ? TRUE : FALSE;
    2967           pwki502->wki502_buf_files_deny_write = (hs[23] != '0') ? TRUE : FALSE;
    2968           pwki502->wki502_buf_read_only_files = (hs[24] != '0') ? TRUE : FALSE;
    2969           pwki502->wki502_force_core_create_mode = (hs[27] != '0') ? TRUE : FALSE;
    2970           pwki502->wki502_use_512_byte_max_transfer =  FALSE; // @@@PH
    2971         }
    2972        
    2973         // the caller is responsible for freeing the memory!
    2974         *bufptr = (LPBYTE)pwki502;
    2975         break;
    2976       }
    2977     }
    2978   }
    2979  
    2980   // @@@PH convert return code to NT code
    2981   return (rc);
    2982 }
    2983 
    2984 
    2985 /*****************************************************************************
    2986  * Name      : NET_API_STATUS NetWkstaSetInfo
    2987  * Purpose   :
    2988  * Parameters: LPWSTR servername
    2989  *             DWORD level
    2990  *             LPBYTE buffer
    2991  *             LPDWORD parm_err
    2992  * Variables :
    2993  * Result    :
    2994  * Remark    :
    2995  * Status    : UNTESTED STUB
    2996  *
    2997  * Stub Generated through PE2LX Stubwizard 0.02 from Markus Montkowski
    2998  *
    2999  * Author    : Markus Montkowski [09.07.98 22:11:39]
    3000  *****************************************************************************/
    3001 ODINFUNCTION4(NET_API_STATUS, OS2NetWkstaSetInfo,
    3002               LPWSTR, servername,
    3003               DWORD, level,
    3004               LPBYTE, buffer,
    3005               LPDWORD, parm_err)
    3006 
    3007 {
    3008 
    3009   dprintf(("NETAPI32: NetWkstaSetInfo(%s, %d, %08x, %08x) not implemented\n"
    3010            ,servername, level, buffer, parm_err
    3011          ));
    3012 
    3013   return (NERR_BASE);
    3014 }
    3015 
    3016 /*****************************************************************************
    3017  * Name      : NET_API_STATUS NetWkstaTransportAdd
    3018  * Purpose   :
    3019  * Parameters: LPWSTR servername
    3020  *             DWORD level
    3021  *             LPBYTE buf
    3022  * Variables :
    3023  * Result    :
    3024  * Remark    :
    3025  * Status    : UNTESTED STUB
    3026  *
    3027  * Stub Generated through PE2LX Stubwizard 0.02 from Markus Montkowski
    3028  *
    3029  * Author    : Markus Montkowski [09.07.98 22:12:18]
    3030  *****************************************************************************/
    3031 ODINFUNCTION3(NET_API_STATUS, OS2NetWkstaTransportAdd,
    3032               LPWSTR, servername,
    3033               DWORD, level,
    3034               LPBYTE, buf)
    3035 
    3036 {
    3037 
    3038   dprintf(("NETAPI32: NetWkstaTransportAdd(%s, %d, %08x)not implemented\n"
    3039            ,servername, level, buf
    3040          ));
    3041 
    3042   return (NERR_BASE);
    3043 }
    3044 
    3045 /*****************************************************************************
    3046  * Name      : NET_API_STATUS NetWkstaTransportDel
    3047  * Purpose   :
    3048  * Parameters: LPWSTR servername
    3049  *             LPWSTR transportname
    3050  *             DWORD ucond
    3051  * Variables :
    3052  * Result    :
    3053  * Remark    :
    3054  * Status    : UNTESTED STUB
    3055  *
    3056  * Stub Generated through PE2LX Stubwizard 0.02 from Markus Montkowski
    3057  *
    3058  * Author    : Markus Montkowski [09.07.98 22:13:11]
    3059  *****************************************************************************/
    3060 ODINFUNCTION3(NET_API_STATUS, OS2NetWkstaTransportDel,
    3061               LPWSTR, servername,
    3062               LPWSTR, transportname,
    3063               DWORD, ucond)
    3064 
    3065 {
    3066 
    3067   dprintf(("NETAPI32: NetWkstaTransportDel(%08x, %08x, %d) not implemented\n"
    3068            ,servername, transportname, ucond
    3069          ));
    3070 
    3071   return (NERR_BASE);
    3072 }
    3073 
    3074 /*****************************************************************************
    3075  * Name      : NET_API_STATUS NetWkstaTransportEnum
    3076  * Purpose   :
    3077  * Parameters: LPWSTR servername
    3078  *             DWORD level
    3079  *             LPBYTE *bufptr
    3080  *             DWORD prefmaxlen
    3081  *             LPDWORD entriesread
    3082  *             LPDWORD totalentries
    3083  *             LPDWORD resumehandle
    3084  * Variables :
    3085  * Result    :
    3086  * Remark    :
    3087  * Status    : UNTESTED STUB
    3088  *
    3089  * Stub Generated through PE2LX Stubwizard 0.02 from Markus Montkowski
    3090  *
    3091  * Author    : Markus Montkowski [09.07.98 22:13:44]
    3092  *****************************************************************************/
    3093 ODINFUNCTION7(NET_API_STATUS, OS2NetWkstaTransportEnum,
    3094               LPWSTR, servername,
    3095               DWORD, level,
    3096               LPBYTE *, bufptr,
    3097               DWORD, prefmaxlen,
    3098               LPDWORD, entriesread,
    3099               LPDWORD, totalentries,
    3100               LPDWORD, resumehandle)
    3101 
    3102 {
    3103 
    3104   dprintf(("NETAPI32: NetWkstaTransportEnum(%08x, %d, %08x, %d, %08x, %08x, %08x) not implemented\n"
    3105            ,servername, level, *bufptr, prefmaxlen, entriesread, totalentries, resumehandle
    3106          ));
    3107 
    3108   return (NERR_BASE);
    3109 }
    3110 
    3111 /*****************************************************************************
    3112  * Name      : NET_API_STATUS NetWkstaUserEnum
    3113  * Purpose   :
    3114  * Parameters: LPWSTR servername
    3115  *             DWORD level
    3116  *             LPBYTE *bufptr
    3117  *             DWORD prefmaxlen
    3118  *             LPDWORD entriesread
    3119  *             LPDWORD totalentries
    3120  *             LPDWORD resumehandle
    3121  * Variables :
    3122  * Result    :
    3123  * Remark    :
    3124  * Status    : UNTESTED STUB
    3125  *
    3126  * Stub Generated through PE2LX Stubwizard 0.02 from Markus Montkowski
    3127  *
    3128  * Author    : Markus Montkowski [09.07.98 22:14:05]
    3129  *****************************************************************************/
    3130 ODINFUNCTION7(NET_API_STATUS, OS2NetWkstaUserEnum,
    3131               LPWSTR, servername,
    3132               DWORD, level,
    3133               LPBYTE *, bufptr,
    3134               DWORD, prefmaxlen,
    3135               LPDWORD, entriesread,
    3136               LPDWORD, totalentries,
    3137               LPDWORD, resumehandle)
    3138 
    3139 {
    3140 
    3141   dprintf(("NETAPI32: NetWkstaUserEnum(%08x, %d, %08x, %d, %08x, %08x, %08x) not implemented\n"
    3142            ,servername, level, *bufptr, prefmaxlen, entriesread, totalentries, resumehandle
    3143          ));
    3144 
    3145   return (NERR_BASE);
    3146 }
    3147 
    3148 /*****************************************************************************
    3149  * Name      : NET_API_STATUS NetWkstaUserGetInfo
    3150  * Purpose   :
    3151  * Parameters: LPWSTR reserved
    3152  *             DWORD level
    3153  *             LPBYTE *bufptr
    3154  * Variables :
    3155  * Result    :
    3156  * Remark    :
    3157  * Status    : UNTESTED STUB
    3158  *
    3159  * Stub Generated through PE2LX Stubwizard 0.02 from Markus Montkowski
    3160  *
    3161  * Author    : Markus Montkowski [09.07.98 22:14:17]
    3162  *****************************************************************************/
    3163 ODINFUNCTION3(NET_API_STATUS, OS2NetWkstaUserGetInfo,
    3164               LPWSTR, reserved,
    3165               DWORD, level,
    3166               LPBYTE *, bufptr)
    3167 
    3168 {
    3169 
    3170   dprintf(("NETAPI32: NetWkstaUserGetInfo(%08x, %d, %08x) not implemented\n"
    3171            ,reserved, level, *bufptr
    3172          ));
    3173 
    3174   return (NERR_BASE);
    3175 }
    3176 
    3177 /*****************************************************************************
    3178  * Name      : NET_API_STATUS NetWkstaUserSetInfo
    3179  * Purpose   :
    3180  * Parameters: LPWSTR reserved
    3181  *             DWORD level
    3182  *             LPBYTE buf
    3183  *             LPDWORD parm_err
    3184  * Variables :
    3185  * Result    :
    3186  * Remark    :
    3187  * Status    : UNTESTED STUB
    3188  *
    3189  * Stub Generated through PE2LX Stubwizard 0.02 from Markus Montkowski
    3190  *
    3191  * Author    : Markus Montkowski [09.07.98 22:16:08]
    3192  *****************************************************************************/
    3193 ODINFUNCTION4(NET_API_STATUS, OS2NetWkstaUserSetInfo,
    3194               LPWSTR, reserved,
    3195               DWORD, level,
    3196               LPBYTE, buf,
    3197               LPDWORD, parm_err)
    3198 
    3199 {
    3200 
    3201   dprintf(("NETAPI32: NetWkstaUserSetInfo(%08x, %d, %08x, %08x) not implemented\n"
    3202            ,reserved, level, buf, parm_err
    3203          ));
    3204 
    3205   return (NERR_BASE);
    3206 }
    3207 
    3208 
    3209929
    3210930/*****************************************************************************
     
    39861706{
    39871707  dprintf(("NETAPI32: NetFileClose not implemented\n"));
    3988 
    3989   return (NERR_BASE);
    3990 }
    3991 
    3992 
    3993 /*****************************************************************************
    3994  * Name      : NET_API_STATUS NetLocalGroupAddMember
    3995  * Purpose   : gives an existing user account or global group membership in
    3996  *             an existing local group
    3997  * Parameters: LPWSTR  lpServerName
    3998  *             LPWSTR  lpGroupName
    3999  *             PSID    membersid
    4000  * Variables :
    4001  * Result    :
    4002  * Remark    :
    4003  * Status    : UNTESTED STUB
    4004  *
    4005  * Author    : Patrick Haller [Thu, 1999/08/18 00:15]
    4006  *****************************************************************************/
    4007 
    4008 ODINFUNCTION3(NET_API_STATUS,OS2NetLocalGroupAddMember,LPWSTR,  lpServerName,
    4009                                                        LPWSTR,  lpGroupName,
    4010                                                        PSID,    membersid)
    4011 {
    4012   dprintf(("NETAPI32: NetLocalGroupAddMember not implemented\n"));
    40131708
    40141709  return (NERR_BASE);
Note: See TracChangeset for help on using the changeset viewer.