examples/VFS/block/block.c

   1 /*
   2  *
   3  * Block access from links to dev mount points specified in PARAMCONF file
   4  *
   5  * Copyright (C) Ronald Kuetemeier, 2001
   6  *
   7  * This program is free software; you can redistribute it and/or modify
   8  * it under the terms of the GNU General Public License as published by
   9  * the Free Software Foundation; either version 2 of the License, or
  10  * (at your option) any later version.
  11  *
  12  * This program is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15  * GNU General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU General Public License
  18  * along with this program; if not, write to the Free Software
  19  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  20  */
  21
  22 #include "config.h"
  23 #include <stdio.h>
  24 #include <sys/stat.h>
  25 #include <sys/types.h>
  26 #include <string.h>
  27 #include <stdlib.h>
  28 #include <fcntl.h>
  29 #include <unistd.h>
  30 #include <errno.h>
  31
  32
  33 #ifdef HAVE_UTIME_H
  34 #include <utime.h>
  35 #endif
  36 #ifdef HAVE_DIRENT_H
  37 #include <dirent.h>
  38 #endif
  39 #include <syslog.h>
  40 #ifdef HAVE_FCNTL_H
  41 #include <fcntl.h>
  42 #endif
  43
  44
  45 #include <includes.h>
  46 #include <vfs.h>
  47
  48
  49
  50 DIR *block_opendir(struct connection_struct *conn, char *fname);
  51 int block_connect(struct connection_struct *conn, char *service, char *user);
  52 void block_disconnect(struct connection_struct *conn);
  53
  54
  55 /* VFS operations */
  56
  57
  58 extern struct vfs_ops default_vfs_ops;   /* For passthrough operation */
  59
  60 struct vfs_ops execute_vfs_ops = {
  61
  62         /* Disk operations */
  63
  64         block_connect,
  65         block_disconnect,
  66         NULL,                     /* disk free */
  67
  68         /* Directory operations */
  69
  70         block_opendir,
  71         NULL,                     /* readdir */
  72         NULL,
  73         NULL,
  74         NULL,                     /* closedir */
  75
  76         /* File operations */
  77
  78         NULL,
  79         NULL,
  80         NULL,                     /* read  */
  81         NULL,                     /* write */
  82         NULL,                     /* lseek */
  83         NULL,
  84         NULL,                     /* fsync */
  85         NULL,                     /* stat  */
  86         NULL,                     /* fstat */
  87         NULL,                     /* lstat */
  88         NULL,
  89         NULL,
  90         NULL,
  91         NULL,                     /* chown */
  92         NULL,
  93         NULL,                     /* chdir */
  94         NULL,                     /* getwd */
  95         NULL,                     /* utime */
  96         NULL,                     /* ftruncate */
  97         NULL,                     /* lock */
  98         NULL,                     /* fget_nt_acl */
  99         NULL,                     /* get_nt_acl */
 100         NULL,                     /* fset_nt_acl */
 101         NULL,                      /* set_nt_acl */
 102         NULL,
 103         NULL
 104 };
 105
 106
 107 #ifndef PARAMCONF
 108 #define PARAMCONF "/etc/samba-block.conf"
 109 #endif
 110
 111 extern BOOL pm_process(char *FileName, BOOL (*sfunc)(char *), BOOL(*pfunc)(char * , char *));
 112
 113 //functions
 114
 115 BOOL enter_pblock_mount(char *dir);
 116 BOOL get_section(char *sect);
 117 BOOL get_parameter_value(char *param, char *value);
 118 BOOL load_param(void);
 119 BOOL search(struct stat *stat_buf);
 120 BOOL dir_search(char *link, char *dir);
 121 BOOL enter_pblock_dir(char *dir);
 122
 123
 124
 125 typedef struct block_dir
 126 {
 127         dev_t st_dev;
 128         int str_len;
 129         char *dir_name;
 130         struct block_dir *next;
 131 } block_dir;
 132
 133
 134 static char *params[] = {"mount_point","dir_name"};
 135 enum                    { MOUNT_POINT , DIR_NAME };
 136
 137 static struct block_dir *pblock_mountp = NULL;
 138 static struct block_dir *pblock_dir = NULL;
 139
 140
 141
 142 /*
 143  * Load the conf file into a table
 144  */
 145
 146 BOOL load_param(void)
 147 {
 148
 149         if ((pm_process(PARAMCONF,&get_section,&get_parameter_value)) == TRUE)
 150         {
 151                 return TRUE;
 152
 153         }
 154         return FALSE;
 155 }
 156
 157
 158
 159 /*
 160  * Enter the key and data into the list
 161  *
 162  */
 163
 164 BOOL enter_pblock_mount(char *dir)
 165 {
 166         struct stat stat_buf;
 167         static struct block_dir *tmp_pblock;
 168
 169
 170         if((stat(dir,&stat_buf)) != 0)
 171         {
 172                 return FALSE;
 173         }
 174
 175         if(pblock_mountp == NULL)
 176         {
 177                 pblock_mountp = calloc(1, sizeof(block_dir));
 178                 if( pblock_mountp == NULL)
 179                 {
 180                         return FALSE;
 181                 }
 182                 tmp_pblock = pblock_mountp;
 183                 tmp_pblock->next = NULL;
 184
 185         }else
 186         {
 187                 tmp_pblock->next = calloc(1, sizeof(block_dir));
 188                 if(tmp_pblock->next == NULL)
 189                 {
 190                         return FALSE;
 191                 }
 192                 tmp_pblock = tmp_pblock->next;
 193                 tmp_pblock->next = NULL;
 194
 195         }
 196
 197
 198         tmp_pblock->st_dev = stat_buf.st_dev;
 199         tmp_pblock->dir_name = strdup(dir);
 200
 201
 202       return TRUE;
 203
 204 }
 205
 206
 207 /*
 208  * Enter the key and data into the list
 209  *
 210  */
 211
 212 BOOL enter_pblock_dir(char *dir)
 213 {
 214         static struct block_dir *tmp_pblock;
 215
 216
 217         if(pblock_dir == NULL)
 218         {
 219                 pblock_dir = calloc(1, sizeof(block_dir));
 220                 if( pblock_dir == NULL)
 221                 {
 222                         return FALSE;
 223                 }
 224                 tmp_pblock = pblock_dir;
 225                 tmp_pblock->next = NULL;
 226
 227         }else
 228         {
 229                 tmp_pblock->next = calloc(1, sizeof(block_dir));
 230                 if(tmp_pblock->next == NULL)
 231                 {
 232                         return FALSE;
 233                 }
 234                 tmp_pblock = tmp_pblock->next;
 235                 tmp_pblock->next = NULL;
 236
 237         }
 238
 239
 240         tmp_pblock->dir_name = strdup(dir);
 241         tmp_pblock->str_len = strlen(dir);
 242
 243
 244       return TRUE;
 245
 246 }
 247
 248
 249
 250
 251 /*
 252  * Function callback for config section names
 253  */
 254
 255 BOOL get_section(char *sect)
 256 {
 257         return TRUE;
 258 }
 259
 260
 261
 262 /*
 263  * Function callback for config parameter value pairs
 264  *
 265  */
 266
 267 BOOL get_parameter_value(char *param, char *value)
 268 {
 269         int i = 0, maxargs = sizeof(params) / sizeof(char *);
 270
 271
 272         for( i= 0; i < maxargs; i++)
 273         {
 274                 if (strcmp(param,params[i]) == 0)
 275                 {
 276                         switch(i)
 277                         {
 278                         case MOUNT_POINT :
 279                                 enter_pblock_mount(value);
 280                                 break;
 281                         case DIR_NAME :
 282                                 enter_pblock_dir(value);
 283                                 break;
 284                         default :
 285                                 break;
 286                         }
 287                 }
 288         }
 289
 290         return TRUE;
 291
 292 }
 293
 294
 295
 296
 297 /* VFS initialisation function.  Return initialised vfs_ops structure
 298    back to SAMBA. */
 299
 300 struct vfs_ops *vfs_init(int *vfs_version)
 301 {
 302         *vfs_version = SMB_VFS_INTERFACE_VERSION;
 303
 304         return(&execute_vfs_ops);
 305 }
 306
 307
 308 /*
 309  * VFS connect and param file loading
 310  */
 311
 312 int block_connect(struct connection_struct *conn, char *service, char *user)
 313 {
 314         if((load_param()) == FALSE)
 315         {
 316
 317                 return -1;
 318
 319         }
 320
 321         DEBUG(0,("%s connecting \n",conn->user));
 322
 323         return (default_vfs_ops.connect(conn, service,user));
 324 }
 325
 326 /*
 327  * Free allocated structures and disconnect
 328  *
 329  */
 330
 331
 332 void block_disconnect(struct connection_struct *conn)
 333 {
 334
 335         struct block_dir *tmp_pblock = (pblock_mountp == NULL ? pblock_dir : pblock_mountp);
 336         struct block_dir *free_pblock = NULL;
 337
 338         while(tmp_pblock != NULL)
 339         {
 340                 free(tmp_pblock->dir_name);
 341                 free_pblock = tmp_pblock;
 342                 tmp_pblock = tmp_pblock->next;
 343                 free(free_pblock);
 344
 345                 if(tmp_pblock == NULL && pblock_dir != NULL)
 346                 {
 347                         tmp_pblock = (pblock_mountp == NULL ? pblock_dir : NULL);
 348                         pblock_dir = NULL;
 349
 350                 }
 351
 352         }
 353
 354
 355
 356         default_vfs_ops.disconnect(conn);
 357 }
 358
 359 /*
 360  * VFS opendir
 361  */
 362
 363 DIR *block_opendir(struct connection_struct *conn, char *fname)
 364 {
 365
 366         char *dir_name = NULL;
 367         struct stat stat_buf;
 368
 369         dir_name = alloca((strlen(conn->origpath) + strlen(fname) + 2) * sizeof(char));
 370
 371         pstrcpy(dir_name,conn->origpath);
 372         pstrcat(dir_name, "/");
 373         strncat(dir_name, fname, strcspn(fname,"/"));
 374
 375         if((lstat(dir_name,&stat_buf)) == 0)
 376         {
 377                 if((S_ISLNK(stat_buf.st_mode)) == 1)
 378                 {
 379                         stat(dir_name,&stat_buf);
 380                         if((search(&stat_buf) || dir_search(dir_name, fname) ) == TRUE)
 381                         {
 382                                 DEBUG(0,("%s used link to blocked dir: %s \n", conn->user, dir_name));
 383                                 errno = EACCES;
 384                                 return NULL;
 385                         }
 386                 }
 387         }
 388
 389         return (default_vfs_ops.opendir(conn, fname));
 390 }
 391
 392
 393 /*
 394  * Find mount point to block in list
 395  */
 396
 397 BOOL search(struct stat *stat_buf)
 398 {
 399         struct block_dir *tmp_pblock = pblock_mountp;
 400
 401         while(tmp_pblock != NULL)
 402         {
 403
 404                 if(tmp_pblock->st_dev == stat_buf->st_dev)
 405                 {
 406                         return TRUE;
 407                 }
 408                 tmp_pblock = tmp_pblock->next;
 409         }
 410
 411         return FALSE;
 412
 413 }
 414
 415 /*
 416  * Find dir in list to block id the starting point is link from a share
 417  */
 418
 419 BOOL dir_search(char *link, char *dir)
 420 {
 421         char buf[PATH_MAX +1], *ext_path;
 422         int len = 0;
 423         struct block_dir *tmp_pblock = pblock_dir;
 424
 425         if((len = readlink(link,buf,sizeof(buf))) == -1)
 426         {
 427                 return TRUE;
 428
 429         }else
 430         {
 431                 buf[len] = '\0';
 432         }
 433
 434
 435         if((ext_path = strchr(dir,'/')) != NULL)
 436         {
 437                 pstrcat(buf,&ext_path[1]);
 438                 len = strlen(buf);
 439         }
 440
 441         while(tmp_pblock != NULL)
 442         {
 443                 if(len < tmp_pblock->str_len)
 444                 {
 445                         tmp_pblock = tmp_pblock->next;
 446                         continue;
 447                 }
 448
 449                 if((strstr(buf,tmp_pblock->dir_name)) != NULL)
 450                 {
 451                         return TRUE;
 452                 }
 453                 tmp_pblock = tmp_pblock->next;
 454         }
 455
 456
 457         return FALSE;
 458
 459 }
 460
 461
 462
 463
 464
 465
 466
 467
 468
 469
 470
 471
 472
 473
 474
 475
 476
 477
 478
 479
 480
 481
 482
 483
 484
 485
 486
 487
 488
 489
 490
 491
 492
 493
 494
 495
 496
 497
 498
 499
 500
 501
 502
 503
 504
 505
 506
 507
 508
 509
 510
 511
 512
 513
 514
 515
 516
 517
 518
 519
 520
 521
 522
 523
 524
 525
 526
 527
 528
 529
 530
 531
 532
 533
 534
 535
 536
 537
 538
 539
 540
 541
 542
 543
 544
 545
 546