haiku.git

/*
 * Copyright 2001-2015, Haiku, Inc. All rights reserved.
 * Distributed under the terms of the MIT License.
 *
 * Authors:
 *		Ithamar R. Adema
 *		Michael Pfeiffer
 */


#include "PrintServerApp.h"

#include <stdio.h>
#include <unistd.h>

#include <Alert.h>
#include <Autolock.h>
#include <Catalog.h>
#include <Directory.h>
#include <File.h>
#include <FindDirectory.h>
#include <image.h>
#include <Locale.h>
#include <Mime.h>
#include <NodeInfo.h>
#include <NodeMonitor.h>
#include <Path.h>
#include <Roster.h>
#include <PrintJob.h>
#include <String.h>

#include "BeUtils.h"
#include "Printer.h"
#include "pr_server.h"
#include "Transport.h"


#undef B_TRANSLATION_CONTEXT
#define B_TRANSLATION_CONTEXT "PrintServerApp"


typedef struct _printer_data {
	char defaultPrinterName[256];
} printer_data_t;


static const char* kSettingsName = "print_server_settings";

BLocker *gLock = NULL;


/*!	Main entry point of print_server.

	@returns B_OK if application was started, or an errorcode if
			the application failed to start.
*/
int
main()
{
	gLock = new BLocker();

	status_t status = B_OK;
	PrintServerApp printServer(&status);
	if (status == B_OK)
		printServer.Run();

	delete gLock;
	return status;
}


/*!	Constructor for print_server's application class. Retrieves the
	name of the default printer from storage, caches the icons for
	a selected printer.

	@param err Pointer to status_t for storing result of application
			initialisation.
	@see BApplication
*/
PrintServerApp::PrintServerApp(status_t* err)
	:
	Inherited(PSRV_SIGNATURE_TYPE, true, err),
	fDefaultPrinter(NULL),
#ifdef HAIKU_TARGET_PLATFORM_HAIKU
	fIconSize(0),
	fSelectedIcon(NULL),
#else
	fSelectedIconMini(NULL),
	fSelectedIconLarge(NULL),
#endif
	fReferences(0),
	fHasReferences(0),
	fUseConfigWindow(true),
	fFolder(NULL)
{
	fSettings = Settings::GetSettings();
	LoadSettings();

	if (*err != B_OK)
		return;

	fHasReferences = create_sem(1, "has_references");

	// Build list of transport addons
	Transport::Scan(B_USER_NONPACKAGED_ADDONS_DIRECTORY);
	Transport::Scan(B_USER_ADDONS_DIRECTORY);
	Transport::Scan(B_SYSTEM_NONPACKAGED_ADDONS_DIRECTORY);
	Transport::Scan(B_SYSTEM_ADDONS_DIRECTORY);

	SetupPrinterList();
	RetrieveDefaultPrinter();

	// Cache icons for selected printer
	BMimeType type(PSRV_PRINTER_FILETYPE);
	type.GetIcon(&fSelectedIcon, &fIconSize);

	PostMessage(PSRV_PRINT_SPOOLED_JOB);
		// Start handling of spooled files
}


PrintServerApp::~PrintServerApp()
{
	SaveSettings();
	delete fSettings;
}


bool
PrintServerApp::QuitRequested()
{
	// don't quit when user types Command+Q!
	BMessage* m = CurrentMessage();
	bool shortcut;
	if (m != NULL && m->FindBool("shortcut", &shortcut) == B_OK && shortcut)
		return false;

	if (!Inherited::QuitRequested())
		return false;

	// Stop watching the folder
	delete fFolder; fFolder = NULL;

	// Release all printers
	Printer* printer;
	while ((printer = Printer::At(0)) != NULL) {
		printer->AbortPrintThread();
		UnregisterPrinter(printer);
	}

	// Wait for printers
	if (fHasReferences > 0) {
		acquire_sem(fHasReferences);
		delete_sem(fHasReferences);
		fHasReferences = 0;
	}

	delete [] fSelectedIcon;
	fSelectedIcon = NULL;

	return true;
}


void
PrintServerApp::Acquire()
{
	if (atomic_add(&fReferences, 1) == 0)
		acquire_sem(fHasReferences);
}


