/*
* Copyright (c) 2007,2008 Apple Inc. All rights reserved.
*
* @APPLE_LICENSE_HEADER_START@
*
* This file contains Original Code and/or Modifications of Original Code
* as defined in and that are subject to the Apple Public Source License
* Version 2.0 (the 'License'). You may not use this file except in
* compliance with the License. Please obtain a copy of the License at
* http://www.opensource.apple.com/apsl/ and read it before using this
* file.
*
* The Original Code and all software distributed under the License are
* distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
* EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
* INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
* Please see the License for the specific language governing rights and
* limitations under the License.
*
* @APPLE_LICENSE_HEADER_END@
*/
#include <map>
#include <vector>
#include <sstream>
class LaunchService;
#define SMB_RUN_CONFIG_PATH "/var/db/smb.conf"
#define SMB_RUN_TEMPLATE "/var/db/.smb.conf.XXXXXXXX"
#define SMB_SHARES_CONFIG_PATH "/var/db/samba/smb.shares"
#define SMB_SHARES_TEMPLATE "/var/db/samba/.smb.shares.XXXXXXXX"
/* Base config file handling. */
struct basic_config
{
basic_config(const std::string& path, const std::string& tmpl)
: m_cpath(path), m_ctmpl(tmpl) {
}
virtual void format(std::ostream&) const = 0;
bool writeback() const;
typedef std::pair<std::string, std::string> param_type;
typedef std::vector<param_type> paramlist_type;
private:
std::string m_cpath; // Path to write config file to
std::string m_ctmpl; // Path to use for mkstemp template
};
/* Class to encapsulate the state of the SMB configuration. Includes the state
* of the smb.conf file and the service daemons.
*/
class SmbConfig : public basic_config
{
public:
typedef enum {
GLOBAL,
PRINTER,
HOMES,
NETLOGON,
PROFILES
} section_type;
typedef std::map<section_type, paramlist_type> smbconf_type;
SmbConfig();
~SmbConfig();
LaunchService& SmbdService() { return *(this->m_smbd); }
LaunchService& NmbdService() { return *(this->m_nmbd); }
LaunchService& WinbindService() { return *(this->m_winbind); }
const LaunchService& SmbdService() const { return *(this->m_smbd); }
const LaunchService& NmbdService() const { return *(this->m_nmbd); }
const LaunchService& WinbindService() const { return *(this->m_winbind); }
void set_param(section_type section, const param_type& param);
/* Meta-data parameters are formatted into the smb.conf header to give the
* reader a guide to the intent of the configuration.
*/
void set_meta(const param_type& param);
bool meta_changed(param_type& param) const;
/* Emit the formatted smb.conf to the given stream. */
void format(std::ostream& out) const;
private:
SmbConfig(const SmbConfig&); // nocopy
SmbConfig& operator=(const SmbConfig&); // nocopy
smbconf_type m_smbconf; /* accumulated smb.conf parameters */
paramlist_type m_metaconf; /* accumulated smb.conf metadata */
paramlist_type m_lastmeta; /* sampled metadata */
LaunchService * m_smbd;
LaunchService * m_nmbd;
LaunchService * m_winbind;
};
/* Class to hold the collection of SMB share definitions. */
class SmbShares : public basic_config
{
public:
typedef std::map<std::string, paramlist_type> smbshares_type;
SmbShares()
: basic_config(SMB_SHARES_CONFIG_PATH, SMB_SHARES_TEMPLATE) {
}
~SmbShares() {
}
/* Emit the formatted smb.conf to the given stream. */
void format(std::ostream& out) const;
void set_param(const std::string& share_name, const param_type& param);
private:
SmbShares(const SmbShares&); // nocopy
SmbShares& operator=(const SmbShares&); // nocopy
smbshares_type m_smbshares;
};
template <class T> basic_config::param_type
make_smb_param(const std::string& key, const T& val)
{
std::ostringstream ostr;
ostr << val;
return make_smb_param<std::string>(key, ostr.str());
}
template <> basic_config::param_type
make_smb_param<std::string>(const std::string& key, const std::string& val);
template <> basic_config::param_type
make_smb_param<bool>(const std::string& key, const bool& val);
class SmbOption;
/* Encapsulate the SMB configuration rules. We take a set of options and apply
* a set of rules to them, which updates the SMB configuration state.
*/
class SmbRules
{
public:
SmbRules();
~SmbRules();
typedef std::vector<SmbOption *> option_list;
typedef option_list::iterator iterator;
typedef option_list::const_iterator const_iterator;
typedef option_list::size_type size_type;
size_type size() const;
iterator begin() { return this->m_options.begin(); }
iterator end() { return this->m_options.end(); }
const_iterator begin() const { return this->m_options.begin(); }
const_iterator end() const { return this->m_options.end(); }
const std::string& version() const { return m_version; }
private:
SmbRules(const SmbRules&); //nocopy
SmbRules& operator=(const SmbRules&); //nocopy
option_list m_options;
std::string m_version;
};
/* vim: set cindent ts=8 sts=4 tw=79 : */