source: branches/samba-3.0/source/smbd/dmapi.c@ 372

/* 
   Unix SMB/CIFS implementation.
   DMAPI Support routines

   Copyright (C) James Peach 2006

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.
   
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
   
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
*/

#include "includes.h"

#undef DBGC_CLASS
#define DBGC_CLASS DBGC_DMAPI

#ifndef USE_DMAPI

int dmapi_init_session(void) { return -1; }
uint32 dmapi_file_flags(const char * const path) { return 0; }
BOOL dmapi_have_session(void) { return False; }

#else /* USE_DMAPI */

#ifdef HAVE_XFS_DMAPI_H
#include <xfs/dmapi.h>
#elif defined(HAVE_SYS_DMI_H)
#include <sys/dmi.h>
#elif defined(HAVE_SYS_JFSDMAPI_H)
#include <sys/jfsdmapi.h>
#elif defined(HAVE_SYS_DMAPI_H)
#include <sys/dmapi.h>
#elif defined(HAVE_DMAPI_H)
#include <dmapi.h>
#endif

#define DMAPI_SESSION_NAME "samba"
#define DMAPI_TRACE 10

static dm_sessid_t dmapi_session = DM_NO_SESSION;

/* Initialise the DMAPI interface. Make sure that we only end up initialising
 * once per process to avoid resource leaks across different DMAPI
 * implementations.
 */
static int init_dmapi_service(void)
{
        static pid_t lastpid;

        pid_t mypid;

        mypid = sys_getpid();
        if (mypid != lastpid) {
                char *version;

                lastpid = mypid;
                if (dm_init_service(&version) < 0) {
                        return -1;
                }

                DEBUG(0, ("Initializing DMAPI: %s\n", version));
        }

        return 0;
}

BOOL dmapi_have_session(void)
{
        return dmapi_session != DM_NO_SESSION;
}

static dm_sessid_t *realloc_session_list(dm_sessid_t * sessions, int count)
{
        dm_sessid_t *nsessions;

        nsessions = TALLOC_REALLOC_ARRAY(NULL, sessions, dm_sessid_t, count);
        if (nsessions == NULL) {
                TALLOC_FREE(sessions);
                return NULL;
        }

        return nsessions;
}

/* Initialise DMAPI session. The session is persistant kernel state, so it
 * might already exist, in which case we merely want to reconnect to it. This
 * function should be called as root.
 */
int dmapi_init_session(void)
{
        char    buf[DM_SESSION_INFO_LEN];
        size_t  buflen;

        uint        nsessions = 10;
        dm_sessid_t *sessions = NULL;

        int i, err;

        /* If we aren't root, something in the following will fail due to lack
         * of privileges. Aborting seems a little extreme.
         */
        SMB_WARN(getuid() == 0, "dmapi_init_session must be called as root");

        dmapi_session = DM_NO_SESSION;
        if (init_dmapi_service() < 0) {
                return -1;
        }

retry:

        if ((sessions = realloc_session_list(sessions, nsessions)) == NULL) {
                return -1;
        }

        err = dm_getall_sessions(nsessions, sessions, &nsessions);
        if (err < 0) {
                if (errno == E2BIG) {
                        nsessions *= 2;
                        goto retry;
                }

                DEBUGADD(DMAPI_TRACE,
                        ("failed to retrieve DMAPI sessions: %s\n",
                        strerror(errno)));
                TALLOC_FREE(sessions);
                return -1;
        }

        for (i = 0; i < nsessions; ++i) {
                err = dm_query_session(sessions[i], sizeof(buf), buf, &buflen);
                buf[sizeof(buf) - 1] = '\0';
                if (err == 0 && strcmp(DMAPI_SESSION_NAME, buf) == 0) {
                        dmapi_session = sessions[i];
                        DEBUGADD(DMAPI_TRACE,
                                ("attached to existing DMAPI session "
                                 "named '%s'\n", buf));
                        break;
                }
        }

        TALLOC_FREE(sessions);

        /* No session already defined. */
        if (dmapi_session == DM_NO_SESSION) {
                err = dm_create_session(DM_NO_SESSION, DMAPI_SESSION_NAME,
                                        &dmapi_session);
                if (err < 0) {
                        DEBUGADD(DMAPI_TRACE,
                                ("failed to create new DMAPI session: %s\n",
                                strerror(errno)));
                        dmapi_session = DM_NO_SESSION;
                        return -1;
                }

                DEBUGADD(DMAPI_TRACE,
                        ("created new DMAPI session named '%s'\n",
                        DMAPI_SESSION_NAME));
        }

        /* Note that we never end the DMAPI session. This enables child
         * processes to continue to use the session after we exit. It also lets
         * you run a second Samba server on different ports without any
         * conflict.
         */

        return 0;
}

/* Reattach to an existing dmapi session. Called from service processes that
 * might not be running as root.
 */
static int reattach_dmapi_session(void)
{
        char    buf[DM_SESSION_INFO_LEN];
        size_t  buflen;

        if (dmapi_session != DM_NO_SESSION ) {
                become_root();

                /* NOTE: On Linux, this call opens /dev/dmapi, costing us a
                 * file descriptor. Ideally, we would close this when we fork.
                 */
                if (init_dmapi_service() < 0) {
                        dmapi_session = DM_NO_SESSION;
                        unbecome_root();
                        return -1;
                }

                if (dm_query_session(dmapi_session, sizeof(buf),