dlls/sane.ds/sane_main.c

   1 /*
   2  * SANE.DS functions
   3  *
   4  * Copyright 2000 Shi Quan He <shiquan@cyberdude.com>
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2.1 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with this library; if not, write to the Free Software
  18  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  19  */
  20
  21 #include "config.h"
  22 #include "wine/port.h"
  23
  24 #include <stdarg.h>
  25 #include <stdio.h>
  26
  27 #include "windef.h"
  28 #include "winbase.h"
  29 #include "twain.h"
  30 #include "sane_i.h"
  31 #include "wine/debug.h"
  32 #include "wine/library.h"
  33
  34 WINE_DEFAULT_DEBUG_CHANNEL(twain);
  35
  36 HINSTANCE SANE_instance;
  37
  38 #ifdef SONAME_LIBSANE
  39
  40 static void *libsane_handle;
  41
  42 static void close_libsane(void *h)
  43 {
  44     if (h)
  45         wine_dlclose(h, NULL, 0);
  46 }
  47
  48 static void *open_libsane(void)
  49 {
  50     void *h;
  51
  52     h = wine_dlopen(SONAME_LIBSANE, RTLD_GLOBAL | RTLD_NOW, NULL, 0);
  53     if (!h)
  54     {
  55         WARN("dlopen(%s) failed\n", SONAME_LIBSANE);
  56         return NULL;
  57     }
  58
  59 #define LOAD_FUNCPTR(f) \
  60     if((p##f = wine_dlsym(h, #f, NULL, 0)) == NULL) { \
  61         close_libsane(h); \
  62         ERR("Could not dlsym %s\n", #f); \
  63         return NULL; \
  64     }
  65
  66     LOAD_FUNCPTR(sane_init)
  67     LOAD_FUNCPTR(sane_exit)
  68     LOAD_FUNCPTR(sane_get_devices)
  69     LOAD_FUNCPTR(sane_open)
  70     LOAD_FUNCPTR(sane_close)
  71     LOAD_FUNCPTR(sane_get_option_descriptor)
  72     LOAD_FUNCPTR(sane_control_option)
  73     LOAD_FUNCPTR(sane_get_parameters)
  74     LOAD_FUNCPTR(sane_start)
  75     LOAD_FUNCPTR(sane_read)
  76     LOAD_FUNCPTR(sane_cancel)
  77     LOAD_FUNCPTR(sane_set_io_mode)
  78     LOAD_FUNCPTR(sane_get_select_fd)
  79     LOAD_FUNCPTR(sane_strstatus)
  80 #undef LOAD_FUNCPTR
  81
  82     return h;
  83 }
  84
  85 #endif /* SONAME_LIBSANE */
  86
  87 BOOL WINAPI DllMain (HINSTANCE hinstDLL, DWORD fdwReason, LPVOID lpvReserved)
  88 {
  89     TRACE("%p,%x,%p\n", hinstDLL, fdwReason, lpvReserved);
  90
  91     switch (fdwReason)
  92     {
  93         case DLL_PROCESS_ATTACH: {
  94 #ifdef SONAME_LIBSANE
  95             SANE_Int version_code;
  96
  97             libsane_handle = open_libsane();
  98             if (! libsane_handle)
  99                 return FALSE;
 100
 101             psane_init (&version_code, NULL);
 102 #endif
 103             SANE_instance = hinstDLL;
 104             DisableThreadLibraryCalls(hinstDLL);
 105             break;
 106         }
 107         case DLL_PROCESS_DETACH:
 108 #ifdef SONAME_LIBSANE
 109             TRACE("calling sane_exit()\n");
 110             psane_exit ();
 111
 112             close_libsane(libsane_handle);
 113             libsane_handle = NULL;
 114 #endif
 115             SANE_instance = NULL;
 116             break;
 117     }
 118
 119     return TRUE;
 120 }
 121
 122 #ifdef SONAME_LIBSANE
 123 static TW_UINT16 SANE_GetIdentity( pTW_IDENTITY, pTW_IDENTITY);
 124 static TW_UINT16 SANE_OpenDS( pTW_IDENTITY, pTW_IDENTITY);
 125 #endif
 126
 127 static TW_UINT16 SANE_SourceControlHandler (
 128            pTW_IDENTITY pOrigin,
 129            TW_UINT16    DAT,
 130            TW_UINT16    MSG,
 131            TW_MEMREF    pData)
 132 {
 133     TW_UINT16 twRC = TWRC_SUCCESS;
 134
 135     switch (DAT)
 136     {
 137         case DAT_IDENTITY:
 138             switch (MSG)
 139             {
 140                 case MSG_CLOSEDS:
 141 #ifdef SONAME_LIBSANE
 142                      psane_close (activeDS.deviceHandle);
 143 #else
 144                      twRC = TWRC_FAILURE;
 145                      activeDS.twCC = TWCC_CAPUNSUPPORTED;
 146 #endif
 147                      break;
 148                 case MSG_OPENDS:
 149 #ifdef SONAME_LIBSANE
 150                      twRC = SANE_OpenDS( pOrigin, (pTW_IDENTITY)pData);
 151 #else
 152                      twRC = TWRC_FAILURE;
 153                      activeDS.twCC = TWCC_CAPUNSUPPORTED;
 154 #endif
 155                      break;
 156                 case MSG_GET:
 157 #ifdef SONAME_LIBSANE
 158                      twRC = SANE_GetIdentity( pOrigin, (pTW_IDENTITY)pData);
 159 #else
 160                      twRC = TWRC_FAILURE;
 161                      activeDS.twCC = TWCC_CAPUNSUPPORTED;
 162 #endif
 163                      break;
 164             }
 165             break;
 166         case DAT_CAPABILITY:
 167             switch (MSG)
 168             {
 169                 case MSG_GET:
 170                     twRC = SANE_CapabilityGet (pOrigin, pData);
 171                     break;
 172                 case MSG_GETCURRENT:
 173                     twRC = SANE_CapabilityGetCurrent (pOrigin, pData);
 174                     break;
 175                 case MSG_GETDEFAULT:
 176                     twRC = SANE_CapabilityGetDefault (pOrigin, pData);
 177                     break;
 178                 case MSG_QUERYSUPPORT:
 179                     twRC = SANE_CapabilityQuerySupport (pOrigin, pData);
 180                     break;
 181                 case MSG_RESET:
 182                     twRC = SANE_CapabilityReset (pOrigin, pData);
 183                     break;
 184                 case MSG_SET:
 185                     twRC = SANE_CapabilitySet (pOrigin, pData);
 186                     break;
 187                 default:
 188                     twRC = TWRC_FAILURE;
 189                     activeDS.twCC = TWCC_CAPBADOPERATION;
 190                     FIXME("unrecognized opertion triplet\n");
 191                     break;
 192             }
 193             break;
 194
 195         case DAT_EVENT:
 196             if (MSG == MSG_PROCESSEVENT)
 197                 twRC = SANE_ProcessEvent (pOrigin, pData);
 198             else
 199             {
 200                 activeDS.twCC = TWCC_CAPBADOPERATION;
 201                 twRC = TWRC_FAILURE;
 202             }
 203             break;
 204
 205         case DAT_PENDINGXFERS:
 206             switch (MSG)
 207             {
 208                 case MSG_ENDXFER:
 209                     twRC = SANE_PendingXfersEndXfer (pOrigin, pData);
 210                     break;
 211                 case MSG_GET:
 212                     twRC = SANE_PendingXfersGet (pOrigin, pData);
 213                     break;
 214                 case MSG_RESET:
 215                     twRC = SANE_PendingXfersReset (pOrigin, pData);
 216                     break;
 217                 default:
 218                     activeDS.twCC = TWCC_CAPBADOPERATION;
 219                     twRC = TWRC_FAILURE;
 220             }
 221             break;
 222
 223         case DAT_SETUPMEMXFER:
 224             if (MSG == MSG_GET)
 225                 twRC = SANE_SetupMemXferGet (pOrigin, pData);
 226             else
 227             {
 228                 activeDS.twCC = TWCC_CAPBADOPERATION;
 229                 twRC = TWRC_FAILURE;
 230             }
 231             break;
 232
 233         case DAT_STATUS:
 234             if (MSG == MSG_GET)
 235                 twRC = SANE_GetDSStatus (pOrigin, pData);
 236             else
 237             {
 238                 activeDS.twCC = TWCC_CAPBADOPERATION;
 239                 twRC = TWRC_FAILURE;
 240             }
 241             break;
 242
 243         case DAT_USERINTERFACE:
 244             switch (MSG)
 245             {
 246                 case MSG_DISABLEDS:
 247                     twRC = SANE_DisableDSUserInterface (pOrigin, pData);
 248                     break;
 249                 case MSG_ENABLEDS:
 250                     twRC = SANE_EnableDSUserInterface (pOrigin, pData);
 251                     break;
 252                 case MSG_ENABLEDSUIONLY:
 253                     twRC = SANE_EnableDSUIOnly (pOrigin, pData);
 254                     break;
 255                 default:
 256                     activeDS.twCC = TWCC_CAPBADOPERATION;
 257                     twRC = TWRC_FAILURE;
 258                     break;
 259             }
 260             break;
 261
 262         case DAT_XFERGROUP:
 263             switch (MSG)
 264             {
 265                 case MSG_GET:
 266                     twRC = SANE_XferGroupGet (pOrigin, pData);
 267                     break;
 268                 case MSG_SET:
 269                     twRC = SANE_XferGroupSet (pOrigin, pData);
 270                     break;
 271                 default:
 272                     activeDS.twCC = TWCC_CAPBADOPERATION;
 273                     twRC = TWRC_FAILURE;
 274                     break;
 275             }
 276             break;
 277
 278         default:
 279             WARN("code unsupported: %d\n", DAT);
 280             activeDS.twCC = TWCC_CAPUNSUPPORTED;
 281             twRC = TWRC_FAILURE;
 282             break;
 283     }
 284
 285     return twRC;
 286 }
 287
 288
 289 static TW_UINT16 SANE_ImageGroupHandler (
 290            pTW_IDENTITY pOrigin,
 291            TW_UINT16    DAT,
 292            TW_UINT16    MSG,
 293            TW_MEMREF    pData)
 294 {
 295     TW_UINT16 twRC = TWRC_SUCCESS;
 296
 297     switch (DAT)
 298     {
 299         case DAT_IMAGEINFO:
 300             if (MSG == MSG_GET)
 301                 twRC = SANE_ImageInfoGet (pOrigin, pData);
 302             else
 303             {
 304                 activeDS.twCC = TWCC_CAPBADOPERATION;
 305                 twRC = TWRC_FAILURE;
 306             }
 307             break;
 308
 309         case DAT_IMAGELAYOUT:
 310             switch (MSG)
 311             {
 312                 case MSG_GET:
 313                     twRC = SANE_ImageLayoutGet (pOrigin, pData);
 314                     break;
 315                 case MSG_GETDEFAULT:
 316                     twRC = SANE_ImageLayoutGetDefault (pOrigin, pData);
 317                     break;
 318                 case MSG_RESET:
 319                     twRC = SANE_ImageLayoutReset (pOrigin, pData);
 320                     break;
 321                 case MSG_SET:
 322                     twRC = SANE_ImageLayoutSet (pOrigin, pData);
 323                     break;
 324                 default:
 325                     twRC = TWRC_FAILURE;
 326                     activeDS.twCC = TWCC_CAPBADOPERATION;
 327                     ERR("unrecognized operation triplet\n");
 328                     break;
 329             }
 330             break;
 331
 332         case DAT_IMAGEMEMXFER:
 333             if (MSG == MSG_GET)
 334                 twRC = SANE_ImageMemXferGet (pOrigin, pData);
 335             else
 336             {
 337                 activeDS.twCC = TWCC_CAPBADOPERATION;
 338                 twRC = TWRC_FAILURE;
 339             }
 340             break;
 341
 342         case DAT_IMAGENATIVEXFER:
 343             if (MSG == MSG_GET)
 344                 twRC = SANE_ImageNativeXferGet (pOrigin, pData);
 345             else
 346             {
 347                 activeDS.twCC = TWCC_CAPBADOPERATION;
 348                 twRC = TWRC_FAILURE;
 349             }
 350             break;
 351
 352         default:
 353             twRC = TWRC_FAILURE;
 354             activeDS.twCC = TWCC_CAPUNSUPPORTED;
 355             WARN("unsupported DG type %d\n", DAT);
 356             break;
 357     }
 358     return twRC;
 359 }
 360
 361 /* Main entry point for the TWAIN library */
 362 TW_UINT16 WINAPI
 363 DS_Entry ( pTW_IDENTITY pOrigin,
 364            TW_UINT32    DG,
 365            TW_UINT16    DAT,
 366            TW_UINT16    MSG,
 367            TW_MEMREF    pData)
 368 {
 369     TW_UINT16 twRC = TWRC_SUCCESS;  /* Return Code */
 370
 371     TRACE("(DG=%d DAT=%d MSG=%d)\n", DG, DAT, MSG);
 372
 373     switch (DG)
 374     {
 375         case DG_CONTROL:
 376             twRC = SANE_SourceControlHandler (pOrigin,DAT,MSG,pData);
 377             break;
 378         case DG_IMAGE:
 379             twRC = SANE_ImageGroupHandler (pOrigin,DAT,MSG,pData);
 380             break;
 381         case DG_AUDIO:
 382             WARN("Audio group of controls not implemented yet.\n");
 383             twRC = TWRC_FAILURE;
 384             activeDS.twCC = TWCC_CAPUNSUPPORTED;
 385             break;
 386         default:
 387             activeDS.twCC = TWCC_BADPROTOCOL;
 388             twRC = TWRC_FAILURE;
 389     }
 390
 391     return twRC;
 392 }
 393
 394 #ifdef SONAME_LIBSANE
 395 /* Sane returns device names that are longer than the 32 bytes allowed
 396    by TWAIN.  However, it colon separates them, and the last bit is
 397    the most interesting.  So we use the last bit, and add a signature
 398    to ensure uniqueness */
 399 static void copy_sane_short_name(const char *in, char *out, size_t outsize)
 400 {
 401     const char *p;
 402     int  signature = 0;
 403
 404     if (strlen(in) <= outsize - 1)
 405     {
 406         strcpy(out, in);
 407         return;
 408     }
 409
 410     for (p = in; *p; p++)
 411         signature += *p;
 412
 413     p = strrchr(in, ':');
 414     if (!p)
 415         p = in;
 416     else
 417         p++;
 418
 419     if (strlen(p) > outsize - 7 - 1)
 420         p += strlen(p) - (outsize - 7 - 1);
 421
 422     strcpy(out, p);
 423     sprintf(out + strlen(out), "(%04X)", signature % 0x10000);
 424
 425 }
 426
 427 static const SANE_Device **sane_devlist;
 428
 429 static void
 430 detect_sane_devices(void) {
 431     if (sane_devlist && sane_devlist[0]) return;
 432     TRACE("detecting sane...\n");
 433     if (psane_get_devices (&sane_devlist, SANE_FALSE) != SANE_STATUS_GOOD)
 434         return;
 435 }
 436
 437 static TW_UINT16
 438 SANE_GetIdentity( pTW_IDENTITY pOrigin, pTW_IDENTITY self) {
 439     static int cursanedev = 0;
 440
 441     detect_sane_devices();
 442     if (!sane_devlist[cursanedev])
 443         return TWRC_FAILURE;
 444     self->ProtocolMajor = TWON_PROTOCOLMAJOR;
 445     self->ProtocolMinor = TWON_PROTOCOLMINOR;
 446     self->SupportedGroups = DG_CONTROL | DG_IMAGE;
 447     copy_sane_short_name(sane_devlist[cursanedev]->name, self->ProductName, sizeof(self->ProductName) - 1);
 448     lstrcpynA (self->Manufacturer, sane_devlist[cursanedev]->vendor, sizeof(self->Manufacturer) - 1);
 449     lstrcpynA (self->ProductFamily, sane_devlist[cursanedev]->model, sizeof(self->ProductFamily) - 1);
 450     cursanedev++;
 451
 452     if (!sane_devlist[cursanedev]               ||
 453         !sane_devlist[cursanedev]->model        ||
 454         !sane_devlist[cursanedev]->vendor       ||
 455         !sane_devlist[cursanedev]->name
 456     )
 457         cursanedev = 0; /* wrap to begin */
 458     return TWRC_SUCCESS;
 459 }
 460
 461 static TW_UINT16 SANE_OpenDS( pTW_IDENTITY pOrigin, pTW_IDENTITY self) {
 462     SANE_Status status;
 463     int i;
 464
 465     detect_sane_devices();
 466     if (!sane_devlist[0]) {
 467         ERR("No scanners? We should not get to OpenDS?\n");
 468         return TWRC_FAILURE;
 469     }
 470
 471     for (i=0; sane_devlist[i] && sane_devlist[i]->model; i++) {
 472         TW_STR32 name;
 473
 474         /* To make string as short as above */
 475         lstrcpynA(name, sane_devlist[i]->vendor, sizeof(name)-1);
 476         if (self->Manufacturer && *self->Manufacturer && strcmp(name, self->Manufacturer))
 477             continue;
 478         lstrcpynA(name, sane_devlist[i]->model, sizeof(name)-1);
 479         if (self->ProductFamily && *self->ProductFamily && strcmp(name, self->ProductFamily))
 480             continue;
 481         copy_sane_short_name(sane_devlist[i]->name, name, sizeof(name) - 1);
 482         if (self->ProductName && *self->ProductName && strcmp(name, self->ProductName))
 483             continue;
 484         break;
 485     }
 486     if (!sane_devlist[i]) {
 487         WARN("Scanner not found.\n");
 488         return TWRC_FAILURE;
 489     }
 490     status = psane_open(sane_devlist[i]->name,&activeDS.deviceHandle);
 491     if (status == SANE_STATUS_GOOD) {
 492         activeDS.twCC = SANE_SaneSetDefaults();
 493         if (activeDS.twCC == TWCC_SUCCESS) {
 494             activeDS.currentState = 4;
 495             return TWRC_SUCCESS;
 496         }
 497         else
 498             psane_close(activeDS.deviceHandle);
 499     }
 500     else
 501         ERR("sane_open(%s): %s\n", sane_devlist[i]->name, psane_strstatus (status));
 502     return TWRC_FAILURE;
 503 }
 504 #endif