本文整理汇总了C++中d_fprintf函数的典型用法代码示例。如果您正苦于以下问题:C++ d_fprintf函数的具体用法?C++ d_fprintf怎么用?C++ d_fprintf使用的例子?那么恭喜您, 这里精选的函数代码示例或许可以为您提供帮助。
在下文中一共展示了d_fprintf函数的15个代码示例,这些例子默认根据受欢迎程度排序。您可以为喜欢或者感觉有用的代码点赞,您的评价将有助于系统推荐出更棒的C++代码示例。
示例1: connect_to_service
/****************************************************************************
connect to \\server\service
****************************************************************************/
NTSTATUS connect_to_service(struct cli_state **c, struct in_addr *server_ip,
const char *server_name,
const char *service_name,
const char *service_type)
{
NTSTATUS nt_status;
if (!opt_password && !opt_machine_pass) {
char *pass = getpass("Password:");
if (pass) {
opt_password = SMB_STRDUP(pass);
}
}
nt_status = cli_full_connection(c, NULL, server_name,
server_ip, opt_port,
service_name, service_type,
opt_user_name, opt_workgroup,
opt_password, 0, Undefined, NULL);
if (NT_STATUS_IS_OK(nt_status)) {
return nt_status;
} else {
d_fprintf(stderr, "Could not connect to server %s\n", server_name);
/* Display a nicer message depending on the result */
if (NT_STATUS_V(nt_status) ==
NT_STATUS_V(NT_STATUS_LOGON_FAILURE))
d_fprintf(stderr, "The username or password was not correct.\n");
if (NT_STATUS_V(nt_status) ==
NT_STATUS_V(NT_STATUS_ACCOUNT_LOCKED_OUT))
d_fprintf(stderr, "The account was locked out.\n");
if (NT_STATUS_V(nt_status) ==
NT_STATUS_V(NT_STATUS_ACCOUNT_DISABLED))
d_fprintf(stderr, "The account was disabled.\n");
return nt_status;
}
}
示例2: net_registry_getvaluesraw
static int net_registry_getvaluesraw(struct net_context *c, int argc,
const char **argv)
{
WERROR werr;
int ret = -1;
struct registry_key *key = NULL;
TALLOC_CTX *ctx = talloc_stackframe();
uint32_t idx;
if (argc != 1 || c->display_usage) {
d_fprintf(stderr, "usage: net rpc registry getvaluesraw "
"<key>\n");
goto done;
}
werr = open_key(ctx, argv[0], REG_KEY_READ, &key);
if (!W_ERROR_IS_OK(werr)) {
d_fprintf(stderr, "open_key failed: %s\n", win_errstr(werr));
goto done;
}
idx = 0;
while (true) {
struct registry_value *val;
werr = reg_enumvalue(talloc_tos(), key, idx, NULL, &val);
if (W_ERROR_EQUAL(werr, WERR_NO_MORE_ITEMS)) {
ret = 0;
break;
}
if (!W_ERROR_IS_OK(werr)) {
break;
}
print_registry_value(val, true);
TALLOC_FREE(val);
idx += 1;
}
done:
TALLOC_FREE(ctx);
return ret;
}
示例3: net_vampire
int net_vampire(struct net_context *ctx, int argc, const char **argv)
{
NTSTATUS status;
struct libnet_context *libnetctx;
struct libnet_Vampire *r;
char *tmp, *targetdir = NULL;
const char *domain_name;
switch (argc) {
case 0: /* no args -> fail */
return net_vampire_usage(ctx, argc, argv);
case 1: /* only DOMAIN */
tmp = talloc_strdup(ctx, argv[0]);
break;
case 2: /* domain and target dir */
tmp = talloc_strdup(ctx, argv[0]);
targetdir = talloc_strdup(ctx, argv[1]);
break;
default: /* too many args -> fail */
return net_vampire_usage(ctx, argc, argv);
}
domain_name = tmp;
libnetctx = libnet_context_init(ctx->event_ctx, ctx->lp_ctx);
if (!libnetctx) {
return -1;
}
libnetctx->cred = ctx->credentials;
r = talloc(ctx, struct libnet_Vampire);
if (!r) {
return -1;
}
/* prepare parameters for the vampire */
r->in.netbios_name = lp_netbios_name(ctx->lp_ctx);
r->in.domain_name = domain_name;
r->in.targetdir = targetdir;
r->out.error_string = NULL;
/* do the domain vampire */
status = libnet_Vampire(libnetctx, r, r);
if (!NT_STATUS_IS_OK(status)) {
d_fprintf(stderr, "Vampire of domain failed: %s\n",
r->out.error_string ? r->out.error_string : nt_errstr(status));
talloc_free(r);
talloc_free(libnetctx);
return -1;
}
d_printf("Vampired domain %s (%s)\n", r->out.domain_name, dom_sid_string(ctx, r->out.domain_sid));
talloc_free(libnetctx);
return 0;
}
示例4: net_usershare_delete
static int net_usershare_delete(struct net_context *c, int argc, const char **argv)
{
char *us_path;
char *sharename;
if (argc != 1 || c->display_usage) {
return net_usershare_delete_usage(c, argc, argv);
}
if ((sharename = strlower_talloc(talloc_tos(), argv[0])) == NULL) {
d_fprintf(stderr, _("strlower_talloc failed\n"));
return -1;
}
if (!validate_net_name(sharename, INVALID_SHARENAME_CHARS, strlen(sharename))) {
d_fprintf(stderr, _("net usershare delete: share name %s contains "
"invalid characters (any of %s)\n"),
sharename, INVALID_SHARENAME_CHARS);
TALLOC_FREE(sharename);
return -1;
}
us_path = talloc_asprintf(talloc_tos(),
"%s/%s",
lp_usershare_path(talloc_tos()),
sharename);
if (!us_path) {
TALLOC_FREE(sharename);
return -1;
}
if (unlink(us_path) != 0) {
d_fprintf(stderr, _("net usershare delete: unable to remove usershare %s. "
"Error was %s\n"),
us_path, strerror(errno));
TALLOC_FREE(sharename);
return -1;
}
TALLOC_FREE(sharename);
return 0;
}
示例5: dbwrap_tool_store_hex
static int dbwrap_tool_store_hex(struct db_context *db,
const char *keyname,
const char *data)
{
NTSTATUS status;
DATA_BLOB datablob;
TDB_DATA tdbdata;
TALLOC_CTX *tmp_ctx = talloc_stackframe();
datablob = strhex_to_data_blob(tmp_ctx, data);
if(strlen(data) > 0 && datablob.length == 0) {
d_fprintf(stderr,
"ERROR: could not convert hex string to data blob\n"
" Not a valid hex string?\n");
talloc_free(tmp_ctx);
return -1;
}
tdbdata.dptr = (unsigned char *)datablob.data;
tdbdata.dsize = datablob.length;
if (dbwrap_is_persistent(db)) {
status = dbwrap_trans_store_bystring(db, keyname,
tdbdata,
TDB_REPLACE);
} else {
status = dbwrap_store_bystring(db, keyname,
tdbdata,
TDB_REPLACE);
}
if (!NT_STATUS_IS_OK(status)) {
d_fprintf(stderr,
"ERROR: could not store string key '%s': %s\n",
keyname, nt_errstr(status));
talloc_free(tmp_ctx);
return -1;
}
talloc_free(tmp_ctx);
return 0;
}
示例6: net_registry_enumerate
static int net_registry_enumerate(struct net_context *c, int argc,
const char **argv)
{
WERROR werr;
struct registry_key *key = NULL;
TALLOC_CTX *ctx = talloc_stackframe();
char *subkey_name;
NTTIME modtime;
uint32_t count;
char *valname = NULL;
struct registry_value *valvalue = NULL;
int ret = -1;
if (argc != 1 || c->display_usage) {
d_printf("Usage: net registry enumerate <path>\n");
d_printf("Example: net registry enumerate "
"'HKLM\\Software\\Samba'\n");
goto done;
}
werr = open_key(ctx, argv[0], REG_KEY_READ, &key);
if (!W_ERROR_IS_OK(werr)) {
d_fprintf(stderr, "open_key failed: %s\n", win_errstr(werr));
goto done;
}
for (count = 0;
werr = reg_enumkey(ctx, key, count, &subkey_name, &modtime),
W_ERROR_IS_OK(werr);
count++)
{
print_registry_key(subkey_name, &modtime);
}
if (!W_ERROR_EQUAL(WERR_NO_MORE_ITEMS, werr)) {
goto done;
}
for (count = 0;
werr = reg_enumvalue(ctx, key, count, &valname, &valvalue),
W_ERROR_IS_OK(werr);
count++)
{
print_registry_value_with_name(valname, valvalue);
}
if (!W_ERROR_EQUAL(WERR_NO_MORE_ITEMS, werr)) {
goto done;
}
ret = 0;
done:
TALLOC_FREE(ctx);
return ret;
}
示例7: net_getdomainsid
static int net_getdomainsid(int argc, const char **argv)
{
DOM_SID domain_sid;
fstring sid_str;
if(!initialize_password_db(False)) {
DEBUG(1, ("WARNING: Could not open passdb - domain sid may not reflect passdb\n"
"backend knowlege (such as the sid stored in LDAP)\n"));
}
/* first check to see if we can even access secrets, so we don't
panic when we can't. */
if (!secrets_init()) {
d_fprintf(stderr, "Unable to open secrets.tdb. "
"Can't fetch domainSID for name: %s\n",
get_global_sam_name());
return 1;
}
/* Generate one, if it doesn't exist */
get_global_sam_sid();
if (!secrets_fetch_domain_sid(global_myname(), &domain_sid)) {
d_fprintf(stderr, "Could not fetch local SID\n");
return 1;
}
sid_to_string(sid_str, &domain_sid);
d_printf("SID for domain %s is: %s\n", global_myname(), sid_str);
if (!secrets_fetch_domain_sid(opt_workgroup, &domain_sid)) {
d_fprintf(stderr, "Could not fetch domain SID\n");
return 1;
}
sid_to_string(sid_str, &domain_sid);
d_printf("SID for domain %s is: %s\n", opt_workgroup, sid_str);
return 0;
}
示例8: net_getlocalsid
/*
Retrieve our local SID or the SID for the specified name
*/
static int net_getlocalsid(struct net_context *c, int argc, const char **argv)
{
struct dom_sid sid;
const char *name;
fstring sid_str;
if (argc >= 1) {
name = argv[0];
}
else {
name = lp_netbios_name();
}
if(!initialize_password_db(false, NULL)) {
d_fprintf(stderr, _("WARNING: Could not open passdb\n"));
return 1;
}
/* first check to see if we can even access secrets, so we don't
panic when we can't. */
if (!secrets_init()) {
d_fprintf(stderr,
_("Unable to open secrets.tdb. Can't fetch domain "
"SID for name: %s\n"), name);
return 1;
}
/* Generate one, if it doesn't exist */
get_global_sam_sid();
if (!secrets_fetch_domain_sid(name, &sid)) {
DEBUG(0, ("Can't fetch domain SID for name: %s\n", name));
return 1;
}
sid_to_fstring(sid_str, &sid);
d_printf(_("SID for domain %s is: %s\n"), name, sid_str);
return 0;
}
示例9: net_registry_deletekey
static int net_registry_deletekey(struct net_context *c, int argc,
const char **argv)
{
WERROR werr;
char *subkeyname;
struct registry_key *hivekey = NULL;
TALLOC_CTX *ctx = talloc_stackframe();
int ret = -1;
if (argc != 1 || c->display_usage) {
d_printf("Usage: net registry deletekey <path>\n");
d_printf("Example: net registry deletekey "
"'HKLM\\Software\\Samba\\smbconf.127.0.0.1'\n");
goto done;
}
if (strlen(argv[0]) == 0) {
d_fprintf(stderr, "error: zero length key name given\n");
goto done;
}
werr = open_hive(ctx, argv[0], REG_KEY_WRITE, &hivekey, &subkeyname);
if (!W_ERROR_IS_OK(werr)) {
d_fprintf(stderr, "open_hive failed: %s\n", win_errstr(werr));
goto done;
}
werr = reg_deletekey(hivekey, subkeyname);
if (!W_ERROR_IS_OK(werr)) {
d_fprintf(stderr, "reg_deletekey failed: %s\n",
win_errstr(werr));
goto done;
}
ret = 0;
done:
TALLOC_FREE(ctx);
return ret;
}
示例10: net_changesecretpw
static int net_changesecretpw(struct net_context *c, int argc,
const char **argv)
{
char *trust_pw;
enum netr_SchannelType sec_channel_type = SEC_CHAN_WKSTA;
if(c->opt_force) {
if (c->opt_stdin) {
set_line_buffering(stdin);
set_line_buffering(stdout);
set_line_buffering(stderr);
}
trust_pw = get_pass(_("Enter machine password: "), c->opt_stdin);
if (trust_pw == NULL) {
d_fprintf(stderr,
_("Error in reading machine password\n"));
return 1;
}
if (!secrets_store_machine_password(trust_pw, lp_workgroup(), sec_channel_type)) {
d_fprintf(stderr,
_("Unable to write the machine account password in the secrets database"));
return 1;
}
else {
d_printf(_("Modified trust account password in secrets database\n"));
}
}
else {
d_printf(_("Machine account password change requires the -f flag.\n"
"Do NOT use this function unless you know what it does!\n"
"This function will change the ADS Domain member "
"machine account password in the secrets.tdb file!\n"));
}
return 0;
}
示例11: d_fprintf
struct cli_state *net_make_ipc_connection_ex( const char *domain, const char *server,
struct in_addr *ip, unsigned flags)
{
char *server_name = NULL;
struct in_addr server_ip;
struct cli_state *cli = NULL;
NTSTATUS nt_status;
if ( !server || !ip ) {
if (!net_find_server(domain, flags, &server_ip, &server_name)) {
d_fprintf(stderr, "Unable to find a suitable server\n");
return NULL;
}
} else {
server_name = SMB_STRDUP( server );
server_ip = *ip;
}
if (flags & NET_FLAGS_ANONYMOUS) {
nt_status = connect_to_ipc_anonymous(&cli, &server_ip, server_name);
} else {
nt_status = connect_to_ipc(&cli, &server_ip, server_name);
}
/* store the server in the affinity cache if it was a PDC */
if ( (flags & NET_FLAGS_PDC) && NT_STATUS_IS_OK(nt_status) )
saf_store( cli->server_domain, cli->desthost );
SAFE_FREE(server_name);
if (NT_STATUS_IS_OK(nt_status)) {
return cli;
} else {
d_fprintf(stderr, "Connection failed: %s\n",
nt_errstr(nt_status));
return NULL;
}
}
示例12: wbinfo_auth_krb5
static bool wbinfo_auth_krb5(char *username, const char *pass, const char *cctype, uint32 flags)
{
struct winbindd_request request;
struct winbindd_response response;
NSS_STATUS result;
/* Send off request */
ZERO_STRUCT(request);
ZERO_STRUCT(response);
fstrcpy(request.data.auth.user, username);
fstrcpy(request.data.auth.pass, pass);
request.flags = flags;
fstrcpy(request.data.auth.krb5_cc_type, cctype);
request.data.auth.uid = geteuid();
result = winbindd_request_response(WINBINDD_PAM_AUTH, &request, &response);
/* Display response */
d_printf("plaintext kerberos password authentication for [%s] %s (requesting cctype: %s)\n",
username, (result == NSS_STATUS_SUCCESS) ? "succeeded" : "failed", cctype);
if (response.data.auth.nt_status)
d_fprintf(stderr, "error code was %s (0x%x)\nerror messsage was: %s\n",
response.data.auth.nt_status_string,
response.data.auth.nt_status,
response.data.auth.error_string);
if (result == NSS_STATUS_SUCCESS) {
if (request.flags & WBFLAG_PAM_INFO3_TEXT) {
if (response.data.auth.info3.user_flgs & NETLOGON_CACHED_ACCOUNT) {
d_printf("user_flgs: NETLOGON_CACHED_ACCOUNT\n");
}
}
if (response.data.auth.krb5ccname[0] != '\0') {
d_printf("credentials were put in: %s\n", response.data.auth.krb5ccname);
} else {
d_printf("no credentials cached\n");
}
}
return result == NSS_STATUS_SUCCESS;
}
示例13: net_registry_getvalue_internal
static int net_registry_getvalue_internal(struct net_context *c, int argc,
const char **argv, bool raw)
{
WERROR werr;
int ret = -1;
struct registry_key *key = NULL;
struct registry_value *value = NULL;
TALLOC_CTX *ctx = talloc_stackframe();
if (argc != 2 || c->display_usage) {
d_fprintf(stderr, "%s\n%s",
_("Usage:"),
_("net registry getvalue <key> <valuename>\n"));
goto done;
}
werr = open_key(ctx, argv[0], REG_KEY_READ, &key);
if (!W_ERROR_IS_OK(werr)) {
d_fprintf(stderr, _("open_key failed: %s\n"), win_errstr(werr));
goto done;
}
werr = reg_queryvalue(ctx, key, argv[1], &value);
if (!W_ERROR_IS_OK(werr)) {
d_fprintf(stderr, _("reg_queryvalue failed: %s\n"),
win_errstr(werr));
goto done;
}
print_registry_value(value, raw);
ret = 0;
done:
TALLOC_FREE(ctx);
return ret;
}
示例14: winbind_separator_int
static char winbind_separator_int(bool strict)
{
struct winbindd_response response;
static bool got_sep;
static char sep;
if (got_sep)
return sep;
ZERO_STRUCT(response);
/* Send off request */
if (winbindd_request_response(WINBINDD_INFO, NULL, &response) !=
NSS_STATUS_SUCCESS) {
d_fprintf(stderr, "could not obtain winbind separator!\n");
if (strict) {
return 0;
}
/* HACK: (this module should not call lp_ funtions) */
return *lp_winbind_separator(cmdline_lp_ctx);
}
sep = response.data.info.winbind_separator;
got_sep = true;
if (!sep) {
d_fprintf(stderr, "winbind separator was NULL!\n");
if (strict) {
return 0;
}
/* HACK: (this module should not call lp_ funtions) */
sep = *lp_winbind_separator(cmdline_lp_ctx);
}
return sep;
}
示例15: net_g_lock_do
static int net_g_lock_do(struct net_context *c, int argc, const char **argv)
{
struct net_g_lock_do_state state;
const char *name, *cmd;
int timeout;
NTSTATUS status;
if (argc != 3) {
d_printf("Usage: net g_lock do <lockname> <timeout> "
"<command>\n");
return -1;
}
name = argv[0];
timeout = atoi(argv[1]);
cmd = argv[2];
state.cmd = cmd;
state.result = -1;
status = g_lock_do(name, G_LOCK_WRITE,
timeval_set(timeout / 1000, timeout % 1000),
net_g_lock_do_fn, &state);
if (!NT_STATUS_IS_OK(status)) {
d_fprintf(stderr, "ERROR: g_lock_do failed: %s\n",
nt_errstr(status));
goto done;
}
if (state.result == -1) {
d_fprintf(stderr, "ERROR: system() returned %s\n",
strerror(errno));
goto done;
}
d_fprintf(stderr, "command returned %d\n", state.result);
done:
return state.result;
}