PyObject *obj = PyDict_GetItemString(info, "name");
char *form_name = PyString_AsString(obj);
- init_unistr2(&form.name, form_name);
+ init_unistr2(&form.name, form_name, strlen(form_name) + 1);
break;
}
default:
obj = PyDict_GetItemString(dict, "name");
name = PyString_AsString(obj);
- init_unistr2(&form->name, name);
+ init_unistr2(&form->name, name, strlen(name) + 1);
result = True;
info3 = driver_ctr.info_3;
filename = dos_basename( info3->driverpath );
- init_unistr2( &data, filename);
+ init_unistr2( &data, filename, strlen(filename)+1 );
regval_ctr_addvalue( val, "Driver", REG_SZ, (char*)data.buffer, data.uni_str_len*sizeof(uint16) );
filename = dos_basename( info3->configfile );
- init_unistr2( &data, filename);
+ init_unistr2( &data, filename, strlen(filename)+1 );
regval_ctr_addvalue( val, "Configuration File", REG_SZ, (char*)data.buffer, data.uni_str_len*sizeof(uint16) );
filename = dos_basename( info3->datafile );
- init_unistr2( &data, filename);
+ init_unistr2( &data, filename, strlen(filename)+1 );
regval_ctr_addvalue( val, "Data File", REG_SZ, (char*)data.buffer, data.uni_str_len*sizeof(uint16) );
filename = dos_basename( info3->helpfile );
- init_unistr2( &data, filename);
+ init_unistr2( &data, filename, strlen(filename)+1 );
regval_ctr_addvalue( val, "Help File", REG_SZ, (char*)data.buffer, data.uni_str_len*sizeof(uint16) );
- init_unistr2( &data, info3->defaultdatatype);
+ init_unistr2( &data, info3->defaultdatatype, strlen(info3->defaultdatatype)+1 );
regval_ctr_addvalue( val, "Data Type", REG_SZ, (char*)data.buffer, data.uni_str_len*sizeof(uint16) );
regval_ctr_addvalue( val, "Version", REG_DWORD, (char*)&info3->cversion, sizeof(info3->cversion) );
break;
buffer = buffer2;
- init_unistr2( &data, filename);
+ init_unistr2( &data, filename, length+1 );
memcpy( buffer+buffer_size, (char*)data.buffer, data.uni_str_len*sizeof(uint16) );
buffer_size += (length + 1)*sizeof(uint16);
regval_ctr_addvalue( val, "cjobs", REG_DWORD, (char*)&info2->cjobs, sizeof(info2->cjobs) );
regval_ctr_addvalue( val, "AveragePPM", REG_DWORD, (char*)&info2->averageppm, sizeof(info2->averageppm) );
- init_unistr2( &data, info2->printername);
+ init_unistr2( &data, info2->printername, strlen(info2->printername)+1 );
regval_ctr_addvalue( val, "Name", REG_SZ, (char*)data.buffer, data.uni_str_len*sizeof(uint16) );
- init_unistr2( &data, info2->location);
+ init_unistr2( &data, info2->location, strlen(info2->location)+1 );
regval_ctr_addvalue( val, "Location", REG_SZ, (char*)data.buffer, data.uni_str_len*sizeof(uint16) );
- init_unistr2( &data, info2->comment);
+ init_unistr2( &data, info2->comment, strlen(info2->comment)+1 );
regval_ctr_addvalue( val, "Comment", REG_SZ, (char*)data.buffer, data.uni_str_len*sizeof(uint16) );
- init_unistr2( &data, info2->parameters);
+ init_unistr2( &data, info2->parameters, strlen(info2->parameters)+1 );
regval_ctr_addvalue( val, "Parameters", REG_SZ, (char*)data.buffer, data.uni_str_len*sizeof(uint16) );
- init_unistr2( &data, info2->portname);
+ init_unistr2( &data, info2->portname, strlen(info2->portname)+1 );
regval_ctr_addvalue( val, "Port", REG_SZ, (char*)data.buffer, data.uni_str_len*sizeof(uint16) );
- init_unistr2( &data, info2->servername);
+ init_unistr2( &data, info2->servername, strlen(info2->servername)+1 );
regval_ctr_addvalue( val, "Server", REG_SZ, (char*)data.buffer, data.uni_str_len*sizeof(uint16) );
- init_unistr2( &data, info2->sharename);
+ init_unistr2( &data, info2->sharename, strlen(info2->sharename)+1 );
regval_ctr_addvalue( val, "Share", REG_SZ, (char*)data.buffer, data.uni_str_len*sizeof(uint16) );
- init_unistr2( &data, info2->drivername);
+ init_unistr2( &data, info2->drivername, strlen(info2->drivername)+1 );
regval_ctr_addvalue( val, "Driver", REG_SZ, (char*)data.buffer, data.uni_str_len*sizeof(uint16) );
- init_unistr2( &data, info2->sepfile);
+ init_unistr2( &data, info2->sepfile, strlen(info2->sepfile)+1 );
regval_ctr_addvalue( val, "Separator File", REG_SZ, (char*)data.buffer, data.uni_str_len*sizeof(uint16) );
- init_unistr2( &data, "winprint");
+ init_unistr2( &data, "winprint", strlen("winprint")+1 );
regval_ctr_addvalue( val, "Print Processor", REG_SZ, (char*)data.buffer, data.uni_str_len*sizeof(uint16) );
s = unistr2_tdup(mem_ctx, &r.ctr.share.info1[i].info_1_str.uni_netname);
if (s)
- init_unistr2(&info1->info_1_str.uni_netname, s);
+ init_unistr2(&info1->info_1_str.uni_netname, s, strlen(s) + 1);
s = unistr2_tdup(mem_ctx, &r.ctr.share.info1[i].info_1_str.uni_remark);
if (s)
- init_unistr2(&info1->info_1_str.uni_remark, s);
+ init_unistr2(&info1->info_1_str.uni_remark, s, strlen(s) + 1);
}
s = unistr2_tdup(mem_ctx, &r.ctr.share.info2[i].info_2_str.uni_netname);
if (s)
- init_unistr2(&info2->info_2_str.uni_netname, s);
+ init_unistr2(&info2->info_2_str.uni_netname, s, strlen(s) + 1);
s = unistr2_tdup(mem_ctx, &r.ctr.share.info2[i].info_2_str.uni_remark);
if (s)
- init_unistr2(&info2->info_2_str.uni_remark, s);
+ init_unistr2(&info2->info_2_str.uni_remark, s, strlen(s) + 1);
s = unistr2_tdup(mem_ctx, &r.ctr.share.info2[i].info_2_str.uni_path);
if (s)
- init_unistr2(&info2->info_2_str.uni_path, s);
+ init_unistr2(&info2->info_2_str.uni_path, s, strlen(s) + 1);
s = unistr2_tdup(mem_ctx, &r.ctr.share.info2[i].info_2_str.uni_passwd);
if (s)
- init_unistr2(&info2->info_2_str.uni_passwd, s);
+ init_unistr2(&info2->info_2_str.uni_passwd, s, strlen(s) + 1);
}
break;
}
s = unistr2_tdup(mem_ctx, &r.ctr.file.info3[i].info_3_str.uni_path_name);
if (s)
- init_unistr2(&info3->info_3_str.uni_path_name, s);
+ init_unistr2(&info3->info_3_str.uni_path_name, s, strlen(s) + 1);
s = unistr2_tdup(mem_ctx, &r.ctr.file.info3[i].info_3_str.uni_user_name);
if (s)
- init_unistr2(&info3->info_3_str.uni_user_name, s);
+ init_unistr2(&info3->info_3_str.uni_user_name, s, strlen(s) + 1);
}
char *servername, char *sharename)
{
DEBUG(5,("init_dfs_q_dfs_remove\n"));
- init_unistr2(&q_d->DfsEntryPath, entrypath);
- init_unistr2(&q_d->ServerName, servername);
- init_unistr2(&q_d->ShareName, sharename);
+ init_unistr2(&q_d->DfsEntryPath, entrypath, strlen(entrypath)+1);
+ init_unistr2(&q_d->ServerName, servername, strlen(servername)+1);
+ init_unistr2(&q_d->ShareName, sharename, strlen(sharename)+1);
q_d->ptr_ServerName = q_d->ptr_ShareName = 1;
return True;
}
{
DEBUG(5,("init_dfs_q_dfs_add\n"));
q_d->ptr_DfsEntryPath = q_d->ptr_ServerName = q_d->ptr_ShareName = 1;
- init_unistr2(&q_d->DfsEntryPath, entrypath);
- init_unistr2(&q_d->ServerName, servername);
- init_unistr2(&q_d->ShareName, sharename);
+ init_unistr2(&q_d->DfsEntryPath, entrypath, strlen(entrypath)+1);
+ init_unistr2(&q_d->ServerName, servername, strlen(servername)+1);
+ init_unistr2(&q_d->ShareName, sharename, strlen(sharename)+1);
if(comment != NULL) {
- init_unistr2(&q_d->Comment, comment);
+ init_unistr2(&q_d->Comment, comment, strlen(comment)+1);
q_d->ptr_Comment = 1;
} else {
q_d->ptr_Comment = 0;
uint32 info_level)
{
DEBUG(5,("init_dfs_q2_get_info\n"));
- init_unistr2(&q_d->uni_path, entrypath);
- init_unistr2(&q_d->uni_server, servername);
- init_unistr2(&q_d->uni_share, sharename);
+ init_unistr2(&q_d->uni_path, entrypath, strlen(entrypath)+1);
+ init_unistr2(&q_d->uni_server, servername, strlen(servername)+1);
+ init_unistr2(&q_d->uni_share, sharename, strlen(sharename)+1);
q_d->level = info_level;
q_d->ptr_server = q_d->ptr_share = 1;
return True;
trn->sid_name_use = sid_name_use;
init_uni_hdr(&trn->hdr_name, len_name);
- init_unistr2(uni_name, name);
+ init_unistr2(uni_name, name, len_name);
trn->domain_idx = idx;
}
r_q->des_access = desired_access;
- init_unistr2(&r_q->uni_server_name, server_name);
+ init_unistr2(&r_q->uni_server_name, server_name,
+ strlen(server_name) + 1);
init_lsa_obj_attr(&r_q->attr, attributes, qos);
}
len = strlen(names[i]);
init_uni_hdr(&q_l->hdr_name[i], len);
- init_unistr2(&q_l->uni_name[i], names[i]);
+ init_unistr2(&q_l->uni_name[i], names[i], len);
}
}
memcpy(&trn->pol, hnd, sizeof(trn->pol));
init_uni_hdr(&trn->hdr_name, len_name);
- init_unistr2(&trn->name, name);
+ init_unistr2(&trn->name, name, len_name);
trn->lang_id = lang_id;
trn->lang_id_sys = lang_id_sys;
}
len_name = 1;
init_uni_hdr(&trn->hdr_right, len_name);
- init_unistr2(&trn->uni2_right, name);
+ init_unistr2(&trn->uni2_right, name, len_name);
}
/*******************************************************************
if (buf != NULL) {
*ptr = 1;
- init_unistr2(str, buf);
+ init_unistr2(str, buf, strlen(buf)+1);
} else {
*ptr = 0;
- init_unistr2(str, "");
+ init_unistr2(str, "", 0);
}
}
}
/*******************************************************************
- Inits a UNISTR2 structure. This function used to deliberately
- over-allocate to a minimum of 256 bytes. That is rather silly, and
- just hides potential bugs. If you need to overallocate then don't use
- this function!
+ Inits a UNISTR2 structure.
********************************************************************/
-void init_unistr2(UNISTR2 *str, const char *buf)
+
+void init_unistr2(UNISTR2 *str, const char *buf, size_t len)
{
- size_t len;
+ ZERO_STRUCTP(str);
- if (!buf) {
- /* this is incorrect, but is needed to cope with some
- broken code that assumes this function will always
- return a valid initialised UNISTR2 */
- buf = "";
- }
+ /* set up string lengths. */
+ str->uni_max_len = (uint32)len;
+ str->undoc = 0;
+ str->uni_str_len = (uint32)len;
- len = push_ucs2_talloc(get_talloc_ctx() , &str->buffer, buf);
+ if (len < MAX_UNISTRLEN)
+ len = MAX_UNISTRLEN;
+ len *= sizeof(uint16);
- if (len == -1) {
- /* oops - we can't convert the string? */
- smb_panic("failed to convert string in init_unistr2");
+ str->buffer = (uint16 *)talloc_zero(get_talloc_ctx(), len);
+ if ((str->buffer == NULL) && (len > 0))
+ {
+ smb_panic("init_unistr2: malloc fail\n");
+ return;
}
- /* set up string lengths. Note that len is guaranteed to be a
- * multiple of 2 from push_ucs2 */
- str->uni_max_len = len/2;
- str->undoc = 0;
- str->uni_str_len = len/2;
+ /*
+ * don't move this test above ! The UNISTR2 must be initialized !!!
+ * jfm, 7/7/2001.
+ */
+ if (buf==NULL)
+ return;
+
+ rpcstr_push((char *)str->buffer, buf, len, STR_TERMINATE);
}
/**
if (logon_srv != NULL) {
log->undoc_buffer = 1;
- init_unistr2(&log->uni_logon_srv, logon_srv);
+ init_unistr2(&log->uni_logon_srv, logon_srv, strlen(logon_srv)+1);
} else {
log->undoc_buffer = 0;
}
if (comp_name != NULL) {
log->undoc_buffer2 = 1;
- init_unistr2(&log->uni_comp_name, comp_name);
+ init_unistr2(&log->uni_comp_name, comp_name, strlen(comp_name)+1);
} else {
log->undoc_buffer2 = 0;
}
log->undoc_buffer = 1;
- init_unistr2(&log->uni_logon_srv, logon_srv);
- init_unistr2(&log->uni_acct_name, acct_name);
+ init_unistr2(&log->uni_logon_srv, logon_srv, strlen(logon_srv)+1);
+ init_unistr2(&log->uni_acct_name, acct_name, strlen(acct_name)+1);
log->sec_chan = sec_chan;
- init_unistr2(&log->uni_comp_name, comp_name);
+ init_unistr2(&log->uni_comp_name, comp_name, strlen(comp_name)+1);
}
/*******************************************************************
static void init_netinfo_2(NETLOGON_INFO_2 *info, uint32 flags, uint32 pdc_status,
uint32 tc_status, const char *trusted_dc_name)
{
+ int len_dc_name = strlen(trusted_dc_name);
info->flags = flags;
info->pdc_status = pdc_status;
info->ptr_trusted_dc_name = 1;
info->tc_status = tc_status;
if (trusted_dc_name != NULL)
- init_unistr2(&info->uni_trusted_dc_name, trusted_dc_name);
+ init_unistr2(&info->uni_trusted_dc_name, trusted_dc_name, len_dc_name+1);
else
- init_unistr2(&info->uni_trusted_dc_name, "");
+ init_unistr2(&info->uni_trusted_dc_name, "", 1);
}
/*******************************************************************
q_l->query_level = query_level;
q_l->switch_value = 0x01;
- init_unistr2(&q_l->uni_server_name, srv_name);
+ init_unistr2(&q_l->uni_server_name, srv_name, strlen(srv_name) + 1);
}
/*******************************************************************
q_l->function_code = 0x01; /* ??? */
q_l->query_level = query_level;
- init_unistr2(&q_l->uni_server_name, srv_name);
+ init_unistr2(&q_l->uni_server_name, srv_name, strlen(srv_name) + 1);
}
/*******************************************************************
fstring domain_name;
fstrcpy(domain_name, dom_name);
strupper(domain_name);
- init_unistr2(&r_t->uni_trust_dom_name[i], domain_name);
+ init_unistr2(&r_t->uni_trust_dom_name[i], domain_name, strlen(domain_name)+1);
/* the use of UNISTR2 here is non-standard. */
r_t->uni_trust_dom_name[i].undoc = 0x1;
}
q_c->undoc_buffer = 1; /* don't know what this buffer is */
- init_unistr2(&q_c->uni_logon_srv, logon_srv );
- init_unistr2(&q_c->uni_logon_clnt, logon_clnt);
+ init_unistr2(&q_c->uni_logon_srv, logon_srv , strlen(logon_srv )+1);
+ init_unistr2(&q_c->uni_logon_clnt, logon_clnt, strlen(logon_clnt)+1);
memcpy(q_c->clnt_chal.data, clnt_chal->data, sizeof(clnt_chal->data));
init_owf_info(&id->lm_owf, lm_cypher);
init_owf_info(&id->nt_owf, nt_cypher);
- init_unistr2(&id->uni_domain_name, domain_name);
- init_unistr2(&id->uni_user_name, user_name);
- init_unistr2(&id->uni_wksta_name, wksta_name);
+ init_unistr2(&id->uni_domain_name, domain_name, len_domain_name);
+ init_unistr2(&id->uni_user_name, user_name, len_user_name);
+ init_unistr2(&id->uni_wksta_name, wksta_name, len_wksta_name);
}
/*******************************************************************
init_str_hdr(&id->hdr_nt_chal_resp, nt_chal_resp_len, nt_chal_resp_len, (nt_chal_resp != NULL) ? 1 : 0);
init_str_hdr(&id->hdr_lm_chal_resp, lm_chal_resp_len, lm_chal_resp_len, (lm_chal_resp != NULL) ? 1 : 0);
- init_unistr2(&id->uni_domain_name, domain_name);
- init_unistr2(&id->uni_user_name, user_name);
- init_unistr2(&id->uni_wksta_name, wksta_name);
+ init_unistr2(&id->uni_domain_name, domain_name, len_domain_name);
+ init_unistr2(&id->uni_user_name, user_name, len_user_name);
+ init_unistr2(&id->uni_wksta_name, wksta_name, len_wksta_name);
init_string2(&id->nt_chal_resp, (const char *)nt_chal_resp, nt_chal_resp_len, nt_chal_resp_len);
init_string2(&id->lm_chal_resp, (const char *)lm_chal_resp, lm_chal_resp_len, lm_chal_resp_len);
usr->num_other_sids = num_other_sids;
usr->buffer_other_sids = (num_other_sids != 0) ? 1 : 0;
- init_unistr2(&usr->uni_user_name, user_name);
- init_unistr2(&usr->uni_full_name, full_name);
- init_unistr2(&usr->uni_logon_script, logon_script);
- init_unistr2(&usr->uni_profile_path, profile_path);
- init_unistr2(&usr->uni_home_dir, home_dir);
- init_unistr2(&usr->uni_dir_drive, dir_drive);
+ init_unistr2(&usr->uni_user_name, user_name, len_user_name);
+ init_unistr2(&usr->uni_full_name, full_name, len_full_name);
+ init_unistr2(&usr->uni_logon_script, logon_script, len_logon_script);
+ init_unistr2(&usr->uni_profile_path, profile_path, len_profile_path);
+ init_unistr2(&usr->uni_home_dir, home_dir, len_home_dir);
+ init_unistr2(&usr->uni_dir_drive, dir_drive, len_dir_drive);
usr->num_groups2 = num_groups;
for (i = 0; i < num_groups; i++)
usr->gids[i] = gids[i];
- init_unistr2(&usr->uni_logon_srv, logon_srv);
- init_unistr2(&usr->uni_logon_dom, logon_dom);
+ init_unistr2(&usr->uni_logon_srv, logon_srv, len_logon_srv);
+ init_unistr2(&usr->uni_logon_dom, logon_dom, len_logon_dom);
init_dom_sid2(&usr->dom_sid, dom_sid);
/* "other" sids are set up above */
{
DEBUG(5, ("init_q_sam_sync\n"));
- init_unistr2(&q_s->uni_srv_name, srv_name);
- init_unistr2(&q_s->uni_cli_name, cli_name);
+ init_unistr2(&q_s->uni_srv_name, srv_name, strlen(srv_name) + 1);
+ init_unistr2(&q_s->uni_cli_name, cli_name, strlen(cli_name) + 1);
if (cli_creds)
memcpy(&q_s->cli_creds, cli_creds, sizeof(q_s->cli_creds));
{
DEBUG(5, ("init_net_q_sam_deltas\n"));
- init_unistr2(&q_s->uni_srv_name, srv_name);
- init_unistr2(&q_s->uni_cli_name, cli_name);
+ init_unistr2(&q_s->uni_srv_name, srv_name, strlen(srv_name) + 1);
+ init_unistr2(&q_s->uni_cli_name, cli_name, strlen(cli_name) + 1);
memcpy(&q_s->cli_creds, cli_creds, sizeof(q_s->cli_creds));
memset(&q_s->ret_creds, 0, sizeof(q_s->ret_creds));
memcpy(&q_c->pnt_pol, hnd, sizeof(q_c->pnt_pol));
init_uni_hdr(&q_c->hdr_name, len_name);
- init_unistr2(&q_c->uni_name, name);
+ init_unistr2(&q_c->uni_name, name, len_name);
init_uni_hdr(&q_c->hdr_class, len_class);
- init_unistr2(&q_c->uni_class, class);
+ init_unistr2(&q_c->uni_class, class, len_class);
q_c->reserved = 0x00000000;
memcpy(&q_c->sam_access, sam_access, sizeof(q_c->sam_access));
memcpy(&q_c->pnt_pol, hnd, sizeof(q_c->pnt_pol));
init_uni_hdr(&q_c->hdr_name, len_name);
- init_unistr2(&q_c->uni_name, name);
+ init_unistr2(&q_c->uni_name, name, len_name);
}
/*******************************************************************
memcpy(&q_c->pnt_pol, hnd, sizeof(q_c->pnt_pol));
init_uni_hdr(&q_c->hdr_name, len_name);
- init_unistr2(&q_c->uni_name, name);
+ init_unistr2(&q_c->uni_name, name, len_name);
}
/*******************************************************************
q_i->pol = *pol;
init_uni_hdr(&(q_i->hdr_type), len_type);
- init_unistr2(&(q_i->uni_type), val_name);
+ init_unistr2(&(q_i->uni_type), val_name, len_type);
q_i->ptr_reserved = 1;
q_i->ptr_buf = 1;
DEBUG(10,("init_reg_r_enum_val: Valuename => [%s]\n", val->valuename));
init_uni_hdr( &r_u->hdr_name, strlen(val->valuename)+1 );
- init_unistr2( &r_u->uni_name, val->valuename);
+ init_unistr2( &r_u->uni_name, val->valuename, strlen(val->valuename)+1 );
/* type */
memcpy(&q_i->pol, pol, sizeof(q_i->pol));
init_uni_hdr(&q_i->hdr_name, val_len);
- init_unistr2(&q_i->uni_name, val_name);
+ init_unistr2(&q_i->uni_name, val_name, val_len);
q_i->type = type;
q_i->buf_value = val;
memcpy(&r_q->pol, pol, sizeof(r_q->pol));
init_uni_hdr(&r_q->hdr_name, len_name);
- init_unistr2(&r_q->uni_name, key_name);
+ init_unistr2(&r_q->uni_name, key_name, len_name);
r_q->unknown_0 = 0x00000000;
r_q->access_desired = access_desired;
q_s->ptr_2 = 1;
init_uni_hdr(&(q_s->hdr_msg), msg_len);
- init_unistr2(&(q_s->uni_msg), msg);
+ init_unistr2(&(q_s->uni_msg), msg, msg_len);
q_s->timeout = timeout;
q_u->connect_pol = *pol;
init_uni_hdr(&q_u->hdr_domain, len_name);
- init_unistr2(&q_u->uni_domain, dom_name);
+ init_unistr2(&q_u->uni_domain, dom_name, len_name);
}
/*******************************************************************
init_uni_hdr(&u_5->hdr_server, len_server);
- init_unistr2(&u_5->uni_server, server);
+ init_unistr2(&u_5->uni_server, server, len_server);
}
/*******************************************************************
memset(u_2->padding, 0, sizeof(u_2->padding)); /* 12 bytes zeros */
- init_unistr2(&u_2->uni_domain, domain);
- init_unistr2(&u_2->uni_server, server);
+ init_unistr2(&u_2->uni_domain, domain, len_domain);
+ init_unistr2(&u_2->uni_server, server, len_server);
}
/*******************************************************************
ZERO_STRUCTP(&sam->str[i].uni_full_name);
ZERO_STRUCTP(&sam->str[i].uni_acct_desc);
- init_unistr2(&sam->str[i].uni_acct_name, pdb_get_username(pwd));
- init_unistr2(&sam->str[i].uni_full_name, pdb_get_fullname(pwd));
- init_unistr2(&sam->str[i].uni_acct_desc, pdb_get_acct_desc(pwd));
+ init_unistr2(&sam->str[i].uni_acct_name, pdb_get_username(pwd), len_sam_name);
+ init_unistr2(&sam->str[i].uni_full_name, pdb_get_fullname(pwd), len_sam_full);
+ init_unistr2(&sam->str[i].uni_acct_desc, pdb_get_acct_desc(pwd), len_sam_desc);
}
return NT_STATUS_OK;
ZERO_STRUCTP(&sam->str[i].uni_srv_name);
ZERO_STRUCTP(&sam->str[i].uni_srv_desc);
- init_unistr2(&sam->str[i].uni_srv_name, username);
- init_unistr2(&sam->str[i].uni_srv_desc, pdb_get_acct_desc(pwd));
+ init_unistr2(&sam->str[i].uni_srv_name, username, len_sam_name);
+ init_unistr2(&sam->str[i].uni_srv_desc, pdb_get_acct_desc(pwd), len_sam_desc);
}
return NT_STATUS_OK;
init_sam_entry3(&sam->sam[i], start_idx + i + 1, len_sam_name, len_sam_desc, grp->rid);
- init_unistr2(&sam->str[i].uni_grp_name, grp->name);
- init_unistr2(&sam->str[i].uni_grp_desc, grp->comment);
+ init_unistr2(&sam->str[i].uni_grp_name, grp->name, len_sam_name);
+ init_unistr2(&sam->str[i].uni_grp_desc, grp->comment, len_sam_desc);
}
return NT_STATUS_OK;
init_uni_hdr(&gr1->hdr_acct_desc, desc_len);
- init_unistr2(&gr1->uni_acct_name, acct_name);
- init_unistr2(&gr1->uni_acct_desc, acct_desc);
+ init_unistr2(&gr1->uni_acct_name, acct_name, acct_len);
+ init_unistr2(&gr1->uni_acct_desc, acct_desc, desc_len);
}
/*******************************************************************
DEBUG(5, ("init_samr_group_info4\n"));
init_uni_hdr(&gr4->hdr_acct_desc, acct_len);
- init_unistr2(&gr4->uni_acct_desc, acct_desc);
+ init_unistr2(&gr4->uni_acct_desc, acct_desc, acct_len);
}
/*******************************************************************
q_e->pol = *pol;
init_uni_hdr(&q_e->hdr_acct_desc, acct_len);
- init_unistr2(&q_e->uni_acct_desc, acct_desc);
+ init_unistr2(&q_e->uni_acct_desc, acct_desc, acct_len);
q_e->access_mask = access_mask;
}
DEBUG(5, ("init_samr_alias_info1\n"));
init_uni_hdr(&al1->hdr_acct_name, acct_len_name);
- init_unistr2(&al1->uni_acct_name, acct_name);
+ init_unistr2(&al1->uni_acct_name, acct_name, acct_len_name);
al1->num_member=num_member;
init_uni_hdr(&al1->hdr_acct_desc, acct_len_desc);
- init_unistr2(&al1->uni_acct_desc, acct_desc);
+ init_unistr2(&al1->uni_acct_desc, acct_desc, acct_len_desc);
}
/*******************************************************************
DEBUG(5, ("init_samr_alias_info3\n"));
init_uni_hdr(&al3->hdr_acct_desc, acct_len);
- init_unistr2(&al3->uni_acct_desc, acct_desc);
+ init_unistr2(&al3->uni_acct_desc, acct_desc, acct_len);
}
/*******************************************************************
q_u->dom_pol = *hnd;
init_uni_hdr(&q_u->hdr_acct_desc, acct_len);
- init_unistr2(&q_u->uni_acct_desc, acct_desc);
+ init_unistr2(&q_u->uni_acct_desc, acct_desc, acct_len);
q_u->access_mask = 0x001f000f;
}
for (i = 0; i < num_names; i++) {
int len_name = name[i] != NULL ? strlen(name[i]) : 0;
init_uni_hdr(&q_u->hdr_name[i], len_name); /* unicode header for user_name */
- init_unistr2(&q_u->uni_name[i], name[i]); /* unicode string for machine account */
+ init_unistr2(&q_u->uni_name[i], name[i], len_name); /* unicode string for machine account */
}
return NT_STATUS_OK;
q_u->domain_pol = *pol;
init_uni_hdr(&q_u->hdr_name, len_name);
- init_unistr2(&q_u->uni_name, name);
+ init_unistr2(&q_u->uni_name, name, len_name);
q_u->acb_info = acb_info;
q_u->access_mask = access_mask;
ZERO_STRUCT(usr->padding_7); /* 0 - padding 16 bytes */
usr->padding_8 = 0; /* 0 - padding 4 bytes */
- init_unistr2(&usr->uni_mach_acct, mach_acct); /* unicode string for machine account */
+ init_unistr2(&usr->uni_mach_acct, mach_acct, len_mach_acct); /* unicode string for machine account */
}
/*******************************************************************
memcpy(usr->pass, newpass, sizeof(usr->pass));
- init_unistr2(&usr->uni_user_name, user_name); /* NULL */
- init_unistr2(&usr->uni_full_name, full_name);
- init_unistr2(&usr->uni_home_dir, home_dir);
- init_unistr2(&usr->uni_dir_drive, dir_drive);
- init_unistr2(&usr->uni_logon_script, log_scr);
- init_unistr2(&usr->uni_profile_path, prof_path);
- init_unistr2(&usr->uni_acct_desc, desc);
- init_unistr2(&usr->uni_workstations, wkstas);
- init_unistr2(&usr->uni_unknown_str, unk_str);
- init_unistr2(&usr->uni_munged_dial, mung_dial);
+ init_unistr2(&usr->uni_user_name, user_name, len_user_name); /* NULL */
+ init_unistr2(&usr->uni_full_name, full_name, len_full_name);
+ init_unistr2(&usr->uni_home_dir, home_dir, len_home_dir);
+ init_unistr2(&usr->uni_dir_drive, dir_drive, len_dir_drive);
+ init_unistr2(&usr->uni_logon_script, log_scr, len_logon_script);
+ init_unistr2(&usr->uni_profile_path, prof_path, len_profile_path);
+ init_unistr2(&usr->uni_acct_desc, desc, len_description);
+ init_unistr2(&usr->uni_workstations, wkstas, len_workstations);
+ init_unistr2(&usr->uni_unknown_str, unk_str, len_unknown_str);
+ init_unistr2(&usr->uni_munged_dial, mung_dial, len_munged_dial);
usr->unknown_6 = unknown_6; /* 0x0000 04ec */
usr->padding4 = 0;
ZERO_STRUCT(usr->padding1);
ZERO_STRUCT(usr->padding2);
- init_unistr2(&usr->uni_user_name, user_name);
- init_unistr2(&usr->uni_full_name, full_name);
- init_unistr2(&usr->uni_home_dir, home_dir);
- init_unistr2(&usr->uni_dir_drive, dir_drive);
- init_unistr2(&usr->uni_logon_script, logon_script);
- init_unistr2(&usr->uni_profile_path, profile_path);
- init_unistr2(&usr->uni_acct_desc, description);
- init_unistr2(&usr->uni_workstations, workstations);
- init_unistr2(&usr->uni_unknown_str, NULL);
- init_unistr2(&usr->uni_munged_dial, munged_dial);
+ init_unistr2(&usr->uni_user_name, user_name, len_user_name);
+ init_unistr2(&usr->uni_full_name, full_name, len_full_name);
+ init_unistr2(&usr->uni_home_dir, home_dir, len_home_dir);
+ init_unistr2(&usr->uni_dir_drive, dir_drive, len_dir_drive);
+ init_unistr2(&usr->uni_logon_script, logon_script, len_logon_script);
+ init_unistr2(&usr->uni_profile_path, profile_path, len_profile_path);
+ init_unistr2(&usr->uni_acct_desc, description, len_description);
+ init_unistr2(&usr->uni_workstations, workstations, len_workstations);
+ init_unistr2(&usr->uni_unknown_str, NULL, len_unknown_str);
+ init_unistr2(&usr->uni_munged_dial, munged_dial, len_munged_dial);
usr->unknown_6 = pdb_get_unknown_6(pw);
usr->padding4 = 0;
len_munged_dial = munged_dial != NULL ? strlen(munged_dial )+1 : 0;
init_uni_hdr(&usr->hdr_munged_dial, len_munged_dial);
- init_unistr2(&usr->uni_munged_dial, munged_dial);
+ init_unistr2(&usr->uni_munged_dial, munged_dial, len_munged_dial);
}
/* make PDC server name \\server */
q_u->ptr_srv_name = len_srv_name > 0 ? 1 : 0;
- init_unistr2(&q_u->uni_srv_name, srv_name);
+ init_unistr2(&q_u->uni_srv_name, srv_name, len_srv_name + 1);
/* example values: 0x0000 0002 */
q_u->access_mask = access_mask;
/* make PDC server name \\server */
q_u->ptr_srv_name = len_srv_name > 0 ? 1 : 0;
- init_unistr2(&q_u->uni_srv_name, srv_name);
+ init_unistr2(&q_u->uni_srv_name, srv_name, len_srv_name + 1);
/* Only value we've seen, possibly an address type ? */
q_u->unk_0 = 2;
q_u->ptr = 1;
init_uni_hdr(&q_u->hdr_srv_name, len_srv_name);
- init_unistr2(&q_u->uni_srv_name, srv_name);
+ init_unistr2(&q_u->uni_srv_name, srv_name, len_srv_name);
}
/*******************************************************************
q_u->ptr_0 = 1;
init_uni_hdr(&q_u->hdr_dest_host, len_dest_host);
- init_unistr2(&q_u->uni_dest_host, dest_host);
+ init_unistr2(&q_u->uni_dest_host, dest_host, len_dest_host);
init_uni_hdr(&q_u->hdr_user_name, len_user_name);
- init_unistr2(&q_u->uni_user_name, user_name);
+ init_unistr2(&q_u->uni_user_name, user_name, len_user_name);
init_enc_passwd(&q_u->nt_newpass, nt_newpass);
init_enc_hash(&q_u->nt_oldhash, nt_oldhash);
{
DEBUG(5,("make_spoolss_q_open_printer_ex\n"));
q_u->printername_ptr = (printername!=NULL)?1:0;
- init_unistr2(&q_u->printername, printername);
+ init_unistr2(&q_u->printername, printername, strlen(printername)+1);
q_u->printer_default.datatype_ptr = 0;
/*
q_u->printer_default.datatype_ptr = (datatype!=NULL)?1:0;
- init_unistr2(&q_u->printer_default.datatype, datatype);
+ init_unistr2(&q_u->printer_default.datatype, datatype, strlen(datatype));
*/
q_u->printer_default.devmode_cont.size=0;
q_u->printer_default.devmode_cont.devmode_ptr=0;
q_u->user_ctr.user1.major=2;
q_u->user_ctr.user1.minor=0;
q_u->user_ctr.user1.processor=0;
- init_unistr2(&q_u->user_ctr.user1.client_name, clientname);
- init_unistr2(&q_u->user_ctr.user1.user_name, user_name);
+ init_unistr2(&q_u->user_ctr.user1.client_name, clientname, strlen(clientname)+1);
+ init_unistr2(&q_u->user_ctr.user1.user_name, user_name, strlen(user_name)+1);
return True;
}
ZERO_STRUCTP(q_u);
q_u->server_name_ptr = (srv_name!=NULL)?1:0;
- init_unistr2(&q_u->server_name, srv_name);
+ init_unistr2(&q_u->server_name, srv_name, strlen(srv_name));
q_u->level = level;
q_u->user_ctr.user1.major=2;
q_u->user_ctr.user1.minor=0;
q_u->user_ctr.user1.processor=0;
- init_unistr2(&q_u->user_ctr.user1.client_name, clientname);
- init_unistr2(&q_u->user_ctr.user1.user_name, user_name);
+ init_unistr2(&q_u->user_ctr.user1.client_name, clientname, strlen(clientname)+1);
+ init_unistr2(&q_u->user_ctr.user1.user_name, user_name, strlen(user_name)+1);
q_u->user_ctr.user1.size=q_u->user_ctr.user1.user_name.uni_str_len +
q_u->user_ctr.user1.client_name.uni_str_len + 2;
/* these must be NULL terminated or else NT4 will
complain about invalid parameters --jerry */
- init_unistr2(&q_u->server, server);
- init_unistr2(&q_u->arch, arch);
- init_unistr2(&q_u->driver, driver);
+ init_unistr2(&q_u->server, server, strlen(server)+1);
+ init_unistr2(&q_u->arch, arch, strlen(arch)+1);
+ init_unistr2(&q_u->driver, driver, strlen(driver)+1);
return True;
DEBUG(5,("make_spoolss_q_getprinterdata\n"));
q_u->handle = *handle;
- init_unistr2(&q_u->valuename, valuename);
+ init_unistr2(&q_u->valuename, valuename, strlen(valuename) + 1);
q_u->size = size;
return True;
DEBUG(5,("make_spoolss_q_getprinterdataex\n"));
q_u->handle = *handle;
- init_unistr2(&q_u->valuename, valuename);
- init_unistr2(&q_u->keyname, keyname);
+ init_unistr2(&q_u->valuename, valuename, strlen(valuename) + 1);
+ init_unistr2(&q_u->keyname, keyname, strlen(keyname) + 1);
q_u->size = size;
return True;
DEBUG(5,("make_spoolss_q_addprinterdriver\n"));
q_u->server_name_ptr = (srv_name!=NULL)?1:0;
- init_unistr2(&q_u->server_name, srv_name);
+ init_unistr2(&q_u->server_name, srv_name, strlen(srv_name)+1);
q_u->level = level;
uint32 size)
{
memcpy(&q_u->handle, hnd, sizeof(q_u->handle));
- init_unistr2(&q_u->key, key);
+ init_unistr2(&q_u->key, key, strlen(key)+1);
q_u->size = size;
return True;
{
memcpy(&q_u->handle, hnd, sizeof(q_u->handle));
q_u->type = data_type;
- init_unistr2(&q_u->value, value);
+ init_unistr2(&q_u->value, value, strlen(value)+1);
q_u->max_len = q_u->real_len = data_size;
q_u->data = data;
{
memcpy(&q_u->handle, hnd, sizeof(q_u->handle));
q_u->type = data_type;
- init_unistr2(&q_u->value, value);
- init_unistr2(&q_u->key, key);
+ init_unistr2(&q_u->value, value, strlen(value)+1);
+ init_unistr2(&q_u->key, key, strlen(key)+1);
q_u->max_len = q_u->real_len = data_size;
q_u->data = data;
if (q_u == NULL)
return False;
- init_unistr2(&q_u->string, string);
+ init_unistr2(&q_u->string, string, strlen(string)+1);
q_u->printer=printer;
q_u->type=type;
DEBUG(5,("make_spoolss_q_enumprinterkey\n"));
memcpy(&q_u->handle, hnd, sizeof(q_u->handle));
- init_unistr2(&q_u->key, key);
+ init_unistr2(&q_u->key, key, strlen(key)+1);
q_u->size = size;
return True;
DEBUG(5,("make_spoolss_q_deleteprinterkey\n"));
memcpy(&q_u->handle, hnd, sizeof(q_u->handle));
- init_unistr2(&q_u->keyname, keyname);
+ init_unistr2(&q_u->keyname, keyname, strlen(keyname)+1);
return True;
}
{
DEBUG(5,("make_spoolss_q_getprintprocessordirectory\n"));
- init_unistr2(&q_u->name, name);
- init_unistr2(&q_u->environment, environment);
+ init_unistr2(&q_u->name, name, strlen(name)+1);
+ init_unistr2(&q_u->environment, environment, strlen(environment)+1);
q_u->level = level;
q_u->level = level;
q_u->level2 = level;
memcpy(&q_u->form, form, sizeof(FORM));
- init_unistr2(&q_u->name, form_name);
+ init_unistr2(&q_u->name, form_name, strlen(form_name) + 1);
return True;
}
BOOL make_spoolss_q_deleteform(SPOOL_Q_DELETEFORM *q_u, POLICY_HND *handle, char *form)
{
memcpy(&q_u->handle, handle, sizeof(POLICY_HND));
- init_unistr2(&q_u->name, form);
+ init_unistr2(&q_u->name, form, strlen(form) + 1);
return True;
}
{
memcpy(&q_u->handle, handle, sizeof(POLICY_HND));
q_u->level = level;
- init_unistr2(&q_u->formname, formname);
+ init_unistr2(&q_u->formname, formname, strlen(formname) + 1);
q_u->buffer=buffer;
q_u->offered=offered;
ctr->docinfo.doc_info_1.p_datatype = datatype ? 1 : 0;
if (docname)
- init_unistr2(&ctr->docinfo.doc_info_1.docname, docname);
+ init_unistr2(&ctr->docinfo.doc_info_1.docname, docname,
+ strlen(docname) + 1);
if (outputfile)
- init_unistr2(&ctr->docinfo.doc_info_1.outputfile, outputfile);
+ init_unistr2(&ctr->docinfo.doc_info_1.outputfile, outputfile,
+ strlen(outputfile) + 1);
if (datatype)
- init_unistr2(&ctr->docinfo.doc_info_1.datatype, datatype);
+ init_unistr2(&ctr->docinfo.doc_info_1.datatype, datatype,
+ strlen(datatype) + 1);
break;
case 2:
POLICY_HND *handle, char *valuename)
{
memcpy(&q_u->handle, handle, sizeof(POLICY_HND));
- init_unistr2(&q_u->valuename, valuename);
+ init_unistr2(&q_u->valuename, valuename, strlen(valuename) + 1);
return True;
}
char *value)
{
memcpy(&q_u->handle, handle, sizeof(POLICY_HND));
- init_unistr2(&q_u->valuename, value);
- init_unistr2(&q_u->keyname, key);
+ init_unistr2(&q_u->valuename, value, strlen(value) + 1);
+ init_unistr2(&q_u->keyname, key, strlen(key) + 1);
return True;
}
q_u->localmachine_ptr = 1;
- init_unistr2(&q_u->localmachine, localmachine);
+ init_unistr2(&q_u->localmachine, localmachine,
+ strlen(localmachine) + 1);
q_u->printerlocal = printerlocal;
DEBUG(5,("init_srv_share_info0_str\n"));
if(net_name)
- init_unistr2(&sh0->uni_netname, net_name);
+ init_unistr2(&sh0->uni_netname, net_name, strlen(net_name)+1);
}
/*******************************************************************
DEBUG(5,("init_srv_share_info1_str\n"));
if(net_name)
- init_unistr2(&sh1->uni_netname, net_name);
+ init_unistr2(&sh1->uni_netname, net_name, strlen(net_name)+1);
if(remark)
- init_unistr2(&sh1->uni_remark, remark);
+ init_unistr2(&sh1->uni_remark, remark, strlen(remark)+1);
}
/*******************************************************************
DEBUG(5,("init_srv_share_info2_str\n"));
if (net_name)
- init_unistr2(&sh2->uni_netname, net_name);
+ init_unistr2(&sh2->uni_netname, net_name, strlen(net_name)+1);
if (remark)
- init_unistr2(&sh2->uni_remark, remark);
+ init_unistr2(&sh2->uni_remark, remark, strlen(remark)+1);
if (path)
- init_unistr2(&sh2->uni_path, path);
+ init_unistr2(&sh2->uni_path, path, strlen(path)+1);
if (passwd)
- init_unistr2(&sh2->uni_passwd, passwd);
+ init_unistr2(&sh2->uni_passwd, passwd, strlen(passwd)+1);
}
/*******************************************************************
DEBUG(5,("init_srv_share_info501_str\n"));
if(net_name)
- init_unistr2(&sh501->uni_netname, net_name);
+ init_unistr2(&sh501->uni_netname, net_name, strlen(net_name)+1);
if(remark)
- init_unistr2(&sh501->uni_remark, remark);
+ init_unistr2(&sh501->uni_remark, remark, strlen(remark)+1);
}
/*******************************************************************
DEBUG(5,("init_srv_share_info502_str\n"));
if(net_name)
- init_unistr2(&sh502str->uni_netname, net_name);
+ init_unistr2(&sh502str->uni_netname, net_name, strlen(net_name)+1);
if(remark)
- init_unistr2(&sh502str->uni_remark, remark);
+ init_unistr2(&sh502str->uni_remark, remark, strlen(remark)+1);
if(path)
- init_unistr2(&sh502str->uni_path, path);
+ init_unistr2(&sh502str->uni_path, path, strlen(path)+1);
if(passwd)
- init_unistr2(&sh502str->uni_passwd, passwd);
+ init_unistr2(&sh502str->uni_passwd, passwd, strlen(passwd)+1);
sh502str->sd = psd;
sh502str->reserved = 0;
sh502str->sd_size = sd_size;
DEBUG(5,("init_srv_share_info1004_str\n"));
if(remark)
- init_unistr2(&sh1004->uni_remark, remark);
+ init_unistr2(&sh1004->uni_remark, remark, strlen(remark)+1);
}
/*******************************************************************
DEBUG(5,("init_srv_share_info1007_str\n"));
if(alternate_directory_name)
- init_unistr2(&sh1007->uni_AlternateDirectoryName, alternate_directory_name);
+ init_unistr2(&sh1007->uni_AlternateDirectoryName, alternate_directory_name, strlen(alternate_directory_name)+1);
}
/*******************************************************************
const char *path, const char *passwd)
{
q->ptr_srv_name = 1;
- init_unistr2(&q->uni_srv_name, srvname);
+ init_unistr2(&q->uni_srv_name, srvname, strlen(srvname) +1);
q->info.switch_value = q->info_level = 2;
q->info.ptr_share_ctr = 1;
const char *sharename)
{
del->ptr_srv_name = 1;
- init_unistr2(&del->uni_srv_name, srvname);
- init_unistr2(&del->uni_share_name, sharename);
+ init_unistr2(&del->uni_srv_name, srvname, strlen(srvname) +1 );
+ init_unistr2(&del->uni_share_name, sharename, strlen(sharename) + 1);
}
/*******************************************************************
{
DEBUG(5,("init_srv_sess_info0_str\n"));
- init_unistr2(&ss0->uni_name, name);
+ init_unistr2(&ss0->uni_name, name, strlen(name)+1);
}
/*******************************************************************
{
DEBUG(5,("init_srv_sess_info1_str\n"));
- init_unistr2(&ss1->uni_name, name);
- init_unistr2(&ss1->uni_user, user);
+ init_unistr2(&ss1->uni_name, name, strlen(name)+1);
+ init_unistr2(&ss1->uni_user, user, strlen(user)+1);
}
/*******************************************************************
{
DEBUG(5,("init_srv_conn_info1_str\n"));
- init_unistr2(&ss1->uni_usr_name, usr_name);
- init_unistr2(&ss1->uni_net_name, net_name);
+ init_unistr2(&ss1->uni_usr_name, usr_name, strlen(usr_name)+1);
+ init_unistr2(&ss1->uni_net_name, net_name, strlen(net_name)+1);
}
/*******************************************************************
{
DEBUG(5,("init_srv_file_info3_str\n"));
- init_unistr2(&fi3->uni_path_name, path_name);
- init_unistr2(&fi3->uni_user_name, user_name);
+ init_unistr2(&fi3->uni_path_name, path_name, strlen(path_name)+1);
+ init_unistr2(&fi3->uni_user_name, user_name, strlen(user_name)+1);
}
/*******************************************************************
uint32 file_id)
{
q_n->ptr_srv_name = 1;
- init_unistr2(&q_n->uni_srv_name, server);
+ init_unistr2(&q_n->uni_srv_name, server, strlen(server) + 1);
q_n->file_id = file_id;
}
void init_srv_q_net_remote_tod(SRV_Q_NET_REMOTE_TOD *q_u, const char *server)
{
q_u->ptr_srv_name = 1;
- init_unistr2(&q_u->uni_srv_name, server);
+ init_unistr2(&q_u->uni_srv_name, server, strlen(server) + 1);
}
slprintf(str, sizeof(pstring)-1, "\\\\%s\\%s\\%s", global_myname(),
j[i].service_name, j[i].volume_name);
DEBUG(5,("init_reply_dfs_info_1: %d) initing entrypath: %s\n",i,str));
- init_unistr2(&dfs1[i].entrypath,str);
+ init_unistr2(&dfs1[i].entrypath,str,strlen(str)+1);
}
return True;
}
dfs2[i].ptr_entrypath = 1;
slprintf(str, sizeof(pstring)-1, "\\\\%s\\%s\\%s", global_myname(),
j[i].service_name, j[i].volume_name);
- init_unistr2(&dfs2[i].entrypath, str);
+ init_unistr2(&dfs2[i].entrypath, str, strlen(str)+1);
dfs2[i].ptr_comment = 0;
dfs2[i].state = 1; /* set up state of dfs junction as OK */
dfs2[i].num_storages = j[i].referral_count;
slprintf(str, sizeof(pstring)-1, "\\\\%s\\%s\\%s", global_myname(),
j[i].service_name, j[i].volume_name);
- init_unistr2(&dfs3[i].entrypath, str);
+ init_unistr2(&dfs3[i].entrypath, str, strlen(str)+1);
dfs3[i].ptr_comment = 1;
- init_unistr2(&dfs3[i].comment, "");
+ init_unistr2(&dfs3[i].comment, "", 1);
dfs3[i].state = 1;
dfs3[i].num_storages = dfs3[i].num_storage_infos = j[i].referral_count;
dfs3[i].ptr_storages = 1;
*p = '\0';
DEBUG(5,("storage %d: %s.%s\n",ii,path,p+1));
stor->state = 2; /* set all storages as ONLINE */
- init_unistr2(&stor->servername, path);
- init_unistr2(&stor->sharename, p+1);
+ init_unistr2(&stor->servername, path, strlen(path)+1);
+ init_unistr2(&stor->sharename, p+1, strlen(p+1)+1);
stor->ptr_servername = stor->ptr_sharename = 1;
}
}
d_q->buffer_dom_sid = dom_sid != NULL ? 1 : 0; /* domain sid pointer */
/* this string is supposed to be character short */
- init_unistr2(&d_q->uni_domain_name, dom_name);
+ init_unistr2(&d_q->uni_domain_name, dom_name, domlen);
d_q->uni_domain_name.uni_max_len++;
if (dom_sid != NULL)
init_uni_hdr(&ref->hdr_ref_dom[num].hdr_dom_name, len);
ref->hdr_ref_dom[num].ptr_dom_sid = dom_sid != NULL ? 1 : 0;
- init_unistr2(&ref->ref_dom[num].uni_dom_name, dom_name);
+ init_unistr2(&ref->ref_dom[num].uni_dom_name, dom_name, len);
init_dom_sid2(&ref->ref_dom[num].ref_dom, dom_sid );
return num;
{
if (nb_name && *nb_name) {
init_uni_hdr(&r_l->hdr_nb_dom_name, strlen(nb_name));
- init_unistr2(&r_l->uni_nb_dom_name, nb_name);
+ init_unistr2(&r_l->uni_nb_dom_name, nb_name,
+ strlen(nb_name));
r_l->hdr_nb_dom_name.uni_max_len += 2;
r_l->uni_nb_dom_name.uni_max_len += 1;
}
if (dns_name && *dns_name) {
init_uni_hdr(&r_l->hdr_dns_dom_name, strlen(dns_name));
- init_unistr2(&r_l->uni_dns_dom_name, dns_name);
+ init_unistr2(&r_l->uni_dns_dom_name, dns_name,
+ strlen(dns_name));
r_l->hdr_dns_dom_name.uni_max_len += 2;
r_l->uni_dns_dom_name.uni_max_len += 1;
}
if (forest_name && *forest_name) {
init_uni_hdr(&r_l->hdr_forest_name, strlen(forest_name));
- init_unistr2(&r_l->uni_forest_name, forest_name);
+ init_unistr2(&r_l->uni_forest_name, forest_name,
+ strlen(forest_name));
r_l->hdr_forest_name.uni_max_len += 2;
r_l->uni_forest_name.uni_max_len += 1;
}
for (i = 0; i < PRIV_ALL_INDEX; i++, entry++) {
if( i<enum_context) {
init_uni_hdr(&entry->hdr_name, 0);
- init_unistr2(&entry->name, NULL);
+ init_unistr2(&entry->name, NULL, 0 );
entry->luid_low = 0;
entry->luid_high = 0;
} else {
init_uni_hdr(&entry->hdr_name, strlen(privs[i+1].priv));
- init_unistr2(&entry->name, privs[i+1].priv);
+ init_unistr2(&entry->name, privs[i+1].priv, strlen(privs[i+1].priv) );
entry->luid_low = privs[i+1].se_priv;
entry->luid_high = 0;
}
if (privs[i].se_priv!=SE_PRIV_ALL) {
DEBUG(10,(": %s\n", privs[i].description));
init_uni_hdr(&r_u->hdr_desc, strlen(privs[i].description));
- init_unistr2(&r_u->desc, privs[i].description);
+ init_unistr2(&r_u->desc, privs[i].description, strlen(privs[i].description) );
r_u->ptr_info=0xdeadbeef;
r_u->lang_id=q_u->lang_id;
init_uni_hdr(&r_u->hdr_user_name, ulen);
r_u->ptr_user_name = 1;
- init_unistr2(&r_u->uni2_user_name, username);
+ init_unistr2(&r_u->uni2_user_name, username, ulen);
r_u->unk1 = 1;
init_uni_hdr(&r_u->hdr_dom_name, dlen);
r_u->ptr_dom_name = 1;
- init_unistr2(&r_u->uni2_dom_name, domname);
+ init_unistr2(&r_u->uni2_dom_name, domname, dlen);
r_u->status = NT_STATUS_OK;
for (i = 0; i < num_entries; i++) {
pwd = disp_user_info[i+start_idx].sam;
temp_name = pdb_get_username(pwd);
- init_unistr2(&uni_temp_name, temp_name);
+ init_unistr2(&uni_temp_name, temp_name, strlen(temp_name)+1);
user_sid = pdb_get_user_sid(pwd);
if (!sid_peek_check_rid(domain_sid, user_sid, &user_rid)) {
int len = strlen(grp[i].name)+1;
init_sam_entry(&sam[i], len, grp[i].rid);
- init_unistr2(&uni_name[i], grp[i].name);
+ init_unistr2(&uni_name[i], grp[i].name, len);
}
*sam_pp = sam;
int len = names[i] != NULL ? strlen(names[i]) : 0;
DEBUG(10, ("names[%d]:%s\n", i, names[i]));
init_uni_hdr(&hdr_name[i], len);
- init_unistr2(&uni_name[i], names[i]);
+ init_unistr2(&uni_name[i], names[i], len);
}
*pp_uni_name = uni_name;
int len = doms[i] != NULL ? strlen(doms[i]) : 0;
init_sam_entry(&sam[i], len, 0);
- init_unistr2(&uni_name[i], doms[i]);
+ init_unistr2(&uni_name[i], doms[i], len);
}
*pp_sam = sam;
/* The length of the message includes the trailing \0 */
- init_unistr2(&unistr, msg->notify.data);
+ init_unistr2(&unistr, msg->notify.data, msg->len);
data->notify_data.data.length = msg->len * 2;
data->notify_data.data.string = (uint16 *)talloc(mem_ctx, msg->len * 2);
form.right = 20;
form.bottom = 30;
- init_unistr2(&form.name, argv[2]);
+ init_unistr2(&form.name, argv[2], strlen(argv[2]) + 1);
/* Add the form */
form.right = 2000;
form.bottom = 3000;
- init_unistr2(&form.name, argv[2]);
+ init_unistr2(&form.name, argv[2], strlen(argv[2]) + 1);
/* Set the form */
git.samba.org / kai / samba.git / commitdiff