testprogs: add win32 spoolss testsuite.

Guenther

testprogs/win32/spoolss/Makefile

@@ -0,0 +1,38 @@
+CFLAGS = /nologo /Zi /MT /Gm- /W4 /FR /D_CRT_SECURE_NO_WARNINGS
+LIBS = kernel32.lib gdi32.lib user32.lib shell32.lib \
+	advapi32.lib ole32.lib ws2_32.lib rpcrt4.lib
+WINSPOOL_LIBS = winspool.lib
+
+all: spoolss.exe
+
+.cpp.obj:
+	cl /c $(CFLAGS) $*.cpp
+
+.c.obj:
+	cl /c $(CFLAGS) $*.c
+
+clean: cleantmp
+	-del *.dll 2>nul
+
+cleantmp:
+	-del *~ *.o *.obj *.sbr *.bsc *.pdb *.lib *.ilk *.exp 2>nul
+	-del test_s.c test_c.c test.h 2>nul
+
+###############################
+# helpers
+###############################
+
+error.obj: error.c
+
+torture.obj: torture.c
+
+###############################
+# binaries
+###############################
+
+spoolss.obj: spoolss.c
+
+spoolss.exe: spoolss.obj error.obj torture.obj
+	cl $(CFLAGS) /Fe$@ spoolss.obj error.obj torture.obj \
+	/link /incremental:no /subsystem:console $(LIBS) $(WINSPOOL_LIBS)
+

testprogs/win32/spoolss/Makefile.mingw

@@ -0,0 +1,22 @@
+MAKE=mingw32-make
+CFLAGS=-I../../../ -I/usr/i686-pc-mingw32/sys-root/mingw/include
+LDFLAGS=-L/usr/i686-pc-mingw32/sys-root/mingw/lib
+CC=/usr/bin/i686-pc-mingw32-gcc
+LIBS=-lwinspool
+
+all: spoolss.exe
+
+clean:
+	rm -vf *.exe tags
+
+ctags:
+	ctags `find . -name "*.[ch]" | grep -v include/proto.h`
+	ctags --c-kinds=-p -a `find /usr/i686-pc-mingw32/sys-root/mingw/include -name "*.[ch]" | grep -v /CVS/`
+
+proto:
+	mkproto.pl torture.c --private=torture_proto.h --public=torture_proto_pub.h --srcdir=. --builddir=.
+
+spoolss.exe: spoolss.c torture.c error.c
+	@echo Compiling spoolss.exe
+	@$(CC) $(CFLAGS) $(LDFLAGS) spoolss.c torture.c error.c $(LIBS) -o spoolss.exe
+

testprogs/win32/spoolss/README

@@ -0,0 +1 @@
+FIXME

testprogs/win32/spoolss/error.c

