/src/samba/lib/param/loadparm_server_role.c

Source
/*
   Unix SMB/CIFS implementation.
   Parameter loading functions
   Copyright (C) Karl Auer 1993-1998

   Largely re-written by Andrew Tridgell, September 1994

   Copyright (C) Simo Sorce 2001
   Copyright (C) Alexander Bokovoy 2002
   Copyright (C) Stefan (metze) Metzmacher 2002
   Copyright (C) Jim McDonough <jmcd@us.ibm.com> 2003
   Copyright (C) Michael Adam 2008
   Copyright (C) Andrew Bartlett 2010

   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 3 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, see <http://www.gnu.org/licenses/>.
*/
#include "includes.h"
#include "lib/param/loadparm.h"
#include "libds/common/roles.h"

/*******************************************************************
 Set the server type we will announce as via nmbd.
********************************************************************/

static const struct srv_role_tab {
  uint32_t role;
  const char *role_str;
} srv_role_tab [] = {
  { ROLE_STANDALONE, "ROLE_STANDALONE" },
  { ROLE_DOMAIN_MEMBER, "ROLE_DOMAIN_MEMBER" },
  { ROLE_DOMAIN_BDC, "ROLE_DOMAIN_BDC" },
  { ROLE_DOMAIN_PDC, "ROLE_DOMAIN_PDC" },
  { ROLE_ACTIVE_DIRECTORY_DC, "ROLE_ACTIVE_DIRECTORY_DC" },
  { ROLE_IPA_DC, "ROLE_IPA_DC"},
  { 0, NULL }
};

const char* server_role_str(uint32_t role)
{
  int i = 0;
  for (i=0; srv_role_tab[i].role_str; i++) {
    if (role == srv_role_tab[i].role) {
      return srv_role_tab[i].role_str;
    }
  }
  return NULL;
}

/**
 * Set the server role based on security, domain logons and domain master
 */
int lp_find_server_role(int server_role, int security, int domain_logons, int domain_master)
{
  int role;

  if (server_role != ROLE_AUTO) {
    if (lp_is_security_and_server_role_valid(server_role, security)) {
      return server_role;
    }
  }

  /* If server_role is set to ROLE_AUTO, or conflicted with the
   * chosen security setting, figure out the correct role */
  role = ROLE_STANDALONE;

  switch (security) {
    case SEC_DOMAIN:
    case SEC_ADS:
      role = ROLE_DOMAIN_MEMBER;
      break;
    case SEC_AUTO:
    case SEC_USER:
      if (domain_logons) {

        if (domain_master) {
          role = ROLE_DOMAIN_PDC;
        } else {
          role = ROLE_DOMAIN_BDC;
        }
      }
      break;
    default:
      DEBUG(0, ("Server's Role undefined due to unknown security mode\n"));
      break;
  }

  return role;
}

/**
 * Set the server role based on security, domain logons and domain master
 */
int lp_find_security(int server_role, int security)
{
  if (security != SEC_AUTO) {
    return security;
  }

  switch (server_role) {
  case ROLE_DOMAIN_MEMBER:
    return SEC_ADS;
  default:
    return SEC_USER;
  }
}


/**
 * Check if server role and security parameters are contradictory
 */
bool lp_is_security_and_server_role_valid(int server_role, int security)
{
  bool valid = false;

  if (security == SEC_AUTO) {
    return true;
  }

  switch (server_role) {
  case ROLE_AUTO:
    valid = true;
    break;
  case ROLE_DOMAIN_MEMBER:
    if (security == SEC_ADS || security == SEC_DOMAIN) {
      valid = true;
    }
    break;

  case ROLE_STANDALONE:
  case ROLE_DOMAIN_PDC:
  case ROLE_DOMAIN_BDC:
  case ROLE_ACTIVE_DIRECTORY_DC:
  case ROLE_IPA_DC:
    if (security == SEC_USER) {
      valid = true;
    }
    break;

  default:
    break;
  }

  return valid;
}

