Initial import of sane-backends version 1.0.24-1.2

1 files changed, 528 insertions, 0 deletions

diff --git a/sanei/sanei_DomainOS.c b/sanei/sanei_DomainOS.c
new file mode 100755
index 0000000..5473151
--- /dev/null
+++ b/sanei/sanei_DomainOS.c
@@ -0,0 +1,528 @@
+/* sane - Scanner Access Now Easy.
+   Copyright (C) 1996, 1997 David Mosberger-Tang
+   This file is part of the SANE package.
+
+   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 2 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, write to the Free Software
+   Foundation, Inc., 59 Temple Place - Suite 330, Boston,
+   MA 02111-1307, USA.
+
+   As a special exception, the authors of SANE give permission for
+   additional uses of the libraries contained in this release of SANE.
+
+   The exception is that, if you link a SANE library with other files
+   to produce an executable, this does not by itself cause the
+   resulting executable to be covered by the GNU General Public
+   License.  Your use of that executable is in no way restricted on
+   account of linking the SANE library code into it.
+
+   This exception does not, however, invalidate any other reasons why
+   the executable file might be covered by the GNU General Public
+   License.
+
+   If you submit changes to SANE to the maintainers to be included in
+   a subsequent release, you agree by submitting the changes that
+   those changes may be distributed with this exception intact.
+
+   If you write modifications of your own for SANE, it is your choice
+   whether to permit this exception to apply to your modifications.
+   If you do not wish that, delete this exception notice.
+
+   This file defines a server for Apollo Domain/OS systems.  It does all
+of the scsi_$ calls that are needed for SANE.  This is necessary because
+Domain/OS will not allow a child process to access a parent's SCSI
+device.  The interface is through a common, mapped area.  Mutex locks
+are used to prevent concurrency problems, and eventcounts are used to
+notify a waiting process that its request has completed.
+
+    This program is intended to support only one device at a time,
+although multiple instances of this program may run concurrently.  It is
+intended that this program be forked/execd by a SANE application, and
+that it will exit when the application exits.
+
+    Upon startup, the program is invoked with the path to an object that
+needs to be mapped for communication.  The parent process will have
+already initialized the 'public' eventcounts and locks, and will be
+waiting for the ResultReady eventcount to be incremented.  After
+initialization, the server will increment this eventcount, and wait for
+an incoming request, which is signified by the CommandAvailable
+eventcount.  This EC will be incremented after another process has
+filled in the parameter area.
+
+DBG levels:
+    0   Error - always printed.
+    1   Basic monitor - print entry to main functions, or errors that are
+         normally suppressed because they are reported at a higher level.
+    2   Medium monitor - show intermediate steps in functions
+    3   Detailed monitor - if its there, print it
+
+*/
+
+#include <assert.h>
+#include <ctype.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include <apollo/base.h>
+#include <apollo/ec2.h>
+#include <apollo/error.h>
+#include <apollo/fault.h>
+#include <apollo/ms.h>
+#include <apollo/mutex.h>
+#include <apollo/pfm.h>
+#include <apollo/scsi.h>
+
+#include "../include/sane/config.h"
+
+#include "../include/sane/sanei_scsi.h"
+
+#include "../include/sane/sanei_debug.h"
+
+#include "sanei_DomainOS.h"
+
+/* Timeout period for SCSI wait, in milliseconds.
+We are using 100 seconds here. */
+#define DomainScsiTimeout 100000
+
+/* Communication Area pointer */
+struct DomainServerCommon *com;
+
+/* Handle for fault handler */
+pfm_$fh_handle_t FaultHandle;
+
+
+static struct
+   {
+   void *DomainSCSIPtr;         /* Pointer to the data block for this device */
+   void *DomainSensePtr;        /* Pointer to the sense area for this device */
+   u_int in_use  : 1;           /* is this DomainFdInfo in use? */
+   u_int fake_fd : 1;           /* is this a fake file descriptor? */
+   scsi_$handle_t scsi_handle;  /* SCSI handle */
+   scsi_$operation_id_t op_id;  /* op_id of current request */
+   } *DomainFdInfo;
+
+/* This function is called error might have occured, but it would be one that I
+don't know how to handle, or never expect to happen.  */
+static void DomainErrorCheck(status_$t status, const char *message)
+   {
+   char *subsystem, *module, *code;
+   short subsystem_length, module_length, code_length;
+
+   if (status.all)
+      {
+      DBG(0, "Unrecoverable Domain/OS Error 0x%08x:  %s\n", status.all, message);
+      error_$find_text(status, &subsystem, &subsystem_length, &module, &module_length, &code, &code_length);
+      if (subsystem_length && module_length && code_length)
+         DBG(0, "%.*s (%.*s/%.*s)\n", code_length, code, subsystem_length, subsystem, module_length, module);
+      exit(EXIT_FAILURE);
+      }
+   }
+
+
+/* This function is the fault handler for the server.  Currently, it only
+handles asynchronous faults.  It always returns to the faulting code, but
+it disables the handler, so that the server can be killed if the parent is
+unable to do so. */
+pfm_$fh_func_val_t FaultHandler(pfm_$fault_rec_t *FaultStatusPtr)
+   {
+   status_$t status;
+
+   DBG(1, "In fault handler, status is %08x\n", FaultStatusPtr->status.all);
+   switch (FaultStatusPtr->status.all)
+      {
+      case fault_$quit:
+         pfm_$release_fault_handler(FaultHandle, &status);
+         DomainErrorCheck(status, "Can't release fault handler");
+         return pfm_$return_to_faulting_code;
+      default:
+         DBG(0, "Unrecognized fault type %08x, exiting\n", FaultStatusPtr->status.all);
+         exit(EXIT_FAILURE);
+      }
+   }
+
+
+static void DomainSCSIOpen(void)
+   {
+   static int num_alloced = 0;
+   int fd;
+   scsi_$handle_t scsi_handle;
+   pinteger len;
+   void *DataBasePtr;
+
+   /* Find fake fd. */
+   for (fd = 0; fd < num_alloced; ++fd)
+      if (!DomainFdInfo[fd].in_use)
+         break;
+
+   /* Acquire the device */
+   DBG(1, "DomainSCSIOpen: dev='%s', fd=%d\n", com->open_path, fd);
+   len = strlen(com->open_path);
+   scsi_$acquire((char *)com->open_path, len, &scsi_handle, &com->CommandStatus);
+   if (com->CommandStatus.all != status_$ok)
+      {
+      /* we have a failure, return an error code, and generate debug output */
+      DBG(1, "DomainSCSIOpen: acquire failed, Domain/OS status is %08x\n", com->CommandStatus.all);
+      error_$print(com->CommandStatus);
+      return;
+      }
+   else
+      {
+      /* device acquired, setup buffers and buffer pointers */
+      DBG(2, "DomainSCSIOpen: acquire OK, handle is %x\n", scsi_handle);
+      /* Create/map the data area */
+      tmpnam(com->open_path);
+      DBG(2, "DomainSCSIOpen: Data block name will be '%s'\n", com->open_path);
+      DataBasePtr = ms_$crmapl(com->open_path, strlen(com->open_path), 0, DomainMaxDataSize + DomainSenseSize, ms_$cowriters, &com->CommandStatus);
+      DomainErrorCheck(com->CommandStatus, "Creating Data Area");
+      assert((((int)DataBasePtr) & 0x3ff) == 0);  /* Relies on Domain/OS mapping new objects on page boundary */
+      DBG(2, "Data Buffer block created at %p, length = 0x%lx\n", DataBasePtr, DomainMaxDataSize + DomainSenseSize);
+      /* Wire the buffer */
+      scsi_$wire(scsi_handle, (void *)DataBasePtr, DomainMaxDataSize + DomainSenseSize, &com->CommandStatus);
+      if (com->CommandStatus.all == status_$ok)
+         {
+         /* success, indicate status */
+         DBG(2, "Buffer wire was successful\n");
+         }
+      else
+         {
+         /* failure, print detail and return code */
+         DBG(1, "Buffer wire failed, Domain/OS status is %08x\n", com->CommandStatus.all);
+         error_$print(com->CommandStatus);
+         return;
+         }
+      }
+
+   if (fd >= num_alloced)
+      {
+      size_t new_size, old_size;
+
+      old_size = num_alloced * sizeof (DomainFdInfo[0]);
+      num_alloced = fd + 8;
+      new_size = num_alloced * sizeof (DomainFdInfo[0]);
+      if (DomainFdInfo)
+         DomainFdInfo = realloc (DomainFdInfo, new_size);
+      else
+         DomainFdInfo = malloc (new_size);
+      memset ((char *) DomainFdInfo + old_size, 0, new_size - old_size);
+      assert(DomainFdInfo);
+      }
+   DomainFdInfo[fd].in_use = 1;
+   DomainFdInfo[fd].scsi_handle = scsi_handle;
+   DomainFdInfo[fd].DomainSCSIPtr = DataBasePtr;
+   DomainFdInfo[fd].DomainSensePtr = ((char *)DataBasePtr) + DomainMaxDataSize;
+   com->fd = fd;
+   }
+
+
+static void DomainSCSIClose(void)
+   {
+   DomainFdInfo[com->fd].in_use = 0;
+   DBG(1, "sanei_scsi_close:  fd=%d\n", com->fd);
+   /* Unwire the buffer */
+   scsi_$unwire(DomainFdInfo[com->fd].scsi_handle, DomainFdInfo[com->fd].DomainSCSIPtr, DomainMaxDataSize + DomainSenseSize, true, &com->CommandStatus);
+   DomainErrorCheck(com->CommandStatus, "Unwiring SCSI buffers");
+   /* Release the device */
+   scsi_$release(DomainFdInfo[com->fd].scsi_handle, &com->CommandStatus);
+   DomainErrorCheck(com->CommandStatus, "Releasing device");
+   /* Unmap the buffer area */
+   ms_$unmap(DomainFdInfo[com->fd].DomainSCSIPtr, DomainMaxDataSize + DomainSenseSize, &com->CommandStatus);
+   DomainErrorCheck(com->CommandStatus, "Unmapping device data area");
+   }
+
+
+/* I have never seen this called, and I'm not sure what to do with it, so I
+guarantee that it will generate a fault, and I can add support for it.  */
+static void DomainSCSIFlushAll(void)
+   {
+   status_$t status;
+
+   DBG(1, "DomainSCSIFlushAll: ()\n");
+   DBG(0, "Error - unimplemented feature in module" "BACKEND_NAME");
+   assert(1==0);
+   }
+
+
+/* This function must only be called from DomainSCSIEnter.  The current
+server architecture requires that the Wait immediately follow the Enter
+command.  */
+static void DomainSCSIWait(void)
+   {
+   int count;
+   char *ascii_wait_status, *ascii_op_status;
+   pinteger return_count;
+   scsi_$op_status_t status_list[1];
+   scsi_$wait_index_t wait_index;
+
+   /* wait for the command completion */
+   wait_index = scsi_$wait(DomainFdInfo[com->fd].scsi_handle, DomainScsiTimeout, true, DomainFdInfo[com->fd].op_id, 1, status_list, &return_count, &com->CommandStatus);
+   DBG(2, " scsi_$wait returned status = %08x\n", com->CommandStatus.all);
+   if (com->CommandStatus.all == status_$ok)
+      {
+      switch (wait_index)
+         {
+         case scsi_device_advance:  ascii_wait_status = "scsi_device_advance"; break;
+         case scsi_timeout:         ascii_wait_status = "scsi_timeout"; break;
+         case scsi_async_fault:     ascii_wait_status = "scsi_async_fault"; break;
+         default:                   ascii_wait_status = "unknown"; break;
+         }
+      DBG(2, " scsi_$wait status is %s, return_count is %d\n", ascii_wait_status, return_count);
+      if (wait_index != scsi_device_advance)
+         {
+         DBG(1, "Error - SCSI timeout, or async fault\n");
+         com->CommandStatus.all = scsi_$operation_timeout;
+         }
+      else for (count = 0; count < return_count; count++)
+         {
+         switch (status_list[count].op_status)
+            {
+            case scsi_good_status:                ascii_op_status = "scsi_good_status"; break;
+            case scsi_check_condition:            ascii_op_status = "scsi_check_condition"; break;
+            case scsi_condition_met:              ascii_op_status = "scsi_condition_met"; break;
+            case scsi_rsv1:                       ascii_op_status = "scsi_rsv1"; break;
+            case scsi_busy:                       ascii_op_status = "scsi_busy"; break;
+            case scsi_rsv2:                       ascii_op_status = "scsi_rsv2"; break;
+            case scsi_rsv3:                       ascii_op_status = "scsi_rsv3"; break;
+            case scsi_rsv4:                       ascii_op_status = "scsi_rsv4"; break;
+            case scsi_intermediate_good:          ascii_op_status = "scsi_intermediate_good"; break;
+            case scsi_rsv5:                       ascii_op_status = "scsi_rsv5"; break;
+            case scsi_intermediate_condition_met: ascii_op_status = "scsi_intermediate_condition_met"; break;
+            case scsi_rsv6:                       ascii_op_status = "scsi_rsv6"; break;
+            case scsi_reservation_conflict:       ascii_op_status = "scsi_reservation_conflict"; break;
+            case scsi_rsv7:                       ascii_op_status = "scsi_rsv7"; break;
+            case scsi_rsv8:                       ascii_op_status = "scsi_rsv8"; break;
+            case scsi_rsv9:                       ascii_op_status = "scsi_rsv9"; break;
+            case scsi_undefined_status:           ascii_op_status = "scsi_undefined_status"; break;
+            default:                              ascii_op_status = "unknown"; break;
+            }
+         DBG(2, " list[%d]: op=%x  cmd_status=%08x, status=%s\n", count, status_list[count].op, status_list[count].cmd_status.all, ascii_op_status);
+         switch (status_list[count].cmd_status.all)
+            {
+            case status_$ok:
+               switch (status_list[count].op_status)
+                  {
+                  case scsi_good_status:
+                     break;
+                  case scsi_busy:
+                     com->CommandStatus.all = status_$ok | 0x80000000;
+                     com->SCSIStatus = scsi_busy;
+                     break;
+                  case scsi_check_condition:
+                     {
+                     static unsigned char scanner_sense_cdb[] = {3, 0, 0, 0, DomainSenseSize, 0};
+                     static scsi_$cdb_t sense_cdb;
+                     static linteger sense_cdb_size;
+                     static scsi_$operation_id_t sense_op_id;
+                     static status_$t sense_status;
+                     static pinteger sense_return_count;
+                     static int temp;
+            
+                     /* Issue the sense command (wire, issue, wait, unwire */
+                     sense_cdb_size = sizeof(scanner_sense_cdb);
+                     memcpy(&sense_cdb, scanner_sense_cdb, sense_cdb_size);
+                     scsi_$do_command_2(DomainFdInfo[com->fd].scsi_handle, sense_cdb, sense_cdb_size, DomainFdInfo[com->fd].DomainSensePtr, DomainSenseSize, scsi_read, &sense_op_id, &sense_status);
+                     DomainErrorCheck(sense_status, "Executing sense command");
+                     scsi_$wait(DomainFdInfo[com->fd].scsi_handle, DomainScsiTimeout, true, sense_op_id, 1, status_list, &sense_return_count, &sense_status);
+                     /* The following debug output is scanner specific */
+                     DBG(2, "Sense information:  Error code=%02x, ASC=%02x, ASCQ=%02x\n", ((u_char *)DomainFdInfo[com->fd].DomainSensePtr)[0], ((char *)DomainFdInfo[com->fd].DomainSensePtr)[0xc], ((char *)DomainFdInfo[com->fd].DomainSensePtr)[0xd]);
+                     DBG(2, " Sense dump:\n");
+                     for (temp = 0; temp < DomainSenseSize; temp++)
+                        DBG(2, " %02x", ((u_char *)DomainFdInfo[com->fd].DomainSensePtr)[temp]);
+                     DBG(2, "\n");
+                     /* see if buffer underrun - ILI/Valid are set, and command was a read */
+                     /* Warning - this might be UMAX specific */
+                     if ((((char *)DomainFdInfo[com->fd].DomainSensePtr)[0] == 0xf0) && (((char *)DomainFdInfo[com->fd].DomainSensePtr)[2] & 0x20) && (com->cdb.g0.cmd == 0x28))
+                        {
+                        /* Warning - the following code is specific to endianness and int size */
+                        /*   Its also very ugly */
+                        DBG(2, "Shortening destination length by %x bytes\n", *(int *)(((char *)DomainFdInfo[com->fd].DomainSensePtr)+3));
+                        com->dst_size -= *(int *)(((char *)DomainFdInfo[com->fd].DomainSensePtr)+3);
+                        DBG(2, "Final dest size is %x\n", com->dst_size);
+                        }
+                     else
+                        {
+                        /* Set this status so that the sense handler can be called */
+                        com->CommandStatus.all = status_$ok | 0x80000000;
+                        com->SCSIStatus = scsi_check_condition;
+                        }
+                     }
+                     break;
+                  default:
+                     /* I fault out in this case because I want to know about this error,
+                        and this guarantees that it will get attention. */
+                     DBG(0, "Unrecoverable Domain/OS scsi handler error:  status=%08x\n", status_list[count].op_status);
+                     exit(EXIT_FAILURE);
+                  }
+               break;
+            /* Handle recognized error conditions by copying the error code over */
+            case scsi_$operation_timeout:
+            case scsi_$dma_underrun:  /* received by some backend code */
+            case scsi_$hdwr_failure:  /* received when both scanners were active */
+               com->CommandStatus = status_list[count].cmd_status;
+               break;
+            default:
+               DBG(0, "Unrecoverable DomainOS scsi handler error:  status=%08x\n", status_list[count].cmd_status.all);
+               error_$print(status_list[count].cmd_status);
+               exit(EXIT_FAILURE);
+            }
+         }
+      /* Dump the buffer contents */
+      if (com->direction == scsi_read)
+         {
+         DBG(3, "first words of buffer are:\n");
+         for (return_count = 0; return_count < com->dst_size; return_count++)
+            DBG(3, "%02X%c", ((unsigned char *)DomainFdInfo[com->fd].DomainSCSIPtr)[return_count], (return_count % 16) == 15 ? '\n' : ' ');
+         DBG(3, "\n");
+         }
+      }
+   else
+      {
+      /* scsi_$wait failed */
+      DBG(1, "scsi_$wait failed, status is %08x\n", com->CommandStatus.all);
+      }
+   }
+
+
+static void DomainSCSIEnter(void)
+   {
+   static int count;
+
+   /* Give some debug info */
+   DBG(1, "Entering DomainSCSIEnter, fd=%d, opcode=%02X\n", com->fd, com->cdb.all[0]);
+   DBG(2, " CDB Contents: ");
+   for (count = 0; count < com->cdb_size; count++)
+      DBG(2, " %02X", com->cdb.all[count]);
+   DBG(2, "\n");
+   DBG(2, "Buffer address is 0x%08x\n", DomainFdInfo[com->fd].DomainSCSIPtr);
+   DBG(2, "Buffer size is %x\n", com->buf_size);
+   DBG(2, "Direction is %s\n", (com->direction == scsi_read) ? "READ" : "WRITE");
+   /* now queue the command */
+   scsi_$do_command_2(DomainFdInfo[com->fd].scsi_handle, com->cdb, com->cdb_size, DomainFdInfo[com->fd].DomainSCSIPtr, com->buf_size, com->direction, &DomainFdInfo[com->fd].op_id, &com->CommandStatus);
+   if (com->CommandStatus.all == status_$ok)
+      {
+      /* success, indicate status */
+      DBG(2, " scsi_$do_command_2 was successful, op_id is %x\n", DomainFdInfo[com->fd].op_id);
+
+      /* If we supported multiple outstanding requests for one device, this would be
+         a good breakpoint.  We would store the op_id in a private place, and construct
+         a queue for each device.  This complicates things, and SANE doesn't seem to need
+         it, so it won't be implemented.  The current server architecture does the wait
+         automatically, and status for the entire operation is returned.  This means that
+         the sanei_scsi_req_enter and sanei_scsi_req_wait calls don't make sense, and
+         should generate an error. */
+      DomainSCSIWait();
+      }
+   else
+      {
+      /* failure, print detail and return code */
+      DBG(1, " scsi_$do_command_2 failed, status is %08x\n", com->CommandStatus.all);
+      }
+   }
+
+
+/* This function is not currently used. */
+static void DomainSCSIReqWait(void)
+   {
+   DBG(1, "sanei_scsi_req_wait: (id=%p)\n", NULL);
+   return;
+   }
+
+
+/* Startup the server */
+static void sanei_DomainOS_init(char *path)
+   {
+   int done, index;
+   long CommandTriggerValue;
+   ec2_$ptr_t CommandAvailablePtr[1];
+   status_$t status;
+   unsigned long length_mapped;
+
+   DBG(1, "Starting Domain SANE Server, common area path = '%s'\n", path);
+   com = ms_$mapl(path, strlen(path), 0, sizeof(struct DomainServerCommon), ms_$cowriters, ms_$wr, true, &length_mapped, &status);
+   DomainErrorCheck(status, "Can't open common area");
+   if (length_mapped < sizeof(struct DomainServerCommon))
+      {
+      DBG(0, "Error - can't open common area '%s' to required length\n", path);
+      DBG(0, " Required length = %lx, returned length = %lx\n", sizeof(struct DomainServerCommon), length_mapped);
+      exit(EXIT_FAILURE);
+      }
+   /* Make the file temporary, so it will disappear when it is closed */
+   ms_$mk_temporary(com, &status);
+   DomainErrorCheck(status, "Can't make common file temporary");
+   DBG(2, "Domain Server common area mapped, length is %lx\n", length_mapped);
+   /* The communication area is open, give the initial response */
+   ec2_$advance(&com->ResultReady, &status);
+   DomainErrorCheck(status, "Can't advance ResultReady EC after startup");
+   /* Enter the command loop */
+   CommandAvailablePtr[0] = &com->CommandAvailable;
+   CommandTriggerValue = ec2_$read(com->CommandAvailable) + 1;
+   /* Inhibit asynchronous faults */
+/*   pfm_$inhibit();*/
+   /* Establish the fault handler */
+   FaultHandle = pfm_$establish_fault_handler(pfm_$all_faults, 0, FaultHandler, &status);
+   DomainErrorCheck(status, "Can't establish fault handler");
+   done = 0;
+   do
+      {
+      /* Wait for the command */
+      DBG(2, "Waiting for incoming command\n");
+      do
+         {
+         index = ec2_$wait_svc(CommandAvailablePtr, &CommandTriggerValue, 1, &status);
+         }
+      while (status.all == ec2_$wait_quit);
+      DomainErrorCheck(status, "Error waiting on CommandAvailable EC");
+      assert (index == 1);
+      /* Get the trigger value for next time - this avoids a race/deadlock */
+      CommandTriggerValue = ec2_$read(com->CommandAvailable) + 1;
+      /* decode/execute the command */
+      DBG(2, "Received a command - opcode is %x\n", com->opcode);
+      switch(com->opcode)
+         {
+         case Open:
+            DomainSCSIOpen();
+            ec2_$advance(&com->CommandAccepted, &status);
+            DomainErrorCheck(status, "Can't advance CommandAccepted EC on open");
+            break;
+         case Close:
+            DomainSCSIClose();
+            ec2_$advance(&com->CommandAccepted, &status);
+            DomainErrorCheck(status, "Can't advance CommandAccepted EC on close");
+            break;
+         case Enter:
+            DomainSCSIEnter();
+            ec2_$advance(&com->CommandAccepted, &status);
+            DomainErrorCheck(status, "Can't advance CommandAccepted EC on enter");
+            break;
+         case Exit:
+            done = 1;
+            /* This lets the parent know that the command was accepted.  It can be
+               used to avoid sending a signal.  */
+            ec2_$advance(&com->CommandAccepted, &status);
+            DomainErrorCheck(status, "Can't advance CommandAccepted EC on exit");
+            break;
+         default:
+            DBG(1, "Invalid command %x received\n", com->opcode);
+         }
+      DBG(2, "Command processing complete\n");
+      }
+   while (!done);
+   /* This would be a good place to close all devices, but for now we'll assume
+      they have already been closed by a well-behaved program */
+   /* Unmap the common area */
+   ms_$unmap(com, sizeof(struct DomainServerCommon), &status);
+   DomainErrorCheck(status, "Error unmapping common area");
+   DBG(1, "Exiting Domain SANE Server\n");
+/*   pfm_$enable();*/
+   exit(EXIT_SUCCESS);
+   }