usr/src/lib/smbsrv/libmlsvc/common/libmlsvc.h

   1 /*
   2  * CDDL HEADER START
   3  *
   4  * The contents of this file are subject to the terms of the
   5  * Common Development and Distribution License (the "License").
   6  * You may not use this file except in compliance with the License.
   7  *
   8  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
   9  * or http://www.opensolaris.org/os/licensing.
  10  * See the License for the specific language governing permissions
  11  * and limitations under the License.
  12  *
  13  * When distributing Covered Code, include this CDDL HEADER in each
  14  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
  15  * If applicable, add the following below this CDDL HEADER, with the
  16  * fields enclosed by brackets "[]" replaced with your own identifying
  17  * information: Portions Copyright [yyyy] [name of copyright owner]
  18  *
  19  * CDDL HEADER END
  20  */
  21 /*
  22  * Copyright (c) 2007, 2010, Oracle and/or its affiliates. All rights reserved.
  23  * Copyright 2015 Nexenta Systems, Inc.  All rights reserved.
  24  */
  25
  26 #ifndef _LIBMLSVC_H
  27 #define _LIBMLSVC_H
  28
  29 #include <uuid/uuid.h>
  30 #include <sys/param.h>
  31 #include <sys/types.h>
  32 #include <sys/uio.h>
  33 #include <sys/ksynch.h>
  34 #include <time.h>
  35 #include <stdio.h>
  36 #include <string.h>
  37 #include <netdb.h>
  38 #include <libuutil.h>
  39 #include <smbsrv/wintypes.h>
  40 #include <smbsrv/hash_table.h>
  41 #include <smbsrv/smb_token.h>
  42 #include <smbsrv/smb_privilege.h>
  43 #include <smbsrv/smb_share.h>
  44 #include <smbsrv/smb_xdr.h>
  45 #include <smbsrv/smb_dfs.h>
  46 #include <smbsrv/libsmb.h>
  47 #include <smbsrv/libmlrpc.h>
  48 #include <smbsrv/ndl/lsarpc.ndl>
  49
  50 #ifdef  __cplusplus
  51 extern "C" {
  52 #endif
  53
  54 uint32_t lsa_lookup_name(char *, uint16_t, smb_account_t *);
  55 uint32_t lsa_lookup_sid(smb_sid_t *, smb_account_t *);
  56
  57 /*
  58  * SMB domain API to discover a domain controller and obtain domain
  59  * information.
  60  */
  61
  62 extern boolean_t smb_locate_dc(char *, smb_domainex_t *);
  63 uint32_t smb_ddiscover_dns(char *, smb_domainex_t *);
  64 extern void smb_ddiscover_bad_dc(char *);
  65 extern void smb_ddiscover_refresh(void);
  66 extern int smb_ddiscover_wait(void);
  67
  68 extern int dssetup_check_service(void);
  69 extern void dssetup_clear_domain_info(void);
  70 extern void mlsvc_disconnect(const char *);
  71 extern int mlsvc_init(void);
  72 extern void mlsvc_fini(void);
  73 extern DWORD mlsvc_netlogon(char *, char *);
  74 extern void mlsvc_join(smb_joininfo_t *, smb_joinres_t *);
  75
  76 extern void smb_logon_domain(smb_logon_t *, smb_token_t *);
  77 extern uint32_t smb_decode_krb5_pac(smb_token_t *, char *, uint_t);
  78 extern boolean_t smb_token_setup_common(smb_token_t *);
  79
  80
  81 /*
  82  * The maximum number of domains (NT limit).
  83  */
  84 #define MLSVC_DOMAIN_MAX                32
  85
  86 #define MLSVC_ANON_USER                 "IPC$"
  87
  88 char *mlsvc_ipc_name(int ipc_type, char *username);
  89
  90 /*
  91  * Passthrough negotiation and authentication interface.
  92  *
  93  * NT supports two forms of password: a Lanman (case-insensitive)
  94  * password and an NT (case-sensitive) password. If either of the
  95  * passwords is not available its pointer and length should be set
  96  * to zero. The session key and vc number are required to validate
  97  * the encrypted passwords.
  98  */
  99
 100 void mlsvc_nt_password_hash(char *result, char *password);
 101 int mlsvc_encrypt_nt_password(char *password, char *key, int keylen, char *out,
 102     int outmax);
 103
 104 #define SMB_AUTOHOME_FILE       "smbautohome"
 105 #define SMB_AUTOHOME_PATH       "/etc"
 106
 107 typedef struct smb_autohome {
 108         struct smb_autohome *ah_next;
 109         uint32_t ah_hits;
 110         time_t ah_timestamp;
 111         char *ah_name;          /* User account name */
 112         char *ah_path;          /* Home directory path */
 113         char *ah_container;     /* ADS container distinguished name */
 114 } smb_autohome_t;
 115
 116 extern void smb_autohome_add(const smb_token_t *);
 117 extern void smb_autohome_remove(const char *);
 118
 119 /*
 120  * A local unique id (LUID) is an opaque id used by servers to identify
 121  * local resources, such as privileges.  A client will use lookup
 122  * functions to translate the LUID to a more general, machine independent
 123  * form; such as a string.
 124  */
 125 typedef struct ms_luid {
 126         uint32_t low_part;
 127         uint32_t high_part;
 128 } ms_luid_t;
 129
 130 /*
 131  * Information about a server as reported by NetServerGetInfo.
 132  * The SV_PLATFORM and SV_TYPE definitions are in srvsvc.ndl.
 133  */
 134 typedef struct srvsvc_server_info {
 135         uint32_t        sv_platform_id;
 136         char            *sv_name;
 137         uint32_t        sv_version_major;
 138         uint32_t        sv_version_minor;
 139         uint32_t        sv_type;
 140         char            *sv_comment;
 141         uint32_t        sv_os;
 142 } srvsvc_server_info_t;
 143
 144 int srvsvc_net_server_getinfo(char *, char *, srvsvc_server_info_t *);
 145 int srvsvc_net_remote_tod(char *, char *, struct timeval *, struct tm *);
 146
 147
 148 /*
 149  * A client_t is created while binding a client connection to hold the
 150  * context for calls made using that connection.
 151  *
 152  * Handles are RPC call specific and we use an inheritance mechanism to
 153  * ensure that each handle has a pointer to the client_t.  When the top
 154  * level (bind) handle is released, we close the connection.
 155  */
 156 typedef struct mlsvc_handle {
 157         ndr_hdid_t                      handle;
 158         ndr_client_t                    *clnt;
 159         srvsvc_server_info_t            svinfo;
 160 } mlsvc_handle_t;
 161
 162 void ndr_rpc_init(void);
 163 void ndr_rpc_fini(void);
 164 uint32_t ndr_rpc_bind(mlsvc_handle_t *, char *, char *, char *, const char *);
 165 void ndr_rpc_unbind(mlsvc_handle_t *);
 166 int ndr_rpc_call(mlsvc_handle_t *, int, void *);
 167 void ndr_rpc_set_nonull(mlsvc_handle_t *);
 168 const srvsvc_server_info_t *ndr_rpc_server_info(mlsvc_handle_t *);
 169 uint32_t ndr_rpc_server_os(mlsvc_handle_t *);
 170 int ndr_rpc_get_ssnkey(mlsvc_handle_t *, unsigned char *, size_t);
 171 void *ndr_rpc_malloc(mlsvc_handle_t *, size_t);
 172 ndr_heap_t *ndr_rpc_get_heap(mlsvc_handle_t *);
 173 void ndr_rpc_release(mlsvc_handle_t *);
 174 boolean_t ndr_is_null_handle(mlsvc_handle_t *);
 175 boolean_t ndr_is_bind_handle(mlsvc_handle_t *);
 176 void ndr_inherit_handle(mlsvc_handle_t *, mlsvc_handle_t *);
 177 void ndr_rpc_status(mlsvc_handle_t *, int, uint32_t);
 178
 179 /* SVCCTL service */
 180 /*
 181  * Calculate the wide-char equivalent string length required to
 182  * store a string - including the terminating null wide-char.
 183  */
 184 #define SVCCTL_WNSTRLEN(S)      ((strlen((S)) + 1) * sizeof (smb_wchar_t))
 185
 186 /* An AVL-storable node representing each service in the SCM database. */
 187 typedef struct svcctl_svc_node {
 188         uu_avl_node_t           sn_node;
 189         char                    *sn_name;       /* Service Name (Key) */
 190         char                    *sn_fmri;       /* Display Name (FMRI) */
 191         char                    *sn_desc;       /* Description */
 192         char                    *sn_state;      /* State */
 193 } svcctl_svc_node_t;
 194
 195 /* This structure provides context for each svcctl_s_OpenManager call. */
 196 typedef struct svcctl_manager_context {
 197         scf_handle_t            *mc_scf_hdl;      /* SCF handle */
 198         scf_propertygroup_t     *mc_scf_gpg;      /* Property group */
 199         scf_property_t          *mc_scf_gprop;    /* Property */
 200         scf_value_t             *mc_scf_gval;     /* Value */
 201         uint32_t                mc_scf_numsvcs;   /* Number of SMF services */
 202         ssize_t                 mc_scf_max_fmri_len;  /* Max FMRI length */
 203         ssize_t                 mc_scf_max_value_len; /* Max Value length */
 204         uint32_t                mc_bytes_needed;  /* Number of bytes needed */
 205         uu_avl_pool_t           *mc_svcs_pool;    /* AVL pool */
 206         uu_avl_t                *mc_svcs;         /* AVL tree of SMF services */
 207 } svcctl_manager_context_t;
 208
 209 /* This structure provides context for each svcctl_s_OpenService call. */
 210 typedef struct svcctl_service_context {
 211         ndr_hdid_t              *sc_mgrid;      /* Manager ID */
 212         char                    *sc_svcname;    /* Service Name */
 213 } svcctl_service_context_t;
 214
 215 typedef enum {
 216         SVCCTL_MANAGER_CONTEXT = 0,
 217         SVCCTL_SERVICE_CONTEXT
 218 } svcctl_context_type_t;
 219
 220 /* This structure provides abstraction for service and manager context call. */
 221 typedef struct svcctl_context {
 222         svcctl_context_type_t   c_type;
 223         union {
 224                 svcctl_manager_context_t *uc_mgr;
 225                 svcctl_service_context_t *uc_svc;
 226                 void *uc_cp;
 227         } c_ctx;
 228 } svcctl_context_t;
 229
 230 /* Service Control Manager (SCM) functions */
 231 void svcctl_init(void);
 232 void svcctl_fini(void);
 233 int svcctl_scm_init(svcctl_manager_context_t *);
 234 void svcctl_scm_fini(svcctl_manager_context_t *);
 235 int svcctl_scm_scf_handle_init(svcctl_manager_context_t *);
 236 void svcctl_scm_scf_handle_fini(svcctl_manager_context_t *);
 237 int svcctl_scm_refresh(svcctl_manager_context_t *);
 238 uint32_t svcctl_scm_enum_services(svcctl_manager_context_t *, uint8_t *,
 239     size_t, uint32_t *, boolean_t);
 240 uint32_t svcctl_scm_validate_service(svcctl_manager_context_t *, char *);
 241 svcctl_svc_node_t *svcctl_scm_find_service(svcctl_manager_context_t *, char *);
 242 uint32_t svcctl_scm_map_status(const char *);
 243
 244 /* LOGR service */
 245 #define LOGR_APPLICATION_LOG            "Application"
 246 #define LOGR_SECURITY_LOG               "Security"
 247 #define LOGR_SYSTEM_LOG                 "System"
 248 #define LOGR_NMSGMASK                   1023
 249 #define LOGR_MAXMSGLEN                  800
 250
 251 typedef struct logr_entry {
 252         struct timeval  le_timestamp;                   /* Time of log entry */
 253         int             le_pri;                         /* Message priority */
 254         char            le_hostname[MAXHOSTNAMELEN];    /* Log hostname */
 255         char            le_msg[LOGR_MAXMSGLEN];         /* Log message text */
 256 } logr_entry_t;
 257
 258 typedef struct logr_info {
 259         logr_entry_t    li_entry[LOGR_NMSGMASK+1];      /* Array of log entry */
 260         int             li_idx;                         /* Index */
 261 } logr_info_t;
 262
 263 typedef struct logr_read_data {
 264         int             rd_tot_recnum;          /* Total no. of record read */
 265         int             rd_last_sentrec;        /* Last sentence read */
 266         char            rd_first_read;          /* First sentence read */
 267         logr_info_t     *rd_log;                /* Log information read */
 268 } logr_read_data_t;
 269
 270 /* This structure provides the context for eventlog calls from clients. */
 271 typedef struct logr_context {
 272         logr_read_data_t *lc_cached_read_data;
 273         char *lc_source_name;
 274 } logr_context_t;
 275
 276 void logr_init(void);
 277 void logr_fini(void);
 278 boolean_t logr_is_supported(char *);
 279 int logr_get_snapshot(logr_context_t *);
 280
 281 /* User and Group quotas */
 282 uint32_t smb_quota_query(smb_quota_query_t *, smb_quota_response_t *);
 283 uint32_t smb_quota_set(smb_quota_set_t *);
 284 void smb_quota_free(smb_quota_response_t *);
 285
 286 uint32_t dfs_get_referrals(const char *, dfs_reftype_t, dfs_info_t *);
 287 void dfs_info_free(dfs_info_t *);
 288
 289 /*
 290  * The spoolss installable copyfile API.
 291  */
 292 typedef void (*spoolss_copyfile_t)(smb_inaddr_t *, char *, char *, char *);
 293 void spoolss_register_copyfile(spoolss_copyfile_t);
 294
 295 #ifdef  __cplusplus
 296 }
 297 #endif
 298
 299 #endif  /* _LIBMLSVC_H */