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 <afsconfig.h>
  11 #include <afs/param.h>
  12
  13 RCSID
  14     ("$Header$");
  15
  16 #include <afs/stds.h>
  17 #include <windows.h>
  18 #include <stdlib.h>
  19 #include <stdio.h>
  20 #include <errno.h>
  21 #include <malloc.h>
  22 #include <string.h>
  23 #include <winioctl.h>
  24 #include <winsock2.h>
  25 #include <nb30.h>
  26
  27 #include <osi.h>
  28
  29 #include <cm.h>
  30 #include <cm_dir.h>
  31 #include <cm_cell.h>
  32 #include <cm_user.h>
  33 #include <cm_conn.h>
  34 #include <cm_scache.h>
  35 #include <cm_buf.h>
  36 #include <cm_utils.h>
  37 #include <cm_ioctl.h>
  38
  39 #include <smb.h>
  40 #include <pioctl_nt.h>
  41
  42 #include <lanahelper.h>
  43
  44 static char AFSConfigKeyName[] =
  45     "SYSTEM\\CurrentControlSet\\Services\\TransarcAFSDaemon\\Parameters";
  46
  47 #define FS_IOCTLREQUEST_MAXSIZE 8192
  48 /* big structure for representing and storing an IOCTL request */
  49 typedef struct fs_ioctlRequest {
  50     char *mp;                   /* marshalling/unmarshalling ptr */
  51     long nbytes;                /* bytes received (when unmarshalling) */
  52     char data[FS_IOCTLREQUEST_MAXSIZE]; /* data we're marshalling */
  53 } fs_ioctlRequest_t;
  54
  55 static int
  56 CMtoUNIXerror(int cm_code)
  57 {
  58     switch (cm_code) {
  59     case CM_ERROR_TIMEDOUT:
  60         return ETIMEDOUT;
  61     case CM_ERROR_NOACCESS:
  62         return EACCES;
  63     case CM_ERROR_NOSUCHFILE:
  64         return ENOENT;
  65     case CM_ERROR_INVAL:
  66         return EINVAL;
  67     case CM_ERROR_BADFD:
  68         return EBADF;
  69     case CM_ERROR_EXISTS:
  70         return EEXIST;
  71     case CM_ERROR_CROSSDEVLINK:
  72         return EXDEV;
  73     case CM_ERROR_NOTDIR:
  74         return ENOTDIR;
  75     case CM_ERROR_ISDIR:
  76         return EISDIR;
  77     case CM_ERROR_READONLY:
  78         return EROFS;
  79     case CM_ERROR_WOULDBLOCK:
  80         return EWOULDBLOCK;
  81     case CM_ERROR_NOSUCHCELL:
  82         return ESRCH;           /* hack */
  83     case CM_ERROR_NOSUCHVOLUME:
  84         return EPIPE;           /* hack */
  85     case CM_ERROR_NOMORETOKENS:
  86         return EDOM;            /* hack */
  87     case CM_ERROR_TOOMANYBUFS:
  88         return EFBIG;           /* hack */
  89     default:
  90         return ENOTTY;
  91     }
  92 }
  93
  94 static void
  95 InitFSRequest(fs_ioctlRequest_t * rp)
  96 {
  97     rp->mp = rp->data;
  98     rp->nbytes = 0;
  99 }
 100
 101 static long
 102 GetIoctlHandle(char *fileNamep, HANDLE * handlep)
 103 {
 104     char *drivep;
 105     char netbiosName[MAX_NB_NAME_LENGTH];
 106     char tbuffer[256]="";
 107     HANDLE fh;
 108
 109     if (fileNamep) {
 110         drivep = strchr(fileNamep, ':');
 111         if (drivep && (drivep - fileNamep) >= 1) {
 112             tbuffer[0] = *(drivep - 1);
 113             tbuffer[1] = ':';
 114             strcpy(tbuffer + 2, SMB_IOCTL_FILENAME);
 115         } else if (fileNamep[0] == fileNamep[1] &&
 116                                fileNamep[0] == '\\')
 117         {
 118             int count = 0, i = 0;
 119
 120             while (count < 4 && fileNamep[i]) {
 121                 tbuffer[i] = fileNamep[i];
 122                 if ( tbuffer[i++] == '\\' )
 123                     count++;
 124             }
 125             if (fileNamep[i] == 0)
 126                 tbuffer[i++] = '\\';
 127             tbuffer[i] = 0;
 128             strcat(tbuffer, SMB_IOCTL_FILENAME);
 129         } else {
 130             char curdir[256]="";
 131
 132             GetCurrentDirectory(sizeof(curdir), curdir);
 133             if ( curdir[1] == ':' ) {
 134                 tbuffer[0] = curdir[0];
 135                 tbuffer[1] = ':';
 136                 strcpy(tbuffer + 2, SMB_IOCTL_FILENAME);
 137             } else if (curdir[0] == curdir[1] &&
 138                        curdir[0] == '\\')
 139             {
 140                 int count = 0, i = 0;
 141
 142                 while (count < 4 && curdir[i]) {
 143                     tbuffer[i] = curdir[i];
 144                     if ( tbuffer[i++] == '\\' )
 145                         count++;
 146                 }
 147                 if (tbuffer[i] == 0)
 148                     tbuffer[i++] = '\\';
 149                 tbuffer[i] = 0;
 150                 strcat(tbuffer, SMB_IOCTL_FILENAME_NOSLASH);
 151             }
 152         }
 153         }
 154         if (!tbuffer[0]) {
 155         /* No file name starting with drive colon specified, use UNC name */
 156         lana_GetNetbiosName(netbiosName,LANA_NETBIOS_NAME_FULL);
 157         sprintf(tbuffer,"\\\\%s\\all%s",netbiosName,SMB_IOCTL_FILENAME);
 158     }
 159
 160     fflush(stdout);
 161     /* now open the file */
 162     fh = CreateFile(tbuffer, GENERIC_READ | GENERIC_WRITE,
 163                     FILE_SHARE_READ | FILE_SHARE_WRITE, NULL, OPEN_EXISTING,
 164                     FILE_FLAG_WRITE_THROUGH, NULL);
 165     fflush(stdout);
 166     if (fh == INVALID_HANDLE_VALUE)
 167         return -1;
 168
 169     /* return fh and success code */
 170     *handlep = fh;
 171     return 0;
 172 }
 173
 174 static long
 175 Transceive(HANDLE handle, fs_ioctlRequest_t * reqp)
 176 {
 177     long rcount;
 178     long ioCount;
 179
 180     rcount = reqp->mp - reqp->data;
 181     if (rcount <= 0)
 182         return EINVAL;          /* not supposed to happen */
 183
 184     if (!WriteFile(handle, reqp->data, rcount, &ioCount, NULL)) {
 185         /* failed to write */
 186         return GetLastError();
 187     }
 188
 189     if (!ReadFile(handle, reqp->data, sizeof(reqp->data), &ioCount, NULL)) {
 190         /* failed to read */
 191         return GetLastError();
 192     }
 193
 194     reqp->nbytes = ioCount;     /* set # of bytes available */
 195     reqp->mp = reqp->data;      /* restart marshalling */
 196
 197     /* return success */
 198     return 0;
 199 }
 200
 201 static long
 202 MarshallLong(fs_ioctlRequest_t * reqp, long val)
 203 {
 204     memcpy(reqp->mp, &val, 4);
 205     reqp->mp += 4;
 206     return 0;
 207 }
 208
 209 static long
 210 UnmarshallLong(fs_ioctlRequest_t * reqp, long *valp)
 211 {
 212     /* not enough data left */
 213     if (reqp->nbytes < 4) {
 214         return -1;
 215     }
 216
 217     memcpy(valp, reqp->mp, 4);
 218     reqp->mp += 4;
 219     reqp->nbytes -= 4;
 220     return 0;
 221 }
 222
 223 /* includes marshalling NULL pointer as a null (0 length) string */
 224 static long
 225 MarshallString(fs_ioctlRequest_t * reqp, char *stringp)
 226 {
 227     int count;
 228
 229     if (stringp)
 230         count = strlen(stringp) + 1;    /* space required including null */
 231     else
 232         count = 1;
 233
 234     /* watch for buffer overflow */
 235     if ((reqp->mp - reqp->data) + count > sizeof(reqp->data))
 236         return -1;
 237
 238     if (stringp)
 239         memcpy(reqp->mp, stringp, count);
 240     else
 241         *(reqp->mp) = 0;
 242     reqp->mp += count;
 243     return 0;
 244 }
 245
 246 /* take a path with a drive letter, possibly relative, and return a full path
 247  * without the drive letter.  This is the full path relative to the working
 248  * dir for that drive letter.  The input and output paths can be the same.
 249  */
 250 static long
 251 fs_GetFullPath(char *pathp, char *outPathp, long outSize)
 252 {
 253     char tpath[1000];
 254     char origPath[1000];
 255     char *firstp;
 256     long code;
 257     int pathHasDrive;
 258     int doSwitch;
 259     char newPath[3];
 260
 261     if (pathp[0] != 0 && pathp[1] == ':') {
 262         /* there's a drive letter there */
 263         firstp = pathp + 2;
 264         pathHasDrive = 1;
 265     } else {
 266         firstp = pathp;
 267         pathHasDrive = 0;
 268     }
 269
 270     if ( firstp[0] == '\\' && firstp[1] == '\\') {
 271         /* UNC path - strip off the server and sharename */
 272         int i, count;
 273         for ( i=2,count=2; count < 4 && firstp[i]; i++ ) {
 274             if ( firstp[i] == '\\' || firstp[i] == '/' ) {
 275                 count++;
 276             }
 277         }
 278         if ( firstp[i] == 0 ) {
 279             strcpy(outPathp,"\\");
 280         } else {
 281             strcpy(outPathp,&firstp[--i]);
 282         }
 283         return 0;
 284     } else if (firstp[0] == '\\' || firstp[0] == '/') {
 285         /* already an absolute pathname, just copy it back */
 286         strcpy(outPathp, firstp);
 287         return 0;
 288     }
 289
 290     GetCurrentDirectory(sizeof(origPath), origPath);
 291
 292     doSwitch = 0;
 293     if (pathHasDrive && (*pathp & ~0x20) != (origPath[0] & ~0x20)) {
 294         /* a drive has been specified and it isn't our current drive.
 295          * to get path, switch to it first.  Must case-fold drive letters
 296          * for user convenience.
 297          */
 298         doSwitch = 1;
 299         newPath[0] = *pathp;
 300         newPath[1] = ':';
 301         newPath[2] = 0;
 302         if (!SetCurrentDirectory(newPath)) {
 303             code = GetLastError();
 304             return code;
 305         }
 306     }
 307
 308     /* now get the absolute path to the current wdir in this drive */
 309     GetCurrentDirectory(sizeof(tpath), tpath);
 310         if (tpath[1] == ':')
 311             strcpy(outPathp, tpath + 2);        /* skip drive letter */
 312         else if ( tpath[0] == '\\' && tpath[1] == '\\') {
 313         /* UNC path - strip off the server and sharename */
 314         int i, count;
 315         for ( i=2,count=2; count < 4 && tpath[i]; i++ ) {
 316             if ( tpath[i] == '\\' || tpath[i] == '/' ) {
 317                 count++;
 318             }
 319         }
 320         if ( tpath[i] == 0 ) {
 321             strcpy(outPathp,"\\");
 322         } else {
 323             strcpy(outPathp,&tpath[--i]);
 324         }
 325     } else {
 326         /* this should never happen */
 327         strcpy(outPathp, tpath);
 328     }
 329
 330     /* if there is a non-null name after the drive, append it */
 331     if (*firstp != 0) {
 332                 int len = strlen(outPathp);
 333                 if (outPathp[len-1] != '\\' && outPathp[len-1] != '/')
 334                         strcat(outPathp, "\\");
 335                 strcat(outPathp, firstp);
 336     }
 337
 338     /* finally, if necessary, switch back to our home drive letter */
 339     if (doSwitch) {
 340         SetCurrentDirectory(origPath);
 341     }
 342
 343     return 0;
 344 }
 345
 346 long
 347 pioctl(char *pathp, long opcode, struct ViceIoctl *blobp, int follow)
 348 {
 349     fs_ioctlRequest_t preq;
 350     long code;
 351     long temp;
 352     char fullPath[1000];
 353     HANDLE reqHandle;
 354
 355     code = GetIoctlHandle(pathp, &reqHandle);
 356     if (code) {
 357         if (pathp)
 358             errno = EINVAL;
 359         else
 360             errno = ENODEV;
 361         return code;
 362     }
 363
 364     /* init the request structure */
 365     InitFSRequest(&preq);
 366
 367     /* marshall the opcode, the path name and the input parameters */
 368     MarshallLong(&preq, opcode);
 369     /* when marshalling the path, remove the drive letter, since we already
 370      * used the drive letter to find the AFS daemon; we don't need it any more.
 371      * Eventually we'll expand relative path names here, too, since again, only
 372      * we understand those.
 373      */
 374     if (pathp) {
 375         code = fs_GetFullPath(pathp, fullPath, sizeof(fullPath));
 376         if (code) {
 377             CloseHandle(reqHandle);
 378             errno = EINVAL;
 379             return code;
 380         }
 381     } else {
 382         strcpy(fullPath, "");
 383     }
 384
 385     MarshallString(&preq, fullPath);
 386     if (blobp->in_size) {
 387         memcpy(preq.mp, blobp->in, blobp->in_size);
 388         preq.mp += blobp->in_size;
 389     }
 390
 391     /* now make the call */
 392     code = Transceive(reqHandle, &preq);
 393     if (code) {
 394         CloseHandle(reqHandle);
 395         return code;
 396     }
 397
 398     /* now unmarshall the return value */
 399     UnmarshallLong(&preq, &temp);
 400     if (temp != 0) {
 401         CloseHandle(reqHandle);
 402         errno = CMtoUNIXerror(temp);
 403         return -1;
 404     }
 405
 406     /* otherwise, unmarshall the output parameters */
 407     if (blobp->out_size) {
 408         temp = blobp->out_size;
 409         if (preq.nbytes < temp)
 410             temp = preq.nbytes;
 411         memcpy(blobp->out, preq.mp, temp);
 412         blobp->out_size = temp;
 413     }
 414
 415     /* and return success */
 416     CloseHandle(reqHandle);
 417     return 0;
 418 }