Context Navigation

source: rxprtutl/trunk/rxprtutl.c@ 8

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

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

Download in other formats: