windows-nt/Source/XPSP1/NT/base/mvdm/thunk/nw4fthk.thk

 __foldwin32sstuff __foldwin32sstuff;
 foldstyleinitialization = true;


/*****************************************************************/
/**               Microsoft Windows 4.00                        **/
/**           Copyright (C) Microsoft Corp., 1992-1993          **/
/*****************************************************************/
/*
 * API thunks for Netware 16bit APIs called from Win32 DLL
 */

enablemapdirect3216 = true;
flatthunks = true;

#include "types.thk"

/*
 * Locale APIs
 *
 * nwlocale.h & nwlocale.lib
 */

LPVOID  ThkNWLlocaleconv( LPVOID lconvPtr);

UINT ThkNWInitUnicodeTables(int countryCode, int codePage);

UINT ThkNWFreeUnicodeTables() ;


/*
 * Misc. APIs
 *
 */

/*
WORD    ThkNWWordSwap(WORD swapWord);

DWORD ThkNWLongSwap(DWORD swapLong);
*/


UINT   ThkNWGetRequesterVersion(LPBYTE majorVersion,LPBYTE minorVersion,LPBYTE revision)
{
   majorVersion=output;
   minorVersion=output;
   revision    =output;
}

/*
 * Directory services APIs
 *
 * nwds*.h & nwcalls.lib
 *
 */

ULONG ThkNWDSCreateContext();

DWORD ThkNWDSFreeContext(ULONG context);

UINT    ThkNWDSGetContext(ULONG context,INT     key, LPVOID lpvalue)
{
        lpvalue = output;
}

UINT ThkNWDSSetContext(ULONG    context,int     key,LPVOID lpvalue)
{
        lpvalue = input;
}

UINT ThkNWDSList(ULONG context,LPSTR object,LPDWORD iterationHandle,DWORD subordinates)
{
        object=input;
        iterationHandle=output;
}


UINT ThkNWDSGetObjectCount(ULONG  context,DWORD  buf,LPDWORD objectCount)
{
        objectCount=output;
}


UINT ThkNWDSGetObjectName(ULONG context,DWORD buf,LPSTR objectName,LPDWORD attrCount,LPVOID objectInfo)
{
        objectName=output;
        objectInfo=output;
}


UINT  ThkNWIsDSAuthenticated();


UINT ThkNWDSAuthenticate(UINT    conn,
                   DWORD   optionsFlag,
                   LPVOID  sessionKey)
{
   sessionKey= output;
}

UINT ThkNWDSLogin(ULONG context,DWORD   optionsFlag,LPSTR       objectName,LPSTR        password,
                                                        DWORD    validityPeriod);


UINT ThkNWDSLogout(ULONG        context);

UINT ThkNWDSAuditGetObjectID(ULONG      context,
                                   LPSTR        objectName,
                                   LPUINT conn,
                                   LPDWORD      objectID)
{
   objectID = output;
}

UINT ThkNWGetPreferredDSServer(LPUINT connID)
{
   connID = output;
}

UINT ThkNWGetNearestDirectoryService(LPUINT connID)
{
   connID = output;
}

UINT ThkNWGetNumConnections(LPWORD numConnections)
{
   numConnections=output;
}

UINT ThkNWFreeConnectionSlot(UINT connID,BYTE  disconnectType);

UINT ThkNWGetNextConnectionID(LPUINT connID)
{
   connID = output;
}

UINT ThkNWSetPreferredDSTree(WORD length,LPSTR treeName)
{
   treeName = output;
}

UINT ThkNWSetDefaultNameContext(WORD contextLength,LPSTR context);

UINT ThkNWGetDefaultNameContext(WORD bufferSize,LPSTR context)
{
   context = output;
}

UINT  ThkNWGetPreferredConnName(LPSTR preferredName,LPBYTE preferredType)
{
   preferredName = output;
   preferredType = output;
}


UINT    ThkNWDSAbbreviateName(ULONG context,LPSTR       inName,LPSTR    abbreviatedName)
{
      abbreviatedName=output;
}

UINT    ThkNWDSCanonicalizeName(ULONG   context,LPSTR   objectName,LPSTR        canonName)
{
      canonName=output;
}


UINT    ThkNWDSRemoveAllTypes(ULONG     context,LPSTR   name,LPSTR      typelessName)
{
         typelessName=output;
}


