Context Navigation

source: rxprtutl/trunk/rxprtutl.c@ 5

Last change on this file since 5 was 5, checked in by Alex Taylor, 12 years ago
Added RPUPrinterCreate function. Renamed several other functions for improved consistency.
File size: 72.6 KB

Rev	Line
[3]	1	/******************************************************************************
	2	* REXX OS/2 Printer Utility API (RXPRTUTL.DLL) *
	3	* (C) 2011 Alex Taylor *
	4	* *
	5	* LICENSE: *
	6	* *
	7	* Redistribution and use in source and binary forms, with or without *
	8	* modification, are permitted provided that the following conditions are *
	9	* met: *
	10	* *
	11	* 1. Redistributions of source code must retain the above copyright *
	12	* notice, this list of conditions and the following disclaimer. *
	13	* *
	14	* 2. Redistributions in binary form must reproduce the above copyright *
	15	* notice, this list of conditions and the following disclaimer in the *
	16	* documentation and/or other materials provided with the distribution. *
	17	* *
	18	* 3. The name of the author may not be used to endorse or promote products *
	19	* derived from this software without specific prior written permission. *
	20	* *
	21	* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ''AS IS'' AND ANY EXPRESS OR *
	22	* IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED *
	23	* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE *
	24	* DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, *
	25	* INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES *
	26	* (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR *
	27	* SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) *
	28	* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, *
	29	* STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN *
	30	* ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE *
	31	* POSSIBILITY OF SUCH DAMAGE. *
	32	* *
	33	******************************************************************************/
	34
	35	#define INCL_DEV
	36	#define INCL_DOSERRORS
	37	#define INCL_DOSMISC
	38	#define INCL_DOSMODULEMGR
	39	#define INCL_DOSPROFILE
	40	#define INCL_SPL
	41	#define INCL_SPLDOSPRINT
	42	#define INCL_SPLERRORS
	43	#define INCL_PM
	44	#define INCL_WIN
	45	#define INCL_WINWORKPLACE
	46	#ifndef OS2_INCLUDED
	47	#include <os2.h>
	48	#endif
	49	#include <ctype.h>
	50	#include <stdio.h>
	51	#include <stdlib.h>
	52	#include <string.h>
	53	#define INCL_RXSHV
	54	#define INCL_RXFUNC
	55	#include <rexxsaa.h>
	56
	57
	58	// CONSTANTS
	59
	60	#define SZ_LIBRARY_NAME "RXPRTUTL" // Name of this library
	61	#define SZ_ERROR_NAME "RPUERROR" // REXX variable used to store error codes
[5]	62	#define SZ_VERSION "0.2.0" // Current version of this library
[3]	63
	64	#define APPNAME_LEAD_STR "PM_"
	65	#define APPNAME_PM_PORT_DRIVER "PM_PORT_DRIVER"
	66	#define APPNAME_PM_SPOOLER_PORT "PM_SPOOLER_PORT"
	67	#define APPNAME_PM_PRINT_OBJECT "PM_PrintObject"
	68	#define APPNAME_PM_WPS_LOCATION "PM_Workplace:Location"
	69
	70	// Values that should be defined in pmsplb.h if it actually existed
	71	#define TYPE_LONG_WAIT 2
	72	#define BIDI_SET_PORTDRV 0x19
	73
	74	// Values used by WinOpenObject
	75	#define OPEN_DEFAULT 0
	76	#define OPEN_CONTENTS 1
	77	#define OPEN_SETTINGS 2
	78	#define OPEN_HELP 3
	79	#define OPEN_TREE 101
	80	#define OPEN_DETAILS 102
	81
	82	// Maximum string lengths...
	83	#define US_COMPOUND_MAXZ 250 // ...of a compound variable
	84	#define US_INTEGER_MAXZ 12 // ...of an integer string
	85	#define US_STEM_MAXZ ( US_COMPOUND_MAXZ - US_INTEGER_MAXZ ) // ...of a stem
	86	#define US_ERRSTR_MAXZ 250 // ...of an error string
	87	#define US_DRVINFO_MAXZ ( CCHMAXPATH + 8 + 32 ) // ...of an driver/port info string
	88	#define US_PRTINFO_MAXZ 180 // ...of a printer info string
	89	#define US_PORT_MAXZ 64 // ...of a port name
[5]	90	#define US_SS_MAXZ 256 // ...of a default WPS setup string
[3]	91
	92	// List of functions to be registered by RPULoadFuncs
	93	static PSZ RxFunctionTbl[] = {
	94	"RPUDropFuncs",
[5]	95	"RPUEnumModels",
[3]	96	"RPUEnumDrivers",
	97	"RPUEnumPorts",
	98	"RPUEnumPrinters",
[5]	99	"RPUQueueDefault",
	100	"RPUQueueHold",
	101	"RPUOpenView",
[3]	102	"RPUPortDialog",
	103	"RPUPortInstall",
	104	"RPUPortSet",
[5]	105	"RPUPrinterCreate",
[3]	106	"RPUPrinterQuery",
	107	"RPUVersion"
	108	};
	109
	110
	111	// FUNCTION DECLARATIONS
	112
	113	// Exported REXX functions
	114	RexxFunctionHandler RPULoadFuncs;
	115	RexxFunctionHandler RPUDropFuncs;
	116	RexxFunctionHandler RPUVersion;
[5]	117	RexxFunctionHandler RPUEnumModels;
[3]	118	RexxFunctionHandler RPUEnumDrivers;
	119	RexxFunctionHandler RPUEnumPorts;
	120	RexxFunctionHandler RPUEnumPrinters;
[5]	121	RexxFunctionHandler RPUOpenView;
[3]	122	RexxFunctionHandler RPUPortDialog;
	123	RexxFunctionHandler RPUPortInstall;
	124	RexxFunctionHandler RPUPortSet;
[5]	125	RexxFunctionHandler RPUPrinterCreate;
[3]	126	RexxFunctionHandler RPUPrinterQuery;
[5]	127	RexxFunctionHandler RPUQueueDefault;
	128	RexxFunctionHandler RPUQueueHold;
[3]	129
	130	// TODO
	131	RexxFunctionHandler RPUPortDelete;
	132	// - function to delete a printer (object, device and queue)
	133
	134	// Internal functions
	135	PSZ GetObjectID( PSZ pszHandle );
	136	HOBJECT PrinterObjectHandle( PSZ pszQueueName );
	137	BOOL SaveResultString( PRXSTRING prsResult, PCH pchBytes, ULONG ulBytes );
	138	BOOL WriteCompoundVariable( PSZ pszStem, PSZ pszTail, PSZ pszValue );
	139	BOOL WriteStemElement( PSZ pszStem, ULONG ulIndex, PSZ pszValue );
	140	void WriteErrorCode( ULONG ulError, PSZ pszContext );
	141
	142
	143
	144	/* ************************************************************************* *
	145	* EXPORTED REXX FUNCTIONS *
	146	* ************************************************************************* */
	147
	148	/* ------------------------------------------------------------------------- *
	149	* RPULoadFuncs *
	150	* *
	151	* Register all RPU* REXX functions except this one. *
	152	* *
	153	* REXX ARGUMENTS: None *
	154	* REXX RETURN VALUE: "" *
	155	* ------------------------------------------------------------------------- */
	156	ULONG APIENTRY RPULoadFuncs( PSZ pszName, ULONG argc, RXSTRING argv[], PSZ pszQueue, PRXSTRING prsResult )
	157	{
	158	int entries,
	159	i;
	160
	161	// Reset the error indicator
	162	WriteErrorCode( 0, NULL );
	163
	164	if ( argc > 0 ) return ( 40 );
	165	entries = sizeof(RxFunctionTbl) / sizeof(PSZ);
	166	for ( i = 0; i < entries; i++ )
	167	RexxRegisterFunctionDll( RxFunctionTbl[i], SZ_LIBRARY_NAME, RxFunctionTbl[i] );
	168
	169	MAKERXSTRING( *prsResult, "", 0 );
	170	return ( 0 );
	171	}
	172
	173
	174	/* ------------------------------------------------------------------------- *
	175	* RPUDropFuncs *
	176	* *
	177	* Deregister all RPU* REXX functions, including this one. *
	178	* *
	179	* REXX ARGUMENTS: None *
	180	* REXX RETURN VALUE: "" *
	181	* ------------------------------------------------------------------------- */
	182	ULONG APIENTRY RPUDropFuncs( PSZ pszName, ULONG argc, RXSTRING argv[], PSZ pszQueue, PRXSTRING prsResult )
	183	{
	184	int entries,
	185	i;
	186
	187	// Reset the error indicator
	188	WriteErrorCode( 0, NULL );
	189
	190	if ( argc > 0 ) return ( 40 );
	191	entries = sizeof(RxFunctionTbl) / sizeof(PSZ);
	192	for ( i = 0; i < entries; i++ )
	193	RexxDeregisterFunction( RxFunctionTbl[i] );
	194
	195	MAKERXSTRING( *prsResult, "", 0 );
	196	return ( 0 );
	197	}
	198
	199
	200	/* ------------------------------------------------------------------------- *
	201	* RPUVersion *
	202	* *
	203	* Returns the current library version. *
	204	* *
	205	* REXX ARGUMENTS: None *
	206	* REXX RETURN VALUE: Current version in the form "major.minor.refresh" *
	207	* ------------------------------------------------------------------------- */
	208	ULONG APIENTRY RPUVersion( PSZ pszName, ULONG argc, RXSTRING argv[], PSZ pszQueue, PRXSTRING prsResult )
	209	{
	210	CHAR szVersion[ 12 ];
	211
	212	// Reset the error indicator
	213	WriteErrorCode( 0, NULL );
	214
	215	if ( argc > 0 ) return ( 40 );
	216	sprintf( szVersion, "%s", SZ_VERSION );
	217
	218	MAKERXSTRING( *prsResult, szVersion, strlen(szVersion) );
	219	return ( 0 );
	220	}
	221
	222
	223	/* ------------------------------------------------------------------------- *
[5]	224	* RPUEnumModels *
[3]	225	* *
[5]	226	* Gets a list of the printer models supported by the specified print *
	227	* driver. *
[3]	228	* *
	229	* REXX ARGUMENTS: *
	230	* 1. Filespec of the printer driver to query. (REQUIRED) *
	231	* 2. The name of the stem in which to return the results. (REQUIRED) *
	232	* *
	233	* REXX RETURN VALUE: *
	234	* 1 on success, or 0 if an error occurred. *
	235	* ------------------------------------------------------------------------- */
