mshtml: Add IHTMLBodyElement bgColor tests.
[wine] / dlls / wnaspi32 / aspi.c
1 /**************************************************************************
2  * ASPI routines
3  * Copyright (C) 2000 David Elliott <dfe@infinite-internet.net>
4  * Copyright (C) 2005 Vitaliy Margolen
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 /* These routines are to be called from either WNASPI32 or WINASPI */
22
23 /* FIXME:
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 #include "config.h"
34 #include "wine/port.h"
35
36 #include <stdio.h>
37 #include <stdarg.h>
38 #include <sys/types.h>
39 #ifdef HAVE_SYS_IOCTL_H
40 #include <sys/ioctl.h>
41 #endif
42 #include <fcntl.h>
43 #include <dirent.h>
44 #ifdef HAVE_UNISTD_H
45 # include <unistd.h>
46 #endif
47 #include <errno.h>
48 #include <string.h>
49
50 #include "windef.h"
51 #include "winbase.h"
52 #include "winreg.h"
53 #include "winerror.h"
54 #include "winescsi.h"
55
56 #include "wine/debug.h"
57 #include "wine/unicode.h"
58
59 WINE_DEFAULT_DEBUG_CHANNEL(aspi);
60
61 #ifdef linux
62 static void set_last_error(void)
63 {
64     int save_errno = errno; /* errno gets overwritten by printf */
65     switch (errno)
66     {
67     case EAGAIN:
68         SetLastError( ERROR_SHARING_VIOLATION );
69         break;
70     case EBADF:
71         SetLastError( ERROR_INVALID_HANDLE );
72         break;
73     case ENOSPC:
74         SetLastError( ERROR_HANDLE_DISK_FULL );
75         break;
76     case EACCES:
77     case EPERM:
78     case EROFS:
79         SetLastError( ERROR_ACCESS_DENIED );
80         break;
81     case EBUSY:
82         SetLastError( ERROR_LOCK_VIOLATION );
83         break;
84     case ENOENT:
85         SetLastError( ERROR_FILE_NOT_FOUND );
86         break;
87     case EISDIR:
88         SetLastError( ERROR_CANNOT_MAKE );
89         break;
90     case ENFILE:
91     case EMFILE:
92         SetLastError( ERROR_NO_MORE_FILES );
93         break;
94     case EEXIST:
95         SetLastError( ERROR_FILE_EXISTS );
96         break;
97     case EINVAL:
98     case ESPIPE:
99         SetLastError( ERROR_SEEK );
100         break;
101     case ENOTEMPTY:
102         SetLastError( ERROR_DIR_NOT_EMPTY );
103         break;
104     case ENOEXEC:
105         SetLastError( ERROR_BAD_FORMAT );
106         break;
107     default:
108         WARN( "unknown file error: %s\n", strerror(save_errno) );
109         SetLastError( ERROR_GEN_FAILURE );
110         break;
111     }
112     errno = save_errno;
113 }
114 #endif
115
116 static const WCHAR wDevicemapScsi[] = {'H','A','R','D','W','A','R','E','\\','D','E','V','I','C','E','M','A','P','\\','S','c','s','i',0};
117
118 /* Exported functions */
119 int ASPI_GetNumControllers(void)
120 {
121     HKEY hkeyScsi, hkeyPort;
122     DWORD i = 0, numPorts, num_ha = 0;
123     WCHAR wPortName[11];
124
125     if (RegOpenKeyExW(HKEY_LOCAL_MACHINE, wDevicemapScsi, 0,
126         KEY_QUERY_VALUE | KEY_ENUMERATE_SUB_KEYS, &hkeyScsi) != ERROR_SUCCESS )
127     {
128         ERR("Could not open HKLM\\%s\n", debugstr_w(wDevicemapScsi));
129         return 0;
130     }
131     while (RegEnumKeyW(hkeyScsi, i++, wPortName, sizeof(wPortName)) == ERROR_SUCCESS)
132     {
133         if (RegOpenKeyExW(hkeyScsi, wPortName, 0, KEY_QUERY_VALUE, &hkeyPort) == ERROR_SUCCESS)
134         {
135             if (RegQueryInfoKeyW(hkeyPort, NULL, NULL, NULL, &numPorts, NULL, NULL,
136                              NULL, NULL, NULL, NULL, NULL) == ERROR_SUCCESS)
137             {
138                 num_ha += numPorts;
139             }
140             RegCloseKey(hkeyPort);
141         }
142     }
143
144     RegCloseKey(hkeyScsi);
145     TRACE("Returning %d host adapters\n", num_ha );
146     return num_ha;
147 }
148
149 BOOL SCSI_GetDeviceName( int h, int c, int t, int d, LPSTR devstr, LPDWORD lpcbData )
150 {
151     char buffer[200];
152     HKEY hkeyScsi;
153     DWORD type;
154
155     snprintf(buffer, sizeof(buffer), KEYNAME_SCSI, h, c, t, d);
156     if( RegOpenKeyExA(HKEY_LOCAL_MACHINE, buffer, 0, KEY_ALL_ACCESS, &hkeyScsi ) != ERROR_SUCCESS )
157     {
158         TRACE("Could not open HKLM\\%s; device does not exist\n", buffer);
159         return FALSE;
160     }
161
162     if( RegQueryValueExA(hkeyScsi, "UnixDeviceName", NULL, &type, (LPBYTE)devstr, lpcbData) != ERROR_SUCCESS )
163     {
164         WARN("Could not query value HKLM\\%s\\UnixDeviceName\n", buffer);
165         RegCloseKey(hkeyScsi);
166         return FALSE;
167     }
168     RegCloseKey(hkeyScsi);
169
170     TRACE("Device name: %s\n", devstr);
171     return TRUE;
172 }
173
174 /* SCSI_GetHCforController
175  * RETURNS
176  *      HIWORD: Host Adapter
177  *      LOWORD: Channel
178  */
179 DWORD ASPI_GetHCforController( int controller )
180 {
181     HKEY hkeyScsi, hkeyPort;
182     DWORD i = 0, numPorts;
183     int num_ha = controller + 1;
184     WCHAR wPortName[15];
185     WCHAR wBusName[15];
186
187     if (RegOpenKeyExW(HKEY_LOCAL_MACHINE, wDevicemapScsi, 0,
188         KEY_QUERY_VALUE | KEY_ENUMERATE_SUB_KEYS, &hkeyScsi) != ERROR_SUCCESS )
189     {
190         ERR("Could not open HKLM\\%s\n", debugstr_w(wDevicemapScsi));
191         return 0xFFFFFFFF;
192     }
193     while (RegEnumKeyW(hkeyScsi, i++, wPortName, sizeof(wPortName)) == ERROR_SUCCESS)
194     {
195         if (RegOpenKeyExW(hkeyScsi, wPortName, 0, KEY_QUERY_VALUE | KEY_ENUMERATE_SUB_KEYS,
196                           &hkeyPort) == ERROR_SUCCESS)
197         {
198             if (RegQueryInfoKeyW(hkeyPort, NULL, NULL, NULL, &numPorts, NULL, NULL,
199                              NULL, NULL, NULL, NULL, NULL) == ERROR_SUCCESS)
200             {
201                 num_ha -= numPorts;
202                 if (num_ha <= 0) break;
203             }
204             else
205             RegCloseKey(hkeyPort);
206         }
207     }
208     RegCloseKey(hkeyScsi);
209
210     if (num_ha > 0)
211     {
212         ERR("Invalid controller(%d)\n", controller);
213         return 0xFFFFFFFF;
214     }
215
216     if (RegEnumKeyW(hkeyPort, -num_ha, wBusName, sizeof(wBusName)) != ERROR_SUCCESS)
217     {
218         ERR("Failed to enumerate keys\n");
219         RegCloseKey(hkeyPort);
220         return 0xFFFFFFFF;
221     }
222     RegCloseKey(hkeyPort);
223
224     return (atoiW(&wPortName[9]) << 16) + atoiW(&wBusName[9]);
225 }
226
227 int SCSI_OpenDevice( int h, int c, int t, int d )
228 {
229     char devstr[20];
230     DWORD cbData = 20;
231     int fd = -1;
232
233     if(!SCSI_GetDeviceName( h, c, t, d, devstr, &cbData ))
234     {
235         WARN("Could not get device name for h%02dc%02dt%02dd%02d\n", h, c, t, d);
236         return -1;
237     }
238
239     TRACE("Opening device %s mode O_RDWR\n",devstr);
240     fd = open(devstr, O_RDWR);
241     if (fd == -1) {
242         char *errstring = strerror(errno);
243         ERR("Failed to open device %s: %s\n", devstr, errstring);
244     }
245
246     return fd;
247 }
248
249 #ifdef linux
250 /* SCSI_Fix_CMD_LEN
251  *      Checks to make sure the CMD_LEN is correct
252  */
253 void
254 SCSI_Fix_CMD_LEN(int fd, int cmd, int len)
255 {
256         /* This is what the linux kernel thinks.... */
257         static const unsigned char scsi_command_size[8] =
258         {
259                 6, 10, 10, 12,
260                 12, 12, 10, 10
261         };
262
263         int index=(cmd>>5)&7;
264
265         if (len!=scsi_command_size[index])
266         {
267                 TRACE("CDBLen for command %d claims to be %d, expected %d\n",
268                                 cmd, len, scsi_command_size[index]);
269                 ioctl(fd,SG_NEXT_CMD_LEN,&len);
270         }
271 }
272
273 int
274 SCSI_LinuxSetTimeout( int fd, int timeout )
275 {
276         int retval;
277         TRACE("Setting timeout to %d jiffies\n", timeout);
278         retval=ioctl(fd,SG_SET_TIMEOUT,&timeout);
279         if(retval)
280         {
281                 WARN("Could not set timeout ! (%s)\n", strerror(errno));
282         }
283         return retval;
284
285 }
286
287 /* This function takes care of the write/read to the linux sg device.
288  * It returns TRUE or FALSE and uses set_last_error() to convert
289  * UNIX errno to Windows GetLastError().  The reason for that is that
290  * several programs will check that error and we might as well set
291  * it here.  We also return the value of the read call in
292  * lpcbBytesReturned.
293  */
294 BOOL /* NOTE: This function SHOULD BLOCK */
295 SCSI_LinuxDeviceIo( int fd,
296                 struct sg_header * lpInBuffer, DWORD cbInBuffer,
297                 struct sg_header * lpOutBuffer, DWORD cbOutBuffer,
298                 LPDWORD lpcbBytesReturned )
299 {
300         DWORD dwBytes;
301         DWORD save_error;
302
303         TRACE("Writing to Linux sg device\n");
304         dwBytes = write( fd, lpInBuffer, cbInBuffer );
305         if( dwBytes != cbInBuffer )
306         {
307                 set_last_error();
308                 save_error = GetLastError();
309                 WARN("Not enough bytes written to scsi device. bytes=%d .. %d\n", cbInBuffer, dwBytes );
310                 /* FIXME: set_last_error() never sets error to ERROR_NOT_ENOUGH_MEMORY... */
311                 if( save_error == ERROR_NOT_ENOUGH_MEMORY )
312                         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)");
313                 WARN("error= %d\n", save_error );
314                 *lpcbBytesReturned = 0;
315                 return FALSE;
316         }
317
318         TRACE("Reading reply from Linux sg device\n");
319         *lpcbBytesReturned = read( fd, lpOutBuffer, cbOutBuffer );
320         if( *lpcbBytesReturned != cbOutBuffer )
321         {
322                 set_last_error();
323                 save_error = GetLastError();
324                 WARN("Not enough bytes read from scsi device. bytes=%d .. %d\n", cbOutBuffer, *lpcbBytesReturned);
325                 WARN("error= %d\n", save_error );
326                 return FALSE;
327         }
328         return TRUE;
329 }
330
331 static void SCSI_Linux_CheckDevices(void)
332 {
333     DIR *devdir;
334     struct dirent *dent = NULL;
335
336     devdir = opendir("/dev");
337     for (dent=readdir(devdir);dent;dent=readdir(devdir))
338     {
339         if (!(strncmp(dent->d_name, "sg", 2)))
340             break;
341     }
342     closedir(devdir);
343
344     if (dent == NULL)
345     {
346         TRACE("WARNING: You don't have any /dev/sgX generic scsi devices ! \"man MAKEDEV\" !\n");
347         return;
348     }
349 }
350 #endif
351
352 void SCSI_Init(void)
353 {
354 #ifdef linux
355     SCSI_Linux_CheckDevices();
356 #endif
357 }