More read_data -> read_socket_with_timeout
[nivanova/samba-autobuild/.git] / source3 / smbd / dmapi.c
1 /* 
2    Unix SMB/CIFS implementation.
3    DMAPI Support routines
4
5    Copyright (C) James Peach 2006
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 3 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, see <http://www.gnu.org/licenses/>.
19 */
20
21 #include "includes.h"
22
23 #undef DBGC_CLASS
24 #define DBGC_CLASS DBGC_DMAPI
25
26 #ifndef USE_DMAPI
27
28 int dmapi_init_session(void) { return -1; }
29 uint32 dmapi_file_flags(const char * const path) { return 0; }
30 bool dmapi_have_session(void) { return False; }
31
32 #else /* USE_DMAPI */
33
34 #ifdef HAVE_XFS_DMAPI_H
35 #include <xfs/dmapi.h>
36 #elif defined(HAVE_SYS_DMI_H)
37 #include <sys/dmi.h>
38 #elif defined(HAVE_SYS_JFSDMAPI_H)
39 #include <sys/jfsdmapi.h>
40 #elif defined(HAVE_SYS_DMAPI_H)
41 #include <sys/dmapi.h>
42 #elif defined(HAVE_DMAPI_H)
43 #include <dmapi.h>
44 #endif
45
46 #define DMAPI_SESSION_NAME "samba"
47 #define DMAPI_TRACE 10
48
49 static dm_sessid_t samba_dmapi_session = DM_NO_SESSION;
50
51 /* Initialise the DMAPI interface. Make sure that we only end up initialising
52  * once per process to avoid resource leaks across different DMAPI
53  * implementations.
54  */
55 static int init_dmapi_service(void)
56 {
57         static pid_t lastpid;
58
59         pid_t mypid;
60
61         mypid = sys_getpid();
62         if (mypid != lastpid) {
63                 char *version;
64
65                 lastpid = mypid;
66                 if (dm_init_service(&version) < 0) {
67                         return -1;
68                 }
69
70                 DEBUG(0, ("Initializing DMAPI: %s\n", version));
71         }
72
73         return 0;
74 }
75
76 bool dmapi_have_session(void)
77 {
78         return samba_dmapi_session != DM_NO_SESSION;
79 }
80
81 static dm_sessid_t *realloc_session_list(dm_sessid_t * sessions, int count)
82 {
83         dm_sessid_t *nsessions;
84
85         nsessions = TALLOC_REALLOC_ARRAY(NULL, sessions, dm_sessid_t, count);
86         if (nsessions == NULL) {
87                 TALLOC_FREE(sessions);
88                 return NULL;
89         }
90
91         return nsessions;
92 }
93
94 /* Initialise DMAPI session. The session is persistant kernel state, so it
95  * might already exist, in which case we merely want to reconnect to it. This
96  * function should be called as root.
97  */
98 int dmapi_init_session(void)
99 {
100         char    buf[DM_SESSION_INFO_LEN];
101         size_t  buflen;
102
103         uint        nsessions = 10;
104         dm_sessid_t *sessions = NULL;
105
106         int i, err;
107
108         /* If we aren't root, something in the following will fail due to lack
109          * of privileges. Aborting seems a little extreme.
110          */
111         SMB_WARN(getuid() == 0, "dmapi_init_session must be called as root");
112
113         samba_dmapi_session = DM_NO_SESSION;
114         if (init_dmapi_service() < 0) {
115                 return -1;
116         }
117
118 retry:
119
120         if ((sessions = realloc_session_list(sessions, nsessions)) == NULL) {
121                 return -1;
122         }
123
124         err = dm_getall_sessions(nsessions, sessions, &nsessions);
125         if (err < 0) {
126                 if (errno == E2BIG) {
127                         nsessions *= 2;
128                         goto retry;
129                 }
130
131                 DEBUGADD(DMAPI_TRACE,
132                         ("failed to retrieve DMAPI sessions: %s\n",
133                         strerror(errno)));
134                 TALLOC_FREE(sessions);
135                 return -1;
136         }
137
138         for (i = 0; i < nsessions; ++i) {
139                 err = dm_query_session(sessions[i], sizeof(buf), buf, &buflen);
140                 buf[sizeof(buf) - 1] = '\0';
141                 if (err == 0 && strcmp(DMAPI_SESSION_NAME, buf) == 0) {
142                         samba_dmapi_session = sessions[i];
143                         DEBUGADD(DMAPI_TRACE,
144                                 ("attached to existing DMAPI session "
145                                  "named '%s'\n", buf));
146                         break;
147                 }
148         }
149
150         TALLOC_FREE(sessions);
151
152         /* No session already defined. */
153         if (samba_dmapi_session == DM_NO_SESSION) {
154                 err = dm_create_session(DM_NO_SESSION, 
155                                         CONST_DISCARD(char *, DMAPI_SESSION_NAME),
156                                         &samba_dmapi_session);
157                 if (err < 0) {
158                         DEBUGADD(DMAPI_TRACE,
159                                 ("failed to create new DMAPI session: %s\n",
160                                 strerror(errno)));
161                         samba_dmapi_session = DM_NO_SESSION;
162                         return -1;
163                 }
164
165                 DEBUGADD(DMAPI_TRACE,
166                         ("created new DMAPI session named '%s'\n",
167                         DMAPI_SESSION_NAME));
168         }
169
170         /* Note that we never end the DMAPI session. This enables child
171          * processes to continue to use the session after we exit. It also lets
172          * you run a second Samba server on different ports without any
173          * conflict.
174          */
175
176         return 0;
177 }
178
179 /* Reattach to an existing dmapi session. Called from service processes that
180  * might not be running as root.
181  */
182 static int reattach_dmapi_session(void)
183 {
184         char    buf[DM_SESSION_INFO_LEN];
185         size_t  buflen;
186
187         if (samba_dmapi_session != DM_NO_SESSION ) {
188                 become_root();
189
190                 /* NOTE: On Linux, this call opens /dev/dmapi, costing us a
191                  * file descriptor. Ideally, we would close this when we fork.
192                  */
193                 if (init_dmapi_service() < 0) {
194                         samba_dmapi_session = DM_NO_SESSION;
195                         unbecome_root();
196                         return -1;
197                 }
198
199                 if (dm_query_session(samba_dmapi_session, sizeof(buf),
200                             buf, &buflen) < 0) {
201                         /* Session is stale. Disable DMAPI. */
202                         samba_dmapi_session = DM_NO_SESSION;
203                         unbecome_root();
204                         return -1;
205                 }
206
207                 set_effective_capability(DMAPI_ACCESS_CAPABILITY);
208
209                 DEBUG(DMAPI_TRACE, ("reattached DMAPI session\n"));
210                 unbecome_root();
211         }
212
213         return 0;
214 }
215
216 /* If a DMAPI session has been initialised, then we need to make sure
217  * we are attached to it and have the correct privileges. This is
218  * necessary to be able to do DMAPI operations across a fork(2). If
219  * it fails, there is no likelihood of that failure being transient.
220  *
221  * Note that this use of the static attached flag relies on the fact
222  * that dmapi_file_flags() is never called prior to forking the
223  * per-client server process.
224  */
225 const void * dmapi_get_current_session(void) 
226 {
227         static int attached = 0;
228         if (dmapi_have_session() && !attached) {
229                 attached++;
230                 if (reattach_dmapi_session() < 0) {
231                         return DM_NO_SESSION;
232                 }
233         }
234         return &samba_dmapi_session;
235 }
236
237 uint32 dmapi_file_flags(const char * const path)
238 {
239         dm_sessid_t dmapi_session;
240         int             err;
241         dm_eventset_t   events = {0};
242         uint            nevents;
243
244         void    *dm_handle = NULL;
245         size_t  dm_handle_len = 0;
246
247         uint32  flags = 0;
248
249         dmapi_session = *(dm_sessid_t*) dmapi_get_current_session();
250         if (dmapi_session == DM_NO_SESSION) {
251                 return 0;
252         }
253
254         /* AIX has DMAPI but no POSIX capablities support. In this case,
255          * we need to be root to do DMAPI manipulations.
256          */
257 #ifndef HAVE_POSIX_CAPABILITIES
258         become_root();
259 #endif
260
261         err = dm_path_to_handle(CONST_DISCARD(char *, path),
262                 &dm_handle, &dm_handle_len);
263         if (err < 0) {
264                 DEBUG(DMAPI_TRACE, ("dm_path_to_handle(%s): %s\n",
265                             path, strerror(errno)));
266
267                 if (errno != EPERM) {
268                         goto done;
269                 }
270
271                 /* Linux capabilities are broken in that changing our
272                  * user ID will clobber out effective capabilities irrespective
273                  * of whether we have set PR_SET_KEEPCAPS. Fortunately, the
274                  * capabilities are not removed from our permitted set, so we
275                  * can re-acquire them if necessary.
276                  */
277
278                 set_effective_capability(DMAPI_ACCESS_CAPABILITY);
279
280                 err = dm_path_to_handle(CONST_DISCARD(char *, path),
281                         &dm_handle, &dm_handle_len);
282                 if (err < 0) {
283                         DEBUG(DMAPI_TRACE,
284                             ("retrying dm_path_to_handle(%s): %s\n",
285                             path, strerror(errno)));
286                         goto done;
287                 }
288         }
289
290         err = dm_get_eventlist(dmapi_session, dm_handle, dm_handle_len,
291                 DM_NO_TOKEN, DM_EVENT_MAX, &events, &nevents);
292         if (err < 0) {
293                 DEBUG(DMAPI_TRACE, ("dm_get_eventlist(%s): %s\n",
294                             path, strerror(errno)));
295                 dm_handle_free(dm_handle, dm_handle_len);
296                 goto done;
297         }
298
299         /* We figure that the only reason a DMAPI application would be
300          * interested in trapping read events is that part of the file is
301          * offline.
302          */
303         DEBUG(DMAPI_TRACE, ("DMAPI event list for %s is %#llx\n",
304                     path, events));
305         if (DMEV_ISSET(DM_EVENT_READ, events)) {
306                 flags = FILE_ATTRIBUTE_OFFLINE;
307         }
308
309         dm_handle_free(dm_handle, dm_handle_len);
310
311         if (flags & FILE_ATTRIBUTE_OFFLINE) {
312                 DEBUG(DMAPI_TRACE, ("%s is OFFLINE\n", path));
313         }
314
315 done:
316
317 #ifndef HAVE_POSIX_CAPABILITIES
318         unbecome_root();
319 #endif
320
321         return flags;
322 }
323
324
325 #endif /* USE_DMAPI */