[5]	236	ULONG APIENTRY RPUEnumModels( PSZ pszName, ULONG argc, RXSTRING argv[], PSZ pszQueue, PRXSTRING prsResult )
[3]	237	{
	238	HAB hab; // desktop anchor-block handle
	239	PSZ pszDriver; // print driver filespec
	240	CHAR szStem[ US_STEM_MAXZ ], // buffers used for building stem
	241	szNumber[ US_INTEGER_MAXZ ]; // ...
	242	BOOL fSuccess; // success indicator
	243	PSTR32 aDeviceName; // array of device names
	244	PSTR64 aDeviceDesc; // array of device descriptions
	245	PSTR16 aDataType; // array of data types
	246	LONG pldn = 0L, // number of device names/descriptions
	247	pldt = 0L, // number of data types
	248	i;
	249
	250
	251	// Reset the error indicator
	252	WriteErrorCode( 0, NULL );
	253
	254	// Make sure we have exactly two valid arguments
	255	if (( argc != 2 ) \|\|
	256	( ! RXVALIDSTRING( argv[0] )) \|\|
	257	( ! RXVALIDSTRING( argv[1] )) \|\|
	258	( RXSTRLEN( argv[1] ) > US_STEM_MAXZ ))
	259	return ( 40 );
	260	pszDriver = argv[0].strptr;
	261
	262	if ( argv[1].strptr[ argv[1].strlength-1 ] == '.') argv[1].strlength--;
	263	strncpy( szStem, argv[1].strptr, RXSTRLEN( argv[1] ));
	264	szStem[ RXSTRLEN( argv[1] ) ] = '\0';
	265
	266	hab = WinInitialize( 0 );
	267	if ( !hab ) {
	268	WriteErrorCode( 0, "WinInitialize");
	269	MAKERXSTRING( *prsResult, "0", 1 );
	270	return ( 0 );
	271	}
	272
	273	// Query the size of the available data
	274	fSuccess = DevQueryDeviceNames( hab, pszDriver, &pldn, NULL, NULL, &pldt, NULL );
	275	if ( !fSuccess ) {
	276	WriteErrorCode( ERRORIDERROR( WinGetLastError( hab )), "DevQueryDeviceNames");
	277	MAKERXSTRING( *prsResult, "0", 1 );
	278	goto cleanup;
	279	}
	280
	281	// Now get the actual data
	282	aDeviceName = malloc( pldn * sizeof( STR32 ));
	283	aDeviceDesc = malloc( pldn * sizeof( STR64 ));
	284	aDataType = malloc( pldt * sizeof( STR16 ));
	285	if ( !aDeviceName \|\| !aDeviceDesc \|\| ! aDataType ) {
	286	WriteErrorCode( ERROR_NOT_ENOUGH_MEMORY, "malloc");
	287	MAKERXSTRING( *prsResult, "0", 1 );
	288	goto cleanup;
	289	}
	290	fSuccess = DevQueryDeviceNames( hab, pszDriver, &pldn, aDeviceName,
	291	aDeviceDesc, &pldt, aDataType );
	292	for ( i = 0; i < pldn; i++ ) {
	293	WriteStemElement( szStem, i+1, (PSZ)aDeviceName[i] );
	294	}
	295	sprintf( szNumber, "%u", pldn );
	296	WriteStemElement( szStem, 0, szNumber );
	297
	298	// Return 1 on success
	299	MAKERXSTRING( *prsResult, "1", 1 );
	300
	301	free( aDeviceName );
	302	free( aDeviceDesc );
	303	free( aDataType );
	304
	305	cleanup:
	306	WinTerminate( hab );
	307	return ( 0 );
	308	}
	309
	310
	311	/* ------------------------------------------------------------------------- *
	312	* RPUEnumPorts *
	313	* *
	314	* Gets a list of the printer ports currently defined on the system. Returns *
	315	* a REXX array (stem) consisting of one string per port, of the form: *
	316	* <port> <driver> <driver path> *
	317	* *
	318	* REXX ARGUMENTS: *
	319	* 1. The name of the stem in which to return the results. (REQUIRED) *
	320	* *
	321	* REXX RETURN VALUE: *
	322	* 1 on success, or 0 if an error occurred. *
	323	* ------------------------------------------------------------------------- */
	324	ULONG APIENTRY RPUEnumPorts( PSZ pszName, ULONG argc, RXSTRING argv[], PSZ pszQueue, PRXSTRING prsResult )
	325	{
	326	PPRPORTINFO1 pInfo;
	327	PVOID pbuf;
	328	ULONG cbBuf,
	329	cTotal,
	330	cReturned,
	331	cbNeeded,
	332	i;
	333	CHAR szStem[ US_STEM_MAXZ ], // buffers used for building stem
	334	szNumber[ US_INTEGER_MAXZ ], // ...
	335	szInfo[ US_DRVINFO_MAXZ ];
	336	SPLERR rc;
	337
	338	// Reset the error indicator
	339	WriteErrorCode( 0, NULL );
	340
	341	// Make sure we have exactly one valid argument (the stem name)
	342	if (( argc != 1 ) \|\| ( ! RXVALIDSTRING( argv[0] )))
	343	return ( 40 );
	344	if ( argv[0].strptr[ argv[0].strlength-1 ] == '.') argv[0].strlength--;
	345	strncpy( szStem, argv[0].strptr, RXSTRLEN( argv[0] ));
	346	szStem[ RXSTRLEN( argv[0] ) ] = '\0';
	347
	348	// Query the amount of available data
	349	rc = SplEnumPort( NULL, 1, NULL, 0L, &cReturned, &cTotal, &cbNeeded, NULL );
	350	if (( rc != ERROR_MORE_DATA ) && ( rc != NERR_BufTooSmall )) {
	351	WriteErrorCode( rc, "SplEnumPort");
	352	MAKERXSTRING( *prsResult, "0", 1 );
	353	return ( 0 );
	354	}
	355
	356	// Now get the actual data
	357	pbuf = malloc( cbNeeded );
	358	if ( !pbuf ) {
	359	WriteErrorCode( ERROR_NOT_ENOUGH_MEMORY, "malloc");
	360	MAKERXSTRING( *prsResult, "0", 1 );
	361	return ( 0 );
	362	}
	363	cbBuf = cbNeeded;
	364	rc = SplEnumPort( NULL, 1, pbuf, cbBuf,
	365	&cReturned, &cTotal, &cbNeeded, NULL );
	366	if ( rc == NO_ERROR ) {
	367	pInfo = (PPRPORTINFO1) pbuf;
	368	for ( i = 0; i < cReturned; i++ ) {
	369	sprintf( szInfo, "%.32s %.8s %s",
	370	pInfo->pszPortName,
	371	pInfo->pszPortDriverName? pInfo->pszPortDriverName: "",
	372	pInfo->pszPortDriverPathName? pInfo->pszPortDriverPathName: "");
	373	WriteStemElement( szStem, i+1, szInfo );
	374	pInfo++;
	375	}
	376	sprintf( szNumber, "%u", cReturned );
	377	WriteStemElement( szStem, 0, szNumber );
	378	MAKERXSTRING( *prsResult, "1", 1 );
	379	}
	380	else {
	381	WriteErrorCode( rc, "SplEnumPort");
	382	MAKERXSTRING( *prsResult, "0", 1 );
	383	}
	384	free( pbuf );
	385
	386	return ( 0 );
	387	}
	388
	389
	390	/* ------------------------------------------------------------------------- *
	391	* RPUEnumDrivers *
	392	* *
	393	* Gets a list of the printer drivers currently installed on the system. *
	394	* Returns a REXX array (stem) with each item being a driver name string. *
	395	* *
	396	* REXX ARGUMENTS: *
	397	* 1. The name of the stem in which to return the results. (REQUIRED) *
	398	* *
	399	* REXX RETURN VALUE: *
	400	* 1 on success, or 0 if an error occurred. *
	401	* ------------------------------------------------------------------------- */
	402	ULONG APIENTRY RPUEnumDrivers( PSZ pszName, ULONG argc, RXSTRING argv[], PSZ pszQueue, PRXSTRING prsResult )
	403	{
	404	PSZ pszDriverName;
	405	PBYTE pbuf;
	406	ULONG cbBuf,
	407	cTotal,
	408	cReturned,
	409	cbNeeded,
	410	i;
	411	CHAR szStem[ US_STEM_MAXZ ], // buffers used for building stem
	412	szNumber[ US_INTEGER_MAXZ ]; // ...
	413	SPLERR rc;
	414
	415
	416	// Reset the error indicator
	417	WriteErrorCode( 0, NULL );
	418
	419	// Make sure we have exactly one valid argument (the stem name)
	420	if (( argc != 1 ) \|\| ( ! RXVALIDSTRING( argv[0] )))
	421	return ( 40 );
	422	if ( argv[0].strptr[ argv[0].strlength-1 ] == '.') argv[0].strlength--;
	423	strncpy( szStem, argv[0].strptr, RXSTRLEN( argv[0] ));
	424	szStem[ RXSTRLEN( argv[0] ) ] = '\0';
	425
	426	// Query the amount of available data
	427	rc = SplEnumDriver( NULL, 0L, NULL, 0L, &cReturned, &cTotal, &cbNeeded, NULL );
	428	if (( rc != ERROR_MORE_DATA ) && ( rc != NERR_BufTooSmall )) {
	429	WriteErrorCode( rc, "SplEnumDriver");
	430	MAKERXSTRING( *prsResult, "0", 1 );
	431	return ( 0 );
	432	}
	433
	434	// Now get the actual data
	435	pbuf = (PBYTE) malloc( cbNeeded );
	436	if ( !pbuf ) {
	437	WriteErrorCode( ERROR_NOT_ENOUGH_MEMORY, "malloc");
	438	MAKERXSTRING( *prsResult, "0", 1 );
	439	return ( 0 );
	440	}
	441	cbBuf = cbNeeded;
	442	rc = SplEnumDriver( NULL, 0L, pbuf, cbBuf, &cReturned ,&cTotal, &cbNeeded, NULL ) ;
	443	if ( rc == NO_ERROR ) {
	444	pszDriverName = (PSZ) pbuf;
	445	for ( i = 0; i < cReturned ; i++ ) {
	446	WriteStemElement( szStem, i+1, pszDriverName );
	447	pszDriverName += DRIV_NAME_SIZE + DRIV_DEVICENAME_SIZE + 2;
	448	}
	449	sprintf( szNumber, "%u", cReturned );
	450	WriteStemElement( szStem, 0, szNumber );
	451	MAKERXSTRING( *prsResult, "1", 1 );
	452	}
	453	else {
	454	WriteErrorCode( rc, "SplEnumDriver");
	455	MAKERXSTRING( *prsResult, "0", 1 );
	456	}
	457	free( pbuf );
	458
	459	return ( 0 );
	460	}
	461
	462
	463	/* ------------------------------------------------------------------------- *
	464	* RPUEnumPrinters *
	465	* *
	466	* Gets a list of the printers currently defined on the system. Returns a *
	467	* compound (stem) variable with the following format: *
	468	* *
	469	* (stem).0 Number of printers *
	470	* (stem).i.!name Printer device (a.k.a. physical) name *
	471	* (stem).i.!queue Printer queue name ('' for direct printers) *
	472	* (stem).i.!host Name of LAN host where printer queue is located *
	473	* ('' for non-LAN printers) *
	474	* (stem).i.!description Printer description (name of WPS object) *
	475	* (stem).i.!handle Printer's object handle ('' for direct printers) *
	476	* (stem).i.!flags Zero or more of the following flags (any order): *
	477	* D This is the default printer queue *
	478	* P Printer queue is paused (held) *
	479	* *
	480	* REXX ARGUMENTS: *
	481	* 1. The name of the stem in which to return the results. (REQUIRED) *
	482	* *
	483	* REXX RETURN VALUE: *
	484	* 1 on success, or 0 if an error occurred. *
	485	* ------------------------------------------------------------------------- */
	486	ULONG APIENTRY RPUEnumPrinters( PSZ pszName, ULONG argc, RXSTRING argv[], PSZ pszQueue, PRXSTRING prsResult )
	487	{
	488	PPRINTERINFO pPInfo = NULL; // pointer to enumerated printer information
	489	PPRQINFO6 pQInfo = NULL; // queue information (level 6)
	490	PVOID pbEnum = NULL, // buffer for SplEnumPrinter
	491	pbQueue = NULL; // buffer for SplQueryQueue
	492	PSZ pszToken;
	493	HOBJECT hObj; // printer WPS object handle
	494	ULONG flType = SPL_PR_QUEUE \| SPL_PR_DIRECT_DEVICE,
	495	cbBuf = 0,
	496	cTotal = 0,
	497	cReturned = 0,
	498	cbNeeded = 0,
	499	ulCount = 0, // number of printers found
	500	i;
	501	CHAR szFlags[ 3 ], // string of flag characters
	502	szHandle[ 9 ], // string for hex object handle
	503	// buffers used for building compound variables:
	504	szStem[ US_STEM_MAXZ - US_INTEGER_MAXZ - 1 ],
	505	szNumber[ US_INTEGER_MAXZ ],
	506	szStemNode[ US_STEM_MAXZ ];
	507	SPLERR rc;
	508
	509
	510	// Reset the error indicator
	511	WriteErrorCode( 0, NULL );
	512
	513	// Make sure we have exactly one valid argument (the stem name)
	514	if (( argc != 1 ) \|\| ( ! RXVALIDSTRING( argv[0] )))
	515	return ( 40 );
	516	if ( argv[0].strptr[ argv[0].strlength-1 ] == '.') argv[0].strlength--;
	517	strncpy( szStem, argv[0].strptr, RXSTRLEN( argv[0] ));
	518	szStem[ RXSTRLEN( argv[0] ) ] = '\0';
	519
	520
	521	/* Our enumeration query asks for two types of devices: direct (non-queued)
	522	* printers, and printer queues.
	523	*
	524	* In the latter case, it's important to note that we ask for the queues
	525	* themselves rather than queued printers. Why? Because we'll need to
	526	* gather information about both printers and their underlying queues (some
	527	* things associated with printer objects actually belong to the queue
	528	* rather than the printer device).
	529	*
	530	* The thing is, given a printer name, there doesn't seem to be an easy way
	531	* to find out the queue associated with it. So we need to do it the other
	532	* way around: get the queue names, then we can identify the printers
	533	* connected to them.
	534	*/
	535
	536	// Query the amount of available data
	537	rc = SplEnumPrinter( NULL, 0L, flType, NULL, 0L,
	538	&cReturned, &cTotal, &cbNeeded, NULL );
	539	if (( rc != ERROR_MORE_DATA ) && ( rc != NERR_BufTooSmall ))
	540	// && ( rc != ERROR_INVALID_PARAMETER ))
	541	{
	542	WriteErrorCode( rc, "SplEnumPrinter");
	543	MAKERXSTRING( *prsResult, "0", 1 );
	544	return ( 0 );
	545	}
	546
	547	// Now get the actual data
	548	pbEnum = malloc( cbNeeded );
	549	if ( !pbEnum ) {
	550	WriteErrorCode( ERROR_NOT_ENOUGH_MEMORY, "malloc");
	551	MAKERXSTRING( *prsResult, "0", 1 );
	552	return ( 0 );
	553	}
	554	cbBuf = cbNeeded;
	555	rc = SplEnumPrinter( NULL, 0L, flType, pbEnum, cbBuf,
	556	&cReturned, &cTotal, &cbNeeded, NULL );
	557	if ( rc != NO_ERROR ) {
	558	WriteErrorCode( rc, "SplEnumPrinter");
	559	MAKERXSTRING( *prsResult, "0", 1 );
	560	goto cleanup;
	561	}
	562
	563	pPInfo = (PPRINTERINFO) pbEnum;
	564	for ( i = 0; i < cReturned; i++ ) {
	565
	566	if ( pPInfo->flType == SPL_PR_DIRECT_DEVICE ) {
	567
	568	/* Direct print device. No queue, no handle; flags do not apply.
	569	* The destination name and description are those of the printer
	570	* device itself, so we don't need any additional queries.
	571	*/
	572	sprintf( szStemNode, "%s.%u", szStem, ++ulCount );
	573
	574	WriteCompoundVariable( szStemNode, "!name",
	575	pPInfo->pszPrintDestinationName );
	576	WriteCompoundVariable( szStemNode, "!description",
	577	pPInfo->pszDescription );
	578	WriteCompoundVariable( szStemNode, "!queue", "");
	579	WriteCompoundVariable( szStemNode, "!flags", "");
	580	WriteCompoundVariable( szStemNode, "!handle", "");
	581
	582	WriteCompoundVariable( szStemNode, "!host",
	583	pPInfo->pszComputerName?
	584	pPInfo->pszComputerName: "");
	585	}
	586	else if ( pPInfo->flType == SPL_PR_QUEUE ) {
	587
	588	/* Print queue. We need to query the queue to find out the details
	589	* of the print device(s) connected to it.
	590	*/
	591	rc = SplQueryQueue( NULL, pPInfo->pszPrintDestinationName,
	592	6L, NULL, 0L, &cbNeeded );
	593	if (( rc != NO_ERROR ) && ( rc != NERR_BufTooSmall )) {
	594	WriteErrorCode( rc, "SplQueryQueue");
	595	MAKERXSTRING( *prsResult, "0", 1 );
	596	goto cleanup;
	597	}
	598	pbQueue = malloc( cbNeeded );
	599	if ( !pbQueue ) {
	600	WriteErrorCode( ERROR_NOT_ENOUGH_MEMORY, "malloc");
	601	MAKERXSTRING( *prsResult, "0", 1 );
	602	goto cleanup;
	603	}
	604	cbBuf = cbNeeded;
	605	rc = SplQueryQueue( NULL, pPInfo->pszPrintDestinationName,
	606	6L, pbQueue, cbBuf, &cbNeeded );
	607	if ( rc != NO_ERROR ) {
	608	WriteErrorCode( rc, "SplQueryQueue");
	609	MAKERXSTRING( *prsResult, "0", 1 );
	610	free( pbQueue );
	611	goto cleanup;
	612	}
	613	pQInfo = (PPRQINFO6) pbQueue;
	614
	615	// Now go through the list of printers connected to this queue...
	616	pszToken = strtok( pQInfo->pszPrinters, ",");
	617	while ( pszToken ) {
	618	sprintf( szStemNode, "%s.%u", szStem, ++ulCount );
	619	WriteCompoundVariable( szStemNode, "!name", pszToken );
	620	WriteCompoundVariable( szStemNode, "!description", pQInfo->pszComment );
	621	WriteCompoundVariable( szStemNode, "!queue", pQInfo->pszName );
	622	WriteCompoundVariable( szStemNode, "!driver", pQInfo->pszDriverName );
	623	WriteCompoundVariable( szStemNode, "!host",
	624	pQInfo->pszRemoteComputerName ?
	625	pQInfo->pszRemoteComputerName: "");
	626
	627	hObj = PrinterObjectHandle( pQInfo->pszName );
	628	if ( hObj )
	629	sprintf( szHandle, "%X", hObj );
	630	else
	631	sprintf( szHandle, "");
	632	WriteCompoundVariable( szStemNode, "!handle", szHandle );
	633
	634	memset( szFlags, 0, sizeof( szFlags ));
	635	if ( pQInfo->fsType & PRQ3_TYPE_APPDEFAULT )
	636	strcat( szFlags, "D");
	637	if ( pQInfo->fsStatus & PRQ3_PAUSED )
	638	strcat( szFlags, "P");
	639	WriteCompoundVariable( szStemNode, "!flags", szFlags );
	640
	641	pszToken = strtok( NULL, ",");
	642	} // while
	643
	644	free( pbQueue );
	645	}
	646
	647	pPInfo++;
	648	}
	649	sprintf( szNumber, "%u", ulCount );
	650	WriteStemElement( szStem, 0, szNumber );
	651	MAKERXSTRING( *prsResult, "1", 1 );
	652
	653	cleanup:
	654	free( pbEnum );
	655	return ( 0 );
	656	}
	657
	658
	659	/* ------------------------------------------------------------------------- *
[5]	660	* RPUOpenView *
[3]	661	* *
	662	* Opens the requested view of the WPS object corresponding to the specified *
	663	* print queue. (Note that WPS printer objects are associated with a queue *
	664	* rather than a printer device, so it is the queue name that must be passed *
	665	* to this function.) *
	666	* *
	667	* REXX ARGUMENTS: *
	668	* 1. The name of the printer queue for the object to open. (REQUIRED) *
	669	* 2. Optional view flag, one of: *
	670	* O Object's default view (DEFAULT) *
	671	* D Details view *
	672	* I Icon view *
	673	* S Settings *
	674	* *
	675	* REXX RETURN VALUE: *
	676	* 1 on success, or 0 if an error occurred. *
	677	* ------------------------------------------------------------------------- */
