~ubuntu-branches/ubuntu/lucid/anytun/lucid

« back to all changes in this revision

Viewing changes to src/win32/registryKey.cpp

  • Committer: Bazaar Package Importer
  • Author(s): Michael Prokop
  • Date: 2009-12-14 02:08:25 UTC
  • Revision ID: james.westby@ubuntu.com-20091214020825-ntyi58y4wvsaglhi
Tags: upstream-0.3.2
ImportĀ upstreamĀ versionĀ 0.3.2

Show diffs side-by-side

added added

removed removed

Lines of Context:
 
1
/*
 
2
 *  anytun
 
3
 *
 
4
 *  The secure anycast tunneling protocol (satp) defines a protocol used
 
5
 *  for communication between any combination of unicast and anycast
 
6
 *  tunnel endpoints.  It has less protocol overhead than IPSec in Tunnel
 
7
 *  mode and allows tunneling of every ETHER TYPE protocol (e.g.
 
8
 *  ethernet, ip, arp ...). satp directly includes cryptography and
 
9
 *  message authentication based on the methodes used by SRTP.  It is
 
10
 *  intended to deliver a generic, scaleable and secure solution for
 
11
 *  tunneling and relaying of packets of any protocol.
 
12
 *
 
13
 *
 
14
 *  Copyright (C) 2007-2009 Othmar Gsenger, Erwin Nindl, 
 
15
 *                          Christian Pointner <satp@wirdorange.org>
 
16
 *
 
17
 *  This file is part of Anytun.
 
18
 *
 
19
 *  Anytun is free software: you can redistribute it and/or modify
 
20
 *  it under the terms of the GNU General Public License as published by
 
21
 *  the Free Software Foundation, either version 3 of the License, or
 
22
 *  any later version.
 
23
 *
 
24
 *  Anytun is distributed in the hope that it will be useful,
 
25
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 
26
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 
27
 *  GNU General Public License for more details.
 
28
 *
 
29
 *  You should have received a copy of the GNU General Public License
 
30
 *  along with anytun.  If not, see <http://www.gnu.org/licenses/>.
 
31
 */
 
32
 
 
33
#include <string.h>
 
34
#include <sstream>
 
35
#include <windows.h>
 
36
 
 
37
#include "registryKey.h"
 
38
 
 
39
#include "../anytunError.h"
 
40
 
 
41
RegistryKey::RegistryKey() : opened_(false)
 
42
{
 
43
}
 
44
 
 
45
RegistryKey::RegistryKey(HKEY hkey, std::string subKey, REGSAM samDesired) : opened_(false)
 
46
{
 
47
  open(hkey, subKey, samDesired);
 
48
}
 
49
 
 
50
RegistryKey::~RegistryKey()
 
51
{
 
52
  close();
 
53
}
 
54
 
 
55
bool RegistryKey::isOpen() const
 
56
{
 
57
  return opened_;
 
58
}
 
59
 
 
60
std::string RegistryKey::getName() const
 
61
{
 
62
  return name_;
 
63
}
 
64
 
 
65
DWORD RegistryKey::open(HKEY hkey, std::string subKey, REGSAM samDesired)
 
66
{
 
67
  if(opened_)
 
68
    RegCloseKey(key_);
 
69
 
 
70
  opened_ = false;
 
71
  name_ = "";
 
72
  LONG err = RegOpenKeyExA(hkey, subKey.c_str(), 0, samDesired, &key_);
 
73
  if(err != ERROR_SUCCESS)
 
74
    return err;
 
75
 
 
76
  name_ = subKey;
 
77
  opened_ = true;
 
78
  return ERROR_SUCCESS;
 
79
}
 
80
 
 
81
void RegistryKey::close()
 
82
{
 
83
  if(opened_)
 
84
    RegCloseKey(key_);
 
85
  opened_ = false;
 
86
}
 
87
 
 
88
std::string RegistryKey::operator[](std::string const& name) const
 
89
{
 
90
  if(!opened_)
 
91
    throw AnytunErrno(ERROR_INVALID_HANDLE);
 
92
 
 
93
  char value[STRING_VALUE_LENGTH];
 
94
  DWORD len = sizeof(value);
 
95
  LONG err = RegQueryValueExA(key_, name.c_str(), NULL, NULL, (LPBYTE)value, &len);
 
96
  if(err != ERROR_SUCCESS)
 
97
    throw AnytunErrno(err);
 
98
 
 
99
  if(value[len-1] != 0) {
 
100
    if(len < sizeof(value))
 
101
      value[len++] = 0;
 
102
    else
 
103
      throw AnytunErrno(ERROR_INSUFFICIENT_BUFFER);
 
104
  }  
 
105
  return std::string(value);
 
106
}
 
107
 
 
108
DWORD RegistryKey::getSubKey(DWORD index, RegistryKey& subKey, REGSAM sam) const
 
109
{
 
110
  char subkeyname[NAME_LENGTH];
 
111
  DWORD len = sizeof(subkeyname);
 
112
  DWORD err = RegEnumKeyExA(key_, index, subkeyname, &len, NULL, NULL, NULL, NULL);
 
113
  if(err != ERROR_SUCCESS)
 
114
    return err;
 
115
 
 
116
  return subKey.open(key_, subkeyname, sam);
 
117
}
 
118
 
 
119
DWORD RegistryKey::getSubKey(std::string name, RegistryKey& subKey, REGSAM sam) const
 
120
{
 
121
  return subKey.open(key_, name.c_str(), sam);
 
122
}