@@ -0,0 +1,115 @@
+/*
+   Unix SMB/CIFS implementation.
+   test suite for spoolss rpc operations
+
+   Copyright (C) Guenther Deschner 2009
+
+   This program is free software; you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation; either version 3 of the License, or
+   (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+
+   You should have received a copy of the GNU General Public License
+   along with this program.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#include "spoolss.h"
+
+const char *errstr(DWORD error)
+{
+	static char tmp[20];
+
+	switch (error) {
+	case ERROR_ACCESS_DENIED:
+		return "ERROR_ACCESS_DENIED";
+	case ERROR_INVALID_PARAMETER:
+		return "ERROR_INVALID_PARAMETER";
+	case ERROR_CALL_NOT_IMPLEMENTED:
+		return "ERROR_CALL_NOT_IMPLEMENTED";
+	case ERROR_INSUFFICIENT_BUFFER:
+		return "ERROR_INSUFFICIENT_BUFFER";
+	case ERROR_INVALID_NAME:
+		return "ERROR_INVALID_NAME";
+	case ERROR_INVALID_LEVEL:
+		return "ERROR_INVALID_LEVEL";
+	case ERROR_MORE_DATA:
+		return "ERROR_MORE_DATA";
+#ifdef ERROR_INVALID_DATATYPE
+	case ERROR_INVALID_DATATYPE:
+		return "ERROR_INVALID_DATATYPE";
+#endif
+	case ERROR_INVALID_ENVIRONMENT:
+		return "ERROR_INVALID_ENVIRONMENT";
+	case ERROR_INVALID_PRINTER_COMMAND:
+		return "ERROR_INVALID_PRINTER_COMMAND";
+	case ERROR_PRINTER_ALREADY_EXISTS:
+		return "ERROR_PRINTER_ALREADY_EXISTS";
+	case ERROR_INVALID_PRINTER_NAME:
+		return "ERROR_INVALID_PRINTER_NAME";
+	case ERROR_INVALID_PRIORITY:
+		return "ERROR_INVALID_PRIORITY";
+	case ERROR_INVALID_SEPARATOR_FILE:
+		return "ERROR_INVALID_SEPARATOR_FILE";
+	case ERROR_UNKNOWN_PRINTPROCESSOR:
+		return "ERROR_UNKNOWN_PRINTPROCESSOR";
+	case ERROR_UNKNOWN_PRINTER_DRIVER:
+		return "ERROR_UNKNOWN_PRINTER_DRIVER";
+	case ERROR_UNKNOWN_PORT:
+		return "ERROR_UNKNOWN_PORT";
+	case ERROR_PRINTER_DRIVER_ALREADY_INSTALLED:
+		return "ERROR_PRINTER_DRIVER_ALREADY_INSTALLED";
+	case ERROR_UNKNOWN_PRINT_MONITOR:
+		return "ERROR_UNKNOWN_PRINT_MONITOR";
+	case ERROR_PRINTER_DRIVER_IN_USE:
+		return "ERROR_PRINTER_DRIVER_IN_USE";
+	case ERROR_SPOOL_FILE_NOT_FOUND:
+		return "ERROR_SPOOL_FILE_NOT_FOUND";
+	case ERROR_SPL_NO_STARTDOC:
+		return "ERROR_SPL_NO_STARTDOC";
+	case ERROR_SPL_NO_ADDJOB:
+		return "ERROR_SPL_NO_ADDJOB";
+	case ERROR_PRINT_PROCESSOR_ALREADY_INSTALLED:
+		return "ERROR_PRINT_PROCESSOR_ALREADY_INSTALLED";
+	case ERROR_PRINT_MONITOR_ALREADY_INSTALLED:
+		return "ERROR_PRINT_MONITOR_ALREADY_INSTALLED";
+	case ERROR_INVALID_PRINT_MONITOR:
+		return "ERROR_INVALID_PRINT_MONITOR";
+	case ERROR_PRINT_MONITOR_IN_USE:
+		return "ERROR_PRINT_MONITOR_IN_USE";
+	case ERROR_PRINTER_HAS_JOBS_QUEUED:
+		return "ERROR_PRINTER_HAS_JOBS_QUEUED";
+	case ERROR_PRINTER_NOT_FOUND:
+		return "ERROR_PRINTER_NOT_FOUND";
+	case ERROR_PRINTER_DRIVER_WARNED:
+		return "ERROR_PRINTER_DRIVER_WARNED";
+	case ERROR_PRINTER_DRIVER_BLOCKED:
+		return "ERROR_PRINTER_DRIVER_BLOCKED";
+#ifdef ERROR_PRINTER_DRIVER_PACKAGE_IN_USE
+	case ERROR_PRINTER_DRIVER_PACKAGE_IN_USE:
+		return "ERROR_PRINTER_DRIVER_PACKAGE_IN_USE";
+#endif
+#ifdef ERROR_CORE_DRIVER_PACKAGE_NOT_FOUND
+	case ERROR_CORE_DRIVER_PACKAGE_NOT_FOUND:
+		return "ERROR_CORE_DRIVER_PACKAGE_NOT_FOUND";
+#endif
+#ifdef ERROR_PRINTER_DRIVER_DOWNLOAD_NEEDED
+	case ERROR_PRINTER_DRIVER_DOWNLOAD_NEEDED:
+		return "ERROR_PRINTER_DRIVER_DOWNLOAD_NEEDED";
+#endif
+#ifdef ERROR_PRINT_JOB_RESTART_REQUIRED
+	case ERROR_PRINT_JOB_RESTART_REQUIRED:
+		return "ERROR_PRINT_JOB_RESTART_REQUIRED";
+#endif
+	default:
+		break;
+	}
+
+	sprintf(tmp, "0x%08x", error);
+
+	return tmp;
+}

testprogs/win32/spoolss/error.h

@@ -0,0 +1,36 @@
+/*
+   Unix SMB/CIFS implementation.
+   test suite for spoolss rpc operations
+
+   Copyright (C) Guenther Deschner 2009
+
+   This program is free software; you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation; either version 3 of the License, or
+   (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+
+   You should have received a copy of the GNU General Public License
+   along with this program.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#ifndef ERROR_INVALID_PARAMETER
+#define ERROR_INVALID_PARAMETER 87
+#endif
+
+#ifndef ERROR_INSUFFICIENT_BUFFER
+#define ERROR_INSUFFICIENT_BUFFER 0x007a
+#endif
+
+#if 0
+#ifdef STATUS_PENDING
+#undef STATUS_PENDING
+#define STATUS_PENDING 0x0103
+#endif
+#endif
+
+const char *errstr(DWORD error);

testprogs/win32/spoolss/spoolss.c

@@ -0,0 +1,771 @@
+/*
+   Unix SMB/CIFS implementation.
+   test suite for spoolss rpc operations
+
+   Copyright (C) Guenther Deschner 2009
+
+   This program is free software; you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation; either version 3 of the License, or
+   (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+
+   You should have received a copy of the GNU General Public License
+   along with this program.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+/****************************************************************************
+****************************************************************************/
+
+#include "spoolss.h"
+#include "string.h"
+#include "torture.h"
+
+/****************************************************************************
+****************************************************************************/
+
+static BOOL test_OpenPrinter(struct torture_context *tctx,
+			     LPSTR printername,
+			     HANDLE handle)
+{
+	torture_comment(tctx, "Testing OpenPrinter(%s)", printername);
+
+	if (!OpenPrinter(printername, handle, NULL)) {
+		char tmp[1024];
+		sprintf(tmp, "failed to open printer %s, error was: 0x%08x\n",
+			printername, GetLastError());
+		torture_fail(tctx, tmp);
+	}
+
+	return TRUE;
+}
+
+/****************************************************************************
+****************************************************************************/
+
+static BOOL test_ClosePrinter(struct torture_context *tctx,
+			      HANDLE handle)
+{
+	torture_comment(tctx, "Testing ClosePrinter");
+
+	if (!ClosePrinter(handle)) {
+		char tmp[1024];
+		sprintf(tmp, "failed to close printer, error was: %s\n",
+			errstr(GetLastError()));
+		torture_fail(tctx, tmp);
+	}
+
+	return TRUE;
+}
+
+
+/****************************************************************************
+****************************************************************************/
+
+static BOOL test_EnumPrinters(struct torture_context *tctx,
+			      LPSTR servername)
+{
+	DWORD levels[]  = { 1, 2, 5 };
+	DWORD success[] = { 1, 1, 1 };
+	DWORD i;
+	DWORD flags = PRINTER_ENUM_NAME;
+	LPBYTE buffer = NULL;
+
+	for (i=0; i < ARRAY_SIZE(levels); i++) {
+
+		DWORD needed = 0;
+		DWORD returned = 0;
+		DWORD err = 0;
+		char tmp[1024];
+
+		torture_comment(tctx, "Testing EnumPrinters level %d", levels[i]);
+
+		EnumPrinters(flags, servername, levels[i], NULL, 0, &needed, &returned);
+		err = GetLastError();
+		if (err == ERROR_INSUFFICIENT_BUFFER) {
+			err = 0;
+			buffer = malloc(needed);
+			torture_assert(tctx, buffer, "malloc failed");
+			if (!EnumPrinters(flags, servername, levels[i], buffer, needed, &needed, &returned)) {
+				err = GetLastError();
+			}
+		}
+		if (err) {
+			sprintf(tmp, "EnumPrinters failed level %d on [%s] (buffer size = %d), error: %s\n",
+				levels[i], servername, needed, errstr(err));
+			if (success[i]) {
+				torture_fail(tctx, tmp);
+			} else {
+				torture_warning(tctx, tmp);
+			}
+		}
+
+		free(buffer);
+		buffer = NULL;
+	}
+
+	return TRUE;
+}
+
+/****************************************************************************
+****************************************************************************/
+
+static BOOL test_EnumDrivers(struct torture_context *tctx,
+			     LPSTR servername)
+{
+	DWORD levels[]  = { 1, 2, 3, 4, 5, 6, 8 };
+	DWORD success[] = { 1, 1, 1, 1, 1, 1, 1 };
+	DWORD i;
+	LPBYTE buffer = NULL;
+
+	for (i=0; i < ARRAY_SIZE(levels); i++) {
+
+		DWORD needed = 0;
+		DWORD returned = 0;
+		DWORD err = 0;
+		char tmp[1024];
+
+		torture_comment(tctx, "Testing EnumPrinterDrivers level %d", levels[i]);
+
+		EnumPrinterDrivers(servername, "Windows NT x86", levels[i], NULL, 0, &needed, &returned);
+		err = GetLastError();
+		if (err == ERROR_INSUFFICIENT_BUFFER) {
+			err = 0;
+			buffer = malloc(needed);
+			torture_assert(tctx, buffer, "malloc failed");
+			if (!EnumPrinterDrivers(servername, "Windows NT x86", levels[i], buffer, needed, &needed, &returned)) {
+				err = GetLastError();
+			}
+		}
+		if (err) {
+			sprintf(tmp, "EnumPrinterDrivers failed level %d on [%s] (buffer size = %d), error: %s\n",
+				levels[i], servername, needed, errstr(err));
+			if (success[i]) {
+				torture_fail(tctx, tmp);
+			} else {
+				torture_warning(tctx, tmp);
+			}
+		}
+
+		free(buffer);
+		buffer = NULL;
+	}
+
+	return TRUE;
+}
+
+/****************************************************************************
+****************************************************************************/
+
+static BOOL test_EnumForms(struct torture_context *tctx,
+			   LPSTR servername,
+			   HANDLE handle)
+{
+	DWORD levels[]  = { 1, 2 };
+	DWORD success[] = { 1, 0 };
+	DWORD i;
+	LPBYTE buffer = NULL;
+
+	for (i=0; i < ARRAY_SIZE(levels); i++) {
+
+		DWORD needed = 0;
+		DWORD returned = 0;
+		DWORD err = 0;
+		char tmp[1024];
+
+		torture_comment(tctx, "Testing EnumForms level %d", levels[i]);
+
+		EnumForms(handle, levels[i], NULL, 0, &needed, &returned);
+		err = GetLastError();
+		if (err == ERROR_INSUFFICIENT_BUFFER) {
+			err = 0;
+			buffer = malloc(needed);
+			torture_assert(tctx, buffer, "malloc failed");
+			if (!EnumForms(handle, levels[i], buffer, needed, &needed, &returned)) {
+				err = GetLastError();
+			}
+		}
+		if (err) {
+			sprintf(tmp, "EnumForms failed level %d on [%s] (buffer size = %d), error: %s\n",
+				levels[i], servername, needed, errstr(err));
+			if (success[i]) {
+				torture_fail(tctx, tmp);
+			} else {
+				torture_warning(tctx, tmp);
+			}
+		}
+
+		free(buffer);
+		buffer = NULL;
+	}
+
+	return TRUE;
+}
+
+/****************************************************************************
+****************************************************************************/
+
+static BOOL test_EnumPorts(struct torture_context *tctx,
+			   LPSTR servername)
+{
+	DWORD levels[]  = { 1, 2 };
+	DWORD success[] = { 1, 1 };
+	DWORD i;
+	LPBYTE buffer = NULL;
+
+	for (i=0; i < ARRAY_SIZE(levels); i++) {
+
+		DWORD needed = 0;
+		DWORD returned = 0;
+		DWORD err = 0;
+		char tmp[1024];
+
+		torture_comment(tctx, "Testing EnumPorts level %d", levels[i]);
+
+		EnumPorts(servername, levels[i], NULL, 0, &needed, &returned);
+		err = GetLastError();
+		if (err == ERROR_INSUFFICIENT_BUFFER) {
+			err = 0;
+			buffer = malloc(needed);
+			torture_assert(tctx, buffer, "malloc failed");
+			if (!EnumPorts(servername, levels[i], buffer, needed, &needed, &returned)) {
+				err = GetLastError();
+			}
+		}
+		if (err) {
+			sprintf(tmp, "EnumPorts failed level %d on [%s] (buffer size = %d), error: %s\n",
+				levels[i], servername, needed, errstr(err));
+			if (success[i]) {
+				torture_fail(tctx, tmp);
+			} else {
+				torture_warning(tctx, tmp);
+			}
+		}
+
+		free(buffer);
+		buffer = NULL;
+	}
+
+	return TRUE;
+}
+
+/****************************************************************************
+****************************************************************************/
+
+static BOOL test_EnumMonitors(struct torture_context *tctx,
+			      LPSTR servername)
+{
+	DWORD levels[]  = { 1, 2 };
+	DWORD success[] = { 1, 1 };
+	DWORD i;
+	LPBYTE buffer = NULL;
+
+	for (i=0; i < ARRAY_SIZE(levels); i++) {
+
+		DWORD needed = 0;
+		DWORD returned = 0;
+		DWORD err = 0;
+		char tmp[1024];
+
+		torture_comment(tctx, "Testing EnumMonitors level %d", levels[i]);
+
+		EnumMonitors(servername, levels[i], NULL, 0, &needed, &returned);
+		err = GetLastError();
+		if (err == ERROR_INSUFFICIENT_BUFFER) {
+			err = 0;
+			buffer = malloc(needed);
+			torture_assert(tctx, buffer, "malloc failed");
+			if (!EnumMonitors(servername, levels[i], buffer, needed, &needed, &returned)) {
+				err = GetLastError();
+			}
+		}
+		if (err) {
+			sprintf(tmp, "EnumMonitors failed level %d on [%s] (buffer size = %d), error: %s\n",
+				levels[i], servername, needed, errstr(err));
+			if (success[i]) {
+				torture_fail(tctx, tmp);
+			} else {
+				torture_warning(tctx, tmp);
+			}
+		}
+
+		free(buffer);
+		buffer = NULL;
+	}
+
+	return TRUE;
+}
+
+/****************************************************************************
+****************************************************************************/
+
+static BOOL test_EnumPrintProcessors(struct torture_context *tctx,
+				     LPSTR servername)
+{
+	DWORD levels[]  = { 1 };
+	DWORD success[] = { 1 };
+	DWORD i;
+	LPBYTE buffer = NULL;
+
+	for (i=0; i < ARRAY_SIZE(levels); i++) {
+
+		DWORD needed = 0;
+		DWORD returned = 0;
+		DWORD err = 0;
+		char tmp[1024];
+
+		torture_comment(tctx, "Testing EnumPrintProcessors level %d", levels[i]);
+
+		EnumPrintProcessors(servername, "Windows NT x86", levels[i], NULL, 0, &needed, &returned);
+		err = GetLastError();
+		if (err == ERROR_INSUFFICIENT_BUFFER) {
+			err = 0;
+			buffer = malloc(needed);
+			torture_assert(tctx, buffer, "malloc failed");
+			if (!EnumPrintProcessors(servername, "Windows NT x86", levels[i], buffer, needed, &needed, &returned)) {
+				err = GetLastError();
+			}
+		}
+		if (err) {
+			sprintf(tmp, "EnumPrintProcessors failed level %d on [%s] (buffer size = %d), error: %s\n",
+				levels[i], servername, needed, errstr(err));
+			if (success[i]) {
+				torture_fail(tctx, tmp);
+			} else {
+				torture_warning(tctx, tmp);
+			}
+		}
+
+		free(buffer);
+		buffer = NULL;
+	}
+
+	return TRUE;
+}
+
+/****************************************************************************
+****************************************************************************/
+
+static BOOL test_EnumPrintProcessorDatatypes(struct torture_context *tctx,
+					     LPSTR servername)
+{
+	DWORD levels[]  = { 1 };
+	DWORD success[] = { 1 };
+	DWORD i;
+	LPBYTE buffer = NULL;
+
+	for (i=0; i < ARRAY_SIZE(levels); i++) {
+
+		DWORD needed = 0;
+		DWORD returned = 0;
+		DWORD err = 0;
+		char tmp[1024];
+
+		torture_comment(tctx, "Testing EnumPrintProcessorDatatypes level %d", levels[i]);
+
+		EnumPrintProcessorDatatypes(servername, "Windows NT x86", levels[i], NULL, 0, &needed, &returned);
+		err = GetLastError();
+		if (err == ERROR_INSUFFICIENT_BUFFER) {
+			err = 0;
+			buffer = malloc(needed);
+			torture_assert(tctx, buffer, "malloc failed");
+			if (!EnumPrintProcessorDatatypes(servername, "Windows NT x86", levels[i], buffer, needed, &needed, &returned)) {
+				err = GetLastError();
+			}
+		}
+		if (err) {
+			sprintf(tmp, "EnumPrintProcessorDatatypes failed level %d on [%s] (buffer size = %d), error: %s\n",
+				levels[i], servername, needed, errstr(err));
+			if (success[i]) {
+				torture_fail(tctx, tmp);
+			} else {
+				torture_warning(tctx, tmp);
+			}
+		}
+
+		free(buffer);
+		buffer = NULL;
+	}
+
+	return TRUE;
+}
+
+/****************************************************************************
+****************************************************************************/
+
+static BOOL test_GetPrinter(struct torture_context *tctx,
+			    LPSTR printername,
+			    HANDLE handle)
+{
+	DWORD levels[]  = { 1, 2, 3, 4, 5, 6, 7, 8 };
+	DWORD success[] = { 1, 1, 1, 1, 1, 1, 1, 1 };
+	DWORD i;
+	LPBYTE buffer = NULL;
+
+	for (i=0; i < ARRAY_SIZE(levels); i++) {
+
+		DWORD needed = 0;
+		DWORD err = 0;
+		char tmp[1024];
+
+		torture_comment(tctx, "Testing GetPrinter level %d", levels[i]);
+
+		GetPrinter(handle, levels[i], NULL, 0, &needed);
+		err = GetLastError();
+		if (err == ERROR_INSUFFICIENT_BUFFER) {
+			err = 0;
+			buffer = malloc(needed);
+			torture_assert(tctx, buffer, "malloc failed");
+			if (!GetPrinter(handle, levels[i], buffer, needed, &needed)) {
+				err = GetLastError();
+			}
+		}
+		if (err) {
+			sprintf(tmp, "GetPrinter failed level %d on [%s] (buffer size = %d), error: %s\n",
+				levels[i], printername, needed, errstr(err));
+			if (success[i]) {
+				torture_fail(tctx, tmp);
+			} else {
+				torture_warning(tctx, tmp);
+			}
+		}
+
+		free(buffer);
+		buffer = NULL;
+	}
+
+	return TRUE;
+}
+
+/****************************************************************************
+****************************************************************************/
+
+static BOOL test_GetPrinterDriver(struct torture_context *tctx,
+				  LPSTR printername,
+				  HANDLE handle)
+{
+	DWORD levels[]  = { 1, 2, 3, 4, 5, 6, 8, 101};
+	DWORD success[] = { 1, 1, 1, 1, 1, 1, 1, 1 };
+	DWORD i;
+	LPBYTE buffer = NULL;
+
+	for (i=0; i < ARRAY_SIZE(levels); i++) {
+
+		DWORD needed = 0;
+		DWORD err = 0;
+		char tmp[1024];
+
+		torture_comment(tctx, "Testing GetPrinterDriver level %d", levels[i]);
+
+		GetPrinterDriver(handle, "Windows NT x86", levels[i], NULL, 0, &needed);
+		err = GetLastError();
+		if (err == ERROR_INSUFFICIENT_BUFFER) {
+			err = 0;
+			buffer = malloc(needed);
+			torture_assert(tctx, buffer, "malloc failed");
+			if (!GetPrinterDriver(handle, "Windows NT x86", levels[i], buffer, needed, &needed)) {
+				err = GetLastError();
+			}
+		}
+		if (err) {
+			sprintf(tmp, "GetPrinterDriver failed level %d on [%s] (buffer size = %d), error: %s\n",
+				levels[i], printername, needed, errstr(err));
+			if (success[i]) {
+				torture_fail(tctx, tmp);
+			} else {
+				torture_warning(tctx, tmp);
+			}
+		}
+
+		free(buffer);
+		buffer = NULL;
+	}
+
+	return TRUE;
+}
+
+
+/****************************************************************************
+****************************************************************************/
+
+static BOOL test_EnumJobs(struct torture_context *tctx,
+			  LPSTR printername,
+			  HANDLE handle)
+{
+	DWORD levels[]  = { 1, 2, 3, 4 };
+	DWORD success[] = { 1, 1, 1, 1 };
+	DWORD i;
+	LPBYTE buffer = NULL;
+
+	for (i=0; i < ARRAY_SIZE(levels); i++) {
+
+		DWORD needed = 0;
+		DWORD returned = 0;
+		DWORD err = 0;
+		char tmp[1024];
+
+		torture_comment(tctx, "Testing EnumJobs level %d", levels[i]);
+
+		EnumJobs(handle, 0, 100, levels[i], NULL, 0, &needed, &returned);
+		err = GetLastError();
+		if (err == ERROR_INSUFFICIENT_BUFFER) {
+			err = 0;
+			buffer = malloc(needed);
+			torture_assert(tctx, buffer, "malloc failed");
+			if (!EnumJobs(handle, 0, 100, levels[i], buffer, needed, &needed, &returned)) {
+				err = GetLastError();
+			}
+		}
+		if (err) {
+			sprintf(tmp, "EnumJobs failed level %d on [%s] (buffer size = %d), error: %s\n",
+				levels[i], printername, needed, errstr(err));
+			if (success[i]) {
+				torture_fail(tctx, tmp);
+			} else {
+				torture_warning(tctx, tmp);
+			}
+		}
+
+		free(buffer);
+		buffer = NULL;
+	}
+
+	return TRUE;
+}
+
+/****************************************************************************
+****************************************************************************/
+
+static BOOL test_OnePrinter(struct torture_context *tctx,
+			    LPSTR printername)
+{
+	HANDLE handle;
+	BOOL ret = TRUE;
+
+	torture_comment(tctx, "Testing Printer %s", printername);
+
+	ret &= test_OpenPrinter(tctx, printername, &handle);
+	ret &= test_GetPrinter(tctx, printername, handle);
+	ret &= test_GetPrinterDriver(tctx, printername, handle);
+	ret &= test_EnumForms(tctx, printername, handle);
+	ret &= test_EnumJobs(tctx, printername, handle);
+	ret &= test_ClosePrinter(tctx, handle);
+
+	return ret;
+}
+
+/****************************************************************************
+****************************************************************************/
+
+static BOOL test_OneDriver(struct torture_context *tctx,
+			   LPSTR printername,
+			   LPSTR drivername)
+{
+	return TRUE;
+}
+
+/****************************************************************************
+****************************************************************************/
+
+static BOOL test_EachDriver(struct torture_context *tctx,
+			    LPSTR servername)
+{
+	return TRUE;
+}
+
+/****************************************************************************
+****************************************************************************/
+
+static BOOL test_EachPrinter(struct torture_context *tctx,
+			     LPSTR servername)
+{
+	DWORD needed = 0;
+	DWORD returned = 0;
+	DWORD err = 0;
+	char tmp[1024];
+	DWORD i;
+	DWORD flags = PRINTER_ENUM_NAME;
+	PPRINTER_INFO_1 buffer = NULL;
+
+	torture_comment(tctx, "Testing EnumPrinters level %d", 1);
+
+	EnumPrinters(flags, servername, 1, NULL, 0, &needed, &returned);
+	err = GetLastError();
+	if (err == ERROR_INSUFFICIENT_BUFFER) {
+		err = 0;
+		buffer = (PPRINTER_INFO_1)malloc(needed);
+		torture_assert(tctx, buffer, "malloc failed");
+		if (!EnumPrinters(flags, servername, 1, (LPBYTE)buffer, needed, &needed, &returned)) {
+			err = GetLastError();
+		}
+	}
+	if (err) {
+		sprintf(tmp, "EnumPrinters failed level %d on [%s] (buffer size = %d), error: %s\n",
+			1, servername, needed, errstr(err));
+		torture_fail(tctx, tmp);
+	}
+
+	for (i=0; i < returned; i++) {
+		torture_assert(tctx, test_OnePrinter(tctx, buffer[i].pName),
+			"failed to test one printer");
+	}
+
+	free(buffer);
+
+	return TRUE;
+}
+
+/****************************************************************************
+****************************************************************************/
+
+static BOOL test_GetPrintProcessorDirectory(struct torture_context *tctx,
+					    LPSTR servername)
+{
+	DWORD levels[]  = { 1 };
+	DWORD success[] = { 1 };
+	DWORD i;
+	LPBYTE buffer = NULL;
+
+	for (i=0; i < ARRAY_SIZE(levels); i++) {
+
+		DWORD needed = 0;
+		DWORD err = 0;
+		char tmp[1024];
+
+		torture_comment(tctx, "Testing GetPrintProcessorDirectory level %d", levels[i]);
+
+		GetPrintProcessorDirectory(servername, "Windows NT x86", levels[i], NULL, 0, &needed);
+		err = GetLastError();
+		if (err == ERROR_INSUFFICIENT_BUFFER) {
+			err = 0;
+			buffer = malloc(needed);
+			torture_assert(tctx, buffer, "malloc failed");
+			if (!GetPrintProcessorDirectory(servername, "Windows NT x86", levels[i], buffer, needed, &needed)) {
+				err = GetLastError();
+			}
+		}
+		if (err) {
+			sprintf(tmp, "GetPrintProcessorDirectory failed level %d on [%s] (buffer size = %d), error: %s\n",
+				levels[i], servername, needed, errstr(err));
+			if (success[i]) {
+				torture_fail(tctx, tmp);
+			} else {
+				torture_warning(tctx, tmp);
+			}
+		}
+
+		free(buffer);
+		buffer = NULL;
+	}
+
+	return TRUE;
+}
+
+/****************************************************************************
+****************************************************************************/
+
+static BOOL test_GetPrinterDriverDirectory(struct torture_context *tctx,
+					   LPSTR servername)
+{
+	DWORD levels[]  = { 1 };
+	DWORD success[] = { 1 };
+	DWORD i;
+	LPBYTE buffer = NULL;
+
+	for (i=0; i < ARRAY_SIZE(levels); i++) {
+
+		DWORD needed = 0;
+		DWORD err = 0;
+		char tmp[1024];
+
+		torture_comment(tctx, "Testing GetPrinterDriverDirectory level %d", levels[i]);
+
+		GetPrinterDriverDirectory(servername, "Windows NT x86", levels[i], NULL, 0, &needed);
+		err = GetLastError();
+		if (err == ERROR_INSUFFICIENT_BUFFER) {
+			err = 0;
+			buffer = malloc(needed);
+			torture_assert(tctx, buffer, "malloc failed");
+			if (!GetPrinterDriverDirectory(servername, "Windows NT x86", levels[i], buffer, needed, &needed)) {
+				err = GetLastError();
+			}
+		}
+		if (err) {
+			sprintf(tmp, "GetPrinterDriverDirectory failed level %d on [%s] (buffer size = %d), error: %s\n",
+				levels[i], servername, needed, errstr(err));
+			if (success[i]) {
+				torture_fail(tctx, tmp);
+			} else {
+				torture_warning(tctx, tmp);
+			}
+		}
+
+		free(buffer);
+		buffer = NULL;
+	}
+
+	return TRUE;
+}
+
+
+/****************************************************************************
+****************************************************************************/
+
+int main(int argc, char *argv[])
+{
+	BOOL ret = FALSE;
+	LPSTR servername;
+	HANDLE handle;
+	struct torture_context *tctx;
+
+	if (argc < 2) {
+		fprintf(stderr, "usage: %s <servername> [print]\n", argv[0]);
+		exit(-1);
+	}
+
+	tctx = malloc(sizeof(struct torture_context));
+	if (!tctx) {
+		fprintf(stderr, "out of memory\n");
+		exit(-1);
+	}
+	memset(tctx, '\0', sizeof(*tctx));
+
+	servername = argv[1];
+
+	if (argc >= 3) {
+		if (strcmp(argv[2], "print") == 0) {
+			tctx->print = TRUE;
+		}
+	}
+
+	ret &= test_EnumPrinters(tctx, servername);
+	ret &= test_EnumDrivers(tctx, servername);
+	ret &= test_OpenPrinter(tctx, servername, &handle);
+	ret &= test_EnumForms(tctx, servername, handle);
+	ret &= test_ClosePrinter(tctx, handle);
+	ret &= test_EnumPorts(tctx, servername);
+	ret &= test_EnumMonitors(tctx, servername);
+	ret &= test_EnumPrintProcessors(tctx, servername);
+	ret &= test_EnumPrintProcessorDatatypes(tctx, servername);
+	ret &= test_GetPrintProcessorDirectory(tctx, servername);
+	ret &= test_GetPrinterDriverDirectory(tctx, servername);
+	ret &= test_EachPrinter(tctx, servername);
+	ret &= test_EachDriver(tctx, servername);
+
+	if (!ret) {
+		if (tctx->last_reason) {
+			fprintf(stderr, "failed: %s\n", tctx->last_reason);
+		}
+		free(tctx);
+		return -1;
+	}
+
+	printf("%s run successfully\n", argv[0]);
+
+	free(tctx);
+	return 0;
+}