UINT ThkNWDSAllocBuf(UINT       size,LPDWORD buf)
{
        buf=output;
}

UINT ThkNWDSFreeBuf(DWORD buf);

/*
 * Bindery APIs
 *
 * nwcalls.lib , nwmisc.h, nwbindry.h
 *
 */


UINT ThkNWCallsInit(DWORD in, DWORD out);

UINT ThkNWGetDefaultConnectionID(LPWORD lpconn)
{
        lpconn=output;
}

UINT  ThkNWVerifyObjectPassword(
  UINT conn,
  LPSTR objectName,
  WORD objectType,
  LPSTR password);

UINT  ThkNWDisallowObjectPassword(
  UINT conn,
  LPSTR objectName,
  WORD objectType,
  LPSTR disallowedPassword);


UINT  ThkNWChangeObjectPassword(
  UINT conn,
  LPSTR objectName,
  WORD objectType,
  LPSTR oldPassword,
  LPSTR newPassword)
{
      newPassword=output;
}


UINT  ThkNWWritePropertyValue(
  UINT conn,
  LPSTR objectName,
  WORD objectType,
  LPSTR propertyName,
  BYTE segmentNumber,
  LPBYTE segmentData,
  BYTE moreSegments);

UINT  ThkNWAddObjectToSet(
  UINT conn,
  LPSTR objectName,
  WORD objectType,
  LPSTR propertyName,
  LPSTR memberName,
  WORD memberType);

UINT  ThkNWDeleteObjectFromSet(
  UINT conn,
  LPSTR objectName,
  WORD objectType,
  LPSTR propertyName,
  LPSTR memberName,
  WORD memberType);

UINT  ThkNWIsObjectInSet(
  UINT conn,
  LPSTR objectName,
  WORD objectType,
  LPSTR propertyName,
  LPSTR memberName,
  WORD memberType);

UINT  ThkNWGetObjectDiskSpaceLeft(
  UINT conn,
  DWORD objectID,
  LPDWORD systemElapsedTime,
  LPDWORD unusedDiskBlocks,
  LPBYTE restrictionEnforced)
{
   systemElapsedTime=output;
   unusedDiskBlocks=output;
   restrictionEnforced=output;
}

UINT  ThkNWGetBinderyAccessLevel(
  UINT conn,
  LPBYTE accessLevel,
  LPDWORD objectID)
{
   accessLevel=output;
   objectID=inout;
}


UINT  ThkNWCreateProperty(
  UINT conn,
  LPSTR objectName,
  WORD objectType,
  LPSTR propertyName,
  BYTE propertyFlags,
  BYTE propertySecurity);

UINT  ThkNWDeleteProperty(
  UINT conn,
  LPSTR objectName,
  WORD objectType,
  LPSTR propertyName);

UINT  ThkNWChangePropertySecurity(
  UINT conn,
  LPSTR objectName,
  WORD objectType,
  LPSTR propertyName,
  BYTE newPropertySecurity)
{
}

UINT  ThkNWCreateObject(
  UINT conn,
  LPSTR objectName,
  WORD objectType,
  BYTE objectFlags,
  BYTE objectSecurity)
{
}


UINT  ThkNWDeleteObject(
  UINT conn,
  LPSTR objectName,
  WORD objectType)
{
}


UINT  ThkNWRenameObject(
  UINT conn,
  LPSTR oldObjectName,
  LPSTR newObjectName,
  WORD objectType)
{
}


UINT  ThkNWChangeObjectSecurity(
  UINT conn,
  LPSTR objectName,
  WORD objectType,
  BYTE newObjectSecurity)
{
}


UINT  ThkNWOpenBindery(UINT conn)
{
}

UINT  ThkNWCloseBindery(UINT conn)
{
}


UINT  ThkNWScanObjectTrusteePaths(
  UINT conn,
  DWORD objectID,
  WORD volNumber,
  LPWORD sequenceNumber,
  LPBYTE accessRights,
  LPSTR dirPath)
{
   sequenceNumber=inout;
   accessRights=inout;
   dirPath=inout;
}


UINT  ThkNWGetObjectEffectiveRights(
  UINT conn,
  DWORD objectID,
  BYTE  dirHandle,
  LPSTR  path,
  LPWORD rightsMask)
{
   path=output;
   rightsMask=output;
}


