← Back to branch summary

~zulcss/ubuntu/lucid/likewise-open/likewise-open-sru

« back to all changes in this revision

Viewing changes to domainjoin/domainjoin-gui/carbon/DomainJoin/DomainJoinInterface.cp

  • Committer: Bazaar Package Importer
  • Author(s): Rick Clark
  • Date: 2008-08-27 08:56:20 UTC
  • mfrom: (1.1.2 upstream)
  • Revision ID: james.westby@ubuntu.com-20080827085620-5q0f58b9qtog9myq
Tags: 4.1.0.2956-0ubuntu1
* missing-likewise-logo.diff: removed
* fixed copyright notice
* updated Standards-Version to 3.8.0
* removed path from command in prerm
* removed stop in S runlevel

Show diffs side-by-side

added added

removed removed

Lines of Context:
domainjoin/domainjoin-gui/carbon/DomainJoin/DomainJoinInterface.cp
 
1
/*
 
2
 *  DomainJoinInterface.cpp
 
3
 *  DomainJoin
 
4
 *
 
5
 *  Created by Sriram Nambakam on 8/7/07.
 
6
 *  Copyright 2007 Centeris Corporation. All rights reserved.
 
7
 *
 
8
 */
 
9
 
 
10
#include "DomainJoinInterface.h"
 
11
 
 
12
DomainJoinInterface* DomainJoinInterface::_instance = NULL;
 
13
 
 
14
DomainJoinInterface::DomainJoinInterface()
 
15
: _libHandle(NULL),
 
16
  _pDJApiFunctionTable(NULL),
 
17
  _pfnShutdownJoinInterface(NULL)
 
18
{
 
19
}
 
20
 
 
21
DomainJoinInterface::~DomainJoinInterface()
 
22
{
 
23
    Cleanup();
 
24
}
 
25
 
 
26
DomainJoinInterface&
 
27
DomainJoinInterface::getInstance()
 
28
{
 
29
    if (_instance == NULL)
 
30
    {
 
31
       _instance = new DomainJoinInterface();
 
32
       _instance->Initialize();
 
33
    }
 
34
    
 
35
    return *_instance;
 
36
}
 
37
 
 
38
void
 
39
DomainJoinInterface::Initialize()
 
40
{
 
41
    const char* LIBDOMAINJOIN = "/opt/centeris/lib/libdomainjoin-mac.so";
 
42
    std::string szShortError = "Failed to load domain join interface";
 
43
    void* pLibHandle = NULL;
 
44
    PFNInitJoinInterface     pfnInitJoinInterface = NULL;
 
45
    PFNShutdownJoinInterface pfnShutdownJoinInterface = NULL;
 
46
    PDJ_API_FUNCTION_TABLE   pFunctionTable = NULL;
 
47
 
 
48
    try
 
49
    {
 
50
        dlerror();
 
51
        pLibHandle = dlopen(LIBDOMAINJOIN, RTLD_LAZY);
 
52
        if (!pLibHandle)
 
53
        {
 
54
           std::string errMsg = dlerror();
 
55
           throw DomainJoinException(-1,
 
56
                                     szShortError,
 
57
                                     errMsg);
 
58
        }
 
59
    
 
60
        LoadFunction(pLibHandle, DJ_INITIALIZE_JOIN_INTERFACE, (void**)&pfnInitJoinInterface);
 
61
    
 
62
        if (pfnInitJoinInterface(&pFunctionTable)) {
 
63
 
 
64
           throw DomainJoinException(-1,
 
65
                                     szShortError,
 
66
                                     "Failed to initialize domain join interface");
 
67
 
 
68
        } else if ( !pFunctionTable->pfnJoinDomain ||
 
69
                    !pFunctionTable->pfnLeaveDomain ||
 
70
                    !pFunctionTable->pfnSetComputerName ||
 
71
                    !pFunctionTable->pfnQueryInformation ||
 
72
                    !pFunctionTable->pfnIsDomainNameResolvable ||
 
73
                    !pFunctionTable->pfnFreeDomainJoinInfo ||
 
74
                    !pFunctionTable->pfnFreeDomainJoinError ) {
 
75
            throw DomainJoinException(-1,
 
76
                                      szShortError,
 
77
                                      "The domain join interface is invalid");
 
78
        }
 
79
       
 
80
        LoadFunction(pLibHandle, DJ_SHUTDOWN_JOIN_INTERFACE, (void**)&pfnShutdownJoinInterface);
 
81
 
 
82
        Cleanup();
 
83
 
 
84
        _libHandle = pLibHandle;
 
85
        _pDJApiFunctionTable = pFunctionTable;
 
86
        _pfnShutdownJoinInterface = pfnShutdownJoinInterface;
 
87
    }
 
88
    catch(std::exception& e)
 
89
    {
 
90
         if (pLibHandle) {
 
91
            if (pfnShutdownJoinInterface &&
 
92
                pFunctionTable)
 
93
            {
 
94
               pfnShutdownJoinInterface(pFunctionTable);
 
95
            }
 
96
            dlclose(pLibHandle);
 
97
         }
 
98
         throw;
 
99
    }
 
100
}
 