testprogs/win32/spoolss/spoolss.h

@@ -0,0 +1,50 @@
+/*
+   Unix SMB/CIFS implementation.
+   test suite for spoolss rpc operations
+
+   Copyright (C) Guenther Deschner 2009
+
+   This program is free software; you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation; either version 3 of the License, or
+   (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+
+   You should have received a copy of the GNU General Public License
+   along with this program.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#if 0
+#include "lib/replace/replace.h"
+#endif
+
+#include <windows.h>
+#include <stdio.h>
+
+#include "error.h"
+
+#if 0
+#include "lib/talloc/talloc.h"
+#include "libcli/util/ntstatus.h"
+#include "lib/torture/torture.h"
+#endif
+
+#ifndef ARRAY_SIZE
+#define ARRAY_SIZE(a) (sizeof(a)/sizeof(a[0]))
+#endif
+
+#ifndef true
+#define true TRUE
+#endif
+
+#ifndef false
+#define false FALSE
+#endif
+
+#ifndef PRINTER_ENUM_NAME
+#define PRINTER_ENUM_NAME 8
+#endif

testprogs/win32/spoolss/string.h

@@ -0,0 +1,15 @@
+/* __location__ macro replacement taken from talloc.h */
+
+/*
+  this uses a little trick to allow __LINE__ to be stringified
+*/
+#ifndef __location__
+#define __STRING_LINE1__(s)    #s
+#define __STRING_LINE2__(s)   __STRING_LINE1__(s)
+#define __STRING_LINE3__  __STRING_LINE2__(__LINE__)
+#define __location__ __FILE__ ":" __STRING_LINE3__
+#endif
+
+#ifndef __STRING
+#define __STRING(s) #s
+#endif

