git.oblomov.eu Git - wine/blob - dlls/winaspi/aspi.c

   1 /**************************************************************************
   2  * ASPI routines
   3  * Copyright (C) 2000 David Elliott <dfe@infinite-internet.net>
   4  *
   5  * This library is free software; you can redistribute it and/or
   6  * modify it under the terms of the GNU Lesser General Public
   7  * License as published by the Free Software Foundation; either
   8  * version 2.1 of the License, or (at your option) any later version.
   9  *
  10  * This library is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13  * Lesser General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU Lesser General Public
  16  * License along with this library; if not, write to the Free Software
  17  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  18  */
  19
  20 /* These routines are to be called from either WNASPI32 or WINASPI */
  21
  22 /* FIXME:
  23  * - Registry format is stupid for now.. fix that later
  24  * - No way to override automatic /proc detection, maybe provide an
  25  *   HKEY_LOCAL_MACHINE\Software\Wine\Wine\Scsi regkey
  26  * - Somewhat debating an #ifdef linux... technically all this code will
  27  *   run on another UNIX.. it will fail nicely.
  28  * - Please add support for mapping multiple channels on host adapters to
  29  *   aspi controllers, e-mail me if you need help.
  30  */
  31
  32 /*
  33 Registry format is currently:
  34 HKEY_DYN_DATA
  35         WineScsi
  36                 (default)=number of host adapters
  37                 hHHcCCtTTdDD=linux device name
  38 */
  39
  40 #include "config.h"
  41
  42 #include <stdio.h>
  43 #include <stdarg.h>
  44 #include <sys/types.h>
  45 #ifdef HAVE_SYS_IOCTL_H
  46 #include <sys/ioctl.h>
  47 #endif
  48 #include <fcntl.h>
  49 #include <dirent.h>
  50 #ifdef HAVE_UNISTD_H
  51 # include <unistd.h>
  52 #endif
  53 #include <errno.h>
  54 #include <string.h>
  55
  56 #include "windef.h"
  57 #include "winbase.h"
  58 #include "winreg.h"
  59 #include "winerror.h"
  60 #include "winescsi.h"
  61
  62 #include "wine/debug.h"
  63
  64 WINE_DEFAULT_DEBUG_CHANNEL(aspi);
  65
  66 /* Internal function prototypes */
  67 static void
  68 SCSI_GetProcinfo();
  69
  70 #ifdef linux
  71 static void
  72 SCSI_MapHCtoController();
  73 #endif
  74
  75 static void set_last_error(void)
  76 {
  77     int save_errno = errno; /* errno gets overwritten by printf */
  78     switch (errno)
  79     {
  80     case EAGAIN:
  81         SetLastError( ERROR_SHARING_VIOLATION );
  82         break;
  83     case EBADF:
  84         SetLastError( ERROR_INVALID_HANDLE );
  85         break;
  86     case ENOSPC:
  87         SetLastError( ERROR_HANDLE_DISK_FULL );
  88         break;
  89     case EACCES:
  90     case EPERM:
  91     case EROFS:
  92         SetLastError( ERROR_ACCESS_DENIED );
  93         break;
  94     case EBUSY:
  95         SetLastError( ERROR_LOCK_VIOLATION );
  96         break;
  97     case ENOENT:
  98         SetLastError( ERROR_FILE_NOT_FOUND );
  99         break;
 100     case EISDIR:
 101         SetLastError( ERROR_CANNOT_MAKE );
 102         break;
 103     case ENFILE:
 104     case EMFILE:
 105         SetLastError( ERROR_NO_MORE_FILES );
 106         break;
 107     case EEXIST:
 108         SetLastError( ERROR_FILE_EXISTS );
 109         break;
 110     case EINVAL:
 111     case ESPIPE:
 112         SetLastError( ERROR_SEEK );
 113         break;
 114     case ENOTEMPTY:
 115         SetLastError( ERROR_DIR_NOT_EMPTY );
 116         break;
 117     case ENOEXEC:
 118         SetLastError( ERROR_BAD_FORMAT );
 119         break;
 120     default:
 121         WARN( "unknown file error: %s\n", strerror(save_errno) );
 122         SetLastError( ERROR_GEN_FAILURE );
 123         break;
 124     }
 125     errno = save_errno;
 126 }
 127
 128 /* Exported functions */
 129 void
 130 SCSI_Init()
 131 {
 132         /* For now we just call SCSI_GetProcinfo */
 133         SCSI_GetProcinfo();
 134 #ifdef linux
 135         SCSI_MapHCtoController();
 136 #endif
 137 }
 138
 139 int
 140 ASPI_GetNumControllers()
 141 {
 142         HKEY hkeyScsi;
 143         HKEY hkeyControllerMap;
 144         DWORD error;
 145         DWORD type = REG_DWORD;
 146         DWORD num_ha = 0;
 147         DWORD cbData = sizeof(num_ha);
 148
 149         if( RegOpenKeyExA(HKEY_DYN_DATA, KEYNAME_SCSI, 0, KEY_ALL_ACCESS, &hkeyScsi ) != ERROR_SUCCESS )
 150         {
 151                 ERR("Could not open HKEY_DYN_DATA\\%s\n",KEYNAME_SCSI);
 152                 return 0;
 153         }
 154
 155         if( (error=RegOpenKeyExA(hkeyScsi, KEYNAME_SCSI_CONTROLLERMAP, 0, KEY_ALL_ACCESS, &hkeyControllerMap )) != ERROR_SUCCESS )
 156         {
 157                 ERR("Could not open HKEY_DYN_DATA\\%s\\%s\n", KEYNAME_SCSI, KEYNAME_SCSI_CONTROLLERMAP);
 158                 RegCloseKey(hkeyScsi);
 159                 SetLastError(error);
 160                 return 0;
 161         }
 162         if( RegQueryValueExA(hkeyControllerMap, NULL, NULL, &type, (LPBYTE)&num_ha, &cbData ) != ERROR_SUCCESS )
 163         {
 164                 ERR("Could not query value HKEY_DYN_DATA\\%s\n",KEYNAME_SCSI);
 165                 num_ha=0;
 166         }
 167         RegCloseKey(hkeyControllerMap);
 168         RegCloseKey(hkeyScsi);
 169         TRACE("Returning %ld host adapters\n", num_ha );
 170         return num_ha;
 171 }
 172
 173 BOOL
 174 SCSI_GetDeviceName( int h, int c, int t, int d, LPSTR devstr, LPDWORD lpcbData )
 175 {
 176
 177         char idstr[20];
 178         HKEY hkeyScsi;
 179         DWORD type;
 180
 181         if( RegOpenKeyExA(HKEY_DYN_DATA, KEYNAME_SCSI, 0, KEY_ALL_ACCESS, &hkeyScsi ) != ERROR_SUCCESS )
 182         {
 183                 ERR("Could not open HKEY_DYN_DATA\\%s\n",KEYNAME_SCSI);
 184                 return FALSE;
 185         }
 186
 187
 188         sprintf(idstr, "h%02dc%02dt%02dd%02d", h, c, t, d);
 189
 190         if( RegQueryValueExA(hkeyScsi, idstr, NULL, &type, devstr, lpcbData) != ERROR_SUCCESS )
 191         {
 192                 WARN("Could not query value HKEY_DYN_DATA\\%s\\%s\n",KEYNAME_SCSI, idstr);
 193                 RegCloseKey(hkeyScsi);
 194                 return FALSE;
 195         }
 196         RegCloseKey(hkeyScsi);
 197
 198         TRACE("scsi %s: Device name: %s\n",idstr,devstr);
 199         return TRUE;
 200 }
 201
 202 /* SCSI_GetHCforController
 203  * RETURNS
 204  *      HIWORD: Host Adapter
 205  *      LOWORD: Channel
 206  */
 207 DWORD
 208 ASPI_GetHCforController( int controller )
 209 {
 210         DWORD hc = 0xFFFFFFFF;
 211         char cstr[20];
 212         DWORD error;
 213         HKEY hkeyScsi;
 214         HKEY hkeyControllerMap;
 215         DWORD type = REG_DWORD;
 216         DWORD cbData = sizeof(DWORD);
 217         DWORD disposition;
 218 #if 0
 219         FIXME("Please fix to map each channel of each host adapter to the proper ASPI controller number!\n");
 220         hc = (controller << 16);
 221         return hc;
 222 #endif
 223         if( (error=RegCreateKeyExA(HKEY_DYN_DATA, KEYNAME_SCSI, 0, NULL, REG_OPTION_VOLATILE, KEY_ALL_ACCESS, NULL, &hkeyScsi, &disposition )) != ERROR_SUCCESS )
 224         {
 225                 ERR("Could not open HKEY_DYN_DATA\\%s\n",KEYNAME_SCSI);
 226                 SetLastError(error);
 227                 return hc;
 228         }
 229         if( disposition != REG_OPENED_EXISTING_KEY )
 230         {
 231                 WARN("Created HKEY_DYN_DATA\\%s\n",KEYNAME_SCSI);
 232         }
 233         if( (error=RegCreateKeyExA(hkeyScsi, KEYNAME_SCSI_CONTROLLERMAP, 0, NULL, REG_OPTION_VOLATILE, KEY_ALL_ACCESS, NULL, &hkeyControllerMap, &disposition )) != ERROR_SUCCESS )
 234         {
 235                 ERR("Could not open HKEY_DYN_DATA\\%s\\%s\n", KEYNAME_SCSI, KEYNAME_SCSI_CONTROLLERMAP);
 236                 RegCloseKey(hkeyScsi);
 237                 SetLastError(error);
 238                 return hc;
 239         }
 240         if( disposition != REG_OPENED_EXISTING_KEY )
 241         {
 242                 WARN("Created HKEY_DYN_DATA\\%s\\%s\n",KEYNAME_SCSI, KEYNAME_SCSI_CONTROLLERMAP);
 243         }
 244
 245         sprintf(cstr, "c%02d", controller);
 246         if( (error=RegQueryValueExA( hkeyControllerMap, cstr, 0, &type, (LPBYTE)&hc, &cbData)) != ERROR_SUCCESS )
 247         {
 248                 ERR("Could not open HKEY_DYN_DATA\\%s\\%s\\%s, error=%lx\n", KEYNAME_SCSI, KEYNAME_SCSI_CONTROLLERMAP, cstr, error );
 249                 SetLastError( error );
 250         }
 251         RegCloseKey(hkeyControllerMap);
 252         RegCloseKey(hkeyScsi);
 253         return hc;
 254
 255 };
 256
 257 int
 258 SCSI_OpenDevice( int h, int c, int t, int d )
 259 {
 260         char devstr[20];
 261         DWORD cbData = 20;
 262         int fd = -1;
 263         char dainbread_linux_hack = 1;
 264
 265         if(!SCSI_GetDeviceName( h, c, t, d, devstr, &cbData ))
 266         {
 267                 WARN("Could not get device name for h%02dc%02dt%02dd%02d\n", h, c, t, d);
 268                 return -1;
 269         }
 270
 271 linux_hack:
 272         TRACE("Opening device %s mode O_RDWR\n",devstr);
 273         fd = open(devstr, O_RDWR);
 274
 275         if( fd < 0 )
 276         {
 277                 int len = strlen(devstr);
 278                 set_last_error(); /* SetLastError() to errno */
 279                 TRACE("Open failed (%s)\n", strerror(errno));
 280
 281                 /* in case of "/dev/sgX", convert from sga to sg0
 282                  * and the other way around.
 283                  * FIXME: remove it if the distributions
 284                  * finally manage to agree on something.
 285                  * The best would probably be a complete
 286                  * rewrite of the Linux SCSI layer
 287                  * to use CAM + devfs :-) */
 288                 if ( (dainbread_linux_hack) &&
 289                      (len >= 3) &&
 290                      (devstr[len-3] == 's') && (devstr[len-2] == 'g') )
 291                 {
 292                         char *p = &devstr[len-1];
 293                         *p = (*p >= 'a') ? *p - 'a' + '0' : *p - '0' + 'a';
 294                         dainbread_linux_hack = 0;
 295                         TRACE("Retry with \"equivalent\" Linux device '%s'\n", devstr);
 296                         goto linux_hack;
 297                 }
 298         }
 299         return fd;
 300 }
 301
 302 #ifdef linux
 303 /* SCSI_Fix_CMD_LEN
 304  *      Checks to make sure the CMD_LEN is correct
 305  */
 306 void
 307 SCSI_Fix_CMD_LEN(int fd, int cmd, int len)
 308 {
 309         int index=(cmd>>5)&7;
 310
 311         if (len!=scsi_command_size[index])
 312         {
 313                 TRACE("CDBLen for command %d claims to be %d, expected %d\n",
 314                                 cmd, len, scsi_command_size[index]);
 315                 ioctl(fd,SG_NEXT_CMD_LEN,&len);
 316         }
 317 }
 318
 319 int
 320 SCSI_LinuxSetTimeout( int fd, int timeout )
 321 {
 322         int retval;
 323         TRACE("Setting timeout to %d jiffies\n", timeout);
 324         retval=ioctl(fd,SG_SET_TIMEOUT,&timeout);
 325         if(retval)
 326         {
 327                 WARN("Could not set timeout ! (%s)\n", strerror(errno));
 328         }
 329         return retval;
 330
 331 }
 332
 333 /* This function takes care of the write/read to the linux sg device.
 334  * It returns TRUE or FALSE and uses set_last_error() to convert
 335  * UNIX errno to Windows GetLastError().  The reason for that is that
 336  * several programs will check that error and we might as well set
 337  * it here.  We also return the value of the read call in
 338  * lpcbBytesReturned.
 339  */
 340 BOOL /* NOTE: This function SHOULD BLOCK */
 341 SCSI_LinuxDeviceIo( int fd,
 342                 struct sg_header * lpInBuffer, DWORD cbInBuffer,
 343                 struct sg_header * lpOutBuffer, DWORD cbOutBuffer,
 344                 LPDWORD lpcbBytesReturned )
 345 {
 346         DWORD dwBytes;
 347         DWORD save_error;
 348
 349         TRACE("Writing to Linux sg device\n");
 350         dwBytes = write( fd, lpInBuffer, cbInBuffer );
 351         if( dwBytes != cbInBuffer )
 352         {
 353                 set_last_error();
 354                 save_error = GetLastError();
 355                 WARN("Not enough bytes written to scsi device. bytes=%ld .. %ld\n", cbInBuffer, dwBytes );
 356                 /* FIXME: set_last_error() never sets error to ERROR_NOT_ENOUGH_MEMORY... */
 357                 if( save_error == ERROR_NOT_ENOUGH_MEMORY )
 358                         MESSAGE("Your Linux kernel was not able to handle the amount of data sent to the scsi device. Try recompiling with a larger SG_BIG_BUFF value (kernel 2.0.x sg.h)");
 359                 WARN("error= %ld\n", save_error );
 360                 *lpcbBytesReturned = 0;
 361                 return FALSE;
 362         }
 363
 364         TRACE("Reading reply from Linux sg device\n");
 365         *lpcbBytesReturned = read( fd, lpOutBuffer, cbOutBuffer );
 366         if( *lpcbBytesReturned != cbOutBuffer )
 367         {
 368                 set_last_error();
 369                 save_error = GetLastError();
 370                 WARN("Not enough bytes read from scsi device. bytes=%ld .. %ld\n", cbOutBuffer, *lpcbBytesReturned);
 371                 WARN("error= %ld\n", save_error );
 372                 return FALSE;
 373         }
 374         return TRUE;
 375 }
 376
 377 /* Internal functions */
 378 struct LinuxProcScsiDevice
 379 {
 380         int host;
 381         int channel;
 382         int target;
 383         int lun;
 384         char vendor[9];
 385         char model[17];
 386         char rev[5];
 387         char type[33];
 388         int ansirev;
 389 };
 390
 391 /*
 392  * we need to declare white spaces explicitly via %*1[ ],
 393  * as there are very dainbread CD-ROM devices out there
 394  * which have their manufacturer name blanked out via spaces,
 395  * which confuses fscanf's parsing (skips all blank spaces)
 396  */
 397 static int
 398 SCSI_getprocentry( FILE * procfile, struct LinuxProcScsiDevice * dev )
 399 {
 400         int result;
 401         result = fscanf( procfile,
 402                 "Host:%*1[ ]scsi%d%*1[ ]Channel:%*1[ ]%d%*1[ ]Id:%*1[ ]%d%*1[ ]Lun:%*1[ ]%d\n",
 403                 &dev->host,
 404                 &dev->channel,
 405                 &dev->target,
 406                 &dev->lun );
 407         if( result == EOF )
 408         {
 409                 /* "end of entries" return, so no TRACE() here */
 410                 return EOF;
 411         }
 412         if( result != 4 )
 413         {
 414                 ERR("bus id line scan count error\n");
 415                 return 0;
 416         }
 417         result = fscanf( procfile,
 418                 "  Vendor:%*1[ ]%8c%*1[ ]Model:%*1[ ]%16c%*1[ ]Rev:%*1[ ]%4c\n",
 419                 dev->vendor,
 420                 dev->model,
 421                 dev->rev );
 422         if( result != 3 )
 423         {
 424                 ERR("model line scan count error\n");
 425                 return 0;
 426         }
 427
 428         result = fscanf( procfile,
 429                 "  Type:%*3[ ]%32c%*1[ ]ANSI%*1[ ]SCSI%*1[ ]revision:%*1[ ]%d\n",
 430                 dev->type,
 431                 &dev->ansirev );
 432         if( result != 2 )
 433         {
 434                 ERR("SCSI type line scan count error\n");
 435                 return 0;
 436         }
 437         /* Since we fscanf with %XXc instead of %s.. put a NULL at end */
 438         dev->vendor[8] = 0;
 439         dev->model[16] = 0;
 440         dev->rev[4] = 0;
 441         dev->type[32] = 0;
 442
 443         return 1;
 444 }
 445
 446 static void
 447 SCSI_printprocentry( const struct LinuxProcScsiDevice * dev )
 448 {
 449         TRACE( "Host: scsi%d Channel: %02d Id: %02d Lun: %02d\n",
 450                 dev->host,
 451                 dev->channel,
 452                 dev->target,
 453                 dev->lun );
 454         TRACE( "  Vendor: %s Model: %s Rev: %s\n",
 455                 dev->vendor,
 456                 dev->model,
 457                 dev->rev );
 458         TRACE( "  Type:   %s ANSI SCSI revision: %02d\n",
 459                 dev->type,
 460                 dev->ansirev );
 461 }
 462
 463 static BOOL
 464 SCSI_PutRegControllerMap( HKEY hkeyControllerMap, int num_controller, int ha, int chan)
 465 {
 466         DWORD error;
 467         char cstr[20];
 468         DWORD hc;
 469         hc = (ha << 16) + chan;
 470         sprintf(cstr, "c%02d", num_controller);
 471         if( (error=RegSetValueExA( hkeyControllerMap, cstr, 0, REG_DWORD, (LPBYTE)&hc, sizeof(DWORD))) != ERROR_SUCCESS )
 472         {
 473                 ERR("Could not create HKEY_DYN_DATA\\%s\\%s\\%s\n", KEYNAME_SCSI, KEYNAME_SCSI_CONTROLLERMAP, cstr );
 474         }
 475         return error;
 476 }
 477
 478 static void
 479 SCSI_MapHCtoController()
 480 {
 481         HKEY hkeyScsi;
 482         HKEY hkeyControllerMap;
 483         DWORD disposition;
 484
 485         char idstr[20];
 486         DWORD cbIdStr;
 487         int i = 0;
 488         DWORD type = 0;
 489         DWORD error;
 490
 491         DWORD num_controller = 0;
 492         int last_ha = -1;
 493         int last_chan = -1;
 494
 495         int ha = 0;
 496         int chan = 0;
 497
 498         if( RegCreateKeyExA(HKEY_DYN_DATA, KEYNAME_SCSI, 0, NULL, REG_OPTION_VOLATILE, KEY_ALL_ACCESS, NULL, &hkeyScsi, &disposition ) != ERROR_SUCCESS )
 499         {
 500                 ERR("Could not open HKEY_DYN_DATA\\%s\n",KEYNAME_SCSI);
 501                 return;
 502         }
 503         if( disposition != REG_OPENED_EXISTING_KEY )
 504         {
 505                 WARN("Created HKEY_DYN_DATA\\%s\n",KEYNAME_SCSI);
 506         }
 507         if( RegCreateKeyExA(hkeyScsi, KEYNAME_SCSI_CONTROLLERMAP, 0, NULL, REG_OPTION_VOLATILE, KEY_ALL_ACCESS, NULL, &hkeyControllerMap, &disposition ) != ERROR_SUCCESS )
 508         {
 509                 ERR("Could not create HKEY_DYN_DATA\\%s\\%s\n", KEYNAME_SCSI, KEYNAME_SCSI_CONTROLLERMAP);
 510                 RegCloseKey(hkeyScsi);
 511                 return;
 512         }
 513
 514         for( i=0; cbIdStr = sizeof(idstr), (error=RegEnumValueA( hkeyScsi, i, idstr, &cbIdStr, NULL, &type, NULL, NULL )) == ERROR_SUCCESS; i++ )
 515         {
 516                 if(idstr[0] == '\0') continue; /* skip the default value */
 517
 518                 if(sscanf(idstr, "h%02dc%02dt%*02dd%*02d", &ha, &chan) != 2) {
 519                         ERR("incorrect reg. value %s\n", debugstr_a(idstr));
 520                         continue;
 521                 }
 522
 523                 if( last_ha < ha )
 524                 {       /* Next HA */
 525                         last_ha = ha;
 526                         last_chan = chan;
 527                         SCSI_PutRegControllerMap( hkeyControllerMap, num_controller, ha, chan);
 528                         num_controller++;
 529                 }
 530                 else if( last_ha > ha )
 531                 {
 532                         FIXME("Expected registry to be sorted\n");
 533                 }
 534                 /* last_ha == ha */
 535                 else if( last_chan < chan )
 536                 {
 537                         last_chan = chan;
 538                         SCSI_PutRegControllerMap( hkeyControllerMap, num_controller, ha, chan);
 539                         num_controller++;
 540                 }
 541                 else if( last_chan > chan )
 542                 {
 543                         FIXME("Expected registry to be sorted\n");
 544                 }
 545                 /* else last_ha == ha && last_chan == chan so do nothing */
 546         }
 547         /* Set (default) value to number of controllers */
 548         if( RegSetValueExA(hkeyControllerMap, NULL, 0, REG_DWORD, (LPBYTE)&num_controller, sizeof(DWORD) ) != ERROR_SUCCESS )
 549         {
 550                 ERR("Could not set value HKEY_DYN_DATA\\%s\\%s\n",KEYNAME_SCSI, KEYNAME_SCSI_CONTROLLERMAP);
 551         }
 552         RegCloseKey(hkeyControllerMap);
 553         RegCloseKey(hkeyScsi);
 554         return;
 555 }
 556 #endif
 557
 558 int SCSI_Linux_CheckDevices(void)
 559 {
 560     DIR *devdir;
 561     struct dirent *dent = NULL;
 562
 563     devdir = opendir("/dev");
 564     for (dent=readdir(devdir);dent;dent=readdir(devdir))
 565     {
 566         if (!(strncmp(dent->d_name, "sg", 2)))
 567             break;
 568     }
 569     closedir(devdir);
 570
 571     if (dent == NULL)
 572     {
 573         TRACE("WARNING: You don't have any /dev/sgX generic scsi devices ! \"man MAKEDEV\" !\n");
 574         return 0;
 575     }
 576     return 1;
 577 }
 578
 579 static void
 580 SCSI_GetProcinfo()
 581 /* I'll admit, this function is somewhat of a mess... it was originally
 582  * designed to make some sort of linked list then I realized that
 583  * HKEY_DYN_DATA would be a lot less messy
 584  */
 585 {
 586 #ifdef linux
 587         static const char procname[] = "/proc/scsi/scsi";
 588         FILE * procfile = NULL;
 589
 590         char read_line[40], read1[10] = "\0", read2[10] = "\0";
 591         int result = 0;
 592
 593         struct LinuxProcScsiDevice dev;
 594
 595         char idstr[20];
 596         char devstr[20];
 597
 598         int devnum=0;
 599         int num_ha = 0;
 600
 601         HKEY hkeyScsi;
 602         DWORD disposition;
 603
 604         /* Check whether user has generic scsi devices at all */
 605         if (!(SCSI_Linux_CheckDevices()))
 606             return;
 607
 608         procfile = fopen( procname, "r" );
 609         if( !procfile )
 610         {
 611                 ERR("Could not open %s\n", procname);
 612                 return;
 613         }
 614
 615         fgets(read_line, 40, procfile);
 616         sscanf( read_line, "Attached %9s %9s", read1, read2);
 617
 618         if(strcmp(read1, "devices:"))
 619         {
 620                 ERR("Incorrect %s format\n", procname);
 621                 return;
 622         }
 623
 624         if(!(strcmp(read2, "none")))
 625         {
 626                 ERR("No devices found in %s. Make sure you loaded your SCSI driver or set up ide-scsi emulation for your IDE device if this app needs it !\n", procname);
 627                 return;
 628         }
 629
 630         if( RegCreateKeyExA(HKEY_DYN_DATA, KEYNAME_SCSI, 0, NULL, REG_OPTION_VOLATILE, KEY_ALL_ACCESS, NULL, &hkeyScsi, &disposition ) != ERROR_SUCCESS )
 631         {
 632                 ERR("Could not create HKEY_DYN_DATA\\%s\n",KEYNAME_SCSI);
 633                 return;
 634         }
 635
 636         /* Read info for one device */
 637         while( (result = SCSI_getprocentry(procfile, &dev)) > 0 )
 638         {
 639                 /* Add to registry */
 640
 641                 sprintf(idstr, "h%02dc%02dt%02dd%02d", dev.host, dev.channel, dev.target, dev.lun);
 642                 sprintf(devstr, "/dev/sg%c", 'a'+devnum);
 643                 if( RegSetValueExA(hkeyScsi, idstr, 0, REG_SZ, devstr, strlen(devstr)+1 ) != ERROR_SUCCESS )
 644                 {
 645                         ERR("Could not set value HKEY_DYN_DATA\\%s\\%s\n",KEYNAME_SCSI, idstr);
 646                 }
 647
 648                 /* Debug output */
 649                 SCSI_printprocentry( &dev );
 650
 651                 /* FIXME: We *REALLY* need number of controllers.. not ha */
 652                 /* num of hostadapters is highest ha + 1 */
 653                 if( dev.host >= num_ha )
 654                         num_ha = dev.host+1;
 655                 devnum++;
 656         } /* while(1) */
 657         if( result != EOF )
 658         {
 659                 ERR("Sorry, incorrect %s format\n", procname);
 660         }
 661         fclose( procfile );
 662         if( RegSetValueExA(hkeyScsi, NULL, 0, REG_DWORD, (LPBYTE)&num_ha, sizeof(num_ha) ) != ERROR_SUCCESS )
 663         {
 664                 ERR("Could not set value HKEY_DYN_DATA\\%s\n",KEYNAME_SCSI);
 665         }
 666         RegCloseKey(hkeyScsi);
 667         return;
 668 #endif
 669 }