101
 
 
102
void
 
103
DomainJoinInterface::Cleanup()
 
104
{
 
105
  if (_libHandle)
 
106
  {
 
107
      if (_pfnShutdownJoinInterface) {
 
108
          _pfnShutdownJoinInterface(_pDJApiFunctionTable);
 
109
      }
 
110
  
 
111
      dlclose(_libHandle);
 
112
      _libHandle = NULL;
 
113
      
 
114
      _pfnShutdownJoinInterface = NULL;
 
115
      _pDJApiFunctionTable = NULL;
 
116
  }
 
117
}
 
118
 
 
119
void
 
120
DomainJoinInterface::LoadFunction(
 
121
        void*       pLibHandle,
 
122
        const char* pszFunctionName,
 
123
        void**      functionPointer
 
124
        )
 
125
{
 
126
    void* function;
 
127
    
 
128
    dlerror();
 
129
    
 
130
    function = dlsym(pLibHandle, pszFunctionName);
 
131
    if (!function)
 
132
    {
 
133
       std::string errMsg = dlerror();
 
134
       throw DomainJoinException(-1,
 
135
                                 "Failed to load symbol",
 
136
                                 errMsg);
 
137
    }
 
138
    
 
139
    *functionPointer = function;
 
140
}
 
141
 
 
142
void
 
143
DomainJoinInterface::JoinDomain(std::string& pszDomainName,
 
144
                                std::string& pszUserName,
 
145
                                std::string& pszPassword,
 
146
                                std::string& pszOU,
 
147
                                bool bNoHosts)
 
148
{
 
149
     PDOMAIN_JOIN_ERROR pError = NULL;
 
150
     
 
151
     int errCode = getInstance()._pDJApiFunctionTable->pfnJoinDomain(
 
152
                                    const_cast<char*>(pszDomainName.c_str()),
 
153
                                    const_cast<char*>(pszOU.c_str()),
 
154
                                    const_cast<char*>(pszUserName.c_str()), 
 
155
                                    const_cast<char*>(pszPassword.c_str()), 
 
156
                                    bNoHosts,
 
157
                                    &pError);
 
158
    if (pError) {
 
159
       DomainJoinException exc(pError->code,
 
160
                               pError->pszShortError,
 
161
                               pError->pszLongError);
 
162
       
 
163
       getInstance()._pDJApiFunctionTable->pfnFreeDomainJoinError(pError);
 
164
     
 
165
       throw exc;  
 
166
    }
 
167
    
 
168
    if (errCode) {
 
169
       DomainJoinException exc(errCode, "Domain Join Error", "Failed to join domain");
 
170
       throw exc;
 
171
    }
 
172
}
 
173
                                        
 
174
void
 
175
DomainJoinInterface::LeaveDomain()
 
176
{
 
177
    PDOMAIN_JOIN_ERROR pError = NULL;
 
178
     
 
179
    int errCode = getInstance()._pDJApiFunctionTable->pfnLeaveDomain(
 
180
                                    NULL,
 
181
                                    NULL,
 
182
                                    &pError);
 
183
    if (pError) {
 
184
       DomainJoinException exc(pError->code,
 
185
                               pError->pszShortError,
 
186
                               pError->pszLongError);
 
187
       
 
188
       getInstance()._pDJApiFunctionTable->pfnFreeDomainJoinError(pError);
 
189
     
 
190
       throw exc;  
 
191
    }
 
192
    
 
193
    if (errCode) {
 
194
       DomainJoinException exc(-1, "Domain Join Error", "Failed to leave domain");
 
195
       throw exc;
 
196
    }
 
197
}
 