testprogs/win32/spoolss/torture.c

@@ -0,0 +1,106 @@
+/*
+   Unix SMB/CIFS implementation.
+   SMB torture UI functions
+
+   Copyright (C) Jelmer Vernooij 2006
+
+   This program is free software; you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation; either version 3 of the License, or
+   (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+
+   You should have received a copy of the GNU General Public License
+   along with this program.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#include "spoolss.h"
+#include "torture.h"
+
+/****************************************************************************
+****************************************************************************/
+
+void torture_warning(struct torture_context *context, const char *comment, ...)
+{
+	va_list ap;
+	char tmp[1024];
+
+#if 0
+	if (!context->results->ui_ops->warning)
+		return;
+#endif
+
+	va_start(ap, comment);
+	if (vsprintf(tmp, comment, ap) == -1) {
+		return;
+	}
+	va_end(ap);
+
+	fprintf(stderr, "WARNING: %s\n", tmp);
+#if 0
+	context->results->ui_ops->warning(context, tmp);
+
+	free(tmp);
+#endif
+}
+
+/****************************************************************************
+****************************************************************************/
+
+void torture_result(struct torture_context *context,
+		    enum torture_result result, const char *fmt, ...)
+{
+	va_list ap;
+	char tmp[1024];
+
+	va_start(ap, fmt);
+
+	if (context->last_reason) {
+		torture_warning(context, "%s", context->last_reason);
+		free(context->last_reason);
+		context->last_reason = NULL;
+	}
+
+	context->last_result = result;
+	if (vsprintf(tmp, fmt, ap) == -1) {
+		return;
+	}
+	context->last_reason = malloc(sizeof(tmp));
+	if (!context->last_reason) {
+		return;
+	}
+	memcpy(context->last_reason, tmp, sizeof(tmp));
+
+	va_end(ap);
+}
+
+/****************************************************************************
+****************************************************************************/
+
+void torture_comment(struct torture_context *context, const char *comment, ...)
+{
+	va_list ap;
+	char tmp[1024];
+#if 0
+	if (!context->results->ui_ops->comment)
+		return;
+#endif
+	va_start(ap, comment);
+	if (vsprintf(tmp, comment, ap) == -1) {
+		return;
+	}
+	va_end(ap);
+
+#if 0
+	context->results->ui_ops->comment(context, tmp);
+#endif
+	fprintf(stdout, "%s\n", tmp);
+
+#if 0
+	free(tmp);
+#endif
+}

