text: /*
   * Copyright (c) 1997 Cygnus Solutions
   *
   * Author:  Michael Graff
   */
  
  #include <windows.h>
  #include <assert.h>
  #include <stdio.h>
  #include <string.h>
  
  #include "cns.h"
  #include "cns_reg.h"
  
  #include "../lib/registry.h"
  
  cns_reg_t cns_res;  /* yes, a global.  Sue me. */
  
  /*
   * function to load all the data we will want from the registry.  If the
   * registry data cannot be found this function will initialize a default
   * environment.
   */
  void
  cns_load_registry(void)
  {
    char    tmp[1024];
    DWORD   tdw;
    char   *ts;
    HKEY    key;
    int     i;
  
    /*
     * Set up reasonable default values.  These will all be overwritten if
     * the registry is successfully opened.
     */
    cns_res.name[0] = '\0';
    cns_res.realm[0] = '\0';
    cns_res.x = 0;
    cns_res.y = 0;
    cns_res.cx = 0;
    cns_res.cy = 0;
  
    cns_res.alert = 0;
    cns_res.beep = 0;
    cns_res.lifetime = DEFAULT_TKT_LIFE * 5;
    cns_res.forwardable = 1;
    cns_res.noaddresses = 0;
  
    for (i = 1 ; i < FILE_MENU_MAX_LOGINS ; i++)
      cns_res.logins[i][0] = '\0';
  
    /*
     * by default, allow the user to override the config file location and NOT the
     * cred cache name.
     */
    cns_res.conf_override = 1;
    cns_res.cc_override = 0;
  
    {
  	char *s;
  	s = krb5_cc_default_name(k5_context);
  
  	strcpy(cns_res.def_ccname, s);
    }
  
    cns_res.def_confname[0] = '\0';
  
    /*
     * If the system has these keys in the registry, do not allow the user to
     * override the config file and ccache locations.
     */
    key = registry_open(HKEY_LOCAL_MACHINE, KERBNET_BASE, KEY_READ);
    if (key != INVALID_HANDLE_VALUE) {
  	if (registry_string_get(key, KERBNET_HOME, &ts) == 0) {
  		cns_res.conf_override = 0;
  		cns_res.def_confname[sizeof(cns_res.def_confname) - 1];
  		strncpy(cns_res.def_confname, ts,
  		        sizeof(cns_res.def_confname) - 1);
  		strncat(cns_res.def_confname, "\\etc\\krb5.conf",
  			sizeof(cns_res.def_confname) - 1 -
  			strlen(cns_res.def_confname));
  		free(ts);
  	  }
  
  	  if (registry_string_get(key, "ccname", &ts) == 0) {
  		cns_res.cc_override = 0;
  		strcpy(cns_res.def_ccname, ts);
  		free(ts);
  	  }
    }
  
    /*
     * Try to open the registry.  If we succeed, read the last used values from there.  If we
     * do not get the registry open simply return.
     */
    key = registry_open(HKEY_CURRENT_USER, KERBNET_CNS_BASE, KEY_ALL_ACCESS);
  
    if (key == INVALID_HANDLE_VALUE)
  	return;
  
    if (registry_dword_get(key, "x", &tdw) == 0)
  	  cns_res.x = tdw;
  
    if (registry_dword_get(key, "y", &tdw) == 0)
  	  cns_res.y = tdw;
  
    if (registry_dword_get(key, "cx", &tdw) == 0)
  	  cns_res.cx = tdw;
  
    if (registry_dword_get(key, "cy", &tdw) == 0)
  	  cns_res.cy = tdw;
  
    if (registry_dword_get(key, "lifetime", &tdw) == 0)
  	  cns_res.lifetime = tdw;
  
    if (registry_dword_get(key, "forwardable", &tdw) == 0)
  	  cns_res.forwardable = tdw;
  
    if (registry_dword_get(key, "noaddresses", &tdw) == 0)
     	  cns_res.noaddresses = tdw;
  
    if (registry_dword_get(key, "alert", &tdw) == 0)
  	  cns_res.alert = tdw;
  
    if (registry_dword_get(key, "beep", &tdw) == 0)
  	  cns_res.beep = tdw;
  
    if (registry_string_get(key, "name", &ts) == 0) {
  	strcpy(cns_res.name, ts);
  	free(ts);
    }
  
    if (registry_string_get(key, "realm", &ts) == 0) {
  	strcpy(cns_res.realm, ts);
  	free(ts);
    }
  
    if (cns_res.conf_override && (registry_string_get(key, "confname", &ts) == 0)) {
  	strcpy(cns_res.confname, ts);
  	free(ts);
    } else
  	  strcpy(cns_res.confname, cns_res.def_confname);
  
    if (cns_res.cc_override && (registry_string_get(key, "ccname", &ts) == 0)) {
  	strcpy(cns_res.ccname, ts);
  	free(ts);
    } else
  	  strcpy(cns_res.ccname, cns_res.def_ccname);
  
    for (i = 0 ; i < FILE_MENU_MAX_LOGINS ; i++) {
      sprintf(tmp, "login_%02d", i);
      if (registry_string_get(key, tmp, &ts) == 0) {
        strcpy(cns_res.logins[i], ts);
        free(ts);
      }
    }
  
    registry_close(key);
  }
  
  /*
   * save all the registry data, creating the keys if needed.
   */
  void
  cns_save_registry(void)
  {
    char    tmp[1024];
    HKEY    key;
    int     i;
  
    /*
     * First, create the heirachy...  This is gross, but functional
     */
    key = registry_key_create(HKEY_CURRENT_USER, CYGNUS_SOLUTIONS, KEY_WRITE);
    if (key == INVALID_HANDLE_VALUE)
  	  return;
  
    key = registry_key_create(HKEY_CURRENT_USER, KERBNET_SANS_VERSION, KEY_WRITE);
    if (key == INVALID_HANDLE_VALUE)
  	  return;
    registry_close(key);
  
    key = registry_key_create(HKEY_CURRENT_USER, KERBNET_BASE, KEY_WRITE);
    if (key == INVALID_HANDLE_VALUE)
  	  return;
    registry_close(key);
  
    key = registry_key_create(HKEY_CURRENT_USER, KERBNET_CNS_BASE, KEY_WRITE);
    if (key == INVALID_HANDLE_VALUE)
  	return;
  
    registry_dword_set(key, "x", cns_res.x);
    registry_dword_set(key, "y", cns_res.y);
    registry_dword_set(key, "cx", cns_res.cx);
    registry_dword_set(key, "cy", cns_res.cy);
  
    registry_dword_set(key, "alert", cns_res.alert);
    registry_dword_set(key, "beep", cns_res.beep);
    registry_dword_set(key, "lifetime", cns_res.lifetime);
    registry_dword_set(key, "forwardable", cns_res.forwardable);
    registry_dword_set(key, "noaddresses", cns_res.noaddresses);
  
    registry_string_set(key, "name", cns_res.name);
    registry_string_set(key, "realm", cns_res.realm);
  
    if (cns_res.conf_override)
    {
        if (strcmp(cns_res.confname, cns_res.def_confname))
  	  registry_string_set(key, "confname", cns_res.confname);
        else
  	  registry_value_delete(key, "confname");
    }
  
    if (cns_res.cc_override)
    {
        if (strcmp(cns_res.ccname, cns_res.def_ccname))
  	  registry_string_set(key, "ccname", cns_res.ccname);
        else
  	  registry_value_delete(key, "ccname");
    }
  
    for (i = 0 ; i < FILE_MENU_MAX_LOGINS ; i++)
      if (cns_res.logins[i][0] != '\0') {
        sprintf(tmp, "login_%02d", i);
        registry_string_set(key, tmp, cns_res.logins[i]);
      }
  
    registry_close(key);
  }
  