HSAdmin Backend Domains, E-Mail, Datenbanken
Purodha
2013-02-20 4a7e12928010374d76e677c8ec3ea4f5e63e9487
commit | author | age
c64ab5 1 /***************************************************************************
CD 2  *   Copyright (C) 2005 by Christof Donat   *
3  *   cdonat@gmx.de   *
4  *                                                                         *
5  *   This program is free software; you can redistribute it and/or modify  *
6  *   it under the terms of the GNU General Public License as published by  *
7  *   the Free Software Foundation; either version 2 of the License, or     *
8  *   (at your option) any later version.                                   *
9  *                                                                         *
10  *   This program is distributed in the hope that it will be useful,       *
11  *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
12  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
13  *   GNU General Public License for more details.                          *
14  *                                                                         *
15  *   You should have received a copy of the GNU General Public License     *
16  *   along with this program; if not, write to the                         *
17  *   Free Software Foundation, Inc.,                                       *
18  *   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.             *
19  ***************************************************************************/
20
21 #include <boost/regex.hpp>
22 #include <boost/lexical_cast.hpp>
23 #include <boost/algorithm/string.hpp>
24 #include <boost/format.hpp>
25
26 #include <iostream>
27 #include <sstream>
28 #include <fstream>
29
30 #include "cmdlineparser.h"
31 #include "logger.h"
32
33 #include <termios.h>
34 #include <unistd.h>
35
36 namespace commandline {
37
38 using std::cout;
39 using std::cin;
40 using std::flush;
41 using std::ifstream;
42 using std::ostringstream;
43
44 using boost::lexical_cast;
45 using boost::bad_lexical_cast;
46 using boost::shared_ptr;
47 using boost::scoped_ptr;
48 using boost::starts_with;
49 using boost::erase_first;
50
51 // dynamic cast needs this
52
53 vector<string> callParameter::parseDisplayspec() {
54     vector<string> rval;
55     boost::regex pattern("\\$\\{([^\\}]*)\\}");
56     boost::sregex_iterator end;
57
58     for(boost::sregex_iterator i(this->m_display.begin(),this->m_display.end(),pattern); i != end; i++ )
59         rval.insert(rval.end(),(*i)[1]);
60
61     Logger::log(Logger::DEBUG,"have parsed displayspec Parameter '"+this->m_display+"'");
62
63     return rval;
64 }
65 string callParameter::evalDisplay(const map<string, string> &values) {
66     string rval = this->m_display;
67     string::size_type pos;
68
69     for( map<string,string>::const_iterator i = values.begin(); i != values.end(); i++ ) {
70         string pattstring = "${"+i->first+"}";
71         while( (pos = rval.find(pattstring,0)) != string::npos ) rval.replace(pos,pattstring.length(),i->second);
72     }
73
74     while( (pos = rval.find("\\n",0)) != string::npos ) rval.replace(pos,2,"\n");
75     while( (pos = rval.find("\\t",0)) != string::npos ) rval.replace(pos,2,"\t");
76     while( (pos = rval.find("\\r",0)) != string::npos ) rval.replace(pos,2,"\r");
77
78     Logger::log(Logger::DEBUG,"have evaluated displayspec Parameter '"+this->m_display+"': '"+rval+"'");
79
80     return rval;
81 }
82
83 string setParameter::toXML(string &username, shared_ptr< ::ConfigFileParser > cfgfile) {
84     string rpccall = "<struct>";
85     rpccall += "<member><name>property</name><value>"+m_property+"</value></member>";
86     rpccall += "<member><name>value</name><value>"+m_value+"</value></member>";
87     rpccall += "</struct>";
88     return rpccall;
89 }
90 string whereParameter::toXML(string &username, shared_ptr< ::ConfigFileParser > cfgfile) {
91     string rpccall = "<struct>";
92     rpccall += "<member><name>property</name><value>"+m_property+"</value></member>";
93     rpccall += "<member><name>value</name><value>"+m_pattern+"</value></member>";
94     rpccall += "</struct>";
95     return rpccall;
96 }
97 string orderParameter::toXML(string &username, shared_ptr< ::ConfigFileParser > cfgfile) {
98     string rpccall = "<struct>";
99     rpccall += "<member><name>property</name><value>"+m_property+"</value></member>";
100     rpccall += "<member><name>ascending</name><value><boolean>";
101     rpccall += string((m_ascending?"1":"0"))+"</boolean></value></member>";
102     rpccall += "</struct>";
103     return rpccall;
104 }
105 string callParameter::toXML(string &username, shared_ptr< ::ConfigFileParser > cfgfile) {
106     string rpccall = "<struct>";
107     rpccall += "<member>";
108     rpccall += "<name>module</name>";
109     rpccall += "<value>"+m_module+"</value>";
110     rpccall += "</member>";
111     rpccall += "<member>";
112     rpccall += "<name>function</name>";
113     rpccall += "<value>"+m_function+"</value>";
114     rpccall += "</member>";
115
116     if( m_force ) {
117         rpccall += "<member>";
118         rpccall += "<name>force</name>";
119         rpccall += "<value><boolean>1</boolean></value>";
120         rpccall += "</member>";
121     }
122     if( m_ignoreerror ) {
123         rpccall += "<member>";
124         rpccall += "<name>ignoreerror</name>";
125         rpccall += "<value><boolean>1</boolean></value>";
126         rpccall += "</member>";
127     }
128
129     // read
130     vector<string> reads = parseDisplayspec();
131
132     if(reads.size()) {
133         rpccall += "<member>";
134         rpccall += "<name>read</name>";
135         rpccall += "<value><array><data>";
136         for(vector<string>::iterator j = reads.begin(); j != reads.end(); j++ )
137             rpccall += "<value>"+(*j)+"</value>";
138         rpccall += "</data></array></value>";
139         rpccall += "</member>";
140     }
141
142     if( m_where.size() ) {
143         rpccall += "<member>";
144         rpccall += "<name>where</name>";
145         rpccall += "<value><array><data>";
146         for(vector<shared_ptr<whereParameter> >::iterator j = m_where.begin(); j != m_where.end(); j++ )
147             rpccall += "<value>"+((*j)->toXML(username,cfgfile))+"</value>";
148         rpccall += "</data></array></value>";
149         rpccall += "</member>";
150     }
151
152     if( m_set.size() ) {
153         rpccall += "<member>";
154         rpccall += "<name>set</name>";
155         rpccall += "<value><array><data>";
156         for(vector<shared_ptr<setParameter> >::iterator j = m_set.begin(); j != m_set.end(); j++ )
157             rpccall += "<value>"+((*j)->toXML(username,cfgfile))+"</value>";
158         rpccall += "</data></array></value>";
159         rpccall += "</member>";
160     }
161
162     if( m_order.size() ) {
163         rpccall += "<member>";
164         rpccall += "<name>order</name>";
165         rpccall += "<value><array><data>";
166         for(vector<shared_ptr<orderParameter> >::iterator j = m_order.begin(); j != m_order.end(); j++ )
167             rpccall += "<value>"+((*j)->toXML(username,cfgfile))+"</value>";
168         rpccall += "</data></array></value>";
169         rpccall += "</member>";
170     }
171
172     if( m_objects.size() ) {
173         rpccall += "<member>";
174         rpccall += "<name>objectid</name>";
175         rpccall += "<value><array><data>";
176         for(vector<string>::iterator j = m_objects.begin(); j != m_objects.end(); j++ )
177             rpccall += "<value>"+(*j)+"</value>";
178         rpccall += "</data></array></value>";
179         rpccall += "</member>";
180     }
181
182     if( m_unset.size() ) {
183         rpccall += "<member>";
184         rpccall += "<name>unset</name>";
185         rpccall += "<value><array><data>";
186         for(vector<string>::iterator j = m_unset.begin(); j != m_unset.end(); j++ )
187             rpccall += "<value><struct><member><name>property</name><value>"+(*j)+"</value></member></struct></value>";
188         rpccall += "</data></array></value>";
189         rpccall += "</member>";
190     }
191     
192     rpccall += "</struct>";
193
194     return rpccall;
195 }
196
197 parsedParameters::parsedParameters(): 
198     m_error(NOERROR), 
199     m_user(""), 
200     m_ticket(""), 
201     m_defaultDisplay(""), 
202     m_addConfigFile(""), 
203     m_test(false), 
204     m_ignoreerrors(false) {}
205
206 string parsedParameters::toXML(string &username, shared_ptr< ::ConfigFileParser > cfgfile) {
207     // begin method call
208     string rpccall = "<?xml version=\"1.0\"?><methodCall><methodName>hsadmin.transaction</methodName><params>";
209     
210     // ticket
211     rpccall += "<param><value><string>";
212     if( this->m_ticket != "" ) {
213         string ticket;
214         ifstream file(this->m_ticket.c_str());
215         if( ! file ) {
216             string msg = Logger::getMessageFormatString(Logger::CouldNotOpenFile);
217             boost::format fmt(msg);
218             fmt % this->m_ticket;
219             Logger::log(Logger::FATAL,fmt.str());
220             exit(-1);
221         }
222         
223         char ch;
224         while(file.get(ch)) ticket += ch;
225
226         boost::regex findticket(".*\\n---\\n");
227
228         ticket = boost::regex_replace(ticket,findticket,"");
229         if( ticket[ticket.size()-1] == '\0' ) ticket = ticket.substr(0,ticket.size()-2);
230
231         rpccall += ticket;
232     } else {
233         rpccall += cfgfile->getTicket(username);
234     }
235     Logger::log(Logger::DEBUG,"have read ticket");
236     rpccall += "</string></value></param>";
237
238     // global Parameters
239     rpccall += "<param><value><struct>";
240     if( this->m_test )
241         rpccall += "<member><name>test</name><value><boolean>1</boolean></value></member>";
242     rpccall += "</struct></value></param>";
243         
244     // calls Array
245     rpccall += "<param><value><array><data>";
246     for( vector<shared_ptr<callParameter> >::iterator c = m_call.begin(); c != m_call.end(); c++ )
247         rpccall += "<value>"+((*c)->toXML(username,cfgfile))+"</value>";
248
249     rpccall += "</data></array></value></param>";
250
251     rpccall += "</params></methodCall>\n";
252
253     return rpccall;
254 }
255
256
257 // specific Parser for --runas-Option
258
259 bool VerbosityOption::parseThis(vector<string>& options, shared_ptr<parsedParameters> result) {
260     bool rval = false;
261     if( starts_with(options[0], "-v") ) {
262         if( options[1] == "none" || 
263             options[1] == "normal" || 
264             options[1] == "high" || 
265             options[1] == "debug" || 
266             options[1] == "debugXML" || 
267             options[1] == "debugAll" ) {
268             if( rval = this->handle(options[1], result) ) {
269                 if( options[0] == "-v" )
270                     options.erase(options.begin(),options.begin()+2);
271                 else {
272                     erase_first(options[0], "v");
273                     options.erase(options.begin()+1);
274                 }
275             }
276         } else {
277             string p;
278             if( rval = this->handle(p, result) ) {
279                 if( options[0] == "-v" )
280                     options.erase(options.begin());
281                 else 
282                     erase_first(options[0], "v");
283             }
284         }
285     }
286     if( starts_with(options[0], "--verbosity=") ) {
287         string p = options[0].substr(12);
288         if( rval = this->handle(p, result) )
289             options.erase(options.begin());
290     }
291     return rval;
292 }
293
294 // constuctors
295
296 TestOption::TestOption() {
297     m_longName = "test";
298     m_shortName = "t";
299 }
300
301 IgnoreErrorOption::IgnoreErrorOption() {
302     m_longName = "ignoreerror";
303     m_shortName = "e";
304 }
305
306 IgnoreErrorsOption::IgnoreErrorsOption() {
307     m_longName = "ignoreerrors";
308     m_shortName = "E";
309 }
310
311 VerbosityOption::VerbosityOption() {
312     m_longName = "verbosity";
313     m_shortName = "v";
314     m_parameterSeparator = "=";
315 }
316
317 RunAsOption::RunAsOption() {
318     m_longName = "runas";
319     m_shortName = "r";
320     m_parameterSeparator = "=";
321 }
322
323 TicketOption::TicketOption() {
324     m_longName = "ticket";
325     m_shortName = "T";
326     m_parameterSeparator = "=";
327 }
328
329 ConfigOption::ConfigOption() {
330     m_longName = "config";
331     m_shortName = "C";
332     m_parameterSeparator = "=";
333 }
334
335 ForceOption::ForceOption() {
336     m_longName = "force";
337 }
338
339 GlobalsOption::GlobalsOption() {
340     m_longName = "globals";
341     m_shortName = "l";
342 }
343
344 WhereOption::WhereOption() {
345     m_longName = "where";
346     m_shortName = "w";
347     m_parameterSeparator = ":";
348 }
349
350 OnlyOption::OnlyOption() {
351     m_longName = "only";
352     m_shortName = "W";
353     m_parameterSeparator = ":";
354 }
355
356 SetOption::SetOption() {
357     m_longName = "set";
358     m_shortName = "s";
359     m_parameterSeparator = ":";
360 }
361
362 SetAllOption::SetAllOption() {
363     m_longName = "setall";
364     m_shortName = "S";
365     m_parameterSeparator = ":";
366 }
367
368 InfileOption::InfileOption() {
369     m_longName = "infile";
370     m_shortName = "f";
371     m_parameterSeparator = ":";
372 }
373
374 OrderOption::OrderOption() {
375     m_longName = "order";
376     m_shortName = "o";
377     m_parameterSeparator = ":";
378 }
379
380 GlobalOrderOption::GlobalOrderOption() {
381     m_longName = "global-order";
382     m_shortName = "O";
383     m_parameterSeparator = ":";
384 }
385
386 InputOption::InputOption() {
387     m_longName = "input";
388     m_shortName = "i";
389     m_parameterSeparator = ":";
390 }
391
392 PassInputOption::PassInputOption() {
393     m_longName = "passinput";
394     m_shortName = "p";
395     m_parameterSeparator = ":";
396 }
397
398 DisplayOption::DisplayOption() {
399     m_longName = "display";
400     m_shortName = "d";
401     m_parameterSeparator = ":";
402 }
403
404 DefaultDisplayOption::DefaultDisplayOption() {
405     m_longName = "default-display";
406     m_shortName = "D";
407     m_parameterSeparator = ":";
408 }
409
410 CallOption::CallOption() {
411     m_longName = "call";
412     m_shortName = "c";
413     m_parameterSeparator = ":";
414 }
415
416 UnsetOption::UnsetOption() {
417     m_longName = "unset";
418     m_shortName = "u";
419     m_parameterSeparator = ":";
420 }
421
422 UnsetAllOption::UnsetAllOption() {
423     m_longName = "unsetall";
424     m_shortName = "U";
425     m_parameterSeparator = ":";
426 }
427
428 ObjectID::ObjectID() { };
429
430
431 // handle functions
432
433 bool TestOption::handle(shared_ptr<parsedParameters> result) {
434     result->m_test = true;
435     Logger::log(Logger::DEBUG," found test Option");
436     return true;
437 }
438
439 bool IgnoreErrorOption::handle(shared_ptr<parsedParameters> result) {
440     if( result->m_call.size() <= 0 ) {
441         result->m_error = NeedCall;
442         return false;
443     }
444     result->m_call.back()->m_ignoreerror = true;
445     Logger::log(Logger::DEBUG," found ignoreerror Option");
446     return true;
447 }
448
449 bool IgnoreErrorsOption::handle(shared_ptr<parsedParameters> result) {
450     result->m_ignoreerrors = true;
451     Logger::log(Logger::DEBUG," found ignoreerrors Option");
452     return true;
453 }
454
455 bool VerbosityOption::handle(string &parameter, shared_ptr<parsedParameters> result) {
456     if( parameter == "none" )         Logger::setLevel(0);
457     else if( parameter == "normal")   Logger::setLevel(1);
458     else if( parameter == "high")     Logger::setLevel(2);
459     else if( parameter == "debug")    Logger::setLevel(3);
460     else if( parameter == "debugXML") Logger::setLevel(4);
461     else if( parameter == "debugAll") Logger::setLevel(5);
462     else                              Logger::incrementLevel();
463
464     Logger::log(Logger::DEBUG," set Verbosity Level to "+lexical_cast<string>(Logger::level));
465
466     return true;
467 }
468
469 bool QuietOption::handle(string &parameter, shared_ptr<parsedParameters> result) {
470     Logger::decrementLevel();
471     Logger::log(Logger::DEBUG," set Verbosity Level to "+lexical_cast<string>(Logger::level));
472     return true;
473 }
474
475 bool RunAsOption::handle(string &parameter, shared_ptr<parsedParameters> result) {
476     result->m_user = parameter;
477     Logger::log(Logger::DEBUG," found runas Option: "+parameter);
478     return true;
479 }
480
481 bool TicketOption::handle(string &parameter, shared_ptr<parsedParameters> result) {
482     result->m_ticket = parameter;
483     Logger::log(Logger::DEBUG," found ticket Option: "+parameter);
484     return true;
485 }
486
487 bool ConfigOption::handle(string &parameter, shared_ptr<parsedParameters> result) {
488     result->m_addConfigFile = parameter;
489     Logger::log(Logger::DEBUG," found config Option: "+parameter);
490     return true;
491 }
492
493 bool ForceOption::handle(shared_ptr<parsedParameters> result) {
494     if( result->m_call.size() <= 0 ) {
495         result->m_error = NeedCall;
496         return false;
497     }
498     result->m_call.back()->m_force = true;
499     Logger::log(Logger::DEBUG," found force Option");
500     return true;
501 }
502
503 bool GlobalsOption::handle(shared_ptr<parsedParameters> result) {
504     if( result->m_call.size() <= 0 ) {
505         result->m_error = NeedCall;
506         return false;
507     }
508     result->m_call.back()->m_globalOrderIndex = result->m_call.back()->m_order.size();
509     Logger::log(Logger::DEBUG," found globals Option");
510     return true;
511 }
512
513 bool WhereOption::handle(string &parameter, shared_ptr<parsedParameters> result) {
514     if( result->m_call.size() <= 0 ) {
515         result->m_error = NeedCall;
516         return false;
517     }
518
519     string::size_type pos = parameter.find('=');
520     string property(parameter,0,pos);
521     string pattern(parameter,(pos != string::npos)?(pos+1):(string::npos));
522
523     whereParameter *where = new whereParameter();
524     where->m_property = property;
525     where->m_pattern  = pattern;
526
527     result->m_call.back()->m_where.push_back(shared_ptr<whereParameter>(where));
528
529     Logger::log(Logger::DEBUG," found where Option: "+parameter);
530     return true;
531 }
532
533 bool OnlyOption::handle(string &parameter, shared_ptr<parsedParameters> result) {
534     string::size_type pos = parameter.find('=');
535     string property(parameter,0,pos);
536     string pattern(parameter,(pos != string::npos)?(pos+1):(string::npos));
537
538     whereParameter *where = new whereParameter();
539     where->m_property = property;
540     where->m_pattern  = pattern;
541
542     result->m_only.push_back(shared_ptr<whereParameter>(where));
543
544     Logger::log(Logger::DEBUG," found only Option: "+parameter);
545     return true;
546 }
547
548 bool UnsetOption::handle(string &parameter, shared_ptr<parsedParameters> result) {
549     if( result->m_call.size() <= 0 ) {
550         result->m_error = NeedCall;
551         return false;
552     }
553
554     result->m_call.back()->m_unset.push_back(parameter);
555     Logger::log(Logger::DEBUG," found unset Option: "+parameter);
556     return true;
557 }
558
559 bool UnsetAllOption::handle(string &parameter, shared_ptr<parsedParameters> result) {
560     result->m_unsetall.push_back(parameter);
561     Logger::log(Logger::DEBUG," found unsetall Option: "+parameter);
562     return true;
563 }
564
565 bool OrderOption::handle(string &parameter, shared_ptr<parsedParameters> result) {
566     if( result->m_call.size() <= 0 ) {
567         result->m_error = NeedCall;
568         return false;
569     }
570
571     string::size_type pos = parameter.find('=');
572     string *property;
573     string * direction;
574     if( pos != string::npos ) {
575         property = new string(parameter,0,pos);
576         direction = new string(parameter,(pos != string::npos)?(pos+1):(string::npos));
577     } else {
578         property = new string(parameter);
579         direction = new string("a");
580     }
581
582     orderParameter *order = new orderParameter();
583     order->m_property = *property;
584     order->m_ascending  = ((*direction)[0] == 'a');
585
586     result->m_call.back()->m_order.push_back(shared_ptr<orderParameter>(order));
587
588     Logger::log(Logger::DEBUG," found order Option: "+parameter);
589     return true;
590 }
591
592 bool GlobalOrderOption::handle(string &parameter, shared_ptr<parsedParameters> result) {
593     string::size_type pos = parameter.find('=');
594     string *property;
595     string * direction;
596     if( pos != string::npos ) {
597         property = new string(parameter,0,pos);
598         direction = new string(parameter,(pos != string::npos)?(pos+1):(string::npos));
599     } else {
600         property = new string(parameter);
601         direction = new string("a");
602     }
603
604     orderParameter *order = new orderParameter();
605     order->m_property = *property;
606     order->m_ascending  = ((*direction)[0] == 'a');
607
608     result->m_globalOrder.push_back(shared_ptr<orderParameter>(order));
609
610     Logger::log(Logger::DEBUG," found global order Option: "+parameter);
611     return true;
612 }
613
614 bool SetOption::handle(string &parameter, shared_ptr<parsedParameters> result) {
615     if( result->m_call.size() <= 0 ) {
616         result->m_error = NeedCall;
617         return false;
618     }
619
620     string::size_type pos = parameter.find('=');
621     string property(parameter,0,pos);
622     string value(parameter,(pos != string::npos)?(pos+1):(string::npos));
623
624     setParameter *set = new setParameter();
625     set->m_property = property;
626     set->m_value  = value;
627
628     result->m_call.back()->m_set.push_back(shared_ptr<setParameter>(set));
629
630     Logger::log(Logger::DEBUG," found set Option: "+parameter);
631     return true;
632 }
633
634 bool SetAllOption::handle(string &parameter, shared_ptr<parsedParameters> result) {
635     string::size_type pos = parameter.find('=');
636     string property(parameter,0,pos);
637     string value(parameter,(pos != string::npos)?(pos+1):(string::npos));
638
639     setParameter *set = new setParameter();
640     set->m_property = property;
641     set->m_value  = value;
642
643     result->m_setall.push_back(shared_ptr<setParameter>(set));
644
645     Logger::log(Logger::DEBUG," found setall Option: "+parameter);
646     return true;
647 }
648
649 bool InfileOption::handle(string &parameter, shared_ptr<parsedParameters> result) {
650     if( result->m_call.size() <= 0 ) {
651         result->m_error = NeedCall;
652         return false;
653     }
654
655     string::size_type pos = parameter.find('=');
656     string property(parameter,0,pos);
657     string filename(parameter,(pos != string::npos)?(pos+1):(string::npos));
658
659     setParameter *set = new setParameter();
660     set->m_property = property;
661
662     ifstream file(filename.c_str());
663     if( ! file ) {
664         string msg = Logger::getMessageFormatString(Logger::CouldNotOpenFile);
665         boost::format fmt(msg);
666         fmt % filename;
667         Logger::log(Logger::FATAL,fmt.str());
668         exit(-1);
669     }
670     char ch;
671     while(file.get(ch)) set->m_value += ch;
672
673     result->m_call.back()->m_set.push_back(shared_ptr<setParameter>(set));
674
675     Logger::log(Logger::DEBUG," found infile Option: "+parameter);
676     return true;
677 }
678
679 bool InputOption::handle(string &parameter, shared_ptr<parsedParameters> result) {
680     if( result->m_call.size() <= 0 ) {
681         result->m_error = NeedCall;
682         return false;
683     }
684
685     setParameter *set = new setParameter();
686     set->m_property = parameter;
687     cout << "Eingabe (" << parameter << "): " << flush;
688     std::getline(cin, set->m_value);
689
690     result->m_call.back()->m_set.push_back(shared_ptr<setParameter>(set));
691
692     Logger::log(Logger::DEBUG," found input Option: "+parameter);
693     return true;
694 }
695
696 string readPasswd() {
697     string rval = "";
698     struct termios t, t2;
699
700     tcgetattr(0,&t);
701     t2 = t;
702     t2.c_lflag &= ~ECHO;
703     tcsetattr(0,TCSANOW,&t2);
704     std::getline(cin, rval);
705     tcsetattr(0,TCSANOW,&t);
706
707     return rval;
708 }
709
710 bool PassInputOption::handle(string &parameter, shared_ptr<parsedParameters> result) {
711     if( result->m_call.size() <= 0 ) {
712         result->m_error = NeedCall;
713         return false;
714     }
715
716     setParameter *set = new setParameter();
717     set->m_property = parameter;
718     cout << "Passworteingabe (" << parameter << "): " << flush;
719     set->m_value = readPasswd();
720
721     result->m_call.back()->m_set.push_back(shared_ptr<setParameter>(set));
722
723     Logger::log(Logger::DEBUG," found password-input Option: "+parameter);
724     return true;
725 }
726
727 bool DisplayOption::handle(string &parameter, shared_ptr<parsedParameters> result) {
728     if( result->m_call.size() <= 0 ) {
729         result->m_error = NeedCall;
730         return false;
731     }
732
733     result->m_call.back()->m_display = parameter;
734
735     Logger::log(Logger::DEBUG," found display Option: "+parameter);
736     return true;
737 }
738
739 bool DefaultDisplayOption::handle(string &parameter, shared_ptr<parsedParameters> result) {
740     result->m_defaultDisplay = parameter;
741
742     Logger::log(Logger::DEBUG," found default display Option: "+parameter);
743     return true;
744 }
745
746 bool ObjectID::handle(string &parameter, shared_ptr<parsedParameters> result) {
747     if( result->m_call.size() <= 0 ) {
748         result->m_error = NeedCall;
749         return false;
750     }
751
752     result->m_call.back()->m_objects.push_back(parameter);
753     Logger::log(Logger::DEBUG," found an ObjectID: "+parameter);
754     return true;
755 }
756
757 bool CallOption::handle(string &parameter, shared_ptr<parsedParameters> result) {
758     string::size_type pos = parameter.find('.');
759     string module(parameter,0,pos);
760     string function(parameter,(pos != string::npos)?(pos+1):(string::npos));
761
762     callParameter *call = new callParameter();
763     call->m_module   = module;
764     call->m_function = function;
765
766     result->m_call.push_back(shared_ptr<callParameter>(call));
767
768     Logger::log(Logger::DEBUG," found call Option: "+parameter);
769     return true;
770 }
771
772 };