Line data Source code
1 : /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
2 : /*
3 : * This file is part of the LibreOffice project.
4 : *
5 : * This Source Code Form is subject to the terms of the Mozilla Public
6 : * License, v. 2.0. If a copy of the MPL was not distributed with this
7 : * file, You can obtain one at http://mozilla.org/MPL/2.0/.
8 : *
9 : * This file incorporates work covered by the following license notice:
10 : *
11 : * Licensed to the Apache Software Foundation (ASF) under one or more
12 : * contributor license agreements. See the NOTICE file distributed
13 : * with this work for additional information regarding copyright
14 : * ownership. The ASF licenses this file to you under the Apache
15 : * License, Version 2.0 (the "License"); you may not use this file
16 : * except in compliance with the License. You may obtain a copy of
17 : * the License at http://www.apache.org/licenses/LICENSE-2.0 .
18 : */
19 :
20 :
21 : #include "registry/registry.hxx"
22 : #include "registry/reflread.hxx"
23 : #include "fileurl.hxx"
24 : #include "options.hxx"
25 :
26 : #include "rtl/ustring.hxx"
27 : #include "osl/diagnose.h"
28 :
29 : #include <stdio.h>
30 : #include <string.h>
31 :
32 : #include <vector>
33 : #include <string>
34 :
35 : using namespace rtl;
36 : using namespace registry::tools;
37 :
38 : #define U2S( s ) \
39 : OUStringToOString(s, RTL_TEXTENCODING_UTF8).getStr()
40 : #define S2U( s ) \
41 : OStringToOUString(s, RTL_TEXTENCODING_UTF8)
42 :
43 0 : class Options_Impl : public Options
44 : {
45 : public:
46 0 : explicit Options_Impl(char const * program)
47 0 : : Options (program), m_bForceOutput(false)
48 0 : {}
49 :
50 0 : std::string const & getIndexReg() const
51 0 : { return m_indexRegName; }
52 0 : std::string const & getTypeReg() const
53 0 : { return m_typeRegName; }
54 0 : bool hasBase() const
55 0 : { return (!m_base.isEmpty()); }
56 0 : const OString & getBase() const
57 0 : { return m_base; }
58 0 : bool forceOutput() const
59 0 : { return m_bForceOutput; }
60 :
61 : protected:
62 : virtual void printUsage_Impl() const;
63 : virtual bool initOptions_Impl (std::vector< std::string > & rArgs);
64 :
65 : std::string m_indexRegName;
66 : std::string m_typeRegName;
67 : OString m_base;
68 : bool m_bForceOutput;
69 : };
70 :
71 : // virtual
72 0 : void Options_Impl::printUsage_Impl() const
73 : {
74 0 : std::string const & rProgName = getProgramName();
75 : fprintf(stderr,
76 : "Usage: %s -r<filename> -o<filename> [-options] | @<filename>\n", rProgName.c_str()
77 0 : );
78 : fprintf(stderr,
79 : " -o<filename> = filename specifies the name of the new singleton index registry.\n"
80 : " -r<filename> = filename specifies the name of the type registry.\n"
81 : " @<filename> = filename specifies a command file.\n"
82 : "Options:\n"
83 : " -b<name> = name specifies the name of a start key. The types will be searched\n"
84 : " under this key in the type registry.\n"
85 : " -f = force the output of all found singletons.\n"
86 : " -h|-? = print this help message and exit.\n"
87 0 : );
88 : fprintf(stderr,
89 : "\n%s Version 1.0\n\n", rProgName.c_str()
90 0 : );
91 0 : }
92 :
93 : // virtual
94 0 : bool Options_Impl::initOptions_Impl(std::vector< std::string > & rArgs)
95 : {
96 0 : std::vector< std::string >::const_iterator first = rArgs.begin(), last = rArgs.end();
97 0 : for (; first != last; ++first)
98 : {
99 0 : std::string option (*first);
100 0 : if ((*first)[0] != '-')
101 : {
102 0 : return badOption("invalid", option.c_str());
103 : }
104 0 : switch ((*first)[1])
105 : {
106 : case 'r':
107 : case 'R':
108 : {
109 0 : if (!((++first != last) && ((*first)[0] != '-')))
110 : {
111 0 : return badOption("invalid", option.c_str());
112 : }
113 0 : m_typeRegName = *first;
114 0 : break;
115 : }
116 : case 'o':
117 : case 'O':
118 : {
119 0 : if (!((++first != last) && ((*first)[0] != '-')))
120 : {
121 0 : return badOption("invalid", option.c_str());
122 : }
123 0 : m_indexRegName = (*first);
124 0 : break;
125 : }
126 : case 'b':
127 : case 'B':
128 : {
129 0 : if (!((++first != last) && ((*first)[0] != '-')))
130 : {
131 0 : return badOption("invalid", option.c_str());
132 : }
133 0 : m_base = OString((*first).c_str(), (*first).size());
134 0 : break;
135 : }
136 : case 'f':
137 : case 'F':
138 : {
139 0 : if ((*first).size() > 2)
140 : {
141 0 : return badOption("invalid", option.c_str());
142 : }
143 0 : m_bForceOutput = sal_True;
144 0 : break;
145 : }
146 : case 'h':
147 : case '?':
148 : {
149 0 : if ((*first).size() > 2)
150 : {
151 0 : return badOption("invalid", option.c_str());
152 : }
153 0 : return printUsage();
154 : // break; // unreachable
155 : }
156 : default:
157 0 : return badOption("unknown", option.c_str());
158 : // break; // unreachable
159 : }
160 0 : }
161 0 : return true;
162 : }
163 :
164 0 : static sal_Bool checkSingletons(Options_Impl const & options, RegistryKey& singletonKey, RegistryKey& typeKey)
165 : {
166 0 : RegValueType valueType = RG_VALUETYPE_NOT_DEFINED;
167 0 : sal_uInt32 size = 0;
168 0 : OUString tmpName;
169 0 : sal_Bool bRet = sal_False;
170 :
171 0 : RegError e = typeKey.getValueInfo(tmpName, &valueType, &size);
172 0 : if ((e != REG_VALUE_NOT_EXISTS) && (e != REG_INVALID_VALUE) && (valueType == RG_VALUETYPE_BINARY))
173 : {
174 0 : std::vector< sal_uInt8 > value(size);
175 0 : typeKey.getValue(tmpName, &value[0]); // @@@ broken api: write to buffer w/o buffer size.
176 :
177 0 : RegistryTypeReader reader(&value[0], value.size(), sal_False);
178 0 : if ( reader.isValid() && reader.getTypeClass() == RT_TYPE_SINGLETON )
179 : {
180 0 : RegistryKey entryKey;
181 0 : OUString singletonName = reader.getTypeName().replace('/', '.');
182 0 : if ( singletonKey.createKey(singletonName, entryKey) )
183 : {
184 : fprintf(stderr, "%s: could not create SINGLETONS entry for \"%s\"\n",
185 0 : options.getProgramName().c_str(), U2S( singletonName ));
186 : }
187 : else
188 : {
189 0 : bRet = sal_True;
190 0 : OUString value2 = reader.getSuperTypeName();
191 :
192 0 : if ( entryKey.setValue(tmpName, RG_VALUETYPE_UNICODE,
193 0 : (RegValue)value2.getStr(), sizeof(sal_Unicode)* (value2.getLength()+1)) )
194 : {
195 : fprintf(stderr, "%s: could not create data entry for singleton \"%s\"\n",
196 0 : options.getProgramName().c_str(), U2S( singletonName ));
197 : }
198 :
199 0 : if ( options.forceOutput() )
200 : {
201 : fprintf(stderr, "%s: create SINGLETON entry for \"%s\" -> \"%s\"\n",
202 0 : options.getProgramName().c_str(), U2S( singletonName ), U2S(value2));
203 0 : }
204 0 : }
205 0 : }
206 : }
207 :
208 0 : RegistryKeyArray subKeys;
209 0 : typeKey.openSubKeys(tmpName, subKeys);
210 :
211 0 : sal_uInt32 length = subKeys.getLength();
212 0 : for (sal_uInt32 i = 0; i < length; i++)
213 : {
214 0 : RegistryKey elementKey = subKeys.getElement(i);
215 0 : if ( checkSingletons(options, singletonKey, elementKey) )
216 : {
217 0 : bRet = sal_True;
218 : }
219 0 : }
220 0 : return bRet;
221 : }
222 :
223 : #if (defined UNX) || (defined __MINGW32__)
224 0 : int main( int argc, char * argv[] )
225 : #else
226 : int _cdecl main( int argc, char * argv[] )
227 : #endif
228 : {
229 0 : std::vector< std::string > args;
230 0 : for (int i = 1; i < argc; i++)
231 : {
232 0 : int result = Options::checkArgument(args, argv[i], strlen(argv[i]));
233 0 : if (result != 0)
234 : {
235 : // failure.
236 0 : return (result);
237 : }
238 : }
239 :
240 0 : Options_Impl options(argv[0]);
241 0 : if (!options.initOptions(args))
242 : {
243 0 : options.printUsage();
244 0 : return (1);
245 : }
246 :
247 0 : OUString indexRegName( convertToFileUrl(options.getIndexReg().c_str(), options.getIndexReg().size()) );
248 0 : Registry indexReg;
249 0 : if ( indexReg.open(indexRegName, REG_READWRITE) )
250 : {
251 0 : if ( indexReg.create(indexRegName) )
252 : {
253 : fprintf(stderr, "%s: open registry \"%s\" failed\n",
254 0 : options.getProgramName().c_str(), options.getIndexReg().c_str());
255 0 : return (2);
256 : }
257 : }
258 :
259 0 : OUString typeRegName( convertToFileUrl(options.getTypeReg().c_str(), options.getTypeReg().size()) );
260 0 : Registry typeReg;
261 0 : if ( typeReg.open(typeRegName, REG_READONLY) )
262 : {
263 : fprintf(stderr, "%s: open registry \"%s\" failed\n",
264 0 : options.getProgramName().c_str(), options.getTypeReg().c_str());
265 0 : return (3);
266 : }
267 :
268 0 : RegistryKey indexRoot;
269 0 : if ( indexReg.openRootKey(indexRoot) )
270 : {
271 : fprintf(stderr, "%s: open root key of registry \"%s\" failed\n",
272 0 : options.getProgramName().c_str(), options.getIndexReg().c_str());
273 0 : return (4);
274 : }
275 :
276 0 : RegistryKey typeRoot;
277 0 : if ( typeReg.openRootKey(typeRoot) )
278 : {
279 : fprintf(stderr, "%s: open root key of registry \"%s\" failed\n",
280 0 : options.getProgramName().c_str(), options.getTypeReg().c_str());
281 0 : return (5);
282 : }
283 :
284 0 : RegistryKey typeKey;
285 0 : if ( options.hasBase() )
286 : {
287 0 : if ( typeRoot.openKey(S2U(options.getBase()), typeKey) )
288 : {
289 : fprintf(stderr, "%s: open base key of registry \"%s\" failed\n",
290 0 : options.getProgramName().c_str(), options.getTypeReg().c_str());
291 0 : return (6);
292 : }
293 : }
294 : else
295 : {
296 0 : typeKey = typeRoot;
297 : }
298 :
299 0 : RegistryKey singletonKey;
300 0 : if ( indexRoot.createKey(OUString("SINGLETONS"), singletonKey) )
301 : {
302 : fprintf(stderr, "%s: open/create SINGLETONS key of registry \"%s\" failed\n",
303 0 : options.getProgramName().c_str(), options.getIndexReg().c_str());
304 0 : return (7);
305 : }
306 :
307 0 : sal_Bool bSingletonsExist = checkSingletons(options, singletonKey, typeKey);
308 :
309 0 : indexRoot.releaseKey();
310 0 : typeRoot.releaseKey();
311 0 : typeKey.releaseKey();
312 0 : singletonKey.releaseKey();
313 0 : if ( indexReg.close() )
314 : {
315 : fprintf(stderr, "%s: closing registry \"%s\" failed\n",
316 0 : options.getProgramName().c_str(), options.getIndexReg().c_str());
317 0 : return (9);
318 : }
319 0 : if ( !bSingletonsExist )
320 : {
321 0 : if ( indexReg.destroy(OUString()) )
322 : {
323 : fprintf(stderr, "%s: destroy registry \"%s\" failed\n",
324 0 : options.getProgramName().c_str(), options.getIndexReg().c_str());
325 0 : return (10);
326 : }
327 : }
328 0 : if ( typeReg.close() )
329 : {
330 : fprintf(stderr, "%s: closing registry \"%s\" failed\n",
331 0 : options.getProgramName().c_str(), options.getTypeReg().c_str());
332 0 : return (11);
333 0 : }
334 0 : }
335 :
336 : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
