src/WINNT/afsd/smb_ioctl.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/param.h>
  11 #include <afs/stds.h>
  12
  13 #include <windows.h>
  14 #include <stdlib.h>
  15 #include <malloc.h>
  16 #include <string.h>
  17 #include <stdio.h>
  18 #include <time.h>
  19
  20 #include <osi.h>
  21
  22 #include "afsd.h"
  23
  24 #include "smb.h"
  25
  26 smb_ioctlProc_t *smb_ioctlProcsp[SMB_IOCTL_MAXPROCS];
  27
  28 void smb_InitIoctl(void)
  29 {
  30         smb_ioctlProcsp[VIOCGETAL] = cm_IoctlGetACL;
  31         smb_ioctlProcsp[VIOC_FILE_CELL_NAME] = cm_IoctlGetFileCellName;
  32         smb_ioctlProcsp[VIOCSETAL] = cm_IoctlSetACL;
  33         smb_ioctlProcsp[VIOC_FLUSHVOLUME] = cm_IoctlFlushVolume;
  34         smb_ioctlProcsp[VIOCFLUSH] = cm_IoctlFlushFile;
  35         smb_ioctlProcsp[VIOCSETVOLSTAT] = cm_IoctlSetVolumeStatus;
  36         smb_ioctlProcsp[VIOCGETVOLSTAT] = cm_IoctlGetVolumeStatus;
  37         smb_ioctlProcsp[VIOCWHEREIS] = cm_IoctlWhereIs;
  38         smb_ioctlProcsp[VIOC_AFS_STAT_MT_PT] = cm_IoctlStatMountPoint;
  39         smb_ioctlProcsp[VIOC_AFS_DELETE_MT_PT] = cm_IoctlDeleteMountPoint;
  40         smb_ioctlProcsp[VIOCCKSERV] = cm_IoctlCheckServers;
  41         smb_ioctlProcsp[VIOC_GAG] = cm_IoctlGag;
  42         smb_ioctlProcsp[VIOCCKBACK] = cm_IoctlCheckVolumes;
  43         smb_ioctlProcsp[VIOCSETCACHESIZE] = cm_IoctlSetCacheSize;
  44         smb_ioctlProcsp[VIOCGETCACHEPARMS] = cm_IoctlGetCacheParms;
  45         smb_ioctlProcsp[VIOCGETCELL] = cm_IoctlGetCell;
  46         smb_ioctlProcsp[VIOCNEWCELL] = cm_IoctlNewCell;
  47         smb_ioctlProcsp[VIOC_GET_WS_CELL] = cm_IoctlGetWsCell;
  48         smb_ioctlProcsp[VIOC_AFS_SYSNAME] = cm_IoctlSysName;
  49         smb_ioctlProcsp[VIOC_GETCELLSTATUS] = cm_IoctlGetCellStatus;
  50         smb_ioctlProcsp[VIOC_SETCELLSTATUS] = cm_IoctlSetCellStatus;
  51         smb_ioctlProcsp[VIOC_SETSPREFS] = cm_IoctlSetSPrefs;
  52         smb_ioctlProcsp[VIOC_GETSPREFS] = cm_IoctlGetSPrefs;
  53         smb_ioctlProcsp[VIOC_STOREBEHIND] = cm_IoctlStoreBehind;
  54         smb_ioctlProcsp[VIOC_AFS_CREATE_MT_PT] = cm_IoctlCreateMountPoint;
  55         smb_ioctlProcsp[VIOC_TRACECTL] = cm_IoctlTraceControl;
  56         smb_ioctlProcsp[VIOCSETTOK] = cm_IoctlSetToken;
  57         smb_ioctlProcsp[VIOCGETTOK] = cm_IoctlGetTokenIter;
  58         smb_ioctlProcsp[VIOCNEWGETTOK] = cm_IoctlGetToken;
  59         smb_ioctlProcsp[VIOCDELTOK] = cm_IoctlDelToken;
  60         smb_ioctlProcsp[VIOCDELALLTOK] = cm_IoctlDelAllToken;
  61         smb_ioctlProcsp[VIOC_SYMLINK] = cm_IoctlSymlink;
  62         smb_ioctlProcsp[VIOC_LISTSYMLINK] = cm_IoctlListlink;
  63         smb_ioctlProcsp[VIOC_DELSYMLINK] = cm_IoctlDeletelink;
  64         smb_ioctlProcsp[VIOC_MAKESUBMOUNT] = cm_IoctlMakeSubmount;
  65         smb_ioctlProcsp[VIOC_GETRXKCRYPT] = cm_IoctlGetRxkcrypt;
  66         smb_ioctlProcsp[VIOC_SETRXKCRYPT] = cm_IoctlSetRxkcrypt;
  67 }
  68
  69 /* called to make a fid structure into an IOCTL fid structure */
  70 void smb_SetupIoctlFid(smb_fid_t *fidp, cm_space_t *prefix)
  71 {
  72         smb_ioctl_t *iop;
  73         cm_space_t *copyPrefix;
  74
  75         lock_ObtainMutex(&fidp->mx);
  76         fidp->flags |= SMB_FID_IOCTL;
  77         fidp->scp = &cm_fakeSCache;
  78         if (fidp->ioctlp == NULL) {
  79                 iop = malloc(sizeof(*iop));
  80                 memset(iop, 0, sizeof(*iop));
  81                 fidp->ioctlp = iop;
  82         }
  83         if (prefix) {
  84                 copyPrefix = cm_GetSpace();
  85                 strcpy(copyPrefix->data, prefix->data);
  86                 fidp->ioctlp->prefix = copyPrefix;
  87         }
  88         lock_ReleaseMutex(&fidp->mx);
  89 }
  90
  91 /* called when we receive a read call, does the send of the received data if
  92  * this is the first read call.  This is the function that actually makes the
  93  * call to the ioctl code.
  94  */
  95 smb_IoctlPrepareRead(smb_fid_t *fidp, smb_ioctl_t *ioctlp, cm_user_t *userp)
  96 {
  97         long opcode;
  98         smb_ioctlProc_t *procp;
  99         long code;
 100
 101         if (ioctlp->flags & SMB_IOCTLFLAG_DATAIN) {
 102                 ioctlp->flags &= ~SMB_IOCTLFLAG_DATAIN;
 103
 104                 /* do the call now, or fail if we didn't get an opcode, or
 105                  * enough of an opcode.
 106                  */
 107                 if (ioctlp->inCopied < sizeof(long)) return CM_ERROR_INVAL;
 108                 memcpy(&opcode, ioctlp->inDatap, sizeof(long));
 109                 ioctlp->inDatap += sizeof(long);
 110
 111                 osi_Log1(afsd_logp, "Ioctl opcode %d", opcode);
 112
 113                 /* check for opcode out of bounds */
 114                 if (opcode < 0 || opcode >= SMB_IOCTL_MAXPROCS)
 115                         return CM_ERROR_TOOBIG;
 116
 117                 /* check for no such proc */
 118                 procp = smb_ioctlProcsp[opcode];
 119                 if (procp == NULL) return CM_ERROR_BADOP;
 120
 121                 /* otherwise, make the call */
 122                 ioctlp->outDatap += sizeof(long);       /* reserve room for return code */
 123                 code = (*procp)(ioctlp, userp);
 124
 125                 osi_Log1(afsd_logp, "Ioctl return code %d", code);
 126
 127                 /* copy in return code */
 128                 memcpy(ioctlp->outAllocp, &code, sizeof(long));
 129         }
 130         return 0;
 131 }
 132
 133 /* called when we receive a write call.  If this is the first write call after
 134  * a series of reads (or the very first call), then we start a new call.
 135  * We also ensure that things are properly initialized for the start of a call.
 136  */
 137 void smb_IoctlPrepareWrite(smb_fid_t *fidp, smb_ioctl_t *ioctlp)
 138 {
 139         /* make sure the buffer(s) are allocated */
 140         if (!ioctlp->inAllocp) ioctlp->inAllocp = malloc(SMB_IOCTL_MAXDATA);
 141         if (!ioctlp->outAllocp) ioctlp->outAllocp = malloc(SMB_IOCTL_MAXDATA);
 142
 143         /* and make sure that we've reset our state for the new incoming request */
 144         if (!(ioctlp->flags & SMB_IOCTLFLAG_DATAIN)) {
 145                 ioctlp->inCopied = 0;
 146                 ioctlp->outCopied = 0;
 147                 ioctlp->inDatap = ioctlp->inAllocp;
 148                 ioctlp->outDatap = ioctlp->outAllocp;
 149                 ioctlp->flags |= SMB_IOCTLFLAG_DATAIN;
 150         }
 151 }
 152
 153 /* called from smb_ReceiveCoreRead when we receive a read on the ioctl fid */
 154 long smb_IoctlRead(smb_fid_t *fidp, smb_vc_t *vcp, smb_packet_t *inp,
 155         smb_packet_t *outp)
 156 {
 157         smb_ioctl_t *iop;
 158         long count;
 159         long leftToCopy;
 160         char *op;
 161         long code;
 162         cm_user_t *userp;
 163
 164         iop = fidp->ioctlp;
 165         count = smb_GetSMBParm(inp, 1);
 166         userp = smb_GetUser(vcp, inp);
 167
 168         /* Identify tree */
 169         iop->tidPathp = smb_GetTIDPath(vcp, ((smb_t *)inp)->tid);
 170
 171         /* turn the connection around, if required */
 172         code = smb_IoctlPrepareRead(fidp, iop, userp);
 173
 174         if (code) {
 175                 cm_ReleaseUser(userp);
 176                 return code;
 177         }
 178
 179         if (iop->flags & SMB_IOCTLFLAG_LOGON) {
 180                 vcp->logonDLLUser = userp;
 181                 userp->flags |= CM_USERFLAG_WASLOGON;
 182         }
 183
 184         leftToCopy = (iop->outDatap - iop->outAllocp) - iop->outCopied;
 185         if (count > leftToCopy) count = leftToCopy;
 186
 187         /* now set the parms for a read of count bytes */
 188         smb_SetSMBParm(outp, 0, count);
 189         smb_SetSMBParm(outp, 1, 0);
 190         smb_SetSMBParm(outp, 2, 0);
 191         smb_SetSMBParm(outp, 3, 0);
 192         smb_SetSMBParm(outp, 4, 0);
 193
 194         smb_SetSMBDataLength(outp, count+3);
 195
 196         op = smb_GetSMBData(outp, NULL);
 197         *op++ = 1;
 198         *op++ = count & 0xff;
 199         *op++ = (count >> 8) & 0xff;
 200
 201         /* now copy the data into the response packet */
 202         memcpy(op, iop->outCopied + iop->outAllocp, count);
 203
 204         /* and adjust the counters */
 205         iop->outCopied += count;
 206
 207         cm_ReleaseUser(userp);
 208         smb_ReleaseFID(fidp);
 209
 210         return 0;
 211 }
 212
 213 /* called from smb_ReceiveCoreWrite when we receive a write call on the IOCTL
 214  * file descriptor.
 215  */
 216 long smb_IoctlWrite(smb_fid_t *fidp, smb_vc_t *vcp, smb_packet_t *inp, smb_packet_t *outp)
 217 {
 218         smb_ioctl_t *iop;
 219         long count;
 220         long code;
 221         char *op;
 222         long inDataBlockCount;
 223
 224         code = 0;
 225         count = smb_GetSMBParm(inp, 1);
 226         iop = fidp->ioctlp;
 227
 228         smb_IoctlPrepareWrite(fidp, iop);
 229
 230         op = smb_GetSMBData(inp, NULL);
 231         op = smb_ParseDataBlock(op, NULL, &inDataBlockCount);
 232
 233         if (count + iop->inCopied > SMB_IOCTL_MAXDATA) {
 234                 code = CM_ERROR_TOOBIG;
 235                 goto done;
 236         }
 237
 238         /* copy data */
 239         memcpy(iop->inDatap + iop->inCopied, op, count);
 240
 241         /* adjust counts */
 242         iop->inCopied += count;
 243
 244 done:
 245         /* return # of bytes written */
 246         if (code == 0) {
 247                 smb_SetSMBParm(outp, 0, count);
 248                 smb_SetSMBDataLength(outp, 0);
 249         }
 250
 251         smb_ReleaseFID(fidp);
 252         return code;
 253 }
 254
 255 /* called from V3 read to handle IOCTL descriptor reads */
 256 long smb_IoctlV3Read(smb_fid_t *fidp, smb_vc_t *vcp, smb_packet_t *inp, smb_packet_t *outp)
 257 {
 258         smb_ioctl_t *iop;
 259         long count;
 260         long code;
 261         long leftToCopy;
 262         char *op;
 263         cm_user_t *userp;
 264
 265         iop = fidp->ioctlp;
 266         count = smb_GetSMBParm(inp, 5);
 267
 268         userp = smb_GetUser(vcp, inp);
 269
 270         {
 271                 smb_user_t *uidp;
 272
 273                 uidp = smb_FindUID(vcp, ((smb_t *)inp)->uid, 0);
 274                 osi_Log3(afsd_logp, "Ioctl uid %d user %x name %s",
 275                          uidp->userID, userp,
 276                          osi_LogSaveString(afsd_logp, uidp->name));
 277                 smb_ReleaseUID(uidp);
 278         }
 279
 280         iop->tidPathp = smb_GetTIDPath(vcp, ((smb_t *)inp)->tid);
 281
 282         code = smb_IoctlPrepareRead(fidp, iop, userp);
 283         if (code) {
 284                 cm_ReleaseUser(userp);
 285                 smb_ReleaseFID(fidp);
 286                 return code;
 287         }
 288
 289         if (iop->flags & SMB_IOCTLFLAG_LOGON) {
 290                 vcp->logonDLLUser = userp;
 291                 userp->flags |= CM_USERFLAG_WASLOGON;
 292         }
 293
 294         leftToCopy = (iop->outDatap - iop->outAllocp) - iop->outCopied;
 295         if (count > leftToCopy) count = leftToCopy;
 296
 297         /* 0 and 1 are reserved for request chaining, were setup by our caller,
 298          * and will be further filled in after we return.
 299          */
 300         smb_SetSMBParm(outp, 2, 0);     /* remaining bytes, for pipes */
 301         smb_SetSMBParm(outp, 3, 0);     /* resvd */
 302         smb_SetSMBParm(outp, 4, 0);     /* resvd */
 303         smb_SetSMBParm(outp, 5, count); /* # of bytes we're going to read */
 304         /* fill in #6 when we have all the parameters' space reserved */
 305         smb_SetSMBParm(outp, 7, 0);     /* resv'd */
 306         smb_SetSMBParm(outp, 8, 0);     /* resv'd */
 307         smb_SetSMBParm(outp, 9, 0);     /* resv'd */
 308         smb_SetSMBParm(outp, 10, 0);    /* resv'd */
 309         smb_SetSMBParm(outp, 11, 0);    /* reserved */
 310
 311         /* get op ptr after putting in the last parm, since otherwise we don't
 312          * know where the data really is.
 313          */
 314         op = smb_GetSMBData(outp, NULL);
 315
 316         /* now fill in offset from start of SMB header to first data byte (to op) */
 317         smb_SetSMBParm(outp, 6, ((int) (op - outp->data)));
 318
 319         /* set the packet data length the count of the # of bytes */
 320         smb_SetSMBDataLength(outp, count);
 321
 322         /* now copy the data into the response packet */
 323         memcpy(op, iop->outCopied + iop->outAllocp, count);
 324
 325         /* and adjust the counters */
 326         iop->outCopied += count;
 327
 328         /* and cleanup things */
 329         cm_ReleaseUser(userp);
 330         smb_ReleaseFID(fidp);
 331
 332         return 0;
 333 }
 334
 335 /* called from Read Raw to handle IOCTL descriptor reads */
 336 long smb_IoctlReadRaw(smb_fid_t *fidp, smb_vc_t *vcp, smb_packet_t *inp,
 337         smb_packet_t *outp)
 338 {
 339         smb_ioctl_t *iop;
 340         long leftToCopy;
 341         NCB *ncbp;
 342         long code;
 343         cm_user_t *userp;
 344
 345         iop = fidp->ioctlp;
 346
 347         userp = smb_GetUser(vcp, inp);
 348
 349         {
 350                 smb_user_t *uidp;
 351
 352                 uidp = smb_FindUID(vcp, ((smb_t *)inp)->uid, 0);
 353                 osi_Log3(afsd_logp, "Ioctl uid %d user %x name %s",
 354                          uidp->userID, userp,
 355                          osi_LogSaveString(afsd_logp, uidp->name));
 356                 smb_ReleaseUID(uidp);
 357         }
 358
 359         iop->tidPathp = smb_GetTIDPath(vcp, ((smb_t *)inp)->tid);
 360
 361         code = smb_IoctlPrepareRead(fidp, iop, userp);
 362         if (code) {
 363                 cm_ReleaseUser(userp);
 364                 smb_ReleaseFID(fidp);
 365                 return code;
 366         }
 367
 368         if (iop->flags & SMB_IOCTLFLAG_LOGON) {
 369                 vcp->logonDLLUser = userp;
 370                 userp->flags |= CM_USERFLAG_WASLOGON;
 371         }
 372
 373         leftToCopy = (iop->outDatap - iop->outAllocp) - iop->outCopied;
 374
 375         ncbp = outp->ncbp;
 376         memset((char *)ncbp, 0, sizeof(NCB));
 377
 378         ncbp->ncb_length = (unsigned short) leftToCopy;
 379         ncbp->ncb_lsn = (unsigned char) vcp->lsn;
 380         ncbp->ncb_command = NCBSEND;
 381         ncbp->ncb_buffer = iop->outCopied + iop->outAllocp;
 382
 383         code = Netbios(ncbp);
 384         if (code != 0)
 385                 osi_Log1(afsd_logp, "ReadRaw send failure code %d", code);
 386
 387         cm_ReleaseUser(userp);
 388         smb_ReleaseFID(fidp);
 389
 390         return 0;
 391 }