UINT  ThkNWScanObject(WORD conn,LPSTR searchName,
                   WORD searchType,LPDWORD objectID,
                   LPSTR objectName,LPWORD objectType,
                   LPBYTE  hasPropertiesFlag,
                   LPBYTE  objectFlags,
                   LPBYTE  objectSecurity)
{
   searchName = input;

   objectID = inout;

   objectName = output;
   objectType = output;
   hasPropertiesFlag  = output;
   objectFlags        = output;
   objectSecurity     = output;
}


UINT  ThkNWScanProperty(WORD conn,
                         LPSTR objectName,
                         WORD objectType,
                         LPSTR searchPropertyName,
                         LPDWORD  sequenceNumber,
                         LPSTR  propertyName,
                         LPBYTE propertyFlags,
                         LPBYTE propertySecurity,
                         LPBYTE hasValueFlag,
                         LPBYTE moreFlag)
{
   objectName = input;
   searchPropertyName=input;

   sequenceNumber=inout;

   propertyName  = output;
   propertyFlags = output;
   propertySecurity = output;
   hasValueFlag = output;
   moreFlag=output;
}

UINT ThkNWReadPropertyValue(
                        WORD  conn,
                        LPSTR objectName,
                        WORD objectType,
                        LPSTR  propertyName,
                        BYTE   segmentNumber,
                        LPBYTE segmentData,
                        LPBYTE moreSegments,
                        LPBYTE flags)
{

   objectName = input;
   propertyName = input;


   segmentData  = output;
   moreSegments = output;
   flags        = output;
}


UINT ThkNWGetObjectName(
                      WORD  conn,
                      DWORD     objectID,
                      LPSTR     objectName,
                      LPWORD    objectType)
{
   objectName = output;
   objectType = output;
}

UINT  ThkNWGetObjectID(UINT     conn,LPSTR objectName,WORD      objectType,LPDWORD objectID)
{
      objectName=input;
      objectID=output;
}


/*
 * Connection management
 *
 *
 */

UINT  ThkNWGetConnInfo(UINT conn, WORD type, LPVOID data)
{
   data=output;
}


UINT  ThkNWLockConnection(UINT conn);

UINT  ThkNWGetConnectionUsageStats(
  UINT  conn,
  UINT  connNumber,
  LPVOID statusBuffer)
{
   statusBuffer = output;
}


UINT  ThkNWGetConnectionInformation(
  UINT conn,
  UINT connNumber,
  LPSTR objectName,
  LPWORD  objectType,
  LPDWORD objectID,
  LPBYTE  loginTime)
{
   objectName = output;
   objectType = output;
   objectID = output;
   loginTime = output;

}

UINT ThkNWGetConnectionIDFromName(DWORD nameLen,
                                 LPBYTE name,
                                 UINT *conn)
{ name = input;
  conn = output;
}

UINT  ThkNWGetInternetAddress(
  UINT conn,
  UINT connNumber,
  LPBYTE internetAddress)
{
         internetAddress=output;
}

VOID  ThkNWGetMaximumConnections(LPWORD maxConnections)
{
   maxConnections=output;
}


UINT  ThkNWGetConnectionList(
  WORD mode,
  LPUINT connListBuffer,
  WORD connListSize,
  LPWORD numConnections)
{
   connListBuffer=output;
   numConnections=output;
}


UINT  ThkNWGetConnectionStatus(
  UINT conn,
  LPVOID        connInfo,
  WORD connInfoSize)
{
   connInfo=output;
}


UINT  ThkNWGetConnectionNumber(
  UINT conn,
  LPUINT connNumber)
{
   connNumber=output;
}


UINT  ThkNWClearConnectionNumber(
  UINT conn,
  UINT connNumber);

UINT  ThkNWGetConnectionHandle(
  LPBYTE serverName,
  WORD mode,
  LPUINT conn,
  LPWORD connScope)
{
   conn=output;
   connScope=output;
}


UINT  ThkNWSetPrimaryConnectionID(UINT conn);

UINT  ThkNWGetPrimaryConnectionID(LPUINT conn)
{
   conn=output;
}


UINT  ThkNWGetObjectConnectionNumbers(
  UINT conn,
  LPSTR objectName,
  WORD objectType,
  LPWORD numConnections,
  LPUINT connList,
  WORD maxConnections)
{
   numConnections=output;
   connList=output;
}