[5]	678	ULONG APIENTRY RPUOpenView( PSZ pszName, ULONG argc, RXSTRING argv[], PSZ pszQueue, PRXSTRING prsResult )
[3]	679	{
	680	HOBJECT hObj;
	681	ULONG ulView = OPEN_DEFAULT;
	682	BOOL fRC;
	683
	684
	685	// Reset the error indicator
	686	WriteErrorCode( 0, NULL );
	687
	688	// Make sure we have at least one valid argument (the queue name)
	689	if ( argc < 1 \|\| ( !RXVALIDSTRING(argv[0]) )) return ( 40 );
	690	pszName = argv[0].strptr;
	691
	692	// Second argument: view (optional, but must be correct if specified)
	693	if ( argc == 2 ) {
	694	if ( RXVALIDSTRING(argv[1]) ) {
	695	switch ( argv[1].strptr[0] ) {
	696	case 'o':
	697	case 'O': ulView = OPEN_DEFAULT; break;
	698	case 'd':
	699	case 'D': ulView = OPEN_DETAILS; break;
	700	case 'i':
	701	case 'I': ulView = OPEN_CONTENTS; break;
	702	case 's':
	703	case 'S': ulView = OPEN_SETTINGS; break;
	704	default : return ( 40 );
	705	}
	706	}
	707	else return ( 40 );
	708	}
	709	if ( argc > 2 ) return ( 40 );
	710
	711	hObj = PrinterObjectHandle( pszName );
	712	if ( !hObj ) return ( 40 );
	713
	714	fRC = WinOpenObject( hObj, ulView, TRUE );
	715
	716	MAKERXSTRING( *prsResult, fRC? "1": "0", 1 );
	717	return ( 0 );
	718	}
	719
	720
	721	/* ------------------------------------------------------------------------- *
	722	* RPUPortInstall *
	723	* *
	724	* Creates a new printer port. *
	725	* *
	726	* REXX ARGUMENTS: *
	727	* 1. The name of the port driver without any extension. This must be *
	728	* installed and registered in OS2.INI already. (REQUIRED) *
	729	* 2. The name of the new port to be created. If not specified, the port *
	730	* driver will be responsible for using a default name. (DEFAULT: none) *
	731	* *
	732	* REXX RETURN VALUE: *
	733	* 1 on success, or 0 if an error occurred. *
	734	* ------------------------------------------------------------------------- */
	735	ULONG APIENTRY RPUPortInstall( PSZ pszName, ULONG argc, RXSTRING argv[], PSZ pszQueue, PRXSTRING prsResult )
	736	{
	737	HAB hab; // desktop anchor-block handle
	738	HMODULE hPdr = NULLHANDLE; // handle to port driver module
	739	PFN pfnInstallPort; // pointer to driver's SplPdInstallPort entrypoint
	740	ULONG ulCB; // return value from PrfQueryProfileString()
	741	PSZ pszPdrName = NULL, // name of the specified port driver
	742	pszPortName = NULL; // name of the new port to create
	743	CHAR szPathName[ CCHMAXPATH+1 ]; // FQN of the port driver module
	744	APIRET rc = 0; // return code from Dos...() functions
	745
	746
	747	// Reset the error indicator
	748	WriteErrorCode( 0, NULL );
	749
	750	// Make sure we have at least one valid argument (the port driver name)
	751	if ( argc < 1 \|\| ( !RXVALIDSTRING(argv[0]) )) return ( 40 );
	752	pszPdrName = argv[0].strptr;
	753
	754	// Second argument: new port name (optional, but must be correct if specified)
	755	if ( argc >= 2 ) {
	756	if ( RXVALIDSTRING(argv[1]) )
	757	pszPortName = strupr( argv[1].strptr );
	758	else return ( 40 );
	759	}
	760
	761	// Get the path to the installed port driver
	762	hab = WinInitialize( 0 );
	763	if ( !hab ) {
	764	WriteErrorCode( 0, "WinInitialize");
	765	MAKERXSTRING( *prsResult, "0", 1 );
	766	return ( 0 );
	767	}
	768
	769	ulCB = PrfQueryProfileString( HINI_SYSTEMPROFILE, APPNAME_PM_PORT_DRIVER,
	770	pszPdrName, NULL, (PVOID) szPathName, CCHMAXPATH );
	771	if ( !ulCB ) {
	772	WriteErrorCode( ERRORIDERROR( WinGetLastError( hab )), "PrfQueryProfileString");
	773	MAKERXSTRING( *prsResult, "0", 1 );
	774	goto cleanup;
	775	}
	776
	777	// Load the port driver DLL and register its port install routine
	778	rc = DosLoadModule( NULL, 0, szPathName, &hPdr );
	779	if ( rc != NO_ERROR \|\| !hPdr ) {
	780	WriteErrorCode( rc, "DosLoadModule");
	781	MAKERXSTRING( *prsResult, "0", 1 );
	782	goto cleanup;
	783	}
	784	rc = DosQueryProcAddr( hPdr, 0, "SPLPDINSTALLPORT", &pfnInstallPort );
	785	if ( rc != NO_ERROR ) {
	786	WriteErrorCode( rc, "DosQueryProcAddr");
	787	MAKERXSTRING( *prsResult, "0", 1 );
	788	goto finish;
	789	}
	790
	791	// Now create the new port (the driver will assign it default settings)
	792	rc = pfnInstallPort( hab, pszPortName );
	793	if ( rc == NO_ERROR ) {
	794	// Return 1 on success
	795	MAKERXSTRING( *prsResult, "1", 1 );
	796	}
	797	else {
	798	WriteErrorCode( rc, "SplPdInstallPort");
	799	MAKERXSTRING( *prsResult, "0", 1 );
	800	}
	801
	802	finish:
	803	DosFreeModule( hPdr );
	804	cleanup:
	805	WinTerminate( hab );
	806	return ( 0 );
	807	}
	808
	809
	810	/* ------------------------------------------------------------------------- *
	811	* RPUPortSet *
	812	* *
	813	* Sets the specified port's configuration settings. IMPORTANT: not all *
	814	* port drivers support this; the standard OS/2 serial and parallel port *
	815	* drivers do NOT. Depending on the port driver, there are two possible *
	816	* outcomes when this API is not supported: *
	817	* A. Port driver does not have an entrypoint for SplPdSet. This is the *
	818	* case for any port driver using pre-Warp conventions. RPUPortSet will *
	819	* return 0 and RPUERROR will be "1: DosQueryProcAddr". *
	820	* B. Port driver supports SplPdSet but does not (correctly) implement the *
	821	* BIDI_SET_PORTDRV command. This is the case for some third-party port *
	822	* drivers. In this case, whether or not RPUPortSet returns a success *
	823	* code entirely depends on how conscientiously the port driver itself *
	824	* is written, but the "INITIALIZATION" key (and possibly others) in *
	825	* the port's entry in OS2SYS.INI will not be updated. The application *
	826	* should always check for this after calling RPUPortSet! *
	827	* If the application determines that either of these failure conditions has *
	828	* occurred, it is advisable to call RPUPortDialog as a fallback measure. *
	829	* *
	830	* Because of the above, use of this function is not generally encouraged *
	831	* except when absolutely necessary. *
	832	* *
	833	* REXX ARGUMENTS: *
	834	* 1. The name of the port driver without any extension. This must be *
	835	* installed and registered in OS2.INI already. (REQUIRED) *
	836	* 2. The name of the port to be configured. (REQUIRED) *
	837	* 3. Byte sequence representing the new port configuration. The format *
	838	* depends on the port driver (and it is up to the caller to know what *
	839	* it is). (REQUIRED) *
	840	* *
	841	* REXX RETURN VALUE: *
	842	* 1 on success, or 0 if an error occurred. *
	843	* ------------------------------------------------------------------------- */
	844	ULONG APIENTRY RPUPortSet( PSZ pszName, ULONG argc, RXSTRING argv[], PSZ pszQueue, PRXSTRING prsResult )
	845	{
	846	HAB hab; // desktop anchor-block handle
	847	HMODULE hPdr = NULLHANDLE; // handle to port driver module
	848	PFN pfnSetPort; // pointer to driver's SplPdSet entrypoint
	849	ULONG ulCB, // return value from PrfQueryProfileString()
	850	cBuf; // size of configuration buffer
	851	PSZ pszPdrName = NULL, // name of the specified port driver
	852	pszPortName = NULL; // name of the new port to create
	853	CHAR szPathName[ CCHMAXPATH+1 ]; // FQN of the port driver module
	854	PBYTE pBuf; // Pointer to configuration buffer
	855	APIRET rc = 0; // return code from Dos...() functions
	856
	857
	858	// Reset the error indicator
	859	WriteErrorCode( 0, NULL );
	860
	861	// Make sure we have exactly three valid arguments
	862	if ( argc != 3 \|\|
	863	!RXVALIDSTRING( argv[0] ) \|\|
	864	!RXVALIDSTRING( argv[1] ) \|\|
	865	!RXVALIDSTRING( argv[2] ) )
	866	return ( 40 );
	867	pszPdrName = argv[0].strptr;
	868	pszPortName = strupr( argv[1].strptr );
	869	pBuf = argv[2].strptr;
	870	cBuf = argv[2].strlength;
	871
	872	// Get the path to the installed port driver
	873	hab = WinInitialize( 0 );
	874	if ( !hab ) {
	875	WriteErrorCode( 0, "WinInitialize");
	876	MAKERXSTRING( *prsResult, "0", 1 );
	877	return ( 0 );
	878	}
	879
	880	ulCB = PrfQueryProfileString( HINI_SYSTEMPROFILE, APPNAME_PM_PORT_DRIVER,
	881	pszPdrName, NULL, (PVOID) szPathName, CCHMAXPATH );
	882	if ( !ulCB ) {
	883	WriteErrorCode( ERRORIDERROR( WinGetLastError( hab )), "PrfQueryProfileString");
	884	MAKERXSTRING( *prsResult, "0", 1 );
	885	goto cleanup;
	886	}
	887
	888	// Load the port driver DLL and register its configuration routine
	889	rc = DosLoadModule( NULL, 0, szPathName, &hPdr );
	890	if ( rc != NO_ERROR \|\| !hPdr ) {
	891	WriteErrorCode( rc, "DosLoadModule");
	892	MAKERXSTRING( *prsResult, "0", 1 );
	893	goto cleanup;
	894	}
	895	rc = DosQueryProcAddr( hPdr, 0, "SPLPDSET", &pfnSetPort );
	896	if ( rc != NO_ERROR ) {
	897	WriteErrorCode( rc, "DosQueryProcAddr");
	898	MAKERXSTRING( *prsResult, "0", 1 );
	899	goto finish;
	900	}
	901
	902	// Now set the new port configuration
	903	rc = pfnSetPort( pszPortName, TYPE_LONG_WAIT, BIDI_SET_PORTDRV, pBuf, cBuf );
	904	if ( rc == NO_ERROR ) {
	905	// Return 1 on success
	906	MAKERXSTRING( *prsResult, "1", 1 );
	907	}
	908	else {
	909	WriteErrorCode( rc, "SplPdSet");
	910	MAKERXSTRING( *prsResult, "0", 1 );
	911	}
	912
	913	finish:
	914	DosFreeModule( hPdr );
	915	cleanup:
	916	WinTerminate( hab );
	917	return ( 0 );
	918	}
	919
	920
	921	/* ------------------------------------------------------------------------- *
	922	* RPUPortDialog *
	923	* *
	924	* Brings up the specified port's configuration dialog. This function can *
	925	* only be used from a PM process. *
	926	* *
	927	* REXX ARGUMENTS: *
	928	* 1. The name of the port driver without any extension. This must be *
	929	* installed and registered in OS2.INI already. (REQUIRED) *
	930	* 2. The name of the port to be configured. (REQUIRED) *
	931	* *
	932	* REXX RETURN VALUE: *
	933	* 1 if the user modified the port configuration. *
	934	* 0 if no changes were made, or if an error occurred. *
	935	* ------------------------------------------------------------------------- */
	936	ULONG APIENTRY RPUPortDialog( PSZ pszName, ULONG argc, RXSTRING argv[], PSZ pszQueue, PRXSTRING prsResult )
	937	{
	938	HAB hab; // desktop anchor-block handle
	939	HMODULE hPdr = NULLHANDLE; // handle to port driver module
	940	PFN pfnSetPort; // pointer to driver's SplPdSet entrypoint
	941	ULONG ulCB, // return value from PrfQueryProfileString()
	942	flModified = 0; // flag indicating settings were changed
	943	PSZ pszPdrName = NULL, // name of the specified port driver
	944	pszPortName = NULL; // name of the new port to create
	945	CHAR szPathName[ CCHMAXPATH+1 ]; // FQN of the port driver module
	946	APIRET rc = 0; // return code from Dos...() functions
	947
	948
	949	// Reset the error indicator
	950	WriteErrorCode( 0, NULL );
	951
	952	// Make sure we have exactly two valid arguments
	953	if ( argc != 2 \|\|
	954	!RXVALIDSTRING( argv[0] ) \|\|
	955	!RXVALIDSTRING( argv[1] ) )
	956	return ( 40 );
	957	pszPdrName = argv[0].strptr;
	958	pszPortName = strupr( argv[1].strptr );
	959
	960	// Get the path to the installed port driver
	961	hab = WinInitialize( 0 );
	962	if ( !hab ) {
	963	WriteErrorCode( 0, "WinInitialize");
	964	MAKERXSTRING( *prsResult, "0", 1 );
	965	return ( 0 );
	966	}
	967
	968	ulCB = PrfQueryProfileString( HINI_SYSTEMPROFILE, APPNAME_PM_PORT_DRIVER,
	969	pszPdrName, NULL, (PVOID) szPathName, CCHMAXPATH );
	970	if ( !ulCB ) {
	971	WriteErrorCode( ERRORIDERROR( WinGetLastError( hab )), "PrfQueryProfileString");
	972	MAKERXSTRING( *prsResult, "0", 1 );
	973	goto cleanup;
	974	}
	975
	976	// Load the port driver DLL and register its dialog routine
	977	rc = DosLoadModule( NULL, 0, szPathName, &hPdr );
	978	if ( rc != NO_ERROR \|\| !hPdr ) {
	979	WriteErrorCode( rc, "DosLoadModule");
	980	MAKERXSTRING( *prsResult, "0", 1 );
	981	goto cleanup;
	982	}
	983	rc = DosQueryProcAddr( hPdr, 0, "SPLPDSETPORT", &pfnSetPort );
	984	if ( rc != NO_ERROR ) {
	985	WriteErrorCode( rc, "DosQueryProcAddr");
	986	MAKERXSTRING( *prsResult, "0", 1 );
	987	goto finish;
	988	}
	989
	990	// Now show the port configuration dialog
	991	rc = pfnSetPort( hab, pszPortName, &flModified );
	992	if ( rc == NO_ERROR ) {
	993	// Return 1 if settings were modified
	994	MAKERXSTRING( *prsResult, flModified? "1": "0", 1 );
	995	}
	996	else {
	997	WriteErrorCode( rc, "SplPdSetPort");
	998	MAKERXSTRING( *prsResult, "0", 1 );
	999	}
	1000
	1001	finish:
	1002	DosFreeModule( hPdr );
	1003	cleanup:
	1004	WinTerminate( hab );
	1005	return ( 0 );
	1006	}
	1007
	1008