testprogs/win32/spoolss/torture.h

@@ -0,0 +1,91 @@
+/*
+   Unix SMB/CIFS implementation.
+   SMB torture UI functions
+
+   Copyright (C) Jelmer Vernooij 2006
+
+   This program is free software; you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation; either version 3 of the License, or
+   (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+
+   You should have received a copy of the GNU General Public License
+   along with this program.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#ifndef __TORTURE_UI_H__
+#define __TORTURE_UI_H__
+
+/****************************************************************************
+****************************************************************************/
+
+enum torture_result {
+	TORTURE_OK=0,
+	TORTURE_FAIL=1,
+	TORTURE_ERROR=2,
+	TORTURE_SKIP=3
+};
+
+struct torture_context {
+	enum torture_result last_result;
+	char *last_reason;
+	BOOL print;
+};
+
+/****************************************************************************
+****************************************************************************/
+
+#define torture_assert(torture_ctx,expr,cmt) do {\
+	if (!(expr)) {\
+		torture_result(torture_ctx, TORTURE_FAIL, __location__": Expression `%s' failed: %s", __STRING(expr), cmt); \
+		return false;\
+	}\
+} while(0)
+
+#define torture_assert_str_equal(torture_ctx,got,expected,cmt)\
+	do { const char *__got = (got), *__expected = (expected); \
+	if (strcmp_safe(__got, __expected) != 0) { \
+		torture_result(torture_ctx, TORTURE_FAIL, \
+			__location__": "#got" was %s, expected %s: %s", \
+			__got, __expected, cmt); \
+		return false; \
+	} \
+	} while(0)
+
+#define torture_assert_int_equal(torture_ctx,got,expected,cmt)\
+	do { int __got = (got), __expected = (expected); \
+	if (__got != __expected) { \
+		torture_result(torture_ctx, TORTURE_FAIL, \
+			__location__": "#got" was %d, expected %d: %s", \
+			__got, __expected, cmt); \
+		return false; \
+	} \
+	} while(0)
+
+#define torture_assert_mem_equal(torture_ctx,got,expected,len,cmt)\
+	do { const void *__got = (got), *__expected = (expected); \
+	if (memcmp(__got, __expected, len) != 0) { \
+		torture_result(torture_ctx, TORTURE_FAIL, \
+			__location__": "#got" of len %d did not match "#expected": %s", (int)len, cmt); \
+		return false; \
+	} \
+	} while(0)
+
+#define torture_skip(torture_ctx,cmt) do {\
+		torture_result(torture_ctx, TORTURE_SKIP, __location__": %s", cmt);\
+		return true; \
+	} while(0)
+
+#define torture_fail(torture_ctx,cmt) do {\
+		torture_result(torture_ctx, TORTURE_FAIL, __location__": %s", cmt);\
+		return false; \
+	} while (0)
+
+#include "torture_proto.h"
+
+#endif

testprogs/win32/spoolss/torture_proto.h

@@ -0,0 +1,32 @@
+#ifndef __TORTURE_PROTO_H__
+#define __TORTURE_PROTO_H__
+
+#undef _PRINTF_ATTRIBUTE
+#define _PRINTF_ATTRIBUTE(a1, a2) PRINTF_ATTRIBUTE(a1, a2)
+/* This file was automatically generated by mkproto.pl. DO NOT EDIT */
+
+/* this file contains prototypes for functions that are private
+ * to this subsystem or library. These functions should not be
+ * used outside this particular subsystem! */
+
+
+/* The following definitions come from torture.c  */
+
+
+/****************************************************************************
+****************************************************************************/
+void torture_warning(struct torture_context *context, const char *comment, ...);
+
+/****************************************************************************
+****************************************************************************/
+void torture_result(struct torture_context *context,
+		    enum torture_result result, const char *fmt, ...);
+
+/****************************************************************************
+****************************************************************************/
+void torture_comment(struct torture_context *context, const char *comment, ...);
+#undef _PRINTF_ATTRIBUTE
+#define _PRINTF_ATTRIBUTE(a1, a2)
+
+#endif /* __TORTURE_PROTO_H__ */
+