void
PrintServerApp::Release()
{
	if (atomic_add(&fReferences, -1) == 1)
		release_sem(fHasReferences);
}


void
PrintServerApp::RegisterPrinter(BDirectory* printer)
{
	BString transport, address, connection, state;

	if (printer->ReadAttrString(PSRV_PRINTER_ATTR_TRANSPORT, &transport) == B_OK
		&& printer->ReadAttrString(PSRV_PRINTER_ATTR_TRANSPORT_ADDR, &address)
			== B_OK
		&& printer->ReadAttrString(PSRV_PRINTER_ATTR_CNX, &connection) == B_OK
		&& printer->ReadAttrString(PSRV_PRINTER_ATTR_STATE, &state) == B_OK
		&& state == "free") {
 		BAutolock lock(gLock);
		if (lock.IsLocked()) {
			// check if printer is already registered
			node_ref node;
			if (printer->GetNodeRef(&node) != B_OK)
				return;

			if (Printer::Find(&node) != NULL)
				return;

			// register new printer
			Resource* resource = fResourceManager.Allocate(transport.String(),
				address.String(), connection.String());
			AddHandler(new Printer(printer, resource));
		 	Acquire();
		}
	}
}


void
PrintServerApp::UnregisterPrinter(Printer* printer)
{
	RemoveHandler(printer);
	Printer::Remove(printer);
	printer->Release();
}


void
PrintServerApp::NotifyPrinterDeletion(Printer* printer)
{
	BAutolock lock(gLock);
	if (lock.IsLocked()) {
		fResourceManager.Free(printer->GetResource());
		Release();
	}
}


void
PrintServerApp::EntryCreated(node_ref* node, entry_ref* entry)
{
	BEntry printer(entry);
	if (printer.InitCheck() == B_OK && printer.IsDirectory()) {
		BDirectory dir(&printer);
		if (dir.InitCheck() == B_OK) RegisterPrinter(&dir);
	}
}


void
PrintServerApp::EntryRemoved(node_ref* node)
{
	Printer* printer = Printer::Find(node);
	if (printer) {
		if (printer == fDefaultPrinter)
			fDefaultPrinter = NULL;
		UnregisterPrinter(printer);
	}
}


void
PrintServerApp::AttributeChanged(node_ref* node)
{
	BDirectory printer(node);
	if (printer.InitCheck() == B_OK)
		RegisterPrinter(&printer);
}


/*!	This method builds the internal list of printers from disk. It
	also installs a node monitor to be sure that the list keeps
	updated with the definitions on disk.

	@return B_OK if successful, or an errorcode if failed.
*/
status_t
PrintServerApp::SetupPrinterList()
{
	// Find directory containing printer definition nodes
	BPath path;
	status_t status = find_directory(B_USER_PRINTERS_DIRECTORY, &path);
	if (status != B_OK)
		return status;

	// Directory has to exist in order to watch it
	mode_t mode = 0777;
	create_directory(path.Path(), mode);

	BDirectory dir(path.Path());
	status = dir.InitCheck();
	if (status != B_OK)
		return status;

	// Register printer definition nodes
	BEntry entry;
	while(dir.GetNextEntry(&entry) == B_OK) {
		if (!entry.IsDirectory())
			continue;

		BDirectory node(&entry);
		BNodeInfo info(&node);
		char buffer[256];
		if (info.GetType(buffer) == B_OK
			&& strcmp(buffer, PSRV_PRINTER_FILETYPE) == 0) {
			RegisterPrinter(&node);
		}
	}

	// Now we are ready to start node watching
	fFolder = new FolderWatcher(this, dir, true);
	fFolder->SetListener(this);

	return B_OK;
}


