winnt-win2000-win98-afs-client-updates-20010623
[openafs.git] / src / sys / pioctl_nt.c
1 /*
2  * Copyright 2000, International Business Machines Corporation and others.
3  * All Rights Reserved.
4  * 
5  * This software has been released under the terms of the IBM Public
6  * License.  For details, see the LICENSE file in the top-level source
7  * directory or online at http://www.openafs.org/dl/license10.html
8  */
9
10 #include <afs/stds.h>
11 #include <windows.h>
12 #include <stdlib.h>
13 #include <stdio.h>
14 #include <errno.h>
15 #include <malloc.h>
16 #include <string.h>
17 #include <winioctl.h>
18 #include <winsock2.h>
19 #include <nb30.h>
20
21 #include <osi.h>
22
23 #include <cm.h>
24 #include <cm_dir.h>
25 #include <cm_cell.h>
26 #include <cm_user.h>
27 #include <cm_conn.h>
28 #include <cm_scache.h>
29 #include <cm_buf.h>
30 #include <cm_utils.h>
31 #include <cm_ioctl.h>
32 \r
33 #include <smb.h>
34 #include <pioctl_nt.h>
35
36 static char AFSConfigKeyName[] =
37         "SYSTEM\\CurrentControlSet\\Services\\TransarcAFSDaemon\\Parameters";
38
39 #define FS_IOCTLREQUEST_MAXSIZE 8192
40 /* big structure for representing and storing an IOCTL request */
41 typedef struct fs_ioctlRequest {
42         char *mp;                               /* marshalling/unmarshalling ptr */
43         long nbytes;                            /* bytes received (when unmarshalling) */
44         char data[FS_IOCTLREQUEST_MAXSIZE];     /* data we're marshalling */
45 } fs_ioctlRequest_t;
46
47 static int CMtoUNIXerror(int cm_code)
48 {
49         switch (cm_code) {
50                 case CM_ERROR_TIMEDOUT: return ETIMEDOUT;
51                 case CM_ERROR_NOACCESS: return EACCES;
52                 case CM_ERROR_NOSUCHFILE: return ENOENT;
53                 case CM_ERROR_INVAL: return EINVAL;
54                 case CM_ERROR_BADFD: return EBADF;
55                 case CM_ERROR_EXISTS: return EEXIST;
56                 case CM_ERROR_CROSSDEVLINK: return EXDEV;
57                 case CM_ERROR_NOTDIR: return ENOTDIR;
58                 case CM_ERROR_ISDIR: return EISDIR;
59                 case CM_ERROR_READONLY: return EROFS;
60                 case CM_ERROR_WOULDBLOCK: return EWOULDBLOCK;
61                 case CM_ERROR_NOSUCHCELL: return ESRCH;         /* hack */
62                 case CM_ERROR_NOSUCHVOLUME: return EPIPE;       /* hack */
63                 case CM_ERROR_NOMORETOKENS: return EDOM;        /* hack */
64                 case CM_ERROR_TOOMANYBUFS: return EFBIG;        /* hack */
65                 default: return ENOTTY;
66         }
67 }
68
69 static void InitFSRequest(fs_ioctlRequest_t *rp)
70 {
71         rp->mp = rp->data;
72         rp->nbytes = 0;
73 }
74
75 static long GetIoctlHandle(char *fileNamep, HANDLE *handlep)
76 {
77         char *drivep;
78         char hostName[256];
79         char tbuffer[100];
80         char *ctemp;
81         HANDLE fh;
82         HKEY parmKey;
83         DWORD dummyLen;
84         long code;
85         int hostsize;
86
87         if (fileNamep) {
88               drivep = strchr(fileNamep, ':');
89               if (drivep && (drivep - fileNamep) >= 1) {
90                 tbuffer[0] = *(drivep-1);
91                 tbuffer[1] = ':';
92                 strcpy(tbuffer+2, SMB_IOCTL_FILENAME);
93               } else
94                 strcpy(tbuffer, SMB_IOCTL_FILENAME);
95         }
96         else {
97                 /* No file name specified, use UNC name */
98                 /* First look for gateway host in Registry */
99                 code = RegOpenKeyEx(HKEY_LOCAL_MACHINE, AFSConfigKeyName,
100                                         0, KEY_QUERY_VALUE, &parmKey);
101                 if (code != ERROR_SUCCESS)
102                         goto nogateway;
103                 dummyLen = sizeof(hostName);
104                 code = RegQueryValueEx(parmKey, "Gateway", NULL, NULL,
105                                         hostName, &dummyLen);
106                 RegCloseKey (parmKey);
107                 if (code == ERROR_SUCCESS)
108                         goto havehost;
109 nogateway:
110                 /* No gateway name in registry; use ourself */
111 #ifndef AFS_WIN95_ENV
112                 gethostname(hostName, sizeof(hostName));
113 #else
114                 /* DJGPP version of gethostname gets the NetBIOS
115                    name of the machine, so that is what we are using for
116                    the AFS server name instead of the DNS name. */
117                 hostsize = sizeof(hostName);
118                 GetComputerName(hostName, &hostsize);
119 #endif /* AFS_WIN95_ENV */
120
121 havehost:
122                 ctemp = strchr(hostName, '.');  /* turn ntafs.* into ntafs */
123                 if (ctemp) *ctemp = 0;
124                 hostName[11] = 0;
125
126                 _strupr(hostName);
127                 sprintf(tbuffer, "\\\\%s-AFS\\all%s",
128                         hostName, SMB_IOCTL_FILENAME);
129         }
130
131         fflush(stdout);
132         /* now open the file */
133         fh = CreateFile(tbuffer, GENERIC_READ | GENERIC_WRITE,
134                 FILE_SHARE_READ | FILE_SHARE_WRITE, NULL,
135                 OPEN_EXISTING, FILE_FLAG_WRITE_THROUGH, NULL);
136         fflush(stdout);
137         if (fh == INVALID_HANDLE_VALUE)
138                 return -1;
139         
140         /* return fh and success code */
141         *handlep = fh;
142         return 0;
143 }
144
145 static long Transceive(HANDLE handle, fs_ioctlRequest_t *reqp)
146 {
147         long rcount;
148         long ioCount;
149
150         rcount = reqp->mp - reqp->data;
151         if (rcount <= 0) return EINVAL;         /* not supposed to happen */
152         
153         if (!WriteFile(handle, reqp->data, rcount, &ioCount, NULL)) {
154                 /* failed to write */
155                 return GetLastError();
156         }
157         
158         if (!ReadFile(handle, reqp->data, sizeof(reqp->data), &ioCount, NULL)) {
159                 /* failed to read */
160                 return GetLastError();
161         }
162         
163         reqp->nbytes = ioCount;         /* set # of bytes available */
164         reqp->mp = reqp->data;          /* restart marshalling */
165
166         /* return success */
167         return 0;
168 }
169
170 static long MarshallLong(fs_ioctlRequest_t *reqp, long val)
171 {
172         memcpy(reqp->mp, &val, 4);
173         reqp->mp += 4;
174         return 0;
175 }
176
177 static long UnmarshallLong(fs_ioctlRequest_t *reqp, long *valp)
178 {
179         /* not enough data left */
180   if (reqp->nbytes < 4) { return -1; }
181
182         memcpy(valp, reqp->mp, 4);
183         reqp->mp += 4;
184         reqp->nbytes -= 4;
185         return 0;
186 }
187
188 /* includes marshalling NULL pointer as a null (0 length) string */
189 static long MarshallString(fs_ioctlRequest_t *reqp, char *stringp)
190 {
191         int count;
192         
193         if (stringp)
194                 count = strlen(stringp) + 1;    /* space required including null */
195         else count = 1;
196
197         /* watch for buffer overflow */
198         if ((reqp->mp - reqp->data) + count > sizeof(reqp->data)) return -1;
199         
200         if (stringp) memcpy(reqp->mp, stringp, count);
201         else *(reqp->mp) = 0;
202         reqp->mp += count;
203         return 0;
204 }
205
206 /* take a path with a drive letter, possibly relative, and return a full path
207  * without the drive letter.  This is the full path relative to the working
208  * dir for that drive letter.  The input and output paths can be the same.
209  */
210 static long fs_GetFullPath(char *pathp, char *outPathp, long outSize)
211 {
212         char tpath[1000];
213         char origPath[1000];
214         char *firstp;
215         long code;
216         int pathHasDrive;
217         int doSwitch;
218         char newPath[3];
219
220         if (pathp[0] != 0 && pathp[1] == ':') {
221                 /* there's a drive letter there */
222                 firstp = pathp+2;
223                 pathHasDrive = 1;
224         }
225         else {
226                 firstp = pathp;
227                 pathHasDrive = 0;
228         }
229         
230         if (*firstp == '\\' || *firstp == '/') {
231                 /* already an absolute pathname, just copy it back */
232                 strcpy(outPathp, firstp);
233                 return 0;
234         }
235         
236         GetCurrentDirectory(sizeof(origPath), origPath);
237         
238         doSwitch = 0;
239         if (pathHasDrive && (*pathp & ~0x20) != (origPath[0] & ~0x20)) {
240                 /* a drive has been specified and it isn't our current drive.
241                  * to get path, switch to it first.  Must case-fold drive letters
242                  * for user convenience.
243                  */
244                 doSwitch = 1;
245                 newPath[0] = *pathp;
246                 newPath[1] = ':';
247                 newPath[2] = 0;
248                 if (!SetCurrentDirectory(newPath)) {
249                         code = GetLastError();
250                         return code;
251                 }
252         }
253         
254         /* now get the absolute path to the current wdir in this drive */
255         GetCurrentDirectory(sizeof(tpath), tpath);
256         strcpy(outPathp, tpath+2);      /* skip drive letter */
257         /* if there is a non-null name after the drive, append it */
258         if (*firstp != 0) {
259                 strcat(outPathp, "\\");
260                 strcat(outPathp, firstp);
261         }
262
263         /* finally, if necessary, switch back to our home drive letter */
264         if (doSwitch) {
265                 SetCurrentDirectory(origPath);
266         }
267         
268         return 0;
269 }
270
271 long pioctl(char *pathp, long opcode, struct ViceIoctl *blobp, int follow)
272 {
273         fs_ioctlRequest_t preq;
274         long code;
275         long temp;
276         char fullPath[1000];
277         HANDLE reqHandle;
278
279         code = GetIoctlHandle(pathp, &reqHandle);
280         if (code) {
281             if (pathp)
282                 errno = EINVAL;
283             else
284                 errno = ENODEV;
285             return code;
286         }
287
288         /* init the request structure */
289         InitFSRequest(&preq);
290
291         /* marshall the opcode, the path name and the input parameters */
292         MarshallLong(&preq, opcode);
293         /* when marshalling the path, remove the drive letter, since we already
294          * used the drive letter to find the AFS daemon; we don't need it any more.
295          * Eventually we'll expand relative path names here, too, since again, only
296          * we understand those.
297          */
298         if (pathp) {
299                 code = fs_GetFullPath(pathp, fullPath, sizeof(fullPath));
300                 if (code) {
301                     CloseHandle(reqHandle);
302                     errno = EINVAL;
303                     return code;
304                 }
305         }
306         else {
307                 strcpy(fullPath, "");
308         }
309
310         MarshallString(&preq, fullPath);
311         if (blobp->in_size) {
312                 memcpy(preq.mp, blobp->in, blobp->in_size);
313                 preq.mp += blobp->in_size;
314         }
315         
316         /* now make the call */
317         code = Transceive(reqHandle, &preq);
318         if (code) {
319                 CloseHandle(reqHandle);
320                 return code;
321         }
322         
323         /* now unmarshall the return value */
324         UnmarshallLong(&preq, &temp);
325         if (temp != 0) {
326                 CloseHandle(reqHandle);
327                 errno = CMtoUNIXerror(temp);
328                 return -1;
329         }
330         
331         /* otherwise, unmarshall the output parameters */
332         if (blobp->out_size) {
333                 temp = blobp->out_size;
334                 if (preq.nbytes < temp) temp = preq.nbytes;
335                 memcpy(blobp->out, preq.mp, temp);
336                 blobp->out_size = temp;
337         }
338         
339         /* and return success */
340         CloseHandle(reqHandle);
341         return 0;
342 }