source/lib/sysquotas.c

   1 /*
   2    Unix SMB/CIFS implementation.
   3    System QUOTA function wrappers
   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
  22 #include "includes.h"
  23
  24 #undef DBGC_CLASS
  25 #define DBGC_CLASS DBGC_QUOTA
  26
  27 #ifdef HAVE_SYS_QUOTAS
  28
  29 #if defined(HAVE_QUOTACTL_4A)
  30
  31 /*#endif HAVE_QUOTACTL_4A */
  32 #elif defined(HAVE_QUOTACTL_4B)
  33
  34 #error HAVE_QUOTACTL_4B not implemeted
  35
  36 /*#endif HAVE_QUOTACTL_4B */
  37 #elif defined(HAVE_QUOTACTL_3)
  38
  39 #error HAVE_QUOTACTL_3 not implemented
  40
  41 /* #endif  HAVE_QUOTACTL_3 */
  42 #else /* NO_QUOTACTL_USED */
  43
  44 #endif /* NO_QUOTACTL_USED */
  45
  46 #ifdef HAVE_MNTENT
  47 static int sys_path_to_bdev(const char *path, char **mntpath, char **bdev, char **fs)
  48 {
  49         int ret = -1;
  50         SMB_STRUCT_STAT S;
  51         FILE *fp;
  52         struct mntent *mnt;
  53         SMB_DEV_T devno;
  54
  55         /* find the block device file */
  56
  57         if (!path||!mntpath||!bdev||!fs)
  58                 smb_panic("sys_path_to_bdev: called with NULL pointer");
  59
  60         (*mntpath) = NULL;
  61         (*bdev) = NULL;
  62         (*fs) = NULL;
  63
  64         if ( sys_stat(path, &S) == -1 )
  65                 return (-1);
  66
  67         devno = S.st_dev ;
  68
  69         fp = setmntent(MOUNTED,"r");
  70
  71         while ((mnt = getmntent(fp))) {
  72                 if ( sys_stat(mnt->mnt_dir,&S) == -1 )
  73                         continue ;
  74
  75                 if (S.st_dev == devno) {
  76                         (*mntpath) = SMB_STRDUP(mnt->mnt_dir);
  77                         (*bdev) = SMB_STRDUP(mnt->mnt_fsname);
  78                         (*fs)   = SMB_STRDUP(mnt->mnt_type);
  79                         if ((*mntpath)&&(*bdev)&&(*fs)) {
  80                                 ret = 0;
  81                         } else {
  82                                 SAFE_FREE(*mntpath);
  83                                 SAFE_FREE(*bdev);
  84                                 SAFE_FREE(*fs);
  85                                 ret = -1;
  86                         }
  87
  88                         break;
  89                 }
  90         }
  91
  92         endmntent(fp) ;
  93
  94         return ret;
  95 }
  96 /* #endif HAVE_MNTENT */
  97 #elif defined(HAVE_DEVNM)
  98
  99 /* we have this on HPUX, ... */
 100 static int sys_path_to_bdev(const char *path, char **mntpath, char **bdev, char **fs)
 101 {
 102         int ret = -1;
 103         char dev_disk[256];
 104         SMB_STRUCT_STAT S;
 105
 106         if (!path||!mntpath||!bdev||!fs)
 107                 smb_panic("sys_path_to_bdev: called with NULL pointer");
 108
 109         (*mntpath) = NULL;
 110         (*bdev) = NULL;
 111         (*fs) = NULL;
 112
 113         /* find the block device file */
 114
 115         if ((ret=sys_stat(path, &S))!=0) {
 116                 return ret;
 117         }
 118
 119         if ((ret=devnm(S_IFBLK, S.st_dev, dev_disk, 256, 1))!=0) {
 120                 return ret;
 121         }
 122
 123         /* we should get the mntpath right...
 124          * but I don't know how
 125          * --metze
 126          */
 127         (*mntpath) = SMB_STRDUP(path);
 128         (*bdev) = SMB_STRDUP(dev_disk);
 129         if ((*mntpath)&&(*bdev)) {
 130                 ret = 0;
 131         } else {
 132                 SAFE_FREE(*mntpath);
 133                 SAFE_FREE(*bdev);
 134                 ret = -1;
 135         }
 136
 137
 138         return ret;
 139 }
 140
 141 /* #endif HAVE_DEVNM */
 142 #else
 143 /* we should fake this up...*/
 144 static int sys_path_to_bdev(const char *path, char **mntpath, char **bdev, char **fs)
 145 {
 146         int ret = -1;
 147
 148         if (!path||!mntpath||!bdev||!fs)
 149                 smb_panic("sys_path_to_bdev: called with NULL pointer");
 150
 151         (*mntpath) = NULL;
 152         (*bdev) = NULL;
 153         (*fs) = NULL;
 154
 155         (*mntpath) = SMB_STRDUP(path);
 156         if (*mntpath) {
 157                 ret = 0;
 158         } else {
 159                 SAFE_FREE(*mntpath);
 160                 ret = -1;
 161         }
 162
 163         return ret;
 164 }
 165 #endif
 166
 167 /*********************************************************************
 168  Now the list of all filesystem specific quota systems we have found
 169 **********************************************************************/
 170 static struct {
 171         const char *name;
 172         int (*get_quota)(const char *path, const char *bdev, enum SMB_QUOTA_TYPE qtype, unid_t id, SMB_DISK_QUOTA *dp);
 173         int (*set_quota)(const char *path, const char *bdev, enum SMB_QUOTA_TYPE qtype, unid_t id, SMB_DISK_QUOTA *dp);
 174 } sys_quota_backends[] = {
 175 #ifdef HAVE_XFS_QUOTAS
 176         {"xfs", sys_get_xfs_quota,      sys_set_xfs_quota},
 177 #endif /* HAVE_XFS_QUOTAS */
 178         {NULL,  NULL,                   NULL}
 179 };
 180
 181 static int command_get_quota(const char *path, enum SMB_QUOTA_TYPE qtype, unid_t id, SMB_DISK_QUOTA *dp)
 182 {
 183         const char *get_quota_command;
 184
 185         get_quota_command = lp_get_quota_command();
 186         if (get_quota_command && *get_quota_command) {
 187                 const char *p;
 188                 char *p2;
 189                 char **lines;
 190                 pstring syscmd;
 191                 int _id = -1;
 192
 193                 switch(qtype) {
 194                         case SMB_USER_QUOTA_TYPE:
 195                         case SMB_USER_FS_QUOTA_TYPE:
 196                                 _id = id.uid;
 197                                 break;
 198                         case SMB_GROUP_QUOTA_TYPE:
 199                         case SMB_GROUP_FS_QUOTA_TYPE:
 200                                 _id = id.gid;
 201                                 break;
 202                         default:
 203                                 DEBUG(0,("invalid quota type.\n"));
 204                                 return -1;
 205                 }
 206
 207                 slprintf(syscmd, sizeof(syscmd)-1,
 208                         "%s \"%s\" %d %d",
 209                         get_quota_command, path, qtype, _id);
 210
 211                 DEBUG (3, ("get_quota: Running command %s\n", syscmd));
 212
 213                 lines = file_lines_pload(syscmd, NULL);
 214                 if (lines) {
 215                         char *line = lines[0];
 216
 217                         DEBUG (3, ("Read output from get_quota, \"%s\"\n", line));
 218
 219                         /* we need to deal with long long unsigned here, if supported */
 220
 221                         dp->qflags = (enum SMB_QUOTA_TYPE)strtoul(line, &p2, 10);
 222                         p = p2;
 223                         while (p && *p && isspace(*p))
 224                                 p++;
 225                         if (p && *p)
 226                                 dp->curblocks = STR_TO_SMB_BIG_UINT(p, &p);
 227                         else
 228                                 goto invalid_param;
 229                         while (p && *p && isspace(*p))
 230                                 p++;
 231                         if (p && *p)
 232                                 dp->softlimit = STR_TO_SMB_BIG_UINT(p, &p);
 233                         else
 234                                 goto invalid_param;
 235                         while (p && *p && isspace(*p))
 236                                 p++;
 237                         if (p && *p)
 238                                 dp->hardlimit = STR_TO_SMB_BIG_UINT(p, &p);
 239                         else
 240                                 goto invalid_param;
 241                         while (p && *p && isspace(*p))
 242                                 p++;
 243                         if (p && *p)
 244                                 dp->curinodes = STR_TO_SMB_BIG_UINT(p, &p);
 245                         else
 246                                 goto invalid_param;
 247                         while (p && *p && isspace(*p))
 248                                 p++;
 249                         if (p && *p)
 250                                 dp->isoftlimit = STR_TO_SMB_BIG_UINT(p, &p);
 251                         else
 252                                 goto invalid_param;
 253                         while (p && *p && isspace(*p))
 254                                 p++;
 255                         if (p && *p)
 256                                 dp->ihardlimit = STR_TO_SMB_BIG_UINT(p, &p);
 257                         else
 258                                 goto invalid_param;
 259                         while (p && *p && isspace(*p))
 260                                 p++;
 261                         if (p && *p)
 262                                 dp->bsize = STR_TO_SMB_BIG_UINT(p, NULL);
 263                         else
 264                                 dp->bsize = 1024;
 265                         file_lines_free(lines);
 266                         DEBUG (3, ("Parsed output of get_quota, ...\n"));
 267
 268 #ifdef LARGE_SMB_OFF_T
 269                         DEBUGADD (5,(
 270                                 "qflags:%u curblocks:%llu softlimit:%llu hardlimit:%llu\n"
 271                                 "curinodes:%llu isoftlimit:%llu ihardlimit:%llu bsize:%llu\n",
 272                                 dp->qflags,(long long unsigned)dp->curblocks,
 273                                 (long long unsigned)dp->softlimit,(long long unsigned)dp->hardlimit,
 274                                 (long long unsigned)dp->curinodes,
 275                                 (long long unsigned)dp->isoftlimit,(long long unsigned)dp->ihardlimit,
 276                                 (long long unsigned)dp->bsize));
 277 #else /* LARGE_SMB_OFF_T */
 278                         DEBUGADD (5,(
 279                                 "qflags:%u curblocks:%lu softlimit:%lu hardlimit:%lu\n"
 280                                 "curinodes:%lu isoftlimit:%lu ihardlimit:%lu bsize:%lu\n",
 281                                 dp->qflags,(long unsigned)dp->curblocks,
 282                                 (long unsigned)dp->softlimit,(long unsigned)dp->hardlimit,
 283                                 (long unsigned)dp->curinodes,
 284                                 (long unsigned)dp->isoftlimit,(long unsigned)dp->ihardlimit,
 285                                 (long unsigned)dp->bsize));
 286 #endif /* LARGE_SMB_OFF_T */
 287                         return 0;
 288                 }
 289
 290                 DEBUG (0, ("get_quota_command failed!\n"));
 291                 return -1;
 292         }
 293
 294         errno = ENOSYS;
 295         return -1;
 296
 297 invalid_param:
 298         DEBUG(0,("The output of get_quota_command is invalid!\n"));
 299         return -1;
 300 }
 301
 302 static int command_set_quota(const char *path, enum SMB_QUOTA_TYPE qtype, unid_t id, SMB_DISK_QUOTA *dp)
 303 {
 304         const char *set_quota_command;
 305
 306         set_quota_command = lp_set_quota_command();
 307         if (set_quota_command && *set_quota_command) {
 308                 char **lines;
 309                 pstring syscmd;
 310                 int _id = -1;
 311
 312                 switch(qtype) {
 313                         case SMB_USER_QUOTA_TYPE:
 314                         case SMB_USER_FS_QUOTA_TYPE:
 315                                 _id = id.uid;
 316                                 break;
 317                         case SMB_GROUP_QUOTA_TYPE:
 318                         case SMB_GROUP_FS_QUOTA_TYPE:
 319                                 _id = id.gid;
 320                                 break;
 321                         default:
 322                                 return -1;
 323                 }
 324
 325 #ifdef LARGE_SMB_OFF_T
 326                 slprintf(syscmd, sizeof(syscmd)-1,
 327                         "%s \"%s\" %d %d "
 328                         "%u %llu %llu "
 329                         "%llu %llu %llu ",
 330                         set_quota_command, path, qtype, _id, dp->qflags,
 331                         (long long unsigned)dp->softlimit,(long long unsigned)dp->hardlimit,
 332                         (long long unsigned)dp->isoftlimit,(long long unsigned)dp->ihardlimit,
 333                         (long long unsigned)dp->bsize);
 334 #else /* LARGE_SMB_OFF_T */
 335                 slprintf(syscmd, sizeof(syscmd)-1,
 336                         "%s \"%s\" %d %d "
 337                         "%u %lu %lu "
 338                         "%lu %lu %lu ",
 339                         set_quota_command, path, qtype, _id, dp->qflags,
 340                         (long unsigned)dp->softlimit,(long unsigned)dp->hardlimit,
 341                         (long unsigned)dp->isoftlimit,(long unsigned)dp->ihardlimit,
 342                         (long unsigned)dp->bsize);
 343 #endif /* LARGE_SMB_OFF_T */
 344
 345
 346
 347                 DEBUG (3, ("get_quota: Running command %s\n", syscmd));
 348
 349                 lines = file_lines_pload(syscmd, NULL);
 350                 if (lines) {
 351                         char *line = lines[0];
 352
 353                         DEBUG (3, ("Read output from set_quota, \"%s\"\n", line));
 354
 355                         file_lines_free(lines);
 356
 357                         return 0;
 358                 }
 359                 DEBUG (0, ("set_quota_command failed!\n"));
 360                 return -1;
 361         }
 362
 363         errno = ENOSYS;
 364         return -1;
 365 }
 366
 367 int sys_get_quota(const char *path, enum SMB_QUOTA_TYPE qtype, unid_t id, SMB_DISK_QUOTA *dp)
 368 {
 369         int ret = -1;
 370         int i;
 371         BOOL ready = False;
 372         char *mntpath = NULL;
 373         char *bdev = NULL;
 374         char *fs = NULL;
 375
 376         if (!path||!dp)
 377                 smb_panic("sys_get_quota: called with NULL pointer");
 378
 379         if (command_get_quota(path, qtype, id, dp)==0) {
 380                 return 0;
 381         } else if (errno != ENOSYS) {
 382                 return -1;
 383         }
 384
 385         if ((ret=sys_path_to_bdev(path,&mntpath,&bdev,&fs))!=0) {
 386                 DEBUG(0,("sys_path_to_bdev() failed for path [%s]!\n",path));
 387                 return ret;
 388         }
 389
 390         errno = 0;
 391         DEBUG(10,("sys_get_quota() uid(%u, %u)\n", (unsigned)getuid(), (unsigned)geteuid()));
 392
 393         for (i=0;(fs && sys_quota_backends[i].name && sys_quota_backends[i].get_quota);i++) {
 394                 if (strcmp(fs,sys_quota_backends[i].name)==0) {
 395                         ret = sys_quota_backends[i].get_quota(mntpath, bdev, qtype, id, dp);
 396                         if (ret!=0) {
 397                                 DEBUG(3,("sys_get_%s_quota() failed for mntpath[%s] bdev[%s] qtype[%d] id[%d]: %s.\n",
 398                                         fs,mntpath,bdev,qtype,(qtype==SMB_GROUP_QUOTA_TYPE?id.gid:id.uid),strerror(errno)));
 399                         } else {
 400                                 DEBUG(10,("sys_get_%s_quota() called for mntpath[%s] bdev[%s] qtype[%d] id[%d].\n",
 401                                         fs,mntpath,bdev,qtype,(qtype==SMB_GROUP_QUOTA_TYPE?id.gid:id.uid)));
 402                         }
 403                         ready = True;
 404                         break;
 405                 }
 406         }
 407
 408         if (!ready) {
 409                 /* use the default vfs quota functions */
 410                 ret=sys_get_vfs_quota(mntpath, bdev, qtype, id, dp);
 411                 if (ret!=0) {
 412                         DEBUG(3,("sys_get_%s_quota() failed for mntpath[%s] bdev[%s] qtype[%d] id[%d]: %s\n",
 413                                 "vfs",mntpath,bdev,qtype,(qtype==SMB_GROUP_QUOTA_TYPE?id.gid:id.uid),strerror(errno)));
 414                 } else {
 415                         DEBUG(10,("sys_get_%s_quota() called for mntpath[%s] bdev[%s] qtype[%d] id[%d].\n",
 416                                 "vfs",mntpath,bdev,qtype,(qtype==SMB_GROUP_QUOTA_TYPE?id.gid:id.uid)));
 417                 }
 418         }
 419
 420         SAFE_FREE(mntpath);
 421         SAFE_FREE(bdev);
 422         SAFE_FREE(fs);
 423
 424         if ((ret!=0)&& (errno == EDQUOT)) {
 425                 DEBUG(10,("sys_get_quota() warning over quota!\n"));
 426                 return 0;
 427         }
 428
 429         return ret;
 430 }
 431
 432 int sys_set_quota(const char *path, enum SMB_QUOTA_TYPE qtype, unid_t id, SMB_DISK_QUOTA *dp)
 433 {
 434         int ret = -1;
 435         int i;
 436         BOOL ready = False;
 437         char *mntpath = NULL;
 438         char *bdev = NULL;
 439         char *fs = NULL;
 440
 441         /* find the block device file */
 442
 443         if (!path||!dp)
 444                 smb_panic("get_smb_quota: called with NULL pointer");
 445
 446         if (command_set_quota(path, qtype, id, dp)==0) {
 447                 return 0;
 448         } else if (errno != ENOSYS) {
 449                 return -1;
 450         }
 451
 452         if ((ret=sys_path_to_bdev(path,&mntpath,&bdev,&fs))!=0) {
 453                 DEBUG(0,("sys_path_to_bdev() failed for path [%s]!\n",path));
 454                 return ret;
 455         }
 456
 457         errno = 0;
 458         DEBUG(10,("sys_set_quota() uid(%u, %u)\n", (unsigned)getuid(), (unsigned)geteuid()));
 459
 460         for (i=0;(fs && sys_quota_backends[i].name && sys_quota_backends[i].set_quota);i++) {
 461                 if (strcmp(fs,sys_quota_backends[i].name)==0) {
 462                         ret = sys_quota_backends[i].set_quota(mntpath, bdev, qtype, id, dp);
 463                         if (ret!=0) {
 464                                 DEBUG(3,("sys_set_%s_quota() failed for mntpath[%s] bdev[%s] qtype[%d] id[%d]: %s.\n",
 465                                         fs,mntpath,bdev,qtype,(qtype==SMB_GROUP_QUOTA_TYPE?id.gid:id.uid),strerror(errno)));
 466                         } else {
 467                                 DEBUG(10,("sys_set_%s_quota() called for mntpath[%s] bdev[%s] qtype[%d] id[%d].\n",
 468                                         fs,mntpath,bdev,qtype,(qtype==SMB_GROUP_QUOTA_TYPE?id.gid:id.uid)));
 469                         }
 470                         ready = True;
 471                         break;
 472                 }
 473         }
 474
 475         if (!ready) {
 476                 /* use the default vfs quota functions */
 477                 ret=sys_set_vfs_quota(mntpath, bdev, qtype, id, dp);
 478                 if (ret!=0) {
 479                         DEBUG(3,("sys_set_%s_quota() failed for mntpath[%s] bdev[%s] qtype[%d] id[%d]: %s.\n",
 480                                 "vfs",mntpath,bdev,qtype,(qtype==SMB_GROUP_QUOTA_TYPE?id.gid:id.uid),strerror(errno)));
 481                 } else {
 482                         DEBUG(10,("sys_set_%s_quota() called for mntpath[%s] bdev[%s] qtype[%d] id[%d].\n",
 483                                 "vfs",mntpath,bdev,qtype,(qtype==SMB_GROUP_QUOTA_TYPE?id.gid:id.uid)));
 484                 }
 485         }
 486
 487         SAFE_FREE(mntpath);
 488         SAFE_FREE(bdev);
 489         SAFE_FREE(fs);
 490
 491         if ((ret!=0)&& (errno == EDQUOT)) {
 492                 DEBUG(10,("sys_set_quota() warning over quota!\n"));
 493                 return 0;
 494         }
 495
 496         return ret;
 497 }
 498
 499 #else /* HAVE_SYS_QUOTAS */
 500  void dummy_sysquotas_c(void);
 501
 502  void dummy_sysquotas_c(void)
 503 {
 504         return;
 505 }
 506 #endif /* HAVE_SYS_QUOTAS */
 507