Initial IBM OpenAFS 1.0 tree
[openafs.git] / src / WINNT / afsreg / afssw.c
1 /* Copyright (C) 1998 Transarc Corporation - All rights reserved.
2  *
3  */
4
5 #include <afs/param.h>
6 #include <afs/stds.h>
7
8 #include <windows.h>
9 #include <stdlib.h>
10 #include <stddef.h>
11 #include <string.h>
12 #include <errno.h>
13
14 #include <afs/errmap_nt.h>
15
16 #include "afsreg.h"
17 #include "afssw.h"
18
19 static int
20 StringDataRead(const char *keyName, const char *valueName, char **bufPP);
21
22 static int
23 StringDataWrite(const char *keyName, const char *valueName, const char *data);
24
25 static int
26 DwordDataRead(const char *keyName, const char *valueName, DWORD *data);
27
28
29
30 /* Functions for accessing AFS software configuration information. */
31
32 /*
33  * afssw_GetServerInstallDir() -- Get directory in which AFS server software is
34  *     installed.  Sets *bufPP to point to allocated buffer containing string.
35  *
36  * RETURN CODES: 0 success, -1 failed (errno set)
37  */
38 int
39 afssw_GetServerInstallDir(char **bufPP)  /* [out] data buffer */
40 {
41     return StringDataRead(AFSREG_SVR_SW_VERSION_KEY,
42                           AFSREG_SVR_SW_VERSION_DIR_VALUE,
43                           bufPP);
44 }
45
46
47 /*
48  * afssw_GetClientInstallDir() -- Get directory in which AFS client software is
49  *     installed.  Sets *bufPP to point to allocated buffer containing string.
50  *
51  * RETURN CODES: 0 success, -1 failed (errno set)
52  */
53 int
54 afssw_GetClientInstallDir(char **bufPP)   /* [out] data buffer */
55 {
56     return StringDataRead(AFSREG_CLT_SW_VERSION_KEY,
57                           AFSREG_CLT_SW_VERSION_DIR_VALUE,
58                           bufPP);
59 }
60
61
62 /*
63  * afssw_GetClientCellName() -- Get name of cell in which AFS client is
64  *     configured.  Sets *bufPP to point to allocated buffer containing string.
65  *
66  * RETURN CODES: 0 success, -1 failed (errno set)
67  */
68 int
69 afssw_GetClientCellName(char **bufPP)  /* [out] data buffer */
70 {
71     return StringDataRead(AFSREG_CLT_SVC_PARAM_KEY,
72                           AFSREG_CLT_SVC_PARAM_CELL_VALUE,
73                           bufPP);
74 }
75
76
77 /*
78  * afssw_SetClientCellName() -- Set name of cell in which AFS client is
79  *     configured.
80  *
81  * RETURN CODES: 0 success, -1 failed (errno set)
82  */
83 int
84 afssw_SetClientCellName(const char *cellName)
85 {
86     return StringDataWrite(AFSREG_CLT_SVC_PARAM_KEY,
87                            AFSREG_CLT_SVC_PARAM_CELL_VALUE,
88                            cellName);
89 }
90
91
92 /*
93  * afssw_GetServerVersion() -- Get version number of installed server.
94  *
95  * RETURN CODES: 0 success, -1 failed (errno set)
96  */
97 int
98 afssw_GetServerVersion(unsigned *major,  /* major version number */
99                        unsigned *minor,  /* minor version number */
100                        unsigned *patch)  /* patch level */
101 {
102     DWORD dwMajor, dwMinor, dwPatch;
103
104     if (DwordDataRead(AFSREG_SVR_SW_VERSION_KEY,
105                       AFSREG_SVR_SW_VERSION_MAJOR_VALUE,
106                       &dwMajor) ||
107
108         DwordDataRead(AFSREG_SVR_SW_VERSION_KEY,
109                       AFSREG_SVR_SW_VERSION_MINOR_VALUE,
110                       &dwMinor) ||
111
112         DwordDataRead(AFSREG_SVR_SW_VERSION_KEY,
113                       AFSREG_SVR_SW_VERSION_PATCH_VALUE,
114                       &dwPatch)) {
115         /* a read failed */
116         return -1;
117     } else {
118         /* return values */
119         *major = dwMajor;
120         *minor = dwMinor;
121         *patch = dwPatch;
122         return 0;
123     }
124 }
125
126
127 /*
128  * afssw_GetClientVersion() -- Get version number of installed client.
129  *
130  * RETURN CODES: 0 success, -1 failed (errno set)
131  */
132 int
133 afssw_GetClientVersion(unsigned *major,  /* major version number */
134                        unsigned *minor,  /* minor version number */
135                        unsigned *patch)  /* patch level */
136 {
137     DWORD dwMajor, dwMinor, dwPatch;
138
139     if (DwordDataRead(AFSREG_CLT_SW_VERSION_KEY,
140                       AFSREG_CLT_SW_VERSION_MAJOR_VALUE,
141                       &dwMajor) ||
142
143         DwordDataRead(AFSREG_CLT_SW_VERSION_KEY,
144                       AFSREG_CLT_SW_VERSION_MINOR_VALUE,
145                       &dwMinor) ||
146
147         DwordDataRead(AFSREG_CLT_SW_VERSION_KEY,
148                       AFSREG_CLT_SW_VERSION_PATCH_VALUE,
149                       &dwPatch)) {
150         /* a read failed */
151         return -1;
152     } else {
153         /* return values */
154         *major = dwMajor;
155         *minor = dwMinor;
156         *patch = dwPatch;
157         return 0;
158     }
159 }
160
161
162
163
164 /* ----------------------- local functions ------------------------- */
165
166 /*
167  * StringDataRead() -- read registry data of type REG_SZ and return in
168  *     allocated buffer.
169  *
170  * RETURN CODES: 0 success, -1 failed (errno set)
171  */
172 static int
173 StringDataRead(const char *keyName, const char *valueName, char **bufPP)
174 {
175     long status;
176     HKEY key;
177
178     if (bufPP == NULL) {
179         errno = EINVAL;
180         return -1;
181     }
182
183     status = RegOpenKeyAlt(AFSREG_NULL_KEY, keyName, KEY_READ, 0, &key, NULL);
184
185     if (status == ERROR_SUCCESS) {
186         DWORD dataType;
187         char *dataBuf = NULL;
188
189         status = RegQueryValueAlt(key, valueName, &dataType, &dataBuf, NULL);
190
191         if (status == ERROR_SUCCESS) {
192             if (dataType == REG_SZ) {
193                 *bufPP = dataBuf;
194             } else {
195                 /* invalid data type */
196                 free(dataBuf);
197                 status = ERROR_INVALID_DATA;
198             }
199         }
200         (void)RegCloseKey(key);
201     }
202
203     if (status) {
204         errno = nterr_nt2unix(status, EIO);
205         return -1;
206     }
207     return 0;
208 }
209
210
211 /*
212  * StringDataWrite() -- write registry data of type REG_SZ.
213  * 
214  * RETURN CODES: 0 success, -1 failed (errno set)
215  */
216 static int
217 StringDataWrite(const char *keyName, const char *valueName, const char *data)
218 {
219     long status;
220     HKEY key;
221
222     if (data == NULL) {
223         errno = EINVAL;
224         return -1;
225     }
226
227     status = RegOpenKeyAlt(AFSREG_NULL_KEY,
228                            keyName, KEY_WRITE, 1 /* create */, &key, NULL);
229
230     if (status == ERROR_SUCCESS) {
231         status = RegSetValueEx(key,
232                                valueName,
233                                0, REG_SZ, data, strlen(data) + 1);
234
235         (void)RegCloseKey(key);
236     }
237
238     if (status) {
239         errno = nterr_nt2unix(status, EIO);
240         return -1;
241     }
242     return 0;
243 }
244
245
246 /*
247  * DwordDataRead() -- read registry data of type REG_DWORD.
248  *
249  * RETURN CODES: 0 success, -1 failed (errno set)
250  */
251 static int
252 DwordDataRead(const char *keyName, const char *valueName, DWORD *data)
253 {
254     long status;
255     HKEY key;
256
257     status = RegOpenKeyAlt(AFSREG_NULL_KEY, keyName, KEY_READ, 0, &key, NULL);
258
259     if (status == ERROR_SUCCESS) {
260         DWORD dataType;
261         DWORD dataBuf;
262         DWORD dataSize = sizeof(DWORD);
263
264         status = RegQueryValueEx(key, valueName,
265                                  NULL, &dataType, (void *)&dataBuf, &dataSize);
266
267         if (status == ERROR_SUCCESS) {
268             if (dataType == REG_DWORD) {
269                 *data = dataBuf;
270             } else {
271                 /* invalid data type */
272                 status = ERROR_INVALID_DATA;
273             }
274         }
275         (void)RegCloseKey(key);
276     }
277
278     if (status) {
279         errno = nterr_nt2unix(status, EIO);
280         return -1;
281     }
282     return 0;
283 }