UINT  ThkNWGetConnListFromObject(
  UINT conn,
  DWORD objectID,
  DWORD searchConnNum,
  LPWORD  connListLen,
  LPDWORD connList
)
{
   connListLen=output;
   connList=output;
}


UINT  ThkNWIsIDInUse(UINT conn);

UINT  ThkNWGetPreferredServer(LPUINT conn)
{
   conn=output;
}

UINT  ThkNWSetPreferredServer(UINT conn)
{
}


/*
 * File server operations
 *
 * nwserver.h
 *
 */



UINT  ThkNWAttachToFileServer(
  LPSTR serverName,
  WORD scopeFlag,
  LPUINT newConnID)
{
   newConnID = output;
}


UINT  ThkNWGetFileServerLoginStatus(
  UINT          conn,
  LPBYTE        loginEnabledFlag)
{
   loginEnabledFlag=output;
}


UINT  ThkNWDetachFromFileServer(UINT conn);

UINT  ThkNWGetFileServerName(UINT conn, LPSTR serverName);

UINT  ThkNWLogoutFromFileServer(UINT conn);

UINT  ThkNWLoginToFileServer(
  UINT conn,
  LPSTR objectName,
  WORD objectType,
  LPSTR password);


UINT  ThkNWEnableFileServerLogin(UINT conn);

UINT  ThkNWDisableFileServerLogin(UINT conn);

UINT  ThkNWGetFileServerDescription(
  UINT conn,
  LPSTR companyName,
  LPSTR revision,
  LPSTR revisionDate,
  LPSTR copyrightNotice)
{

   companyName=output;
   revision=output;
   revisionDate=output;
   copyrightNotice=output;

}


UINT  ThkNWGetFileServerVersion(
  UINT conn,
  LPWORD serverVersion)
{
   serverVersion=output;
}


UINT  ThkNWAttachToFileServerByConn(
  UINT conn,
  LPSTR serverName,
  WORD scopeFlag,
  LPUINT newConnID)
{
   newConnID=output;
}


UINT ThkNWGetVolumeName(UINT conn,WORD volNum,LPSTR volName)
{
   volName=output;
}

UINT ThkNWParsePath(LPSTR  path,
                                                  LPSTR serverName,
                                                  LPUINT conn,
                                                  LPSTR volName,
                                                  LPSTR dirPath)
{
   serverName=output;
   conn=output;
   volName=output;
   dirPath=output;
}


UINT ThkNWGetDriveStatus(
            UINT     driveNumber,
            WORD    pathFormat,
            LPWORD  status,
            LPUINT  conn,
            LPSTR   rootPath,
            LPSTR   relativePath,
            LPSTR   fullPath)
{
   status = output;
   conn = output;
   rootPath = output;
   relativePath= output;
   fullPath= output;
}

UINT ThkNWSetDriveBase(
  UINT   driveNumber,
  UINT   conn,
  BYTE   dirHandle,
  LPSTR  dirPath,
  WORD driveScope)
{
}

UINT   ThkNWDeleteDriveBase(
  UINT   driveNumber,
  WORD driveScope)
{
}

UINT ThkNWConvertHandle(UINT   conn,
                              BYTE   accessMode,
                              LPBYTE NetWareHandle,
                              WORD   handleSize,
                              DWORD  fileSize,
                              LPWORD fileHandle)
{
  NetWareHandle = input;
  fileHandle = output;
}

/*
*
* Queue Management Services
*
*/
UINT ThkNWAbortServicingQueueJob(UINT  conn,
                                        DWORD queueID,
                                        DWORD jobNumber,
                                        UINT  fileHandle);

UINT ThkNWChangeQueueJobEntry2(UINT conn,DWORD queueID,LPBYTE job);

UINT ThkNWCloseFileAndStartQueueJob2(UINT conn,
                                           DWORD queueID,
                                           DWORD jobNumber,
                                           UINT fileHandle);

UINT ThkNWCreateQueueFile2(UINT conn,
                                 DWORD queueID,
                                 LPBYTE job,
                                 UINT *fileHandle);


UINT ThkNWGetQueueJobFileSize2(
  UINT conn,
  DWORD queueID,
  WORD jobNumber,
  LPDWORD fileSize)
{
  fileSize = output;
}


UINT ThkNWGetQueueJobList2(
  UINT conn,
  DWORD queueID,
  DWORD queueStartPosition,
  LPBYTE job)
{
}

