source/libsmb/clifsinfo.c

   1 /*
   2    Unix SMB/CIFS implementation.
   3    FS info functions
   4    Copyright (C) Stefan (metze) Metzmacher      2003
   5
   6    This program is free software; you can redistribute it and/or modify
   7    it under the terms of the GNU General Public License as published by
   8    the Free Software Foundation; either version 2 of the License, or
   9    (at your option) any later version.
  10
  11    This program 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
  14    GNU General Public License for more details.
  15
  16    You should have received a copy of the GNU General Public License
  17    along with this program; if not, write to the Free Software
  18    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  19 */
  20
  21 #include "includes.h"
  22
  23 /****************************************************************************
  24  Get UNIX extensions version info.
  25 ****************************************************************************/
  26
  27 BOOL cli_unix_extensions_version(struct cli_state *cli, uint16 *pmajor, uint16 *pminor,
  28                                         uint32 *pcaplow, uint32 *pcaphigh)
  29 {
  30         BOOL ret = False;
  31         uint16 setup;
  32         char param[2];
  33         char *rparam=NULL, *rdata=NULL;
  34         unsigned int rparam_count=0, rdata_count=0;
  35
  36         setup = TRANSACT2_QFSINFO;
  37
  38         SSVAL(param,0,SMB_QUERY_CIFS_UNIX_INFO);
  39
  40         if (!cli_send_trans(cli, SMBtrans2,
  41                     NULL,
  42                     0, 0,
  43                     &setup, 1, 0,
  44                     param, 2, 0,
  45                     NULL, 0, 560)) {
  46                 goto cleanup;
  47         }
  48
  49         if (!cli_receive_trans(cli, SMBtrans2,
  50                               &rparam, &rparam_count,
  51                               &rdata, &rdata_count)) {
  52                 goto cleanup;
  53         }
  54
  55         if (cli_is_error(cli)) {
  56                 ret = False;
  57                 goto cleanup;
  58         } else {
  59                 ret = True;
  60         }
  61
  62         if (rdata_count < 12) {
  63                 goto cleanup;
  64         }
  65
  66         *pmajor = SVAL(rdata,0);
  67         *pminor = SVAL(rdata,2);
  68         *pcaplow = IVAL(rdata,4);
  69         *pcaphigh = IVAL(rdata,8);
  70
  71         /* todo: but not yet needed
  72          *       return the other stuff
  73          */
  74
  75 cleanup:
  76         SAFE_FREE(rparam);
  77         SAFE_FREE(rdata);
  78
  79         return ret;
  80 }
  81
  82 BOOL cli_get_fs_attr_info(struct cli_state *cli, uint32 *fs_attr)
  83 {
  84         BOOL ret = False;
  85         uint16 setup;
  86         char param[2];
  87         char *rparam=NULL, *rdata=NULL;
  88         unsigned int rparam_count=0, rdata_count=0;
  89
  90         if (!cli||!fs_attr)
  91                 smb_panic("cli_get_fs_attr_info() called with NULL Pionter!");
  92
  93         setup = TRANSACT2_QFSINFO;
  94
  95         SSVAL(param,0,SMB_QUERY_FS_ATTRIBUTE_INFO);
  96
  97         if (!cli_send_trans(cli, SMBtrans2,
  98                     NULL,
  99                     0, 0,
 100                     &setup, 1, 0,
 101                     param, 2, 0,
 102                     NULL, 0, 560)) {
 103                 goto cleanup;
 104         }
 105
 106         if (!cli_receive_trans(cli, SMBtrans2,
 107                               &rparam, &rparam_count,
 108                               &rdata, &rdata_count)) {
 109                 goto cleanup;
 110         }
 111
 112         if (cli_is_error(cli)) {
 113                 ret = False;
 114                 goto cleanup;
 115         } else {
 116                 ret = True;
 117         }
 118
 119         if (rdata_count < 12) {
 120                 goto cleanup;
 121         }
 122
 123         *fs_attr = IVAL(rdata,0);
 124
 125         /* todo: but not yet needed
 126          *       return the other stuff
 127          */
 128
 129 cleanup:
 130         SAFE_FREE(rparam);
 131         SAFE_FREE(rdata);
 132
 133         return ret;
 134 }
 135
 136 BOOL cli_get_fs_volume_info_old(struct cli_state *cli, fstring volume_name, uint32 *pserial_number)
 137 {
 138         BOOL ret = False;
 139         uint16 setup;
 140         char param[2];
 141         char *rparam=NULL, *rdata=NULL;
 142         unsigned int rparam_count=0, rdata_count=0;
 143         unsigned char nlen;
 144
 145         setup = TRANSACT2_QFSINFO;
 146
 147         SSVAL(param,0,SMB_INFO_VOLUME);
 148
 149         if (!cli_send_trans(cli, SMBtrans2,
 150                     NULL,
 151                     0, 0,
 152                     &setup, 1, 0,
 153                     param, 2, 0,
 154                     NULL, 0, 560)) {
 155                 goto cleanup;
 156         }
 157
 158         if (!cli_receive_trans(cli, SMBtrans2,
 159                               &rparam, &rparam_count,
 160                               &rdata, &rdata_count)) {
 161                 goto cleanup;
 162         }
 163
 164         if (cli_is_error(cli)) {
 165                 ret = False;
 166                 goto cleanup;
 167         } else {
 168                 ret = True;
 169         }
 170
 171         if (rdata_count < 5) {
 172                 goto cleanup;
 173         }
 174
 175         if (pserial_number) {
 176                 *pserial_number = IVAL(rdata,0);
 177         }
 178         nlen = CVAL(rdata,l2_vol_cch);
 179         clistr_pull(cli, volume_name, rdata + l2_vol_szVolLabel, sizeof(fstring), nlen, STR_NOALIGN);
 180
 181         /* todo: but not yet needed
 182          *       return the other stuff
 183          */
 184
 185 cleanup:
 186         SAFE_FREE(rparam);
 187         SAFE_FREE(rdata);
 188
 189         return ret;
 190 }
 191
 192 BOOL cli_get_fs_volume_info(struct cli_state *cli, fstring volume_name, uint32 *pserial_number, time_t *pdate)
 193 {
 194         BOOL ret = False;
 195         uint16 setup;
 196         char param[2];
 197         char *rparam=NULL, *rdata=NULL;
 198         unsigned int rparam_count=0, rdata_count=0;
 199         unsigned int nlen;
 200
 201         setup = TRANSACT2_QFSINFO;
 202
 203         SSVAL(param,0,SMB_QUERY_FS_VOLUME_INFO);
 204
 205         if (!cli_send_trans(cli, SMBtrans2,
 206                     NULL,
 207                     0, 0,
 208                     &setup, 1, 0,
 209                     param, 2, 0,
 210                     NULL, 0, 560)) {
 211                 goto cleanup;
 212         }
 213
 214         if (!cli_receive_trans(cli, SMBtrans2,
 215                               &rparam, &rparam_count,
 216                               &rdata, &rdata_count)) {
 217                 goto cleanup;
 218         }
 219
 220         if (cli_is_error(cli)) {
 221                 ret = False;
 222                 goto cleanup;
 223         } else {
 224                 ret = True;
 225         }
 226
 227         if (rdata_count < 19) {
 228                 goto cleanup;
 229         }
 230
 231         if (pdate) {
 232                 *pdate = interpret_long_date(rdata);
 233         }
 234         if (pserial_number) {
 235                 *pserial_number = IVAL(rdata,8);
 236         }
 237         nlen = IVAL(rdata,12);
 238         clistr_pull(cli, volume_name, rdata + 18, sizeof(fstring), nlen, STR_UNICODE);
 239
 240         /* todo: but not yet needed
 241          *       return the other stuff
 242          */
 243
 244 cleanup:
 245         SAFE_FREE(rparam);
 246         SAFE_FREE(rdata);
 247
 248         return ret;
 249 }