s3-vfs: Use the system. namespace for fake ACLs
[kai/samba.git] / source3 / modules / vfs_scannedonly.c
1 /*
2  * scannedonly VFS module for Samba 3.5 and beyond
3  *
4  * Copyright 2007,2008,2009,2010,2011 (C) Olivier Sessink
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 3 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  * ABOUT SCANNEDONLY
21  *
22  * scannedonly implements a 'filter' like vfs module that talks over a
23  * unix domain socket or over UDP to a anti-virus engine.
24  *
25  * files that are clean have a corresponding .scanned:{filename} file
26  * in the same directory. So why the .scanned: files? They take up
27  * only an inode, because they are 0 bytes. To test if the file is
28  * scanned only a stat() call on the filesystem is needed which is
29  * very quick compared to a database lookup. All modern filesystems
30  * use database technology such as balanced trees for lookups anyway.
31  * The number of inodes in modern filesystems is also not limiting
32  * anymore. The .scanned: files are also easy scriptable. You can
33  * remove them with a simple find command or create them with a
34  * simple touch command. Extended filesystem attributes have similar
35  * properties, but are not supported on all filesystems, so that
36  * would limit the usage of the module (and attributes are not as
37  * easily scriptable)
38  *
39  * files that are not clean are sent to the AV-engine. Only the
40  * filename is sent over the socket. The protocol is very simple:
41  * a newline separated list of filenames inside each datagram.
42  *
43  * a file AV-scan may be requested multiple times, the AV-engine
44  * should also check if the file has been scanned already. Requests
45  * can also be dropped by the AV-engine (and we thus don't need the
46  * reliability of TCP).
47  *
48  */
49
50 #include "includes.h"
51 #include "smbd/smbd.h"
52 #include "system/filesys.h"
53
54 #include "config.h"
55
56 #define SENDBUFFERSIZE 1450
57
58 #ifndef       SUN_LEN
59 #define       SUN_LEN(sunp)   ((size_t)((struct sockaddr_un *)0)->sun_path \
60                                 + strlen((sunp)->sun_path))
61 #endif
62
63
64 struct Tscannedonly {
65         int socket;
66         int domain_socket;
67         int portnum;
68         int scanning_message_len;
69         int recheck_time_open;
70         int recheck_tries_open;
71         int recheck_size_open;
72         int recheck_time_readdir;
73         int recheck_tries_readdir;
74         bool show_special_files;
75         bool rm_hidden_files_on_rmdir;
76         bool hide_nonscanned_files;
77         bool allow_nonscanned_files;
78         const char *socketname;
79         const char *scanhost;
80         const char *scanning_message;
81         const char *p_scanned; /* prefix for scanned files */
82         const char *p_virus; /* prefix for virus containing files */
83         const char *p_failed; /* prefix for failed to scan files */
84         char gsendbuffer[SENDBUFFERSIZE + 1];
85 };
86
87 #define STRUCTSCANO(var) ((struct Tscannedonly *)var)
88
89 struct scannedonly_DIR {
90         char *base;
91         int recheck_tries_done; /* if 0 the directory listing has not yet
92         been checked for files that need to be scanned. */
93         DIR *DIR;
94 };
95 #define SCANNEDONLY_DEBUG 9
96 /*********************/
97 /* utility functions */
98 /*********************/
99
100 static char *real_path_from_notify_path(TALLOC_CTX *ctx,
101                                         struct Tscannedonly *so,
102                                         const char *path)
103 {
104         char *name;
105         int len, pathlen;
106
107         name = strrchr(path, '/');
108         if (!name) {
109                 return NULL;
110         }
111         pathlen = name - path;
112         name++;
113         len = strlen(name);
114         if (len <= so->scanning_message_len) {
115                 return NULL;
116         }
117
118         if (strcmp(name + (len - so->scanning_message_len),
119                    so->scanning_message) != 0) {
120                 return NULL;
121         }
122
123         return talloc_strndup(ctx,path,
124                               pathlen + len - so->scanning_message_len);
125 }
126
127 static char *cachefile_name(TALLOC_CTX *ctx,
128                             const char *shortname,
129                             const char *base,
130                             const char *p_scanned)
131 {
132         return talloc_asprintf(ctx, "%s%s%s", base, p_scanned, shortname);
133 }
134
135 static char *name_w_ending_slash(TALLOC_CTX *ctx, const char *name)
136 {
137         int len = strlen(name);
138         if (name[len - 1] == '/') {
139                 return talloc_strdup(ctx,name);
140         } else {
141                 return talloc_asprintf(ctx, "%s/", name);
142         }
143 }
144
145 static char *cachefile_name_f_fullpath(TALLOC_CTX *ctx,
146                                        const char *fullpath,
147                                        const char *p_scanned)
148 {
149         const char *base;
150         char *tmp, *cachefile;
151         const char *shortname;
152         tmp = strrchr(fullpath, '/');
153         if (tmp) {
154                 base = talloc_strndup(ctx, fullpath, (tmp - fullpath) + 1);
155                 shortname = tmp + 1;
156         } else {
157                 base = "";
158                 shortname = (const char *)fullpath;
159         }
160         cachefile = cachefile_name(ctx, shortname, base, p_scanned);
161         DEBUG(SCANNEDONLY_DEBUG,
162               ("cachefile_name_f_fullpath cachefile=%s\n", cachefile));
163         return cachefile;
164 }
165
166 static char *construct_full_path(TALLOC_CTX *ctx, vfs_handle_struct * handle,
167                                  const char *somepath, bool ending_slash)
168 {
169         const char *tmp;
170
171         if (!somepath) {
172                 return NULL;
173         }
174         if (somepath[0] == '/') {
175                 if (ending_slash) {
176                         return name_w_ending_slash(ctx,somepath);
177                 }
178                 return talloc_strdup(ctx,somepath);
179         }
180         tmp = somepath;
181         if (tmp[0]=='.'&&tmp[1]=='/') {
182                 tmp+=2;
183         }
184         /* vfs_GetWd() seems to return a path with a slash */
185         if (ending_slash) {
186                 return talloc_asprintf(ctx, "%s/%s/",
187                                        vfs_GetWd(ctx, handle->conn),tmp);
188         }
189         return talloc_asprintf(ctx, "%s/%s",
190                                vfs_GetWd(ctx, handle->conn),tmp);
191 }
192
193 static int connect_to_scanner(vfs_handle_struct * handle)
194 {
195         struct Tscannedonly *so = (struct Tscannedonly *)handle->data;
196
197         if (so->domain_socket) {
198                 struct sockaddr_un saun;
199                 DEBUG(SCANNEDONLY_DEBUG, ("socket=%s\n", so->socketname));
200                 if ((so->socket = socket(AF_UNIX, SOCK_DGRAM, 0)) < 0) {
201                         DEBUG(2, ("failed to create socket %s\n",
202                                   so->socketname));
203                         return -1;
204                 }
205                 saun.sun_family = AF_UNIX;
206                 strncpy(saun.sun_path, so->socketname,
207                         sizeof(saun.sun_path) - 1);
208                 if (connect(so->socket, (struct sockaddr *)(void *)&saun,
209                             SUN_LEN(&saun)) < 0) {
210                         DEBUG(2, ("failed to connect to socket %s\n",
211                                   so->socketname));
212                         return -1;
213                 }
214                 DEBUG(SCANNEDONLY_DEBUG,("bound %s to socket %d\n",
215                                          saun.sun_path, so->socket));
216
217         } else {
218                 so->socket = open_udp_socket(so->scanhost, so->portnum);
219                 if (so->socket < 0) {
220                         DEBUG(2,("failed to open UDP socket to %s:%d\n",
221                                  so->scanhost,so->portnum));
222                         return -1;
223                 }
224         }
225
226         {/* increasing the socket buffer is done because we have large bursts
227             of UDP packets or DGRAM's on a domain socket whenever we hit a
228             large directory with lots of unscanned files. */
229                 int sndsize;
230                 socklen_t size = sizeof(int);
231                 getsockopt(so->socket, SOL_SOCKET, SO_RCVBUF,
232                            (char *)&sndsize, &size);
233                 DEBUG(SCANNEDONLY_DEBUG, ("current socket buffer size=%d\n",
234                                           sndsize));
235                 sndsize = 262144;
236                 if (setsockopt(so->socket, SOL_SOCKET, SO_RCVBUF,
237                                (char *)&sndsize,
238                                (int)sizeof(sndsize)) != 0) {
239                         DEBUG(SCANNEDONLY_DEBUG,
240                               ("error setting socket buffer %s (%d)\n",
241                                strerror(errno), errno));
242                 }
243         }
244         set_blocking(so->socket, false);
245         return 0;
246 }
247
248 static void flush_sendbuffer(vfs_handle_struct * handle)
249 {
250         struct Tscannedonly *so = (struct Tscannedonly *)handle->data;
251         int ret, len, loop = 10;
252         if (so->gsendbuffer[0] == '\0') {
253                 return;
254         }
255
256         do {
257                 loop--;
258                 len = strlen(so->gsendbuffer);
259                 ret = send(so->socket, so->gsendbuffer, len, 0);
260                 if (ret == len) {
261                         so->gsendbuffer[0] = '\0';
262                         break;
263                 }
264                 if (ret == -1) {
265                         DEBUG(3,("scannedonly flush_sendbuffer: "
266                                  "error sending on socket %d to scanner:"
267                                  " %s (%d)\n",
268                                  so->socket, strerror(errno), errno));
269                         if (errno == ECONNREFUSED || errno == ENOTCONN
270                             || errno == ECONNRESET) {
271                                 if (connect_to_scanner(handle) == -1)
272                                         break;  /* connecting fails, abort */
273                                 /* try again */
274                         } else if (errno != EINTR) {
275                                 /* on EINTR we just try again, all remaining
276                                    other errors we log the error
277                                    and try again ONCE */
278                                 loop = 1;
279                                 DEBUG(3,("scannedonly flush_sendbuffer: "
280                                          "error sending data to scanner: %s "
281                                          "(%d)\n", strerror(errno), errno));
282                         }
283                 } else {
284                         /* --> partial write: Resend all filenames that were
285                            not or not completely written. a partial filename
286                            written means the filename will not arrive correctly,
287                            so resend it completely */
288                         int pos = 0;
289                         while (pos < len) {
290                                 char *tmp = strchr(so->gsendbuffer+pos, '\n');
291                                 if (tmp && tmp - so->gsendbuffer < ret)
292                                         pos = tmp - so->gsendbuffer + 1;
293                                 else
294                                         break;
295                         }
296                         memmove(so->gsendbuffer, so->gsendbuffer + pos,
297                                 SENDBUFFERSIZE - ret);
298                         /* now try again */
299                 }
300         } while (loop > 0);
301
302         if (so->gsendbuffer[0] != '\0') {
303                 DEBUG(2,
304                       ("scannedonly flush_sendbuffer: "
305                        "failed to send files to AV scanner, "
306                        "discarding files."));
307                 so->gsendbuffer[0] = '\0';
308         }
309 }
310
311 static void notify_scanner(vfs_handle_struct * handle, const char *scanfile)
312 {
313         const char *tmp;
314         int tmplen, gsendlen;
315         struct Tscannedonly *so = (struct Tscannedonly *)handle->data;
316         TALLOC_CTX *ctx=talloc_tos();
317         if (scanfile[0] != '/') {
318                 tmp = construct_full_path(ctx,handle, scanfile, false);
319         } else {
320                 tmp = (const char *)scanfile;
321         }
322         tmplen = strlen(tmp);
323         gsendlen = strlen(so->gsendbuffer);
324         DEBUG(SCANNEDONLY_DEBUG,
325               ("scannedonly notify_scanner: tmp=%s, tmplen=%d, gsendlen=%d\n",
326                tmp, tmplen, gsendlen));
327         if (gsendlen + tmplen >= SENDBUFFERSIZE) {
328                 flush_sendbuffer(handle);
329         }
330         /* FIXME ! Truncate checks... JRA. */
331         (void)strlcat(so->gsendbuffer, tmp, SENDBUFFERSIZE + 1);
332         (void)strlcat(so->gsendbuffer, "\n", SENDBUFFERSIZE + 1);
333 }
334
335 static bool is_scannedonly_file(struct Tscannedonly *so, const char *shortname)
336 {
337         if (shortname[0]!='.') {
338                 return false;
339         }
340         if (strncmp(shortname, so->p_scanned, strlen(so->p_scanned)) == 0) {
341                 return true;
342         }
343         if (strncmp(shortname, so->p_virus, strlen(so->p_virus)) == 0) {
344                 return true;
345         }
346         if (strncmp(shortname, so->p_failed, strlen(so->p_failed)) == 0) {
347                 return true;
348         }
349         return false;
350 }
351
352 static bool timespec_is_newer(struct timespec *base, struct timespec *test)
353 {
354         return timespec_compare(base,test) < 0;
355 }
356
357 /*
358 vfs_handle_struct *handle the scannedonly handle
359 scannedonly_DIR * sDIR the scannedonly struct if called from _readdir()
360 or NULL
361 fullpath is a full path starting from / or a relative path to the
362 current working directory
363 shortname is the filename without directory components
364 basename, is the directory without file name component
365 allow_nonexistent return TRUE if stat() on the requested file fails
366 recheck_time, the time in milliseconds to wait for the daemon to
367 create a .scanned file
368 recheck_tries, the number of tries to wait
369 recheck_size, size in Kb of files that should not be waited for
370 loop : boolean if we should try to loop over all files in the directory
371 and send a notify to the scanner for all files that need scanning
372 */
373 static bool scannedonly_allow_access(vfs_handle_struct * handle,
374                                      struct scannedonly_DIR *sDIR,
375                                      struct smb_filename *smb_fname,
376                                      const char *shortname,
377                                      const char *base_name,
378                                      int allow_nonexistent,
379                                      int recheck_time, int recheck_tries,
380                                      int recheck_size, int loop)
381 {
382         struct smb_filename *cache_smb_fname;
383         TALLOC_CTX *ctx=talloc_tos();
384         char *cachefile;
385         int retval = -1;
386         DEBUG(SCANNEDONLY_DEBUG,
387               ("smb_fname->base_name=%s, shortname=%s, base_name=%s\n"
388                ,smb_fname->base_name,shortname,base_name));
389
390         if (ISDOT(shortname) || ISDOTDOT(shortname)) {
391                 return true;
392         }
393         if (is_scannedonly_file(STRUCTSCANO(handle->data), shortname)) {
394                 DEBUG(SCANNEDONLY_DEBUG,
395                       ("scannedonly_allow_access, %s is a scannedonly file, "
396                        "return 0\n", shortname));
397                 return false;
398         }
399
400         if (!VALID_STAT(smb_fname->st)) {
401                 DEBUG(SCANNEDONLY_DEBUG,("stat %s\n",smb_fname->base_name));
402                 retval = SMB_VFS_NEXT_STAT(handle, smb_fname);
403                 if (retval != 0) {
404                         /* failed to stat this file?!? --> hide it */
405                         DEBUG(SCANNEDONLY_DEBUG,("no valid stat, return"
406                                                  " allow_nonexistent=%d\n",
407                                                  allow_nonexistent));
408                         return allow_nonexistent;
409                 }
410         }
411         if (!S_ISREG(smb_fname->st.st_ex_mode)) {
412                 DEBUG(SCANNEDONLY_DEBUG,
413                       ("%s is not a regular file, ISDIR=%d\n",
414                        smb_fname->base_name,
415                        S_ISDIR(smb_fname->st.st_ex_mode)));
416                 return (STRUCTSCANO(handle->data)->
417                         show_special_files ||
418                         S_ISDIR(smb_fname->st.st_ex_mode));
419         }
420         if (smb_fname->st.st_ex_size == 0) {
421                 DEBUG(SCANNEDONLY_DEBUG,("empty file, return 1\n"));
422                 return true;    /* empty files cannot contain viruses ! */
423         }
424         cachefile = cachefile_name(ctx,
425                                    shortname,
426                                    base_name,
427                                    STRUCTSCANO(handle->data)->p_scanned);
428         create_synthetic_smb_fname(ctx, cachefile,NULL,NULL,&cache_smb_fname);
429         if (!VALID_STAT(cache_smb_fname->st)) {
430                 retval = SMB_VFS_NEXT_STAT(handle, cache_smb_fname);
431         }
432         if (retval == 0 && VALID_STAT(cache_smb_fname->st)) {
433                 if (timespec_is_newer(&smb_fname->st.st_ex_ctime,
434                                       &cache_smb_fname->st.st_ex_ctime)) {
435                         talloc_free(cache_smb_fname);
436                         return true;
437                 }
438                 /* no cachefile or too old */
439                 SMB_VFS_NEXT_UNLINK(handle, cache_smb_fname);
440                 retval = -1;
441         }
442
443         notify_scanner(handle, smb_fname->base_name);
444
445         if (loop && sDIR && sDIR->recheck_tries_done == 0) {
446                 /* check the rest of the directory and notify the
447                    scanner if some file needs scanning */
448                 long offset;
449                 struct dirent *dire;
450
451                 offset = SMB_VFS_NEXT_TELLDIR(handle, sDIR->DIR);
452                 dire = SMB_VFS_NEXT_READDIR(handle, sDIR->DIR, NULL);
453                 while (dire) {
454                         char *fpath2;
455                         struct smb_filename *smb_fname2;
456                         fpath2 = talloc_asprintf(ctx, "%s%s", base_name,dire->d_name);
457                         DEBUG(SCANNEDONLY_DEBUG,
458                               ("scannedonly_allow_access in loop, "
459                                "found %s\n", fpath2));
460                         create_synthetic_smb_fname(ctx, fpath2,NULL,NULL,
461                                                    &smb_fname2);
462                         scannedonly_allow_access(handle, NULL,
463                                                  smb_fname2,
464                                                  dire->d_name,
465                                                  base_name, 0, 0, 0, 0, 0);
466                         talloc_free(fpath2);
467                         talloc_free(smb_fname2);
468                         dire = SMB_VFS_NEXT_READDIR(handle, sDIR->DIR,NULL);
469                 }
470                 sDIR->recheck_tries_done = 1;
471                 SMB_VFS_NEXT_SEEKDIR(handle, sDIR->DIR, offset);
472         }
473         if (recheck_time > 0
474             && ((recheck_size > 0
475                  && smb_fname->st.st_ex_size < (1024 * recheck_size))
476                  || (sDIR && sDIR->recheck_tries_done < recheck_tries)
477                 )) {
478                 int numloops = sDIR ? sDIR->recheck_tries_done : 0;
479                 flush_sendbuffer(handle);
480                 while (retval != 0      /*&& errno == ENOENT */
481                        && numloops < recheck_tries) {
482                         DEBUG(SCANNEDONLY_DEBUG,
483                               ("scannedonly_allow_access, wait (try=%d "
484                                "(max %d), %d ms) for %s\n",
485                                numloops, recheck_tries,
486                                recheck_time, cache_smb_fname->base_name));
487                         smb_msleep(recheck_time);
488                         retval = SMB_VFS_NEXT_STAT(handle, cache_smb_fname);
489                         numloops++;
490                 }
491                 if (sDIR)
492                         sDIR->recheck_tries_done = numloops;
493         }
494         /* still no cachefile, or still too old, return 0 */
495         if (retval != 0
496             || !timespec_is_newer(&smb_fname->st.st_ex_ctime,
497                                   &cache_smb_fname->st.st_ex_ctime)) {
498                 DEBUG(SCANNEDONLY_DEBUG,
499                       ("retval=%d, return 0\n",retval));
500                 return false;
501         }
502         return true;
503 }
504
505 /*********************/
506 /* VFS functions     */
507 /*********************/
508
509 static DIR *scannedonly_opendir(vfs_handle_struct * handle,
510                                            const char *fname,
511                                            const char *mask, uint32 attr)
512 {
513         DIR *DIRp;
514         struct scannedonly_DIR *sDIR;
515
516         DIRp = SMB_VFS_NEXT_OPENDIR(handle, fname, mask, attr);
517         if (!DIRp) {
518                 return NULL;
519         }
520
521         sDIR = talloc(NULL, struct scannedonly_DIR);
522         if (fname[0] != '/') {
523                 sDIR->base = construct_full_path(sDIR,handle, fname, true);
524         } else {
525                 sDIR->base = name_w_ending_slash(sDIR, fname);
526         }
527         DEBUG(SCANNEDONLY_DEBUG,
528                         ("scannedonly_opendir, fname=%s, base=%s\n",fname,sDIR->base));
529         sDIR->DIR = DIRp;
530         sDIR->recheck_tries_done = 0;
531         return (DIR *) sDIR;
532 }
533
534 static DIR *scannedonly_fdopendir(vfs_handle_struct * handle,
535                                            files_struct *fsp,
536                                            const char *mask, uint32 attr)
537 {
538         DIR *DIRp;
539         struct scannedonly_DIR *sDIR;
540         const char *fname;
541
542         DIRp = SMB_VFS_NEXT_FDOPENDIR(handle, fsp, mask, attr);
543         if (!DIRp) {
544                 return NULL;
545         }
546
547         fname = (const char *)fsp->fsp_name->base_name;
548
549         sDIR = talloc(NULL, struct scannedonly_DIR);
550         if (fname[0] != '/') {
551                 sDIR->base = construct_full_path(sDIR,handle, fname, true);
552         } else {
553                 sDIR->base = name_w_ending_slash(sDIR, fname);
554         }
555         DEBUG(SCANNEDONLY_DEBUG,
556                         ("scannedonly_fdopendir, fname=%s, base=%s\n",fname,sDIR->base));
557         sDIR->DIR = DIRp;
558         sDIR->recheck_tries_done = 0;
559         return (DIR *) sDIR;
560 }
561
562
563 static struct dirent *scannedonly_readdir(vfs_handle_struct *handle,
564                                               DIR * dirp,
565                                               SMB_STRUCT_STAT *sbuf)
566 {
567         struct dirent *result;
568         int allowed = 0;
569         char *tmp;
570         struct smb_filename *smb_fname;
571         char *notify_name;
572         int namelen;
573         struct dirent *newdirent;
574         TALLOC_CTX *ctx=talloc_tos();
575
576         struct scannedonly_DIR *sDIR = (struct scannedonly_DIR *)dirp;
577         if (!dirp) {
578                 return NULL;
579         }
580
581         result = SMB_VFS_NEXT_READDIR(handle, sDIR->DIR, sbuf);
582
583         if (!result)
584                 return NULL;
585
586         if (is_scannedonly_file(STRUCTSCANO(handle->data), result->d_name)) {
587                 DEBUG(SCANNEDONLY_DEBUG,
588                       ("scannedonly_readdir, %s is a scannedonly file, "
589                        "skip to next entry\n", result->d_name));
590                 return scannedonly_readdir(handle, dirp, NULL);
591         }
592         tmp = talloc_asprintf(ctx, "%s%s", sDIR->base, result->d_name);
593         DEBUG(SCANNEDONLY_DEBUG,
594               ("scannedonly_readdir, check access to %s (sbuf=%p)\n",
595                tmp,sbuf));
596
597         /* even if we don't hide nonscanned files or we allow non scanned
598            files we call allow_access because it will notify the daemon to
599            scan these files */
600         create_synthetic_smb_fname(ctx, tmp,NULL,
601                                    sbuf?VALID_STAT(*sbuf)?sbuf:NULL:NULL,
602                                    &smb_fname);
603         allowed = scannedonly_allow_access(
604                 handle, sDIR, smb_fname,
605                 result->d_name,
606                 sDIR->base, 0,
607                 STRUCTSCANO(handle->data)->hide_nonscanned_files
608                 ? STRUCTSCANO(handle->data)->recheck_time_readdir
609                 : 0,
610                 STRUCTSCANO(handle->data)->recheck_tries_readdir,
611                 -1,
612                 1);
613         DEBUG(SCANNEDONLY_DEBUG,
614               ("scannedonly_readdir access to %s (%s) = %d\n", tmp,
615                result->d_name, allowed));
616         if (allowed) {
617                 return result;
618         }
619         DEBUG(SCANNEDONLY_DEBUG,
620               ("hide_nonscanned_files=%d, allow_nonscanned_files=%d\n",
621                STRUCTSCANO(handle->data)->hide_nonscanned_files,
622                STRUCTSCANO(handle->data)->allow_nonscanned_files
623                       ));
624
625         if (!STRUCTSCANO(handle->data)->hide_nonscanned_files
626             || STRUCTSCANO(handle->data)->allow_nonscanned_files) {
627                 return result;
628         }
629
630         DEBUG(SCANNEDONLY_DEBUG,
631               ("scannedonly_readdir, readdir listing for %s not "
632                "allowed, notify user\n", result->d_name));
633         notify_name = talloc_asprintf(
634                 ctx,"%s %s",result->d_name,
635                 STRUCTSCANO(handle->data)->scanning_message);
636         namelen = strlen(notify_name);
637         newdirent = (struct dirent *)talloc_array(
638                 ctx, char, sizeof(struct dirent) + namelen + 1);
639         if (!newdirent) {
640                 return NULL;
641         }
642         memcpy(newdirent, result, sizeof(struct dirent));
643         memcpy(&newdirent->d_name, notify_name, namelen + 1);
644         DEBUG(SCANNEDONLY_DEBUG,
645               ("scannedonly_readdir, return newdirent at %p with "
646                "notification %s\n", newdirent, newdirent->d_name));
647         return newdirent;
648 }
649
650 static void scannedonly_seekdir(struct vfs_handle_struct *handle,
651                                 DIR * dirp, long offset)
652 {
653         struct scannedonly_DIR *sDIR = (struct scannedonly_DIR *)dirp;
654         SMB_VFS_NEXT_SEEKDIR(handle, sDIR->DIR, offset);
655 }
656
657 static long scannedonly_telldir(struct vfs_handle_struct *handle,
658                                 DIR * dirp)
659 {
660         struct scannedonly_DIR *sDIR = (struct scannedonly_DIR *)dirp;
661         return SMB_VFS_NEXT_TELLDIR(handle, sDIR->DIR);
662 }
663
664 static void scannedonly_rewinddir(struct vfs_handle_struct *handle,
665                                   DIR * dirp)
666 {
667         struct scannedonly_DIR *sDIR = (struct scannedonly_DIR *)dirp;
668         SMB_VFS_NEXT_REWINDDIR(handle, sDIR->DIR);
669 }
670
671 static int scannedonly_closedir(vfs_handle_struct * handle,
672                                 DIR * dirp)
673 {
674         int retval;
675         struct scannedonly_DIR *sDIR = (struct scannedonly_DIR *)dirp;
676         flush_sendbuffer(handle);
677         retval = SMB_VFS_NEXT_CLOSEDIR(handle, sDIR->DIR);
678         TALLOC_FREE(sDIR);
679         return retval;
680 }
681
682 static int scannedonly_stat(vfs_handle_struct * handle,
683                             struct smb_filename *smb_fname)
684 {
685         int ret;
686         ret = SMB_VFS_NEXT_STAT(handle, smb_fname);
687         DEBUG(SCANNEDONLY_DEBUG, ("scannedonly_stat: %s returned %d\n",
688                                   smb_fname->base_name, ret));
689         if (ret != 0 && errno == ENOENT) {
690                 TALLOC_CTX *ctx=talloc_tos();
691                 char *test_base_name, *tmp_base_name = smb_fname->base_name;
692                 /* possibly this was a fake name (file is being scanned for
693                    viruses.txt): check for that and create the real name and
694                    stat the real name */
695                 test_base_name = real_path_from_notify_path(
696                         ctx,
697                         STRUCTSCANO(handle->data),
698                         smb_fname->base_name);
699                 if (test_base_name) {
700                         smb_fname->base_name = test_base_name;
701                         ret = SMB_VFS_NEXT_STAT(handle, smb_fname);
702                         DEBUG(5, ("_stat: %s returned %d\n",
703                                   test_base_name, ret));
704                         smb_fname->base_name = tmp_base_name;
705                 }
706         }
707         return ret;
708 }
709
710 static int scannedonly_lstat(vfs_handle_struct * handle,
711                              struct smb_filename *smb_fname)
712 {
713         int ret;
714         ret = SMB_VFS_NEXT_LSTAT(handle, smb_fname);
715         DEBUG(SCANNEDONLY_DEBUG, ("scannedonly_lstat: %s returned %d\n",
716                                   smb_fname->base_name, ret));
717         if (ret != 0 && errno == ENOENT) {
718                 TALLOC_CTX *ctx=talloc_tos();
719                 char *test_base_name, *tmp_base_name = smb_fname->base_name;
720                 /* possibly this was a fake name (file is being scanned for
721                    viruses.txt): check for that and create the real name and
722                    stat the real name */
723                 test_base_name = real_path_from_notify_path(
724                         ctx, STRUCTSCANO(handle->data), smb_fname->base_name);
725                 if (test_base_name) {
726                         smb_fname->base_name = test_base_name;
727                         ret = SMB_VFS_NEXT_LSTAT(handle, smb_fname);
728                         DEBUG(5, ("_lstat: %s returned %d\n",
729                                   test_base_name, ret));
730                         smb_fname->base_name = tmp_base_name;
731                 }
732         }
733         return ret;
734 }
735
736 static int scannedonly_open(vfs_handle_struct * handle,
737                             struct smb_filename *smb_fname,
738                             files_struct * fsp, int flags, mode_t mode)
739 {
740         const char *base;
741         char *tmp, *shortname;
742         int allowed, write_access = 0;
743         TALLOC_CTX *ctx=talloc_tos();
744         /* if open for writing ignore it */
745         if ((flags & O_ACCMODE) == O_WRONLY) {
746                 return SMB_VFS_NEXT_OPEN(handle, smb_fname, fsp, flags, mode);
747         }
748         if ((flags & O_ACCMODE) == O_RDWR) {
749                 write_access = 1;
750         }
751         /* check if this file is scanned already */
752         tmp = strrchr(smb_fname->base_name, '/');
753         if (tmp) {
754                 base = talloc_strndup(ctx,smb_fname->base_name,
755                                       (tmp - smb_fname->base_name) + 1);
756                 shortname = tmp + 1;
757         } else {
758                 base = "";
759                 shortname = (char *)smb_fname->base_name;
760         }
761         allowed = scannedonly_allow_access(
762                 handle, NULL, smb_fname, shortname,
763                 base,
764                 write_access,
765                 STRUCTSCANO(handle->data)->recheck_time_open,
766                 STRUCTSCANO(handle->data)->recheck_tries_open,
767                 STRUCTSCANO(handle->data)->recheck_size_open,
768                 0);
769         flush_sendbuffer(handle);
770         DEBUG(SCANNEDONLY_DEBUG, ("scannedonly_open: allow=%d for %s\n",
771                                   allowed, smb_fname->base_name));
772         if (allowed
773             || STRUCTSCANO(handle->data)->allow_nonscanned_files) {
774                 return SMB_VFS_NEXT_OPEN(handle, smb_fname, fsp, flags, mode);
775         }
776         errno = EACCES;
777         return -1;
778 }
779
780 static int scannedonly_close(vfs_handle_struct * handle, files_struct * fsp)
781 {
782         /* we only have to notify the scanner
783            for files that were open readwrite or writable. */
784         if (fsp->can_write) {
785                 TALLOC_CTX *ctx = talloc_tos();
786                 notify_scanner(handle, construct_full_path(
787                                        ctx,handle,
788                                        fsp->fsp_name->base_name,false));
789                 flush_sendbuffer(handle);
790         }
791         return SMB_VFS_NEXT_CLOSE(handle, fsp);
792 }
793
794 static int scannedonly_rename(vfs_handle_struct * handle,
795                               const struct smb_filename *smb_fname_src,
796                               const struct smb_filename *smb_fname_dst)
797 {
798         /* rename the cache file before we pass the actual rename on */
799         struct smb_filename *smb_fname_src_tmp = NULL;
800         struct smb_filename *smb_fname_dst_tmp = NULL;
801         char *cachefile_src, *cachefile_dst;
802         bool needscandst=false;
803         int ret;
804         TALLOC_CTX *ctx = talloc_tos();
805
806         /* Setup temporary smb_filename structs. */
807         cachefile_src = cachefile_name_f_fullpath(
808                 ctx,
809                 smb_fname_src->base_name,
810                 STRUCTSCANO(handle->data)->p_scanned);
811         cachefile_dst = cachefile_name_f_fullpath(
812                 ctx,
813                 smb_fname_dst->base_name,
814                 STRUCTSCANO(handle->data)->p_scanned);
815         create_synthetic_smb_fname(ctx, cachefile_src,NULL,NULL,
816                                    &smb_fname_src_tmp);
817         create_synthetic_smb_fname(ctx, cachefile_dst,NULL,NULL,
818                                    &smb_fname_dst_tmp);
819
820         ret = SMB_VFS_NEXT_RENAME(handle, smb_fname_src_tmp, smb_fname_dst_tmp);
821         if (ret == ENOENT) {
822                 needscandst=true;
823         } else if (ret != 0) {
824                 DEBUG(SCANNEDONLY_DEBUG,
825                       ("failed to rename %s into %s error %d: %s\n", cachefile_src,
826                        cachefile_dst, ret, strerror(ret)));
827                 needscandst=true;
828         }
829         ret = SMB_VFS_NEXT_RENAME(handle, smb_fname_src, smb_fname_dst);
830         if (ret == 0 && needscandst) {
831                 notify_scanner(handle, smb_fname_dst->base_name);
832                 flush_sendbuffer(handle);
833         }
834         return ret;
835 }
836
837 static int scannedonly_unlink(vfs_handle_struct * handle,
838                               const struct smb_filename *smb_fname)
839 {
840         /* unlink the 'scanned' file too */
841         struct smb_filename *smb_fname_cache = NULL;
842         char * cachefile;
843         TALLOC_CTX *ctx = talloc_tos();
844
845         cachefile = cachefile_name_f_fullpath(
846                 ctx,
847                 smb_fname->base_name,
848                 STRUCTSCANO(handle->data)->p_scanned);
849         create_synthetic_smb_fname(ctx, cachefile,NULL,NULL,
850                                    &smb_fname_cache);
851         if (SMB_VFS_NEXT_UNLINK(handle, smb_fname_cache) != 0) {
852                 DEBUG(SCANNEDONLY_DEBUG, ("_unlink: failed to unlink %s\n",
853                                           smb_fname_cache->base_name));
854         }
855         return SMB_VFS_NEXT_UNLINK(handle, smb_fname);
856 }
857
858 static int scannedonly_rmdir(vfs_handle_struct * handle, const char *path)
859 {
860         /* if there are only .scanned: .virus: or .failed: files, we delete
861            those, because the client cannot see them */
862         DIR *dirp;
863         struct dirent *dire;
864         TALLOC_CTX *ctx = talloc_tos();
865         bool only_deletable_files = true, have_files = false;
866         char *path_w_slash;
867
868         if (!STRUCTSCANO(handle->data)->rm_hidden_files_on_rmdir)
869                 return SMB_VFS_NEXT_RMDIR(handle, path);
870
871         path_w_slash = name_w_ending_slash(ctx,path);
872         dirp = SMB_VFS_NEXT_OPENDIR(handle, path, NULL, 0);
873         if (!dirp) {
874                 return -1;
875         }
876         while ((dire = SMB_VFS_NEXT_READDIR(handle, dirp, NULL)) != NULL) {
877                 if (ISDOT(dire->d_name) || ISDOTDOT(dire->d_name)) {
878                         continue;
879                 }
880                 have_files = true;
881                 if (!is_scannedonly_file(STRUCTSCANO(handle->data),
882                                          dire->d_name)) {
883                         struct smb_filename *smb_fname = NULL;
884                         char *fullpath;
885                         int retval;
886
887                         if (STRUCTSCANO(handle->data)->show_special_files) {
888                                 only_deletable_files = false;
889                                 break;
890                         }
891                         /* stat the file and see if it is a
892                            special file */
893                         fullpath = talloc_asprintf(ctx, "%s%s", path_w_slash,
894                                                   dire->d_name);
895                         create_synthetic_smb_fname(ctx, fullpath,NULL,NULL,
896                                                    &smb_fname);
897                         retval = SMB_VFS_NEXT_STAT(handle, smb_fname);
898                         if (retval == 0
899                             && S_ISREG(smb_fname->st.st_ex_mode)) {
900                                 only_deletable_files = false;
901                         }
902                         TALLOC_FREE(fullpath);
903                         TALLOC_FREE(smb_fname);
904                         break;
905                 }
906         }
907         DEBUG(SCANNEDONLY_DEBUG,
908               ("path=%s, have_files=%d, only_deletable_files=%d\n",
909                path, have_files, only_deletable_files));
910         if (have_files && only_deletable_files) {
911                 DEBUG(SCANNEDONLY_DEBUG,
912                       ("scannedonly_rmdir, remove leftover scannedonly "
913                        "files from %s\n", path_w_slash));
914                 SMB_VFS_NEXT_REWINDDIR(handle, dirp);
915                 while ((dire = SMB_VFS_NEXT_READDIR(handle, dirp, NULL))
916                        != NULL) {
917                         char *fullpath;
918                         struct smb_filename *smb_fname = NULL;
919                         if (ISDOT(dire->d_name) || ISDOTDOT(dire->d_name)) {
920                                 continue;
921                         }
922                         fullpath = talloc_asprintf(ctx, "%s%s", path_w_slash,
923                                                   dire->d_name);
924                         create_synthetic_smb_fname(ctx, fullpath,NULL,NULL,
925                                                    &smb_fname);
926                         DEBUG(SCANNEDONLY_DEBUG, ("unlink %s\n", fullpath));
927                         SMB_VFS_NEXT_UNLINK(handle, smb_fname);
928                         TALLOC_FREE(fullpath);
929                         TALLOC_FREE(smb_fname);
930                 }
931         }
932         SMB_VFS_NEXT_CLOSEDIR(handle, dirp);
933         return SMB_VFS_NEXT_RMDIR(handle, path);
934 }
935
936 static void free_scannedonly_data(void **data)
937 {
938         SAFE_FREE(*data);
939 }
940
941 static int scannedonly_connect(struct vfs_handle_struct *handle,
942                                const char *service, const char *user)
943 {
944
945         struct Tscannedonly *so;
946
947         so = SMB_MALLOC_P(struct Tscannedonly);
948         if (so == NULL) {
949                 errno = ENOMEM;
950                 return -1;
951         }
952         handle->data = (void *)so;
953         handle->free_data = free_scannedonly_data;
954         so->gsendbuffer[0]='\0';
955         so->domain_socket =
956                 lp_parm_bool(SNUM(handle->conn), "scannedonly",
957                              "domain_socket", True);
958         so->socketname = lp_parm_const_string(SNUM(handle->conn),
959                                              "scannedonly", "socketname",
960                                              "/var/lib/scannedonly/scan");
961
962         so->portnum =
963                 lp_parm_int(SNUM(handle->conn), "scannedonly", "portnum",
964                             2020);
965         so->scanhost = lp_parm_const_string(SNUM(handle->conn),
966                                              "scannedonly", "scanhost",
967                                              "localhost");
968
969         so->show_special_files =
970                 lp_parm_bool(SNUM(handle->conn), "scannedonly",
971                              "show_special_files", True);
972         so->rm_hidden_files_on_rmdir =
973                 lp_parm_bool(SNUM(handle->conn), "scannedonly",
974                              "rm_hidden_files_on_rmdir", True);
975         so->hide_nonscanned_files =
976                 lp_parm_bool(SNUM(handle->conn), "scannedonly",
977                              "hide_nonscanned_files", False);
978         so->allow_nonscanned_files =
979                 lp_parm_bool(SNUM(handle->conn), "scannedonly",
980                              "allow_nonscanned_files", False);
981         so->scanning_message = lp_parm_const_string(SNUM(handle->conn),
982                                              "scannedonly",
983                                              "scanning_message",
984                                              "is being scanned for viruses");
985         so->scanning_message_len = strlen(so->scanning_message);
986         so->recheck_time_open =
987                 lp_parm_int(SNUM(handle->conn), "scannedonly",
988                             "recheck_time_open", 50);
989         so->recheck_tries_open =
990                 lp_parm_int(SNUM(handle->conn), "scannedonly",
991                             "recheck_tries_open", 100);
992         so->recheck_size_open =
993                 lp_parm_int(SNUM(handle->conn), "scannedonly",
994                             "recheck_size_open", 100);
995         so->recheck_time_readdir =
996                 lp_parm_int(SNUM(handle->conn), "scannedonly",
997                             "recheck_time_readdir", 50);
998         so->recheck_tries_readdir =
999                 lp_parm_int(SNUM(handle->conn), "scannedonly",
1000                             "recheck_tries_readdir", 20);
1001
1002         so->p_scanned =
1003                 lp_parm_const_string(SNUM(handle->conn),
1004                                              "scannedonly",
1005                                              "pref_scanned",
1006                                              ".scanned:");
1007         so->p_virus =
1008                 lp_parm_const_string(SNUM(handle->conn),
1009                                              "scannedonly",
1010                                              "pref_virus",
1011                                              ".virus:");
1012         so->p_failed =
1013                 lp_parm_const_string(SNUM(handle->conn),
1014                                              "scannedonly",
1015                                              "pref_failed",
1016                                              ".failed:");
1017         connect_to_scanner(handle);
1018
1019         return SMB_VFS_NEXT_CONNECT(handle, service, user);
1020 }
1021
1022 /* VFS operations structure */
1023 static struct vfs_fn_pointers vfs_scannedonly_fns = {
1024         .opendir_fn = scannedonly_opendir,
1025         .fdopendir_fn = scannedonly_fdopendir,
1026         .readdir_fn = scannedonly_readdir,
1027         .seekdir_fn = scannedonly_seekdir,
1028         .telldir_fn = scannedonly_telldir,
1029         .rewind_dir_fn = scannedonly_rewinddir,
1030         .closedir_fn = scannedonly_closedir,
1031         .rmdir_fn = scannedonly_rmdir,
1032         .stat_fn = scannedonly_stat,
1033         .lstat_fn = scannedonly_lstat,
1034         .open_fn = scannedonly_open,
1035         .close_fn = scannedonly_close,
1036         .rename_fn = scannedonly_rename,
1037         .unlink_fn = scannedonly_unlink,
1038         .connect_fn = scannedonly_connect
1039 };
1040
1041 NTSTATUS vfs_scannedonly_init(void)
1042 {
1043         return smb_register_vfs(SMB_VFS_INTERFACE_VERSION, "scannedonly",
1044                                 &vfs_scannedonly_fns);
1045 }