[5]	1009	/* ------------------------------------------------------------------------- *
	1010	* RPUPrinterCreate *
	1011	* *
	1012	* Creates a new local printer object. The associated print queue and *
	1013	* device are also created if they do not exist. However, the associated *
	1014	* output port must exist, and the specified printer driver/model must have *
	1015	* been installed already. *
	1016	* *
	1017	* The WPS object is created with default settings, other than those which *
	1018	* are specified here. *
	1019	* *
	1020	* This function will not create a LAN printer object. Use the function *
	1021	* RPUPrinterCreateRemote (not yet implemented) for that purpose. *
	1022	* *
	1023	* REXX ARGUMENTS: *
	1024	* 1. The name of the print queue, to be created if necessary. (REQUIRED) *
	1025	* 2. The "physical name" of the printer device, ditto. (REQUIRED) *
	1026	* 3. The name of the printer port, which must exist already. (REQUIRED) *
	1027	* 4. The default printer driver.model to be associated with *
	1028	* the device. If specified, this must be installed in the *
	1029	* system already. If NOT specified, IBMNULL will be assumed *
	1030	* if the specified printer device does not already exist. (OPTIONAL) *
	1031	* 5. The printer object title (i.e. human-readable name). If *
	1032	* not specified, the physical name will be used. (OPTIONAL) *
	1033	* 6. The printer's WPS object ID (max length 225). (OPTIONAL) *
	1034	* *
	1035	* REXX RETURN VALUE: *
	1036	* 1 on success, or 0 if an error occurred. *
	1037	* ------------------------------------------------------------------------- */
	1038	ULONG APIENTRY RPUPrinterCreate( PSZ pszName, ULONG argc, RXSTRING argv[], PSZ pszQueue, PRXSTRING prsResult )
	1039	{
	1040	PRDINFO3 devinfo = {0};
	1041	PRQINFO3 qinfo = {0};
	1042	ULONG cbBuf = 0;
	1043	BOOL fNewD = FALSE,
	1044	fNewQ = FALSE;
	1045	PSZ pszQueueName = NULL,
	1046	pszDeviceName = NULL,
	1047	pszPortName = NULL,
	1048	pszModel = NULL,
	1049	pszTitle = NULL,
	1050	pszOID = NULL;
	1051	CHAR szSetup[ US_SS_MAXZ ] = {0};
	1052	SPLERR rc;
	1053
	1054
	1055	// Reset the error indicator
	1056	WriteErrorCode( 0, NULL );
	1057
	1058	// Validate the REXX arguments
	1059	if (( argc < 3 ) \|\| ( argc > 6 ) \|\| ( ! RXVALIDSTRING( argv[0] )) \|\|
	1060	( ! RXVALIDSTRING( argv[1] )) \|\| ( ! RXVALIDSTRING( argv[2] )))
	1061	return ( 40 );
	1062	if (( argc > 3 ) && ( ! RXVALIDSTRING( argv[3] )))
	1063	return ( 40 );
	1064	if (( argc > 4 ) && ( ! RXVALIDSTRING( argv[4] )))
	1065	return ( 40 );
	1066	if (( argc > 5 ) && ( ! RXVALIDSTRING( argv[5] )))
	1067	return ( 40 );
	1068
	1069	pszQueueName = argv[0].strptr;
	1070	pszDeviceName = argv[1].strptr;
	1071	pszPortName = argv[2].strptr;
	1072	if ( argc > 3 ) pszModel = argv[3].strptr;
	1073	pszTitle = ( argc > 4 ) ? argv[4].strptr : pszDeviceName;
	1074	if ( argc > 5 ) pszOID = argv[5].strptr;
	1075
	1076	// Find out if device exists already
	1077	rc = SplQueryDevice( NULL, pszDeviceName, 0, NULL, 0, &cbBuf );
	1078	if ( rc == NERR_DestNotFound ) {
	1079
	1080	// Nope, create it now
	1081	devinfo.pszPrinterName = pszDeviceName;
	1082	devinfo.pszUserName = NULL;
	1083	devinfo.pszLogAddr = pszPortName;
	1084	devinfo.pszComment = pszTitle;
	1085	devinfo.pszDrivers = pszModel ? pszModel : "IBMNULL";
	1086	devinfo.usTimeOut = 45;
	1087	rc = SplCreateDevice( NULL, 3, &devinfo, sizeof( devinfo ));
	1088	if ( rc != NO_ERROR ) {
	1089	WriteErrorCode( rc, "SplCreateDevice");
	1090	MAKERXSTRING( *prsResult, "0", 1 );
	1091	return ( 0 );
	1092	}
	1093	fNewD = TRUE;
	1094	}
	1095	else if ( rc != NO_ERROR ) {
	1096	WriteErrorCode( rc, "SplQueryDevice");
	1097	MAKERXSTRING( *prsResult, "0", 1 );
	1098	return ( 0 );
	1099	}
	1100
	1101	// Find out if the queue name already exists
	1102	rc = SplQueryQueue( NULL, pszQueueName, 3, NULL, 0, &cbBuf );
	1103	if ( rc == NERR_QNotFound ) {
	1104
	1105	// Nope, create it now
	1106	qinfo.pszName = pszQueueName;
	1107	qinfo.uPriority = PRQ_DEF_PRIORITY;
	1108	qinfo.fsType = PRQ3_TYPE_RAW;
	1109	qinfo.pszPrProc = "PMPRINT";
	1110	qinfo.pszComment = pszTitle;
	1111	qinfo.pszPrinters = pszDeviceName;
	1112	qinfo.pszDriverName = pszModel ? pszModel : "IBMNULL";
	1113	qinfo.pDriverData = NULL;
	1114	rc = SplCreateQueue( NULL, 3, &qinfo, sizeof( qinfo ));
	1115	if ( rc != NO_ERROR ) {
	1116	WriteErrorCode( rc, "SplCreateQueue");
	1117	MAKERXSTRING( *prsResult, "0", 1 );
	1118	if ( fNewD ); // TODO delete device
	1119	return ( 0 );
	1120	}
	1121	fNewQ = TRUE;
	1122	}
	1123	else if ( rc != NO_ERROR ) {
	1124	WriteErrorCode( rc, "SplQueryQueue");
	1125	MAKERXSTRING( *prsResult, "0", 1 );
	1126	if ( fNewD ); // TODO delete device
	1127	return ( 0 );
	1128	}
	1129
	1130	if ( pszOID )
	1131	sprintf( szSetup, "TAKEDEFAULTS=YES;OBJECTID=%.225s;", pszOID );
	1132	else
	1133	sprintf( szSetup, "TAKEDEFAULTS=YES;");
	1134	if ( WinCreateObject("WPPrinter", pszTitle, szSetup,
	1135	"<WP_DESKTOP>", CO_FAILIFEXISTS ) == NULLHANDLE )
	1136	{
	1137	WriteErrorCode( 0, "WinCreateObject");
	1138	MAKERXSTRING( *prsResult, "0", 1 );
	1139	if ( fNewD ); // TODO delete device
	1140	if ( fNewQ ); // TODO delete queue
	1141	return ( 0 );
	1142	}
	1143
	1144	return ( 0 );
	1145	}
	1146
	1147
	1148	/* ------------------------------------------------------------------------- *
	1149	* RPUPrinterQuery *
	1150	* *
	1151	* Gets information about the specified printer device. *
	1152	* *
	1153	* (stem).i.!description Printer description (name of WPS object) *
	1154	* (stem).i.!port Name of the port the printer is using *
	1155	* (stem).i.!driver List of the drivers used by this printer *
	1156	* TODO: *
	1157	* (stem).i.!flags Zero or more of the following flags (any order): *
	1158	* E A printer error has occurred *
	1159	* H Printer destination is paused *
	1160	* I Intervention required *
	1161	* N Printer has raised a notification alert *
	1162	* O Printer is offline *
	1163	* P Printer is out of paper *
	1164	* X Printer is not processing/paused *
	1165	* *
	1166	* REXX ARGUMENTS: *
	1167	* 1. The name of the printer device being queried. (REQUIRED) *
	1168	* 2. The name of the stem in which to return the results. (REQUIRED) *
	1169	* *
	1170	* REXX RETURN VALUE: *
	1171	* 1 on success, or 0 if an error occurred. *
	1172	* ------------------------------------------------------------------------- */
	1173	ULONG APIENTRY RPUPrinterQuery( PSZ pszName, ULONG argc, RXSTRING argv[], PSZ pszQueue, PRXSTRING prsResult )
	1174	{
	1175	PPRDINFO3 pInfo = NULL;
	1176	PVOID pbuf = NULL;
	1177	ULONG cbBuf = 0,
	1178	cbNeeded = 0;
	1179	PSZ pszDeviceName;
	1180	CHAR szStem[ US_STEM_MAXZ ]; // compound variable stem name
	1181	SPLERR rc;
	1182
	1183
	1184	// Reset the error indicator
	1185	WriteErrorCode( 0, NULL );
	1186
	1187	// Validate the REXX arguments
	1188	if (( argc != 2 ) \|\|
	1189	( ! RXVALIDSTRING( argv[0] )) \|\| ( ! RXVALIDSTRING( argv[1] )))
	1190	return ( 40 );
	1191
	1192	pszDeviceName = argv[0].strptr;
	1193	//printf("Device: \"%s\"\n", pszDeviceName );
	1194
	1195	// Initialize the result stem name
	1196	if ( RXSTRLEN(argv[1]) > US_STEM_MAXZ ) return ( 40 );
	1197	if ( argv[1].strptr[ argv[1].strlength-1 ] == '.') argv[1].strlength--;
	1198	strncpy( szStem, argv[1].strptr, RXSTRLEN( argv[1] ));
	1199	szStem[ RXSTRLEN( argv[1] ) ] = '\0';
	1200
	1201
	1202	// Query the amount of available data
	1203	rc = SplQueryDevice( NULL, pszDeviceName, 3L, NULL, 0L, &cbNeeded );
	1204	if (( rc != ERROR_MORE_DATA ) && ( rc != NERR_BufTooSmall ))
	1205	{
	1206	WriteErrorCode( rc, "SplQueryDevice");
	1207	MAKERXSTRING( *prsResult, "0", 1 );
	1208	return ( 0 );
	1209	}
	1210
	1211	// Now get the actual data
	1212	pbuf = malloc( cbNeeded );
	1213	if ( !pbuf ) {
	1214	WriteErrorCode( ERROR_NOT_ENOUGH_MEMORY, "malloc");
	1215	MAKERXSTRING( *prsResult, "0", 1 );
	1216	return ( 0 );
	1217	}
	1218	cbBuf = cbNeeded;
	1219	rc = SplQueryDevice( NULL, pszDeviceName, 3L, pbuf, cbBuf, &cbNeeded );
	1220	if ( rc == NO_ERROR ) {
	1221	pInfo = (PPRDINFO3) pbuf;
	1222	WriteCompoundVariable( szStem, "!name", pInfo->pszPrinterName );
	1223	WriteCompoundVariable( szStem, "!port", pInfo->pszLogAddr );
	1224	WriteCompoundVariable( szStem, "!description", pInfo->pszComment );
	1225	WriteCompoundVariable( szStem, "!drivers", pInfo->pszDrivers );
	1226	MAKERXSTRING( *prsResult, "1", 1 );
	1227	}
	1228	else {
	1229	WriteErrorCode( rc, "SplQueryDevice");
	1230	MAKERXSTRING( *prsResult, "0", 1 );
	1231	}
	1232
	1233	free( pbuf );
	1234	return ( 0 );
	1235	}
	1236
	1237
	1238	/* ------------------------------------------------------------------------- *
	1239	* RPUQueueDefault *
	1240	* *
	1241	* Sets the requested printer queue as the system default printer. *
	1242	* *
	1243	* REXX ARGUMENTS: *
	1244	* 1. The name of the printer queue to set as default. (REQUIRED) *
	1245	* *
	1246	* REXX RETURN VALUE: *
	1247	* 1 on success, or 0 if an error occurred. *
	1248	* ------------------------------------------------------------------------- */
	1249	ULONG APIENTRY RPUQueueDefault( PSZ pszName, ULONG argc, RXSTRING argv[], PSZ pszQueue, PRXSTRING prsResult )
	1250	{
	1251	HOBJECT hObj;
	1252	BOOL fRC;
	1253
	1254	// Reset the error indicator
	1255	WriteErrorCode( 0, NULL );
	1256
	1257	// Make sure we have at least one valid argument (the queue name)
	1258	if ( argc != 1 \|\| ( !RXVALIDSTRING(argv[0]) )) return ( 40 );
	1259	pszName = argv[0].strptr;
	1260
	1261	hObj = PrinterObjectHandle( pszName );
	1262	if ( !hObj ) return ( 40 );
	1263
	1264	fRC = WinSetObjectData( hObj, "APPDEFAULT=YES;");
	1265
	1266	MAKERXSTRING( *prsResult, fRC? "1": "0", 1 );
	1267	return ( 0 );
	1268	}
	1269
	1270
	1271	/* ------------------------------------------------------------------------- *
	1272	* RPUQueueHold *
	1273	* *
	1274	* Holds or releases the specified print queue. *
	1275	* *
	1276	* REXX ARGUMENTS: *
	1277	* 1. The name of the printer queue to hold or release. (REQUIRED) *
	1278	* 2. Action flag, one of: *
	1279	* Y Hold printer (DEFAULT) *
	1280	* N Release printer *
	1281	* *
	1282	* REXX RETURN VALUE: *
	1283	* 1 on success, or 0 if an error occurred. *
	1284	* ------------------------------------------------------------------------- */
	1285	ULONG APIENTRY RPUQueueHold( PSZ pszName, ULONG argc, RXSTRING argv[], PSZ pszQueue, PRXSTRING prsResult )
	1286	{
	1287	PSZ pszQueueName; // Print queue name
	1288	BOOL fHold = TRUE;
	1289	SPLERR rc;
	1290
	1291
	1292	// Reset the error indicator
	1293	WriteErrorCode( 0, NULL );
	1294
	1295	// Make sure we have at least one valid argument (the queue name)
	1296	if ( argc < 1 \|\| argc > 2 \|\| ( !RXVALIDSTRING(argv[0]) )) return ( 40 );
	1297	pszQueueName = argv[0].strptr;
	1298
	1299	// Second argument: view (optional, but must be correct if specified)
	1300	if ( argc == 2 ) {
	1301	if ( RXVALIDSTRING(argv[1]) ) {
	1302	switch ( argv[1].strptr[0] ) {
	1303	case 'y':
	1304	case 'Y': fHold = TRUE; break;
	1305	case 'n':
	1306	case 'N': fHold = FALSE; break;
	1307	default : return ( 40 );
	1308	}
	1309	}
	1310	else return ( 40 );
	1311	}
	1312
	1313	rc = fHold ? SplHoldQueue( NULL, pszQueueName ) :
	1314	SplReleaseQueue( NULL, pszQueueName );
	1315	if ( rc != NO_ERROR ) {
	1316	WriteErrorCode( rc, fHold ? "SplHoldQueue" : "SplReleaseQueue");
	1317	MAKERXSTRING( *prsResult, "0", 1 );
	1318	}
	1319	else MAKERXSTRING( *prsResult, "1", 1 );
	1320
	1321	return ( 0 );
	1322	}
	1323
	1324
