35 /* |
35 /* |
36 * Declare library specific JNI_Onload entry if static build |
36 * Declare library specific JNI_Onload entry if static build |
37 */ |
37 */ |
38 DEF_STATIC_JNI_OnLoad |
38 DEF_STATIC_JNI_OnLoad |
39 |
39 |
40 JNIEXPORT jintArray JNICALL Java_java_util_prefs_WindowsPreferences_WindowsRegOpenKey |
40 JNIEXPORT jlongArray JNICALL |
41 (JNIEnv* env, jclass this_class, jint hKey, jbyteArray lpSubKey, jint securityMask) { |
41 Java_java_util_prefs_WindowsPreferences_WindowsRegOpenKey(JNIEnv* env, |
42 HKEY handle; |
42 jclass this_class, jlong hKey, jbyteArray lpSubKey, jint securityMask) { |
43 char* str; |
43 char* str = (*env)->GetByteArrayElements(env, lpSubKey, NULL); |
44 int tmp[2]; |
44 CHECK_NULL_RETURN(str, NULL); |
45 int errorCode=-1; |
45 |
46 jintArray result; |
46 HKEY handle; |
47 str = (*env)->GetByteArrayElements(env, lpSubKey, NULL); |
47 int errorCode = RegOpenKeyEx((HKEY) hKey, str, 0, securityMask, &handle); |
48 CHECK_NULL_RETURN(str, NULL); |
48 (*env)->ReleaseByteArrayElements(env, lpSubKey, str, 0); |
49 errorCode = RegOpenKeyEx((HKEY)hKey, str, 0, securityMask, &handle); |
49 |
50 (*env)->ReleaseByteArrayElements(env, lpSubKey, str, 0); |
50 jlong tmp[2]; |
51 tmp[0]= (int) handle; |
51 tmp[0] = (jlong) handle; |
52 tmp[1]= errorCode; |
52 tmp[1] = errorCode; |
53 result = (*env)->NewIntArray(env,2); |
53 jlongArray result = (*env)->NewLongArray(env, 2); |
54 if (result != NULL) { |
54 if (result != NULL) { |
55 (*env)->SetIntArrayRegion(env, result, 0, 2, tmp); |
55 (*env)->SetLongArrayRegion(env, result, 0, 2, tmp); |
56 } |
56 } |
57 return result; |
57 return result; |
58 } |
58 } |
59 |
59 |
60 JNIEXPORT jint JNICALL Java_java_util_prefs_WindowsPreferences_WindowsRegCloseKey |
60 JNIEXPORT jint JNICALL |
61 (JNIEnv* env, jclass this_class, jint hKey) { |
61 Java_java_util_prefs_WindowsPreferences_WindowsRegCloseKey(JNIEnv* env, |
62 return (jint) RegCloseKey((HKEY) hKey); |
62 jclass this_class, jlong hKey) { |
63 }; |
63 return (jint) RegCloseKey((HKEY) hKey); |
64 |
64 }; |
65 JNIEXPORT jintArray JNICALL Java_java_util_prefs_WindowsPreferences_WindowsRegCreateKeyEx |
65 |
66 (JNIEnv* env, jclass this_class, jint hKey, jbyteArray lpSubKey) { |
66 JNIEXPORT jlongArray JNICALL |
67 HKEY handle; |
67 Java_java_util_prefs_WindowsPreferences_WindowsRegCreateKeyEx(JNIEnv* env, |
68 char* str; |
68 jclass this_class, jlong hKey, jbyteArray lpSubKey) { |
69 int tmp[3]; |
69 char* str = (*env)->GetByteArrayElements(env, lpSubKey, NULL); |
70 DWORD lpdwDisposition; |
70 CHECK_NULL_RETURN(str, NULL); |
71 int errorCode; |
71 |
72 jintArray result = NULL; |
72 HKEY handle; |
73 str = (*env)->GetByteArrayElements(env, lpSubKey, NULL); |
73 DWORD lpdwDisposition; |
74 CHECK_NULL_RETURN(str, NULL); |
74 int errorCode = RegCreateKeyEx((HKEY) hKey, str, 0, NULL, |
75 errorCode = RegCreateKeyEx((HKEY)hKey, str, 0, NULL, |
75 REG_OPTION_NON_VOLATILE, KEY_READ, |
76 REG_OPTION_NON_VOLATILE, KEY_READ, |
76 NULL, &handle, &lpdwDisposition); |
77 NULL, &handle, &lpdwDisposition); |
77 (*env)->ReleaseByteArrayElements(env, lpSubKey, str, 0); |
78 (*env)->ReleaseByteArrayElements(env, lpSubKey, str, 0); |
78 |
79 tmp[0]= (int) handle; |
79 jlong tmp[3]; |
80 tmp[1]= errorCode; |
80 tmp[0] = (jlong) handle; |
81 tmp[2]= lpdwDisposition; |
81 tmp[1] = errorCode; |
82 result = (*env)->NewIntArray(env,3); |
82 tmp[2] = lpdwDisposition; |
83 if (result != NULL) { |
83 jlongArray result = (*env)->NewLongArray(env, 3); |
84 (*env)->SetIntArrayRegion(env, result, 0, 3, tmp); |
84 if (result != NULL) { |
85 } |
85 (*env)->SetLongArrayRegion(env, result, 0, 3, tmp); |
86 return result; |
86 } |
87 } |
87 return result; |
88 |
88 } |
89 JNIEXPORT jint JNICALL Java_java_util_prefs_WindowsPreferences_WindowsRegDeleteKey |
89 |
90 (JNIEnv* env, jclass this_class, jint hKey, jbyteArray lpSubKey) { |
90 JNIEXPORT jint JNICALL |
91 char* str; |
91 Java_java_util_prefs_WindowsPreferences_WindowsRegDeleteKey(JNIEnv* env, |
92 int result; |
92 jclass this_class, jlong hKey, jbyteArray lpSubKey) { |
93 str = (*env)->GetByteArrayElements(env, lpSubKey, NULL); |
93 char* str = (*env)->GetByteArrayElements(env, lpSubKey, NULL); |
94 CHECK_NULL_RETURN(str, -1); |
94 CHECK_NULL_RETURN(str, -1); |
95 result = RegDeleteKey((HKEY)hKey, str); |
95 |
96 (*env)->ReleaseByteArrayElements(env, lpSubKey, str, 0); |
96 int result = RegDeleteKey((HKEY) hKey, str); |
97 return result; |
97 (*env)->ReleaseByteArrayElements(env, lpSubKey, str, 0); |
98 |
98 return result; |
99 }; |
99 |
100 |
100 }; |
101 JNIEXPORT jint JNICALL Java_java_util_prefs_WindowsPreferences_WindowsRegFlushKey |
101 |
102 (JNIEnv* env, jclass this_class, jint hKey) { |
102 JNIEXPORT jint JNICALL |
103 return RegFlushKey ((HKEY)hKey); |
103 Java_java_util_prefs_WindowsPreferences_WindowsRegFlushKey(JNIEnv* env, |
104 } |
104 jclass this_class, jlong hKey) { |
105 |
105 return RegFlushKey((HKEY) hKey); |
106 JNIEXPORT jbyteArray JNICALL Java_java_util_prefs_WindowsPreferences_WindowsRegQueryValueEx |
106 } |
107 (JNIEnv* env, jclass this_class, jint hKey, jbyteArray valueName) { |
107 |
108 char* valueNameStr; |
108 JNIEXPORT jbyteArray JNICALL |
109 char* buffer; |
109 Java_java_util_prefs_WindowsPreferences_WindowsRegQueryValueEx(JNIEnv* env, |
110 jbyteArray result; |
110 jclass this_class, jlong hKey, jbyteArray valueName) { |
111 DWORD valueType; |
111 char* valueNameStr = (*env)->GetByteArrayElements(env, valueName, NULL); |
112 DWORD valueSize; |
112 CHECK_NULL_RETURN(valueNameStr, NULL); |
113 valueNameStr = (*env)->GetByteArrayElements(env, valueName, NULL); |
113 |
114 CHECK_NULL_RETURN(valueNameStr, NULL); |
114 DWORD valueType; |
115 if (RegQueryValueEx((HKEY)hKey, valueNameStr, NULL, &valueType, NULL, |
115 DWORD valueSize; |
116 &valueSize) != ERROR_SUCCESS) { |
116 if (RegQueryValueEx((HKEY) hKey, valueNameStr, NULL, &valueType, NULL, |
|
117 &valueSize) != ERROR_SUCCESS) { |
117 (*env)->ReleaseByteArrayElements(env, valueName, valueNameStr, 0); |
118 (*env)->ReleaseByteArrayElements(env, valueName, valueNameStr, 0); |
118 return NULL; |
119 return NULL; |
119 } |
120 } |
120 |
121 |
121 buffer = (char*)malloc(valueSize); |
122 char* buffer = (char*) malloc(valueSize); |
122 if (buffer != NULL) { |
123 if (buffer != NULL) { |
123 if (RegQueryValueEx((HKEY)hKey, valueNameStr, NULL, &valueType, buffer, |
124 if (RegQueryValueEx((HKEY) hKey, valueNameStr, NULL, &valueType, buffer, |
124 &valueSize) != ERROR_SUCCESS) { |
125 &valueSize) != ERROR_SUCCESS) { |
125 free(buffer); |
126 free(buffer); |
126 (*env)->ReleaseByteArrayElements(env, valueName, valueNameStr, 0); |
|
127 return NULL; |
|
128 } |
|
129 } else { |
|
130 JNU_ThrowOutOfMemoryError(env, "native memory allocation failed"); |
|
131 (*env)->ReleaseByteArrayElements(env, valueName, valueNameStr, 0); |
127 (*env)->ReleaseByteArrayElements(env, valueName, valueNameStr, 0); |
132 return NULL; |
128 return NULL; |
133 } |
129 } |
134 |
130 } else { |
135 if (valueType == REG_SZ) { |
131 JNU_ThrowOutOfMemoryError(env, "native memory allocation failed"); |
136 result = (*env)->NewByteArray(env, valueSize); |
132 (*env)->ReleaseByteArrayElements(env, valueName, valueNameStr, 0); |
137 if (result != NULL) { |
133 return NULL; |
138 (*env)->SetByteArrayRegion(env, result, 0, valueSize, buffer); |
134 } |
139 } |
135 |
140 } else { |
136 jbyteArray result; |
141 result = NULL; |
137 if (valueType == REG_SZ) { |
|
138 result = (*env)->NewByteArray(env, valueSize); |
|
139 if (result != NULL) { |
|
140 (*env)->SetByteArrayRegion(env, result, 0, valueSize, buffer); |
142 } |
141 } |
|
142 } else { |
|
143 result = NULL; |
|
144 } |
|
145 free(buffer); |
|
146 (*env)->ReleaseByteArrayElements(env, valueName, valueNameStr, 0); |
|
147 return result; |
|
148 } |
|
149 |
|
150 JNIEXPORT jint JNICALL |
|
151 Java_java_util_prefs_WindowsPreferences_WindowsRegSetValueEx(JNIEnv* env, |
|
152 jclass this_class, jlong hKey, jbyteArray valueName, jbyteArray data) { |
|
153 if ((valueName == NULL) || (data == NULL)) { |
|
154 return -1; |
|
155 } |
|
156 int size = (*env)->GetArrayLength(env, data); |
|
157 char* dataStr = (*env)->GetByteArrayElements(env, data, NULL); |
|
158 CHECK_NULL_RETURN(dataStr, -1); |
|
159 |
|
160 char* valueNameStr = (*env)->GetByteArrayElements(env, valueName, NULL); |
|
161 int error_code = -1; |
|
162 if (valueNameStr != NULL) { |
|
163 error_code = RegSetValueEx((HKEY) hKey, valueNameStr, 0, |
|
164 REG_SZ, dataStr, size); |
|
165 (*env)->ReleaseByteArrayElements(env, valueName, valueNameStr, 0); |
|
166 } |
|
167 (*env)->ReleaseByteArrayElements(env, data, dataStr, 0); |
|
168 return error_code; |
|
169 } |
|
170 |
|
171 JNIEXPORT jint JNICALL |
|
172 Java_java_util_prefs_WindowsPreferences_WindowsRegDeleteValue(JNIEnv* env, |
|
173 jclass this_class, jlong hKey, jbyteArray valueName) { |
|
174 if (valueName == NULL) { |
|
175 return -1; |
|
176 } |
|
177 char* valueNameStr = (*env)->GetByteArrayElements(env, valueName, NULL); |
|
178 CHECK_NULL_RETURN(valueNameStr, -1); |
|
179 |
|
180 int error_code = RegDeleteValue((HKEY) hKey, valueNameStr); |
|
181 (*env)->ReleaseByteArrayElements(env, valueName, valueNameStr, 0); |
|
182 return error_code; |
|
183 } |
|
184 |
|
185 JNIEXPORT jlongArray JNICALL |
|
186 Java_java_util_prefs_WindowsPreferences_WindowsRegQueryInfoKey(JNIEnv* env, |
|
187 jclass this_class, jlong hKey) { |
|
188 int subKeysNumber; |
|
189 int maxSubKeyLength; |
|
190 int valuesNumber; |
|
191 int maxValueNameLength; |
|
192 int errorCode = RegQueryInfoKey((HKEY) hKey, NULL, NULL, NULL, |
|
193 &subKeysNumber, &maxSubKeyLength, NULL, |
|
194 &valuesNumber, &maxValueNameLength, |
|
195 NULL, NULL, NULL); |
|
196 |
|
197 jlong tmp[5]; |
|
198 tmp[0] = subKeysNumber; |
|
199 tmp[1] = errorCode; |
|
200 tmp[2] = valuesNumber; |
|
201 tmp[3] = maxSubKeyLength; |
|
202 tmp[4] = maxValueNameLength; |
|
203 jintArray result = (*env)->NewLongArray(env, 5); |
|
204 if (result != NULL) { |
|
205 (*env)->SetLongArrayRegion(env, result, 0, 5, tmp); |
|
206 } |
|
207 return result; |
|
208 } |
|
209 |
|
210 JNIEXPORT jbyteArray JNICALL |
|
211 Java_java_util_prefs_WindowsPreferences_WindowsRegEnumKeyEx(JNIEnv* env, |
|
212 jclass this_class, jlong hKey, jint subKeyIndex, jint maxKeyLength) { |
|
213 int size = maxKeyLength; |
|
214 char* buffer = (char*) malloc(maxKeyLength); |
|
215 if (buffer == NULL) { |
|
216 JNU_ThrowOutOfMemoryError(env, "native memory allocation failed"); |
|
217 return NULL; |
|
218 } |
|
219 if (RegEnumKeyEx((HKEY) hKey, subKeyIndex, buffer, &size, NULL, NULL, |
|
220 NULL, NULL) != ERROR_SUCCESS) { |
143 free(buffer); |
221 free(buffer); |
144 (*env)->ReleaseByteArrayElements(env, valueName, valueNameStr, 0); |
222 return NULL; |
145 return result; |
223 } |
146 } |
224 |
147 |
225 jbyteArray result = (*env)->NewByteArray(env, size + 1); |
148 |
226 if (result != NULL) { |
149 |
227 (*env)->SetByteArrayRegion(env, result, 0, size + 1, buffer); |
150 |
228 } |
151 JNIEXPORT jint JNICALL Java_java_util_prefs_WindowsPreferences_WindowsRegSetValueEx |
229 free(buffer); |
152 (JNIEnv* env, jclass this_class, jint hKey, jbyteArray valueName, jbyteArray data) { |
230 return result; |
153 char* valueNameStr; |
231 } |
154 char* dataStr; |
232 |
155 int size = -1; |
233 JNIEXPORT jbyteArray JNICALL |
156 int nameSize = -1; |
234 Java_java_util_prefs_WindowsPreferences_WindowsRegEnumValue(JNIEnv* env, |
157 int error_code = -1; |
235 jclass this_class, jlong hKey, jint valueIndex, jint maxValueNameLength) { |
158 if ((valueName == NULL)||(data == NULL)) {return -1;} |
236 int size = maxValueNameLength; |
159 size = (*env)->GetArrayLength(env, data); |
237 char* buffer = (char*) malloc(maxValueNameLength); |
160 dataStr = (*env)->GetByteArrayElements(env, data, NULL); |
238 if (buffer == NULL) { |
161 CHECK_NULL_RETURN(dataStr, -1); |
239 JNU_ThrowOutOfMemoryError(env, "native memory allocation failed"); |
162 valueNameStr = (*env)->GetByteArrayElements(env, valueName, NULL); |
240 return NULL; |
163 if (valueNameStr != NULL) { |
241 } |
164 error_code = RegSetValueEx((HKEY)hKey, valueNameStr, 0, |
242 |
165 REG_SZ, dataStr, size); |
243 int error_code = RegEnumValue((HKEY) hKey, valueIndex, buffer, |
166 (*env)->ReleaseByteArrayElements(env, valueName, valueNameStr, 0); |
244 &size, NULL, NULL, NULL, NULL); |
167 } |
245 if (error_code != ERROR_SUCCESS) { |
168 (*env)->ReleaseByteArrayElements(env, data, dataStr, 0); |
|
169 return error_code; |
|
170 } |
|
171 |
|
172 JNIEXPORT jint JNICALL Java_java_util_prefs_WindowsPreferences_WindowsRegDeleteValue |
|
173 (JNIEnv* env, jclass this_class, jint hKey, jbyteArray valueName) { |
|
174 char* valueNameStr; |
|
175 int error_code = -1; |
|
176 if (valueName == NULL) {return -1;} |
|
177 valueNameStr = (*env)->GetByteArrayElements(env, valueName, NULL); |
|
178 CHECK_NULL_RETURN(valueNameStr, -1); |
|
179 error_code = RegDeleteValue((HKEY)hKey, valueNameStr); |
|
180 (*env)->ReleaseByteArrayElements(env, valueName, valueNameStr, 0); |
|
181 return error_code; |
|
182 } |
|
183 |
|
184 JNIEXPORT jintArray JNICALL Java_java_util_prefs_WindowsPreferences_WindowsRegQueryInfoKey |
|
185 (JNIEnv* env, jclass this_class, jint hKey) { |
|
186 jintArray result = NULL; |
|
187 int tmp[5]; |
|
188 int valuesNumber = -1; |
|
189 int maxValueNameLength = -1; |
|
190 int maxSubKeyLength = -1; |
|
191 int subKeysNumber = -1; |
|
192 int errorCode = -1; |
|
193 errorCode = RegQueryInfoKey((HKEY)hKey, NULL, NULL, NULL, |
|
194 &subKeysNumber, &maxSubKeyLength, NULL, |
|
195 &valuesNumber, &maxValueNameLength, |
|
196 NULL, NULL, NULL); |
|
197 tmp[0]= subKeysNumber; |
|
198 tmp[1]= (int)errorCode; |
|
199 tmp[2]= valuesNumber; |
|
200 tmp[3]= maxSubKeyLength; |
|
201 tmp[4]= maxValueNameLength; |
|
202 result = (*env)->NewIntArray(env,5); |
|
203 if (result != NULL) { |
|
204 (*env)->SetIntArrayRegion(env, result, 0, 5, tmp); |
|
205 } |
|
206 return result; |
|
207 } |
|
208 |
|
209 JNIEXPORT jbyteArray JNICALL Java_java_util_prefs_WindowsPreferences_WindowsRegEnumKeyEx |
|
210 (JNIEnv* env, jclass this_class, jint hKey , jint subKeyIndex, jint maxKeyLength) { |
|
211 int size = maxKeyLength; |
|
212 jbyteArray result; |
|
213 char* buffer = NULL; |
|
214 buffer = (char*)malloc(maxKeyLength); |
|
215 if (buffer == NULL) { |
|
216 JNU_ThrowOutOfMemoryError(env, "native memory allocation failed"); |
|
217 return NULL; |
|
218 } |
|
219 if (RegEnumKeyEx((HKEY) hKey, subKeyIndex, buffer, &size, NULL, NULL, |
|
220 NULL, NULL) != ERROR_SUCCESS){ |
|
221 free(buffer); |
246 free(buffer); |
222 return NULL; |
247 return NULL; |
223 } |
248 } |
224 result = (*env)->NewByteArray(env, size + 1); |
249 jbyteArray result = (*env)->NewByteArray(env, size + 1); |
225 if (result != NULL) { |
250 if (result != NULL) { |
226 (*env)->SetByteArrayRegion(env, result, 0, size + 1, buffer); |
251 (*env)->SetByteArrayRegion(env, result, 0, size + 1, buffer); |
227 } |
252 } |
228 free(buffer); |
253 free(buffer); |
229 return result; |
254 return result; |
230 } |
255 } |
231 |
|
232 JNIEXPORT jbyteArray JNICALL Java_java_util_prefs_WindowsPreferences_WindowsRegEnumValue |
|
233 (JNIEnv* env, jclass this_class, jint hKey , jint valueIndex, jint maxValueNameLength){ |
|
234 int size = maxValueNameLength; |
|
235 jbyteArray result; |
|
236 char* buffer = NULL; |
|
237 int error_code; |
|
238 buffer = (char*)malloc(maxValueNameLength); |
|
239 if (buffer == NULL) { |
|
240 JNU_ThrowOutOfMemoryError(env, "native memory allocation failed"); |
|
241 return NULL; |
|
242 } |
|
243 error_code = RegEnumValue((HKEY) hKey, valueIndex, buffer, |
|
244 &size, NULL, NULL, NULL, NULL); |
|
245 if (error_code!= ERROR_SUCCESS){ |
|
246 free(buffer); |
|
247 return NULL; |
|
248 } |
|
249 result = (*env)->NewByteArray(env, size + 1); |
|
250 if (result != NULL) { |
|
251 (*env)->SetByteArrayRegion(env, result, 0, size + 1, buffer); |
|
252 } |
|
253 free(buffer); |
|
254 return result; |
|
255 } |
|
256 |
256 |
257 |
257 |
258 #ifdef __cplusplus |
258 #ifdef __cplusplus |
259 } |
259 } |
260 #endif |
260 #endif |