/*!	Message handling method for print_server application class.

	@param msg Actual message sent to application class.
*/
void
PrintServerApp::MessageReceived(BMessage* msg)
{
	switch(msg->what) {
		case PSRV_GET_ACTIVE_PRINTER:
		case PSRV_MAKE_PRINTER_ACTIVE_QUIETLY:
		case PSRV_MAKE_PRINTER_ACTIVE:
		case PSRV_MAKE_PRINTER:
		case PSRV_SHOW_PAGE_SETUP:
		case PSRV_SHOW_PRINT_SETUP:
		case PSRV_PRINT_SPOOLED_JOB:
		case PSRV_GET_DEFAULT_SETTINGS:
			Handle_BeOSR5_Message(msg);
			break;

		case B_GET_PROPERTY:
		case B_SET_PROPERTY:
		case B_CREATE_PROPERTY:
		case B_DELETE_PROPERTY:
		case B_COUNT_PROPERTIES:
		case B_EXECUTE_PROPERTY:
			HandleScriptingCommand(msg);
			break;

		default:
			Inherited::MessageReceived(msg);
	}
}


/*!	Creates printer definition/spool directory. It sets the
	attributes of the directory to the values passed and calls
	the driver's add_printer method to handle any configuration
	needed.

	@param printerName Name of printer to create.
	@param driverName Name of driver to use for this printer.
	@param connection "Local" or "Network".
	@param transportName Name of transport driver to use.
	@param transportPath Configuration data for transport driver.
*/
status_t
PrintServerApp::CreatePrinter(const char* printerName, const char* driverName,
	const char* connection, const char* transportName,
	const char* transportPath)
{
	// Find directory containing printer definitions
	BPath path;
	status_t status = find_directory(B_USER_PRINTERS_DIRECTORY, &path, true,
		NULL);
	if (status != B_OK)
		return status;

	// Create our printer definition/spool directory
	BDirectory printersDir(path.Path());
	BDirectory printer;

	status = printersDir.CreateDirectory(printerName, &printer);
	if (status == B_FILE_EXISTS) {
		printer.SetTo(&printersDir, printerName);

		BString info;
		char type[B_MIME_TYPE_LENGTH];
		BNodeInfo(&printer).GetType(type);
		if (strcmp(PSRV_PRINTER_FILETYPE, type) == 0) {
			BPath path;
			if (Printer::FindPathToDriver(printerName, &path) == B_OK) {
				if (fDefaultPrinter) {
					// the printer exists, but is not the default printer
					if (strcmp(fDefaultPrinter->Name(), printerName) != 0)
						status = B_OK;
					return status;
				}
				// the printer exists, but no default at all
				return B_OK;
			} else {
				info.SetTo(B_TRANSLATE(
					"A printer with that name already exists, "
					"but its driver could not be found! Replace?"));
			}
		} else {
			info.SetTo(B_TRANSLATE(
				"A printer with that name already exists, "
				"but it's not usable at all! Replace?"));
		}

		if (info.Length() != 0) {
			BAlert *alert = new BAlert("Info", info.String(),
				B_TRANSLATE("Cancel"), B_TRANSLATE("OK"));
			alert->SetShortcut(0, B_ESCAPE);
			if (alert->Go() == 0)
				return status;
		}
	} else if (status != B_OK) {
		return status;
	}

	// Set its type to a printer
	BNodeInfo info(&printer);
	info.SetType(PSRV_PRINTER_FILETYPE);

	// Store the settings in its attributes
	printer.WriteAttr(PSRV_PRINTER_ATTR_PRT_NAME, B_STRING_TYPE, 0, printerName,
		::strlen(printerName) + 1);
	printer.WriteAttr(PSRV_PRINTER_ATTR_DRV_NAME, B_STRING_TYPE, 0, driverName,
		::strlen(driverName) + 1);
	printer.WriteAttr(PSRV_PRINTER_ATTR_TRANSPORT, B_STRING_TYPE, 0,
		transportName, ::strlen(transportName) + 1);
	printer.WriteAttr(PSRV_PRINTER_ATTR_TRANSPORT_ADDR, B_STRING_TYPE, 0,
		transportPath, ::strlen(transportPath) + 1);
	printer.WriteAttr(PSRV_PRINTER_ATTR_CNX, B_STRING_TYPE, 0, connection,
		::strlen(connection) + 1);

	status = Printer::ConfigurePrinter(driverName, printerName);
	if (status == B_OK) {
		// Notify printer driver that a new printer definition node
		// has been created.
		printer.WriteAttr(PSRV_PRINTER_ATTR_STATE, B_STRING_TYPE, 0, "free",
			::strlen("free")+1);
	}

	if (status != B_OK) {
		BEntry entry;
		if (printer.GetEntry(&entry) == B_OK)
			entry.Remove();
	}

	return status;
}


