This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
- the Free Software Foundation; either version 2 of the License, or
+ the Free Software Foundation; either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
- along with this program; if not, write to the Free Software
- Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#include "includes.h"
const char *servername)
{
ADS_STATUS status;
- char *srv_dn, **srv_cn, *s;
+ char *srv_dn, **srv_cn, *s = NULL;
const char *attrs[] = {"*", "nTSecurityDescriptor", NULL};
status = ads_find_machine_acct(ads, res, servername);
servername));
return status;
}
- srv_dn = ldap_get_dn(ads->ld, *res);
+ if (ads_count_replies(ads, *res) != 1) {
+ if (res) {
+ ads_msgfree(ads, *res);
+ *res = NULL;
+ }
+ return ADS_ERROR(LDAP_NO_SUCH_OBJECT);
+ }
+ srv_dn = ldap_get_dn(ads->ldap.ld, *res);
+ if (srv_dn == NULL) {
+ if (res) {
+ ads_msgfree(ads, *res);
+ *res = NULL;
+ }
+ return ADS_ERROR(LDAP_NO_MEMORY);
+ }
srv_cn = ldap_explode_dn(srv_dn, 1);
- ads_msgfree(ads, *res);
+ if (srv_cn == NULL) {
+ ldap_memfree(srv_dn);
+ if (res) {
+ ads_msgfree(ads, *res);
+ *res = NULL;
+ }
+ return ADS_ERROR(LDAP_INVALID_DN_SYNTAX);
+ }
+ if (res) {
+ ads_msgfree(ads, *res);
+ *res = NULL;
+ }
- asprintf(&s, "(cn=%s-%s)", srv_cn[0], printer);
+ if (asprintf(&s, "(cn=%s-%s)", srv_cn[0], printer) == -1) {
+ ldap_memfree(srv_dn);
+ return ADS_ERROR(LDAP_NO_MEMORY);
+ }
status = ads_search(ads, res, s, attrs);
ldap_memfree(srv_dn);
ldap_value_free(srv_cn);
- free(s);
+ SAFE_FREE(s);
return status;
}
/*
map a REG_SZ to an ldap mod
*/
-static BOOL map_sz(TALLOC_CTX *ctx, ADS_MODLIST *mods,
+static bool map_sz(TALLOC_CTX *ctx, ADS_MODLIST *mods,
const REGISTRY_VALUE *value)
{
char *str_value = NULL;
+ size_t converted_size;
ADS_STATUS status;
if (value->type != REG_SZ)
- return False;
+ return false;
if (value->size && *((smb_ucs2_t *) value->data_p)) {
- pull_ucs2_talloc(ctx, &str_value, (const smb_ucs2_t *) value->data_p);
+ if (!pull_ucs2_talloc(ctx, &str_value,
+ (const smb_ucs2_t *) value->data_p,
+ &converted_size))
+ {
+ return false;
+ }
status = ads_mod_str(ctx, mods, value->valuename, str_value);
return ADS_ERR_OK(status);
}
- return True;
+ return true;
}
/*
map a REG_DWORD to an ldap mod
*/
-static BOOL map_dword(TALLOC_CTX *ctx, ADS_MODLIST *mods,
+static bool map_dword(TALLOC_CTX *ctx, ADS_MODLIST *mods,
const REGISTRY_VALUE *value)
{
char *str_value = NULL;
/*
map a boolean REG_BINARY to an ldap mod
*/
-static BOOL map_bool(TALLOC_CTX *ctx, ADS_MODLIST *mods,
+static bool map_bool(TALLOC_CTX *ctx, ADS_MODLIST *mods,
const REGISTRY_VALUE *value)
{
char *str_value;
/*
map a REG_MULTI_SZ to an ldap mod
*/
-static BOOL map_multi_sz(TALLOC_CTX *ctx, ADS_MODLIST *mods,
+static bool map_multi_sz(TALLOC_CTX *ctx, ADS_MODLIST *mods,
const REGISTRY_VALUE *value)
{
char **str_values = NULL;
+ size_t converted_size;
smb_ucs2_t *cur_str = (smb_ucs2_t *) value->data_p;
uint32 size = 0, num_vals = 0, i=0;
ADS_STATUS status;
(num_vals + 1) * sizeof(char *));
cur_str = (smb_ucs2_t *) value->data_p;
- for (i=0; i < num_vals; i++)
+ for (i=0; i < num_vals; i++) {
cur_str += pull_ucs2_talloc(ctx, &str_values[i],
- cur_str);
+ cur_str, &converted_size) ?
+ converted_size : (size_t)-1;
+ }
status = ads_mod_strlist(ctx, mods, value->valuename,
(const char **) str_values);
struct valmap_to_ads {
const char *valname;
- BOOL (*fn)(TALLOC_CTX *, ADS_MODLIST *, const REGISTRY_VALUE *);
+ bool (*fn)(TALLOC_CTX *, ADS_MODLIST *, const REGISTRY_VALUE *);
};
/*
const char *printer)
{
WERROR result;
- char *printername, *servername;
- REGVAL_CTR *dsdriver_ctr, *dsspooler_ctr;
+ char *printername;
+ struct spoolss_PrinterEnumValues *info;
+ uint32_t count;
uint32 i;
- POLICY_HND pol;
+ struct policy_handle pol;
- asprintf(&servername, "\\\\%s", cli->cli->desthost);
- asprintf(&printername, "%s\\%s", servername, printer);
- if (!servername || !printername) {
+ if ((asprintf(&printername, "%s\\%s", cli->srv_name_slash, printer) == -1)) {
DEBUG(3, ("Insufficient memory\n"));
return WERR_NOMEM;
}
-
- result = rpccli_spoolss_open_printer_ex(cli, mem_ctx, printername,
- "", MAXIMUM_ALLOWED_ACCESS,
- servername, cli->cli->user_name, &pol);
+
+ result = rpccli_spoolss_openprinter_ex(cli, mem_ctx,
+ printername,
+ SEC_FLAG_MAXIMUM_ALLOWED,
+ &pol);
if (!W_ERROR_IS_OK(result)) {
DEBUG(3, ("Unable to open printer %s, error is %s.\n",
- printername, dos_errstr(result)));
+ printername, win_errstr(result)));
+ SAFE_FREE(printername);
return result;
}
-
- if ( !(dsdriver_ctr = TALLOC_ZERO_P( mem_ctx, REGVAL_CTR )) )
- return WERR_NOMEM;
- result = rpccli_spoolss_enumprinterdataex(cli, mem_ctx, &pol, SPOOL_DSDRIVER_KEY, dsdriver_ctr);
+ result = rpccli_spoolss_enumprinterdataex(cli, mem_ctx, &pol,
+ SPOOL_DSDRIVER_KEY,
+ 0,
+ &count,
+ &info);
if (!W_ERROR_IS_OK(result)) {
DEBUG(3, ("Unable to do enumdataex on %s, error is %s.\n",
- printername, dos_errstr(result)));
+ printername, win_errstr(result)));
} else {
- uint32 num_values = regval_ctr_numvals( dsdriver_ctr );
-
/* Have the data we need now, so start building */
- for (i=0; i < num_values; i++) {
- map_regval_to_ads(mem_ctx, mods, dsdriver_ctr->values[i]);
+ for (i=0; i < count; i++) {
+ REGISTRY_VALUE v;
+ DATA_BLOB blob;
+
+ result = push_spoolss_PrinterData(mem_ctx, &blob,
+ info[i].type,
+ info[i].data);
+ if (W_ERROR_IS_OK(result)) {
+ fstrcpy(v.valuename, info[i].value_name);
+ v.type = info[i].type;
+ v.data_p = blob.data;
+ v.size = blob.length;
+
+ map_regval_to_ads(mem_ctx, mods, &v);
+ }
}
}
-
- if ( !(dsspooler_ctr = TALLOC_ZERO_P( mem_ctx, REGVAL_CTR )) )
- return WERR_NOMEM;
-
- result = rpccli_spoolss_enumprinterdataex(cli, mem_ctx, &pol, SPOOL_DSSPOOLER_KEY, dsspooler_ctr);
+ result = rpccli_spoolss_enumprinterdataex(cli, mem_ctx, &pol,
+ SPOOL_DSSPOOLER_KEY,
+ 0,
+ &count,
+ &info);
if (!W_ERROR_IS_OK(result)) {
DEBUG(3, ("Unable to do enumdataex on %s, error is %s.\n",
- printername, dos_errstr(result)));
+ printername, win_errstr(result)));
} else {
- uint32 num_values = regval_ctr_numvals( dsspooler_ctr );
-
- for (i=0; i<num_values; i++) {
- map_regval_to_ads(mem_ctx, mods, dsspooler_ctr->values[i]);
+ for (i=0; i < count; i++) {
+ REGISTRY_VALUE v;
+ DATA_BLOB blob;
+
+ result = push_spoolss_PrinterData(mem_ctx, &blob,
+ info[i].type,
+ info[i].data);
+ if (W_ERROR_IS_OK(result)) {
+ fstrcpy(v.valuename, info[i].value_name);
+ v.type = info[i].type;
+ v.data_p = blob.data;
+ v.size = blob.length;
+
+ map_regval_to_ads(mem_ctx, mods, &v);
+ }
}
}
-
- ads_mod_str(mem_ctx, mods, SPOOL_REG_PRINTERNAME, printer);
- TALLOC_FREE( dsdriver_ctr );
- TALLOC_FREE( dsspooler_ctr );
+ ads_mod_str(mem_ctx, mods, SPOOL_REG_PRINTERNAME, printer);
- rpccli_spoolss_close_printer(cli, mem_ctx, &pol);
+ rpccli_spoolss_ClosePrinter(cli, mem_ctx, &pol, NULL);
+ SAFE_FREE(printername);
return result;
}
-BOOL get_local_printer_publishing_data(TALLOC_CTX *mem_ctx,
+bool get_local_printer_publishing_data(TALLOC_CTX *mem_ctx,
ADS_MODLIST *mods,
NT_PRINTER_DATA *data)
{
git.samba.org / samba.git / blobdiff