static bool reload_nmbd_services(bool test)
{
bool ret;
set_remote_machine_name("nmbd", False);
if ( lp_loaded() ) {
const char *fname = lp_configfile();
if (file_exist(fname) && !strcsequal(fname,get_dyn_CONFIGFILE())) {
set_dyn_CONFIGFILE(fname);
test = False;
}
}
if ( test && !lp_file_list_changed() )
return(True);
ret = lp_load_global(get_dyn_CONFIGFILE());
/* perhaps the config filename is now set */
if ( !test ) {
DEBUG( 3, ( "services not loaded\n" ) );
reload_nmbd_services( True );
}
return(ret);
}
static bool reload_services_file(const char *lfile)
{
bool ret;
if (lp_loaded()) {
char *fname = lp_configfile(talloc_tos());
if (file_exist(fname) && !strcsequal(fname,get_dyn_CONFIGFILE())) {
set_dyn_CONFIGFILE(fname);
}
TALLOC_FREE(fname);
}
/* if this is a child, restore the logfile to the special
name - <domain>, idmap, etc. */
if (lfile && *lfile) {
lp_set_logfile(lfile);
}
reopen_logs();
ret = lp_load_global(get_dyn_CONFIGFILE());
reopen_logs();
load_interfaces();
return(ret);
}
bool reload_services(struct smbd_server_connection *sconn,
bool (*snumused) (struct smbd_server_connection *, int),
bool test)
{
struct smbXsrv_connection *xconn = NULL;
bool ret;
if (sconn != NULL) {
xconn = sconn->conn;
}
if (lp_loaded()) {
char *fname = lp_next_configfile(talloc_tos());
if (file_exist(fname) &&
!strcsequal(fname, get_dyn_CONFIGFILE())) {
set_dyn_CONFIGFILE(fname);
test = False;
}
TALLOC_FREE(fname);
}
reopen_logs();
if (test && !lp_file_list_changed())
return(True);
lp_killunused(sconn, snumused);
ret = lp_load(get_dyn_CONFIGFILE(),
false, /* global only */
false, /* save defaults */
true, /* add_ipc */
true); /* initialize globals */
/* perhaps the config filename is now set */
if (!test) {
reload_services(sconn, snumused, true);
}
reopen_logs();
load_interfaces();
if (xconn != NULL) {
set_socket_options(xconn->transport.sock, "SO_KEEPALIVE");
set_socket_options(xconn->transport.sock, lp_socket_options());
}
mangle_reset_cache();
reset_stat_cache();
/* this forces service parameters to be flushed */
set_current_service(NULL,0,True);
return(ret);
}
int main(int argc, const char **argv)
{
bool ret;
poptContext pc;
TALLOC_CTX *mem_ctx = talloc_stackframe();
struct poptOption long_options[] = {
POPT_COMMON_SAMBA
{0, 0, 0, 0}
};
load_case_tables();
setup_logging(argv[0], DEBUG_STDERR);
/* parse options */
pc = poptGetContext("smbconftort", argc, (const char **)argv,
long_options, 0);
while(poptGetNextOpt(pc) != -1) { }
poptFreeContext(pc);
ret = lp_load_global(get_dyn_CONFIGFILE());
if (!ret) {
printf("failure: error loading the configuration\n");
goto done;
}
ret = torture_smbconf();
done:
talloc_free(mem_ctx);
return ret ? 0 : -1;
}
int main(int argc, char *argv[])
{
char *desthost;
const char *configfile;
TALLOC_CTX *frame = talloc_stackframe();
load_case_tables();
setup_logging(argv[0], DEBUG_STDOUT);
configfile = get_dyn_CONFIGFILE();
if (argc < 2) {
fprintf(stderr,"smbfilter <desthost> <netbiosname>\n");
exit(1);
}
desthost = argv[1];
if (argc > 2) {
netbiosname = argv[2];
}
if (!lp_load_global(configfile)) {
d_printf("Unable to load config file\n");
}
start_filter(desthost);
TALLOC_FREE(frame);
return 0;
}
/****************************************************************************
main program
****************************************************************************/
int main(int argc, char *argv[])
{
TALLOC_CTX *frame = talloc_stackframe();
const char **argv_const = discard_const_p(const char *, argv);
struct user_auth_info *auth_info;
struct poptOption long_options[] = {
POPT_AUTOHELP
{ "broadcast", 'b', POPT_ARG_VAL, &use_bcast, True, "Use broadcast instead of using the master browser" },
{ "domains", 'D', POPT_ARG_VAL, &level, LEV_WORKGROUP, "List only domains (workgroups) of tree" },
{ "servers", 'S', POPT_ARG_VAL, &level, LEV_SERVER, "List domains(workgroups) and servers of tree" },
POPT_COMMON_SAMBA
POPT_COMMON_CREDENTIALS
POPT_TABLEEND
};
poptContext pc;
/* Initialise samba stuff */
load_case_tables();
setlinebuf(stdout);
setup_logging(argv[0], DEBUG_STDERR);
auth_info = user_auth_info_init(frame);
if (auth_info == NULL) {
exit(1);
}
popt_common_set_auth_info(auth_info);
pc = poptGetContext("smbtree", argc, argv_const, long_options,
POPT_CONTEXT_KEEP_FIRST);
while(poptGetNextOpt(pc) != -1);
poptFreeContext(pc);
popt_burn_cmdline_password(argc, argv);
lp_load_global(get_dyn_CONFIGFILE());
load_interfaces();
/* Parse command line args */
if (get_cmdline_auth_info_use_machine_account(auth_info) &&
!set_cmdline_auth_info_machine_account_creds(auth_info)) {
TALLOC_FREE(frame);
return 1;
}
set_cmdline_auth_info_getpass(auth_info);
/* Now do our stuff */
if (!print_tree(auth_info)) {
TALLOC_FREE(frame);
return 1;
}
TALLOC_FREE(frame);
return 0;
}
bool reload_services(struct messaging_context *msg_ctx, int smb_sock,
bool test)
{
bool ret;
if (lp_loaded()) {
char *fname = lp_configfile();
if (file_exist(fname) &&
!strcsequal(fname, get_dyn_CONFIGFILE())) {
set_dyn_CONFIGFILE(fname);
test = False;
}
TALLOC_FREE(fname);
}
reopen_logs();
if (test && !lp_file_list_changed())
return(True);
lp_killunused(conn_snum_used);
ret = lp_load(get_dyn_CONFIGFILE(), False, False, True, True);
/* perhaps the config filename is now set */
if (!test)
reload_services(msg_ctx, smb_sock, True);
reopen_logs();
load_interfaces();
if (smb_sock != -1) {
set_socket_options(smb_sock,"SO_KEEPALIVE");
set_socket_options(smb_sock, lp_socket_options());
}
mangle_reset_cache();
reset_stat_cache();
/* this forces service parameters to be flushed */
set_current_service(NULL,0,True);
return(ret);
}
int main(int argc, char **argv)
{
sec_init();
load_case_tables();
if (!lp_load_initial_only(get_dyn_CONFIGFILE())) {
fprintf(stderr, "Can't load %s - run testparm to debug it\n",
get_dyn_CONFIGFILE());
exit(1);
}
if (argc == 1) {
help();
exit(1);
}
process_arguments(argc, argv);
exit(0);
}
int main(int argc, char **argv)
{
struct poptOption long_options[] = {
POPT_AUTOHELP
/* ... */
POPT_COMMON_SAMBA
POPT_COMMON_CONNECTION
POPT_COMMON_CREDENTIALS
POPT_TABLEEND
};
int opt;
poptContext pc;
struct user_auth_info *auth_info;
TALLOC_CTX *frame;
struct registry_context *ctx;
WERROR rv;
frame = talloc_stackframe();
setup_logging("regedit", DEBUG_DEFAULT_STDERR);
lp_set_cmdline("log level", "0");
/* process options */
auth_info = user_auth_info_init(frame);
if (auth_info == NULL) {
exit(1);
}
popt_common_set_auth_info(auth_info);
pc = poptGetContext("regedit", argc, (const char **)argv, long_options, 0);
while ((opt = poptGetNextOpt(pc)) != -1) {
/* TODO */
}
if (!lp_load_global(get_dyn_CONFIGFILE())) {
DEBUG(0, ("ERROR loading config file...\n"));
exit(1);
}
/* some simple tests */
rv = reg_open_samba3(frame, &ctx);
if (!W_ERROR_IS_OK(rv)) {
TALLOC_FREE(frame);
return 1;
}
display_window(frame, ctx);
TALLOC_FREE(frame);
return 0;
}
NET_API_STATUS libnetapi_init(struct libnetapi_ctx **context)
{
NET_API_STATUS ret;
TALLOC_CTX *frame;
if (stat_ctx && libnetapi_initialized) {
*context = stat_ctx;
return NET_API_STATUS_SUCCESS;
}
#if 0
talloc_enable_leak_report();
#endif
frame = talloc_stackframe();
/* Case tables must be loaded before any string comparisons occour */
load_case_tables_library();
/* When libnetapi is invoked from an application, it does not
* want to be swamped with level 10 debug messages, even if
* this has been set for the server in smb.conf */
lp_set_cmdline("log level", "0");
setup_logging("libnetapi", DEBUG_STDERR);
if (!lp_load(get_dyn_CONFIGFILE(), true, false, false, true)) {
TALLOC_FREE(frame);
fprintf(stderr, "error loading %s\n", get_dyn_CONFIGFILE() );
return W_ERROR_V(WERR_GENERAL_FAILURE);
}
init_names();
load_interfaces();
reopen_logs();
BlockSignals(True, SIGPIPE);
ret = libnetapi_net_init(context);
TALLOC_FREE(frame);
return ret;
}
static void update_conf(struct tevent_context *ev,
struct messaging_context *msg)
{
change_to_root_user();
lp_load(get_dyn_CONFIGFILE(), true, false, false, true);
load_printers(ev, msg);
spoolss_reopen_logs(spoolss_child_id);
if (spoolss_child_id == 0) {
pfh_daemon_config(DAEMON_NAME,
&pf_spoolss_cfg,
&default_pf_spoolss_cfg);
pfh_manage_pool(ev, msg, &pf_spoolss_cfg, spoolss_pool);
}
}
int main(int argc, const char *argv[])
{
const char *config_file = get_dyn_CONFIGFILE();
const char *sequence = "";
poptContext pc;
char *buff;
TALLOC_CTX *ctx = talloc_stackframe();
struct poptOption long_options[] = {
POPT_AUTOHELP
POPT_COMMON_VERSION
POPT_TABLEEND
};
load_case_tables();
pc = poptGetContext(NULL, argc, argv, long_options,
POPT_CONTEXT_KEEP_FIRST);
poptSetOtherOptionHelp(pc, "[OPTION...] <sequence-string>");
while(poptGetNextOpt(pc) != -1);
setup_logging(poptGetArg(pc), true);
sequence = poptGetArg(pc);
if (sequence == NULL) {
fprintf(stderr, "ERROR: missing sequence string\n");
return 1;
}
dbf = x_stderr;
DEBUGLEVEL = 0;
AllowDebugChange = false;
if (!lp_load(config_file,false,true,false,true)) {
fprintf(stderr,"Error loading services.\n");
return 1;
}
while(next_token_talloc(ctx, &sequence, &buff, NULL)) {
printf("[%s]\n", buff);
}
talloc_free(ctx);
return 0;
}
static void mdssd_sig_hup_handler(struct tevent_context *ev,
struct tevent_signal *se,
int signum,
int count,
void *siginfo,
void *pvt)
{
change_to_root_user();
lp_load_global(get_dyn_CONFIGFILE());
reopen_logs();
pfh_daemon_config(DAEMON_NAME,
&pf_mdssd_cfg,
&default_pf_mdssd_cfg);
/* relay to all children */
prefork_send_signal_to_all(mdssd_pool, SIGHUP);
}
int main(int argc, const char **argv)
{
bool ret;
poptContext pc;
TALLOC_CTX *mem_ctx = talloc_stackframe();
struct poptOption long_options[] = {
POPT_COMMON_SAMBA
{0, 0, 0, 0}
};
load_case_tables();
dbf = x_stderr;
/* parse options */
pc = poptGetContext("smbconftort", argc, (const char **)argv,
long_options, 0);
while(poptGetNextOpt(pc) != -1) { }
poptFreeContext(pc);
ret = lp_load(get_dyn_CONFIGFILE(),
true, /* globals_only */
false, /* save_defaults */
false, /* add_ipc */
true /* initialize globals */);
if (!ret) {
printf("failure: error loading the configuration\n");
goto done;
}
ret = torture_smbconf();
done:
TALLOC_FREE(mem_ctx);
return ret ? 0 : -1;
}
static void mdssd_smb_conf_updated(struct messaging_context *msg,
void *private_data,
uint32_t msg_type,
struct server_id server_id,
DATA_BLOB *data)
{
struct tevent_context *ev_ctx;
DEBUG(10, ("Got message saying smb.conf was updated. Reloading.\n"));
ev_ctx = talloc_get_type_abort(private_data, struct tevent_context);
change_to_root_user();
lp_load_global(get_dyn_CONFIGFILE());
reopen_logs();
if (mdssd_child_id == 0) {
pfh_daemon_config(DAEMON_NAME,
&pf_mdssd_cfg,
&default_pf_mdssd_cfg);
pfh_manage_pool(ev_ctx, msg, &pf_mdssd_cfg, mdssd_pool);
}
}
/*
main program
*/
int main(int argc, const char *argv[])
{
TALLOC_CTX *mem_ctx;
struct tevent_context *ev_ctx;
struct messaging_context *msg_ctx;
struct db_context *db;
int unsafe_writes = 0;
struct poptOption popt_options[] = {
POPT_AUTOHELP
POPT_COMMON_SAMBA
{ "timelimit", 't', POPT_ARG_INT, &timelimit, 0, "timelimit", "INTEGER" },
{ "delay", 'D', POPT_ARG_INT, &torture_delay, 0, "delay (in seconds) between operations", "INTEGER" },
{ "verbose", 'v', POPT_ARG_NONE, &verbose, 0, "switch on verbose mode", NULL },
{ "db-name", 'N', POPT_ARG_STRING, &db_name, 0, "name of the test db", "NAME" },
{ "no-trans", 'n', POPT_ARG_NONE, &no_trans, 0, "use fetch_lock/record store instead of transactions", NULL },
{ "unsafe-writes", 'u', POPT_ARG_NONE, &unsafe_writes, 0, "do not use tdb transactions when writing", NULL },
POPT_TABLEEND
};
int opt;
const char **extra_argv;
int extra_argc = 0;
poptContext pc;
int tdb_flags;
int ret = 1;
mem_ctx = talloc_stackframe();
if (verbose) {
setbuf(stdout, (char *)NULL); /* don't buffer */
} else {
setlinebuf(stdout);
}
load_case_tables();
setup_logging(argv[0], DEBUG_STDERR);
lp_set_cmdline("log level", "0");
pc = poptGetContext(argv[0], argc, argv, popt_options, POPT_CONTEXT_KEEP_FIRST);
while ((opt = poptGetNextOpt(pc)) != -1) {
switch (opt) {
default:
fprintf(stderr, "Invalid option %s: %s\n",
poptBadOption(pc, 0), poptStrerror(opt));
goto done;
}
}
/* setup the remaining options for the main program to use */
extra_argv = poptGetArgs(pc);
if (extra_argv) {
extra_argv++;
while (extra_argv[extra_argc]) extra_argc++;
}
lp_load_global(get_dyn_CONFIGFILE());
ev_ctx = samba_tevent_context_init(mem_ctx);
if (ev_ctx == NULL) {
d_fprintf(stderr, "ERROR: could not init event context\n");
goto done;
}
msg_ctx = messaging_init(mem_ctx, ev_ctx);
if (msg_ctx == NULL) {
d_fprintf(stderr, "ERROR: could not init messaging context\n");
goto done;
}
if (unsafe_writes == 1) {
tdb_flags = TDB_NOSYNC;
} else {
tdb_flags = TDB_DEFAULT;
}
if (no_trans) {
tdb_flags |= TDB_CLEAR_IF_FIRST|TDB_INCOMPATIBLE_HASH;
}
db = db_open(mem_ctx, db_name, 0, tdb_flags, O_RDWR | O_CREAT, 0644,
DBWRAP_LOCK_ORDER_1);
if (db == NULL) {
d_fprintf(stderr, "failed to open db '%s': %s\n", db_name,
strerror(errno));
goto done;
}
if (get_my_vnn() == NONCLUSTER_VNN) {
set_my_vnn(0);
}
pnn = get_my_vnn();
printf("Starting test on node %u. running for %u seconds. "
"sleep delay: %u seconds.\n", pnn, timelimit, torture_delay);
if (!verbose && (pnn == 0)) {
tevent_add_timer(ev_ctx, db, timeval_current_ofs(1, 0), each_second, db);
}
test_store_records(db, ev_ctx);
if (verbose || (pnn == 0)) {
if (success != true) {
printf("The test FAILED\n");
ret = 2;
} else {
printf("SUCCESS!\n");
ret = 0;
}
}
done:
talloc_free(mem_ctx);
return ret;
}
int main(int argc, char **argv, char **envp)
{
int opt;
TALLOC_CTX *frame = talloc_stackframe();
poptContext pc;
static char *string_arg;
static char *opt_domain_name;
static int int_arg;
int result = 1;
bool verbose = false;
struct poptOption long_options[] = {
POPT_AUTOHELP
/* longName, shortName, argInfo, argPtr, value, descrip,
argDesc */
{ "domain-users", 'u', POPT_ARG_NONE, 0, 'u', "Lists all domain users", "domain"},
{ "domain-groups", 'g', POPT_ARG_NONE, 0, 'g', "Lists all domain groups", "domain" },
{ "WINS-by-name", 'N', POPT_ARG_STRING, &string_arg, 'N', "Converts NetBIOS name to IP", "NETBIOS-NAME" },
{ "WINS-by-ip", 'I', POPT_ARG_STRING, &string_arg, 'I', "Converts IP address to NetBIOS name", "IP" },
{ "name-to-sid", 'n', POPT_ARG_STRING, &string_arg, 'n', "Converts name to sid", "NAME" },
{ "sid-to-name", 's', POPT_ARG_STRING, &string_arg, 's', "Converts sid to name", "SID" },
{ "lookup-rids", 'R', POPT_ARG_STRING, &string_arg, 'R', "Converts RIDs to names", "RIDs" },
{ "uid-to-sid", 'U', POPT_ARG_INT, &int_arg, 'U', "Converts uid to sid" , "UID" },
{ "gid-to-sid", 'G', POPT_ARG_INT, &int_arg, 'G', "Converts gid to sid", "GID" },
{ "sid-to-uid", 'S', POPT_ARG_STRING, &string_arg, 'S', "Converts sid to uid", "SID" },
{ "sid-to-gid", 'Y', POPT_ARG_STRING, &string_arg, 'Y', "Converts sid to gid", "SID" },
{ "allocate-uid", 0, POPT_ARG_NONE, 0, OPT_ALLOCATE_UID,
"Get a new UID out of idmap" },
{ "allocate-gid", 0, POPT_ARG_NONE, 0, OPT_ALLOCATE_GID,
"Get a new GID out of idmap" },
{ "check-secret", 't', POPT_ARG_NONE, 0, 't', "Check shared secret" },
{ "trusted-domains", 'm', POPT_ARG_NONE, 0, 'm', "List trusted domains" },
{ "all-domains", 0, POPT_ARG_NONE, 0, OPT_LIST_ALL_DOMAINS, "List all domains (trusted and own domain)" },
{ "own-domain", 0, POPT_ARG_NONE, 0, OPT_LIST_OWN_DOMAIN, "List own domain" },
{ "sequence", 0, POPT_ARG_NONE, 0, OPT_SEQUENCE, "Show sequence numbers of all domains" },
{ "online-status", 0, POPT_ARG_NONE, 0, OPT_ONLINESTATUS, "Show whether domains are marked as online or offline"},
{ "domain-info", 'D', POPT_ARG_STRING, &string_arg, 'D', "Show most of the info we have about the domain" },
{ "user-info", 'i', POPT_ARG_STRING, &string_arg, 'i', "Get user info", "USER" },
{ "uid-info", 0, POPT_ARG_INT, &int_arg, OPT_UID_INFO, "Get user info from uid", "UID" },
{ "group-info", 0, POPT_ARG_STRING, &string_arg, OPT_GROUP_INFO, "Get group info", "GROUP" },
{ "user-groups", 'r', POPT_ARG_STRING, &string_arg, 'r', "Get user groups", "USER" },
{ "user-domgroups", 0, POPT_ARG_STRING, &string_arg,
OPT_USERDOMGROUPS, "Get user domain groups", "SID" },
{ "user-sids", 0, POPT_ARG_STRING, &string_arg, OPT_USERSIDS, "Get user group sids for user SID", "SID" },
{ "authenticate", 'a', POPT_ARG_STRING, &string_arg, 'a', "authenticate user", "user%password" },
{ "set-auth-user", 0, POPT_ARG_STRING, &string_arg, OPT_SET_AUTH_USER, "Store user and password used by winbindd (root only)", "user%password" },
{ "getdcname", 0, POPT_ARG_STRING, &string_arg, OPT_GETDCNAME,
"Get a DC name for a foreign domain", "domainname" },
{ "dsgetdcname", 0, POPT_ARG_STRING, &string_arg, OPT_DSGETDCNAME, "Find a DC for a domain", "domainname" },
{ "get-auth-user", 0, POPT_ARG_NONE, NULL, OPT_GET_AUTH_USER, "Retrieve user and password used by winbindd (root only)", NULL },
{ "ping", 'p', POPT_ARG_NONE, 0, 'p', "Ping winbindd to see if it is alive" },
{ "domain", 0, POPT_ARG_STRING, &opt_domain_name, OPT_DOMAIN_NAME, "Define to the domain to restrict operation", "domain" },
#ifdef WITH_FAKE_KASERVER
{ "klog", 'k', POPT_ARG_STRING, &string_arg, 'k', "set an AFS token from winbind", "user%password" },
#endif
#ifdef HAVE_KRB5
{ "krb5auth", 'K', POPT_ARG_STRING, &string_arg, 'K', "authenticate user using Kerberos", "user%password" },
/* destroys wbinfo --help output */
/* "user%password,DOM\\user%password,[email protected],EXAMPLE.COM\\user%password" }, */
#endif
{ "separator", 0, POPT_ARG_NONE, 0, OPT_SEPARATOR, "Get the active winbind separator", NULL },
{ "verbose", 0, POPT_ARG_NONE, 0, OPT_VERBOSE, "Print additional information per command", NULL },
POPT_COMMON_CONFIGFILE
POPT_COMMON_VERSION
POPT_TABLEEND
};
/* Samba client initialisation */
load_case_tables();
/* Parse options */
pc = poptGetContext("wbinfo", argc, (const char **)argv, long_options, 0);
/* Parse command line options */
if (argc == 1) {
poptPrintHelp(pc, stderr, 0);
return 1;
}
while((opt = poptGetNextOpt(pc)) != -1) {
/* get the generic configuration parameters like --domain */
switch (opt) {
case OPT_VERBOSE:
verbose = True;
break;
}
}
poptFreeContext(pc);
if (!lp_load(get_dyn_CONFIGFILE(), true, false, false, true)) {
d_fprintf(stderr, "wbinfo: error opening config file %s. Error was %s\n",
get_dyn_CONFIGFILE(), strerror(errno));
exit(1);
}
if (!init_names())
return 1;
load_interfaces();
pc = poptGetContext(NULL, argc, (const char **)argv, long_options,
POPT_CONTEXT_KEEP_FIRST);
while((opt = poptGetNextOpt(pc)) != -1) {
switch (opt) {
case 'u':
if (!print_domain_users(opt_domain_name)) {
d_fprintf(stderr, "Error looking up domain users\n");
goto done;
}
break;
case 'g':
if (!print_domain_groups(opt_domain_name)) {
d_fprintf(stderr, "Error looking up domain groups\n");
goto done;
}
break;
case 's':
if (!wbinfo_lookupsid(string_arg)) {
d_fprintf(stderr, "Could not lookup sid %s\n", string_arg);
goto done;
}
break;
case 'R':
if (!wbinfo_lookuprids(opt_domain_name, string_arg)) {
d_fprintf(stderr, "Could not lookup RIDs %s\n", string_arg);
goto done;
}
break;
case 'n':
if (!wbinfo_lookupname(string_arg)) {
d_fprintf(stderr, "Could not lookup name %s\n", string_arg);
goto done;
}
break;
case 'N':
if (!wbinfo_wins_byname(string_arg)) {
d_fprintf(stderr, "Could not lookup WINS by name %s\n", string_arg);
goto done;
}
break;
case 'I':
if (!wbinfo_wins_byip(string_arg)) {
d_fprintf(stderr, "Could not lookup WINS by IP %s\n", string_arg);
goto done;
}
break;
case 'U':
if (!wbinfo_uid_to_sid(int_arg)) {
d_fprintf(stderr, "Could not convert uid %d to sid\n", int_arg);
goto done;
}
break;
case 'G':
if (!wbinfo_gid_to_sid(int_arg)) {
d_fprintf(stderr, "Could not convert gid %d to sid\n",
int_arg);
goto done;
}
break;
case 'S':
if (!wbinfo_sid_to_uid(string_arg)) {
d_fprintf(stderr, "Could not convert sid %s to uid\n",
string_arg);
goto done;
}
break;
case 'Y':
if (!wbinfo_sid_to_gid(string_arg)) {
d_fprintf(stderr, "Could not convert sid %s to gid\n",
string_arg);
goto done;
}
break;
case OPT_ALLOCATE_UID:
if (!wbinfo_allocate_uid()) {
d_fprintf(stderr, "Could not allocate a uid\n");
goto done;
}
break;
case OPT_ALLOCATE_GID:
if (!wbinfo_allocate_gid()) {
d_fprintf(stderr, "Could not allocate a gid\n");
goto done;
}
break;
case 't':
if (!wbinfo_check_secret()) {
d_fprintf(stderr, "Could not check secret\n");
goto done;
}
break;
case 'm':
if (!wbinfo_list_domains(false, verbose)) {
d_fprintf(stderr, "Could not list trusted domains\n");
goto done;
}
break;
case OPT_SEQUENCE:
if (!wbinfo_show_sequence(opt_domain_name)) {
d_fprintf(stderr, "Could not show sequence numbers\n");
goto done;
}
break;
case OPT_ONLINESTATUS:
if (!wbinfo_show_onlinestatus(opt_domain_name)) {
d_fprintf(stderr, "Could not show online-status\n");
goto done;
}
break;
case 'D':
if (!wbinfo_domain_info(string_arg)) {
d_fprintf(stderr, "Could not get domain info\n");
goto done;
}
break;
case 'i':
if (!wbinfo_get_userinfo(string_arg)) {
d_fprintf(stderr, "Could not get info for user %s\n",
string_arg);
goto done;
}
break;
case OPT_UID_INFO:
if ( !wbinfo_get_uidinfo(int_arg)) {
d_fprintf(stderr, "Could not get info for uid "
"%d\n", int_arg);
goto done;
}
break;
case OPT_GROUP_INFO:
if ( !wbinfo_get_groupinfo(string_arg)) {
d_fprintf(stderr, "Could not get info for "
"group %s\n", string_arg);
goto done;
}
break;
case 'r':
if (!wbinfo_get_usergroups(string_arg)) {
d_fprintf(stderr, "Could not get groups for user %s\n",
string_arg);
goto done;
}
break;
case OPT_USERSIDS:
if (!wbinfo_get_usersids(string_arg)) {
d_fprintf(stderr, "Could not get group SIDs for user SID %s\n",
string_arg);
goto done;
}
break;
case OPT_USERDOMGROUPS:
if (!wbinfo_get_userdomgroups(string_arg)) {
d_fprintf(stderr, "Could not get user's domain groups "
"for user SID %s\n", string_arg);
goto done;
}
break;
case 'a': {
bool got_error = false;
char *pass;
if ((pass = strchr(string_arg, '%')) != NULL) {
*pass = 0;
pass++;
} else {
pass = (char *)"";
}
if (!wbinfo_auth(string_arg, pass)) {
d_fprintf(stderr, "Could not authenticate user %s with "
"plaintext password\n", string_arg);
got_error = true;
}
if (!wbinfo_auth_crap(string_arg, pass)) {
d_fprintf(stderr, "Could not authenticate user %s with "
"challenge/response\n", string_arg);
got_error = true;
}
if (got_error)
goto done;
break;
}
case 'K': {
uint32 flags = WBFLAG_PAM_KRB5 |
WBFLAG_PAM_CACHED_LOGIN |
WBFLAG_PAM_FALLBACK_AFTER_KRB5 |
WBFLAG_PAM_INFO3_TEXT;
char *pass;
if ((pass = strchr(string_arg, '%')) != NULL) {
*pass = 0;
pass++;
} else {
pass = (char *)"";
}
if (!wbinfo_auth_krb5(string_arg, pass, "FILE", flags)) {
d_fprintf(stderr, "Could not authenticate user [%s] with "
"Kerberos (ccache: %s)\n", string_arg, "FILE");
goto done;
}
break;
}
case 'k':
if (!wbinfo_klog(string_arg)) {
d_fprintf(stderr, "Could not klog user\n");
goto done;
}
break;
case 'p':
if (!wbinfo_ping()) {
d_fprintf(stderr, "could not ping winbindd!\n");
goto done;
}
break;
case OPT_SET_AUTH_USER:
if (!wbinfo_set_auth_user(string_arg)) {
goto done;
}
break;
case OPT_GET_AUTH_USER:
wbinfo_get_auth_user();
break;
case OPT_GETDCNAME:
if (!wbinfo_getdcname(string_arg)) {
goto done;
}
break;
case OPT_DSGETDCNAME:
if (!wbinfo_dsgetdcname(string_arg, 0)) {
goto done;
}
break;
case OPT_SEPARATOR: {
const char sep = winbind_separator_int(true);
if ( !sep ) {
goto done;
}
d_printf("%c\n", sep);
break;
}
case OPT_LIST_ALL_DOMAINS:
if (!wbinfo_list_domains(true, verbose)) {
goto done;
}
break;
case OPT_LIST_OWN_DOMAIN:
if (!wbinfo_list_own_domain()) {
goto done;
}
break;
/* generic configuration options */
case OPT_DOMAIN_NAME:
break;
case OPT_VERBOSE:
break;
default:
d_fprintf(stderr, "Invalid option\n");
poptPrintHelp(pc, stderr, 0);
goto done;
}
}
result = 0;
/* Exit code */
done:
talloc_destroy(frame);
poptFreeContext(pc);
return result;
}
/****************************************************************************
main program
****************************************************************************/
int main(int argc, const char **argv)
{
int opt,i;
char *p;
int rc = 0;
int argc_new = 0;
const char ** argv_new;
poptContext pc;
TALLOC_CTX *frame = talloc_stackframe();
struct net_context *c = talloc_zero(frame, struct net_context);
struct poptOption long_options[] = {
{"help", 'h', POPT_ARG_NONE, 0, 'h'},
{"workgroup", 'w', POPT_ARG_STRING, &c->opt_target_workgroup},
{"user", 'U', POPT_ARG_STRING, &c->opt_user_name, 'U'},
{"ipaddress", 'I', POPT_ARG_STRING, 0,'I'},
{"port", 'p', POPT_ARG_INT, &c->opt_port},
{"myname", 'n', POPT_ARG_STRING, &c->opt_requester_name},
{"server", 'S', POPT_ARG_STRING, &c->opt_host},
{"encrypt", 'e', POPT_ARG_NONE, NULL, 'e', N_("Encrypt SMB transport (UNIX extended servers only)") },
{"container", 'c', POPT_ARG_STRING, &c->opt_container},
{"comment", 'C', POPT_ARG_STRING, &c->opt_comment},
{"maxusers", 'M', POPT_ARG_INT, &c->opt_maxusers},
{"flags", 'F', POPT_ARG_INT, &c->opt_flags},
{"long", 'l', POPT_ARG_NONE, &c->opt_long_list_entries},
{"reboot", 'r', POPT_ARG_NONE, &c->opt_reboot},
{"force", 'f', POPT_ARG_NONE, &c->opt_force},
{"stdin", 'i', POPT_ARG_NONE, &c->opt_stdin},
{"timeout", 't', POPT_ARG_INT, &c->opt_timeout},
{"request-timeout",0,POPT_ARG_INT, &c->opt_request_timeout},
{"machine-pass",'P', POPT_ARG_NONE, &c->opt_machine_pass},
{"kerberos", 'k', POPT_ARG_NONE, &c->opt_kerberos},
{"myworkgroup", 'W', POPT_ARG_STRING, &c->opt_workgroup},
{"use-ccache", 0, POPT_ARG_NONE, &c->opt_ccache},
{"verbose", 'v', POPT_ARG_NONE, &c->opt_verbose},
{"test", 'T', POPT_ARG_NONE, &c->opt_testmode},
/* Options for 'net groupmap set' */
{"local", 'L', POPT_ARG_NONE, &c->opt_localgroup},
{"domain", 'D', POPT_ARG_NONE, &c->opt_domaingroup},
{"ntname", 'N', POPT_ARG_STRING, &c->opt_newntname},
{"rid", 'R', POPT_ARG_INT, &c->opt_rid},
/* Options for 'net rpc share migrate' */
{"acls", 0, POPT_ARG_NONE, &c->opt_acls},
{"attrs", 0, POPT_ARG_NONE, &c->opt_attrs},
{"timestamps", 0, POPT_ARG_NONE, &c->opt_timestamps},
{"exclude", 'X', POPT_ARG_STRING, &c->opt_exclude},
{"destination", 0, POPT_ARG_STRING, &c->opt_destination},
{"tallocreport", 0, POPT_ARG_NONE, &c->do_talloc_report},
/* Options for 'net rpc vampire (keytab)' */
{"force-full-repl", 0, POPT_ARG_NONE, &c->opt_force_full_repl},
{"single-obj-repl", 0, POPT_ARG_NONE, &c->opt_single_obj_repl},
{"clean-old-entries", 0, POPT_ARG_NONE, &c->opt_clean_old_entries},
/* Options for 'net idmap'*/
{"db", 0, POPT_ARG_STRING, &c->opt_db},
{"lock", 0, POPT_ARG_NONE, &c->opt_lock},
{"auto", 'a', POPT_ARG_NONE, &c->opt_auto},
{"repair", 0, POPT_ARG_NONE, &c->opt_repair},
/* Options for 'net registry check'*/
{"reg-version", 0, POPT_ARG_INT, &c->opt_reg_version},
{"output", 'o', POPT_ARG_STRING, &c->opt_output},
{"wipe", 0, POPT_ARG_NONE, &c->opt_wipe},
POPT_COMMON_SAMBA
{ 0, 0, 0, 0}
};
zero_sockaddr(&c->opt_dest_ip);
setup_logging(argv[0], DEBUG_STDERR);
load_case_tables();
setlocale(LC_ALL, "");
#if defined(HAVE_BINDTEXTDOMAIN)
bindtextdomain(MODULE_NAME, get_dyn_LOCALEDIR());
#endif
#if defined(HAVE_TEXTDOMAIN)
textdomain(MODULE_NAME);
#endif
/* set default debug level to 0 regardless of what smb.conf sets */
lp_set_cmdline("log level", "0");
c->private_data = net_func;
pc = poptGetContext(NULL, argc, (const char **) argv, long_options,
POPT_CONTEXT_KEEP_FIRST);
while((opt = poptGetNextOpt(pc)) != -1) {
switch (opt) {
case 'h':
c->display_usage = true;
break;
case 'e':
c->smb_encrypt = true;
break;
case 'I':
if (!interpret_string_addr(&c->opt_dest_ip,
poptGetOptArg(pc), 0)) {
d_fprintf(stderr, _("\nInvalid ip address specified\n"));
} else {
c->opt_have_ip = true;
}
break;
case 'U':
c->opt_user_specified = true;
c->opt_user_name = SMB_STRDUP(c->opt_user_name);
p = strchr(c->opt_user_name,'%');
if (p) {
*p = 0;
c->opt_password = p+1;
}
break;
default:
d_fprintf(stderr, _("\nInvalid option %s: %s\n"),
poptBadOption(pc, 0), poptStrerror(opt));
net_help(c, argc, argv);
exit(1);
}
}
lp_load_global(get_dyn_CONFIGFILE());
#if defined(HAVE_BIND_TEXTDOMAIN_CODESET)
/* Bind our gettext results to 'unix charset'
This ensures that the translations and any embedded strings are in the
same charset. It won't be the one from the user's locale (we no
longer auto-detect that), but it will be self-consistent.
*/
bind_textdomain_codeset(MODULE_NAME, lp_unix_charset());
#endif
argv_new = (const char **)poptGetArgs(pc);
argc_new = argc;
for (i=0; i<argc; i++) {
if (argv_new[i] == NULL) {
argc_new = i;
break;
}
}
if (c->do_talloc_report) {
talloc_enable_leak_report();
}
if (c->opt_requester_name) {
lp_set_cmdline("netbios name", c->opt_requester_name);
}
if (!c->opt_user_name && getenv("LOGNAME")) {
c->opt_user_name = getenv("LOGNAME");
}
if (!c->opt_workgroup) {
c->opt_workgroup = smb_xstrdup(lp_workgroup());
}
if (!c->opt_target_workgroup) {
c->opt_target_workgroup = smb_xstrdup(lp_workgroup());
}
if (!init_names())
exit(1);
load_interfaces();
/* this makes sure that when we do things like call scripts,
that it won't assert because we are not root */
sec_init();
if (c->opt_machine_pass) {
/* it is very useful to be able to make ads queries as the
machine account for testing purposes and for domain leave */
net_use_krb_machine_account(c);
}
if (!c->opt_password) {
c->opt_password = getenv("PASSWD");
}
/* Failing to init the msg_ctx isn't a fatal error. Only
root-level things (joining/leaving domains etc.) will be denied. */
c->msg_ctx = messaging_init(c, procid_self(),
event_context_init(c));
rc = net_run_function(c, argc_new-1, argv_new+1, "net", net_func);
DEBUG(2,("return code = %d\n", rc));
gencache_stabilize();
libnetapi_free(c->netapi_ctx);
poptFreeContext(pc);
TALLOC_FREE(frame);
return rc;
}
/****************************************************************************
main program
****************************************************************************/
int main(int argc,char *argv[])
{
TALLOC_CTX *frame = talloc_stackframe();
struct user_auth_info local_auth_info;
struct poptOption long_options[] = {
POPT_AUTOHELP
{ "broadcast", 'b', POPT_ARG_VAL, &use_bcast, True, "Use broadcast instead of using the master browser" },
{ "domains", 'D', POPT_ARG_VAL, &level, LEV_WORKGROUP, "List only domains (workgroups) of tree" },
{ "servers", 'S', POPT_ARG_VAL, &level, LEV_SERVER, "List domains(workgroups) and servers of tree" },
POPT_COMMON_SAMBA
POPT_COMMON_CREDENTIALS
POPT_TABLEEND
};
poptContext pc;
/* Initialise samba stuff */
load_case_tables();
setlinebuf(stdout);
dbf = x_stderr;
setup_logging(argv[0],True);
pc = poptGetContext("smbtree", argc, (const char **)argv, long_options,
POPT_CONTEXT_KEEP_FIRST);
while(poptGetNextOpt(pc) != -1);
poptFreeContext(pc);
lp_load(get_dyn_CONFIGFILE(),True,False,False,True);
load_interfaces();
/* Parse command line args */
if (get_cmdline_auth_info_use_machine_account() &&
!set_cmdline_auth_info_machine_account_creds()) {
TALLOC_FREE(frame);
return 1;
}
if (!get_cmdline_auth_info_got_pass()) {
char *pass = getpass("Password: ");
if (pass) {
set_cmdline_auth_info_password(pass);
}
}
/* Now do our stuff */
if (!get_cmdline_auth_info_copy(&local_auth_info)) {
return 1;
}
if (!print_tree(&local_auth_info)) {
TALLOC_FREE(frame);
return 1;
}
TALLOC_FREE(frame);
return 0;
}
int main(int argc, char *argv[])
{
int c;
int profile_only = 0;
bool show_processes, show_locks, show_shares;
poptContext pc;
struct poptOption long_options[] = {
POPT_AUTOHELP
{"processes", 'p', POPT_ARG_NONE, NULL, 'p', "Show processes only" },
{"verbose", 'v', POPT_ARG_NONE, NULL, 'v', "Be verbose" },
{"locks", 'L', POPT_ARG_NONE, NULL, 'L', "Show locks only" },
{"shares", 'S', POPT_ARG_NONE, NULL, 'S', "Show shares only" },
{"user", 'u', POPT_ARG_STRING, &username, 'u', "Switch to user" },
{"brief", 'b', POPT_ARG_NONE, NULL, 'b', "Be brief" },
{"profile", 'P', POPT_ARG_NONE, NULL, 'P', "Do profiling" },
{"profile-rates", 'R', POPT_ARG_NONE, NULL, 'R', "Show call rates" },
{"byterange", 'B', POPT_ARG_NONE, NULL, 'B', "Include byte range locks"},
{"numeric", 'n', POPT_ARG_NONE, NULL, 'n', "Numeric uid/gid"},
POPT_COMMON_SAMBA
POPT_TABLEEND
};
TALLOC_CTX *frame = talloc_stackframe();
int ret = 0;
struct messaging_context *msg_ctx;
sec_init();
load_case_tables();
setup_logging(argv[0], DEBUG_STDERR);
if (getuid() != geteuid()) {
d_printf("smbstatus should not be run setuid\n");
ret = 1;
goto done;
}
pc = poptGetContext(NULL, argc, (const char **) argv, long_options,
POPT_CONTEXT_KEEP_FIRST);
while ((c = poptGetNextOpt(pc)) != -1) {
switch (c) {
case 'p':
processes_only = true;
break;
case 'v':
verbose = true;
break;
case 'L':
locks_only = true;
break;
case 'S':
shares_only = true;
break;
case 'b':
brief = true;
break;
case 'u':
Ucrit_addUid(nametouid(poptGetOptArg(pc)));
break;
case 'P':
case 'R':
profile_only = c;
break;
case 'B':
show_brl = true;
break;
case 'n':
numeric_only = true;
break;
}
}
/* setup the flags based on the possible combincations */
show_processes = !(shares_only || locks_only || profile_only) || processes_only;
show_locks = !(shares_only || processes_only || profile_only) || locks_only;
show_shares = !(processes_only || locks_only || profile_only) || shares_only;
if ( username )
Ucrit_addUid( nametouid(username) );
if (verbose) {
d_printf("using configfile = %s\n", get_dyn_CONFIGFILE());
}
if (!lp_load_initial_only(get_dyn_CONFIGFILE())) {
fprintf(stderr, "Can't load %s - run testparm to debug it\n",
get_dyn_CONFIGFILE());
ret = -1;
goto done;
}
if (lp_clustering()) {
/*
* This implicitly initializes the global ctdbd
* connection, usable by the db_open() calls further
* down.
*/
msg_ctx = messaging_init(NULL, event_context_init(NULL));
if (msg_ctx == NULL) {
fprintf(stderr, "messaging_init failed\n");
ret = -1;
goto done;
}
}
if (!lp_load_global(get_dyn_CONFIGFILE())) {
fprintf(stderr, "Can't load %s - run testparm to debug it\n",
get_dyn_CONFIGFILE());
ret = -1;
goto done;
}
switch (profile_only) {
case 'P':
/* Dump profile data */
return status_profile_dump(verbose);
case 'R':
/* Continuously display rate-converted data */
return status_profile_rates(verbose);
default:
break;
}
if ( show_processes ) {
d_printf("\nSamba version %s\n",samba_version_string());
d_printf("PID Username Group Machine \n");
d_printf("-------------------------------------------------------------------\n");
if (lp_security() == SEC_SHARE) {
d_printf(" <processes do not show up in "
"anonymous mode>\n");
}
sessionid_traverse_read(traverse_sessionid, NULL);
if (processes_only) {
goto done;
}
}
if ( show_shares ) {
if (verbose) {
d_printf("Opened %s\n", lock_path("connections.tdb"));
}
if (brief) {
goto done;
}
d_printf("\nService pid machine Connected at\n");
d_printf("-------------------------------------------------------\n");
connections_forall_read(traverse_fn1, NULL);
d_printf("\n");
if ( shares_only ) {
goto done;
}
}
if ( show_locks ) {
int result;
struct db_context *db;
db = db_open(NULL, lock_path("locking.tdb"), 0,
TDB_CLEAR_IF_FIRST|TDB_INCOMPATIBLE_HASH, O_RDONLY, 0,
DBWRAP_LOCK_ORDER_1);
if (!db) {
d_printf("%s not initialised\n",
lock_path("locking.tdb"));
d_printf("This is normal if an SMB client has never "
"connected to your server.\n");
exit(0);
} else {
TALLOC_FREE(db);
}
if (!locking_init_readonly()) {
d_printf("Can't initialise locking module - exiting\n");
ret = 1;
goto done;
}
result = share_mode_forall(print_share_mode, NULL);
if (result == 0) {
d_printf("No locked files\n");
} else if (result < 0) {
d_printf("locked file list truncated\n");
}
d_printf("\n");
if (show_brl) {
brl_forall(print_brl, NULL);
}
locking_end();
}
done:
TALLOC_FREE(frame);
return ret;
}
int main(int argc, const char **argv)
{
static int list_users = False;
static int verbose = False;
static int spstyle = False;
static int machine = False;
static int add_user = False;
static int delete_user = False;
static int modify_user = False;
uint32_t setparms, checkparms;
int opt;
static char *full_name = NULL;
static char *acct_desc = NULL;
static const char *user_name = NULL;
static char *home_dir = NULL;
static char *home_drive = NULL;
static const char *backend = NULL;
static char *backend_in = NULL;
static char *backend_out = NULL;
static int transfer_groups = False;
static int transfer_account_policies = False;
static int reset_account_policies = False;
static int force_initialised_password = False;
static char *logon_script = NULL;
static char *profile_path = NULL;
static char *user_domain = NULL;
static char *account_control = NULL;
static char *account_policy = NULL;
static char *user_sid = NULL;
static char *machine_sid = NULL;
static long int account_policy_value = 0;
bool account_policy_value_set = False;
static int badpw_reset = False;
static int hours_reset = False;
static char *pwd_time_format = NULL;
static int pw_from_stdin = False;
struct pdb_methods *bin, *bout;
static char *kickoff_time = NULL;
TALLOC_CTX *frame = talloc_stackframe();
NTSTATUS status;
poptContext pc;
struct poptOption long_options[] = {
POPT_AUTOHELP
{"list", 'L', POPT_ARG_NONE, &list_users, 0, "list all users", NULL},
{"verbose", 'v', POPT_ARG_NONE, &verbose, 0, "be verbose", NULL },
{"smbpasswd-style", 'w',POPT_ARG_NONE, &spstyle, 0, "give output in smbpasswd style", NULL},
{"user", 'u', POPT_ARG_STRING, &user_name, 0, "use username", "USER" },
{"account-desc", 'N', POPT_ARG_STRING, &acct_desc, 0, "set account description", NULL},
{"fullname", 'f', POPT_ARG_STRING, &full_name, 0, "set full name", NULL},
{"homedir", 'h', POPT_ARG_STRING, &home_dir, 0, "set home directory", NULL},
{"drive", 'D', POPT_ARG_STRING, &home_drive, 0, "set home drive", NULL},
{"script", 'S', POPT_ARG_STRING, &logon_script, 0, "set logon script", NULL},
{"profile", 'p', POPT_ARG_STRING, &profile_path, 0, "set profile path", NULL},
{"domain", 'I', POPT_ARG_STRING, &user_domain, 0, "set a users' domain", NULL},
{"user SID", 'U', POPT_ARG_STRING, &user_sid, 0, "set user SID or RID", NULL},
{"machine SID", 'M', POPT_ARG_STRING, &machine_sid, 0, "set machine SID or RID", NULL},
{"create", 'a', POPT_ARG_NONE, &add_user, 0, "create user", NULL},
{"modify", 'r', POPT_ARG_NONE, &modify_user, 0, "modify user", NULL},
{"machine", 'm', POPT_ARG_NONE, &machine, 0, "account is a machine account", NULL},
{"delete", 'x', POPT_ARG_NONE, &delete_user, 0, "delete user", NULL},
{"backend", 'b', POPT_ARG_STRING, &backend, 0, "use different passdb backend as default backend", NULL},
{"import", 'i', POPT_ARG_STRING, &backend_in, 0, "import user accounts from this backend", NULL},
{"export", 'e', POPT_ARG_STRING, &backend_out, 0, "export user accounts to this backend", NULL},
{"group", 'g', POPT_ARG_NONE, &transfer_groups, 0, "use -i and -e for groups", NULL},
{"policies", 'y', POPT_ARG_NONE, &transfer_account_policies, 0, "use -i and -e to move account policies between backends", NULL},
{"policies-reset", 0, POPT_ARG_NONE, &reset_account_policies, 0, "restore default policies", NULL},
{"account-policy", 'P', POPT_ARG_STRING, &account_policy, 0,"value of an account policy (like maximum password age)",NULL},
{"value", 'C', POPT_ARG_LONG, &account_policy_value, 'C',"set the account policy to this value", NULL},
{"account-control", 'c', POPT_ARG_STRING, &account_control, 0, "Values of account control", NULL},
{"force-initialized-passwords", 0, POPT_ARG_NONE, &force_initialised_password, 0, "Force initialization of corrupt password strings in a passdb backend", NULL},
{"bad-password-count-reset", 'z', POPT_ARG_NONE, &badpw_reset, 0, "reset bad password count", NULL},
{"logon-hours-reset", 'Z', POPT_ARG_NONE, &hours_reset, 0, "reset logon hours", NULL},
{"time-format", 0, POPT_ARG_STRING, &pwd_time_format, 0, "The time format for time parameters", NULL },
{"password-from-stdin", 't', POPT_ARG_NONE, &pw_from_stdin, 0, "get password from standard in", NULL},
{"kickoff-time", 'K', POPT_ARG_STRING, &kickoff_time, 0, "set the kickoff time", NULL},
POPT_COMMON_SAMBA
POPT_TABLEEND
};
bin = bout = NULL;
smb_init_locale();
setup_logging("pdbedit", DEBUG_STDOUT);
pc = poptGetContext(NULL, argc, argv, long_options,
POPT_CONTEXT_KEEP_FIRST);
while((opt = poptGetNextOpt(pc)) != -1) {
switch (opt) {
case 'C':
account_policy_value_set = True;
break;
}
}
poptGetArg(pc); /* Drop argv[0], the program name */
if (user_name == NULL)
user_name = poptGetArg(pc);
if (!lp_load_global(get_dyn_CONFIGFILE())) {
fprintf(stderr, "Can't load %s - run testparm to debug it\n", get_dyn_CONFIGFILE());
exit(1);
}
if (!init_names())
exit(1);
setparms = (backend ? BIT_BACKEND : 0) +
(verbose ? BIT_VERBOSE : 0) +
(spstyle ? BIT_SPSTYLE : 0) +
(full_name ? BIT_FULLNAME : 0) +
(home_dir ? BIT_HOMEDIR : 0) +
(home_drive ? BIT_HDIRDRIVE : 0) +
(logon_script ? BIT_LOGSCRIPT : 0) +
(profile_path ? BIT_PROFILE : 0) +
(user_domain ? BIT_USERDOMAIN : 0) +
(machine ? BIT_MACHINE : 0) +
(user_name ? BIT_USER : 0) +
(list_users ? BIT_LIST : 0) +
(force_initialised_password ? BIT_FIX_INIT : 0) +
(user_sid ? BIT_USERSIDS : 0) +
(machine_sid ? BIT_USERSIDS : 0) +
(modify_user ? BIT_MODIFY : 0) +
(add_user ? BIT_CREATE : 0) +
(delete_user ? BIT_DELETE : 0) +
(account_control ? BIT_ACCTCTRL : 0) +
(account_policy ? BIT_ACCPOLICY : 0) +
(account_policy_value_set ? BIT_ACCPOLVAL : 0) +
(backend_in ? BIT_IMPORT : 0) +
(backend_out ? BIT_EXPORT : 0) +
(badpw_reset ? BIT_BADPWRESET : 0) +
(hours_reset ? BIT_LOGONHOURS : 0) +
(kickoff_time ? BIT_KICKOFFTIME : 0) +
(acct_desc ? BIT_DESCRIPTION : 0);
if (setparms & BIT_BACKEND) {
/* HACK: set the global passdb backend by overwriting globals.
* This way we can use regular pdb functions for default
* operations that do not involve passdb migrations */
lp_set_cmdline("passdb backend", backend);
} else {
backend = lp_passdb_backend();
}
if (!initialize_password_db(False, NULL)) {
fprintf(stderr, "Can't initialize passdb backend.\n");
exit(1);
}
/* the lowest bit options are always accepted */
checkparms = setparms & ~MASK_ALWAYS_GOOD;
if (checkparms & BIT_FIX_INIT) {
return fix_users_list();
}
/* account policy operations */
if ((checkparms & BIT_ACCPOLICY) && !(checkparms & ~(BIT_ACCPOLICY + BIT_ACCPOLVAL))) {
uint32_t value;
enum pdb_policy_type field = account_policy_name_to_typenum(account_policy);
if (field == 0) {
const char **names;
int count;
int i;
account_policy_names_list(talloc_tos(), &names, &count);
fprintf(stderr, "No account policy by that name!\n");
if (count !=0) {
fprintf(stderr, "Account policy names are:\n");
for (i = 0; i < count ; i++) {
d_fprintf(stderr, "%s\n", names[i]);
}
}
TALLOC_FREE(names);
exit(1);
}
if (!pdb_get_account_policy(field, &value)) {
fprintf(stderr, "valid account policy, but unable to fetch value!\n");
if (!account_policy_value_set)
exit(1);
}
printf("account policy \"%s\" description: %s\n", account_policy, account_policy_get_desc(field));
if (account_policy_value_set) {
printf("account policy \"%s\" value was: %u\n", account_policy, value);
if (!pdb_set_account_policy(field, account_policy_value)) {
fprintf(stderr, "valid account policy, but unable to set value!\n");
exit(1);
}
printf("account policy \"%s\" value is now: %lu\n", account_policy, account_policy_value);
exit(0);
} else {
printf("account policy \"%s\" value is: %u\n", account_policy, value);
exit(0);
}
}
if (reset_account_policies) {
if (reinit_account_policies()) {
exit(1);
}
exit(0);
}
/* import and export operations */
if (((checkparms & BIT_IMPORT) ||
(checkparms & BIT_EXPORT)) &&
!(checkparms & ~(BIT_IMPORT +BIT_EXPORT +BIT_USER))) {
if (backend_in) {
status = make_pdb_method_name(&bin, backend_in);
} else {
status = make_pdb_method_name(&bin, backend);
}
if (!NT_STATUS_IS_OK(status)) {
fprintf(stderr, "Unable to initialize %s.\n",
backend_in ? backend_in : backend);
return 1;
}
if (backend_out) {
status = make_pdb_method_name(&bout, backend_out);
} else {
status = make_pdb_method_name(&bout, backend);
}
if (!NT_STATUS_IS_OK(status)) {
fprintf(stderr, "Unable to initialize %s.\n",
backend_out ? backend_out : backend);
return 1;
}
if (transfer_account_policies) {
if (!(checkparms & BIT_USER)) {
return export_account_policies(bin, bout);
}
} else if (transfer_groups) {
if (!(checkparms & BIT_USER)) {
return export_groups(bin, bout);
}
} else {
return export_database(bin, bout,
(checkparms & BIT_USER) ? user_name : NULL);
}
}
/* if BIT_USER is defined but nothing else then threat it as -l -u for compatibility */
/* fake up BIT_LIST if only BIT_USER is defined */
if ((checkparms & BIT_USER) && !(checkparms & ~BIT_USER)) {
checkparms += BIT_LIST;
}
/* modify flag is optional to maintain backwards compatibility */
/* fake up BIT_MODIFY if BIT_USER and at least one of MASK_USER_GOOD is defined */
if (!((checkparms & ~MASK_USER_GOOD) & ~BIT_USER) && (checkparms & MASK_USER_GOOD)) {
checkparms += BIT_MODIFY;
}
/* list users operations */
if (checkparms & BIT_LIST) {
if (!(checkparms & ~BIT_LIST)) {
return print_users_list(verbose, spstyle);
}
if (!(checkparms & ~(BIT_USER + BIT_LIST))) {
return print_user_info(user_name, verbose, spstyle);
}
}
/* mask out users options */
checkparms &= ~MASK_USER_GOOD;
/* if bad password count is reset, we must be modifying */
if (checkparms & BIT_BADPWRESET) {
checkparms |= BIT_MODIFY;
checkparms &= ~BIT_BADPWRESET;
}
/* if logon hours is reset, must modify */
if (checkparms & BIT_LOGONHOURS) {
checkparms |= BIT_MODIFY;
checkparms &= ~BIT_LOGONHOURS;
}
/* account operation */
if ((checkparms & BIT_CREATE) || (checkparms & BIT_MODIFY) || (checkparms & BIT_DELETE)) {
/* check use of -u option */
if (!(checkparms & BIT_USER)) {
fprintf (stderr, "Username not specified! (use -u option)\n");
return -1;
}
/* account creation operations */
if (!(checkparms & ~(BIT_CREATE + BIT_USER + BIT_MACHINE))) {
if (checkparms & BIT_MACHINE) {
return new_machine(user_name, machine_sid);
} else {
return new_user(user_name, full_name,
home_dir, home_drive,
logon_script, profile_path,
user_sid, pw_from_stdin);
}
}
/* account deletion operations */
if (!(checkparms & ~(BIT_DELETE + BIT_USER + BIT_MACHINE))) {
if (checkparms & BIT_MACHINE) {
return delete_machine_entry(user_name);
} else {
return delete_user_entry(user_name);
}
}
/* account modification operations */
if (!(checkparms & ~(BIT_MODIFY + BIT_USER + BIT_MACHINE))) {
if (checkparms & BIT_MACHINE) {
return set_machine_info(user_name,
account_control,
machine_sid);
} else {
return set_user_info(user_name, full_name,
home_dir, acct_desc,
home_drive, logon_script,
profile_path, account_control,
user_sid, user_domain,
badpw_reset, hours_reset,
kickoff_time);
}
}
}
if (setparms >= 0x20) {
fprintf (stderr, "Incompatible or insufficient options on command line!\n");
}
poptPrintHelp(pc, stderr, 0);
TALLOC_FREE(frame);
return 1;
}
/*
* Do some module- and library-wide intializations
*/
static void
SMBC_module_init(void * punused)
{
bool conf_loaded = False;
char *home = NULL;
TALLOC_CTX *frame = talloc_stackframe();
load_case_tables();
setup_logging("libsmbclient", True);
/* Here we would open the smb.conf file if needed ... */
lp_set_in_client(True);
home = getenv("HOME");
if (home) {
char *conf = NULL;
if (asprintf(&conf, "%s/.smb/smb.conf", home) > 0) {
if (lp_load(conf, True, False, False, True)) {
conf_loaded = True;
} else {
DEBUG(5, ("Could not load config file: %s\n",
conf));
}
SAFE_FREE(conf);
}
}
if (!conf_loaded) {
/*
* Well, if that failed, try the get_dyn_CONFIGFILE
* Which points to the standard locn, and if that
* fails, silently ignore it and use the internal
* defaults ...
*/
if (!lp_load(get_dyn_CONFIGFILE(), True, False, False, False)) {
DEBUG(5, ("Could not load config file: %s\n",
get_dyn_CONFIGFILE()));
} else if (home) {
char *conf;
/*
* We loaded the global config file. Now lets
* load user-specific modifications to the
* global config.
*/
if (asprintf(&conf,
"%s/.smb/smb.conf.append",
home) > 0) {
if (!lp_load(conf, True, False, False, False)) {
DEBUG(10,
("Could not append config file: "
"%s\n",
conf));
}
SAFE_FREE(conf);
}
}
}
load_interfaces(); /* Load the list of interfaces ... */
reopen_logs(); /* Get logging working ... */
/*
* Block SIGPIPE (from lib/util_sock.c: write())
* It is not needed and should not stop execution
*/
BlockSignals(True, SIGPIPE);
/* Create the mutex we'll use to protect initialized_ctx_count */
if (SMB_THREAD_CREATE_MUTEX("initialized_ctx_count_mutex",
initialized_ctx_count_mutex) != 0) {
smb_panic("SMBC_module_init: "
"failed to create 'initialized_ctx_count' mutex");
}
TALLOC_FREE(frame);
}
/****************************************************************************
main program
****************************************************************************/
int main(int argc, const char *argv[])
{
int opt;
unsigned int lookup_type = 0x0;
fstring lookup;
static bool find_master=False;
static bool lookup_by_ip = False;
poptContext pc = NULL;
TALLOC_CTX *frame = talloc_stackframe();
int rc = 0;
struct poptOption long_options[] = {
POPT_AUTOHELP
{ "broadcast", 'B', POPT_ARG_STRING, NULL, 'B', "Specify address to use for broadcasts", "BROADCAST-ADDRESS" },
{ "flags", 'f', POPT_ARG_NONE, NULL, 'f', "List the NMB flags returned" },
{ "unicast", 'U', POPT_ARG_STRING, NULL, 'U', "Specify address to use for unicast" },
{ "master-browser", 'M', POPT_ARG_NONE, NULL, 'M', "Search for a master browser" },
{ "recursion", 'R', POPT_ARG_NONE, NULL, 'R', "Set recursion desired in package" },
{ "status", 'S', POPT_ARG_NONE, NULL, 'S', "Lookup node status as well" },
{ "translate", 'T', POPT_ARG_NONE, NULL, 'T', "Translate IP addresses into names" },
{ "root-port", 'r', POPT_ARG_NONE, NULL, 'r', "Use root port 137 (Win95 only replies to this)" },
{ "lookup-by-ip", 'A', POPT_ARG_NONE, NULL, 'A', "Do a node status on <name> as an IP Address" },
POPT_COMMON_SAMBA
POPT_COMMON_CONNECTION
{ 0, 0, 0, 0 }
};
*lookup = 0;
load_case_tables();
setup_logging(argv[0], DEBUG_STDOUT);
pc = poptGetContext("nmblookup", argc, argv,
long_options, POPT_CONTEXT_KEEP_FIRST);
poptSetOtherOptionHelp(pc, "<NODE> ...");
while ((opt = poptGetNextOpt(pc)) != -1) {
switch (opt) {
case 'f':
give_flags = true;
break;
case 'M':
find_master = true;
break;
case 'R':
recursion_desired = true;
break;
case 'S':
find_status = true;
break;
case 'r':
RootPort = true;
break;
case 'A':
lookup_by_ip = true;
break;
case 'B':
if (interpret_string_addr(&bcast_addr,
poptGetOptArg(pc),
NI_NUMERICHOST)) {
got_bcast = True;
use_bcast = True;
}
break;
case 'U':
if (interpret_string_addr(&bcast_addr,
poptGetOptArg(pc),
0)) {
got_bcast = True;
use_bcast = False;
}
break;
case 'T':
translate_addresses = !translate_addresses;
break;
}
}
poptGetArg(pc); /* Remove argv[0] */
if(!poptPeekArg(pc)) {
poptPrintUsage(pc, stderr, 0);
rc = 1;
goto out;
}
if (!lp_load_global(get_dyn_CONFIGFILE())) {
fprintf(stderr, "Can't load %s - run testparm to debug it\n",
get_dyn_CONFIGFILE());
}
load_interfaces();
if (!open_sockets()) {
rc = 1;
goto out;
}
while(poptPeekArg(pc)) {
char *p;
struct in_addr ip;
fstrcpy(lookup,poptGetArg(pc));
if(lookup_by_ip) {
struct sockaddr_storage ss;
ip = interpret_addr2(lookup);
in_addr_to_sockaddr_storage(&ss, ip);
fstrcpy(lookup,"*");
if (!do_node_status(lookup, lookup_type, &ss)) {
rc = 1;
}
continue;
}
if (find_master) {
if (*lookup == '-') {
fstrcpy(lookup,"\01\02__MSBROWSE__\02");
lookup_type = 1;
} else {
lookup_type = 0x1d;
}
}
p = strchr_m(lookup,'#');
if (p) {
*p = '\0';
sscanf(++p,"%x",&lookup_type);
}
if (!query_one(lookup, lookup_type)) {
rc = 1;
d_printf( "name_query failed to find name %s", lookup );
if( 0 != lookup_type ) {
d_printf( "#%02x", lookup_type );
}
d_printf( "\n" );
}
}
out:
poptFreeContext(pc);
TALLOC_FREE(frame);
return rc;
}
static NTSTATUS auth3_generate_session_info_pac(struct auth4_context *auth_ctx,
TALLOC_CTX *mem_ctx,
struct smb_krb5_context *smb_krb5_context,
DATA_BLOB *pac_blob,
const char *princ_name,
const struct tsocket_address *remote_address,
uint32_t session_info_flags,
struct auth_session_info **session_info)
{
TALLOC_CTX *tmp_ctx;
struct PAC_LOGON_INFO *logon_info = NULL;
struct netr_SamInfo3 *info3_copy = NULL;
bool is_mapped;
bool is_guest;
char *ntuser;
char *ntdomain;
char *username;
char *rhost;
struct passwd *pw;
NTSTATUS status;
int rc;
tmp_ctx = talloc_new(mem_ctx);
if (!tmp_ctx) {
return NT_STATUS_NO_MEMORY;
}
if (pac_blob) {
#ifdef HAVE_KRB5
status = kerberos_pac_logon_info(tmp_ctx, *pac_blob, NULL, NULL,
NULL, NULL, 0, &logon_info);
#else
status = NT_STATUS_ACCESS_DENIED;
#endif
if (!NT_STATUS_IS_OK(status)) {
goto done;
}
}
rc = get_remote_hostname(remote_address,
&rhost,
tmp_ctx);
if (rc < 0) {
status = NT_STATUS_NO_MEMORY;
goto done;
}
if (strequal(rhost, "UNKNOWN")) {
rhost = tsocket_address_inet_addr_string(remote_address,
tmp_ctx);
if (rhost == NULL) {
status = NT_STATUS_NO_MEMORY;
goto done;
}
}
status = get_user_from_kerberos_info(tmp_ctx, rhost,
princ_name, logon_info,
&is_mapped, &is_guest,
&ntuser, &ntdomain,
&username, &pw);
if (!NT_STATUS_IS_OK(status)) {
DEBUG(1, ("Failed to map kerberos principal to system user "
"(%s)\n", nt_errstr(status)));
status = NT_STATUS_ACCESS_DENIED;
goto done;
}
/* save the PAC data if we have it */
if (logon_info) {
status = create_info3_from_pac_logon_info(tmp_ctx,
logon_info,
&info3_copy);
if (!NT_STATUS_IS_OK(status)) {
goto done;
}
netsamlogon_cache_store(ntuser, info3_copy);
}
/* setup the string used by %U */
sub_set_smb_name(username);
/* reload services so that the new %U is taken into account */
lp_load_with_shares(get_dyn_CONFIGFILE());
status = make_session_info_krb5(mem_ctx,
ntuser, ntdomain, username, pw,
info3_copy, is_guest, is_mapped, NULL /* No session key for now, caller will sort it out */,
session_info);
if (!NT_STATUS_IS_OK(status)) {
DEBUG(1, ("Failed to map kerberos pac to server info (%s)\n",
nt_errstr(status)));
status = NT_STATUS_ACCESS_DENIED;
goto done;
}
DEBUG(5, (__location__ "OK: user: %s domain: %s client: %s\n",
ntuser, ntdomain, rhost));
status = NT_STATUS_OK;
done:
TALLOC_FREE(tmp_ctx);
return status;
}
/****************************************************************************
main program
****************************************************************************/
int main(int argc, const char **argv)
{
int opt,i;
char *p;
int rc = 0;
int argc_new = 0;
const char ** argv_new;
poptContext pc;
TALLOC_CTX *frame = talloc_stackframe();
struct net_context *c = talloc_zero(frame, struct net_context);
struct poptOption long_options[] = {
{"help", 'h', POPT_ARG_NONE, 0, 'h'},
{"workgroup", 'w', POPT_ARG_STRING, &c->opt_target_workgroup},
{"user", 'U', POPT_ARG_STRING, &c->opt_user_name, 'U'},
{"ipaddress", 'I', POPT_ARG_STRING, 0,'I'},
{"port", 'p', POPT_ARG_INT, &c->opt_port},
{"myname", 'n', POPT_ARG_STRING, &c->opt_requester_name},
{"server", 'S', POPT_ARG_STRING, &c->opt_host},
{"encrypt", 'e', POPT_ARG_NONE, NULL, 'e', "Encrypt SMB transport (UNIX extended servers only)" },
{"container", 'c', POPT_ARG_STRING, &c->opt_container},
{"comment", 'C', POPT_ARG_STRING, &c->opt_comment},
{"maxusers", 'M', POPT_ARG_INT, &c->opt_maxusers},
{"flags", 'F', POPT_ARG_INT, &c->opt_flags},
{"long", 'l', POPT_ARG_NONE, &c->opt_long_list_entries},
{"reboot", 'r', POPT_ARG_NONE, &c->opt_reboot},
{"force", 'f', POPT_ARG_NONE, &c->opt_force},
{"stdin", 'i', POPT_ARG_NONE, &c->opt_stdin},
{"timeout", 't', POPT_ARG_INT, &c->opt_timeout},
{"request-timeout",0,POPT_ARG_INT, &c->opt_request_timeout},
{"machine-pass",'P', POPT_ARG_NONE, &c->opt_machine_pass},
{"kerberos", 'k', POPT_ARG_NONE, &c->opt_kerberos},
{"myworkgroup", 'W', POPT_ARG_STRING, &c->opt_workgroup},
{"verbose", 'v', POPT_ARG_NONE, &c->opt_verbose},
{"test", 'T', POPT_ARG_NONE, &c->opt_testmode},
/* Options for 'net groupmap set' */
{"local", 'L', POPT_ARG_NONE, &c->opt_localgroup},
{"domain", 'D', POPT_ARG_NONE, &c->opt_domaingroup},
{"ntname", 'N', POPT_ARG_STRING, &c->opt_newntname},
{"rid", 'R', POPT_ARG_INT, &c->opt_rid},
/* Options for 'net rpc share migrate' */
{"acls", 0, POPT_ARG_NONE, &c->opt_acls},
{"attrs", 0, POPT_ARG_NONE, &c->opt_attrs},
{"timestamps", 0, POPT_ARG_NONE, &c->opt_timestamps},
{"exclude", 'X', POPT_ARG_STRING, &c->opt_exclude},
{"destination", 0, POPT_ARG_STRING, &c->opt_destination},
{"tallocreport", 0, POPT_ARG_NONE, &c->do_talloc_report},
/* Options for 'net rpc vampire (keytab)' */
{"force-full-repl", 0, POPT_ARG_NONE, &c->opt_force_full_repl},
{"single-obj-repl", 0, POPT_ARG_NONE, &c->opt_single_obj_repl},
{"clean-old-entries", 0, POPT_ARG_NONE, &c->opt_clean_old_entries},
POPT_COMMON_SAMBA
{ 0, 0, 0, 0}
};
zero_sockaddr(&c->opt_dest_ip);
load_case_tables();
/* set default debug level to 0 regardless of what smb.conf sets */
DEBUGLEVEL_CLASS[DBGC_ALL] = 0;
dbf = x_stderr;
c->private_data = net_func;
pc = poptGetContext(NULL, argc, (const char **) argv, long_options,
POPT_CONTEXT_KEEP_FIRST);
while((opt = poptGetNextOpt(pc)) != -1) {
switch (opt) {
case 'h':
c->display_usage = true;
break;
case 'e':
c->smb_encrypt = true;
break;
case 'I':
if (!interpret_string_addr(&c->opt_dest_ip,
poptGetOptArg(pc), 0)) {
d_fprintf(stderr, "\nInvalid ip address specified\n");
} else {
c->opt_have_ip = true;
}
break;
case 'U':
c->opt_user_specified = true;
c->opt_user_name = SMB_STRDUP(c->opt_user_name);
p = strchr(c->opt_user_name,'%');
if (p) {
*p = 0;
c->opt_password = p+1;
}
break;
default:
d_fprintf(stderr, "\nInvalid option %s: %s\n",
poptBadOption(pc, 0), poptStrerror(opt));
net_help(c, argc, argv);
exit(1);
}
}
/*
* Don't load debug level from smb.conf. It should be
* set by cmdline arg or remain default (0)
*/
AllowDebugChange = false;
lp_load(get_dyn_CONFIGFILE(), true, false, false, true);
argv_new = (const char **)poptGetArgs(pc);
argc_new = argc;
for (i=0; i<argc; i++) {
if (argv_new[i] == NULL) {
argc_new = i;
break;
}
}
if (c->do_talloc_report) {
talloc_enable_leak_report();
}
if (c->opt_requester_name) {
set_global_myname(c->opt_requester_name);
}
if (!c->opt_user_name && getenv("LOGNAME")) {
c->opt_user_name = getenv("LOGNAME");
}
if (!c->opt_workgroup) {
c->opt_workgroup = smb_xstrdup(lp_workgroup());
}
if (!c->opt_target_workgroup) {
c->opt_target_workgroup = smb_xstrdup(lp_workgroup());
}
if (!init_names())
exit(1);
load_interfaces();
/* this makes sure that when we do things like call scripts,
that it won't assert becouse we are not root */
sec_init();
if (c->opt_machine_pass) {
/* it is very useful to be able to make ads queries as the
machine account for testing purposes and for domain leave */
net_use_krb_machine_account(c);
}
if (!c->opt_password) {
c->opt_password = getenv("PASSWD");
}
rc = net_run_function(c, argc_new-1, argv_new+1, "net", net_func);
DEBUG(2,("return code = %d\n", rc));
libnetapi_free(c->netapi_ctx);
poptFreeContext(pc);
TALLOC_FREE(frame);
return rc;
}
int main(int argc, const char *argv[])
{
static bool is_daemon;
static bool opt_interactive;
static bool Fork = true;
static bool no_process_group;
static bool log_stdout;
poptContext pc;
char *p_lmhosts = NULL;
int opt;
enum {
OPT_DAEMON = 1000,
OPT_INTERACTIVE,
OPT_FORK,
OPT_NO_PROCESS_GROUP,
OPT_LOG_STDOUT
};
struct poptOption long_options[] = {
POPT_AUTOHELP
{"daemon", 'D', POPT_ARG_NONE, NULL, OPT_DAEMON, "Become a daemon(default)" },
{"interactive", 'i', POPT_ARG_NONE, NULL, OPT_INTERACTIVE, "Run interactive (not a daemon)" },
{"foreground", 'F', POPT_ARG_NONE, NULL, OPT_FORK, "Run daemon in foreground (for daemontools & etc)" },
{"no-process-group", 0, POPT_ARG_NONE, NULL, OPT_NO_PROCESS_GROUP, "Don't create a new process group" },
{"log-stdout", 'S', POPT_ARG_NONE, NULL, OPT_LOG_STDOUT, "Log to stdout" },
{"hosts", 'H', POPT_ARG_STRING, &p_lmhosts, 0, "Load a netbios hosts file"},
{"port", 'p', POPT_ARG_INT, &global_nmb_port, 0, "Listen on the specified port" },
POPT_COMMON_SAMBA
{ NULL }
};
TALLOC_CTX *frame;
NTSTATUS status;
/*
* Do this before any other talloc operation
*/
talloc_enable_null_tracking();
frame = talloc_stackframe();
setup_logging(argv[0], DEBUG_DEFAULT_STDOUT);
load_case_tables();
global_nmb_port = NMB_PORT;
pc = poptGetContext("nmbd", argc, argv, long_options, 0);
while ((opt = poptGetNextOpt(pc)) != -1) {
switch (opt) {
case OPT_DAEMON:
is_daemon = true;
break;
case OPT_INTERACTIVE:
opt_interactive = true;
break;
case OPT_FORK:
Fork = false;
break;
case OPT_NO_PROCESS_GROUP:
no_process_group = true;
break;
case OPT_LOG_STDOUT:
log_stdout = true;
break;
default:
d_fprintf(stderr, "\nInvalid option %s: %s\n\n",
poptBadOption(pc, 0), poptStrerror(opt));
poptPrintUsage(pc, stderr, 0);
exit(1);
}
};
poptFreeContext(pc);
global_in_nmbd = true;
StartupTime = time(NULL);
sys_srandom(time(NULL) ^ sys_getpid());
if (!override_logfile) {
char *lfile = NULL;
if (asprintf(&lfile, "%s/log.nmbd", get_dyn_LOGFILEBASE()) < 0) {
exit(1);
}
lp_set_logfile(lfile);
SAFE_FREE(lfile);
}
fault_setup();
dump_core_setup("nmbd", lp_logfile());
/* POSIX demands that signals are inherited. If the invoking process has
* these signals masked, we will have problems, as we won't receive them. */
BlockSignals(False, SIGHUP);
BlockSignals(False, SIGUSR1);
BlockSignals(False, SIGTERM);
#if defined(SIGFPE)
/* we are never interested in SIGFPE */
BlockSignals(True,SIGFPE);
#endif
/* We no longer use USR2... */
#if defined(SIGUSR2)
BlockSignals(True, SIGUSR2);
#endif
if ( opt_interactive ) {
Fork = False;
log_stdout = True;
}
if ( log_stdout && Fork ) {
DEBUG(0,("ERROR: Can't log to stdout (-S) unless daemon is in foreground (-F) or interactive (-i)\n"));
exit(1);
}
if (log_stdout) {
setup_logging(argv[0], DEBUG_STDOUT);
} else {
setup_logging( argv[0], DEBUG_FILE);
}
reopen_logs();
DEBUG(0,("nmbd version %s started.\n", samba_version_string()));
DEBUGADD(0,("%s\n", COPYRIGHT_STARTUP_MESSAGE));
if (!lp_load_initial_only(get_dyn_CONFIGFILE())) {
DEBUG(0, ("error opening config file '%s'\n", get_dyn_CONFIGFILE()));
exit(1);
}
if (nmbd_messaging_context() == NULL) {
return 1;
}
if ( !reload_nmbd_services(False) )
return(-1);
if(!init_names())
return -1;
reload_nmbd_services( True );
if (strequal(lp_workgroup(),"*")) {
DEBUG(0,("ERROR: a workgroup name of * is no longer supported\n"));
exit(1);
}
set_samba_nb_type();
if (!is_daemon && !is_a_socket(0)) {
DEBUG(0,("standard input is not a socket, assuming -D option\n"));
is_daemon = True;
}
if (is_daemon && !opt_interactive) {
DEBUG( 2, ( "Becoming a daemon.\n" ) );
become_daemon(Fork, no_process_group, log_stdout);
}
#if HAVE_SETPGID
/*
* If we're interactive we want to set our own process group for
* signal management.
*/
if (opt_interactive && !no_process_group)
setpgid( (pid_t)0, (pid_t)0 );
#endif
if (nmbd_messaging_context() == NULL) {
return 1;
}
#ifndef SYNC_DNS
/* Setup the async dns. We do it here so it doesn't have all the other
stuff initialised and thus chewing memory and sockets */
if(lp_we_are_a_wins_server() && lp_dns_proxy()) {
start_async_dns();
}
#endif
if (!directory_exist(lp_lockdir())) {
mkdir(lp_lockdir(), 0755);
}
pidfile_create("nmbd");
status = reinit_after_fork(nmbd_messaging_context(),
nmbd_event_context(),
procid_self(), false);
if (!NT_STATUS_IS_OK(status)) {
DEBUG(0,("reinit_after_fork() failed\n"));
exit(1);
}
if (!nmbd_setup_sig_term_handler())
exit(1);
if (!nmbd_setup_sig_hup_handler())
exit(1);
/* get broadcast messages */
if (!serverid_register(procid_self(),
FLAG_MSG_GENERAL |
FLAG_MSG_NMBD |
FLAG_MSG_DBWRAP)) {
DEBUG(1, ("Could not register myself in serverid.tdb\n"));
exit(1);
}
messaging_register(nmbd_messaging_context(), NULL,
MSG_FORCE_ELECTION, nmbd_message_election);
#if 0
/* Until winsrepl is done. */
messaging_register(nmbd_messaging_context(), NULL,
MSG_WINS_NEW_ENTRY, nmbd_wins_new_entry);
#endif
messaging_register(nmbd_messaging_context(), NULL,
MSG_SHUTDOWN, nmbd_terminate);
messaging_register(nmbd_messaging_context(), NULL,
MSG_SMB_CONF_UPDATED, msg_reload_nmbd_services);
messaging_register(nmbd_messaging_context(), NULL,
MSG_SEND_PACKET, msg_nmbd_send_packet);
TimeInit();
DEBUG( 3, ( "Opening sockets %d\n", global_nmb_port ) );
if ( !open_sockets( is_daemon, global_nmb_port ) ) {
kill_async_dns_child();
return 1;
}
/* Determine all the IP addresses we have. */
load_interfaces();
/* Create an nmbd subnet record for each of the above. */
if( False == create_subnets() ) {
DEBUG(0,("ERROR: Failed when creating subnet lists. Exiting.\n"));
kill_async_dns_child();
exit(1);
}
/* Load in any static local names. */
if (p_lmhosts) {
set_dyn_LMHOSTSFILE(p_lmhosts);
}
load_lmhosts_file(get_dyn_LMHOSTSFILE());
DEBUG(3,("Loaded hosts file %s\n", get_dyn_LMHOSTSFILE()));
/* If we are acting as a WINS server, initialise data structures. */
if( !initialise_wins() ) {
DEBUG( 0, ( "nmbd: Failed when initialising WINS server.\n" ) );
kill_async_dns_child();
exit(1);
}
/*
* Register nmbd primary workgroup and nmbd names on all
* the broadcast subnets, and on the WINS server (if specified).
* Also initiate the startup of our primary workgroup (start
* elections if we are setup as being able to be a local
* master browser.
*/
if( False == register_my_workgroup_and_names() ) {
DEBUG(0,("ERROR: Failed when creating my my workgroup. Exiting.\n"));
kill_async_dns_child();
exit(1);
}
if (!initialize_nmbd_proxy_logon()) {
DEBUG(0,("ERROR: Failed setup nmbd_proxy_logon.\n"));
kill_async_dns_child();
exit(1);
}
if (!nmbd_init_packet_server()) {
kill_async_dns_child();
exit(1);
}
TALLOC_FREE(frame);
process();
kill_async_dns_child();
return(0);
}
int main(int argc, const char **argv)
{
poptContext pc;
int opt;
struct tevent_context *evt_ctx;
struct messaging_context *msg_ctx;
static struct poptOption long_options[] = {
/* POPT_AUTOHELP */
{ NULL, '\0', POPT_ARG_INCLUDE_TABLE, help_options,
0, "Help options:", NULL },
{ "timeout", 't', POPT_ARG_INT, &timeout, 't',
"Set timeout value in seconds", "TIMEOUT" },
POPT_COMMON_SAMBA
POPT_TABLEEND
};
TALLOC_CTX *frame = talloc_stackframe();
int ret = 0;
load_case_tables();
setup_logging(argv[0], DEBUG_STDOUT);
/* Parse command line arguments using popt */
pc = poptGetContext(
"smbcontrol", argc, (const char **)argv, long_options, 0);
poptSetOtherOptionHelp(pc, "[OPTION...] <destination> <message-type> "
"<parameters>");
if (argc == 1)
usage(pc);
while ((opt = poptGetNextOpt(pc)) != -1) {
switch(opt) {
case 't': /* --timeout */
break;
default:
fprintf(stderr, "Invalid option\n");
poptPrintHelp(pc, stderr, 0);
break;
}
}
/* We should now have the remaining command line arguments in
argv. The argc parameter should have been decremented to the
correct value in the above switch statement. */
argv = (const char **)poptGetArgs(pc);
argc = 0;
if (argv != NULL) {
while (argv[argc] != NULL) {
argc++;
}
}
if (argc <= 1)
usage(pc);
lp_load_global(get_dyn_CONFIGFILE());
/* Need to invert sense of return code -- samba
* routines mostly return True==1 for success, but
* shell needs 0. */
if (!(evt_ctx = tevent_context_init(NULL)) ||
!(msg_ctx = messaging_init(NULL, evt_ctx))) {
fprintf(stderr, "could not init messaging context\n");
TALLOC_FREE(frame);
exit(1);
}
ret = !do_command(evt_ctx, msg_ctx, argc, argv);
TALLOC_FREE(frame);
return ret;
}
int main(int argc, const char **argv)
{
struct tevent_context *evt_ctx;
struct messaging_context *msg_ctx;
struct db_context *db;
uint16_t count;
const char *dbname;
const char *opname;
dbwrap_op op;
const char *keyname = "";
const char *keytype = "int32";
dbwrap_type type;
const char *valuestr = "0";
TALLOC_CTX *mem_ctx = talloc_stackframe();
int ret = 1;
struct poptOption popt_options[] = {
POPT_AUTOHELP
POPT_COMMON_SAMBA
POPT_TABLEEND
};
int opt;
const char **extra_argv;
int extra_argc = 0;
poptContext pc;
load_case_tables();
lp_set_cmdline("log level", "0");
setup_logging(argv[0], DEBUG_STDERR);
pc = poptGetContext(argv[0], argc, argv, popt_options, POPT_CONTEXT_KEEP_FIRST);
while ((opt = poptGetNextOpt(pc)) != -1) {
switch (opt) {
default:
fprintf(stderr, "Invalid option %s: %s\n",
poptBadOption(pc, 0), poptStrerror(opt));
goto done;
}
}
/* setup the remaining options for the main program to use */
extra_argv = poptGetArgs(pc);
if (extra_argv) {
extra_argv++;
while (extra_argv[extra_argc]) extra_argc++;
}
lp_load_global(get_dyn_CONFIGFILE());
if ((extra_argc < 2) || (extra_argc > 5)) {
d_fprintf(stderr,
"USAGE: %s <database> <op> [<key> [<type> [<value>]]]\n"
" ops: fetch, store, delete, erase, listkeys\n"
" types: int32, uint32, string, hex\n",
argv[0]);
goto done;
}
dbname = extra_argv[0];
opname = extra_argv[1];
if (strcmp(opname, "store") == 0) {
if (extra_argc != 5) {
d_fprintf(stderr, "ERROR: operation 'store' requires "
"value argument\n");
goto done;
}
valuestr = extra_argv[4];
keytype = extra_argv[3];
keyname = extra_argv[2];
op = OP_STORE;
} else if (strcmp(opname, "fetch") == 0) {
if (extra_argc != 4) {
d_fprintf(stderr, "ERROR: operation 'fetch' requires "
"type but not value argument\n");
goto done;
}
op = OP_FETCH;
keytype = extra_argv[3];
keyname = extra_argv[2];
} else if (strcmp(opname, "delete") == 0) {
if (extra_argc != 3) {
d_fprintf(stderr, "ERROR: operation 'delete' does "
"not allow type nor value argument\n");
goto done;
}
keyname = extra_argv[2];
op = OP_DELETE;
} else if (strcmp(opname, "erase") == 0) {
if (extra_argc != 2) {
d_fprintf(stderr, "ERROR: operation 'erase' does "
"not take a key argument\n");
goto done;
}
op = OP_ERASE;
} else if (strcmp(opname, "listkeys") == 0) {
if (extra_argc != 2) {
d_fprintf(stderr, "ERROR: operation 'listkeys' does "
"not take a key argument\n");
goto done;
}
op = OP_LISTKEYS;
} else {
d_fprintf(stderr,
"ERROR: invalid op '%s' specified\n"
" supported ops: fetch, store, delete\n",
opname);
goto done;
}
if (strcmp(keytype, "int32") == 0) {
type = TYPE_INT32;
} else if (strcmp(keytype, "uint32") == 0) {
type = TYPE_UINT32;
} else if (strcmp(keytype, "string") == 0) {
type = TYPE_STRING;
} else if (strcmp(keytype, "hex") == 0) {
type = TYPE_HEX;
} else {
d_fprintf(stderr, "ERROR: invalid type '%s' specified.\n"
" supported types: int32, uint32, "
"string, hex\n",
keytype);
goto done;
}
evt_ctx = tevent_context_init(mem_ctx);
if (evt_ctx == NULL) {
d_fprintf(stderr, "ERROR: could not init event context\n");
goto done;
}
msg_ctx = messaging_init(mem_ctx, evt_ctx);
if (msg_ctx == NULL) {
d_fprintf(stderr, "ERROR: could not init messaging context\n");
goto done;
}
db = db_open(mem_ctx, dbname, 0, TDB_DEFAULT, O_RDWR | O_CREAT, 0644);
if (db == NULL) {
d_fprintf(stderr, "ERROR: could not open dbname\n");
goto done;
}
for (count = 0; dispatch_table[count].cmd != NULL; count++) {
if ((op == dispatch_table[count].op) &&
(type == dispatch_table[count].type))
{
ret = dispatch_table[count].cmd(db, keyname, valuestr);
break;
}
}
done:
TALLOC_FREE(mem_ctx);
return ret;
}
int main(int argc,const char *argv[])
{
/* shall I run as a daemon */
bool is_daemon = false;
bool interactive = false;
bool Fork = true;
bool no_process_group = false;
bool log_stdout = false;
char *ports = NULL;
char *profile_level = NULL;
int opt;
poptContext pc;
bool print_build_options = False;
enum {
OPT_DAEMON = 1000,
OPT_INTERACTIVE,
OPT_FORK,
OPT_NO_PROCESS_GROUP,
OPT_LOG_STDOUT
};
struct poptOption long_options[] = {
POPT_AUTOHELP
{"daemon", 'D', POPT_ARG_NONE, NULL, OPT_DAEMON, "Become a daemon (default)" },
{"interactive", 'i', POPT_ARG_NONE, NULL, OPT_INTERACTIVE, "Run interactive (not a daemon)"},
{"foreground", 'F', POPT_ARG_NONE, NULL, OPT_FORK, "Run daemon in foreground (for daemontools, etc.)" },
{"no-process-group", '\0', POPT_ARG_NONE, NULL, OPT_NO_PROCESS_GROUP, "Don't create a new process group" },
{"log-stdout", 'S', POPT_ARG_NONE, NULL, OPT_LOG_STDOUT, "Log to stdout" },
{"build-options", 'b', POPT_ARG_NONE, NULL, 'b', "Print build options" },
{"port", 'p', POPT_ARG_STRING, &ports, 0, "Listen on the specified ports"},
{"profiling-level", 'P', POPT_ARG_STRING, &profile_level, 0, "Set profiling level","PROFILE_LEVEL"},
POPT_COMMON_SAMBA
POPT_COMMON_DYNCONFIG
POPT_TABLEEND
};
struct smbd_parent_context *parent = NULL;
TALLOC_CTX *frame;
NTSTATUS status;
uint64_t unique_id;
struct tevent_context *ev_ctx;
struct messaging_context *msg_ctx;
/*
* Do this before any other talloc operation
*/
talloc_enable_null_tracking();
frame = talloc_stackframe();
setup_logging(argv[0], DEBUG_DEFAULT_STDOUT);
load_case_tables();
smbd_init_globals();
TimeInit();
#ifdef HAVE_SET_AUTH_PARAMETERS
set_auth_parameters(argc,argv);
#endif
pc = poptGetContext("smbd", argc, argv, long_options, 0);
while((opt = poptGetNextOpt(pc)) != -1) {
switch (opt) {
case OPT_DAEMON:
is_daemon = true;
break;
case OPT_INTERACTIVE:
interactive = true;
break;
case OPT_FORK:
Fork = false;
break;
case OPT_NO_PROCESS_GROUP:
no_process_group = true;
break;
case OPT_LOG_STDOUT:
log_stdout = true;
break;
case 'b':
print_build_options = True;
break;
default:
d_fprintf(stderr, "\nInvalid option %s: %s\n\n",
poptBadOption(pc, 0), poptStrerror(opt));
poptPrintUsage(pc, stderr, 0);
exit(1);
}
}
poptFreeContext(pc);
if (interactive) {
Fork = False;
log_stdout = True;
}
if (log_stdout) {
setup_logging(argv[0], DEBUG_STDOUT);
} else {
setup_logging(argv[0], DEBUG_FILE);
}
if (print_build_options) {
build_options(True); /* Display output to screen as well as debug */
exit(0);
}
#ifdef HAVE_SETLUID
/* needed for SecureWare on SCO */
setluid(0);
#endif
set_remote_machine_name("smbd", False);
if (interactive && (DEBUGLEVEL >= 9)) {
talloc_enable_leak_report();
}
if (log_stdout && Fork) {
DEBUG(0,("ERROR: Can't log to stdout (-S) unless daemon is in foreground (-F) or interactive (-i)\n"));
exit(1);
}
/* we want to re-seed early to prevent time delays causing
client problems at a later date. (tridge) */
generate_random_buffer(NULL, 0);
/* get initial effective uid and gid */
sec_init();
/* make absolutely sure we run as root - to handle cases where people
are crazy enough to have it setuid */
gain_root_privilege();
gain_root_group_privilege();
fault_setup();
dump_core_setup("smbd", lp_logfile());
/* we are never interested in SIGPIPE */
BlockSignals(True,SIGPIPE);
#if defined(SIGFPE)
/* we are never interested in SIGFPE */
BlockSignals(True,SIGFPE);
#endif
#if defined(SIGUSR2)
/* We are no longer interested in USR2 */
BlockSignals(True,SIGUSR2);
#endif
/* POSIX demands that signals are inherited. If the invoking process has
* these signals masked, we will have problems, as we won't recieve them. */
BlockSignals(False, SIGHUP);
BlockSignals(False, SIGUSR1);
BlockSignals(False, SIGTERM);
/* Ensure we leave no zombies until we
* correctly set up child handling below. */
CatchChild();
/* we want total control over the permissions on created files,
so set our umask to 0 */
umask(0);
reopen_logs();
DEBUG(0,("smbd version %s started.\n", samba_version_string()));
DEBUGADD(0,("%s\n", COPYRIGHT_STARTUP_MESSAGE));
DEBUG(2,("uid=%d gid=%d euid=%d egid=%d\n",
(int)getuid(),(int)getgid(),(int)geteuid(),(int)getegid()));
/* Output the build options to the debug log */
build_options(False);
if (sizeof(uint16) < 2 || sizeof(uint32) < 4) {
DEBUG(0,("ERROR: Samba is not configured correctly for the word size on your machine\n"));
exit(1);
}
if (!lp_load_initial_only(get_dyn_CONFIGFILE())) {
DEBUG(0, ("error opening config file '%s'\n", get_dyn_CONFIGFILE()));
exit(1);
}
/* Init the security context and global current_user */
init_sec_ctx();
/*
* Initialize the event context. The event context needs to be
* initialized before the messaging context, cause the messaging
* context holds an event context.
* FIXME: This should be s3_tevent_context_init()
*/
ev_ctx = server_event_context();
if (ev_ctx == NULL) {
exit(1);
}
/*
* Init the messaging context
* FIXME: This should only call messaging_init()
*/
msg_ctx = server_messaging_context();
if (msg_ctx == NULL) {
exit(1);
}
/*
* Reloading of the printers will not work here as we don't have a
* server info and rpc services set up. It will be called later.
*/
if (!reload_services(NULL, -1, False)) {
exit(1);
}
/* ...NOTE... Log files are working from this point! */
DEBUG(3,("loaded services\n"));
init_structs();
#ifdef WITH_PROFILE
if (!profile_setup(msg_ctx, False)) {
DEBUG(0,("ERROR: failed to setup profiling\n"));
return -1;
}
if (profile_level != NULL) {
int pl = atoi(profile_level);
struct server_id src;
DEBUG(1, ("setting profiling level: %s\n",profile_level));
src.pid = getpid();
set_profile_level(pl, src);
}
#endif
if (!is_daemon && !is_a_socket(0)) {
if (!interactive)
DEBUG(0,("standard input is not a socket, assuming -D option\n"));
/*
* Setting is_daemon here prevents us from eventually calling
* the open_sockets_inetd()
*/
is_daemon = True;
}
if (is_daemon && !interactive) {
DEBUG( 3, ( "Becoming a daemon.\n" ) );
become_daemon(Fork, no_process_group, log_stdout);
}
generate_random_buffer((uint8_t *)&unique_id, sizeof(unique_id));
set_my_unique_id(unique_id);
#if HAVE_SETPGID
/*
* If we're interactive we want to set our own process group for
* signal management.
*/
if (interactive && !no_process_group)
setpgid( (pid_t)0, (pid_t)0);
#endif
if (!directory_exist(lp_lockdir()))
mkdir(lp_lockdir(), 0755);
if (is_daemon)
pidfile_create("smbd");
status = reinit_after_fork(msg_ctx,
ev_ctx,
procid_self(), false);
if (!NT_STATUS_IS_OK(status)) {
DEBUG(0,("reinit_after_fork() failed\n"));
exit(1);
}
smbd_server_conn->msg_ctx = msg_ctx;
smbd_setup_sig_term_handler();
smbd_setup_sig_hup_handler(ev_ctx,
msg_ctx);
/* Setup all the TDB's - including CLEAR_IF_FIRST tdb's. */
if (smbd_memcache() == NULL) {
exit(1);
}
memcache_set_global(smbd_memcache());
/* Initialise the password backed before the global_sam_sid
to ensure that we fetch from ldap before we make a domain sid up */
if(!initialize_password_db(false, ev_ctx))
exit(1);
if (!secrets_init()) {
DEBUG(0, ("ERROR: smbd can not open secrets.tdb\n"));
exit(1);
}
if (lp_server_role() == ROLE_DOMAIN_BDC || lp_server_role() == ROLE_DOMAIN_PDC) {
struct loadparm_context *lp_ctx = loadparm_init_s3(NULL, loadparm_s3_context());
if (!open_schannel_session_store(NULL, lp_ctx)) {
DEBUG(0,("ERROR: Samba cannot open schannel store for secured NETLOGON operations.\n"));
exit(1);
}
TALLOC_FREE(lp_ctx);
}
if(!get_global_sam_sid()) {
DEBUG(0,("ERROR: Samba cannot create a SAM SID.\n"));
exit(1);
}
if (!sessionid_init()) {
exit(1);
}
if (!connections_init(True))
exit(1);
if (!locking_init())
exit(1);
if (!messaging_tdb_parent_init(ev_ctx)) {
exit(1);
}
if (!notify_internal_parent_init(ev_ctx)) {
exit(1);
}
if (!serverid_parent_init(ev_ctx)) {
exit(1);
}
if (!W_ERROR_IS_OK(registry_init_full()))
exit(1);
/* Open the share_info.tdb here, so we don't have to open
after the fork on every single connection. This is a small
performance improvment and reduces the total number of system
fds used. */
if (!share_info_db_init()) {
DEBUG(0,("ERROR: failed to load share info db.\n"));
exit(1);
}
status = init_system_info();
if (!NT_STATUS_IS_OK(status)) {
DEBUG(1, ("ERROR: failed to setup system user info: %s.\n",
nt_errstr(status)));
return -1;
}
if (!init_guest_info()) {
DEBUG(0,("ERROR: failed to setup guest info.\n"));
return -1;
}
if (!file_init(smbd_server_conn)) {
DEBUG(0, ("ERROR: file_init failed\n"));
return -1;
}
/* This MUST be done before start_epmd() because otherwise
* start_epmd() forks and races against dcesrv_ep_setup() to
* call directory_create_or_exist() */
if (!directory_create_or_exist(lp_ncalrpc_dir(), geteuid(), 0755)) {
DEBUG(0, ("Failed to create pipe directory %s - %s\n",
lp_ncalrpc_dir(), strerror(errno)));
return -1;
}
if (is_daemon && !interactive) {
if (rpc_epmapper_daemon() == RPC_DAEMON_FORK) {
start_epmd(ev_ctx, msg_ctx);
}
}
if (!dcesrv_ep_setup(ev_ctx, msg_ctx)) {
exit(1);
}
/* only start other daemons if we are running as a daemon
* -- bad things will happen if smbd is launched via inetd
* and we fork a copy of ourselves here */
if (is_daemon && !interactive) {
if (rpc_lsasd_daemon() == RPC_DAEMON_FORK) {
start_lsasd(ev_ctx, msg_ctx);
}
if (!_lp_disable_spoolss() &&
(rpc_spoolss_daemon() != RPC_DAEMON_DISABLED)) {
bool bgq = lp_parm_bool(-1, "smbd", "backgroundqueue", true);
if (!printing_subsystem_init(ev_ctx, msg_ctx, true, bgq)) {
exit(1);
}
}
} else if (!_lp_disable_spoolss() &&
(rpc_spoolss_daemon() != RPC_DAEMON_DISABLED)) {
if (!printing_subsystem_init(ev_ctx, msg_ctx, false, false)) {
exit(1);
}
}
if (!is_daemon) {
/* inetd mode */
TALLOC_FREE(frame);
/* Started from inetd. fd 0 is the socket. */
/* We will abort gracefully when the client or remote system
goes away */
smbd_server_conn->sock = dup(0);
/* close our standard file descriptors */
if (!debug_get_output_is_stdout()) {
close_low_fds(False); /* Don't close stderr */
}
#ifdef HAVE_ATEXIT
atexit(killkids);
#endif
/* Stop zombies */
smbd_setup_sig_chld_handler(ev_ctx);
smbd_process(ev_ctx, smbd_server_conn);
exit_server_cleanly(NULL);
return(0);
}
parent = talloc_zero(ev_ctx, struct smbd_parent_context);
if (!parent) {
exit_server("talloc(struct smbd_parent_context) failed");
}
parent->interactive = interactive;
if (!open_sockets_smbd(parent, ev_ctx, msg_ctx, ports))
exit_server("open_sockets_smbd() failed");
/* do a printer update now that all messaging has been set up,
* before we allow clients to start connecting */
printing_subsystem_update(ev_ctx, msg_ctx, false);
TALLOC_FREE(frame);
/* make sure we always have a valid stackframe */
frame = talloc_stackframe();
smbd_parent_loop(ev_ctx, parent);
exit_server_cleanly(NULL);
TALLOC_FREE(frame);
return(0);
}
int /* O - Exit status */
main(int argc, /* I - Number of command-line arguments */
char *argv[])
{ /* I - Command-line arguments */
int i; /* Looping var */
int copies; /* Number of copies */
int port; /* Port number */
char uri[1024], /* URI */
*sep, /* Pointer to separator */
*tmp, *tmp2, /* Temp pointers to do escaping */
*password; /* Password */
char *username, /* Username */
*server, /* Server name */
*printer;/* Printer name */
const char *workgroup; /* Workgroup */
FILE *fp; /* File to print */
int status = 1; /* Status of LPD job */
struct cli_state *cli; /* SMB interface */
char null_str[1];
int tries = 0;
bool need_auth = true;
const char *dev_uri;
TALLOC_CTX *frame = talloc_stackframe();
null_str[0] = '\0';
/*
* we expect the URI in argv[0]. Detect the case where it is in
* argv[1] and cope
*/
if (argc > 2 && strncmp(argv[0], "smb://", 6) &&
strncmp(argv[1], "smb://", 6) == 0) {
argv++;
argc--;
}
if (argc == 1) {
/*
* NEW! In CUPS 1.1 the backends are run with no arguments
* to list the available devices. These can be devices
* served by this backend or any other backends (i.e. you
* can have an SNMP backend that is only used to enumerate
* the available network printers... :)
*/
list_devices();
status = 0;
goto done;
}
if (argc < 6 || argc > 7) {
fprintf(stderr,
"Usage: %s [DEVICE_URI] job-id user title copies options [file]\n"
" The DEVICE_URI environment variable can also contain the\n"
" destination printer:\n"
"\n"
" smb://[username:password@][workgroup/]server[:port]/printer\n",
argv[0]);
goto done;
}
/*
* If we have 7 arguments, print the file named on the command-line.
* Otherwise, print data from stdin...
*/
if (argc == 6) {
/*
* Print from Copy stdin to a temporary file...
*/
fp = stdin;
copies = 1;
} else if ((fp = fopen(argv[6], "rb")) == NULL) {
perror("ERROR: Unable to open print file");
goto done;
} else {
copies = atoi(argv[4]);
}
/*
* Find the URI...
*/
dev_uri = getenv("DEVICE_URI");
if (dev_uri) {
strncpy(uri, dev_uri, sizeof(uri) - 1);
} else if (strncmp(argv[0], "smb://", 6) == 0) {
strncpy(uri, argv[0], sizeof(uri) - 1);
} else {
fputs("ERROR: No device URI found in DEVICE_URI environment variable or argv[0] !\n", stderr);
goto done;
}
uri[sizeof(uri) - 1] = '\0';
/*
* Extract the destination from the URI...
*/
if ((sep = strrchr_m(uri, '@')) != NULL) {
tmp = uri + 6;
*sep++ = '\0';
/* username is in tmp */
server = sep;
/*
* Extract password as needed...
*/
if ((tmp2 = strchr_m(tmp, ':')) != NULL) {
*tmp2++ = '\0';
password = uri_unescape_alloc(tmp2);
} else {
password = null_str;
}
username = uri_unescape_alloc(tmp);
} else {
if ((username = getenv("AUTH_USERNAME")) == NULL) {
username = null_str;
}
if ((password = getenv("AUTH_PASSWORD")) == NULL) {
password = null_str;
}
server = uri + 6;
}
tmp = server;
if ((sep = strchr_m(tmp, '/')) == NULL) {
fputs("ERROR: Bad URI - need printer name!\n", stderr);
goto done;
}
*sep++ = '\0';
tmp2 = sep;
if ((sep = strchr_m(tmp2, '/')) != NULL) {
/*
* Convert to smb://[username:password@]workgroup/server/printer...
*/
*sep++ = '\0';
workgroup = uri_unescape_alloc(tmp);
server = uri_unescape_alloc(tmp2);
printer = uri_unescape_alloc(sep);
} else {
workgroup = NULL;
server = uri_unescape_alloc(tmp);
printer = uri_unescape_alloc(tmp2);
}
if ((sep = strrchr_m(server, ':')) != NULL) {
*sep++ = '\0';
port = atoi(sep);
} else {
port = 0;
}
/*
* Setup the SAMBA server state...
*/
setup_logging("smbspool", DEBUG_STDOUT);
lp_set_in_client(True); /* Make sure that we tell lp_load we are */
load_case_tables();
if (!lp_load(get_dyn_CONFIGFILE(), True, False, False, True)) {
fprintf(stderr, "ERROR: Can't load %s - run testparm to debug it\n", get_dyn_CONFIGFILE());
goto done;
}
if (workgroup == NULL) {
workgroup = lp_workgroup();
}
load_interfaces();
do {
cli = smb_connect(workgroup, server, port, printer,
username, password, argv[2], &need_auth);
if (cli == NULL) {
if (need_auth) {
exit(2);
} else if (getenv("CLASS") == NULL) {
fprintf(stderr, "ERROR: Unable to connect to CIFS host, will retry in 60 seconds...\n");
sleep(60);
tries++;
} else {
fprintf(stderr, "ERROR: Unable to connect to CIFS host, trying next printer...\n");
goto done;
}
}
} while ((cli == NULL) && (tries < MAX_RETRY_CONNECT));
if (cli == NULL) {
fprintf(stderr, "ERROR: Unable to connect to CIFS host after (tried %d times)\n", tries);
goto done;
}
/*
* Now that we are connected to the server, ignore SIGTERM so that we
* can finish out any page data the driver sends (e.g. to eject the
* current page... Only ignore SIGTERM if we are printing data from
* stdin (otherwise you can't cancel raw jobs...)
*/
if (argc < 7) {
CatchSignal(SIGTERM, SIG_IGN);
}
/*
* Queue the job...
*/
for (i = 0; i < copies; i++) {
status = smb_print(cli, argv[3] /* title */ , fp);
if (status != 0) {
break;
}
}
cli_shutdown(cli);
/*
* Return the queue status...
*/
done:
TALLOC_FREE(frame);
return (status);
}