[3]	1325	/* ************************************************************************* *
	1326	* INTERNAL PRINTER-RELATED FUNCTIONS *
	1327	* ************************************************************************* */
	1328
	1329	/* ------------------------------------------------------------------------- *
	1330	* PrinterObjectHandle *
	1331	* *
	1332	* Given a print queue name, obtain the handle to the WPS printer object *
	1333	* associated with that queue. This is done by querying OS2.INI for the *
	1334	* queues defined in PM_PrintObject and reading the associated handle IDs. *
	1335	* *
	1336	* ARGUMENTS: *
	1337	* PSZ pszQueueName: The printer queue name. This is NOT the same as the *
	1338	* printer device name, although in many cases they may *
	1339	* have the same value. *
	1340	* *
	1341	* RETURNS: HOBJECT *
	1342	* WPS object handle of the printer object; NULLHANDLE if no object was *
	1343	* found or an error occurred. *
	1344	* ------------------------------------------------------------------------- */
	1345	HOBJECT PrinterObjectHandle( PSZ pszQueueName )
	1346	{
	1347	PVOID pbuf = NULL;
	1348	PSZ psz;
	1349	CHAR szValue[ 256 ];
	1350	ULONG cbTotal = 0,
	1351	cbActual = 0;
	1352	HOBJECT hObj = 0;
	1353	BOOL fRC;
	1354
	1355
	1356	fRC = PrfQueryProfileSize( HINI_USERPROFILE,
	1357	APPNAME_PM_PRINT_OBJECT, NULL, &cbTotal );
	1358	if ( !fRC \|\| !cbTotal ) {
	1359	//WriteErrorCode( ERRORIDERROR( WinGetLastError( hab )), "PrfQueryProfileSize");
	1360	return NULLHANDLE;
	1361	}
	1362	pbuf = malloc( cbTotal );
	1363	if ( !pbuf ) {
	1364	WriteErrorCode( ERROR_NOT_ENOUGH_MEMORY, "malloc");
	1365	return NULLHANDLE;
	1366	}
	1367
	1368	cbActual = PrfQueryProfileString( HINI_USERPROFILE, APPNAME_PM_PRINT_OBJECT,
	1369	NULL, NULL, pbuf, cbTotal );
	1370	if ( !cbActual ) {
	1371	//WriteErrorCode( ERRORIDERROR( WinGetLastError( hab )), "PrfQueryProfileString");
	1372	return NULLHANDLE;
	1373	}
	1374
	1375	psz = (PSZ) pbuf;
	1376	while ( *psz ) {
	1377	if ( !PrfQueryProfileString( HINI_USERPROFILE, APPNAME_PM_PRINT_OBJECT,
	1378	psz, NULL, szValue, 255 ))
	1379	{
	1380	//WriteErrorCode( ERRORIDERROR( WinGetLastError( hab )), "PrfQueryProfileString");
	1381	break;
	1382	}
	1383	if (( strcmp( szValue, pszQueueName ) == 0 ) &&
	1384	( sscanf( psz, "%u", (PULONG) &hObj ) == 1 ))
	1385	{
	1386	break;
	1387	}
	1388	psz += strlen( psz ) + 1;
	1389	}
	1390
	1391	free ( pbuf );
	1392	return ( hObj );
	1393	}
	1394
	1395
	1396	/* ------------------------------------------------------------------------- *
	1397	* GetObjectID *
	1398	* *
	1399	* Given a WPS object handle, find out the corresponding object ID if one *
	1400	* exists. *
	1401	* *
	1402	* ARGUMENTS: *
	1403	* PSZ pszHandle: The WPS object handle, as a hexadecimal string. This *
	1404	* should have no prefix, and be all upper-case. *
	1405	* *
	1406	* RETURNS: PSZ *
	1407	* The object ID string. It is up to the caller to free it when done. *
	1408	* This will be NULL if no object ID was found. *
	1409	* ------------------------------------------------------------------------- */
	1410	PSZ GetObjectID( PSZ pszHandle )
	1411	{
	1412	PVOID pbuf = NULL;
	1413	ULONG cbTotal = 0,
	1414	cbActual = 0;
	1415	CHAR szValue[ 9 ];
	1416	PSZ psz,
	1417	pszObjID = NULL;
	1418	BOOL fRC;
	1419
	1420
	1421	fRC = PrfQueryProfileSize( HINI_USERPROFILE,
	1422	APPNAME_PM_WPS_LOCATION, NULL, &cbTotal );
	1423	if ( !fRC \|\| !cbTotal ) {
	1424	//WriteErrorCode( ERRORIDERROR( WinGetLastError( hab )), "PrfQueryProfileSize");
	1425	return NULL;
	1426	}
	1427	pbuf = malloc( cbTotal );
	1428	if ( !pbuf ) {
	1429	WriteErrorCode( ERROR_NOT_ENOUGH_MEMORY, "malloc");
	1430	return NULL;
	1431	}
	1432
	1433	cbActual = PrfQueryProfileString( HINI_USERPROFILE, APPNAME_PM_WPS_LOCATION,
	1434	NULL, NULL, pbuf, cbTotal );
	1435	if ( !cbActual ) {
	1436	//WriteErrorCode( ERRORIDERROR( WinGetLastError( hab )), "PrfQueryProfileString");
	1437	return NULL;
	1438	}
	1439
	1440	psz = (PSZ) pbuf;
	1441	while ( *psz ) {
	1442	if ( !PrfQueryProfileString( HINI_USERPROFILE, APPNAME_PM_WPS_LOCATION,
	1443	psz, NULL, szValue, 8 ))
	1444	{
	1445	//WriteErrorCode( ERRORIDERROR( WinGetLastError( hab )), "PrfQueryProfileString");
	1446	break;
	1447	}
	1448	if (( strcmp( szValue, pszHandle ) == 0 ) &&
	1449	(( pszObjID = strdup( psz )) != NULL ))
	1450	{
	1451	break;
	1452	}
	1453	psz += strlen( psz ) + 1;
	1454	}
	1455
	1456	free ( pbuf );
	1457	return ( pszObjID );
	1458	}
	1459
	1460
	1461	/* ************************************************************************* *
	1462	* INTERNAL REXX DLL UTILITY FUNCTIONS *
	1463	* ************************************************************************* */
	1464
	1465
	1466	/* ------------------------------------------------------------------------- *
	1467	* SaveResultString *
	1468	* *
	1469	* Writes new string contents to the specified RXSTRING, allocating any *
	1470	* additional memory that may be required. If the string to be written has *
	1471	* zero length, nothing is done. *
	1472	* *
	1473	* This function should be used in place of MAKERXSTRING if there is a *
	1474	* possibility that the string contents could be longer than 256 characters. *
	1475	* *
	1476	* ARGUMENTS: *
	1477	* PRXSTRING prsResult: Pointer to an existing RXSTRING for writing. *
	1478	* PCH pchBytes : The string contents to write to prsResult. *
	1479	* ULONG ulBytes : The number of bytes in pchBytes to write. *
	1480	* *
	1481	* RETURNS: BOOL *
	1482	* TRUE if prsResult was successfully updated. FALSE otherwise. *
	1483	* ------------------------------------------------------------------------- */
	1484	BOOL SaveResultString( PRXSTRING prsResult, PCH pchBytes, ULONG ulBytes )
	1485	{
	1486	ULONG ulRC;
	1487	PCH pchNew;
	1488
	1489	if ( ulBytes == 0 ) return ( FALSE );
	1490	if ( ulBytes > 256 ) {
	1491	// REXX provides 256 bytes by default; allocate more if necessary
	1492	ulRC = DosAllocMem( (PVOID) &pchNew, ulBytes, PAG_WRITE \| PAG_COMMIT );
	1493	if ( ulRC != 0 ) {
	1494	WriteErrorCode( ulRC, "DosAllocMem");
	1495	return ( FALSE );
	1496	}
	1497	DosFreeMem( prsResult->strptr );
	1498	prsResult->strptr = pchNew;
	1499	}
	1500	memcpy( prsResult->strptr, pchBytes, ulBytes );
	1501	prsResult->strlength = ulBytes;
	1502
	1503	return ( TRUE );
	1504	}
	1505
	1506
	1507	/* ------------------------------------------------------------------------- *
	1508	* WriteStemElement *
	1509	* *
	1510	* Creates a stem element (compound variable) in the calling REXX program *
	1511	* using the REXX shared variable pool interface. *
	1512	* *
	1513	* ARGUMENTS: *
	1514	* PSZ pszStem : The name of the stem (before the '.') *
	1515	* ULONG ulIndex : The number of the stem element (after the '.') *
	1516	* PSZ pszValue : The value to write to the compound variable. *
	1517	* *
	1518	* RETURNS: BOOL *
	1519	* TRUE on success, FALSE on failure. *
	1520	* ------------------------------------------------------------------------- */
	1521	BOOL WriteStemElement( PSZ pszStem, ULONG ulIndex, PSZ pszValue )
	1522	{
	1523	SHVBLOCK shvVar; // REXX shared variable pool block
	1524	ULONG ulRc,
	1525	ulBytes;
	1526	CHAR szCompoundName[ US_COMPOUND_MAXZ ],
	1527	*pchValue;
	1528
	1529	sprintf( szCompoundName, "%s.%d", pszStem, ulIndex );
	1530	if ( pszValue == NULL ) {
	1531	pchValue = "";
	1532	ulBytes = 0;
	1533	} else {
	1534	ulBytes = strlen( pszValue );
	1535	ulRc = DosAllocMem( (PVOID) &pchValue, ulBytes + 1, PAG_WRITE \| PAG_COMMIT );
	1536	if ( ulRc != 0 ) {
	1537	WriteErrorCode( ulRc, "DosAllocMem");
	1538	return FALSE;
	1539	}
	1540	memcpy( pchValue, pszValue, ulBytes );
	1541	}
	1542	MAKERXSTRING( shvVar.shvname, szCompoundName, strlen(szCompoundName) );
	1543	shvVar.shvvalue.strptr = pchValue;
	1544	shvVar.shvvalue.strlength = ulBytes;
	1545	shvVar.shvnamelen = RXSTRLEN( shvVar.shvname );
	1546	shvVar.shvvaluelen = RXSTRLEN( shvVar.shvvalue );
	1547	shvVar.shvcode = RXSHV_SYSET;
	1548	shvVar.shvnext = NULL;
	1549	ulRc = RexxVariablePool( &shvVar );
	1550	if ( ulRc > 1 ) {
	1551	WriteErrorCode( shvVar.shvret, "RexxVariablePool (SHVBLOCK.shvret)");
	1552	return FALSE;
	1553	}
	1554	return TRUE;
	1555
	1556	}
	1557
	1558
	1559	/* ------------------------------------------------------------------------- *
	1560	* WriteCompoundVariable *
	1561	* *
	1562	* Creates a compound variable in the calling REXX program using the REXX *
	1563	* shared variable pool interface. *
	1564	* *
	1565	* ARGUMENTS: *
	1566	* PSZ pszStem : The name of the stem (before the '.') *
	1567	* PSZ pszTail : The name of the trailing portion (after the '.') *
	1568	* PSZ pszValue : The value to write to the compound variable. *
	1569	* *
	1570	* RETURNS: BOOL *
	1571	* TRUE on success, FALSE on failure. *
	1572	* ------------------------------------------------------------------------- */
	1573	BOOL WriteCompoundVariable( PSZ pszStem, PSZ pszTail, PSZ pszValue )
	1574	{
	1575	SHVBLOCK shvVar; // REXX shared variable pool block
	1576	ULONG ulRc,
	1577	ulBytes;
	1578	CHAR szCompoundName[ US_COMPOUND_MAXZ ],
	1579	*pchValue;
	1580
	1581	sprintf( szCompoundName, "%s.%s", pszStem, pszTail );
	1582	if ( pszValue == NULL ) {
	1583	pchValue = "";
	1584	ulBytes = 0;
	1585	} else {
	1586	ulBytes = strlen( pszValue );
	1587	ulRc = DosAllocMem( (PVOID) &pchValue, ulBytes + 1, PAG_WRITE \| PAG_COMMIT );
	1588	if ( ulRc != 0 ) {
	1589	WriteErrorCode( ulRc, "DosAllocMem");
	1590	return FALSE;
	1591	}
	1592	memcpy( pchValue, pszValue, ulBytes );
	1593	}
	1594	MAKERXSTRING( shvVar.shvname, szCompoundName, strlen(szCompoundName) );
	1595	shvVar.shvvalue.strptr = pchValue;
	1596	shvVar.shvvalue.strlength = ulBytes;
	1597	shvVar.shvnamelen = RXSTRLEN( shvVar.shvname );
	1598	shvVar.shvvaluelen = RXSTRLEN( shvVar.shvvalue );
	1599	shvVar.shvcode = RXSHV_SYSET;
	1600	shvVar.shvnext = NULL;
	1601	ulRc = RexxVariablePool( &shvVar );
	1602	if ( ulRc > 1 ) {
	1603	WriteErrorCode( shvVar.shvret, "RexxVariablePool (SHVBLOCK.shvret)");
	1604	return FALSE;
	1605	}
	1606	return TRUE;
	1607	}
	1608
	1609
	1610	/* ------------------------------------------------------------------------- *
	1611	* WriteErrorCode *
	1612	* *
	1613	* Writes an error code to a special variable in the calling REXX program *
	1614	* using the REXX shared variable pool interface. This is used to return *
	1615	* API error codes to the REXX program, since the REXX functions themselves *
	1616	* normally return string values. *
	1617	* *
	1618	* ARGUMENTS: *
	1619	* ULONG ulError : The error code returned by the failing API call. *
	1620	* PSZ pszContext: A string describing the API call that failed. *
	1621	* *
	1622	* RETURNS: N/A *
	1623	* ------------------------------------------------------------------------- */
	1624	void WriteErrorCode( ULONG ulError, PSZ pszContext )
	1625	{
	1626	SHVBLOCK shvVar; // REXX shared variable pool block
	1627	ULONG ulRc;
	1628	CHAR szErrorText[ US_ERRSTR_MAXZ ];
	1629
	1630	if ( pszContext == NULL )
	1631	sprintf( szErrorText, "%X", ulError );
	1632	else
	1633	sprintf( szErrorText, "%X: %s", ulError, pszContext );
	1634	MAKERXSTRING( shvVar.shvname, SZ_ERROR_NAME, strlen(SZ_ERROR_NAME) );
	1635	MAKERXSTRING( shvVar.shvvalue, szErrorText, strlen(szErrorText) );
	1636	shvVar.shvnamelen = RXSTRLEN( shvVar.shvname );
	1637	shvVar.shvvaluelen = RXSTRLEN( shvVar.shvvalue );
	1638	shvVar.shvcode = RXSHV_SYSET;
	1639	shvVar.shvnext = NULL;
	1640	ulRc = RexxVariablePool( &shvVar );
	1641	if ( ulRc > 1 )
	1642	printf("Unable to set %s: rc = %d\n", shvVar.shvname.strptr, shvVar.shvret );
	1643	}
	1644
	1645

Note: See TracBrowser for help on using the repository browser.

Download in other formats: