utils.hh

// -*- c-basic-offset: 4; tab-width: 8; indent-tabs-mode: t -*-
// vim:set sts=4 ts=8:

// Copyright (c) 2001-2011 XORP, Inc and Others
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU Lesser General Public License, Version
// 2.1, June 1999 as published by the Free Software Foundation.
// Redistribution and/or modification of this program under the terms of
// any other version of the GNU Lesser General Public License is not
// permitted.
// 
// 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. For more details,
// see the GNU Lesser General Public License, Version 2.1, a copy of
// which can be found in the XORP LICENSE.lgpl file.
// 
// XORP, Inc, 2953 Bunker Hill Lane, Suite 204, Santa Clara, CA 95054, USA;
// http://xorp.net

#ifndef __LIBXORP_UTILS_HH__
#define __LIBXORP_UTILS_HH__


#include "utility.h"

//
// Set of utilities
//

#define PATH_CURDIR         "."
#define PATH_PARENT         ".."

#define NT_PATH_DELIMITER_CHAR      '\\'
#define NT_PATH_DELIMITER_STRING    "\\"
#define NT_PATH_ENV_DELIMITER_CHAR  ';'
#define NT_PATH_ENV_DELIMITER_STRING    ";"
#define NT_PATH_DRIVE_DELIMITER_CH  ':'
#define NT_EXECUTABLE_SUFFIX        ".exe"

// NT specific
#define NT_PATH_UNC_PREFIX      "\\\\"
#define NT_PATH_DRIVE_SUFFIX        ":"

#define UNIX_PATH_DELIMITER_CHAR    '/'
#define UNIX_PATH_DELIMITER_STRING  "/"
#define UNIX_PATH_ENV_DELIMITER_CHAR    ':'
#define UNIX_PATH_ENV_DELIMITER_STRING  ":"
#define UNIX_EXECUTABLE_SUFFIX      ""

#ifdef  HOST_OS_WINDOWS
#define PATH_DELIMITER_CHAR     NT_PATH_DELIMITER_CHAR
#define PATH_DELIMITER_STRING       NT_PATH_DELIMITER_STRING
#define PATH_ENV_DELIMITER_CHAR     NT_PATH_ENV_DELIMITER_CHAR
#define PATH_ENV_DELIMITER_STRING   NT_PATH_ENV_DELIMITER_STRING
#define EXECUTABLE_SUFFIX       NT_EXECUTABLE_SUFFIX
#else   // ! HOST_OS_WINDOWS
#define PATH_DELIMITER_CHAR     UNIX_PATH_DELIMITER_CHAR
#define PATH_DELIMITER_STRING       UNIX_PATH_DELIMITER_STRING
#define PATH_ENV_DELIMITER_CHAR     UNIX_PATH_ENV_DELIMITER_CHAR
#define PATH_ENV_DELIMITER_STRING   UNIX_PATH_ENV_DELIMITER_STRING
#define EXECUTABLE_SUFFIX       UNIX_EXECUTABLE_SUFFIX
#endif  // ! HOST_OS_WINDOWS


inline string
unix_path_to_native(const string& unixpath)
{
#ifdef HOST_OS_WINDOWS
    string nativepath = unixpath;
    string::size_type n = 0;
    while (string::npos != (n = nativepath.find(UNIX_PATH_DELIMITER_CHAR, n))) {
        nativepath[n] = NT_PATH_DELIMITER_CHAR;
    }
    return (nativepath);
#else // ! HOST_OS_WINDOWS
    return string(unixpath);
#endif // ! HOST_OS_WINDOWS
}

inline bool
is_absolute_path(const string& path, bool homeok = false)
{
    if (path.empty())
    return false;

#ifdef HOST_OS_WINDOWS
    if ((path.find(NT_PATH_UNC_PREFIX) == 0) ||
    ((path.size() >= 2) && isalpha(path[0]) && path[1] == ':'))
        return true;
    return false;
    UNUSED(homeok);
#else // ! HOST_OS_WINDOWS
    if (path[0] == '/')
        return true;
    if (homeok && path[0] == '~')
        return true;
    return false;
#endif // ! HOST_OS_WINDOWS
}

list<string> split(const string& s, char sep);

string strip_empty_spaces(const string& s);

bool has_empty_space(const string& s);

const char* xorp_basename(const char* argv0);

template<class T> void
delete_pointers_list(list<T *>& delete_list)
{
    list<T *> tmp_list;
    
    // Swap the elements, so the original container never contains
    // entries that point to deleted elements.
    swap(tmp_list, delete_list);
    
    for (typename list<T *>::iterator iter = tmp_list.begin();
     iter != tmp_list.end();
     ++iter) {
    T *elem = (*iter);
    delete elem;
    }
    tmp_list.clear();
}

template<class T> void
delete_pointers_vector(vector<T *>& delete_vector)
{
    vector<T *> tmp_vector;
    // Swap the elements, so the original container never contains
    // entries that point to deleted elements.
    swap(tmp_vector, delete_vector);
    
    for (typename vector<T *>::iterator iter = tmp_vector.begin();
     iter != tmp_vector.end();
     ++iter) {
    T *elem = (*iter);
    delete elem;
    }
    tmp_vector.clear();
}

FILE*   xorp_make_temporary_file(const string& tmp_dir,
                 const string& filename_template,
                 string& final_filename,
                 string& errmsg);

#ifdef HOST_OS_WINDOWS

void win_quote_args(const list<string>& args, string& cmdline);
#endif // HOST_OS_WINDOWS

inline uint32_t
xorp_bit_count_uint32(uint32_t x)
{
    //
    // 32-bit recursive reduction using SWAR...
    // but first step is mapping 2-bit values
    // into sum of 2 1-bit values in sneaky way.
    //
    x -= ((x >> 1) & 0x55555555);
    x = (((x >> 2) & 0x33333333) + (x & 0x33333333));
    x = (((x >> 4) + x) & 0x0f0f0f0f);
    x += (x >> 8);
    x += (x >> 16);
    x &= 0x0000003f;

    return (x);
}

inline uint32_t
xorp_leading_zero_count_uint32(uint32_t x)
{
    x |= (x >> 1);
    x |= (x >> 2);
    x |= (x >> 4);
    x |= (x >> 8);
    x |= (x >> 16);

    return (32 - xorp_bit_count_uint32(x));
}

template <typename A>
class AlignData {
public:
    AlignData(const vector<uint8_t>& buffer) {
    if (_data_is_copied) {
        _data = malloc(sizeof(uint8_t) * buffer.size());
        memcpy(_data, &buffer[0], sizeof(uint8_t) * buffer.size());
        _const_data = _data;
    } else {
        _data = NULL;
        _const_data = &buffer[0];
    }
    _payload = reinterpret_cast<const A*>(_const_data);
    }

    ~AlignData() {
    if (_data != NULL)
        free(_data);
    }

    const A* payload() const { return (_payload); }

    const A* payload_by_offset(size_t offset) const {
    const void* offset_data;
    offset_data = reinterpret_cast<const uint8_t*>(_const_data) + offset;
    return (reinterpret_cast<const A*>(offset_data));
    }

private:
    // Damn..code assumes data is not coppied, see:
    // NetlinkSocket::force_recvmsg_flgs
    // Will just have to assume that alignment is OK till we can clean this up. --Ben
    static const bool _data_is_copied = false;

    void*   _data;
    const void* _const_data;
    const A*    _payload;
};

#endif // __LIBXORP_UTILS_HH__