src/openvpn/mstats.c

/*
 *  OpenVPN -- An application to securely tunnel IP networks
 *             over a single TCP/UDP port, with support for SSL/TLS-based
 *             session authentication and key exchange,
 *             packet encryption, packet authentication, and
 *             packet compression.
 *
 *  Copyright (C) 2002-2018 OpenVPN Inc <sales@openvpn.net>
 *
 *  This program is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License version 2
 *  as published by the Free Software Foundation.
 *
 *  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.,
 *  51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
 */

/*
 * Maintain usage stats in a memory-mapped file
 */

#ifdef HAVE_CONFIG_H
#include "config.h"
#elif defined(_MSC_VER)
#include "config-msvc.h"
#endif

#include "syshead.h"

#if defined(ENABLE_MEMSTATS)

#include <sys/mman.h>

#include "error.h"
#include "misc.h"
#include "mstats.h"

#include "memdbg.h"

volatile struct mmap_stats *mmap_stats = NULL; /* GLOBAL */
static char mmap_fn[128];

void
mstats_open(const char *fn)
{
    void *data;
    ssize_t stat;
    int fd;
    struct mmap_stats ms;

    if (mmap_stats) /* already called? */
    {
        return;
    }

    /* verify that filename is not too long */
    if (strlen(fn) >= sizeof(mmap_fn))
    {
        msg(M_FATAL, "mstats_open: filename too long");
    }

    /* create file that will be memory mapped */
    fd = open(fn, O_CREAT | O_TRUNC | O_RDWR, S_IRUSR | S_IWUSR);
    if (fd < 0)
    {
        msg(M_ERR, "mstats_open: cannot open: %s", fn);
        return;
    }

    /* set the file to the correct size to contain a
     * struct mmap_stats, and zero it */
    CLEAR(ms);
    ms.state = MSTATS_ACTIVE;
    stat = write(fd, &ms, sizeof(ms));
    if (stat != sizeof(ms))
    {
        msg(M_ERR, "mstats_open: write error: %s", fn);
        close(fd);
        return;
    }

    /* mmap the file */
    data = mmap(NULL, sizeof(struct mmap_stats), PROT_READ|PROT_WRITE, MAP_SHARED, fd, 0);
    if (data == MAP_FAILED)
    {
        msg(M_ERR, "mstats_open: write error: %s", fn);
        close(fd);
        return;
    }

    /* close the fd (mmap now controls the file) */
    if (close(fd))
    {
        msg(M_ERR, "mstats_open: close error: %s", fn);
    }

    /* save filename so we can delete it later */
    strcpy(mmap_fn, fn);

    /* save a global pointer to memory-mapped region */
    mmap_stats = (struct mmap_stats *)data;

    msg(M_INFO, "memstats data will be written to %s", fn);
}

void
mstats_close(void)
{
    if (mmap_stats)
    {
        mmap_stats->state = MSTATS_EXPIRED;
        if (munmap((void *)mmap_stats, sizeof(struct mmap_stats)))
        {
            msg(M_WARN | M_ERRNO, "mstats_close: munmap error");
        }
        platform_unlink(mmap_fn);
        mmap_stats = NULL;
    }
}

#endif /* if defined(ENABLE_MEMSTATS) */