198
 
 
199
bool
 
200
DomainJoinInterface::IsDomainNameResolvable(const std::string& domainName)
 
201
{
 
202
    PDOMAIN_JOIN_ERROR pError = NULL;
 
203
    short bResolvable = 0;
 
204
     
 
205
    int errCode = getInstance()._pDJApiFunctionTable->pfnIsDomainNameResolvable(
 
206
                                    const_cast<char*>(domainName.c_str()),
 
207
                                    &bResolvable,
 
208
                                    &pError);
 
209
                                    
 
210
    if (pError) {
 
211
       DomainJoinException exc(pError->code,
 
212
                               pError->pszShortError,
 
213
                               pError->pszLongError);
 
214
       
 
215
       getInstance()._pDJApiFunctionTable->pfnFreeDomainJoinError(pError);
 
216
     
 
217
       throw exc;  
 
218
    }
 
219
    
 
220
    if (errCode) {
 
221
       DomainJoinException exc(errCode, "Domain Join Error", "Failed to determine if domain name is resolvable through DNS");
 
222
       throw exc;
 
223
    }
 
224
    
 
225
    return bResolvable;
 
226
}
 
227
        
 
228
void
 
229
DomainJoinInterface::SetComputerName(std::string& pszComputerName,
 
230
                                     std::string& pszDomainName)
 
231
{
 
232
    PDOMAIN_JOIN_ERROR pError = NULL;
 
233
 
 
234
    int errCode = getInstance()._pDJApiFunctionTable->pfnSetComputerName(
 
235
                                    const_cast<char*>(pszComputerName.c_str()),
 
236
                                    const_cast<char*>(pszDomainName.c_str()),
 
237
                                    &pError);
 
238
                                    
 
239
    if (pError) {
 
240
       DomainJoinException exc(pError->code,
 
241
                               pError->pszShortError,
 
242
                               pError->pszLongError);
 
243
       
 
244
       getInstance()._pDJApiFunctionTable->pfnFreeDomainJoinError(pError);
 
245
     
 
246
       throw exc;  
 
247
    }
 
248
    
 
249
    if (errCode) {
 
250
       DomainJoinException exc(errCode, "Domain Join Error", "Failed to set the computer name");
 
251
       throw exc;
 
252
    }
 
253
}
 
254
 
 
255
void
 
256
DomainJoinInterface::GetDomainJoinStatus(DomainJoinStatus& joinStatus)
 
257
{
 
258
    PDOMAIN_JOIN_INFO pInfo = NULL;
 
259
    PDOMAIN_JOIN_ERROR pError = NULL;
 
260
 
 
261
    int errCode = getInstance()._pDJApiFunctionTable->pfnQueryInformation(
 
262
                                    &pInfo,
 
263
                                    &pError);
 
264
                                    
 
265
    if (pError) {
 
266
       DomainJoinException exc(pError->code,
 
267
                               pError->pszShortError,
 
268
                               pError->pszLongError);
 
269
       
 
270
       getInstance()._pDJApiFunctionTable->pfnFreeDomainJoinError(pError);
 
271
     
 
272
       throw exc;  
 
273
    }
 
274
    
 
275
    if (errCode) {
 
276
       DomainJoinException exc(errCode, "Domain Join Error", "Failed to query domain join status");
 
277
       throw exc;
 
278
    }
 
279
    
 
280
    joinStatus.Name = (pInfo->pszName ? pInfo->pszName : "");
 
281
    joinStatus.DnsDomain = (pInfo->pszDnsDomain ? pInfo->pszDnsDomain : "");
 
282
    joinStatus.DomainName = (pInfo->pszDomainName ? pInfo->pszDomainName : "");
 
283
    joinStatus.ShortDomainName = (pInfo->pszDomainShortName ? pInfo->pszDomainShortName : "");
 
284
    joinStatus.LogFilePath = (pInfo->pszLogFilePath ? pInfo->pszLogFilePath : "");
 
285
    
 
286
    getInstance()._pDJApiFunctionTable->pfnFreeDomainJoinInfo(pInfo);
 
287
}