Line	Count	Source
1		/*
2		Unix SMB/CIFS implementation.
3		Parameter loading functions
4		Copyright (C) Karl Auer 1993-1998
5
6		Largely re-written by Andrew Tridgell, September 1994
7
8		Copyright (C) Simo Sorce 2001
9		Copyright (C) Alexander Bokovoy 2002
10		Copyright (C) Stefan (metze) Metzmacher 2002
11		Copyright (C) Jim McDonough <jmcd@us.ibm.com> 2003
12		Copyright (C) Michael Adam 2008
13		Copyright (C) Andrew Bartlett 2010
14
15		This program is free software; you can redistribute it and/or modify
16		it under the terms of the GNU General Public License as published by
17		the Free Software Foundation; either version 3 of the License, or
18		(at your option) any later version.
19
20		This program is distributed in the hope that it will be useful,
21		but WITHOUT ANY WARRANTY; without even the implied warranty of
22		MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
23		GNU General Public License for more details.
24
25		You should have received a copy of the GNU General Public License
26		along with this program. If not, see <http://www.gnu.org/licenses/>.
27		*/
28		#include "includes.h"
29		#include "lib/param/loadparm.h"
30		#include "libds/common/roles.h"
31
32		/*******************************************************************
33		Set the server type we will announce as via nmbd.
34		********************************************************************/
35
36		static const struct srv_role_tab {
37		uint32_t role;
38		const char *role_str;
39		} srv_role_tab [] = {
40		{ ROLE_STANDALONE, "ROLE_STANDALONE" },
41		{ ROLE_DOMAIN_MEMBER, "ROLE_DOMAIN_MEMBER" },
42		{ ROLE_DOMAIN_BDC, "ROLE_DOMAIN_BDC" },
43		{ ROLE_DOMAIN_PDC, "ROLE_DOMAIN_PDC" },
44		{ ROLE_ACTIVE_DIRECTORY_DC, "ROLE_ACTIVE_DIRECTORY_DC" },
45		{ ROLE_IPA_DC, "ROLE_IPA_DC"},
46		{ 0, NULL }
47		};
48
49		const char* server_role_str(uint32_t role)
50	0	{
51	0	int i = 0;
52	0	for (i=0; srv_role_tab[i].role_str; i++) {
53	0	if (role == srv_role_tab[i].role) {
54	0	return srv_role_tab[i].role_str;
55	0	}
56	0	}
57	0	return NULL;
58	0	}
59
60		/**
61		* Set the server role based on security, domain logons and domain master
62		*/
63		int lp_find_server_role(int server_role, int security, int domain_logons, int domain_master)
64	0	{
65	0	int role;
66
67	0	if (server_role != ROLE_AUTO) {
68	0	if (lp_is_security_and_server_role_valid(server_role, security)) {
69	0	return server_role;
70	0	}
71	0	}
72
73		/* If server_role is set to ROLE_AUTO, or conflicted with the
74		* chosen security setting, figure out the correct role */
75	0	role = ROLE_STANDALONE;
76
77	0	switch (security) {
78	0	case SEC_DOMAIN:
79	0	case SEC_ADS:
80	0	role = ROLE_DOMAIN_MEMBER;
81	0	break;
82	0	case SEC_AUTO:
83	0	case SEC_USER:
84	0	if (domain_logons) {
85
86	0	if (domain_master) {
87	0	role = ROLE_DOMAIN_PDC;
88	0	} else {
89	0	role = ROLE_DOMAIN_BDC;
90	0	}
91	0	}
92	0	break;
93	0	default:
94	0	DEBUG(0, ("Server's Role undefined due to unknown security mode\n"));
95	0	break;
96	0	}
97
98	0	return role;
99	0	}
100
101		/**
102		* Set the server role based on security, domain logons and domain master
103		*/
104		int lp_find_security(int server_role, int security)
105	0	{
106	0	if (security != SEC_AUTO) {
107	0	return security;
108	0	}
109
110	0	switch (server_role) {
111	0	case ROLE_DOMAIN_MEMBER:
112	0	return SEC_ADS;
113	0	default:
114	0	return SEC_USER;
115	0	}
116	0	}
117
118
119		/**
120		* Check if server role and security parameters are contradictory
121		*/
122		bool lp_is_security_and_server_role_valid(int server_role, int security)
123	0	{
124	0	bool valid = false;
125
126	0	if (security == SEC_AUTO) {
127	0	return true;
128	0	}
129
130	0	switch (server_role) {
131	0	case ROLE_AUTO:
132	0	valid = true;
133	0	break;
134	0	case ROLE_DOMAIN_MEMBER:
135	0	if (security == SEC_ADS \|\| security == SEC_DOMAIN) {
136	0	valid = true;
137	0	}
138	0	break;
139
140	0	case ROLE_STANDALONE:
141	0	case ROLE_DOMAIN_PDC:
142	0	case ROLE_DOMAIN_BDC:
143	0	case ROLE_ACTIVE_DIRECTORY_DC:
144	0	case ROLE_IPA_DC:
145	0	if (security == SEC_USER) {
146	0	valid = true;
147	0	}
148	0	break;
149
150	0	default:
151	0	break;
152	0	}
153
154	0	return valid;
155	0	}

Coverage Report

Created: 2026-07-25 07:00