/*!	Makes a new printer the active printer. This is done simply
	by changing our class attribute fDefaultPrinter, and changing
	the icon of the BNode for the printer. Ofcourse, we need to
	change the icon of the "old" default printer first back to a
	"non-active" printer icon first.

	@param printerName Name of the new active printer.
	@return B_OK on success, or error code otherwise.
*/
status_t
PrintServerApp::SelectPrinter(const char* printerName)
{
	// Find the node of the "old" default printer
	BNode node;
	if (fDefaultPrinter != NULL
		&& FindPrinterNode(fDefaultPrinter->Name(), node) == B_OK) {
		// and remove the custom icon
		BNodeInfo info(&node);
		info.SetIcon(NULL, B_MINI_ICON);
		info.SetIcon(NULL, B_LARGE_ICON);
	}

	// Find the node for the new default printer
	status_t status = FindPrinterNode(printerName, node);
	if (status == B_OK) {
		// and add the custom icon
		BNodeInfo info(&node);
		info.SetIcon(fSelectedIcon, fIconSize);
	}

	fDefaultPrinter = Printer::Find(printerName);
	StoreDefaultPrinter();
		// update our pref file
	be_roster->Broadcast(new BMessage(B_PRINTER_CHANGED));

	return status;
}


//! Handles calling the printer drivers for printing a spooled job.
void
PrintServerApp::HandleSpooledJobs()
{
	const int n = Printer::CountPrinters();
	for (int i = 0; i < n; i ++) {
		Printer* printer = Printer::At(i);
		printer->HandleSpooledJob();
	}
}


/*!	Loads the currently selected printer from a private settings
	file.

	@return Error code on failore, or B_OK if all went fine.
*/
status_t
PrintServerApp::RetrieveDefaultPrinter()
{
	fDefaultPrinter = Printer::Find(fSettings->DefaultPrinter());
	return B_OK;
}


/*!	Stores the currently selected printer in a private settings
	file.

	@return Error code on failore, or B_OK if all went fine.
*/
status_t
PrintServerApp::StoreDefaultPrinter()
{
	if (fDefaultPrinter)
		fSettings->SetDefaultPrinter(fDefaultPrinter->Name());
	else
		fSettings->SetDefaultPrinter("");
	return B_OK;
}


/*!	Find the BNode representing the specified printer. It searches
	*only* in the users printer definitions.

	@param name Name of the printer to look for.
	@param node BNode to set to the printer definition node.
	@return B_OK if found, an error code otherwise.
*/
status_t
PrintServerApp::FindPrinterNode(const char* name, BNode& node)
{
	// Find directory containing printer definitions
	BPath path;
	status_t status = find_directory(B_USER_PRINTERS_DIRECTORY, &path, true,
		NULL);
	if (status != B_OK)
		return status;

	path.Append(name);
	return node.SetTo(path.Path());
}


bool 
PrintServerApp::OpenSettings(BFile& file, const char* name, bool forReading)
{
	BPath path;
	uint32 openMode = forReading ? B_READ_ONLY : B_CREATE_FILE | B_ERASE_FILE
		| B_WRITE_ONLY;
	return find_directory(B_USER_SETTINGS_DIRECTORY, &path) == B_OK
		&& path.Append(name) == B_OK
		&& file.SetTo(path.Path(), openMode) == B_OK;
}


void 
PrintServerApp::LoadSettings()
{
	BFile file;
	if (OpenSettings(file, kSettingsName, true)) {
		fSettings->Load(&file);
		fUseConfigWindow = fSettings->UseConfigWindow();
	}
}


void 
PrintServerApp::SaveSettings()
{
	BFile file;
	if (OpenSettings(file, kSettingsName, false)) {
		fSettings->SetUseConfigWindow(fUseConfigWindow);
		fSettings->Save(&file);
	}
}