r10003: in the rush for 10k, I forgot to run add the rest of Chris' libmsrpc files

(This used to be commit 32bebc452dffa8348b94c5b866350b1fe761986f)

1 files changed, 684 insertions, 0 deletions

diff --git a/source3/libmsrpc/libmsrpc_internal.c b/source3/libmsrpc/libmsrpc_internal.c
new file mode 100644
index 00000000000..2560fd602bd
--- /dev/null
+++ b/source3/libmsrpc/libmsrpc_internal.c
@@ -0,0 +1,684 @@
+/* 
+ *  Unix SMB/CIFS implementation.
+ *  MS-RPC client internal functions
+ *  Copyright (C) Chris Nicholls              2005.
+ *  
+ *  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
+ *  (at your option) any later version.
+ *  
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  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.
+ */
+
+
+#include "libmsrpc.h"
+#include "libmsrpc_internal.h"
+
+/*takes a string like HKEY_LOCAL_MACHINE\HARDWARE\ACPI and returns the reg_type code and then a pointer to the start of the path (HARDWARE)*/
+int cac_ParseRegPath(char *path, uint32 *reg_type, char **key_name) {
+
+   if(!path)
+      return CAC_FAILURE;
+
+   if(strncmp(path, "HKLM", 4) == 0) {
+      *reg_type = HKEY_LOCAL_MACHINE;
+      *key_name = (path[4] == '\\') ? path + 5 : NULL;
+   }
+   else if(strncmp(path, "HKEY_LOCAL_MACHINE", 18) == 0) {
+      *reg_type = HKEY_LOCAL_MACHINE;
+      *key_name = (path[18] == '\\') ? path + 19 : NULL;
+   }
+   else if(strncmp(path, "HKCR", 4) == 0) {
+      *reg_type = HKEY_CLASSES_ROOT;
+      *key_name = (path[4] == '\\') ? path + 5 : NULL;
+   }
+   else if(strncmp(path, "HKEY_CLASSES_ROOT", 17) == 0) {
+      *reg_type = HKEY_CLASSES_ROOT;
+      *key_name = (path[17] == '\\') ? path + 18 : NULL;
+   }
+   else if(strncmp(path, "HKU", 3) == 0) {
+      *reg_type = HKEY_USERS;
+      *key_name = (path[3] == '\\') ? path + 4 : NULL;
+   }
+   else if(strncmp(path, "HKEY_USERS", 10) == 0) {
+      *reg_type = HKEY_USERS;
+      *key_name = (path[10] == '\\') ? path + 11 : NULL;
+   }
+   else if(strncmp(path, "HKPD", 4) == 0) {
+      *reg_type = HKEY_PERFORMANCE_DATA;
+      *key_name = (path[4] == '\\') ? path + 5 : NULL;
+   }
+   else if(strncmp(path, "HKEY_PERFORMANCE_DATA", 21) == 0) {
+      *reg_type = HKEY_PERFORMANCE_DATA;
+      *key_name = (path[21] == '\\') ? path + 22 : NULL;
+   }
+   else {
+      return CAC_FAILURE;
+   }
+
+   return CAC_SUCCESS;
+}
+
+
+
+RPC_DATA_BLOB *cac_MakeRpcDataBlob(TALLOC_CTX *mem_ctx, uint32 data_type, REG_VALUE_DATA data) {
+   RPC_DATA_BLOB *blob = NULL;
+   int i;
+   uint32 size = 0;
+   uint32 len  = 0;
+   uint8 *multi = NULL;
+   uint32 multi_idx = 0;
+
+   blob = talloc(mem_ctx, RPC_DATA_BLOB);
+
+   if(!blob) {
+      errno = ENOMEM;
+      return NULL;
+   }
+
+   switch(data_type) {
+      case REG_SZ:
+         init_rpc_blob_str(blob, data.reg_sz, strlen(data.reg_sz ) + 1);
+         break;
+
+      case REG_EXPAND_SZ:
+         init_rpc_blob_str(blob, data.reg_expand_sz, strlen(data.reg_sz) + 1);
+         break;
+
+      case REG_BINARY:
+         init_rpc_blob_bytes(blob, data.reg_binary.data, data.reg_binary.data_length);
+         break;
+
+      case REG_DWORD:
+         init_rpc_blob_uint32(blob, data.reg_dword);
+         break;
+         
+      case REG_DWORD_BE:
+         init_rpc_blob_uint32(blob, data.reg_dword_be);
+         break;
+         
+      case REG_MULTI_SZ:
+         /*need to find the size*/
+         for(i = 0; i < data.reg_multi_sz.num_strings; i++) {
+            size += strlen(data.reg_multi_sz.strings[i]) + 1;
+         }
+
+         /**need a whole bunch of unicode strings in a row (seperated by null characters), with an extra null-character on the end*/
+
+         multi = TALLOC_ZERO_ARRAY(mem_ctx, uint8, (size + 1)*2); /*size +1 for the extra null character*/
+         if(!multi) {
+            errno = ENOMEM;
+            break;
+         }
+         
+         /*do it using rpcstr_push()*/
+         multi_idx = 0;
+         for(i = 0; i < data.reg_multi_sz.num_strings; i++) {
+            len = strlen(data.reg_multi_sz.strings[i]) + 1;
+
+            rpcstr_push((multi + multi_idx), data.reg_multi_sz.strings[i], len * 2, STR_TERMINATE);
+
+            /* x2 becuase it is a uint8 buffer*/
+            multi_idx += len * 2;
+         }
+            
+         /*now initialize the buffer as binary data*/
+         init_rpc_blob_bytes(blob, multi, (size + 1)*2);
+
+         break;
+
+      default:
+         talloc_free(blob);
+         blob = NULL;
+   }
+
+   if(!(blob->buffer)) {
+      talloc_free(blob);
+      return NULL;
+   }
+
+   return blob;
+}
+
+/*turns a string in a uint16 array to a char array*/
+char *cac_unistr_to_str(TALLOC_CTX *mem_ctx, uint16 *src, int num_bytes) {
+   char *buf;
+   
+   int i = 0;
+
+   uint32 str_len = 0;
+   
+   /*don't allocate more space than we need*/
+   while( (str_len) < num_bytes/2 && src[str_len] != 0x0000)
+      str_len++;
+
+   /*need room for a '\0'*/
+   str_len++;
+
+   buf = talloc_array(mem_ctx, char, str_len);
+   if(!buf) {
+      return NULL;
+   }
+
+   for(i = 0; i < num_bytes/2; i++) {
+      buf[i] = ((char *)src)[2*i];
+   }
+
+   buf[str_len - 1] = '\0';
+
+   return buf;
+}
+
+REG_VALUE_DATA *cac_MakeRegValueData(TALLOC_CTX *mem_ctx, uint32 data_type, REGVAL_BUFFER buf) {
+   REG_VALUE_DATA *data;
+
+   uint32 i;
+
+   /*all of the following used for MULTI_SZ data*/
+   uint32 size       = 0;
+   uint32 len        = 0;
+   uint32 multi_idx  = 0;
+   uint32 num_strings= 0;
+   char **strings    = NULL;
+
+   data = talloc(mem_ctx, REG_VALUE_DATA);
+   if(!data) {
+      errno = ENOMEM;
+      return NULL;
+   }
+
+   switch (data_type) {
+      case REG_SZ:
+         data->reg_sz = cac_unistr_to_str(mem_ctx, buf.buffer, buf.buf_len);
+         if(!data->reg_sz) {
+            talloc_free(data);
+            errno = ENOMEM;
+            data = NULL;
+         }
+            
+         break;
+
+      case REG_EXPAND_SZ:
+         data->reg_expand_sz = cac_unistr_to_str(mem_ctx, buf.buffer, buf.buf_len);
+
+         if(!data->reg_expand_sz) {
+            talloc_free(data);
+            errno = ENOMEM;
+            data = NULL;
+         }
+            
+         break;
+
+      case REG_BINARY:
+         size = buf.buf_len;
+
+         data->reg_binary.data_length = size;
+
+         data->reg_binary.data = talloc_memdup(mem_ctx, buf.buffer, size);
+         if(!data->reg_binary.data) {
+            talloc_free(data);
+            errno = ENOMEM;
+            data = NULL;
+         }
+         break;
+
+      case REG_DWORD:
+         data->reg_dword = *((uint32 *)buf.buffer);
+         break;
+
+      case REG_DWORD_BE:
+         data->reg_dword_be = *((uint32 *)buf.buffer);
+         break;
+
+      case REG_MULTI_SZ:
+         size = buf.buf_len;
+
+         /*find out how many strings there are. size is # of bytes and we want to work uint16*/
+         for(i = 0; i < (size/2 - 1); i++) {
+            if(buf.buffer[i] == 0x0000)
+               num_strings++;
+
+            /*buffer is suppsed to be terminated with \0\0, but it might not be*/
+            if(buf.buffer[i] == 0x0000 && buf.buffer[i + 1] == 0x0000)
+               break;
+         }
+         
+         strings = talloc_array(mem_ctx, char *, num_strings);
+         if(!strings) {
+            errno = ENOMEM;
+            talloc_free(data);
+            break;
+         }
+
+         if(num_strings == 0) /*then our work here is done*/
+            break;
+
+         for(i = 0; i < num_strings; i++) {
+            /*find out how many characters are in this string*/
+            len = 0;
+            /*make sure we don't go past the end of the buffer and keep looping until we have a uni \0*/
+            while( multi_idx + len < size/2 && buf.buffer[multi_idx + len] != 0x0000)
+               len++;
+
+            /*stay aware of the \0\0*/
+            len++;
+
+            strings[i] = TALLOC_ZERO_ARRAY(mem_ctx, char, len);
+
+            /*pull out the unicode string*/
+            rpcstr_pull(strings[i], (buf.buffer + multi_idx) , len, -1, STR_TERMINATE);
+
+            /*keep track of where we are in the bigger array*/
+            multi_idx += len;
+         }
+
+         data->reg_multi_sz.num_strings = num_strings;
+         data->reg_multi_sz.strings     = strings;
+
+         break;
+
+      default:
+         talloc_free(data);
+         data = NULL;
+   }
+
+   return data;
+}
+
+SAM_USERINFO_CTR *cac_MakeUserInfoCtr(TALLOC_CTX *mem_ctx, CacUserInfo *info) {
+   SAM_USERINFO_CTR *ctr = NULL;
+
+   /*the flags we are 'setting'- include/passdb.h*/
+   uint32 flags = ACCT_USERNAME | ACCT_FULL_NAME | ACCT_PRIMARY_GID | ACCT_ADMIN_DESC | ACCT_DESCRIPTION |
+                     ACCT_HOME_DIR | ACCT_HOME_DRIVE | ACCT_LOGON_SCRIPT | ACCT_PROFILE | ACCT_WORKSTATIONS |
+                      ACCT_FLAGS;
+
+   NTTIME logon_time;
+   NTTIME logoff_time;
+   NTTIME kickoff_time;
+   NTTIME pass_last_set_time;
+   NTTIME pass_can_change_time;
+   NTTIME pass_must_change_time;
+
+   UNISTR2 user_name;
+   UNISTR2 full_name;
+   UNISTR2 home_dir;
+   UNISTR2 dir_drive;
+   UNISTR2 log_scr;
+   UNISTR2 prof_path;
+   UNISTR2 desc;
+   UNISTR2 wkstas;
+   UNISTR2 mung_dial;
+   UNISTR2 unk;
+
+   ctr = talloc(mem_ctx, SAM_USERINFO_CTR);
+   if(!ctr)
+      return NULL;
+
+   ZERO_STRUCTP(ctr->info.id23);
+
+   ctr->info.id21 = talloc(mem_ctx, SAM_USER_INFO_21);
+   if(!ctr->info.id21)
+      return NULL;
+
+   ctr->switch_value = 21;
+
+   ZERO_STRUCTP(ctr->info.id21);
+
+   unix_to_nt_time(&logon_time, info->logon_time);
+   unix_to_nt_time(&logoff_time, info->logoff_time);
+   unix_to_nt_time(&kickoff_time, info->kickoff_time);
+   unix_to_nt_time(&pass_last_set_time, info->pass_last_set_time);
+   unix_to_nt_time(&pass_can_change_time, info->pass_can_change_time);
+   unix_to_nt_time(&pass_must_change_time, info->pass_must_change_time);
+
+   /*initialize the strings*/
+   init_unistr2(&user_name, info->username, STR_TERMINATE);
+   init_unistr2(&full_name, info->full_name, STR_TERMINATE);
+   init_unistr2(&home_dir, info->home_dir, STR_TERMINATE);
+   init_unistr2(&dir_drive, info->home_drive, STR_TERMINATE);
+   init_unistr2(&log_scr, info->logon_script, STR_TERMINATE);
+   init_unistr2(&prof_path, info->profile_path, STR_TERMINATE);
+   init_unistr2(&desc, info->description, STR_TERMINATE);
+   init_unistr2(&wkstas, info->workstations, STR_TERMINATE);
+   init_unistr2(&unk, "\0", STR_TERMINATE);
+   init_unistr2(&mung_dial, info->dial, STR_TERMINATE);
+
+   /*manually set passmustchange*/
+   ctr->info.id21->passmustchange = (info->pass_must_change) ? 0x01 : 0x00;
+
+   init_sam_user_info21W(ctr->info.id21,
+                         &logon_time,
+                         &logoff_time,
+                         &kickoff_time,
+                         &pass_last_set_time,
+                         &pass_can_change_time,
+                         &pass_must_change_time,
+                         &user_name,
+                         &full_name,
+                         &home_dir,
+                         &dir_drive,
+                         &log_scr,
+                         &prof_path,
+                         &desc,
+                         &wkstas,
+                         &unk,
+                         &mung_dial,
+                         info->lm_password,
+                         info->nt_password,
+                         info->rid,
+                         info->group_rid,
+                         info->acb_mask,
+                         flags,
+                         168, /*logon divs*/
+                         info->logon_hours,
+                         info->bad_passwd_count,
+                         info->logon_count);
+
+   return ctr;
+   
+}
+
+char *talloc_unistr2_to_ascii(TALLOC_CTX *mem_ctx, UNISTR2 str) {
+   char *buf = NULL;
+
+   if(!mem_ctx)
+      return NULL;
+
+   buf = talloc_array(mem_ctx, char, (str.uni_str_len + 1));
+   if(!buf)
+      return NULL;
+
+   unistr2_to_ascii(buf, &str, str.uni_str_len + 1);
+
+   return buf;
+}
+
+CacUserInfo *cac_MakeUserInfo(TALLOC_CTX *mem_ctx, SAM_USERINFO_CTR *ctr) {
+   CacUserInfo *info = NULL;
+   SAM_USER_INFO_21 *id21 = NULL;
+
+   if(!ctr || ctr->switch_value != 21)
+      return NULL;
+
+   info = talloc(mem_ctx, CacUserInfo);
+   if(!info)
+      return NULL;
+
+   id21 = ctr->info.id21;
+
+   ZERO_STRUCTP(info);
+
+   info->logon_time = nt_time_to_unix(&id21->logon_time);
+   info->logoff_time = nt_time_to_unix(&id21->logoff_time);
+   info->kickoff_time = nt_time_to_unix(&id21->kickoff_time);
+   info->pass_last_set_time = nt_time_to_unix(&id21->pass_last_set_time);
+   info->pass_can_change_time = nt_time_to_unix(&id21->pass_can_change_time);
+   info->pass_must_change_time = nt_time_to_unix(&id21->pass_must_change_time);
+
+   info->username = talloc_unistr2_to_ascii(mem_ctx, id21->uni_user_name);
+   if(!info->username)
+      return NULL;
+
+   info->full_name = talloc_unistr2_to_ascii(mem_ctx, id21->uni_full_name);
+   if(!info->full_name)
+      return NULL;
+   
+   info->home_dir = talloc_unistr2_to_ascii(mem_ctx, id21->uni_home_dir);
+   if(!info->home_dir)
+      return NULL;
+   
+   info->home_drive = talloc_unistr2_to_ascii(mem_ctx, id21->uni_dir_drive);
+   if(!info->home_drive)
+      return NULL;
+
+   info->logon_script = talloc_unistr2_to_ascii(mem_ctx, id21->uni_logon_script);
+   if(!info->logon_script)
+      return NULL;
+
+   info->profile_path = talloc_unistr2_to_ascii(mem_ctx, id21->uni_profile_path);
+   if(!info->profile_path)
+      return NULL;
+   
+   info->description = talloc_unistr2_to_ascii(mem_ctx, id21->uni_acct_desc);
+   if(!info->description)
+      return NULL;
+   
+   info->workstations = talloc_unistr2_to_ascii(mem_ctx, id21->uni_workstations);
+   if(!info->workstations)
+      return NULL;
+
+   info->dial = talloc_unistr2_to_ascii(mem_ctx, id21->uni_munged_dial);
+   if(!info->dial)
+      return NULL;
+
+   info->rid = id21->user_rid;
+   info->group_rid = id21->group_rid;
+   info->acb_mask = id21->acb_info;
+   info->bad_passwd_count = id21->bad_password_count;
+   info->logon_count = id21->logon_count;
+
+   memcpy(info->nt_password, id21->nt_pwd, 8);
+   memcpy(info->lm_password, id21->lm_pwd, 8);
+   
+   info->logon_hours = talloc_memdup(mem_ctx, &(id21->logon_hrs), sizeof(LOGON_HRS));
+   if(!info->logon_hours)
+      return NULL;
+
+   info->pass_must_change = (id21->passmustchange) ? True : False;
+
+   return info;
+}
+
+CacGroupInfo *cac_MakeGroupInfo(TALLOC_CTX *mem_ctx, GROUP_INFO_CTR *ctr) {
+   CacGroupInfo *info = NULL;
+
+   if(!mem_ctx || !ctr || ctr->switch_value1 != 1)
+      return NULL;
+
+   info = talloc(mem_ctx, CacGroupInfo);
+   if(!info)
+      return NULL;
+
+   info->name = talloc_unistr2_to_ascii(mem_ctx, ctr->group.info1.uni_acct_name);
+   if(!info->name)
+      return NULL;
+
+   info->description = talloc_unistr2_to_ascii(mem_ctx, ctr->group.info1.uni_acct_desc);
+   if(!info->description)
+      return NULL;
+
+   info->num_members = ctr->group.info1.num_members;
+
+   return info;
+}
+
+GROUP_INFO_CTR *cac_MakeGroupInfoCtr(TALLOC_CTX *mem_ctx, CacGroupInfo *info) {
+   GROUP_INFO_CTR *ctr = NULL;
+
+   if(!mem_ctx || !info)
+      return NULL;
+
+   ctr = talloc(mem_ctx, GROUP_INFO_CTR);
+   if(!ctr)
+      return NULL;
+
+   ctr->switch_value1 = 1;
+
+   init_samr_group_info1(&(ctr->group.info1), info->name, info->description, info->num_members);
+
+   return ctr;
+}
+
+CacAliasInfo *cac_MakeAliasInfo(TALLOC_CTX *mem_ctx, ALIAS_INFO_CTR ctr) {
+   CacGroupInfo *info = NULL;
+
+   if(!mem_ctx || ctr.level != 1)
+      return NULL;
+
+   info = talloc(mem_ctx, CacAliasInfo);
+   if(!info)
+      return NULL;
+
+   info->name = talloc_unistr2_to_ascii(mem_ctx, *(ctr.alias.info1.name.string));
+   if(!info->name)
+      return NULL;
+
+   info->description = talloc_unistr2_to_ascii(mem_ctx, *(ctr.alias.info1.description.string));
+   if(!info->name)
+      return NULL;
+
+   info->num_members = ctr.alias.info1.num_member;
+
+   return info;
+}
+
+ALIAS_INFO_CTR *cac_MakeAliasInfoCtr(TALLOC_CTX *mem_ctx, CacAliasInfo *info) {
+   ALIAS_INFO_CTR *ctr = NULL;
+
+   if(!mem_ctx || !info)
+      return NULL;
+
+   ctr = talloc(mem_ctx, ALIAS_INFO_CTR);
+   if(!ctr)
+      return NULL;
+
+   ctr->level = 1;
+
+   init_samr_alias_info1(&(ctr->alias.info1), info->name, info->num_members, info->description);
+
+   return ctr;
+}
+
+CacDomainInfo *cac_MakeDomainInfo(TALLOC_CTX *mem_ctx, SAM_UNK_INFO_1 *info1, SAM_UNK_INFO_2 *info2, SAM_UNK_INFO_12 *info12) {
+   CacDomainInfo *info = NULL;
+
+   if(!mem_ctx || !info1 || !info2 || !info12)
+      return NULL;
+
+   info = talloc(mem_ctx, CacDomainInfo);
+   if(!info)
+      return NULL;
+
+   info->min_pass_length = info1->min_length_password;
+   info->pass_history    = info1->password_history;
+
+   cac_InitCacTime(&(info->expire), info1->expire);
+   cac_InitCacTime(&(info->min_pass_age), info1->min_passwordage);
+
+   info->server_role       = info2->server_role;
+   info->num_users         = info2->num_domain_usrs;
+   info->num_domain_groups = info2->num_domain_grps;
+   info->num_local_groups  = info2->num_local_grps;
+
+   /*if these have been ZERO'd out we need to know. uni_str_len will be 0*/
+   if(info2->uni_comment.uni_str_len == 0) {
+      info->comment = talloc_strdup(mem_ctx, "\0");
+   }
+   else {
+      info->comment = talloc_unistr2_to_ascii(mem_ctx, info2->uni_comment);
+   }
+
+   if(info2->uni_domain.uni_str_len == 0) {
+      info->domain_name = talloc_strdup(mem_ctx, "\0");
+   }
+   else {
+      info->domain_name = talloc_unistr2_to_ascii(mem_ctx, info2->uni_domain);
+   }
+
+   if(info2->uni_server.uni_str_len == 0) {
+      info->server_name = talloc_strdup(mem_ctx, "\0");
+   }
+   else {
+      info->server_name = talloc_unistr2_to_ascii(mem_ctx, info2->uni_server);
+   }
+
+
+   cac_InitCacTime(&(info->lockout_duration), info12->duration);
+   cac_InitCacTime(&(info->lockout_reset), info12->reset_count);
+   info->num_bad_attempts = info12->bad_attempt_lockout;
+
+   return info;
+}
+
+char *cac_unistr_ascii(TALLOC_CTX *mem_ctx, UNISTR src) {
+   char *buf;
+   uint32 len;
+
+   if(!mem_ctx || !src.buffer)
+      return NULL;
+
+   len = unistrlen(src.buffer) + 1;
+
+   buf = TALLOC_ZERO_ARRAY(mem_ctx, char, len);
+   if(!buf)
+      return NULL;
+
+   rpcstr_pull(buf, src.buffer, len, -1, STR_TERMINATE);
+
+   return buf;
+}
+
+CacService *cac_MakeServiceArray(TALLOC_CTX *mem_ctx, ENUM_SERVICES_STATUS *svc, uint32 num_services) {
+   int i;
+   CacService *services = NULL;
+
+   if(!mem_ctx || !svc)
+      return NULL;
+
+   services = TALLOC_ZERO_ARRAY(mem_ctx, CacService, num_services);
+   if(!services)
+      return NULL;
+
+   for(i = 0; i < num_services; i++) {
+      services[i].service_name = cac_unistr_ascii(mem_ctx, svc[i].servicename);
+      services[i].display_name = cac_unistr_ascii(mem_ctx, svc[i].displayname);
+
+      if(!services[i].service_name || !services[i].display_name)
+         return NULL;
+
+      services[i].status = svc[i].status;
+   }
+
+   return services;
+}
+
+int cac_InitCacServiceConfig(TALLOC_CTX *mem_ctx, SERVICE_CONFIG *src, CacServiceConfig *dest) {
+   if(!src || !dest)
+      return CAC_FAILURE;
+
+   dest->exe_path = talloc_unistr2_to_ascii(mem_ctx, *src->executablepath);
+   if(!dest->exe_path)
+      return CAC_FAILURE;
+
+   dest->load_order_group = talloc_unistr2_to_ascii(mem_ctx, *src->loadordergroup);
+   if(!dest->load_order_group)
+      return CAC_FAILURE;
+
+   dest->dependencies = talloc_unistr2_to_ascii(mem_ctx, *src->dependencies);
+   if(!dest->dependencies)
+      return CAC_FAILURE;
+
+   dest->start_name = talloc_unistr2_to_ascii(mem_ctx, *src->startname);
+   if(!dest->start_name)
+      return CAC_FAILURE;
+
+   dest->display_name = talloc_unistr2_to_ascii(mem_ctx, *src->displayname);
+   if(!dest->display_name)
+      return CAC_FAILURE;
+
+   dest->type = src->service_type;
+   dest->start_type = src->start_type;
+   dest->error_control = src->error_control;
+   dest->tag_id = src->tag_id;
+
+   return CAC_SUCCESS;
+}