UINT ThkNWReadQueueCurrentStatus2(
  UINT conn,
  DWORD queueID,
  LPBYTE queueStatus,
  LPWORD numberOfJobs,
  LPWORD numberOfServers,
  LPDWORD serverIDlist,
  LPWORD  serverConnList)
{
}

UINT ThkNWReadQueueJobEntry2(
  UINT conn,
  DWORD queueID,
  WORD jobNumber,
  LPBYTE job)
{
  job=output;
}

UINT ThkNWRemoveJobFromQueue2(
  UINT conn,
  DWORD queueID,
  WORD jobNumber);

UINT ThkNWSetQueueCurrentStatus2(
  UINT conn,
  DWORD queueID,
  DWORD queueStatus);

/*
*
* Printer Services
*
*/
UINT ThkNWGetCaptureFlags(BYTE LPTDevice,
                                LPBYTE captureFlagsRW,
                                LPBYTE captureFlagsRO)
{
  captureFlagsRW=output;
  captureFlagsRO=output;
}


UINT ThkNWGetPrinterDefaults(LPBYTE status,
                                   LPBYTE flags,
                                   LPBYTE tabSize,
                                   LPBYTE serverPrinter,
                                   LPBYTE numberCopies,
                                   LPBYTE formType,
                                   LPSTR  bannerText,
                                   LPBYTE localLPTDevice,
                                   LPWORD captureTimeOutCount,
                                   LPBYTE captureOnDeviceClose)
{
  flags=output;
  tabSize=output;
  serverPrinter=output;
  numberCopies=output;
  formType=output;
  bannerText=output;
  localLPTDevice=output;
  captureTimeOutCount=output;
  captureOnDeviceClose=output;
}



UINT ThkNWStartQueueCapture(UINT                conn,
                           BYTE                 LPTDevice,
                           DWORD        queueID,
                           LPSTR                queueName);

UINT ThkNWGetCaptureStatus(BYTE LPTDevice);

UINT ThkNWFlushCapture(BYTE LPTDevice);

UINT ThkNWEndCapture(BYTE LPTDevice);

UINT ThkNWCancelCapture(BYTE LPTDevice);


/*
 * Print server management APIs
 */


UINT   ThkNWPSComAttachToPrintServer(
                                                                        WORD  connType,
                                                                        DWORD connID,
                                                                        WORD  timeOut,
                                                                        LPSTR   pServerName,
                                                                        LPWORD spxID)
{
   pServerName=input;
   spxID=output;
}


UINT   ThkNWPSComLoginToPrintServer(
                                                                        WORD  connType,
                                                                        DWORD connID,
                                                                        WORD  spxID,
                                                                        LPBYTE accessLevel);

UINT   ThkNWPSComDetachFromPrintServer(WORD  spxID);


UINT   ThkNWPSComGetPrinterStatus(
                                                                        WORD  spxID,
                                                                        WORD  printerID,
                                                                        LPBYTE status,
                                                                        LPBYTE troubleCode,
                                                                        LPBYTE active,
                                                                        LPBYTE serviceMode,
                                                                        LPWORD formNumber,
                                                                        LPSTR  formName,
                                                                        LPSTR  printerName)
{
   status=output;
   troubleCode=output;
   active=output;
   serviceMode=output;
   formNumber=output;
   formName=output;
   printerName=output;
}

UINT   ThkNWPSComGetNextRemotePrinter(
                                                                        WORD  spxID,
                                                                        LPWORD  printerID,
                                                                        LPWORD  printerType,
                                                                        LPSTR   printerName)
{
   printerID=output;
   printerType=output;
   printerName=output;
}


UINT   ThkNWPSComGetQueuesServiced(
                                                                        WORD    spxID,
                                                                        WORD    printerID,
                                                                        LPWORD  sequence,
                                                                        LPSTR   nServerName,
                                                                        LPSTR   queueName,
                                                                        LPWORD  priority)=
UINT   ThkNWPSComGetQueuesServiced(
                                                                        WORD    spxID,
                                                                        WORD    printerID,
                                                                        LPWORD  sequence,
                                                                        LPSTR   nServerName,
                                                                        LPSTR   queueName,
                                                                        LPWORD  priority)
{
   sequence=output;
   nServerName=output;
   queueName=output;
   priority=output;
}